acc

Comprehensive architecture audit with pattern recommendations. Detects DDD, CQRS, Clean/Hexagonal/Layered Architecture, Event Sourcing, EDA, Outbox, Saga, Stability, GoF Structural (Adapter, Facade, Proxy, Composite, Bridge, Flyweight), and Behavioral (Strategy, State, Chain, Decorator, Null Object, Template Method, Visitor, Iterator, Memento) patterns. Provides actionable recommendations with links to generation skills.

Perform a comprehensive audit of CI/CD configuration, including security, performance, and best practices.

Perform a comprehensive audit of the `.claude/` folder in the current project.

DDD architecture audit with pattern recommendations. Analyzes layer separation, domain model richness, and architectural violations. Provides actionable recommendations with links to generation skills.

Perform a comprehensive audit of Docker configuration, including architecture, security, performance, and production readiness.

Audit documentation quality. Checks completeness, accuracy, clarity, navigation, and diagrams. Use for documentation review and improvement planning.

Design patterns audit. Analyzes stability (Circuit Breaker, Retry, Rate Limiter, Bulkhead), behavioral (Strategy, State, Chain, Decorator, Null Object, Template Method, Visitor, Iterator, Memento), GoF structural (Adapter, Facade, Proxy, Composite, Bridge, Flyweight), creational (Builder, Factory, Pool), integration (Outbox, Saga, ADR), and SOLID/GRASP compliance.

Performance audit. Detects N+1 queries, memory issues, caching gaps, inefficient loops, batch processing problems, algorithm complexity, connection pools, serialization overhead.

Audit PSR compliance. Checks PSR-1/PSR-12 coding style, PSR-4 autoloading, and PSR interface implementations. Use for PHP standards compliance review.

Security audit (OWASP Top 10, PHP-specific vulnerabilities). Analyzes input validation, injection, authentication, authorization, CSRF, XSS, XXE, SSRF, deserialization, path traversal.

Audit test quality. Checks coverage gaps, test smells, naming, isolation. Recommends improvements and can generate fixes.

Fix bug based on description, stack trace, or file reference

Fix CI pipeline issues with interactive approval

Improve CI/CD pipeline performance by analyzing and optimizing caching, parallelization, and job structure.

Setup CI pipeline from scratch. Creates GitHub Actions or GitLab CI configuration with lint, test, build, and deploy stages.

Perform comprehensive code review on branch changes with configurable depth levels.

You are a git commit specialist that creates meaningful commit messages.

Explain code — structure, business logic, data flows, architecture. Accepts file/dir, HTTP route (GET /api/orders), or console command (app:process-payments). Modes: quick, deep, onboarding, business, qa.

You are a master of creating Claude Code components.

Generate DDD components. Creates entities, value objects, aggregates, commands, queries, repositories, domain services, factories, specifications, DTOs, ACL, event stores, snapshots, and use cases for PHP 8.4.

Generate Docker components. Creates Dockerfiles, Compose configs, Nginx, entrypoint, Makefile, and environment templates for PHP projects.

Generate or rewrite documentation for a file/folder. Creates README, architecture docs, Mermaid diagrams. Use when you need to create or improve technical documentation.

Generate design patterns. Creates Circuit Breaker, Retry, Rate Limiter, Bulkhead, Cache-Aside, Timeout, Strategy, State, Chain of Responsibility, Decorator, Null Object, Template Method, Visitor, Iterator, Memento, Adapter, Facade, Proxy, Composite, Bridge, Flyweight, Builder, Object Pool, Factory, Outbox, Saga, ADR, Correlation Context, API Versioning, Health Check, Unit of Work, Message Broker Adapter, Idempotent Consumer, Dead Letter Queue, Idempotency Handler, Structured Logger, Access Control, Distributed Lock, Read-Write Proxy, Metrics Collector patterns.

Generate PSR-compliant components. Creates PSR-3 loggers, PSR-6/16 caches, PSR-7/17/18 HTTP, PSR-11 containers, PSR-14 events, PSR-15 middleware, PSR-13 links, PSR-20 clocks.

Generate or rewrite tests for PHP file/folder. Creates unit tests, integration tests, builders, mocks following DDD/CQRS patterns.

Guided refactoring with analysis and pattern application. Analyzes code smells, SOLID violations, testability issues. Provides prioritized refactoring roadmap with generation commands.

Design patterns audit coordinator. Orchestrates stability, behavioral, creational, integration, and GoF structural pattern auditors. Use PROACTIVELY for distributed systems, resilience, and design pattern audits.

Design patterns generation coordinator. Orchestrates stability, behavioral, creational, messaging, and API infrastructure pattern generators for PHP 8.4. Use PROACTIVELY when creating design patterns.

Performance review specialist. Detects N+1 queries, query inefficiency, caching opportunities, unnecessary loops, lazy loading problems, batch processing gaps, complexity issues, missing indexes. Use PROACTIVELY for code review performance analysis.

Pipeline design specialist. Creates CI/CD workflow structures for GitHub Actions and GitLab CI. Designs stages, job dependencies, and optimal execution flow.

Pipeline performance optimization specialist. Analyzes CI execution time, improves caching, parallelization, and identifies bottlenecks.

SOLID and GRASP principles auditor. Analyzes SRP, OCP, LSP, ISP, DIP violations, GRASP compliance, code smells, encapsulation, immutability, and leaky abstractions. Called by acc:architecture-auditor.

PSR compliance auditor for PHP projects. Analyzes PSR-1/PSR-12 coding style, PSR-4 autoloading, and PSR interface implementations. Use PROACTIVELY for PSR audit, coding standards review, or when analyzing PHP project compliance.

Generates PSR-compliant PHP components. Use PROACTIVELY when creating loggers (PSR-3), caches (PSR-6/16), HTTP messages (PSR-7/17/18), containers (PSR-11), events (PSR-14), middleware (PSR-15), links (PSR-13), clocks (PSR-20).

Readability review specialist. Analyzes naming conventions, code style, method/class length, nesting depth, comments quality, magic values, consistency, simplification opportunities. Use PROACTIVELY for code review readability analysis.

Refactoring coordinator. Orchestrates code analysis (readability, testability, SOLID violations, code smells) and pattern generation. Use for guided refactoring workflows.

Resource usage review specialist. Detects memory issues, connection pool problems, serialization overhead, async pattern violations, file I/O inefficiencies. Use PROACTIVELY for code review resource analysis.

Scalability review specialist. Detects horizontal scaling blockers, database scaling issues, replication readiness, stateless design violations. Use PROACTIVELY for code review scalability analysis.

Security review coordinator. Orchestrates 4 specialized security reviewers covering OWASP Top 10: injection, authentication/authorization, data security, and secure design. Use PROACTIVELY for code review security analysis.

Stability patterns auditor. Analyzes Circuit Breaker, Retry, Rate Limiter, Bulkhead, Timeout, Cascading Failures, and Fallback patterns. Called by acc:pattern-auditor coordinator.

Stability patterns generator. Creates Circuit Breaker, Retry, Rate Limiter, Bulkhead, Cache-Aside, and Timeout components for PHP 8.4. Called by acc:pattern-generator coordinator.

Static analysis configuration specialist. Configures PHPStan, Psalm, PHP-CS-Fixer, DEPTRAC, and Rector for PHP projects with appropriate levels and rules.

Structural architecture auditor. Analyzes DDD, Clean Architecture, Hexagonal, Layered, Microservices, Cloud-Native patterns, bounded contexts, and 12-Factor compliance. Called by acc:architecture-auditor.

Test quality auditor for PHP projects. Analyzes coverage gaps, test smells, naming conventions, isolation. Use PROACTIVELY for test audit, test quality review, or when improving test suites.

Creates PHP tests for DDD/CQRS projects. Generates unit tests, integration tests, builders, mocks, test doubles. Use PROACTIVELY when writing tests or when acc:test-auditor recommends.

Test pipeline configuration specialist. Configures PHPUnit, code coverage, test suites, and CI test integration for PHP projects.

Testability review specialist. Analyzes dependency injection usage, pure functions, side effects, test coverage quality, test structure. Use PROACTIVELY for code review testability analysis.

API & infrastructure patterns generator. Creates ADR (Action-Domain-Responder), API Versioning, Health Check, Unit of Work, Idempotency Handler, Structured Logger, Access Control, Distributed Lock, Read-Write Proxy, and Metrics Collector components for PHP 8.4. Called by acc:pattern-generator coordinator.

Architecture audit coordinator. Orchestrates structural, behavioral, and integration auditors for comprehensive reviews. Use PROACTIVELY for architecture audits.

Meta-generator for PHP 8.4 architecture components. Coordinates DDD and integration pattern generation. Use PROACTIVELY when creating bounded contexts, complex domain structures, or full-stack architecture components.

Authentication and authorization security reviewer. Analyzes authentication mechanisms, access control, CSRF protection, mass assignment, and PHP type juggling vulnerabilities. Covers OWASP A01:2021 Broken Access Control, A07:2021 Authentication Failures.

GoF Behavioral patterns auditor. Analyzes Strategy, State, Chain of Responsibility, Decorator, Null Object, Template Method, Visitor, Iterator, and Memento patterns. Called by acc:pattern-auditor coordinator.

Behavioral patterns generator. Creates Strategy, State, Chain of Responsibility, Decorator, Null Object, Template Method, Visitor, Iterator, and Memento components for PHP 8.4. Called by acc:pattern-generator coordinator.

Coordinates bug diagnosis, fix generation, and test creation. Orchestrates acc:bug-hunter, acc:bug-fixer, and acc:test-generator.

Generates safe, minimal bug fixes using diagnosis from bug-hunter. Analyzes root cause, impact, and prevents regressions.

Bug detection specialist. Finds logic errors, null pointers, boundary issues, race conditions, resource leaks, exception issues, type issues, SQL injection, infinite loops. Use PROACTIVELY for code review bug detection.

Business logic analysis specialist. Extracts business rules, explains business processes in natural language, maps domain concepts and ubiquitous language, detects state machines. Translates code to business terminology.

CI/CD coordinator. Orchestrates pipeline setup, debugging, optimization, and auditing. Delegates to specialized agents for static analysis, testing, security, Docker, and deployment.

CI pipeline debugging specialist. Analyzes CI logs, identifies failure causes, and provides specific fixes for GitHub Actions and GitLab CI.

CI fix generation and application specialist. Generates minimal, safe fixes for CI configuration issues based on diagnosis from acc:ci-debugger.

CI/CD security specialist. Audits secrets handling, permissions, dependency scanning, and security configurations in CI pipelines.

Expert in creating Claude Code commands, agents, and skills. Use PROACTIVELY when you need to create or improve Claude Code components.

Code review coordinator. Orchestrates multi-level reviews (low/medium/high) with git diff analysis, delegates to specialized reviewers, aggregates findings with severity levels, calculates task match score, determines verdict. Use PROACTIVELY for code reviews.

Codebase navigation specialist. Scans directory structure, identifies architectural layers, detects framework and patterns, finds entry points. Provides structural map for other explain agents.

CQRS/ES/EDA patterns auditor. Analyzes Command/Query separation, Event Sourcing compliance, and Event-Driven Architecture patterns. Called by acc:architecture-auditor and acc:pattern-auditor.

CQRS/ES component generator. Creates Commands, Queries, Event Stores, Snapshots, and Read Models for PHP 8.4. Called by acc:generate-ddd command and acc:architecture-generator coordinator.

Creational patterns auditor. Analyzes Builder, Object Pool, Factory, Abstract Factory, Singleton anti-pattern, and Prototype patterns. Called by acc:pattern-auditor coordinator.

Creational patterns generator. Creates Builder, Object Pool, and Factory components for PHP 8.4. Called by acc:pattern-generator coordinator.

Data flow analysis specialist. Traces request lifecycles through all layers, maps data transformations between DTOs/Commands/Entities/Responses, identifies async communication flows with queues and events.

Data security reviewer. Analyzes sensitive data handling, cryptographic usage, logging failures, HTTP security headers, and CORS configuration. Covers OWASP A02:2021 Cryptographic Failures, A09:2021 Logging Failures, A05:2021 Security Misconfiguration.

DDD architecture auditor for PHP projects. Analyzes layer separation, domain model, dependencies. Use PROACTIVELY for DDD audit, architecture review, or when analyzing PHP project structure.

Creates DDD building blocks for PHP 8.4. Use PROACTIVELY when creating entities, value objects, aggregates, use cases, repositories, domain services, factories, specifications, DTOs, or anti-corruption layers.

Deployment configuration specialist. Creates blue-green, canary, and rolling deployment configurations with health checks, rollback procedures, and feature flags.

Design security reviewer. Analyzes input validation, output encoding, insecure design patterns, and dependency vulnerabilities. Covers OWASP A04:2021 Insecure Design, A06:2021 Vulnerable Components, input/output security.

Diagram designer for technical documentation. Use PROACTIVELY when creating Mermaid diagrams, C4 models, sequence diagrams, class diagrams, or ER diagrams.

Docker configuration specialist for CI/CD. Creates optimized Dockerfiles, manages layer caching, and configures container builds for PHP projects.

Dockerfile architecture specialist. Designs multi-stage builds, optimizes stage organization, and ensures best practices for PHP Docker images.

Docker Compose configuration specialist. Designs multi-service PHP stacks with health checks, networking, and environment management.

Docker expert system coordinator. Orchestrates Docker auditing, generation, and optimization. Delegates to specialized agents for architecture, images, compose, performance, security, debugging, and production.

Docker error diagnosis specialist. Analyzes build failures, runtime errors, and container connectivity issues for PHP projects.

Docker image and PHP extensions specialist. Manages base image selection, PHP extension installation, and build dependency cleanup.

Docker performance optimization specialist. Analyzes build time, image size, layer caching, and PHP runtime performance.

Docker production readiness specialist. Ensures health checks, graceful shutdown, logging, monitoring, and deployment configuration.

Docker security audit and hardening specialist. Analyzes container security, secrets management, user permissions, and vulnerability exposure.

Documentation quality auditor. Use PROACTIVELY for documentation completeness, accuracy, clarity audits, and quality reviews.

Technical documentation writer for PHP projects. Use PROACTIVELY when generating README, ARCHITECTURE.md, API docs, ADRs, getting started guides, or any technical documentation.

Code explanation coordinator. Orchestrates codebase navigation, business logic extraction, data flow tracing, visualization, and documentation suggestion. Supports 5 modes — quick, deep, onboarding, business, qa.

PHP framework knowledge expert. Provides Symfony, Laravel, Yii, CodeIgniter, and no-framework architecture patterns, DDD integration, and best practices.

GoF Structural patterns auditor. Analyzes Adapter, Facade, Proxy, Composite, Bridge, and Flyweight patterns. Called by acc:pattern-auditor coordinator.

GoF Structural patterns generator. Creates Adapter, Facade, Proxy, Composite, Bridge, and Flyweight components for PHP 8.4. Called by acc:pattern-generator coordinator.

Injection security reviewer. Analyzes SQL injection, command injection, SSRF, XXE, path traversal, and insecure deserialization vulnerabilities. Covers OWASP A03:2021 Injection, A10:2021 SSRF, A08:2021 Software Integrity, A01:2021 (path traversal).

Integration patterns auditor. Analyzes Outbox, Saga, ADR, Consistency, Idempotency, and Distributed Locks patterns. Called by acc:architecture-auditor.

Messaging & event-driven patterns generator. Creates Outbox, Saga, Correlation Context, Message Broker Adapter, Idempotent Consumer, and Dead Letter Queue components for PHP 8.4. Called by acc:pattern-generator coordinator.

Observability auditor. Analyzes structured logging, correlation IDs, metrics endpoints, tracing integration, and health checks. Called by acc:architecture-auditor.

Access Control knowledge base. Provides ACL, RBAC, ABAC, ReBAC models, multi-tenancy patterns, and PHP implementations (Symfony Voters, Laravel Gates) for security audits and generation.

Action-Domain-Responder pattern knowledge base. Provides patterns, antipatterns, and PHP-specific guidelines for ADR (web-specific MVC alternative) audits.

Generates Architecture Decision Records (ADR) for PHP projects. Creates structured decision documentation with context, decision, and consequences.

Analyzes existing CI/CD configurations. Detects issues in GitHub Actions and GitLab CI files, checks for best practices, caching efficiency, and security concerns.

Analyzes CI/CD pipeline logs to identify failure causes. Parses error messages, detects common failure patterns, and provides fix recommendations.

Analyzes coupling and cohesion metrics in PHP codebases. Calculates Afferent/Efferent coupling (Ca/Ce), LCOM metrics, instability index, and abstractness. Identifies highly coupled modules and low cohesion classes.

Analyzes Docker build errors for PHP projects. Identifies extension compilation failures, dependency issues, memory limits, and provides fixes.

Analyzes Docker image size for PHP projects. Identifies bloated layers, unnecessary packages, and provides size reduction strategies.

Analyzes Docker runtime errors for PHP containers. Identifies 502 Bad Gateway, OOM kills, connection refused, and permission issues.

Parses and analyzes PHP application logs in PSR-3/Monolog, Laravel, Symfony, and plain error_log formats. Extracts exceptions, stack traces, request context, error frequency, and correlates related errors.

Analyzes PHP codebase for SOLID principle violations. Detects God classes (SRP), type switches (OCP), broken contracts (LSP), fat interfaces (ISP), and concrete dependencies (DIP). Generates actionable reports with severity levels and remediation recommendations.

Analyzes PHP codebase for test coverage gaps. Detects untested classes, methods, branches, exception paths, and edge cases. Provides actionable recommendations.

API Design knowledge base. Provides REST constraints, Richardson Maturity Model, HTTP semantics, content negotiation, and GraphQL/gRPC comparison for API audits and generation.

Generates API documentation for PHP projects. Creates endpoint documentation with parameters, responses, and examples.

Generates ARCHITECTURE.md files for PHP projects. Creates layer documentation, component descriptions, and architectural diagrams.

Bug fix knowledge base. Provides bug categories, symptoms, fix patterns, and minimal intervention principles for PHP 8.4 projects.

Analyzes bug fix blast radius. Determines affected code, dependencies, callers/callees, and potential side effects of changes.

Regression prevention checklist for bug fixes. Ensures API compatibility, behavior preservation, and no unintended side effects.

Root cause analysis methods for PHP bugs. Provides 5 Whys technique, fault tree analysis, git bisect guidance, and stack trace parsing.

Caching Strategies knowledge base. Provides caching patterns (Cache-Aside, Read-Through, Write-Through, Write-Behind), invalidation approaches, multi-level caching, and Redis data structures for caching audits and generation.

Generates CHANGELOG.md files following Keep a Changelog format. Creates version history documentation.

Analyzes PHP code for 12-Factor App compliance. Detects hardcoded configuration, file-based state, env-specific conditionals, non-streaming logs, and missing environment variable usage.

Audits Abstract Factory pattern implementations. Checks family consistency, product hierarchy, factory method completeness, and cross-family compatibility.

Analyzes PHP code for access control issues. Detects inline role checks, hardcoded permissions, mixed ACL/RBAC models, missing Voter/Policy pattern, and authorization logic in controllers.

Audits DDD aggregate design rules. Checks single transaction boundary, identity by root, invariant enforcement, small aggregates, and consistency boundaries.

Detects synchronous operations that should be async. Identifies blocking email sends, in-request API calls, heavy processing in request cycle, and missing queue offloading.

Analyzes PHP code for authentication issues. Detects weak password handling, insecure sessions, missing auth checks, token vulnerabilities.

Analyzes PHP code for authorization issues. Detects missing access control, IDOR vulnerabilities, privilege escalation, role-based access gaps.

Analyzes PHP code for batch processing issues. Detects single-item vs bulk operations, missing batch inserts, individual API calls in loops, transaction overhead.

Analyzes bounded context boundaries in DDD projects. Detects cross-context coupling, shared kernel violations, context mapping issues, and ubiquitous language inconsistencies. Generates context map diagrams and boundary recommendations.

Analyzes PHP code for caching opportunities and issues. Detects missing cache, cache invalidation problems, over-caching, repeated expensive operations.

Detects cascading failure risks in PHP systems. Identifies shared resources, unbounded queues, missing backpressure, thread pool exhaustion, and failure propagation paths.

Analyzes PHP code for class length issues. Detects classes exceeding 300 lines, God class indicators, cohesion issues, SRP violations.

Analyzes PHP code for style issues. Checks PSR-12 compliance, formatting consistency, whitespace usage, line length.

Analyzes PHP code for command injection vulnerabilities. Detects shell_exec, exec, system, passthru with user input, missing escapeshellarg/escapeshellcmd.

Analyzes PHP code for comment quality issues. Detects missing PHPDoc, outdated comments, commented-out code, opportunities for self-documenting code.

Analyzes PHP code for connection pool issues. Detects connection leaks, improper pool sizing, missing connection release, timeout issues.

Analyzes PHP code for consistency issues. Detects mixed coding styles, inconsistent patterns, API inconsistencies, naming convention violations.

Audits Bounded Context communication patterns. Checks Context Map relationships (Shared Kernel, ACL, Open Host), event vs direct calls, and anti-corruption layer usage.

Audits CORS configuration security. Detects wildcard origins, credentials with wildcards, dynamic origin reflection, missing preflight handling, and overly permissive policies.

Audits CQRS and Event Sourcing alignment. Checks command/query separation, projection idempotency, event store consistency, and read/write model synchronization.

Analyzes PHP code for cryptography issues. Detects weak algorithms, hardcoded keys, insecure random, poor key management, deprecated functions.

Analyzes PHP code for CSRF vulnerabilities. Detects missing CSRF tokens, state-changing GET requests, token validation gaps.

Analyzes PHP code for database scaling issues. Detects single DB connection for all queries, missing read replica configuration, SELECT queries hitting master, and missing connection pooling.

Analyzes PHP code for dependency injection issues. Detects constructor injection usage, interface dependencies, service locator antipattern, new keyword in business logic.

Analyzes PHP dependencies for security vulnerabilities. Detects outdated packages, known CVEs, unsupported versions, vulnerable transitive dependencies.

Analyzes PHP code for insecure deserialization. Detects unserialize with user input, missing allowed_classes, PHP object injection risks, gadget chains.

Analyzes PHP code for distributed lock issues. Detects missing TTL on locks, lock without try/finally, unsafe Redis SETNX patterns, missing lock release, and deadlock risks.

Verifies code examples in documentation. Checks that class names, method signatures, namespaces, and imports match actual codebase. Detects outdated and misleading examples.

Validates documentation links. Detects broken relative links, missing anchor targets, malformed URLs, and orphaned documentation files.

Checks Docker Compose configuration for PHP stacks. Detects missing health checks, improper dependencies, hardcoded values, and networking issues.

Checks Docker health check configuration for PHP services. Verifies PHP-FPM, Nginx, and dependent service health checks.

Checks Docker layer efficiency for PHP builds. Analyzes layer ordering, cache utilization, and identifies optimization opportunities.

Checks PHP configuration in Docker containers. Verifies php.ini settings, OPcache, PHP-FPM pool, and extension configuration for production.

Checks Docker production readiness for PHP applications. Verifies health checks, graceful shutdown, logging, monitoring, and resource limits.

Detects secrets and credentials in Docker configuration. Scans Dockerfile, Compose, and .env files for exposed passwords, tokens, and keys.

Checks Docker security for PHP projects. Detects root user, exposed secrets, privileged mode, and missing security configurations.

Checks Docker user and permission configuration. Detects root execution, improper file ownership, and missing security constraints.

Analyzes PHP code for encapsulation violations. Detects public mutable state, exposed internals, Tell Don't Ask violations, getter/setter abuse, and information hiding breaches.

Audits fallback and graceful degradation strategies. Checks cache fallback, feature flags, default values, circuit breaker fallbacks, and degraded mode implementations.

Audits file I/O patterns in PHP code. Detects full-file reads into memory, missing file locks, temp file cleanup issues, missing stream usage, and insecure file operations.

Analyzes PHP code for idempotency issues. Detects missing idempotency keys on POST/PUT endpoints, non-idempotent command handlers, duplicate write risks, and retry-unsafe operations.

Analyzes PHP code for immutability violations. Checks Value Objects, Events, DTOs for readonly properties, no setters, final classes, and wither patterns. Ensures domain objects maintain invariants.

Detects missing database indexes in PHP code. Identifies unindexed WHERE/JOIN columns, incorrect composite index order, covering index opportunities, and index-defeating patterns.

Analyzes PHP code for input validation issues. Detects missing validation, weak regex, type coercion attacks, length/format gaps, whitelist violations.

Detects OWASP A04:2021 Insecure Design vulnerabilities. Identifies missing rate limiting, account lockout, CAPTCHA, TOCTOU races, business logic flaws, and threat modeling gaps.

Analyzes PHP code for lazy loading issues. Detects premature loading, missing pagination, inappropriate eager loading, infinite scroll problems.

Detects leaky abstractions in PHP code. Identifies implementation details exposed in interfaces, concrete returns from abstract methods, framework leakage into domain, and infrastructure concerns in application layer.

Detects OWASP A09:2021 Security Logging and Monitoring Failures. Identifies log injection, PII in logs, missing audit trails, insufficient error context, and blind spots.

Analyzes PHP code for magic values. Detects hardcoded numbers, string literals without constants, configuration values embedded in code.

Detects mass assignment vulnerabilities. Identifies unguarded model filling, Request::all() to create/update, missing $fillable/$guarded, and parameter binding without whitelisting.

Analyzes PHP code for method length issues. Detects methods exceeding 30 lines, single responsibility violations, extract method opportunities.

Analyzes PHP code for naming convention issues. Detects non-descriptive names, abbreviations, inconsistent casing, misleading names.

Analyzes PHP code for nesting depth issues. Detects deep nesting over 3 levels, complex conditionals, early return opportunities.

Analyzes PHP code for observability gaps. Detects missing structured logging, absent correlation IDs, missing health endpoints, unstructured log calls, and missing OpenTelemetry setup.

Analyzes PHP code for output encoding issues. Detects XSS vulnerabilities, missing HTML encoding, raw output, template injection risks.

Analyzes PHP code for path traversal vulnerabilities. Detects directory traversal, file inclusion with user input, missing path validation, symlink attacks.

Analyzes PHP code for pure function patterns. Detects side-effect-free methods, deterministic output, immutable inputs. Pure functions are easily testable.

Analyzes PHP code for query efficiency issues. Detects SELECT *, missing indexes hints, unnecessary joins, full table scans, suboptimal WHERE clauses.

Analyzes PHP code for scalability issues. Detects file-based sessions, in-memory state, hardcoded hostnames, filesystem-dependent state, and missing stateless design patterns.

Audits HTTP security headers configuration. Checks CSP, X-Frame-Options, HSTS, X-Content-Type-Options, Referrer-Policy, Permissions-Policy, and cache control headers.

Analyzes PHP code for sensitive data exposure. Detects plaintext secrets, exposed credentials, PII in logs, insecure storage, hardcoded keys.

Analyzes PHP code for serialization overhead. Detects inefficient JSON encoding, large object hydration, missing JsonSerializable, circular reference issues.

Analyzes PHP code for side effect issues. Detects state mutation, global access, static method calls, I/O operations mixed with business logic.

Detects Singleton anti-pattern in PHP code. Identifies global state via static instances, hidden dependencies, tight coupling, and testability issues.

Analyzes PHP code for SQL injection vulnerabilities. Detects query concatenation, ORM misuse, raw queries, dynamic identifiers, prepared statement bypasses.

Analyzes PHP code for SSRF vulnerabilities. Detects unvalidated URLs, internal network access, DNS rebinding, cloud metadata access, URL parsing bypass attempts.

Analyzes PHP test code quality. Checks test structure, assertion quality, test isolation, naming conventions, AAA pattern adherence.

Audits timeout configuration across HTTP clients, database connections, queue consumers, cache operations, and external service calls. Detects missing or misconfigured timeouts.

Detects PHP type juggling vulnerabilities. Identifies loose comparison with user input, in_array without strict mode, switch statement type coercion, and hash comparison bypasses.

Audits version consistency across project files. Checks composer.json, README, CHANGELOG, docs, and configuration files for version number synchronization.

Analyzes PHP code for XML External Entity vulnerabilities. Detects unsafe XML parsers, missing entity protection, LIBXML flags issues, XSLT attacks.

CI/CD pipeline knowledge base. Provides platforms overview (GitHub Actions, GitLab CI), pipeline stages, caching strategies, parallelization, artifact management, and environment management.

PHP CI tools knowledge base. Provides PHPStan levels and configuration, Psalm integration, PHP-CS-Fixer rules, DEPTRAC layer analysis, Rector automated refactoring, and code coverage tools.

Comprehensive knowledge base for Claude Code formats, patterns, and configuration. Use when creating, improving, or auditing commands, agents, skills, hooks, memory, plugins, or settings.

Clean Architecture knowledge base. Provides patterns, antipatterns, and PHP-specific guidelines for Clean Architecture and Hexagonal Architecture audits.

Cloud Native knowledge base. Provides 12-Factor App principles with PHP-specific implementations, container-first patterns, and environment configuration for architecture audits.

Generates code examples for PHP documentation. Creates minimal, copy-paste ready examples with expected output.

CodeIgniter 4 framework knowledge base. Provides CI4 MVC architecture, DDD integration, persistence, services, security (Shield auth, Filters authorization, CSRF), event system, queue (codeigniter4/queue jobs, workers, retry), infrastructure components (cache, HTTP client, email, throttler), testing, and antipatterns for CodeIgniter PHP projects.

Consistency Patterns knowledge base. Provides strong vs eventual consistency, idempotency keys, optimistic/pessimistic locking, conflict resolution, and saga compensation patterns for distributed systems audits.

CQRS architecture knowledge base. Provides patterns, antipatterns, and PHP-specific guidelines for Command Query Responsibility Segregation audits.

Generates Access Control components for PHP 8.4. Creates RBAC/ABAC components with PermissionInterface, RoleInterface, VoterInterface, AccessDecisionManager. Includes unit tests.

Generates ADR Action classes for PHP 8.4. Creates single-responsibility HTTP endpoint handlers with PSR-7 support. Includes unit tests.

Generates Adapter pattern for PHP 8.4. Converts incompatible interfaces, wraps legacy code and external libraries. Includes unit tests.

Generates DDD Aggregates for PHP 8.4. Creates consistency boundaries with root entity, domain events, and invariant protection. Includes unit tests.

Generates DDD Anti-Corruption Layer for PHP 8.4. Creates translation layer between bounded contexts or external systems. Includes adapters, translators, facades, and unit tests.

Generates API Versioning pattern for PHP 8.4. Creates version resolution strategies (URI prefix, Accept header, query parameter), middleware, and deprecation support. Includes unit tests.

Generates Bridge pattern for PHP 8.4. Decouples abstraction from implementation. Includes unit tests.

Generates Builder pattern for PHP 8.4. Creates step-by-step object construction with fluent interface and validation. Includes unit tests.

Generates Bulkhead pattern for PHP 8.4. Creates resource isolation with semaphore-based concurrency limiting and thread pool isolation. Includes unit tests.

Generates Cache-Aside pattern for PHP 8.4. Creates cache executor with PSR-16 integration, stampede protection via distributed locking, tag-based invalidation, and key generation. Includes unit tests.

Generates Chain of Responsibility pattern for PHP 8.4. Creates handler chains for request processing with middleware-style composition. Includes unit tests.

Generates Circuit Breaker pattern for PHP 8.4. Creates resilience component protecting against cascading failures with state management, fallback support, and metrics. Includes unit tests.

Generates CQRS Commands and Handlers for PHP 8.4. Creates immutable command DTOs with handlers that modify state. Includes unit tests.

Generates Composite pattern for PHP 8.4. Creates tree structures with uniform treatment of individual and composite objects. Includes unit tests.

Generates Correlation ID propagation components for PHP 8.4. Creates PSR-15 middleware, Monolog processor, message bus header propagation, and CorrelationContext value object. Includes unit tests.

Generates Dead Letter Queue components for PHP 8.4. Creates failed message capture, retry strategy with exponential backoff, failure classification, and unit tests.

Generates Decorator pattern for PHP 8.4. Creates wrapper classes for dynamic behavior addition without inheritance. Includes unit tests.

Generates deployment strategy configurations. Creates blue-green, canary, rolling deployment configs for GitHub Actions and GitLab CI with health checks and rollback procedures.

Generates DEPTRAC configurations for PHP projects. Creates deptrac.yaml with DDD layer rules, bounded context separation, and dependency constraints.

Generates DI Container configuration for PHP 8.4. Creates module classes, service providers, container configuration, and autowiring setup. Supports Symfony, Laravel, and PHP-DI patterns. Includes unit tests.

Generates Distributed Lock for PHP 8.4. Creates LockInterface, LockFactory, RedisLockAdapter with TTL, and database lock adapter. Includes unit tests.

Generates Docker Compose development configurations for PHP projects. Creates full development stacks with database, cache, queue, and debugging tools.

Generates Docker Compose production configurations for PHP projects. Creates hardened stacks with resource limits, restart policies, and monitoring.

Generates Docker entrypoint scripts for PHP containers. Creates startup scripts with signal handling, migrations, and cache warmup.

Generates Docker environment templates for PHP projects. Creates .env.docker files with service configurations and documentation.

Generates Docker health check scripts for PHP services. Creates PHP-FPM, Nginx, and custom endpoint health checks.

Generates Docker Makefile with common commands for PHP projects. Creates build, run, test, and deployment targets.

Generates Nginx configuration for PHP-FPM Docker containers. Creates optimized reverse proxy configs with gzip, security headers, and caching.

Generates PHP configuration files for Docker containers. Creates optimized php.ini, OPcache, and PHP-FPM pool configurations.

Generates Supervisor configuration for Docker PHP containers. Creates process management configs for workers, schedulers, and multi-process setups.

Generates optimized Dockerfiles for PHP CI pipelines. Creates multi-stage builds with separate stages for dependencies, testing, and production with minimal image sizes.

Generates development Dockerfiles for PHP projects. Creates images with Xdebug, hot reload, and development tools.

Generates production-ready Dockerfiles for PHP 8.4 projects. Creates multi-stage builds with composer deps, extensions builder, and optimized production stages.

Generates optimized .dockerignore files for PHP projects. Excludes tests, docs, IDE files, and development artifacts to minimize build context.

Generates DDD Domain Events for PHP 8.4. Creates immutable event records with metadata, past-tense naming. Includes unit tests.

Generates DDD Domain Services for PHP 8.4. Creates stateless services for business logic that doesn't belong to entities or value objects. Includes unit tests.

Generates DTO (Data Transfer Object) for PHP 8.4. Creates immutable objects for layer boundaries, API requests/responses, and data serialization. Includes unit tests.

Generates DDD Entities for PHP 8.4. Creates identity-based objects with behavior, state transitions, and invariant protection. Includes unit tests.

Generates Event Store pattern for PHP 8.4. Creates event sourcing storage infrastructure with event streams, stored events, optimistic locking, and version tracking. Includes unit tests.

Generates Facade pattern for PHP 8.4. Creates simplified interface to complex subsystems. Includes unit tests.

Generates DDD Factory for PHP 8.4. Creates factories for complex domain object instantiation with validation and encapsulated creation logic. Includes unit tests.

Generates feature flag implementations for PHP projects. Creates flag services, configuration, percentage rollouts, user targeting, and integration with deployment pipelines.

Generates Flyweight pattern for PHP 8.4. Optimizes memory via shared intrinsic state. Includes unit tests.

Generates GitHub Actions workflows for PHP projects. Creates CI/CD pipelines with PHPStan, PHPUnit, code coverage, Docker builds, and deployment stages.

Generates GitLab CI configurations for PHP projects. Creates pipelines with stages, caching, artifacts, parallel jobs, and deployment environments.

Generates Health Check pattern for PHP 8.4. Creates application-level health endpoints with component checkers (Database, Redis, RabbitMQ), status aggregation, and RFC-compliant JSON response. Includes unit tests.

Generates Idempotency Handler for PHP 8.4. Creates PSR-15 middleware with Redis-backed deduplication, IdempotencyKey value object, and storage interface. Includes unit tests.

Generates Idempotent Consumer components for PHP 8.4. Creates message deduplication infrastructure with idempotency key management, storage backends, middleware, and unit tests.

Generates PHPUnit integration tests for PHP 8.4. Creates tests with real dependencies, database transactions, HTTP mocking. Supports repositories, API clients, message handlers.

Generates Iterator pattern for PHP 8.4. Creates sequential access to aggregate elements without exposing underlying representation, with iterator interface and iterable collections. Includes unit tests.

Generates Mediator pattern for PHP 8.4. Creates coordination layer for complex component interactions with event dispatching, request/response handling, and colleague classes. Reduces coupling between interacting objects. Includes unit tests.

Generates Memento pattern for PHP 8.4. Creates state capture and restoration mechanism for undo/redo functionality, with originator, memento, and caretaker components. Includes unit tests.

Generates Message Broker Adapter components for PHP 8.4. Creates unified broker interface with RabbitMQ, Kafka, SQS adapters, message serialization, and unit tests.

Generates Metrics Collector for PHP 8.4. Creates MetricsCollectorInterface, Counter/Gauge/Histogram wrappers, PrometheusMetricsCollector, MetricsMiddleware for RED metrics. Includes unit tests.

Generates InMemory repository implementations for PHP 8.4 testing. Creates fake repositories with array storage, supporting CRUD operations and queries without database.

Generates Null Object pattern for PHP 8.4. Creates safe default implementations eliminating null checks. Includes unit tests.

Generates Object Pool pattern for PHP 8.4. Creates reusable object containers for expensive resources like connections. Includes unit tests.

Generates Transactional Outbox pattern components for PHP 8.4. Creates OutboxMessage entity, repository, publisher, and processor with unit tests.

Generates PHPStan configurations for PHP projects. Creates phpstan.neon with appropriate level, extensions, paths, baseline support, and DDD-specific rules.

Generates Policy pattern for PHP 8.4. Creates encapsulated business rules for authorization, validation, and domain constraints. Includes unit tests.

Generates Prototype pattern implementations for PHP 8.4. Creates deep/shallow copy, clone customization, prototype registries, and immutable object duplication.

Generates Proxy pattern for PHP 8.4. Controls access, adds lazy loading, caching, logging. Includes unit tests.

Generates Psalm configurations for PHP projects. Creates psalm.xml with appropriate error level, plugins, taint analysis, and DDD-specific settings.

Generates PSR-11 Container implementation for PHP 8.4. Creates ContainerInterface with service resolution, autowiring support, and exceptions. Includes unit tests.

Generates PSR-13 Hypermedia Links implementation for PHP 8.4. Creates LinkInterface, EvolvableLinkInterface, and LinkProviderInterface for HATEOAS support. Includes unit tests.

Generates PSR-14 Event Dispatcher implementation for PHP 8.4. Creates EventDispatcherInterface, ListenerProviderInterface, and StoppableEventInterface with event propagation. Includes unit tests.

Generates PSR-15 HTTP Middleware implementation for PHP 8.4. Creates MiddlewareInterface and RequestHandlerInterface with pipeline composition. Includes unit tests.

Generates PSR-16 Simple Cache implementation for PHP 8.4. Creates CacheInterface with get/set/delete operations and TTL handling. Includes unit tests.

Generates PSR-17 HTTP Factories implementation for PHP 8.4. Creates RequestFactoryInterface, ResponseFactoryInterface, StreamFactoryInterface, UriFactoryInterface, ServerRequestFactoryInterface, UploadedFileFactoryInterface. Includes unit tests.

Generates PSR-18 HTTP Client implementation for PHP 8.4. Creates ClientInterface with request sending and exception handling. Includes unit tests.

Generates PSR-20 Clock implementation for PHP 8.4. Creates ClockInterface implementations including SystemClock, FrozenClock, and OffsetClock for time abstraction and testing. Includes unit tests.

Generates PSR-3 Logger implementation for PHP 8.4. Creates LoggerInterface implementations with log levels, context interpolation, and LoggerAwareTrait usage. Includes unit tests.

Generates PSR-6 Cache implementation for PHP 8.4. Creates CacheItemPoolInterface and CacheItemInterface implementations with TTL handling and deferred saves. Includes unit tests.

Generates PSR-7 HTTP Message implementations for PHP 8.4. Creates Request, Response, Stream, Uri, and ServerRequest classes with immutability. Includes unit tests.

Generates CQRS Queries and Handlers for PHP 8.4. Creates read-only query DTOs with handlers that return data without side effects. Includes unit tests.

Generates Rate Limiter pattern for PHP 8.4. Creates request throttling with token bucket, sliding window, and fixed window algorithms. Includes unit tests.

Generates Read Model/Projection for PHP 8.4. Creates optimized query models for CQRS read side with projections and denormalization. Includes unit tests.

Generates Read/Write Connection Proxy for PHP 8.4. Creates connection wrapper with query routing logic, transaction-aware routing, and replica health checks. Includes unit tests.

Generates Rector configurations for PHP projects. Creates rector.php with PHP upgrade sets, code quality rules, dead code removal, and framework-specific migrations.

Generates DDD Repository interfaces and implementation stubs for PHP 8.4. Creates domain interfaces in Domain layer, implementation in Infrastructure.

Generates ADR Responder classes for PHP 8.4. Creates HTTP response builders with PSR-7/PSR-17 support. Includes unit tests.

Generates Retry pattern for PHP 8.4. Creates resilience component with exponential backoff, jitter, and configurable retry strategies. Includes unit tests.

Generates Saga pattern components for PHP 8.4. Creates Saga interfaces, steps, orchestrator, state management, and compensation logic with unit tests.

Generates Snapshot pattern for PHP 8.4. Creates aggregate snapshot infrastructure for event sourcing performance optimization with configurable strategies and version tracking. Includes unit tests.

Generates DDD Specification for PHP 8.4. Creates reusable business rule objects for validation, filtering, and querying with composite pattern support. Includes unit tests.

Generates State pattern for PHP 8.4. Creates state machines with context, state interface, and concrete states for behavior changes. Includes unit tests.

Generates Strategy pattern for PHP 8.4. Creates interchangeable algorithm families with context class, strategy interface, and concrete implementations. Includes unit tests.

Generates Structured Logger for PHP 8.4. Creates PSR-3 structured logging setup with Monolog processors, correlation ID propagation, and context middleware. Includes unit tests.

Generates Template Method pattern for PHP 8.4. Creates abstract algorithm skeleton with customizable steps, allowing subclasses to override specific parts without changing structure. Includes unit tests.

Generates Test Data Builder and Object Mother patterns for PHP 8.4. Creates fluent builders with sensible defaults and factory methods for test data creation.

Generates test doubles (Mocks, Stubs, Fakes, Spies) for PHP 8.4. Creates appropriate double type based on testing needs with PHPUnit MockBuilder patterns.

Generates Timeout pattern components for PHP 8.4. Creates execution time limit infrastructure with configurable timeouts, fallback support, stream timeouts, and unit tests.

Generates Unit of Work pattern components for PHP 8.4. Creates transactional consistency infrastructure with aggregate tracking, flush/rollback, domain event collection, and unit tests.

Generates PHPUnit unit tests for PHP 8.4. Creates isolated tests with AAA pattern, proper naming, attributes, and one behavior per test. Supports Value Objects, Entities, Services.

Generates Application Use Cases for PHP 8.4. Creates orchestration services that coordinate domain objects, handle transactions, and dispatch events. Includes unit tests.

Generates DDD Value Objects for PHP 8.4. Creates immutable, self-validating objects with equality comparison. Includes unit tests.

Generates Visitor pattern for PHP 8.4. Creates operations on object structures without modifying element classes, with visitor interface, concrete visitors, and visitable elements. Includes unit tests.

DDD architecture knowledge base. Provides patterns, antipatterns, and PHP-specific guidelines for Domain-Driven Design audits.

Deployment knowledge base. Provides zero-downtime strategies, blue-green deployment, canary releases, rolling updates, rollback procedures, feature flags, and health check patterns.

Detects architectural patterns (MVC, DDD, Hexagonal, CQRS, Layered, Event Sourcing, Microservice) from namespace structure, interface placement, and dependency direction. Outputs confidence score per pattern.

Detects CI/CD antipatterns in pipeline configurations. Identifies slow pipelines, security issues, maintenance problems, and provides remediation guidance.

Detects code smells in PHP codebases. Identifies God Class, Feature Envy, Data Clumps, Long Parameter List, Long Method, Primitive Obsession, Message Chains, Inappropriate Intimacy. Generates actionable reports with refactoring recommendations.

Detects Docker antipatterns in PHP projects. Identifies layer ordering issues, cache invalidation, bloated images, and configuration smells.

Detects memory issues in PHP code. Finds large arrays in memory, missing generators, memory leaks, unbounded data loading, inefficient data structures.

Detects N+1 query problems in PHP code. Finds queries in loops, missing eager loading, lazy loading abuse, relationship traversal issues.

Detects test antipatterns and code smells in PHP test suites. Identifies 15 smells (Logic in Test, Mock Overuse, Fragile Tests, Mystery Guest, etc.) with fix recommendations and refactoring patterns for testability.

Detects unnecessary loop patterns in PHP code. Finds nested loop inefficiency, redundant iterations, in-loop operations that could be batched, loop invariant code.

Diagram knowledge base. Provides Mermaid syntax, C4 model, diagram types, and best practices for technical diagrams.

Discovers log files in PHP projects. Knows standard paths for Laravel, Symfony, CodeIgniter, Yii2/Yii3, PHP-FPM, Docker, CI/CD, web servers, and databases. Parses framework configs to extract custom log paths. Scores and prioritizes findings.

Docker base images knowledge base for PHP. Provides image selection guidelines, Alpine vs Debian comparison, and version pinning strategies.

Docker BuildKit knowledge base. Provides cache mount patterns, build secrets, SSH forwarding, and parallel build optimization.

Docker Compose knowledge base for PHP stacks. Provides service configuration patterns, health checks, networking, and environment management.

Docker knowledge base for PHP projects. Provides patterns, best practices, and guidelines for Dockerfile, Compose, security, and production readiness.

Docker multi-stage build knowledge base. Provides patterns for PHP dependency, extension builder, and production stages with cache optimization.

Docker networking knowledge base. Provides network configuration patterns, DNS resolution, port mapping, and multi-service communication for PHP.

Docker orchestration knowledge base. Provides patterns for Swarm, Kubernetes basics, service scaling, and load balancing for PHP.

Docker PHP extensions knowledge base. Provides installation patterns for common extensions, build dependency management, and PECL usage.

Docker production knowledge base for PHP. Provides deployment patterns, health checks, graceful shutdown, logging, and monitoring.

Docker image scanning knowledge base. Provides vulnerability detection, compliance checking, and SBOM generation for PHP container images.

Docker security knowledge base for PHP. Provides hardening patterns, vulnerability scanning, secrets management, and OWASP container guidelines.

Docker troubleshooting knowledge base. Provides debugging patterns, common error solutions, and diagnostic commands for PHP containers.

Documentation knowledge base. Provides documentation types, audiences, best practices, and antipatterns for technical documentation creation.

Documentation QA knowledge base. Provides quality checklists, audit criteria, and metrics for documentation review.

Event-Driven Architecture knowledge base. Provides patterns, antipatterns, and PHP-specific guidelines for EDA audits including messaging, pub/sub, and saga patterns.

Estimates algorithm complexity in PHP code. Analyzes time and space complexity, detects O(n²) algorithms, exponential growth patterns, inefficient data structures.

Estimates and optimizes CI/CD pipeline execution time. Analyzes job dependencies, identifies bottlenecks, and suggests parallelization strategies.

Event Sourcing knowledge base. Provides patterns, antipatterns, and PHP-specific guidelines for Event Sourcing architecture audits.

Identifies business workflows with actors, steps, preconditions, and outcomes. Translates method chains into natural language business processes like "When customer places order, system validates inventory..."

Output format templates for all 5 explanation modes — quick (compact), deep (full analysis with diagrams), onboarding (project guide), business (non-technical), qa (interactive Q&A).

Extracts validation rules, guards, business constraints, authorization rules, and invariants from domain code. Maps technical implementations to business terminology for non-technical stakeholders.

Maps domain model components — Entities, Value Objects, Aggregates, Services, Events, Repositories. Builds Ubiquitous Language glossary connecting code names to business terminology.

Detects state machines from enums, status fields, switch/match statements, and transition methods. Extracts states, transitions, guards, and actions to build state diagram data.

Detects boundary issues in PHP code. Finds array index out of bounds, empty collection access, off-by-one errors, integer overflow, string length issues.

Detects exception handling issues in PHP code. Finds swallowed exceptions, generic catches, missing exception handling, re-throwing without context, exception in finally.

Detects infinite loop risks in PHP code. Finds missing break conditions, incorrect loop variables, unbounded recursion, circular references.

Detects logic errors in PHP code. Finds incorrect conditions, wrong operators, missing switch cases, inverted logic, short-circuit evaluation issues.

Detects null pointer issues in PHP code. Finds property/method access on null, missing null checks, nullable returns without handling, optional chaining gaps.

Detects race conditions in PHP code. Finds shared mutable state, check-then-act patterns, TOCTOU vulnerabilities, concurrent modification issues.

Detects resource leaks in PHP code. Finds unclosed file handles, database connections not released, streams not freed, missing finally blocks, temporary files not cleaned.

Detects type issues in PHP code. Finds implicit type coercion, mixed types in comparisons, unsafe casting, type mismatches in returns.

Generates minimal, safe bug fixes for PHP 8.4. Provides fix templates for each bug category with DDD/Clean Architecture patterns.

Generates minimal, safe fixes for CI configuration issues. Provides fix templates for dependency, test, lint, infrastructure, Docker, and timeout failures.

Generates Getting Started guides for PHP projects. Creates step-by-step tutorials for first-time users.

GRASP principles knowledge base for PHP 8.4 projects. Provides quick reference for 9 responsibility assignment patterns (Information Expert, Creator, Controller, Low Coupling, High Cohesion, Polymorphism, Pure Fabrication, Indirection, Protected Variations). Use for architecture audits and design decisions.

Hexagonal Architecture (Ports & Adapters) knowledge base. Provides patterns, antipatterns, and PHP-specific guidelines for Hexagonal Architecture audits.

Finds application entry points — Controllers, Actions, Console Commands, Event Handlers, Message Consumers, route definitions, middleware, and scheduled tasks. Maps HTTP/CLI/async entry points to their handlers.

Laravel framework knowledge base. Provides architecture, DDD integration, Eloquent persistence, service container, security, queues, events, infrastructure components, testing, and antipatterns for Laravel PHP projects.

Layered Architecture knowledge base. Provides patterns, antipatterns, and PHP-specific guidelines for traditional N-tier/Layered Architecture audits.

Finds queue publishing (RabbitMQ, Redis), event dispatching, webhooks, and scheduled tasks. Documents synchronous-to-asynchronous boundaries, message formats, consumer chains, and retry policies.

Generates Mermaid diagrams for technical documentation. Provides templates for flowcharts, sequence diagrams, class diagrams, ER diagrams, and C4 models.

Message Queue knowledge base. Provides broker comparison, delivery guarantees, consumer groups, and advanced RabbitMQ/Kafka patterns for messaging audits and generation.

Microservices Architecture knowledge base. Provides service decomposition, communication patterns, API gateway, service discovery, and data management guidelines for architecture audits and generation.

Framework-less PHP knowledge base. Provides pure PHP project architecture, DDD integration, PSR-7/PSR-15 HTTP, standalone persistence, DI containers, security (JWT lcobucci/jwt, RBAC middleware, password hashing, CSRF), event system (PSR-14, league/event, domain events, async processing), queue (enqueue/enqueue, php-amqplib, workers, supervisor), infrastructure components (PSR-6/16 cache, PSR-18 HTTP client, mailer, rate limiting), testing, and antipatterns for projects without a full framework.

Observability knowledge base. Provides three pillars (logs, metrics, traces), structured logging, distributed tracing, metrics collection (RED/USE), SLI/SLO/SLA definitions for observability audits and generation.

Optimizes Docker build time for PHP projects. Analyzes layer caching, BuildKit features, parallel builds, and dependency installation.

Optimizes Docker Compose resource allocation for PHP stacks. Configures memory limits, CPU constraints, and service scaling.

Optimizes Docker image size for PHP projects. Reduces image footprint through Alpine, multi-stage builds, layer cleanup, and dependency minimization.

Analyzes and optimizes Docker layer caching for PHP projects. Identifies layer ordering issues, cache invalidation problems, and provides recommendations for faster builds.

Optimizes OPcache configuration for PHP Docker containers. Configures memory, file limits, JIT, and validation for production and development.

Optimizes PHP-FPM configuration in Docker containers. Tunes process manager, request handling, and resource allocation for production workloads.

Optimizes Docker container startup time for PHP applications. Reduces initialization overhead through preloading, caching, and entrypoint optimization.

Outbox Pattern knowledge base. Provides patterns, antipatterns, and PHP-specific guidelines for transactional outbox, polling publisher, and reliable messaging audits.

PSR-4 autoloading standard knowledge base for PHP 8.4 projects. Provides quick reference for namespace-to-path mapping, composer.json configuration, directory structure, and common mistakes. Use for autoloading audits and project structure reviews.

PSR-1 and PSR-12 coding standards knowledge base for PHP 8.4 projects. Provides quick reference for basic coding standard and extended coding style with detection patterns, examples, and antipattern identification. Use for code style audits and compliance reviews.

PHP Standards Recommendations (PSR) overview knowledge base. Provides comprehensive reference for all accepted PSRs including PSR-1,3,4,6,7,11,12,13,14,15,16,17,18,20. Use for PSR selection decisions and compliance audits.

Generates README.md files for PHP projects. Creates structured documentation with badges, installation, usage, and examples.

Replication and Sharding knowledge base. Provides read/write splitting at application level, connection wrapper patterns, replica lag handling, and query routing for database scaling audits.

Resolves HTTP routes (GET /api/orders) and console commands (app:process-payments) to their handler files. Detects framework, searches route/command definitions, extracts handler class and method, locates file via PSR-4 mapping.

Saga Pattern knowledge base. Provides patterns, antipatterns, and PHP-specific guidelines for saga orchestration, choreography, and distributed transaction audits.

Scalability knowledge base. Provides vertical vs horizontal scaling, stateless design, session management, connection pooling, capacity planning, and PHP-FPM tuning for scalability audits.

Scans directory tree to identify architectural layers (Domain, Application, Infrastructure, Presentation), detect framework (Symfony, Laravel, custom), count files per layer, and build project structure map.

SOLID principles knowledge base for PHP 8.4 projects. Provides quick reference for SRP, OCP, LSP, ISP, DIP with detection patterns, PHP examples, and antipattern identification. Use for architecture audits and code quality reviews.

Stability Patterns knowledge base. Provides patterns, antipatterns, and PHP-specific guidelines for Circuit Breaker, Retry, Rate Limiter, Bulkhead, and resilience audits.

Suggests code simplification opportunities. Identifies extract method candidates, complex expressions, redundant code, refactoring opportunities.

Suggests testability improvements for PHP code. Provides DI refactoring suggestions, mock opportunities, interface extraction, testing strategy recommendations.

Symfony framework knowledge base. Provides architecture, DDD integration, persistence, DI, security, messenger, workflow, events, infrastructure components, testing, and antipatterns for Symfony PHP projects.

TaskCreate pattern guidelines for progress tracking in coordinator agents

Testing knowledge base for PHP 8.4 projects. Provides testing pyramid, AAA pattern, naming conventions, isolation principles, DDD testing guidelines, and PHPUnit patterns.

Maps data transformation chains — Request DTO to Command to Entity to Response DTO. Identifies mappers, serializers, type conversions, and data loss points across layer boundaries.

Traces full request lifecycle from Router through Middleware, Controller, UseCase, Repository to Response. Documents HTTP methods, routes, middleware stack, response codes, and error handling paths.

Generates troubleshooting guides and FAQ sections for PHP projects. Creates problem-solution documentation.

Yii framework knowledge base. Provides Yii3 modular architecture, DDD integration, PSR-7/PSR-15 compliance, persistence, DI, security (RBAC, auth), event system (PSR-14), queue/jobs, infrastructure components (cache, rate limiter, HTTP client), testing, and antipatterns for Yii PHP projects.

1 hook across 1 event