@qazuor/claude-code-config 0.1.0

package/templates/commands/_registry.json

@@ -0,0 +1,420 @@
+{
+  "category": "commands",
+  "modules": [
+    {
+      "id": "quality-check",
+      "name": "Quality Check",
+      "description": "Run comprehensive quality checks (lint, types, tests, coverage)",
+      "file": "quality-check.md",
+      "tags": ["core", "quality", "ci"],
+      "longDescription": "Runs a comprehensive quality check pipeline including linting, type checking, tests, and coverage verification. Essential command before commits and PRs.",
+      "whatItDoes": [
+        "Runs linting (ESLint/Biome)",
+        "Performs TypeScript type checking",
+        "Executes test suites with coverage",
+        "Validates coverage thresholds",
+        "Reports all issues in summary"
+      ],
+      "whenToUse": "Before every commit and PR. Essential for maintaining code quality.",
+      "skillLevel": "beginner",
+      "relatedModules": ["code-check", "run-tests"]
+    },
+    {
+      "id": "code-check",
+      "name": "Code Check",
+      "description": "Run code analysis, linting, and formatting checks",
+      "file": "code-check.md",
+      "tags": ["core", "linting", "formatting"],
+      "longDescription": "Focused code analysis command that runs linting, formatting checks, and static analysis. Faster than full quality check for quick validation.",
+      "whatItDoes": [
+        "Runs linter with auto-fix option",
+        "Checks code formatting",
+        "Performs static analysis",
+        "Identifies code smells",
+        "Suggests improvements"
+      ],
+      "whenToUse": "During development for quick code quality feedback. Faster than full quality-check.",
+      "skillLevel": "beginner",
+      "relatedModules": ["quality-check"]
+    },
+    {
+      "id": "run-tests",
+      "name": "Run Tests",
+      "description": "Execute test suites with various options",
+      "file": "run-tests.md",
+      "tags": ["core", "testing", "vitest"],
+      "longDescription": "Flexible test runner command supporting unit tests, integration tests, watch mode, coverage, and filtering. Works with Vitest and Jest.",
+      "whatItDoes": [
+        "Runs unit and integration tests",
+        "Supports watch mode for TDD",
+        "Generates coverage reports",
+        "Filters tests by name/path",
+        "Runs tests in parallel"
+      ],
+      "whenToUse": "During TDD workflow, before commits, or when validating changes.",
+      "techStack": ["Vitest", "Jest", "Testing Library"],
+      "skillLevel": "beginner",
+      "relatedModules": ["quality-check", "tdd-methodology"]
+    },
+    {
+      "id": "security-audit",
+      "name": "Security Audit",
+      "description": "Comprehensive security audit for vulnerabilities",
+      "file": "audit/security-audit.md",
+      "tags": ["audit", "security", "owasp"],
+      "longDescription": "Deep security review covering OWASP Top 10, dependency vulnerabilities, authentication, authorization, and data handling.",
+      "whatItDoes": [
+        "Audits for OWASP Top 10 vulnerabilities",
+        "Scans dependencies for CVEs",
+        "Reviews authentication flows",
+        "Checks data handling practices",
+        "Generates security report"
+      ],
+      "whenToUse": "Before production deployment or during security reviews.",
+      "skillLevel": "advanced",
+      "relatedModules": ["security-testing", "security-audit"]
+    },
+    {
+      "id": "performance-audit",
+      "name": "Performance Audit",
+      "description": "Performance analysis and optimization recommendations",
+      "file": "audit/performance-audit.md",
+      "tags": ["audit", "performance", "optimization"],
+      "longDescription": "Performance audit covering Core Web Vitals, bundle analysis, database queries, and rendering performance.",
+      "whatItDoes": [
+        "Analyzes Core Web Vitals",
+        "Reviews bundle size",
+        "Identifies N+1 queries",
+        "Checks rendering performance",
+        "Provides optimization recommendations"
+      ],
+      "whenToUse": "Before major launches or when investigating performance issues.",
+      "skillLevel": "intermediate",
+      "relatedModules": ["performance-testing", "performance-audit"]
+    },
+    {
+      "id": "accessibility-audit",
+      "name": "Accessibility Audit",
+      "description": "WCAG compliance audit for accessibility",
+      "file": "audit/accessibility-audit.md",
+      "tags": ["audit", "accessibility", "wcag"],
+      "longDescription": "Accessibility audit following WCAG 2.1 Level AA guidelines. Covers keyboard navigation, screen readers, and color contrast.",
+      "whatItDoes": [
+        "Audits WCAG 2.1 compliance",
+        "Tests keyboard navigation",
+        "Validates screen reader compatibility",
+        "Checks color contrast",
+        "Reviews ARIA usage"
+      ],
+      "whenToUse": "Before releases and after UI changes.",
+      "skillLevel": "intermediate",
+      "relatedModules": ["accessibility-audit", "ux-ui-designer"]
+    },
+    {
+      "id": "start-feature-plan",
+      "name": "Start Feature Plan",
+      "description": "Initialize Level 3 feature planning workflow",
+      "file": "start-feature-plan.md",
+      "tags": ["planning", "features", "workflow"],
+      "longDescription": "Initiates the Level 3 feature planning workflow for complex, multi-day features. Creates planning session, coordinates agents, and produces PDR, tech analysis, and task breakdown.",
+      "whatItDoes": [
+        "Creates planning session directory",
+        "Invokes Product Functional for PDR",
+        "Invokes Product Technical for architecture",
+        "Generates task breakdown",
+        "Coordinates with relevant agents"
+      ],
+      "whenToUse": "When starting complex features that need planning, architecture review, and task breakdown.",
+      "skillLevel": "intermediate",
+      "relatedModules": ["product-functional", "product-technical", "tech-lead"]
+    },
+    {
+      "id": "start-refactor-plan",
+      "name": "Start Refactor Plan",
+      "description": "Initialize refactoring planning session",
+      "file": "start-refactor-plan.md",
+      "tags": ["planning", "refactoring", "workflow"],
+      "longDescription": "Initiates a planning session for refactoring work. Analyzes current state, identifies improvement areas, and creates safe refactoring plan with tests.",
+      "whatItDoes": [
+        "Analyzes code for refactoring",
+        "Identifies code smells and issues",
+        "Plans safe refactoring steps",
+        "Ensures test coverage exists",
+        "Coordinates with QA for validation"
+      ],
+      "whenToUse": "When planning significant refactoring that affects multiple files or modules.",
+      "skillLevel": "intermediate",
+      "relatedModules": ["tech-lead", "qa-engineer"]
+    },
+    {
+      "id": "sync-planning",
+      "name": "Sync Planning",
+      "description": "Synchronize planning documents to issue tracker",
+      "file": "sync-planning.md",
+      "tags": ["planning", "sync", "github", "linear"],
+      "longDescription": "Synchronizes planning documents (PDR, tech analysis, TODOs) to issue trackers like GitHub Issues or Linear. Creates linked issues from task breakdown.",
+      "whatItDoes": [
+        "Parses TODOs.md for tasks",
+        "Creates issues in tracker",
+        "Links issues to planning docs",
+        "Updates task status",
+        "Syncs bidirectionally"
+      ],
+      "whenToUse": "After planning approval to create trackable issues from the task breakdown.",
+      "skillLevel": "intermediate",
+      "relatedModules": ["start-feature-plan"]
+    },
+    {
+      "id": "sync-planning-github",
+      "name": "Sync Planning to GitHub",
+      "description": "Sync planning to GitHub Issues",
+      "file": "planning/sync-planning-github.md",
+      "tags": ["planning", "github", "issues"],
+      "longDescription": "Syncs planning documents specifically to GitHub Issues. Creates issues with proper labels, milestones, and project board integration.",
+      "whatItDoes": [
+        "Creates GitHub Issues from tasks",
+        "Applies labels and milestones",
+        "Links to project boards",
+        "Updates issue status",
+        "Handles issue comments"
+      ],
+      "whenToUse": "When using GitHub Issues for task tracking.",
+      "skillLevel": "intermediate",
+      "relatedModules": ["sync-planning"]
+    },
+    {
+      "id": "sync-todos-github",
+      "name": "Sync TODOs to GitHub",
+      "description": "Sync TODO comments to GitHub Issues",
+      "file": "planning/sync-todos-github.md",
+      "tags": ["planning", "github", "todos"],
+      "longDescription": "Scans codebase for TODO comments and creates/updates GitHub Issues. Tracks technical debt and pending work items.",
+      "whatItDoes": [
+        "Scans code for TODO comments",
+        "Creates issues for new TODOs",
+        "Updates existing issues",
+        "Links issues to code locations",
+        "Reports on technical debt"
+      ],
+      "whenToUse": "To track and manage TODO comments in the codebase.",
+      "skillLevel": "beginner",
+      "relatedModules": ["sync-planning-github"]
+    },
+    {
+      "id": "check-completed-tasks",
+      "name": "Check Completed Tasks",
+      "description": "Auto-detect and mark completed tasks",
+      "file": "planning/check-completed-tasks.md",
+      "tags": ["planning", "automation", "tracking"],
+      "longDescription": "Automatically detects completed tasks by analyzing code changes and test results. Updates task status in tracking systems.",
+      "whatItDoes": [
+        "Analyzes recent commits",
+        "Detects completed tasks",
+        "Updates task status",
+        "Reports completion status",
+        "Suggests next tasks"
+      ],
+      "whenToUse": "Periodically to keep task tracking in sync with actual progress.",
+      "skillLevel": "beginner",
+      "relatedModules": ["sync-planning"]
+    },
+    {
+      "id": "planning-cleanup",
+      "name": "Planning Cleanup",
+      "description": "Clean up planning artifacts after completion",
+      "file": "planning/planning-cleanup.md",
+      "tags": ["planning", "cleanup", "maintenance"],
+      "longDescription": "Cleans up planning artifacts after a feature is complete. Archives planning docs, closes issues, and updates project state.",
+      "whatItDoes": [
+        "Archives planning documents",
+        "Closes related issues",
+        "Updates project board",
+        "Generates completion summary",
+        "Cleans up temporary files"
+      ],
+      "whenToUse": "After a feature is fully deployed and verified.",
+      "skillLevel": "beginner",
+      "relatedModules": ["sync-planning"]
+    },
+    {
+      "id": "cleanup-issues",
+      "name": "Cleanup Issues",
+      "description": "Clean up stale and outdated issues",
+      "file": "planning/cleanup-issues.md",
+      "tags": ["planning", "cleanup", "issues"],
+      "longDescription": "Identifies and cleans up stale issues. Closes abandoned issues, labels inactive ones, and generates cleanup reports.",
+      "whatItDoes": [
+        "Identifies stale issues",
+        "Closes abandoned issues",
+        "Labels inactive issues",
+        "Generates cleanup report",
+        "Notifies stakeholders"
+      ],
+      "whenToUse": "Periodically for issue hygiene and project maintenance.",
+      "skillLevel": "beginner",
+      "relatedModules": ["sync-planning-github"]
+    },
+    {
+      "id": "add-new-entity",
+      "name": "Add New Entity",
+      "description": "Generate full CRUD entity (model, service, API, tests)",
+      "file": "add-new-entity.md",
+      "tags": ["development", "entities", "scaffolding"],
+      "longDescription": "Scaffolds a complete entity with database model, service layer, API endpoints, and tests. Follows project conventions and architecture patterns.",
+      "whatItDoes": [
+        "Creates database schema/model",
+        "Generates service layer with CRUD",
+        "Creates API endpoints",
+        "Generates unit and integration tests",
+        "Adds validation schemas"
+      ],
+      "whenToUse": "When adding new data entities that need full CRUD operations.",
+      "skillLevel": "intermediate",
+      "relatedModules": ["db-drizzle-engineer", "hono-engineer", "qa-engineer"]
+    },
+    {
+      "id": "update-docs",
+      "name": "Update Docs",
+      "description": "Update project documentation after changes",
+      "file": "update-docs.md",
+      "tags": ["development", "documentation"],
+      "longDescription": "Analyzes code changes and updates relevant documentation including README, API docs, architecture diagrams, and changelog.",
+      "whatItDoes": [
+        "Identifies affected documentation",
+        "Updates API documentation",
+        "Refreshes README sections",
+        "Updates architecture diagrams",
+        "Adds changelog entries"
+      ],
+      "whenToUse": "After implementing features or making changes that affect documentation.",
+      "skillLevel": "beginner",
+      "relatedModules": ["tech-writer", "markdown-formatter"]
+    },
+    {
+      "id": "five-why",
+      "name": "Five Why Analysis",
+      "description": "Root cause analysis using Five Why method",
+      "file": "five-why.md",
+      "tags": ["development", "analysis", "debugging"],
+      "longDescription": "Systematic root cause analysis using the Five Why methodology. Helps identify underlying causes of bugs, issues, or failures.",
+      "whatItDoes": [
+        "Guides through Five Why questions",
+        "Documents cause chain",
+        "Identifies root cause",
+        "Suggests preventive measures",
+        "Creates action items"
+      ],
+      "whenToUse": "When debugging complex issues or after incidents to prevent recurrence.",
+      "skillLevel": "intermediate",
+      "relatedModules": ["debugger"]
+    },
+    {
+      "id": "commit",
+      "name": "Commit",
+      "description": "Create atomic git commits with conventional messages",
+      "file": "git/commit.md",
+      "tags": ["git", "commits", "core"],
+      "longDescription": "Creates atomic git commits following conventional commit format. Ensures only task-related files are included and generates proper commit messages.",
+      "whatItDoes": [
+        "Reviews staged changes",
+        "Validates atomic commit scope",
+        "Generates conventional message",
+        "Handles breaking changes",
+        "Runs pre-commit checks"
+      ],
+      "whenToUse": "When committing changes. Ensures atomic commits and proper message format.",
+      "skillLevel": "beginner",
+      "relatedModules": ["git-commit-helper"]
+    },
+    {
+      "id": "format-markdown",
+      "name": "Format Markdown",
+      "description": "Format and lint markdown files",
+      "file": "formatting/format-markdown.md",
+      "tags": ["formatting", "markdown", "docs"],
+      "longDescription": "Formats markdown files following consistent style guidelines. Checks for formatting issues, broken links, and style violations.",
+      "whatItDoes": [
+        "Formats markdown consistently",
+        "Fixes heading hierarchy",
+        "Validates link references",
+        "Standardizes list formatting",
+        "Ensures code block languages"
+      ],
+      "whenToUse": "Before committing documentation changes or when cleaning up markdown files.",
+      "skillLevel": "beginner",
+      "relatedModules": ["markdown-formatter", "tech-writer"]
+    },
+    {
+      "id": "create-agent",
+      "name": "Create Agent",
+      "description": "Create a new specialized agent",
+      "file": "meta/create-agent.md",
+      "tags": ["meta", "agents", "creation"],
+      "longDescription": "Creates a new specialized agent with proper structure, configuration, and documentation. Follows the standard agent template.",
+      "whatItDoes": [
+        "Creates agent markdown file",
+        "Adds YAML frontmatter",
+        "Generates configuration section",
+        "Creates standard structure",
+        "Updates registry"
+      ],
+      "whenToUse": "When adding new capabilities that require a specialized agent.",
+      "skillLevel": "advanced",
+      "relatedModules": ["create-command", "create-skill"]
+    },
+    {
+      "id": "create-command",
+      "name": "Create Command",
+      "description": "Create a new workflow command",
+      "file": "meta/create-command.md",
+      "tags": ["meta", "commands", "creation"],
+      "longDescription": "Creates a new command with proper structure, configuration, and documentation. Follows the standard command template.",
+      "whatItDoes": [
+        "Creates command markdown file",
+        "Adds YAML frontmatter",
+        "Generates configuration section",
+        "Creates execution flow",
+        "Updates registry"
+      ],
+      "whenToUse": "When adding new workflow automation commands.",
+      "skillLevel": "advanced",
+      "relatedModules": ["create-agent", "create-skill"]
+    },
+    {
+      "id": "create-skill",
+      "name": "Create Skill",
+      "description": "Create a new reusable skill",
+      "file": "meta/create-skill.md",
+      "tags": ["meta", "skills", "creation"],
+      "longDescription": "Creates a new skill with proper structure, configuration, and documentation. Follows the standard skill template.",
+      "whatItDoes": [
+        "Creates skill markdown file",
+        "Adds YAML frontmatter",
+        "Generates configuration section",
+        "Creates standard structure",
+        "Updates registry"
+      ],
+      "whenToUse": "When adding new reusable knowledge or patterns.",
+      "skillLevel": "advanced",
+      "relatedModules": ["create-agent", "create-command"]
+    },
+    {
+      "id": "help",
+      "name": "Help",
+      "description": "Show available commands, agents, and documentation",
+      "file": "meta/help.md",
+      "tags": ["meta", "help", "reference"],
+      "longDescription": "Displays help information about available commands, agents, skills, and documentation. Provides quick reference for the AI assistant system.",
+      "whatItDoes": [
+        "Lists available commands",
+        "Shows agent descriptions",
+        "Displays skill references",
+        "Links to documentation",
+        "Provides usage examples"
+      ],
+      "whenToUse": "When unsure what commands are available or how to use the system.",
+      "skillLevel": "beginner",
+      "relatedModules": []
+    }
+  ]
+}

package/templates/commands/add-new-entity.md

@@ -0,0 +1,211 @@
+---
+name: add-new-entity
+description: Structured workflow for adding new domain entities following architecture patterns
+type: development
+category: workflow
+config_required:
+  - layer_structure: "Define layer architecture (e.g., Database → Service → API → Frontend)"
+  - entity_patterns: "Specify entity naming and file organization patterns"
+  - test_framework: "Configure testing framework and coverage requirements"
+  - file_locations: "Define base paths for schemas, models, services, routes"
+---
+
+# Add New Entity Command
+
+## Purpose
+
+Orchestrates complete implementation of new domain entities following established architecture patterns. Creates necessary files across all layers, ensures pattern consistency, and maintains comprehensive testing.
+
+## ⚙️ Configuration
+
+| Setting | Description | Example |
+|---------|-------------|---------|
+| `layer_structure` | Define application layers | `Database → Service → API → Frontend` |
+| `entity_patterns` | Entity naming conventions | `PascalCase entities, snake_case tables` |
+| `test_framework` | Testing setup | `Vitest, Jest, etc.` |
+| `coverage_minimum` | Minimum test coverage | `90%` |
+| `base_paths.schemas` | Schema file location | `packages/schemas/src/` |
+| `base_paths.models` | Model file location | `packages/db/src/models/` |
+| `base_paths.services` | Service file location | `packages/services/src/` |
+| `base_paths.routes` | Route file location | `apps/api/src/routes/` |
+
+## Usage
+
+```bash
+/add-new-entity {entity_name}
+```
+
+## Execution Flow
+
+### Phase 1: Planning
+
+**Agent**: `product-technical`
+
+1. Analyze entity requirements and relationships
+2. Design database schema
+3. Plan API endpoints and service methods
+4. Define validation rules and business logic
+
+**Deliverables**: Entity design document
+
+### Phase 2: Implementation (TDD)
+
+**Layer 1: Database**
+
+- Agent: `db-engineer`
+- Files: Schema definition, model class, migration
+- Tests: Model CRUD operations
+
+**Layer 2: Service**
+
+- Agent: Backend specialist
+- Files: Validation schemas, service class
+- Tests: Business logic, edge cases
+
+**Layer 3: API**
+
+- Agent: API specialist
+- Files: Route definitions, endpoint handlers
+- Tests: API endpoints, authentication
+
+**Layer 4: Frontend**
+
+- Agent: Frontend specialist
+- Files: Components, hooks, pages
+- Tests: Component behavior, integration
+
+### Phase 3: Validation
+
+**Quality Checks**:
+
+- Code quality: `/quality-check`
+- Test coverage: ≥ configured minimum
+- Security review
+- Performance analysis
+
+**Integration Testing**:
+
+- End-to-end workflows
+- Error scenarios
+- Acceptance criteria
+
+### Phase 4: Finalization
+
+**Documentation**:
+
+- API endpoint documentation
+- Component usage examples
+- Integration guides
+
+**Review**:
+
+- Architecture consistency
+- Pattern compliance
+- Code quality approval
+
+## Entity Implementation Pattern
+
+### Required Files Structure
+
+```text
+{base_paths.schemas}/{entity}/
+├── create.schema.ts
+├── update.schema.ts
+└── index.ts
+
+{base_paths.models}/
+└── {entity}.model.ts
+
+{base_paths.services}/{entity}/
+├── {entity}.service.ts
+└── index.ts
+
+{base_paths.routes}/{entity}/
+└── index.ts
+```
+
+### Pattern Requirements
+
+- Extend base classes where available
+- Follow project naming conventions
+- Implement proper error handling
+- Include comprehensive validation
+
+## Quality Standards
+
+### Code Quality
+
+- Type safety: Strict TypeScript
+- Testing: ≥ configured coverage minimum
+- Patterns: Consistent with existing code
+- Documentation: Complete API docs
+
+### Architecture
+
+- Clear layer separation
+- Proper error handling patterns
+- Comprehensive input validation
+- Authentication/authorization implemented
+
+## Output Format
+
+```text
+✅ NEW ENTITY IMPLEMENTATION COMPLETE
+
+Entity: {EntityName}
+Layers: {count} implemented
+
+📊 Summary:
+✅ Database: Schema, model, migration
+✅ Service: Business logic, {coverage}% coverage
+✅ API: {count} endpoints
+✅ Frontend: {count} components
+
+📋 Files Created: {count}
+Database: {list}
+Service: {list}
+API: {list}
+Frontend: {list}
+
+📈 Quality Metrics:
+✅ Coverage: {percentage}%
+✅ Type Safety: 100%
+✅ Performance: {metrics}
+```
+
+## Related Commands
+
+- `/start-feature-plan` - Complex entity planning
+- `/quality-check` - Entity validation
+- `/update-docs` - Documentation updates
+
+## When to Use
+
+- Adding new domain concepts
+- Extending data model
+- Implementing entity-centric features
+- Adding new data structures
+
+## Prerequisites
+
+- Entity requirements defined
+- Relationships identified
+- Business rules documented
+- Design completed
+
+## Best Practices
+
+### Implementation Order
+
+1. Database schema (foundation)
+2. Model layer (data access)
+3. Service layer (business logic)
+4. API layer (external interface)
+5. Frontend layer (user interface)
+
+### Testing Strategy
+
+- Unit tests: Each layer independently
+- Integration tests: Layer interactions
+- API tests: Endpoint behavior
+- E2E tests: Complete workflows