vibe-fabric 0.3.2 → 0.3.3

package/.claude/prompts/prd/assess.md

@@ -0,0 +1,156 @@
+# PRD Assessment
+
+## Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| {PROJECT_PATH} | Path to the project directory | Yes |
+| {OUTPUT_FILE} | Path to write the assessment output | Yes |
+
+---
+
+## Context
+
+You are helping manage a Product Requirements Document (PRD) for a software project.
+
+Project: {PROJECT_PATH}
+
+---
+
+## Your Task
+
+Analyze the current PRD state and help the user with PRD management.
+
+### Step 1: Analyze Current State
+
+Read and analyze:
+- `docs/prd/` - Current PRD structure and content
+- `docs/scopes/completed/` - Completed work (to identify status updates needed)
+- `docs/sync-cache/` - Implementation data (if available)
+
+Identify:
+- **Format issues**: Missing fields, invalid IDs, inconsistent structure
+- **Status mismatches**: Requirements that should be marked 'implemented' based on completed scopes
+- **Coverage gaps**: Areas that may need documentation
+- **Overall health**: Module count, requirement count, coverage percentage
+
+### Step 2: Present Findings
+
+Summarize your findings clearly:
+- How many modules and requirements exist
+- Coverage percentage (implemented vs total)
+- Number and types of issues found
+- Status updates needed
+
+### Step 3: Ask User Intent
+
+Ask the user: **"What brings you here today?"**
+
+Listen for signals like:
+- "add a feature" → task-capture-feature
+- "fix issues" → task-fix-format
+- "update statuses" → task-update-status
+- "just checking" → no tasks, show summary only
+
+### Step 4: Create Task List
+
+Based on findings and user intent, create a list of tasks:
+
+**Task Types:**
+- `task-fix-format` - Fix format issues (non-interactive)
+- `task-update-status` - Update statuses from scopes (non-interactive)
+- `task-capture-feature` - Capture new feature requirements (interactive)
+- `task-document-code` - Document undocumented code (non-interactive)
+- `task-deprecate` - Mark deprecated features (non-interactive)
+
+---
+
+## Output Format
+
+Write to: {OUTPUT_FILE}
+
+```json
+{
+  "complexity": "S|M|L",
+  "assessment": {
+    "prd_exists": true,
+    "module_count": 5,
+    "requirement_count": 23,
+    "coverage_percentage": 68,
+    "format_issues": 2,
+    "status_updates_needed": 5,
+    "user_intent": "add payments feature"
+  },
+  "tasks": [
+    {
+      "id": 1,
+      "name": "fix-format",
+      "description": "Fix 2 format issues in PRD files",
+      "prompt": "task-fix-format",
+      "interactive": false,
+      "context": {
+        "issues": ["REQ-AUTH-001: missing priority", "REQ-USER-003: invalid AC format"]
+      }
+    },
+    {
+      "id": 2,
+      "name": "update-status",
+      "description": "Update 5 requirement statuses from completed scopes",
+      "prompt": "task-update-status",
+      "interactive": false,
+      "context": {
+        "updates": [
+          {"req": "REQ-AUTH-001", "scope": "SCOPE-001", "status": "implemented"}
+        ]
+      }
+    },
+    {
+      "id": 3,
+      "name": "capture-payments",
+      "description": "Capture requirements for payments feature",
+      "prompt": "task-capture-feature",
+      "interactive": true,
+      "context": {
+        "feature": "payments",
+        "hints": ["payment processing", "subscriptions", "billing"]
+      }
+    }
+  ]
+}
+```
+
+---
+
+## Rules
+
+- Focus ONLY on PRD management
+- Maximum 10 tasks (group related work if needed)
+- Always fix format issues first
+- Always update statuses from completed scopes
+- Only add capture tasks if user requests new features
+- Be concise in your analysis - don't overwhelm the user
+- If no issues and no user requests, output empty tasks array
+
+---
+
+## Examples
+
+**User says "just checking":**
+```json
+{
+  "complexity": "S",
+  "assessment": {...},
+  "tasks": []
+}
+```
+
+**User says "add authentication feature":**
+```json
+{
+  "complexity": "M",
+  "assessment": {...},
+  "tasks": [
+    {"id": 1, "name": "capture-auth", "prompt": "task-capture-feature", "interactive": true, ...}
+  ]
+}
+```

package/.claude/prompts/prd/synthesize.md

@@ -0,0 +1,191 @@
+# PRD Synthesis and Approval
+
+## Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| {PROJECT_PATH} | Path to the project directory | Yes |
+| {TASK_OUTPUTS} | JSON array of task output file paths | Yes |
+| {TOTAL_TASKS} | Number of tasks completed | Yes |
+
+---
+
+## Context
+
+You are reviewing all changes from the PRD operation and getting user approval.
+
+Project: {PROJECT_PATH}
+Task outputs: {TASK_OUTPUTS}
+Total tasks: {TOTAL_TASKS}
+
+---
+
+## Your Task
+
+Present all changes for user approval and apply approved changes.
+
+### Step 1: Load All Task Outputs
+
+Read each file in {TASK_OUTPUTS} and combine the results.
+
+### Step 2: Present Summary
+
+Group changes by category and present clearly:
+
+```
+╔════════════════════════════════════════════════════════════════════╗
+║                       CHANGES TO APPLY                              ║
+╠════════════════════════════════════════════════════════════════════╣
+║                                                                    ║
+║  ✓ FORMAT FIXES (2)                                                ║
+║    • REQ-AUTH-001: Added priority P1                               ║
+║    • REQ-USER-003: Fixed AC format                                 ║
+║                                                                    ║
+║  ✓ STATUS UPDATES (5)                                              ║
+║    • REQ-AUTH-001: draft → implemented                             ║
+║    • REQ-AUTH-002: draft → implemented                             ║
+║    • REQ-USER-001: draft → implemented                             ║
+║    ...                                                             ║
+║                                                                    ║
+║  ✓ NEW MODULE: payments                                            ║
+║    • 4 user needs                                                  ║
+║    • 6 business rules                                              ║
+║    • 12 acceptance criteria                                        ║
+║                                                                    ║
+║  ⚠ DRAFTED (needs review): 3 requirements                          ║
+║    • PaymentService → REQ-PAY-010                                  ║
+║    ...                                                             ║
+║                                                                    ║
+╚════════════════════════════════════════════════════════════════════╝
+```
+
+### Step 3: Get User Decision
+
+Ask user:
+- **"Accept all"** - Apply all changes
+- **"Accept partial"** - Let user specify what to include/exclude
+- **"Reject"** - Discard all changes
+- **"Show details"** - Show full content of specific change
+
+### Step 4: Apply Approved Changes
+
+For approved changes:
+1. Write modified files
+2. Create new module directories if needed
+3. Create new requirement files if needed
+4. Update module `_index.md` files
+
+### Step 5: Generate Summary
+
+After applying changes:
+- List all files modified
+- List all files created
+- Show updated coverage percentage
+
+---
+
+## Output Format
+
+No file output needed - changes are applied directly to PRD files.
+
+Display to user:
+```
+Applied changes:
+  ✓ Modified 7 files
+  ✓ Created 4 files
+  ✓ Coverage: 68% → 75%
+
+Files modified:
+  • docs/prd/modules/auth/login.md
+  • docs/prd/modules/auth/registration.md
+  • ...
+
+Files created:
+  • docs/prd/modules/payments/_index.md
+  • docs/prd/modules/payments/processing.md
+  • ...
+```
+
+---
+
+## Rules
+
+- NEVER apply changes without user approval
+- If user says "reject", discard ALL changes
+- If user says "accept partial", only apply specified items
+- Drafted requirements (status: inferred) need explicit approval
+- Create proper directory structure for new modules
+- Update `_index.md` files when adding new requirements
+- Preserve existing formatting in modified files
+- Use consistent ID numbering (REQ-XXX-NNN)
+
+---
+
+## Module Structure
+
+When creating new modules:
+
+```
+docs/prd/modules/{module-name}/
+├── _index.md           # Module overview
+└── {feature}.md        # Individual requirements
+```
+
+**_index.md template:**
+```markdown
+# {Module Name}
+
+## Overview
+
+[Brief description]
+
+## Requirements
+
+| ID | Title | Status | Priority |
+|----|-------|--------|----------|
+| REQ-XXX-001 | Title | draft | P1 |
+
+## Related
+
+- [Requirement 1](./requirement.md)
+```
+
+**Requirement template:**
+```markdown
+# REQ: {Title}
+
+## Metadata
+
+| Field | Value |
+|-------|-------|
+| **ID** | `REQ-XXX-001` |
+| **Module** | `module-name` |
+| **Status** | `draft` |
+| **Priority** | `P1` |
+| **Last Updated** | YYYY-MM-DD |
+| **Covered By** | - |
+
+---
+
+## Context
+
+[Background]
+
+---
+
+## User Needs
+
+- **UN-1:** [Description]
+
+---
+
+## Business Rules
+
+- **BR-1:** [Description]
+
+---
+
+## Acceptance Criteria
+
+- **AC-1:** Given [context], when [action], then [result]
+```

package/.claude/prompts/prd/task-capture-feature.md

@@ -0,0 +1,133 @@
+# Capture Feature Requirements
+
+## Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| {PROJECT_PATH} | Path to the project directory | Yes |
+| {OUTPUT_FILE} | Path to write task output | Yes |
+| {TASK_NAME} | Name of this task | Yes |
+| {TASK_DESCRIPTION} | Description of feature to capture | Yes |
+| {FEATURE} | Feature name | Yes |
+| {HINTS} | Hints about what the feature might include | No |
+| {PREVIOUS_OUTPUTS} | Paths to previous task outputs | Yes |
+
+---
+
+## Context
+
+You are capturing requirements for a new feature through conversation.
+
+Project: {PROJECT_PATH}
+Task: {TASK_NAME}
+Feature: {FEATURE}
+Hints: {HINTS}
+
+---
+
+## Your Task
+
+Have a focused conversation to capture detailed requirements for {FEATURE}.
+
+### Conversation Flow
+
+**1. Understanding the Problem**
+- "What problem does {FEATURE} solve?"
+- "Who will use this feature?"
+- "What happens today without it?"
+
+**2. User Needs (UN)**
+- "What should users be able to do with {FEATURE}?"
+- "What are the must-have capabilities?"
+- "What would be nice-to-have?"
+
+Capture as User Needs:
+```
+- UN-1: User needs to [action] so that [benefit]
+- UN-2: User needs to [action] so that [benefit]
+```
+
+**3. Business Rules (BR)**
+- "Are there any constraints or limits?"
+- "What should NOT be allowed?"
+- "Are there compliance requirements?"
+
+Capture as Business Rules:
+```
+- BR-1: [Rule statement]
+- BR-2: [Rule statement]
+```
+
+**4. Acceptance Criteria (AC)**
+Derive from User Needs:
+```
+- AC-1: Given [context], when [action], then [result] (validates UN-1)
+- AC-2: Given [context], when [action], then [result] (validates UN-1)
+```
+
+**5. Out of Scope**
+- "What should this feature NOT include?"
+- "What's for future versions?"
+
+### Keep the Session Focused
+
+- Stay on the {FEATURE} topic
+- Don't expand scope to other features
+- 10-15 minutes maximum
+- Be concise in questions
+- Confirm understanding before moving on
+
+---
+
+## Output Format
+
+Write to: {OUTPUT_FILE}
+
+```json
+{
+  "task": "capture-feature",
+  "status": "complete",
+  "feature": "{FEATURE}",
+  "module_path": "docs/prd/modules/{feature}/",
+  "requirements": {
+    "user_needs": [
+      {
+        "id": "UN-1",
+        "description": "User needs to [action] so that [benefit]",
+        "priority": "P1"
+      }
+    ],
+    "business_rules": [
+      {
+        "id": "BR-1",
+        "description": "[Rule statement]"
+      }
+    ],
+    "acceptance_criteria": [
+      {
+        "id": "AC-1",
+        "user_need": "UN-1",
+        "given": "context",
+        "when": "action",
+        "then": "result"
+      }
+    ],
+    "out_of_scope": [
+      "Item 1",
+      "Item 2"
+    ]
+  },
+  "notes": "Additional context captured during conversation"
+}
+```
+
+---
+
+## Rules
+
+- Focus ONLY on {FEATURE}
+- Every User Need must have at least one Acceptance Criterion
+- Use clear, testable language
+- Don't invent requirements - capture what user tells you
+- If user is unsure, note it and move on
+- Keep it practical - avoid over-engineering requirements

package/.claude/prompts/prd/task-deprecate.md

@@ -0,0 +1,84 @@
+# Deprecate Removed Features
+
+## Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| {PROJECT_PATH} | Path to the project directory | Yes |
+| {OUTPUT_FILE} | Path to write task output | Yes |
+| {TASK_NAME} | Name of this task | Yes |
+| {TASK_DESCRIPTION} | Description of what to deprecate | Yes |
+| {DEPRECATED_ITEMS} | JSON array of requirements to deprecate | Yes |
+
+---
+
+## Context
+
+You are marking requirements as deprecated because the code has been removed.
+
+Project: {PROJECT_PATH}
+Task: {TASK_NAME}
+
+Items to deprecate:
+{DEPRECATED_ITEMS}
+
+---
+
+## Your Task
+
+Mark requirements as deprecated (don't delete them - maintain history).
+
+### Step 1: Verify Removal
+
+For each item, verify:
+- The code is truly removed (not in current maps)
+- The requirement exists in the PRD
+
+### Step 2: Update Status
+
+Change status to `deprecated` and add deprecation note:
+
+```markdown
+| **Status** | `deprecated` |
+
+> **Deprecated:** Feature removed as of [date]. Code no longer exists in codebase.
+```
+
+### Step 3: Update Module Index
+
+If all requirements in a module are deprecated, note in the module's `_index.md`.
+
+---
+
+## Output Format
+
+Write to: {OUTPUT_FILE}
+
+```json
+{
+  "task": "deprecate",
+  "status": "complete",
+  "deprecated": [
+    {
+      "requirement": "REQ-LEGACY-001",
+      "file": "docs/prd/modules/legacy/old-feature.md",
+      "reason": "Feature removed - code no longer exists",
+      "old_status": "implemented",
+      "new_status": "deprecated"
+    }
+  ],
+  "files_modified": [
+    "docs/prd/modules/legacy/old-feature.md"
+  ]
+}
+```
+
+---
+
+## Rules
+
+- NEVER delete requirements - only deprecate
+- Always add deprecation note with reason
+- Preserve all existing content
+- If requirement still has code coverage, don't deprecate
+- If unsure, skip and note in output

package/.claude/prompts/prd/task-document-code.md

@@ -0,0 +1,110 @@
+# Document Undocumented Code
+
+## Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| {PROJECT_PATH} | Path to the project directory | Yes |
+| {OUTPUT_FILE} | Path to write task output | Yes |
+| {TASK_NAME} | Name of this task | Yes |
+| {TASK_DESCRIPTION} | Description of what to document | Yes |
+| {UNDOCUMENTED_ITEMS} | JSON array of code items without PRD coverage | Yes |
+
+---
+
+## Context
+
+You are drafting requirements for code that exists but isn't documented in the PRD.
+
+Project: {PROJECT_PATH}
+Task: {TASK_NAME}
+
+Undocumented items:
+{UNDOCUMENTED_ITEMS}
+
+---
+
+## Your Task
+
+Create draft requirements for undocumented code.
+
+### Step 1: Analyze Code
+
+For each undocumented item:
+- Read the relevant map file (from `docs/sync-cache/`)
+- Understand what the code does
+- Identify the module it belongs to
+
+### Step 2: Infer Requirements
+
+Based on code analysis, infer likely:
+- User Needs: What capability does this provide?
+- Business Rules: What constraints are enforced?
+- Acceptance Criteria: What behavior is expected?
+
+### Step 3: Create Draft Documents
+
+Mark all inferred requirements as:
+- Status: `inferred`
+- Note: "Inferred from existing code - please review"
+
+---
+
+## Output Format
+
+Write to: {OUTPUT_FILE}
+
+```json
+{
+  "task": "document-code",
+  "status": "complete",
+  "drafted": [
+    {
+      "code_item": "PaymentService",
+      "source": "docs/sync-cache/backend/maps/services.json",
+      "module": "payments",
+      "drafted_requirement": {
+        "id": "REQ-PAY-010",
+        "status": "inferred",
+        "title": "Payment Processing",
+        "user_needs": [
+          {
+            "id": "UN-1",
+            "description": "User needs to process payments",
+            "priority": "P1"
+          }
+        ],
+        "business_rules": [
+          {
+            "id": "BR-1",
+            "description": "Payments must be validated before processing"
+          }
+        ],
+        "acceptance_criteria": [
+          {
+            "id": "AC-1",
+            "given": "valid payment details",
+            "when": "payment is submitted",
+            "then": "payment is processed successfully"
+          }
+        ],
+        "note": "Inferred from existing code - please review"
+      }
+    }
+  ],
+  "files_to_create": [
+    "docs/prd/modules/payments/processing.md"
+  ]
+}
+```
+
+---
+
+## Rules
+
+- Mark ALL drafted requirements as status: "inferred"
+- Add note explaining these are inferred
+- Don't assume features that aren't in the code
+- Keep requirements minimal - better to understate than overstate
+- User will review and approve before these are added
+- If code purpose is unclear, note uncertainty in output