ai-qakit 1.0.0

package/templates/.cursor/commands/devkit/spec/update-plan.md

@@ -0,0 +1,234 @@
+---
+description: Update an existing implementation plan with new requirements or modifications
+---
+
+# Update Plan
+
+Update an existing implementation plan with new requirements or modifications.
+
+## Usage
+
+`@spec/update-plan [task-id] [description of changes]`
+
+**Pathing rule:** Always use paths rooted at `./.cursor/...` (e.g., `./.cursor/tasks/ABC-123/plan/plan.md`).
+
+## Examples
+
+```
+@spec/update-plan ABC-123 Add caching layer for API responses
+@spec/update-plan AUTH-001 Include refresh token rotation
+```
+
+**Requires:** Task must exist with plan in `./.cursor/tasks/[task-id]/plan/`
+
+## Workflow
+
+### Phase 1: Parse Arguments
+
+1. **Extract from $ARGUMENTS:**
+   - `[task-id]` = first argument (e.g., `ABC-123`)
+   - `[description]` = remaining text (the modification/new requirement)
+
+2. **If task-id missing:**
+   - Check `./.cursor/active-task` first
+   - If not found, ask user for task-id
+
+3. **If description missing:**
+   - Ask user: "What changes or new requirements do you want to add to the plan?"
+
+### Phase 2: Validate
+
+1. Verify `./.cursor/tasks/[task-id]/` directory exists
+2. If not found: "Task not found. Run `@spec/task` first."
+3. Verify `./.cursor/tasks/[task-id]/plan/plan.md` exists
+4. If not found: "Plan not found. Run `@spec/plan` first."
+
+### Phase 3: Read Existing Plan
+
+1. **Read the main plan file:**
+   - Read `./.cursor/tasks/[task-id]/plan/plan.md`
+   - Extract metadata (platform, api-approach, etc.)
+   - Note current phases and their status
+
+2. **Read all phase files:**
+   - List all files in `./.cursor/tasks/[task-id]/plan/`
+   - Read each `phase-XX-*.md` file
+   - Identify completed/in-progress/pending phases
+
+3. **Read requirements (if needed):**
+   - Read `./.cursor/tasks/[task-id]/requirements/` for context
+
+### Phase 4: Analyze Change Request
+
+**Categorize the change type:**
+
+| Type | Description |
+|------|-------------|
+| **NEW_PHASE** | Adds entirely new functionality requiring new phase(s) |
+| **MODIFY_PHASE** | Changes existing phase scope or steps |
+| **REORDER** | Changes phase sequence or dependencies |
+| **REMOVE** | Removes or descopes a phase |
+| **REFINEMENT** | Clarifies or adds detail without structural change |
+
+**Impact assessment:**
+- Which existing phases are affected?
+- Are new phases needed?
+- Does this change dependencies between phases?
+- Does this affect the API approach (schema-first/code-first)?
+
+**Confirm with user:**
+- Present interpretation: "I understand you want to: [interpreted change]. Is this correct?"
+- Wait for confirmation before proceeding
+
+### Phase 5: Update Plan Files
+
+#### For NEW_PHASE changes:
+
+1. **Create new phase file(s):**
+   - Determine phase number (insert appropriately in sequence)
+   - Renumber existing phases if needed
+   - Create `phase-XX-new-phase-name.md` with:
+     - Context links
+     - Overview (date, description, priority, status)
+     - Key Insights
+     - Requirements references
+     - Architecture
+     - Related code files
+     - Implementation Steps
+     - Success Criteria
+     - Risks, Security, Next steps
+
+2. **Update `plan.md`:**
+   - Add new phase to phase list
+   - Update phase count
+   - Add change log entry
+
+#### For MODIFY_PHASE changes:
+
+1. **Update affected phase file(s):**
+   - Modify relevant sections
+   - Preserve completed steps
+   - Add new implementation steps
+   - Update success criteria
+   - Add modification note
+
+2. **Update `plan.md`:**
+   - Update phase description if scope changed
+   - Add change log entry
+
+#### For REORDER changes:
+
+1. **Renumber phase files:**
+   - Rename files with new numbers
+   - Update internal references
+   - Update dependencies
+
+2. **Update `plan.md`:**
+   - Reorder phase list
+   - Add change log entry
+
+#### For REMOVE changes:
+
+1. **Mark phase as descoped:**
+   - Do NOT delete the file
+   - Add `status: DESCOPED` to phase file
+   - Add reason for removal
+   - Optionally move to `./.cursor/tasks/[task-id]/plan/archive/`
+
+2. **Update `plan.md`:**
+   - Mark phase as descoped
+   - Update phase count
+   - Add change log entry
+
+#### For REFINEMENT changes:
+
+1. **Update phase file(s):**
+   - Add clarifying details
+   - Update implementation steps
+   - Add/modify success criteria
+
+2. **Update `plan.md`:**
+   - Add change log entry
+
+### Phase 6: Maintain Code Review Phase
+
+**CRITICAL:** Ensure the code review phase remains the FINAL phase.
+
+1. If new phases were added after code review, renumber code review to be last
+2. Update code review phase to include any new files from added phases
+3. Code review phase is NEVER removed or descoped
+
+### Phase 7: Update Change Log
+
+Add entry to `plan.md`:
+
+```markdown
+## Change Log
+
+| Date | Change Type | Description |
+|------|-------------|-------------|
+| [YYYY-MM-DD] | [NEW_PHASE/MODIFY_PHASE/etc.] | [Brief description] |
+```
+
+### Phase 8: Validate & Confirm
+
+1. **Validate plan integrity:**
+   - All phases properly numbered
+   - No gaps in sequence
+   - Dependencies consistent
+   - Code review is final phase
+   - All phase files exist and valid
+
+2. **Ask user to review changes**
+
+## Output
+
+```
+════════════════════════════════════════════════════════════════════
+                    📝 PLAN UPDATED
+════════════════════════════════════════════════════════════════════
+
+TASK: [task-id]
+CHANGE TYPE: [NEW_PHASE | MODIFY_PHASE | REORDER | REMOVE | REFINEMENT]
+
+MODIFICATION SUMMARY:
+  [Brief description of what was changed]
+
+FILES MODIFIED:
+  📄 ./.cursor/tasks/[task-id]/plan/plan.md
+  📄 ./.cursor/tasks/[task-id]/plan/phase-XX-*.md (if applicable)
+
+PHASE SUMMARY:
+  Total Phases: [count]
+  ✅ Completed: [count]
+  🔄 In Progress: [count]
+  ⏳ Pending: [count]
+
+CHANGES MADE:
+  [+] Added: [phase/step description] (if applicable)
+  [~] Modified: [phase/step description] (if applicable)
+  [-] Removed: [phase/step description] (if applicable)
+
+NEXT STEPS:
+  1. Review updated plan in ./.cursor/tasks/[task-id]/plan/
+  2. Run @spec/implement [task-id] to continue implementation
+
+Ready to implement? Run:
+  → @spec/implement [task-id]
+
+════════════════════════════════════════════════════════════════════
+```
+
+## Important Notes
+
+- **CRITICAL:** Follow `./.cursor/rules/` for code quality standards
+- **CRITICAL:** Follow `./docs/development-rules.md` if exists
+- This command UPDATES existing plans, does NOT create new ones
+- Preserve completed work - never modify completed phases without explicit confirmation
+- Code review phase must ALWAYS remain the final phase
+- Add change log entries for traceability
+- **DO NOT** start implementing - this command only updates the plan
+
+## Context
+
+$ARGUMENTS

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

@@ -0,0 +1,222 @@
+---
+description: Update existing task requirements with new content or changes
+---
+
+# Update Requirements
+
+Update existing task requirements with new content or changes.
+
+**Note:** This command **UPDATES** existing requirements. For initial requirement capture, use `@spec/capture-requirement`.
+
+## Usage
+```
+@spec/update-requirement [task-id] [new requirement or changes]
+```
+
+## Examples
+```
+@spec/update-requirement ABC-123 Add validation for email field with regex pattern
+@spec/update-requirement ABC-123 Change: Button should be red instead of blue
+@spec/update-requirement feature-auth Remove: OAuth support - not needed for MVP
+@spec/update-requirement ABC-123 Clarify: Login should timeout after 30 seconds
+```
+
+## 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.
+
+## Workflow
+
+### 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: Ask user to input task-id
+3. If content not provided: Ask user "What requirement would you like to add or change?"
+4. Verify `./.cursor/tasks/[task-id]/` exists
+5. If not found: "Task not found. Run `@spec/task` first."
+6. Verify `./.cursor/tasks/[task-id]/requirements/` exists and has content
+7. If missing/empty: "No requirements found. Run `@spec/capture-requirement` first."
+
+### Phase 2: Read Existing Requirements
+
+Read ALL files within `./.cursor/tasks/[task-id]/requirements/`:
+- Any `.md` files
+- Any subdirectories containing requirements
+
+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
+
+**1. `./.cursor/tasks/[task-id]/requirements/01-functional.md`:**
+```markdown
+# Functional Requirements: [task-id]
+
+**Last Updated:** [YYYY-MM-DD]
+
+## Overview
+[Brief description of the feature/task]
+
+## Requirements
+
+### Core Functionality
+- [ ] FR-001: [Requirement]
+  - Acceptance: [criteria]
+- [ ] FR-002: [Requirement]
+  - Acceptance: [criteria]
+
+### User Stories
+- As a [user], I want [action], so that [benefit]
+
+### Acceptance Criteria
+- [ ] [Criterion 1]
+- [ ] [Criterion 2]
+
+## Non-Functional Requirements
+- [ ] NFR-001: [Performance/Security/Scalability requirement]
+
+## Out of Scope
+- [What is explicitly NOT included]
+```
+
+**2. `./.cursor/tasks/[task-id]/requirements/10-notes.md`:**
+```markdown
+# Notes: [task-id]
+
+**Last Updated:** [YYYY-MM-DD]
+
+## 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]
+
+## 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 `./.cursor/tasks/[task-id]/requirements/01-functional.md`
+2. Write updated `10-notes.md` to `./.cursor/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:**
+   - Ask user about each question using multiple-choice format
+   - Present recommendation: `**Recommended:** Option X - <reason>`
+   - Update `10-notes.md` with decisions
+   - Update `01-functional.md` if answers affect requirements
+3. **Resolution loop:**
+   - Pick most critical question
+   - Ask with clear options
+   - Record decision in 10-notes.md
+   - Remove from open list
+4. **Only proceed to summary when ALL questions are resolved**
+
+### Phase 7: Summary Output
+
+```
+════════════════════════════════════════
+✅ 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 ./.cursor/tasks/[task-id]/requirements/
+  2. Run @spec/plan [task-id] to update implementation plan (if needed)
+
+Need more changes? Run:
+  → @spec/update-requirement [task-id] [more changes]
+
+════════════════════════════════════════
+```
+
+## Guardrails
+
+- This command **UPDATES** existing requirements with new content or changes
+- For initial requirement capture, use `@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 before completing**

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

@@ -0,0 +1,154 @@
+# Implement Lite Task
+
+## Usage
+```
+@.cursor/commands/devkit/spec-lite/do.md [task-id]
+```
+
+## Examples
+```
+@.cursor/commands/devkit/spec-lite/do.md fix-login-bug
+@.cursor/commands/devkit/spec-lite/do.md add-logout
+```
+
+**Requires:** Task with plan in `./.cursor/tasks/[task-id]/plan.md`
+
+## 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.
+
+## Pre-Implementation Check (Active Task Detection)
+
+Before starting, check for existing active task:
+
+1. **Check active-task file:** If `./.cursor/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:** Ask user for task-id
+
+## Workflow
+
+### Step 0: Validate
+
+1. If task-id not provided, check `./.cursor/active-task` first
+2. Verify `./.cursor/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. Note all phases and tasks to complete
+
+**Output:** `✓ Step 1: Loaded plan with [N] phases`
+
+### Step 2: Implement All Phases
+
+For each phase (except final review phase):
+1. Implement each task in the phase
+2. Follow `./docs/code-standards.md`
+3. Run type checking to verify no syntax errors
+
+**Output:** `✓ Step 2: Implemented [N] phases - [files modified]`
+
+### Step 3: Code Review (AFTER ALL FILES CREATED)
+
+**IMPORTANT:** Only trigger code review AFTER all implementation is complete. Review ALL files at once, not one-by-one.
+
+**Code Review (batch):**
+- Collect complete list of ALL modified files
+- Review ALL code as a batch - NOT one file at a time
+- Check against `./docs/code-standards.md` and `./.cursor/rules/`
+- Report critical issues only
+- Fix any violations
+
+**Output:** `✓ Step 3: Review [passed/N issues]`
+
+### Step 4: User Approval
+
+Present summary:
+- What was implemented
+- Files modified
+- Code review status
+- Any notes
+
+**Ask:** "Implementation complete. Approve changes?"
+
+**Output (waiting):** `⏸ Step 4: WAITING for approval`
+**Output (approved):** `✓ Step 4: Approved`
+
+### Step 5: Finalize
+
+After user approval:
+1. Update plan.md - mark all phases as DONE
+2. Update task README.md - set status to Complete
+3. Update `./docs/` if significant changes
+
+**Output:** `✓ Step 5: Task [task-id] complete`
+
+### Step 6: Clear Active Task
+
+After successful completion:
+- Remove `./.cursor/active-task` file OR
+- Update it to indicate completion
+
+### Step 7: Summary Report
+
+```
+════════════════════════════════════════════════════════════════════
+                    ✅ LITE TASK COMPLETE
+════════════════════════════════════════════════════════════════════
+
+TASK: [task-id]
+STATUS: Implementation Complete
+
+IMPLEMENTED:
+  ✅ Phase 1: [name]
+  ✅ Phase 2: [name]
+  ✅ Phase 3: [name]
+  ✅ Code Review: Passed
+
+FILES MODIFIED:
+  • [file1] - [brief change]
+  • [file2] - [brief change]
+
+NEXT STEPS:
+  1. Run @spec-lite/test.md [task-id] for testing with 100% coverage
+  2. After tests pass, commit your changes
+
+Ready for testing? Run:
+  → @spec-lite/test.md [task-id]
+
+════════════════════════════════════════════════════════════════════
+```
+
+## Critical Rules
+
+- **ALL PHASES IN ONE SESSION** - Don't stop mid-way
+- **NO RESEARCH** - Use existing knowledge only
+- **NO TESTS** - Do not create unit/integration/E2E tests (use `@devkit:spec-lite:test` instead)
+- **FOLLOW CODE STANDARDS** - Check ./docs/code-standards.md
+- **USER APPROVAL REQUIRED** - Don't finalize without approval
+
+## 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 `./.cursor/rules/` 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