ai-qakit 1.0.0

package/templates/.claude/commands/devkit/spec/update-requirement.md

@@ -0,0 +1,239 @@
+---
+description: Update existing task requirements with new content or changes
+argument-hint: "[task-id] [new requirement or changes]"
+allowed-tools: Read, Write, Edit, Bash, Grep, AskUserQuestion, Skill
+---
+
+<!--
+Usage: /spec:update-requirement [task-id] [content]
+Example: /spec:update-requirement ABC-123 Add validation for email field with regex pattern
+Example: /spec:update-requirement ABC-123 Change: Button should be red instead of blue
+Requires: Task must exist with requirements in ./.claude/tasks/[task-id]/requirements/
+
+This command UPDATES existing requirements with new content or changes.
+For initial requirement capture, use /devkit:spec:capture-requirement instead.
+-->
+
+## Your Mission
+
+Update requirements for an existing task by adding new requirements or modifying existing ones based on user-provided content, then regenerate the consolidated requirement files.
+
+---
+
+## Phase 1: Parse Arguments & Validate
+
+**Arguments format:** `[task-id] [content]`
+- First word = task-id
+- Everything after = new requirement or change content
+
+1. Parse `$ARGUMENTS` to extract task-id (first word) and content (remaining text)
+2. If task-id not provided, use `AskUserQuestion` to ask for it
+3. If content not provided, use `AskUserQuestion` to ask: "What requirement would you like to add or change?"
+4. Validate `./.claude/tasks/[task-id]/` directory exists
+5. If not found, return error: "Task not found. Run `/devkit:spec:task` first."
+6. Verify `./.claude/tasks/[task-id]/requirements/` exists and has content
+7. If requirements folder is empty or missing, return error: "No requirements found. Run `/devkit:spec:capture-requirement` first."
+
+---
+
+## Phase 2: Read Existing Requirements
+
+Read ALL files in `./.claude/tasks/[task-id]/requirements/`:
+
+```bash
+ls -la ./.claude/tasks/[task-id]/requirements/
+```
+
+For each file found, read and understand:
+- Current functional requirements
+- Existing constraints and limitations
+- Previous decisions and notes
+
+---
+
+## Phase 3: Analyze & Apply Changes
+
+Analyze the user-provided content to determine the type of update:
+
+### Change Types
+
+| Prefix/Pattern | Action |
+|----------------|--------|
+| `Add:` or new requirement | Add as new requirement with next available FR-ID |
+| `Change:` or `Update:` | Modify existing requirement |
+| `Remove:` or `Delete:` | Mark requirement as removed/deprecated |
+| `Clarify:` | Add acceptance criteria or details |
+| No prefix | Treat as new requirement addition |
+
+### Processing Rules
+
+1. **For new requirements:**
+   - Generate next FR-ID (FR-XXX)
+   - Add to appropriate category in `01-functional.md`
+   - Mark as `[ ]` (pending)
+
+2. **For changes to existing:**
+   - Find matching requirement by ID or description
+   - Update the requirement text
+   - Preserve the original ID
+   - Add change note to `10-notes.md`
+
+3. **For removals:**
+   - Mark as `[x] REMOVED:` with reason
+   - Add removal note to `10-notes.md`
+
+4. **For clarifications:**
+   - Add to existing requirement's acceptance criteria
+   - Do not create new requirement
+
+---
+
+## Phase 4: Regenerate Output Files
+
+### File 1: `01-functional.md`
+
+Update the functional requirements file with the changes:
+
+```markdown
+# Functional Requirements
+
+## Overview
+[Brief summary of what the task/feature does]
+
+## Requirements
+
+### [Category 1]
+- [ ] FR-001: [Requirement description]
+  - Acceptance: [criteria]
+- [ ] FR-002: [Requirement description]
+  - Acceptance: [criteria]
+
+### [Category 2]
+- [ ] FR-003: [Requirement description]
+  - Acceptance: [criteria]
+
+## Non-Functional Requirements
+- [ ] NFR-001: [Performance/Security/Scalability requirement]
+- [ ] NFR-002: [Performance/Security/Scalability requirement]
+
+## Out of Scope
+- [What is explicitly NOT included]
+```
+
+### File 2: `10-notes.md`
+
+Update with change log entry:
+
+```markdown
+# Requirements Notes
+
+## Decisions
+| Decision | Rationale | Date |
+|----------|-----------|------|
+| [Decision 1] | [Why] | [When] |
+
+## Constraints
+- [Constraint 1]
+- [Constraint 2]
+
+## Risks
+| Risk | Impact | Mitigation |
+|------|--------|------------|
+| [Risk 1] | [Impact] | [How to mitigate] |
+
+## Dependencies
+- [Dependency 1]
+- [Dependency 2]
+
+## Questions Resolved
+| Question | Decision | Date |
+|----------|----------|------|
+| [Question 1] | [Answer] | [When] |
+
+## Change Log
+| Date | Change | Reason |
+|------|--------|--------|
+| [Today] | [Description of change applied] | User update via /spec:update-requirement |
+```
+
+---
+
+## Phase 5: Write Output Files
+
+1. Write updated `01-functional.md` to `./.claude/tasks/[task-id]/requirements/01-functional.md`
+2. Write updated `10-notes.md` to `./.claude/tasks/[task-id]/requirements/10-notes.md`
+
+**Rules:**
+- Preserve existing requirement IDs
+- Update status if change affects implementation
+- Always add change log entry for traceability
+- Keep requirements testable and specific
+
+---
+
+## Phase 6: Resolve Open Questions
+
+**IMPORTANT:** Before completing, ALL open questions MUST be resolved.
+
+1. **Check for open questions** found in requirement files
+2. **If questions exist:**
+   - Use `AskUserQuestion` tool to ask user about each question
+   - Present options when applicable with recommendation
+   - Update `10-notes.md` with decisions
+   - Update `01-functional.md` if answers affect requirements
+   - Repeat until no open questions remain
+
+3. **Resolution loop:**
+   ```
+   WHILE open_questions.length > 0:
+     - Pick the most critical question
+     - Use AskUserQuestion with clear options
+     - Record decision in 10-notes.md
+     - Update functional requirements if needed
+     - Remove question from open list
+   ```
+
+4. **Only proceed to summary when ALL questions are resolved**
+
+---
+
+## Phase 7: Summary
+
+```
+════════════════════════════════════════════════════════════════════
+            ✅ REQUIREMENTS UPDATED: [task-id]
+════════════════════════════════════════════════════════════════════
+
+CHANGE APPLIED:
+  📝 [Summary of the change/addition made]
+
+CHANGE TYPE:
+  [ADD | CHANGE | REMOVE | CLARIFY]
+
+AFFECTED REQUIREMENTS:
+  - [FR-XXX]: [Brief description]
+
+FILES UPDATED:
+  📄 requirements/01-functional.md
+  📄 requirements/10-notes.md
+
+NEXT STEPS:
+  1. Review updated requirements in ./.claude/tasks/[task-id]/requirements/
+  2. Run `/devkit:spec:plan [task-id]` to update implementation plan (if needed)
+
+Need more changes? Run:
+  → /devkit:spec:update-requirement [task-id] [more changes]
+
+════════════════════════════════════════════════════════════════════
+```
+
+---
+
+## Important Notes
+
+- This command **UPDATES** existing requirements with new content or changes
+- For initial requirement capture, use `/devkit:spec:capture-requirement` instead
+- All changes are logged in `10-notes.md` for traceability
+- Requirement IDs are preserved when updating existing requirements
+- Use clear prefixes (`Add:`, `Change:`, `Remove:`, `Clarify:`) for explicit intent
+- **MUST resolve ALL open questions using AskUserQuestion before completing**

package/templates/.claude/commands/devkit/spec-lite/do.md

@@ -0,0 +1,280 @@
+---
+description: Implement all phases of a lite task (use /spec:test for testing)
+argument-hint: [task-id]
+allowed-tools: Read, Write, Edit, Bash, AskUserQuestion, Glob, Grep, Task, Skill
+---
+
+<!--
+Usage: /devkit:spec-lite:do [task-id]
+Example: /devkit:spec-lite:do fix-login-bug
+Example: /devkit:spec-lite:do add-logout
+Requires: Task with plan in ./.claude/tasks/[task-id]/plan.md
+-->
+
+**MUST READ** `CLAUDE.md` to understand orchestration rules before proceeding.
+
+Activate relevant skills based on task type:
+- `backend-development` for backend tasks
+- `frontend-development` for frontend tasks
+- `code-review` for review phase
+
+## Your Mission
+
+Implement lite task: **$ARGUMENTS**
+
+Execute all phases in ONE session. This is for SMALL tasks.
+
+**DO NOT create any tests** (unit tests, integration tests, E2E tests). Testing is handled separately via `/devkit:spec-lite:test` command.
+
+## Available Sub-Agents
+
+| Agent | Use For |
+|-------|---------|
+| `coder` | Implementation (auto-activates skills based on task type) |
+| `code-reviewer` | Review code quality |
+| `project-manager` | Update task status |
+
+**Note:** The `coder` agent has a built-in Skill Selection Matrix and will automatically activate appropriate skills (frontend-development, backend-development, databases, typescript-pro, ui-ux-pro-max, etc.) based on task context.
+
+**Note:** Testing is handled separately via `/devkit/spec-lite/test` command.
+
+## Pre-Implementation Check (Active Task Detection)
+
+Before starting, check for existing active task:
+
+1. **Check active-task file:** If `./.claude/active-task` exists:
+   - Read the path from file
+   - If task-id matches or not provided: use active task
+   - If different task-id provided: update active-task file
+
+2. **If no task-id provided and no active task:** Use `AskUserQuestion` tool to ask user for task-id
+
+## Workflow
+
+### Step 0: Setup & Validation
+
+#### Step 0.1: Sub-Agent Report Preference (MANDATORY)
+
+**Before spawning ANY sub-agent**, you MUST ask user about report preference:
+
+Use `AskUserQuestion` tool:
+```
+question: "How should sub-agent reports be delivered?"
+header: "Report Style"
+options:
+  - label: "Inline Report (Recommended)"
+    description: "Brief summary displayed in conversation, no file saved"
+  - label: "Detailed Report"
+    description: "Full analysis saved to ./.claude/tasks/[TASK-ID]/reports/"
+```
+
+**Pass preference to ALL sub-agent prompts:**
+- Inline selected → Add `generate_report: false` to prompt
+- Detailed selected → Add `generate_report: true` to prompt
+
+**IMPORTANT:** Do NOT spawn any sub-agent until this question is answered.
+
+#### Step 0.2: Validate Task
+
+1. If task-id not provided, check `./.claude/active-task` first
+2. Verify `./.claude/tasks/$ARGUMENTS/plan.md` exists
+3. If not found: "Plan not found. Run `/devkit:spec-lite:plan` first."
+
+### Step 1: Load Plan
+
+1. Read `plan.md` completely
+2. Read `requirements.md` for acceptance criteria
+3. Initialize TodoWrite with all phases and tasks
+
+**Output:** `✓ Step 1: Loaded plan with [N] phases`
+
+### Step 2: Implement All Phases
+
+**Use `coder` sub-agent** with Structured Context Protocol for skill detection:
+```
+Task(subagent_type="coder", prompt="
+---
+context:
+  task-id: [task-id]
+  platform: [frontend | backend | fullstack]
+  task-type: [ui, api, database, auth, etc.]
+  files: [list of files to create/modify]
+  technologies: [React, TypeScript, PostgreSQL, etc.]
+---
+
+Implement lite task [task-id].
+Plan: [plan summary]
+Phases to implement: [phase list]
+
+[task description summary]
+
+SKILL USAGE: Check <available_skills> and use Skill tool for matching tasks.
+", description="Implement phases")
+```
+
+For each phase (except final review phase):
+1. Mark phase as in_progress in TodoWrite
+2. Implement each task in the phase
+3. Mark tasks complete as done
+4. Run type checking to verify no syntax errors (only all phase are completed, run one time for all the file that generated across all the phases)
+5. **If NOT the last phase:** Use `AskUserQuestion` to ask user if they want to proceed:
+   ```
+   question: "Phase [phase-name] completed. Do you want to proceed to the next phase?"
+   header: "Next Phase"
+   options:
+     - label: "Yes, continue (Recommended)"
+       description: "Proceed to implement the next phase immediately"
+     - label: "No, stop here"
+       description: "Pause and return later with /devkit:spec-lite:do"
+   ```
+   - **"Yes, continue":** Proceed to next phase
+   - **"No, stop here":** Skip remaining phases, go to Step 3 (Code Review) with completed phases only
+
+**Output:** `✓ Step 2: Implemented [N] phases - [files modified]`
+
+### Step 3: Code Review (ONLY AFTER ALL PHASES COMPLETE)
+
+**CRITICAL:** Only trigger code review AFTER ALL phases in Step 2 are fully implemented. Do NOT review after each phase - review ALL files at once as a batch.
+
+**Verification before code review:**
+1. Confirm all phases from Step 2 are marked complete
+2. Run type checking and compile to verify no syntax errors
+3. **Start the app** to verify it runs without runtime errors:
+   - Frontend: `npm run dev` or equivalent - verify app loads without console errors
+   - Backend: `npm run start:dev` or equivalent - verify server starts and responds
+   - Fullstack: Verify both frontend and backend start successfully
+4. If startup fails: Fix the issue before proceeding to code review
+
+**MANDATORY: Collect ALL files before review:**
+1. Review the plan file to get the complete list of ALL phases
+2. For EACH phase, collect ALL files that were created or modified
+3. Compile a COMPLETE file list covering the ENTIRE task (not just 1-2 files)
+4. Pass this COMPLETE list to the code-reviewer
+
+**Use `code-reviewer` sub-agent** for batch review:
+```
+Task(subagent_type="code-reviewer", prompt="Review ALL code for lite task [task-id] across the ENTIRE plan.
+
+**COMPLETE FILE LIST (all phases):**
+- Phase 1: [list all files from phase 1]
+- Phase 2: [list all files from phase 2]
+- Phase N: [list all files from phase N]
+
+Review ALL [total count] files as a SINGLE batch - NOT one file at a time. Do NOT skip any files. Check against ./docs/code-standards.md and ./.claude/rules/index.md. Report critical issues only. SKILL USAGE: Check <available_skills> and use Skill tool for matching tasks.", description="Review all code")
+```
+
+**Output:** `✓ Step 3: Review [passed/N issues] - [total files] files reviewed, app starts successfully`
+
+### Step 4: User Approval
+
+**REQUIRED:** Before finalizing, get explicit user approval for the completed task.
+
+1. **Present Task Summary:**
+   - Files created/modified
+   - Key changes implemented
+   - Code review status
+
+2. **Request Approval:**
+   Use `AskUserQuestion`: "Task [task-id] implementation complete. Please review the changes and confirm:\n\n**Files Changed:** [list]\n**Key Changes:** [summary]\n**Code Review:** [status]\n\nApprove this task? (yes/no/feedback)"
+
+3. **Handle Response:**
+   - **"yes" or approval:** Proceed to Step 5
+   - **"no" or rejection:** STOP, ask for specific feedback, return to relevant step (2/3)
+   - **feedback provided:** Address feedback, re-run affected steps, request approval again
+
+**Output (waiting):** `⏸ Step 4: WAITING for approval`
+**Output (approved):** `✓ Step 4: User approved task [task-id]`
+
+**Validation:** User must explicitly approve. Do not proceed without approval.
+
+### Step 5: Finalize
+
+**Use `project-manager` sub-agent:**
+```
+Task(subagent_type="project-manager", prompt="Update lite task [task-id] status to Complete. Update plan.md phases to DONE. Update README.md status. Check <available_skills> and use Skill tool for matching tasks.", description="Update status")
+```
+
+### Step 6: Clear Active Task
+
+After successful completion:
+- Remove `./.claude/active-task` file OR
+- Update it to indicate completion
+
+**Output:** `✓ Step 5: Task [task-id] complete`
+
+### Step 7: Summary Report
+
+**IMPORTANT:** Only show this summary after ALL steps (1-6) are complete and user has approved (Step 4).
+
+```
+════════════════════════════════════════════════════════════════════
+                    ✅ LITE TASK COMPLETE
+════════════════════════════════════════════════════════════════════
+
+TASK: [task-id]
+STATUS: Implementation Complete
+
+IMPLEMENTED:
+  ✅ Phase 1: [name]
+  ✅ Phase 2: [name]
+  ✅ Phase 3: [name]
+  ✅ Phase 4: Code Review
+
+FILES MODIFIED:
+  • [file1] - [brief change]
+  • [file2] - [brief change]
+
+CODE REVIEW: Passed
+
+NEXT STEPS:
+  → Ready for testing: /devkit:spec-lite:test [task-id]
+  → After tests pass, commit your changes
+
+════════════════════════════════════════════════════════════════════
+```
+
+## Sub-Agent Usage Summary
+
+| Step | Agent | Purpose |
+|------|-------|---------|
+| Step 2 | `coder` | Implement all phases (auto-activates skills) |
+| Step 3 | `code-reviewer` | Review code quality (ONLY after ALL phases complete) |
+| Step 4 | `AskUserQuestion` | Get explicit user approval (REQUIRED) |
+| Step 5 | `project-manager` | Update task status |
+
+**Testing:** Use `/devkit:spec:test` command separately for comprehensive testing.
+
+## Critical Rules
+
+- **ALL PHASES IN ONE SESSION** - Complete all phases unless user chooses to stop
+- **ASK BEFORE NEXT PHASE** - After each phase (except last), ask user if they want to continue
+- **NO RESEARCH** - Use existing knowledge only
+- **NO TESTS** - Do not create unit/integration/E2E tests (use `/devkit:spec-lite:test` instead)
+- **VERIFY APP STARTS** - After implementation, verify app starts without errors before code review
+- **CODE REVIEW AFTER ALL PHASES** - Do NOT review after each phase, review ALL files as batch after ALL phases complete
+- **FOLLOW CODE STANDARDS** - Check ./docs/code-standards.md
+- **USER APPROVAL MANDATORY** - Do not proceed to Step 5 without explicit user approval
+- **SUB-AGENT SKILL INHERITANCE** - Include skill reminder in sub-agent prompts
+
+## Blocking Gates
+
+- **Step 3:** App must start successfully AND no critical code review issues
+- **Step 4:** User must explicitly approve (MANDATORY)
+- **Step 5:** project-manager must complete successfully
+
+## When to Use Full Spec Instead
+
+If during implementation you find:
+- Task is more complex than expected
+- Need research or external docs
+- More than 4 phases required
+
+Stop and suggest: "This task is too complex for lite spec. Use `/devkit:spec:plan` instead."
+
+## Important Notes
+
+- **CRITICAL:** Follow `./.claude/rules/index.md` for code quality standards
+- **CRITICAL:** Follow `./docs/development-rules.md` if exists
+- This is for SMALL tasks only
+- One session, all phases
+- Keep it simple - YAGNI, KISS, DRY