vibe-fabric 0.3.2 → 0.4.0

package/.claude/prompts/gaps/assess.md

@@ -0,0 +1,203 @@
+# Gap Analysis 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 performing a gap analysis between the PRD (requirements) and the synchronized repository maps (implementation). This helps identify:
+- Requirements that have no implementation
+- Implementations that have no requirements
+- Partial implementations
+- Potential consistency issues
+
+Project: {PROJECT_PATH}
+
+---
+
+## Your Task
+
+Analyze the PRD requirements against synchronized repository data and help the user understand coverage gaps.
+
+### Step 1: Analyze PRD Requirements
+
+Read and analyze:
+- `docs/prd/modules/` - All requirement modules
+- Count requirements by module and priority
+
+For each requirement, note:
+- ID (e.g., REQ-AUTH-001)
+- Module
+- Priority (P0, P1, P2)
+- Status (draft, approved, implemented)
+
+### Step 2: Analyze Repository Maps
+
+Read and analyze:
+- `docs/sync-cache/*/maps/` - Entity, API, service maps from synced repos
+
+For each repository, identify:
+- Models/entities defined
+- API endpoints
+- Services and modules
+- Key functionality areas
+
+### Step 3: Identify Gaps
+
+Compare requirements to implementation:
+
+**Unimplemented Requirements:**
+- Requirements with status != 'implemented' that have no matching implementation
+
+**Undocumented Features:**
+- Code/APIs in maps that don't appear in any requirement
+
+**Partial Implementation:**
+- Requirements partially covered (some ACs met, others not)
+
+**Status Mismatches:**
+- Requirements marked 'implemented' but no matching code found
+
+### Step 4: Present Findings
+
+Summarize clearly:
+- Total requirements analyzed
+- Implementation coverage percentage
+- Number of gaps by category
+- Most critical gaps (P0 requirements not implemented)
+
+### Step 5: Ask User Intent
+
+Ask the user: **"What would you like to focus on?"**
+
+Options:
+1. **Full gap report** - Analyze all modules in depth
+2. **Specific module** - Focus on one module (e.g., "auth gaps")
+3. **Quick summary** - High-level overview only
+4. **Just checking** - Show summary, no tasks
+
+### Step 6: Create Task List
+
+Based on findings and user intent, create tasks:
+
+**Task Types:**
+- `task-analyze-module` - Deep analysis of a specific module's gaps (non-interactive)
+
+---
+
+## Output Format
+
+Write to: {OUTPUT_FILE}
+
+```json
+{
+  "complexity": "S|M|L",
+  "assessment": {
+    "prd_exists": true,
+    "maps_exist": true,
+    "module_count": 5,
+    "requirement_count": 23,
+    "implementation_coverage": 68,
+    "unimplemented_p0": 2,
+    "unimplemented_total": 8,
+    "undocumented_features": 5,
+    "status_mismatches": 1,
+    "repos_analyzed": ["backend", "frontend"],
+    "user_intent": "full gap report"
+  },
+  "tasks": [
+    {
+      "id": 1,
+      "name": "analyze-auth-gaps",
+      "description": "Analyze gaps in auth module",
+      "prompt": "task-analyze-module",
+      "interactive": false,
+      "context": {
+        "module": "auth",
+        "requirements": ["REQ-AUTH-001", "REQ-AUTH-002"],
+        "repos": ["backend"]
+      }
+    },
+    {
+      "id": 2,
+      "name": "analyze-users-gaps",
+      "description": "Analyze gaps in users module",
+      "prompt": "task-analyze-module",
+      "interactive": false,
+      "context": {
+        "module": "users",
+        "requirements": ["REQ-USER-001"],
+        "repos": ["backend", "frontend"]
+      }
+    }
+  ]
+}
+```
+
+---
+
+## Rules
+
+- Focus ONLY on gap analysis between PRD and implementations
+- Maximum 10 tasks (one per module analyzed)
+- Prioritize P0 requirements in analysis
+- If no maps exist, explain that `vibe sync` should be run first
+- If no PRD exists, explain that `vibe prd` should be run first
+- Be concise - don't list every single requirement, summarize by module
+- If user says "just checking", output empty tasks array
+
+---
+
+## Examples
+
+**User says "just checking":**
+```json
+{
+  "complexity": "S",
+  "assessment": {...},
+  "tasks": []
+}
+```
+
+**User says "full gap report":**
+```json
+{
+  "complexity": "L",
+  "assessment": {...},
+  "tasks": [
+    {"id": 1, "name": "analyze-auth-gaps", "prompt": "task-analyze-module", ...},
+    {"id": 2, "name": "analyze-users-gaps", "prompt": "task-analyze-module", ...},
+    {"id": 3, "name": "analyze-payments-gaps", "prompt": "task-analyze-module", ...}
+  ]
+}
+```
+
+**User says "check auth module":**
+```json
+{
+  "complexity": "S",
+  "assessment": {...},
+  "tasks": [
+    {"id": 1, "name": "analyze-auth-gaps", "prompt": "task-analyze-module", ...}
+  ]
+}
+```
+
+**No maps exist:**
+```json
+{
+  "complexity": "S",
+  "assessment": {
+    "prd_exists": true,
+    "maps_exist": false,
+    "error": "No repository maps found. Run 'vibe sync' first to sync your repositories."
+  },
+  "tasks": []
+}
+```

package/.claude/prompts/gaps/synthesize.md

@@ -0,0 +1,180 @@
+# Synthesize Gap Report
+
+## 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 synthesizing the results of gap analysis tasks into a comprehensive report. Each task analyzed one module's requirements against implementation.
+
+Project: {PROJECT_PATH}
+Task outputs: {TASK_OUTPUTS}
+Total tasks: {TOTAL_TASKS}
+
+---
+
+## Your Task
+
+Combine all module gap analyses into a comprehensive gap report.
+
+### Step 1: Load Task Outputs
+
+Read each task output file from {TASK_OUTPUTS}.
+
+### Step 2: Aggregate Results
+
+Combine all module analyses:
+- Total requirements across all modules
+- Overall coverage percentage
+- All gaps categorized by severity
+- All undocumented features
+- All recommendations
+
+### Step 3: Prioritize Gaps
+
+Rank gaps by impact:
+1. **Critical** - P0 requirements with missing implementation
+2. **High** - P1 requirements partially implemented
+3. **Medium** - P2 requirements with gaps
+4. **Low** - Documentation/status mismatches
+
+### Step 4: Generate Summary Report
+
+Create a summary suitable for project planning:
+- Executive summary
+- Coverage by module
+- Top priority gaps
+- Recommended actions
+
+### Step 5: Write Report File
+
+Generate `docs/reports/gap-analysis.md` with:
+- Date of analysis
+- Coverage summary table
+- Detailed gaps by module
+- Recommendations
+
+---
+
+## Output
+
+### Console Output
+
+Print a summary:
+
+```
+Gap Analysis Complete
+=====================
+
+Coverage Summary:
+- Total Requirements: 23
+- Fully Implemented: 15 (65%)
+- Partially Implemented: 5 (22%)
+- Not Implemented: 3 (13%)
+
+Critical Gaps (P0):
+1. REQ-PAY-001: Payment processing - missing Stripe integration
+2. REQ-AUTH-003: MFA - not implemented
+
+High Priority Gaps (P1):
+1. REQ-USER-002: Profile pictures - missing upload endpoint
+2. REQ-AUTH-002: Password reset - incomplete flow
+
+Report written to: docs/reports/gap-analysis.md
+
+Next Steps:
+- Create scopes for critical gaps with: vibe scope
+- Update PRD statuses with: vibe prd
+```
+
+### Report File
+
+Write to: `docs/reports/gap-analysis.md`
+
+```markdown
+# Gap Analysis Report
+
+**Generated:** 2026-01-21
+**Modules Analyzed:** 5
+**Overall Coverage:** 65%
+
+## Executive Summary
+
+[2-3 paragraph summary of findings]
+
+## Coverage by Module
+
+| Module | Requirements | Implemented | Coverage |
+|--------|--------------|-------------|----------|
+| auth | 5 | 4 | 80% |
+| users | 3 | 2 | 67% |
+| payments | 4 | 0 | 0% |
+| ... | ... | ... | ... |
+
+## Critical Gaps
+
+### REQ-PAY-001: Payment Processing
+
+**Status:** Not Implemented
+**Priority:** P0
+
+**Missing:**
+- Stripe integration
+- Payment intent creation
+- Webhook handling
+
+**Recommendation:** Create SCOPE for payment integration as highest priority.
+
+[... more gaps ...]
+
+## Undocumented Features
+
+| Feature | Location | Recommendation |
+|---------|----------|----------------|
+| POST /auth/refresh | backend | Add requirement for token refresh |
+| ... | ... | ... |
+
+## Recommendations
+
+1. **Immediate:** Create scopes for P0 gaps (payments, MFA)
+2. **Short-term:** Complete partial implementations (password reset)
+3. **Documentation:** Add requirements for undocumented features
+
+## Next Steps
+
+- Run `vibe scope` to create implementation scopes for gaps
+- Run `vibe prd` to update requirement statuses
+- Run `vibe sync` to refresh implementation maps after changes
+```
+
+---
+
+## Rules
+
+- Be actionable - every gap should have a clear next step
+- Prioritize by business impact (P0 > P1 > P2)
+- Keep executive summary concise (max 3 paragraphs)
+- Use tables for scannable data
+- Include specific commands for next steps
+- Create the reports directory if it doesn't exist
+- Timestamp the report
+
+---
+
+## Directory Structure
+
+Ensure this exists:
+```
+docs/
+└── reports/
+    └── gap-analysis.md
+```
+
+Create `docs/reports/` if it doesn't exist.

package/.claude/prompts/gaps/task-analyze-module.md

@@ -0,0 +1,198 @@
+# Analyze Module Gaps
+
+## Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| {PROJECT_PATH} | Path to the project directory | Yes |
+| {TASK_NAME} | Name of this task | Yes |
+| {TASK_DESCRIPTION} | Description of this task | Yes |
+| {OUTPUT_FILE} | Path to write the task output | Yes |
+| {PREVIOUS_OUTPUTS} | JSON array of previous task output paths | Yes |
+| {MODULE} | Module name to analyze | Yes |
+| {REQUIREMENTS} | JSON array of requirement IDs to analyze | Yes |
+| {REPOS} | JSON array of repo aliases to check | Yes |
+
+---
+
+## Context
+
+You are analyzing gaps for a specific PRD module. Compare the requirements against the implementation maps from synchronized repositories.
+
+Project: {PROJECT_PATH}
+Module: {MODULE}
+Requirements: {REQUIREMENTS}
+Repositories: {REPOS}
+
+---
+
+## Your Task
+
+Perform deep gap analysis for this module.
+
+### Step 1: Load Requirements
+
+Read each requirement file:
+- `docs/prd/modules/{MODULE}/*.md`
+
+For each requirement, extract:
+- ID
+- User needs (UN-*)
+- Business rules (BR-*)
+- Acceptance criteria (AC-*)
+- Current status
+
+### Step 2: Load Repository Maps
+
+For each repo in {REPOS}, read:
+- `docs/sync-cache/{repo}/maps/entities.json` - Data models
+- `docs/sync-cache/{repo}/maps/api.json` - API endpoints
+- `docs/sync-cache/{repo}/maps/services.json` - Business logic
+- `docs/sync-cache/{repo}/maps/modules.json` - Module structure
+
+### Step 3: Match Requirements to Implementation
+
+For each requirement:
+
+1. **Find related code:**
+   - Search entities for matching models
+   - Search API for matching endpoints
+   - Search services for matching functionality
+
+2. **Assess coverage:**
+   - Fully implemented: All ACs can be verified in code
+   - Partially implemented: Some ACs verified, others missing
+   - Not implemented: No matching code found
+
+3. **Note discrepancies:**
+   - Extra functionality in code not in requirements
+   - Requirements that don't match implementation patterns
+
+### Step 4: Generate Gap Report
+
+Create detailed gap report for this module.
+
+---
+
+## Output Format
+
+Write to: {OUTPUT_FILE}
+
+```json
+{
+  "module": "{MODULE}",
+  "summary": {
+    "total_requirements": 5,
+    "fully_implemented": 2,
+    "partially_implemented": 2,
+    "not_implemented": 1,
+    "coverage_percentage": 60
+  },
+  "requirements": [
+    {
+      "id": "REQ-AUTH-001",
+      "title": "User Authentication",
+      "status_in_prd": "approved",
+      "implementation_status": "fully_implemented",
+      "evidence": {
+        "entities": ["User", "Session"],
+        "endpoints": ["POST /auth/login", "POST /auth/logout"],
+        "services": ["AuthService.login", "AuthService.logout"]
+      },
+      "acceptance_criteria": [
+        {
+          "id": "AC-1",
+          "description": "User can log in with email/password",
+          "implemented": true,
+          "evidence": "POST /auth/login endpoint with email/password body"
+        },
+        {
+          "id": "AC-2",
+          "description": "Failed login returns error message",
+          "implemented": true,
+          "evidence": "AuthService.login throws UnauthorizedError"
+        }
+      ],
+      "gaps": [],
+      "recommendations": []
+    },
+    {
+      "id": "REQ-AUTH-002",
+      "title": "Password Reset",
+      "status_in_prd": "approved",
+      "implementation_status": "partially_implemented",
+      "evidence": {
+        "entities": ["PasswordResetToken"],
+        "endpoints": ["POST /auth/forgot-password"],
+        "services": ["AuthService.requestPasswordReset"]
+      },
+      "acceptance_criteria": [
+        {
+          "id": "AC-1",
+          "description": "User can request password reset email",
+          "implemented": true,
+          "evidence": "POST /auth/forgot-password endpoint"
+        },
+        {
+          "id": "AC-2",
+          "description": "User can reset password with valid token",
+          "implemented": false,
+          "evidence": null
+        }
+      ],
+      "gaps": [
+        {
+          "type": "missing_endpoint",
+          "description": "No endpoint for POST /auth/reset-password",
+          "severity": "high",
+          "ac_id": "AC-2"
+        }
+      ],
+      "recommendations": [
+        "Add POST /auth/reset-password endpoint to complete password reset flow"
+      ]
+    }
+  ],
+  "undocumented_features": [
+    {
+      "type": "endpoint",
+      "item": "POST /auth/refresh-token",
+      "location": "backend",
+      "recommendation": "Add requirement for token refresh functionality"
+    }
+  ],
+  "module_recommendations": [
+    "Update REQ-AUTH-002 status to 'in_progress' in PRD",
+    "Consider adding requirement for refresh token functionality",
+    "Complete POST /auth/reset-password implementation"
+  ]
+}
+```
+
+---
+
+## Rules
+
+- Analyze ONLY the specified module
+- Be thorough - check every acceptance criterion
+- Provide specific evidence (file names, endpoint paths, function names)
+- Severity levels: high (P0 AC missing), medium (P1 AC missing), low (P2 AC missing)
+- Don't make assumptions - if you can't find evidence, mark as not implemented
+- Include actionable recommendations
+- Keep output focused and structured
+
+---
+
+## Evidence Guidelines
+
+When claiming something is implemented, cite specific evidence:
+
+**Good evidence:**
+- "POST /auth/login endpoint in api.json"
+- "User entity with email, passwordHash fields in entities.json"
+- "AuthService.validatePassword in services.json"
+
+**Bad evidence:**
+- "Probably exists somewhere"
+- "Should be implemented"
+- "Likely in the auth module"