claude-code-templates 1.21.11 → 1.21.13

package/cli-tool/components/commands/security/add-authentication-system.md

@@ -0,0 +1,34 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [auth-method] | --oauth | --jwt | --mfa | --passwordless
+description: Implement secure user authentication system with chosen method and security best practices
+model: sonnet
+---
+
+# Add Authentication System
+
+Implement secure user authentication system: **$ARGUMENTS**
+
+## Current Application State
+
+- Framework detection: @package.json or @requirements.txt or @Cargo.toml
+- Existing auth: !`grep -r "auth\|login\|jwt\|session" src/ --include="*.js" --include="*.py" --include="*.rs" | wc -l`
+- Security config: @.env* (check for auth-related variables)
+- Database setup: Check for user models or auth tables
+
+## Task
+
+Implement comprehensive authentication system with security best practices:
+
+**Authentication Methods**: Choose from username/password, OAuth 2.0, JWT, SAML, MFA, or passwordless based on $ARGUMENTS
+
+**Implementation Areas**:
+1. **User Management** - Registration, profiles, password policies, account verification
+2. **Authentication Flow** - Login/logout, session management, token handling, middleware
+3. **Authorization System** - RBAC, permissions, route protection, API security
+4. **Security Hardening** - Password hashing, rate limiting, CSRF protection, secure cookies
+5. **Integration** - Frontend components, API endpoints, database models, middleware
+
+**Security Standards**: Implement OWASP authentication guidelines, secure session management, and proper error handling.
+
+**Output**: Production-ready authentication system with comprehensive security controls and user-friendly interface.

package/cli-tool/components/commands/security/dependency-audit.md

@@ -0,0 +1,32 @@
+---
+allowed-tools: Read, Bash, Grep
+argument-hint: [scope] | --security | --licenses | --updates | --all
+description: Audit dependencies for security vulnerabilities, license compliance, and update recommendations
+model: sonnet
+---
+
+# Dependency Audit
+
+Audit dependencies for security vulnerabilities and compliance: **$ARGUMENTS**
+
+## Current Dependencies
+
+- Package files: @package.json or @requirements.txt or @Cargo.toml or @pom.xml
+- Lock files: @package-lock.json or @poetry.lock or @Cargo.lock
+- Security scan: !`npm audit --audit-level=moderate 2>/dev/null || pip check 2>/dev/null || cargo audit 2>/dev/null || echo "No security scanner available"`
+- Outdated packages: !`npm outdated 2>/dev/null || pip list --outdated 2>/dev/null || echo "Check manually"`
+
+## Task
+
+Perform comprehensive dependency security and compliance audit:
+
+**Audit Scope**: Use $ARGUMENTS to focus on security, licenses, updates, or complete audit
+
+**Analysis Areas**:
+1. **Vulnerability Scanning** - Known CVEs, security advisories, exploit availability
+2. **Version Analysis** - Outdated packages, breaking changes, update recommendations
+3. **License Compliance** - License compatibility, restrictions, legal obligations
+4. **Supply Chain Security** - Package authenticity, maintainer status, suspicious dependencies
+5. **Performance Impact** - Bundle size, unused dependencies, optimization opportunities
+
+**Output**: Prioritized security report with critical vulnerabilities, recommended actions, and compliance status.

package/cli-tool/components/commands/security/penetration-test.md

@@ -0,0 +1,40 @@
+---
+allowed-tools: Read, Bash, Grep, Glob
+argument-hint: [target] | --web-app | --api | --auth | --full-scan
+description: Perform penetration testing and vulnerability assessment on application
+model: sonnet
+---
+
+# Penetration Test
+
+Perform penetration testing and vulnerability assessment: **$ARGUMENTS**
+
+## Application Context
+
+- Running services: !`netstat -tlnp 2>/dev/null | grep LISTEN | head -10 || lsof -i -P | grep LISTEN | head -10`
+- Web framework: @package.json or @requirements.txt (detect framework and version)
+- API endpoints: !`grep -r "route\|endpoint\|@app\\.route\|@RequestMapping" src/ 2>/dev/null | wc -l`
+- Authentication: !`grep -r "auth\|login\|jwt\|session" src/ 2>/dev/null | wc -l`
+
+## Task
+
+Conduct systematic penetration testing following ethical hacking methodologies:
+
+**Test Target**: Use $ARGUMENTS to focus on web application, API, authentication, or comprehensive testing
+
+**Testing Phases**:
+1. **Reconnaissance** - Service discovery, technology fingerprinting, attack surface mapping
+2. **Vulnerability Assessment** - OWASP Top 10, injection flaws, broken authentication
+3. **Exploitation Testing** - XSS, CSRF, SQL injection, privilege escalation attempts
+4. **Authentication Testing** - Brute force, session management, authorization bypasses
+5. **API Security Testing** - Input validation, rate limiting, authentication bypass
+6. **Infrastructure Testing** - Network security, container security, configuration issues
+
+**Testing Methodology**:
+- Follow OWASP Testing Guide and NIST guidelines
+- Use both automated tools and manual testing techniques
+- Document all findings with proof-of-concept examples
+- Provide remediation recommendations for each vulnerability
+- Maintain ethical boundaries and avoid data damage
+
+**Output**: Comprehensive penetration test report with executive summary, detailed findings, risk ratings, and remediation roadmap.

package/cli-tool/components/commands/security/secrets-scanner.md

@@ -0,0 +1,39 @@
+---
+allowed-tools: Read, Bash, Grep, Glob
+argument-hint: [scope] | --api-keys | --passwords | --certificates | --fix
+description: Scan codebase for exposed secrets, credentials, and sensitive information
+model: sonnet
+---
+
+# Secrets Scanner
+
+Scan codebase for exposed secrets and sensitive information: **$ARGUMENTS**
+
+## Current Repository State
+
+- Git status: !`git status --porcelain | wc -l` uncommitted files
+- File types: !`find . -name "*.js" -o -name "*.py" -o -name "*.env*" -o -name "*.yml" | wc -l` scannables
+- Recent commits: !`git log --oneline --grep="password\|key\|secret\|token" -5`
+- Environment files: @.env* or @config/* (if exists)
+
+## Task
+
+Perform comprehensive secrets detection and remediation across codebase:
+
+**Scan Scope**: Use $ARGUMENTS to focus on API keys, passwords, certificates, or complete scan
+
+**Detection Categories**:
+1. **API Keys & Tokens** - GitHub, AWS, Google Cloud, Stripe, third-party services
+2. **Database Credentials** - Connection strings, usernames, passwords
+3. **Certificates & Keys** - Private keys, SSH keys, SSL certificates
+4. **Authentication Secrets** - JWT secrets, session keys, OAuth credentials
+5. **Configuration Leaks** - Hardcoded URLs, internal endpoints, debug settings
+
+**Remediation Actions**:
+- Identify exposed secrets with file locations and line numbers
+- Provide secure alternatives (environment variables, secret management)
+- Generate .gitignore entries for sensitive files
+- Create secure configuration templates
+- Implement secrets management best practices
+
+**Output**: Detailed security report with risk levels, immediate actions, and long-term security improvements.

package/cli-tool/components/commands/security/security-audit.md

@@ -0,0 +1,82 @@
+---
+allowed-tools: Read, Bash, Grep, Glob
+argument-hint: [focus-area] | --full
+description: Perform comprehensive security assessment and vulnerability analysis
+model: sonnet
+---
+
+# Security Audit
+
+Perform comprehensive security assessment: $ARGUMENTS
+
+## Current Environment
+
+- Dependency scan: !`npm audit --audit-level=moderate 2>/dev/null || pip check 2>/dev/null || echo "No package manager detected"`
+- Environment files: @.env* (if exists)
+- Security config: @.github/workflows/security.yml or @security/ (if exists)
+- Recent commits: !`git log --oneline --grep="security\|fix" -10`
+
+## Task
+
+Perform systematic security audit following these steps:
+
+1. **Environment Setup**
+   - Identify the technology stack and framework
+   - Check for existing security tools and configurations
+   - Review deployment and infrastructure setup
+
+2. **Dependency Security**
+   - Scan all dependencies for known vulnerabilities
+   - Check for outdated packages with security issues
+   - Review dependency sources and integrity
+   - Use appropriate tools: `npm audit`, `pip check`, `cargo audit`, etc.
+
+3. **Authentication & Authorization**
+   - Review authentication mechanisms and implementation
+   - Check for proper session management
+   - Verify authorization controls and access restrictions
+   - Examine password policies and storage
+
+4. **Input Validation & Sanitization**
+   - Check all user input validation and sanitization
+   - Look for SQL injection vulnerabilities
+   - Identify potential XSS (Cross-Site Scripting) issues
+   - Review file upload security and validation
+
+5. **Data Protection**
+   - Identify sensitive data handling practices
+   - Check encryption implementation for data at rest and in transit
+   - Review data masking and anonymization practices
+   - Verify secure communication protocols (HTTPS, TLS)
+
+6. **Secrets Management**
+   - Scan for hardcoded secrets, API keys, and passwords
+   - Check for proper secrets management practices
+   - Review environment variable security
+   - Identify exposed configuration files
+
+7. **Error Handling & Logging**
+   - Review error messages for information disclosure
+   - Check logging practices for security events
+   - Verify sensitive data is not logged
+   - Assess error handling robustness
+
+8. **Infrastructure Security**
+   - Review containerization security (Docker, etc.)
+   - Check CI/CD pipeline security
+   - Examine cloud configuration and permissions
+   - Assess network security configurations
+
+9. **Security Headers & CORS**
+   - Check security headers implementation
+   - Review CORS configuration
+   - Verify CSP (Content Security Policy) settings
+   - Examine cookie security attributes
+
+10. **Reporting**
+    - Document all findings with severity levels (Critical, High, Medium, Low)
+    - Provide specific remediation steps for each issue
+    - Include code examples and file references
+    - Create an executive summary with key recommendations
+
+Use automated security scanning tools when available and provide manual review for complex security patterns.

package/cli-tool/components/commands/security/security-hardening.md

@@ -0,0 +1,33 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [focus-area] | --headers | --auth | --encryption | --infrastructure
+description: Harden application security configuration with comprehensive security controls
+model: sonnet
+---
+
+# Security Hardening
+
+Harden application security configuration and controls: **$ARGUMENTS**
+
+## Current Security Posture
+
+- Framework: @package.json or @requirements.txt or @Cargo.toml (detect framework)
+- Security headers: !`curl -I http://localhost:3000 2>/dev/null | grep -i 'x-\|content-security\|strict-transport' || echo "No server running"`
+- Environment config: @.env* (check for security-related variables)
+- Dependencies: !`npm audit --audit-level=moderate 2>/dev/null || echo "Run dependency audit first"`
+
+## Task
+
+Implement comprehensive security hardening based on security best practices:
+
+**Hardening Focus**: Use $ARGUMENTS to target specific areas or apply comprehensive hardening
+
+**Security Controls**:
+1. **Authentication & Authorization** - MFA, RBAC, session security, password policies
+2. **Input Validation** - XSS prevention, SQL injection protection, CSRF tokens
+3. **Secure Communication** - HTTPS/TLS, HSTS, certificate management
+4. **Data Protection** - Encryption at rest/transit, key management, secure storage
+5. **Security Headers** - CSP, CORS, security response headers
+6. **Infrastructure Security** - Container hardening, network segmentation, monitoring
+
+**Output**: Hardened application with comprehensive security controls, proper configuration, and monitoring capabilities.

package/cli-tool/components/commands/setup/create-database-migrations.md

@@ -0,0 +1,35 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [migration-name] | --create-table | --add-column | --alter-table
+description: Create and manage database migrations with proper versioning and rollback support
+model: sonnet
+---
+
+# Create Database Migrations
+
+Create and manage database migrations: **$ARGUMENTS**
+
+## Current Database State
+
+- ORM detection: @package.json or @requirements.txt (detect Sequelize, Prisma, Alembic, etc.)
+- Migration files: !`find . -name "*migration*" -type f | head -5`
+- Database config: @config/database.* or @prisma/schema.prisma
+- Current schema: !`ls migrations/ 2>/dev/null | wc -l` migrations found
+
+## Task
+
+Create comprehensive database migrations with proper versioning and rollback capabilities:
+
+**Migration Types**: Use $ARGUMENTS to specify table creation, column addition, table alteration, or data migration
+
+**Migration Framework**:
+1. **Migration Planning** - Analyze schema changes, dependencies, and data impact
+2. **Migration Generation** - Create timestamped migration files with up/down methods
+3. **Schema Updates** - Table creation, column modifications, index management
+4. **Data Migrations** - Safe data transformations and backfills
+5. **Rollback Strategy** - Implement reliable rollback procedures for each change
+6. **Testing** - Validate migrations in development and staging environments
+
+**Best Practices**: Follow database-specific conventions, maintain referential integrity, handle large datasets efficiently, and ensure zero-downtime deployments.
+
+**Output**: Production-ready migration files with comprehensive rollback support, proper indexing, and data safety measures.

package/cli-tool/components/commands/setup/design-database-schema.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [schema-type] | --relational | --nosql | --hybrid | --normalize
+description: Design optimized database schemas with proper relationships, constraints, and performance considerations
+model: sonnet
+---
+
+# Design Database Schema
+
+Design optimized database schemas with comprehensive data modeling: **$ARGUMENTS**
+
+## Current Project Context
+
+- Application type: Based on $ARGUMENTS or codebase analysis
+- Data requirements: @requirements/ or project documentation
+- Existing schema: @prisma/schema.prisma or @migrations/ or database dumps
+- Performance needs: Expected scale, query patterns, and data volume
+
+## Task
+
+Design comprehensive database schema with optimal structure and performance:
+
+**Schema Type**: Use $ARGUMENTS to specify relational, NoSQL, hybrid approach, or normalization level
+
+**Design Framework**:
+1. **Requirements Analysis** - Business entities, relationships, data flow, and access patterns
+2. **Entity Modeling** - Tables/collections, attributes, primary/foreign keys, constraints
+3. **Relationship Design** - One-to-one, one-to-many, many-to-many associations
+4. **Normalization Strategy** - Data consistency vs performance trade-offs
+5. **Performance Optimization** - Indexing strategy, query optimization, partitioning
+6. **Security Design** - Access control, data encryption, audit trails
+
+**Advanced Patterns**: Implement temporal data, soft deletes, JSONB fields, full-text search, audit logging, and scalability patterns.
+
+**Validation**: Ensure referential integrity, data consistency, query performance, and future extensibility.
+
+**Output**: Complete schema design with DDL scripts, ER diagrams, performance analysis, and migration strategy.

package/cli-tool/components/commands/setup/design-rest-api.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [api-version] | --v1 | --v2 | --graphql-hybrid | --openapi
+description: Design RESTful API architecture with comprehensive endpoints, authentication, and documentation
+model: sonnet
+---
+
+# Design REST API
+
+Design comprehensive RESTful API architecture: **$ARGUMENTS**
+
+## Current Application State
+
+- Framework detection: @package.json or @requirements.txt (Express, FastAPI, Spring Boot, etc.)
+- Existing API: !`grep -r "route\|endpoint\|@app\\.route" src/ 2>/dev/null | wc -l` routes found
+- Authentication: !`grep -r "auth\|jwt\|session" src/ 2>/dev/null | wc -l` auth components
+- Documentation: @swagger.yaml or @openapi.json (if exists)
+
+## Task
+
+Design complete RESTful API with industry best practices and comprehensive functionality:
+
+**API Version**: Use $ARGUMENTS to specify API version, GraphQL hybrid approach, or OpenAPI specification
+
+**API Architecture**:
+1. **Resource Design** - RESTful endpoints, HTTP methods, URL structure, resource relationships
+2. **Request/Response Models** - Data validation, serialization, error handling, status codes
+3. **Authentication & Authorization** - JWT, OAuth, RBAC, API keys, rate limiting
+4. **API Documentation** - OpenAPI/Swagger specs, interactive documentation, code examples
+5. **Versioning Strategy** - URL, header, or content-type based versioning
+6. **Performance & Security** - Caching, pagination, CORS, input validation, SQL injection prevention
+
+**Advanced Features**: Real-time capabilities, file uploads, batch operations, webhooks, and monitoring integration.
+
+**Standards Compliance**: Follow REST principles, HTTP specifications, and API design best practices.
+
+**Output**: Complete API specification with endpoints, authentication, validation, documentation, and client SDKs.

package/cli-tool/components/commands/setup/implement-graphql-api.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [schema-approach] | --schema-first | --code-first | --federation
+description: Implement GraphQL API with comprehensive schema, resolvers, and real-time subscriptions
+model: sonnet
+---
+
+# Implement GraphQL API
+
+Implement comprehensive GraphQL API with modern best practices: **$ARGUMENTS**
+
+## Current Application Context
+
+- Framework: @package.json or @requirements.txt (detect Apollo, GraphQL Yoga, etc.)
+- Existing API: !`find . -name "*.graphql" -o -name "*schema*" -o -name "*resolver*" | wc -l`
+- Database integration: @prisma/schema.prisma or database connection configs
+- Authentication: !`grep -r "auth\|jwt\|context" src/ 2>/dev/null | wc -l`
+
+## Task
+
+Build production-ready GraphQL API with comprehensive functionality and performance optimization:
+
+**Schema Approach**: Use $ARGUMENTS to specify schema-first, code-first, or federation architecture
+
+**GraphQL Implementation**:
+1. **Schema Design** - Type definitions, queries, mutations, subscriptions, custom scalars
+2. **Resolver Architecture** - Data fetching, authentication, authorization, error handling
+3. **DataLoader Integration** - N+1 query prevention, batch loading, caching strategies
+4. **Real-time Features** - WebSocket subscriptions, live data updates, connection management
+5. **Security & Performance** - Query complexity analysis, depth limiting, rate limiting
+6. **Development Tools** - GraphQL Playground, introspection, schema stitching
+
+**Advanced Features**: File uploads, federated schemas, Apollo Federation, schema directives, and monitoring.
+
+**Production Readiness**: Implement comprehensive error handling, logging, metrics, and deployment strategies.
+
+**Output**: Complete GraphQL API with optimized resolvers, real-time capabilities, security controls, and developer documentation.

package/cli-tool/components/commands/setup/migrate-to-typescript.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [migration-strategy] | --gradual | --complete | --strict | --incremental
+description: Migrate JavaScript project to TypeScript with proper typing and tooling setup
+model: sonnet
+---
+
+# Migrate to TypeScript
+
+Migrate JavaScript project to TypeScript with comprehensive type safety: **$ARGUMENTS**
+
+## Current JavaScript State
+
+- Project structure: @package.json (analyze JS/TS mix and dependencies)
+- JavaScript files: !`find . -name "*.js" -not -path "./node_modules/*" | wc -l`
+- Existing TypeScript: !`find . -name "*.ts" -not -path "./node_modules/*" | wc -l`
+- Build system: @webpack.config.js or @vite.config.js or @rollup.config.js
+
+## Task
+
+Systematically migrate JavaScript codebase to TypeScript with proper typing and tooling:
+
+**Migration Strategy**: Use $ARGUMENTS to specify gradual migration, complete conversion, strict mode, or incremental approach
+
+**Migration Process**:
+1. **Environment Setup** - TypeScript installation, tsconfig.json configuration, build tool integration
+2. **Type Definitions** - Install @types packages, create custom type declarations, define interfaces
+3. **File Migration** - Rename .js to .ts/.tsx, add type annotations, resolve compiler errors
+4. **Code Transformation** - Convert classes, functions, and modules with proper typing
+5. **Error Resolution** - Fix type mismatches, null/undefined handling, strict mode issues
+6. **Testing & Validation** - Update test files, configure type checking, validate type coverage
+
+**Advanced Features**: Generic types, mapped types, conditional types, module augmentation, and strict compiler settings.
+
+**Developer Experience**: Configure IDE integration, debugging, linting rules, and team onboarding.
+
+**Output**: Fully typed TypeScript codebase with strict type checking, comprehensive IntelliSense, and improved developer productivity.

package/cli-tool/components/commands/setup/setup-ci-cd-pipeline.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [platform] | --github-actions | --gitlab-ci | --azure-pipelines | --jenkins
+description: Setup comprehensive CI/CD pipeline with automated testing, deployment, and monitoring
+model: sonnet
+---
+
+# Setup CI/CD Pipeline
+
+Setup comprehensive CI/CD pipeline with automated workflows and deployments: **$ARGUMENTS**
+
+## Current Repository State
+
+- Version control: !`git remote -v | head -1` (GitHub, GitLab, etc.)
+- Existing CI: !`find . -name ".github" -o -name ".gitlab-ci.yml" -o -name "azure-pipelines.yml" | wc -l`
+- Test framework: @package.json or testing files detection
+- Deployment config: @Dockerfile or deployment manifests
+
+## Task
+
+Implement production-ready CI/CD pipeline with comprehensive automation and best practices:
+
+**Platform Choice**: Use $ARGUMENTS to specify GitHub Actions, GitLab CI, Azure Pipelines, or Jenkins
+
+**Pipeline Architecture**:
+1. **Build Automation** - Code compilation, dependency installation, artifact creation
+2. **Testing Strategy** - Unit tests, integration tests, e2e tests, code coverage reporting
+3. **Quality Gates** - Linting, security scanning, vulnerability assessment, code quality metrics
+4. **Deployment Automation** - Staging deployment, production deployment, rollback mechanisms
+5. **Environment Management** - Infrastructure provisioning, configuration management, secrets handling
+6. **Monitoring Integration** - Performance monitoring, error tracking, deployment notifications
+
+**Advanced Features**: Parallel job execution, matrix builds, deployment strategies (blue-green, canary), and multi-environment support.
+
+**Security & Compliance**: Secure credential management, compliance checks, audit trails, and approval workflows.
+
+**Output**: Complete CI/CD pipeline with automated testing, secure deployments, monitoring integration, and comprehensive documentation.

package/cli-tool/components/commands/setup/setup-development-environment.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [environment-type] | --local | --docker | --cloud | --full-stack
+description: Setup comprehensive development environment with tools, configurations, and workflows
+model: sonnet
+---
+
+# Setup Development Environment
+
+Setup comprehensive development environment with modern tooling: **$ARGUMENTS**
+
+## Current Environment State
+
+- Operating system: !`uname -s` and architecture detection
+- Development tools: !`node --version 2>/dev/null || python --version 2>/dev/null || echo "No runtime detected"`
+- Package managers: !`which npm yarn pnpm pip poetry cargo 2>/dev/null | wc -l` managers available
+- IDE/Editor: Check for VS Code, IntelliJ, or other development environments
+
+## Task
+
+Configure complete development environment with modern tools and best practices:
+
+**Environment Type**: Use $ARGUMENTS to specify local setup, Docker-based, cloud environment, or full-stack development
+
+**Environment Setup**:
+1. **Runtime Installation** - Programming languages, package managers, version managers (nvm, pyenv, rustup)
+2. **Development Tools** - IDE configuration, extensions, debuggers, profilers, database clients
+3. **Build System** - Compilers, bundlers, task runners, CI/CD tools, testing frameworks
+4. **Code Quality** - Linting, formatting, pre-commit hooks, code analysis tools
+5. **Environment Configuration** - Environment variables, secrets management, configuration files
+6. **Team Synchronization** - Shared configurations, documentation, onboarding guides
+
+**Advanced Features**: Hot reloading, debugging configuration, performance monitoring, container orchestration.
+
+**Automation**: Automated setup scripts, configuration management, team environment synchronization.
+
+**Output**: Complete development environment with documented setup process, team configurations, and troubleshooting guides.

package/cli-tool/components/commands/setup/setup-docker-containers.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [environment-type] | --development | --production | --microservices | --compose
+description: Setup Docker containerization with multi-stage builds and development workflows
+model: sonnet
+---
+
+# Setup Docker Containers
+
+Setup comprehensive Docker containerization for development and production: **$ARGUMENTS**
+
+## Current Project State
+
+- Application type: @package.json or @requirements.txt (detect Node.js, Python, etc.)
+- Existing Docker: @Dockerfile or @docker-compose.yml (if exists)
+- Dependencies: !`find . -name "package-lock.json" -o -name "poetry.lock" -o -name "Pipfile.lock" | wc -l`
+- Services needed: Database, cache, message queue detection from configs
+
+## Task
+
+Implement production-ready Docker containerization with optimized builds and development workflows:
+
+**Environment Type**: Use $ARGUMENTS to specify development, production, microservices, or Docker Compose setup
+
+**Containerization Strategy**:
+1. **Dockerfile Creation** - Multi-stage builds, layer optimization, security best practices
+2. **Development Workflow** - Hot reloading, volume mounts, debugging capabilities
+3. **Production Optimization** - Image size reduction, security scanning, health checks
+4. **Multi-Service Setup** - Docker Compose, service discovery, networking configuration
+5. **CI/CD Integration** - Build automation, registry management, deployment pipelines
+6. **Monitoring & Logs** - Container observability, log aggregation, resource monitoring
+
+**Security Features**: Non-root users, minimal base images, vulnerability scanning, secrets management.
+
+**Performance Optimization**: Layer caching, build contexts, multi-platform builds, and resource constraints.
+
+**Output**: Complete Docker setup with optimized containers, development workflows, production deployment, and comprehensive documentation.

package/cli-tool/components/commands/setup/setup-formatting.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [language] | --javascript | --typescript | --python | --multi-language
+description: Configure comprehensive code formatting tools with consistent style enforcement
+model: sonnet
+---
+
+# Setup Code Formatting
+
+Configure comprehensive code formatting with consistent style enforcement: **$ARGUMENTS**
+
+## Current Project State
+
+- Languages detected: !`find . -name "*.js" -o -name "*.ts" -o -name "*.py" -o -name "*.rs" | head -5`
+- Existing formatters: @.prettierrc or @pyproject.toml or @rustfmt.toml
+- Package manager: @package.json or @requirements.txt or @Cargo.toml
+- IDE config: @.vscode/settings.json or @.editorconfig
+
+## Task
+
+Setup comprehensive code formatting system with automated enforcement and team consistency:
+
+**Language Focus**: Use $ARGUMENTS to configure JavaScript/TypeScript, Python, Rust, or multi-language formatting
+
+**Formatting Setup**:
+1. **Tool Installation** - Prettier, Black, rustfmt, language-specific formatters and plugins
+2. **Configuration** - Style rules, line length, indentation, quotes, trailing commas, language-specific options
+3. **IDE Integration** - Editor extensions, format-on-save, keyboard shortcuts, workspace settings
+4. **Automation** - Pre-commit hooks, CI/CD formatting checks, automated formatting scripts
+5. **Team Sync** - Shared configurations, style guides, enforcement policies, onboarding documentation
+6. **Validation** - Formatting verification, CI integration, team compliance monitoring
+
+**Advanced Features**: Custom rules, framework-specific formatting, performance optimization, incremental formatting.
+
+**Consistency**: Cross-platform compatibility, team standardization, legacy code migration strategies.
+
+**Output**: Complete formatting system with automated enforcement, team configurations, and style compliance monitoring.

package/cli-tool/components/commands/setup/setup-linting.md

@@ -0,0 +1,37 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [language] | --javascript | --typescript | --python | --multi-language
+description: Configure comprehensive code linting and quality analysis tools with automated enforcement
+model: sonnet
+---
+
+# Setup Code Linting
+
+Configure comprehensive code linting and quality analysis: **$ARGUMENTS**
+
+## Current Code Quality State
+
+- Languages detected: !`find . -name "*.js" -o -name "*.ts" -o -name "*.py" -o -name "*.rs" | head -5`
+- Existing linters: @.eslintrc.* or @pyproject.toml or @tslint.json
+- Package manager: @package.json or @requirements.txt or @Cargo.toml
+- Code quality tools: !`which eslint flake8 pylint mypy clippy 2>/dev/null | wc -l`
+
+## Task
+
+Setup comprehensive code linting system with quality analysis and automated enforcement:
+
+**Language Focus**: Use $ARGUMENTS to configure JavaScript/TypeScript ESLint, Python linting, or multi-language quality analysis
+
+**Linting Configuration**:
+1. **Tool Installation** - ESLint, Flake8, Pylint, MyPy, Clippy, language-specific linters and plugins
+2. **Rule Configuration** - Code style rules, error detection, best practices, security patterns, performance guidelines
+3. **IDE Integration** - Real-time linting, error highlighting, quick fixes, workspace settings
+4. **Quality Gates** - Pre-commit validation, CI/CD integration, pull request checks, quality metrics
+5. **Custom Rules** - Project-specific patterns, architectural constraints, team conventions
+6. **Performance** - Incremental linting, caching strategies, parallel execution, optimization
+
+**Advanced Features**: Security linting, accessibility checks, performance analysis, dependency analysis, code complexity metrics.
+
+**Team Standards**: Shared configurations, style guides, review guidelines, onboarding documentation.
+
+**Output**: Complete linting system with automated quality gates, team standards enforcement, and comprehensive code analysis.