ai-qakit 1.0.0

package/templates/.claude/commands/devkit/config/bootstrap.md

@@ -0,0 +1,137 @@
+---
+description: Bootstrap a new project step by step
+argument-hint: [user-requirements]
+allowed-tools: Read, Write, MultiEdit, Bash, LS, Glob, Grep, WebSearch, WebFetch, Task, AskUserQuestion, Skill
+---
+
+**Report Protocol**: Follow ./.claude/CLAUDE.md "Sub-Agent Report Generation" protocol before spawning subagents.
+
+**Ultrathink** to plan & bootstrap a new project follow the Orchestration Protocol, Core Responsibilities, Subagents Team and Development Rules in your `CLAUDE.md` file: 
+
+---
+
+## User's Objectives & Requirements
+
+<user-requirements>$ARGUMENTS</user-requirements>
+
+---
+
+## Role Responsibilities
+
+- You are an elite software engineering expert who specializes in system architecture design and technical decision-making. 
+- Your core mission is to collaborate with users to find the best possible solutions while maintaining brutal honesty about feasibility and trade-offs, then collaborate with your subagents to implement the plan.
+- You operate by the holy trinity of software engineering: **YAGNI** (You Aren't Gonna Need It), **KISS** (Keep It Simple, Stupid), and **DRY** (Don't Repeat Yourself). Every solution you propose must honor these principles.
+
+---
+
+## Your Approach
+
+1. **Question Everything**: Use `AskUserQuestion` tool to ask probing questions to the user to fully understand the user's request, constraints, and true objectives. Don't assume - clarify until you're 100% certain.
+
+2. **Brutal Honesty**: Provide frank, unfiltered feedback about ideas. If something is unrealistic, over-engineered, or likely to cause problems, say so directly. Your job is to prevent costly mistakes.
+
+3. **Explore Alternatives**: Always consider multiple approaches. Present 2-3 viable solutions with clear pros/cons, explaining why one might be superior. Use `AskUserQuestion` tool to ask the user for their preferences.
+
+4. **Challenge Assumptions**: Question the user's initial approach. Often the best solution is different from what was originally envisioned. Use `AskUserQuestion` tool to ask the user for their preferences.
+
+5. **Consider All Stakeholders**: Evaluate impact on end users, developers, operations team, and business objectives.
+
+---
+
+## Workflow:
+
+Follow strictly these following steps:
+
+### Fullfill the request
+
+* If you have any questions, use `AskUserQuestion` tool to ask the user to clarify them.
+* Use `AskUserQuestion` tool to ask 1 question at a time, wait for the user to answer before moving to the next question.
+* If you don't have any questions, start the next step.
+
+**IMPORTANT:** Analyze the skills catalog and activate the skills that are needed for the task during the process.
+
+### Research
+
+* Use multiple `researcher` subagents in parallel to explore the user's request, idea validation, challenges, and find the best possible solutions.
+* Keep every research markdown report concise (≤150 lines) while covering all requested topics and citations.
+
+### Tech Stack
+
+1. Use `AskUserQuestion` tool to ask the user for any tech stack they want to use, if the user provides their tech stack, skip step 2-3.
+2. Use `planner` subagent and multiple `researcher` subagents in parallel to find a best fit tech stack for this project, keeping research reports within the ≤150 lines limit.
+3. Use `AskUserQuestion` tool to ask the user to review and approve the tech stack, if the user requests to change the tech stack, repeat the previous step until the user approves the tech stack
+4. Write the tech stack down in `./docs` directory
+
+### Planning
+
+* Use `planner` subagent to create a detailed implementation plan following the progressive disclosure structure:
+  - Create a directory `plans/{date}-plan-name` (date format from `$TASK_DATE_FORMAT`).
+  - Save the overview access point at `plan.md`, keep it generic, under 80 lines, and list each phase with status/progress and links.
+  - For each phase, add `phase-XX-phase-name.md` files containing sections (Context links, Overview with date/priority/statuses, Key Insights, Requirements, Architecture, Related code files, Implementation Steps, Todo list, Success Criteria, Risk Assessment, Security Considerations, Next steps).
+* Clearly explain the pros and cons of the plan.
+
+**IMPORTANT**: **Do not** start implementing immediately!
+* Use `AskUserQuestion` tool to ask the user to review and approve the plan, if the user requests to change the plan, repeat the previous step until the user approves the plan
+
+### Wireframe & Design
+
+* Use `AskUserQuestion` tool to ask the user if they want to create wireframes and design guidelines, if yes, continue to the next step, if no, skip to **"Implementation"** phase.
+* Use `ui-ux-designer` subagent and multiple `researcher` subagents in parallel to create a design plan that follows the same directory/phase structure described above, keeping related research reports within the ≤150 lines limit.
+   - **Research** about design style, trends, fonts, colors, border, spacing, elements' positions, etc.
+   - Describe details of the assets in the design so they can be generated with `ai-multimodal` skill later on.
+   - **IMPORTANT:** Try to predict the font name (Google Fonts) and font size in the given screenshot, don't just use **Inter** or **Poppins** fonts.
+* Then use `ui-ux-designer` subagent to create the design guidelines at `./docs/design-guidelines.md` file & generate wireframes in HTML at `./docs/wireframe` directory, make sure it's clear for developers to implement later on.
+* If there are no logo provided, use `ai-multimodal` skill to generate a logo.
+* Use `chrome-devtools` skill to take a screenshot of the wireframes and save it at `./docs/wireframes/` directory.
+* Use `AskUserQuestion` tool to ask the user to review and approve the design guidelines, if the user requests to change the design guidelines, repeat the previous step until the user approves the design guidelines.
+
+**REMEMBER**:
+- You can always generate images with `ai-multimodal` skill on the fly for visual assets.
+- You always read and analyze the generated assets with `ai-multimodal` skill to verify they meet requirements.
+- For image editing (removing background, adjusting, cropping), use `ImageMagick` skill or similar tools as needed.
+
+### Implementation
+
+* Use `general agent (main agent)` to implement the plan step by step, follow the implementation plan in `./plans` directory.
+* Use `ui-ux-designer` subagent to implement the frontend part follow the design guidelines at `./docs/design-guidelines.md` file.
+  * Use `ai-multimodal` skill to generate the assets.
+  * Use `ai-multimodal` (`video-analysis`, or `document-extraction`) skills to analyze the generated assets based on their format.
+  * Use `Background Removal Tool` to remove background from the assets if needed.
+  * Use `ai-multimodal` (`image-generation`) skill to edit the assets if needed.
+  * Use `imagemagick` skill to crop or resize the assets if needed.
+* Run type checking and compile the code command to make sure there are no syntax errors.
+
+### Testing
+
+* Write the tests for the plan, make sure you don't use fake data just to pass the tests, tests should be real and cover all possible cases.
+* Use `tester` subagent to run the tests, make sure it works, then report back to main agent.
+* If there are issues or failed tests, use `debugger` subagent to find the root cause of the issues, then ask main agent to fix all of them and 
+* Repeat the process until all tests pass or no more issues are reported. Again, do not ignore failed tests or use fake data just to pass the build or github actions.
+
+### Code Review
+
+* After finishing, delegate to `code-reviewer` subagent to review code. If there are critical issues, ask main agent to improve the code and tell `tester` agent to run the tests again. Repeat the process until all tests pass.
+* When all tests pass, code is reviewed, the tasks are completed, report back to user with a summary of the changes and explain everything briefly, use `AskUserQuestion` tool to ask user to review the changes and approve them.
+* **IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.
+
+### Documentation
+
+* If user approves the changes, use `docs-manager` subagent to update the docs if needed.
+  * Create/update `./docs/README.md` file (keep it concise, under 300 lines).
+  * Create/update `./docs/codebase-summary.md` file.
+  * Create/update `./docs/project-overview.-pdr.md` (Product Development Requirements) file.
+  * Create/update `./docs/code-standards.md` file.
+  * Create/update `./docs/system-architecture.md` file.
+* Use `project-manager` subagent to create a project roadmap at `./docs/project-roadmap.md` file & project progress and task status in the given plan file.
+* **IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.
+
+### Onboarding
+
+* Instruct the user to get started with the project.
+* Help the user to configure the project step by step, use `AskUserQuestion` tool to ask 1 question at a time, wait for the user to answer before moving to the next question.
+* If user requests to change the configuration, repeat the previous step until the user approves the configuration.
+
+### Final Report
+* Report back to user with a summary of the changes and explain everything briefly, guide user to get started and suggest the next steps.
+- **IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
+- **IMPORTANT:** In reports, list any unresolved questions at the end, if any.

package/templates/.claude/commands/devkit/config/init-backend.md

@@ -0,0 +1,233 @@
+---
+description: Initialize backend project commands based on generated documentation
+allowed-tools: Read, Grep, Bash, Write, Edit, AskUserQuestion, SlashCommand, Skill
+---
+
+**Report Protocol**: Follow ./.claude/CLAUDE.md "Sub-Agent Report Generation" protocol before spawning subagents.
+
+# Initialize Backend Project
+
+## Overview
+
+This command initializes backend-specific Claude commands by:
+1. Running `/docs:init` to generate project documentation
+2. Customizing all backend commands to match project conventions
+
+## Usage
+
+`/config:init-backend [optional context about the project]`
+
+## Context
+
+- Project context: $ARGUMENTS
+- This command relies on `/docs:init` to analyze the codebase
+- Then customizes backend commands based on generated docs
+
+---
+
+## Process
+
+### Phase 1: Generate Project Documentation
+
+Run the docs initialization command first:
+
+```
+/docs:init
+```
+
+Wait for `/docs:init` to complete before proceeding.
+
+---
+
+### Phase 2: Extract Project Configuration
+
+After docs are generated, read the following files to extract project configuration:
+
+1. **Read `./docs/codebase-summary.md`** - Extract:
+   - Test framework and test paths
+   - ORM/database migration tool
+   - API type (REST/GraphQL/Hybrid)
+   - File naming conventions
+   - Directory structure
+
+2. **Read `./docs/code-standards.md`** (if exists) - Extract:
+   - Coding conventions
+   - Naming patterns
+   - Project-specific patterns
+
+3. **Read `./docs/system-architecture.md`** (if exists) - Extract:
+   - Architecture patterns
+   - Module organization
+   - API design patterns
+
+---
+
+### Phase 3: Copy Backend Commands
+
+Copy backend commands from template folder to root commands folder:
+
+```bash
+# Copy backend commands to root level for direct access
+cp .claude/commands/backend/create-api.md .claude/commands/
+cp .claude/commands/backend/create-migration.md .claude/commands/
+cp .claude/commands/backend/create-schema.md .claude/commands/
+cp .claude/commands/backend/design-rest-api.md .claude/commands/
+cp .claude/commands/backend/design-graphql-api.md .claude/commands/
+```
+
+---
+
+### Phase 4: Detect API Type and Clean Up
+
+Based on documentation analysis:
+
+**If REST only (no GraphQL detected):**
+```bash
+rm -f .claude/commands/design-graphql-api.md
+```
+
+**If GraphQL only (no REST detected):**
+```bash
+rm -f .claude/commands/design-rest-api.md
+```
+
+**If Hybrid:** Keep both commands.
+
+---
+
+### Phase 5: Customize Commands
+
+Rewrite each command using the Edit/Write tool to match project-specific configuration:
+
+| Command | Customize For |
+|---------|---------------|
+| `create-test.md` | Detected test framework, actual test paths, coverage commands, naming conventions |
+| `create-migration.md` | Detected ORM, actual migration paths, migration commands |
+| `create-api.md` | Detected API type ONLY - remove references to other types |
+| `create-schema.md` | Detected ORM, actual entity paths, detected patterns |
+| `design-rest-api.md` | Project's REST conventions (if applicable) |
+| `design-graphql-api.md` | Project's GraphQL conventions (if applicable) |
+
+### Customization Guidelines
+
+For each command:
+
+1. **Read the copied command** from `.claude/commands/`
+2. **Extract project-specific values** from generated docs:
+   - Test framework and commands
+   - ORM and migration tool
+   - API type (REST/GraphQL)
+   - File naming conventions
+   - Directory structure
+3. **Rewrite the command** to include ONLY:
+   - The specific framework detected (remove all others)
+   - Actual directory paths from this project
+   - Actual commands from this project
+   - Reference to `./docs/` for context
+4. **Remove generic examples** and replace with project-specific ones
+
+### Example Customization
+
+**Before (generic create-test.md):**
+```markdown
+## Multi-Framework Support
+- Jest (JavaScript/TypeScript)
+- JUnit (Java)
+- Pytest (Python)
+- RSpec (Ruby)
+```
+
+**After (customized for NestJS project):**
+```markdown
+## Testing Framework: Jest
+
+Reference: `./docs/codebase-summary.md` for project conventions
+
+### Test Location
+- Tests: `src/**/*.spec.ts`
+- E2E: `test/*.e2e-spec.ts`
+
+### Commands
+```bash
+pnpm test              # Run unit tests
+pnpm test:cov          # Run with coverage
+pnpm test:e2e          # Run E2E tests
+```
+```
+
+---
+
+### Phase 6: Final Summary
+
+Display summary of customized commands:
+
+```
+════════════════════════════════════════════════════════════════════
+                    ✅ BACKEND INITIALIZATION COMPLETE
+════════════════════════════════════════════════════════════════════
+
+📝 CUSTOMIZED COMMANDS:
+   ✅ create-test.md       → [test framework] + actual paths
+   ✅ create-migration.md  → [ORM] + actual commands
+   ✅ create-api.md        → [API type] only
+   ✅ create-schema.md     → [ORM] + entity patterns
+
+🆕 API-SPECIFIC:
+   [✅/❌] design-rest-api.md
+   [✅/❌] design-graphql-api.md
+
+📂 DOCUMENTATION GENERATED:
+   ✅ ./docs/codebase-summary.md
+   ✅ ./docs/code-standards.md (if applicable)
+   ✅ ./docs/system-architecture.md (if applicable)
+
+════════════════════════════════════════════════════════════════════
+```
+
+---
+
+### Phase 7: Validation
+
+Use AskUserQuestion:
+- question: "Do you have any additional requirements or corrections for the customized commands?"
+- header: "Feedback"
+- options:
+  - No, everything looks good
+  - Yes, I have additional requirements
+
+**If "Yes":** Wait for input, update relevant commands, and ask again.
+
+**If "No":**
+
+```
+════════════════════════════════════════════════════════════════════
+                         🎉 SETUP COMPLETE!
+════════════════════════════════════════════════════════════════════
+
+🚀 QUICK START:
+   /create-schema User with email, name, password
+   /create-migration add users table
+   /create-api CRUD for users
+   /create-test src/modules/users/users.service.ts
+
+💡 All commands use YOUR project's actual paths, conventions, and tools.
+   Reference ./docs/ for project documentation.
+
+════════════════════════════════════════════════════════════════════
+```
+
+---
+
+## Begin Now
+
+Execute the phases in order:
+
+1. **Phase 1**: Run `/docs:init` to generate project documentation
+2. **Phase 2**: Read generated docs to extract project configuration
+3. **Phase 3**: Copy backend commands to root commands folder
+4. **Phase 4**: Clean up API-specific commands based on detected API type
+5. **Phase 5**: Customize all commands for this project's specific stack
+6. **Phase 6**: Display final summary
+7. **Phase 7**: Handle any additional requirements
+
+Use the appropriate tools (Bash, Read, Grep, Edit, Write) to complete the task. If anything is unclear, ask questions using AskUserQuestion.