vibe-fabric 0.3.2 → 0.4.0

package/dist/core/repo/templates/claude-prompts.js

@@ -1,257 +1,512 @@
 /**
- * .claude/prompts/ templates
+ * .claude/prompts/ templates for Ralph autonomous executor
  */
 export const claudePrompts = [
-    // ralph-research.md
+    // ralph-research.md - Research phase prompt (REQ-6)
     {
         path: '.claude/prompts/ralph-research.md',
-        content: `# Ralph Research Prompt
+        content: `# Ralph Research Phase
 
-## Context
+You are preparing context for autonomous execution of plan:
+\`{PLAN_PATH}\`
 
-Plan ID: {{PLAN_ID}}
-Session Number: {{SESSION_NUMBER}}
-Previous Sessions: {{PREVIOUS_SESSIONS}}
+## Mission
 
-## Instructions
+Gather ALL necessary context ONCE so subsequent task sessions can execute without re-researching.
+This research will be used by all following execution sessions, which start with fresh context.
 
-Prepare for the next execution session by:
+## Process
 
-1. **Review Progress**
-   - Read the plan file
-   - Check the progress log
-   - Identify completed vs pending steps
+1. **Read the Plan**
+   - Read the full plan file at \`{PLAN_PATH}\`
+   - Understand all tasks and acceptance criteria
+   - Note dependencies between tasks
+
+2. **Analyze Codebase Context**
+   - Read maps in \`vibe/maps/\` if they exist
+   - Search knowledge base in \`vibe/knowledge-base/\`
+   - Check \`vibe/implementation-plans/completed/\` for similar work
+   - Identify patterns and conventions in the codebase
 
-2. **Gather Context**
-   - Read relevant source files
-   - Check knowledge base for related entries
-   - Review any error logs from previous sessions
+3. **Identify Key Files**
+   - For each task, list the files that need to be read or modified
+   - Note any shared utilities or types needed
+   - Identify test file locations
 
-3. **Plan Next Steps**
-   - Identify 2-3 steps to accomplish this session
-   - Note any dependencies or blockers
-   - Prepare code context
+4. **Document Gotchas**
+   - Check for known issues in knowledge base
+   - Note any architectural constraints
+   - Identify potential blockers
+
+## Output
 
-## Output Format
+Append a "## Ralph Research Context" section to the plan file with:
 
 \`\`\`markdown
-# Session {{SESSION_NUMBER}} Brief
+## Ralph Research Context
+
+### Codebase Summary
+- [Key architectural patterns]
+- [Relevant conventions]
+- [Important utilities/types]
+
+### Maps Analysis
+- [Summary of relevant entity maps]
+- [API/service relationships]
+
+### Knowledge Base Findings
+- [Relevant gotchas or decisions]
+- [Patterns from similar implementations]
+
+### Key Files by Task
 
-## Progress Summary
-- Steps completed: X/Y
-- Last completed: [step description]
-- Blockers: [any issues]
+**Task 1:**
+- Read: [files to read]
+- Modify: [files to modify]
+- Test: [test file]
 
-## Next Steps
-1. [Step to do]
-2. [Step to do]
+**Task 2:**
+- Read: [files]
+- Modify: [files]
+- Test: [test file]
 
-## Context Files
-- path/to/file1.ts
-- path/to/file2.ts
+[Continue for all tasks...]
 
-## Notes
-[Any relevant context or warnings]
+### Potential Blockers
+- [Any identified risks or blockers]
 \`\`\`
+
+## Rules
+
+- Be thorough - subsequent sessions depend on this research
+- Be specific - list actual file paths, not generic descriptions
+- Be concise - avoid unnecessary prose
+- When complete, EXIT immediately
 `,
     },
-    // ralph-execution.md
+    // ralph-execution.md - Task execution prompt (REQ-7)
     {
         path: '.claude/prompts/ralph-execution.md',
-        content: `# Ralph Execution Prompt
+        content: `# Ralph Task Execution
 
-## Context
+You are executing **Task {CURRENT_TASK} of {TOTAL_TASKS}** from plan:
+\`{PLAN_PATH}\`
 
-Plan ID: {{PLAN_ID}}
-Session Brief: {{SESSION_BRIEF}}
-Steps to Execute: {{STEPS}}
+## CRITICAL RULES
 
-## Instructions
+1. **Complete ONLY Task {CURRENT_TASK}**
+   - Do NOT attempt other tasks
+   - Do NOT "look ahead" to future tasks
+   - Do NOT continue after this task
 
-Execute the planned steps for this session:
+2. **Fresh Context**
+   - You are starting with NO memory of previous tasks
+   - Read the "Ralph Research Context" section for background
+   - Read the plan's progress log for what's already done
 
-1. **Read the brief** - Understand what to accomplish
-2. **Execute each step** - Make the required changes
-3. **Verify changes** - Run tests, check behavior
-4. **Log progress** - Update the plan's progress log
+3. **Validation Required**
+   - Run typecheck after every code change: \`npm run typecheck\` or \`npx tsc --noEmit\`
+   - Run lint after every code change: \`npm run lint\`
+   - Fix ALL issues before marking task complete
 
-## Guidelines
+4. **Exit Protocol**
+   - Update progress log in plan file
+   - Mark task complete in progress log
+   - EXIT immediately after
 
-- Make focused, incremental changes
-- Test after each significant change
-- Document any deviations from the plan
-- Note any issues for the cleanup phase
+## Process
 
-## Output
+1. **Read the Plan**
+   - Read \`{PLAN_PATH}\`
+   - Find Task {CURRENT_TASK} specification
+   - Read the "Ralph Research Context" section
+   - Check progress log for completed tasks
+
+2. **Locate Key Files**
+   - Use the key files listed in research context
+   - Read necessary files before modifying
+
+3. **Execute Task**
+   - Implement the task requirements
+   - Follow existing code patterns
+   - Add appropriate error handling
+
+4. **Validate**
+   - Run typecheck
+   - Run lint
+   - Fix any issues
+
+5. **Update Progress**
+   - Add to progress log in plan:
+     \`\`\`markdown
+     ### Task {CURRENT_TASK} - [Date]
+     - Status: Complete
+     - Changes: [list of files changed]
+     - Notes: [any relevant notes]
+     \`\`\`
+
+6. **EXIT**
+   - Do not continue to next task
+   - Ralph will spawn a new session for the next task
 
-After execution, provide:
-- Summary of changes made
-- Files modified
-- Test results
-- Any issues encountered
+## Blocker Handling
+
+If you cannot complete this task after 3 attempts:
+1. Add to plan: \`### PLAN_BLOCKED: [description of blocker]\`
+2. Include what you tried and why it failed
+3. EXIT immediately
+
+Ralph will pause and notify for human intervention.
+
+## Example Progress Log Entry
+
+\`\`\`markdown
+### Task 3 - 2026-01-22
+- Status: Complete
+- Changes:
+  - src/core/auth.ts: Added validateToken function
+  - src/types/auth.ts: Added TokenPayload interface
+  - tests/auth.test.ts: Added 5 test cases
+- Notes: Used existing crypto utility for signature verification
+\`\`\`
 `,
     },
-    // ralph-cleanup.md
+    // ralph-cleanup.md - Cleanup phase prompt (REQ-8)
     {
         path: '.claude/prompts/ralph-cleanup.md',
-        content: `# Ralph Cleanup Prompt
+        content: `# Ralph Cleanup Phase
+
+You are verifying and finalizing plan:
+\`{PLAN_PATH}\`
 
-## Context
+All tasks have been completed. This is the final verification phase.
 
-Plan ID: {{PLAN_ID}}
-Session Number: {{SESSION_NUMBER}}
-Execution Summary: {{EXECUTION_SUMMARY}}
+## Mission
 
-## Instructions
+Verify all work is complete, run quality checks, and finalize the plan.
 
-Verify and clean up after the execution session:
+## Process
 
-1. **Verify Changes**
-   - Review all modified files
-   - Ensure changes are correct
-   - Check for any leftover debug code
+1. **Read the Plan**
+   - Read \`{PLAN_PATH}\`
+   - Review all task progress entries
+   - Check acceptance criteria
 
-2. **Run Tests**
-   - Run relevant unit tests
-   - Run integration tests if applicable
-   - Check for regressions
+2. **Run Quality Checks**
+   - Run full test suite: \`npm test\`
+   - Run typecheck: \`npm run typecheck\`
+   - Run lint: \`npm run lint\`
+   - Run build: \`npm run build\`
 
-3. **Update Documentation**
-   - Update progress log in the plan
-   - Check off completed acceptance criteria
-   - Add any KB entries for learnings
+3. **Verify Acceptance Criteria**
+   - Go through each AC in the plan
+   - Mark each as verified or note issues
+   - Add verification section to plan
 
-4. **Prepare Handoff**
-   - Note any unfinished work
-   - Document blockers for next session
-   - Update plan status if complete
+4. **Final Documentation**
+   - Update plan status to "complete"
+   - Add completion timestamp
+   - Add any learnings to knowledge base
 
-## Output Format
+5. **Cleanup**
+   - Remove any debug code or console.logs
+   - Ensure all files are properly formatted
+   - Check for any TODO comments that should be resolved
+
+## Output
+
+Add a "## Completion Summary" section to the plan:
 
 \`\`\`markdown
-# Session {{SESSION_NUMBER}} Summary
+## Completion Summary
+
+### Verification Date
+[Date]
 
-## Changes Made
-- file1.ts: [description]
-- file2.ts: [description]
+### Quality Checks
+- [x] All tests pass
+- [x] Typecheck passes
+- [x] Lint passes
+- [x] Build succeeds
 
-## Test Results
-- [x] Unit tests pass
-- [ ] Integration tests pass
+### Acceptance Criteria Verification
+- [x] AC-1: [description] - Verified
+- [x] AC-2: [description] - Verified
+- [ ] AC-3: [description] - Issue: [note]
 
-## Acceptance Criteria
-- [x] AC-1: ...
-- [ ] AC-2: ...
+### Files Changed
+- [List all files modified during implementation]
 
-## Issues
-- [Issue description]
+### Learnings
+- [Any knowledge base entries to add]
 
-## Next Session
-- [What to do next]
+### Status
+**COMPLETE** - Ready for review
 \`\`\`
+
+## Rules
+
+- Run ALL quality checks, not just some
+- Be honest about any failing checks
+- If there are issues, note them but don't try to fix complex problems
+- Simple fixes (lint, formatting) can be done
+- Complex issues should be noted for human review
+- EXIT when complete
 `,
     },
-    // ralph-plan-extraction.md
+    // ralph-plan-extraction.md - Extraction phase for plan mode (REQ-11)
     {
         path: '.claude/prompts/ralph-plan-extraction.md',
-        content: `# Ralph Plan Extraction Prompt
+        content: `# Ralph Plan Extraction Phase
 
-## Context
+You are creating an implementation plan from scope:
+\`{SCOPE_PATH}\`
 
-Scope ID: {{SCOPE_ID}}
-Scope Content: {{SCOPE_CONTENT}}
+## Mission
 
-## Instructions
+Parse the scope and identify modules for planning. Each module will be planned in a separate session.
 
-Extract a detailed implementation plan from the scope:
+## Process
 
-1. **Analyze Requirements**
-   - Identify all functional requirements
+1. **Read the Scope**
+   - Read \`{SCOPE_PATH}\`
+   - Understand all requirements
    - Note acceptance criteria
-   - Understand technical constraints
+   - Identify technical constraints
 
-2. **Plan Architecture**
-   - Determine files to create/modify
-   - Identify dependencies
-   - Plan data flow
+2. **Analyze Codebase**
+   - Read relevant maps in \`vibe/maps/\`
+   - Check knowledge base for related work
+   - Understand existing architecture
 
-3. **Break Down Steps**
-   - Create concrete implementation steps
-   - Order by dependencies
-   - Estimate complexity
+3. **Identify Modules**
+   - Break scope into logical modules
+   - Each module should be independently plannable
+   - Note dependencies between modules
 
-## Output Format
+4. **Create Plan Skeleton**
+   - Create plan file in \`vibe/implementation-plans/active/\`
+   - Add metadata and overview
+   - List identified modules
 
-Follow the PLAN_TEMPLATE.md structure.
+## Output
+
+Create plan file at \`vibe/implementation-plans/active/PLAN-{SCOPE_ID}.md\`:
+
+\`\`\`markdown
+# PLAN-{SCOPE_ID}: [Title from scope]
+
+## Metadata
+| Field | Value |
+|-------|-------|
+| Scope | {SCOPE_ID} |
+| Status | planning |
+| Created | [Date] |
+| Modules | [count] |
+
+## Overview
+[Brief description of what will be implemented]
+
+## Modules
+
+### Module 1: [Name]
+- Description: [What this module covers]
+- Requirements: [REQ-X, REQ-Y, ...]
+- Dependencies: [Other modules this depends on]
+- Status: pending
+
+### Module 2: [Name]
+- Description: [...]
+- Requirements: [...]
+- Dependencies: [...]
+- Status: pending
+
+[Continue for all modules...]
+
+## Requirements Coverage
+| Requirement | Module | Status |
+|-------------|--------|--------|
+| REQ-1 | Module 1 | planned |
+| REQ-2 | Module 2 | planned |
+
+## Progress Log
+[Will be updated as modules are planned]
+\`\`\`
+
+## Rules
+
+- Create 3-8 modules (too few = too complex, too many = too granular)
+- Ensure ALL requirements map to at least one module
+- Note dependencies to determine planning order
+- EXIT when plan skeleton is created
 `,
     },
-    // ralph-plan-module.md
+    // ralph-plan-module.md - Module planning prompt (REQ-12)
     {
         path: '.claude/prompts/ralph-plan-module.md',
-        content: `# Ralph Module Plan Prompt
+        content: `# Ralph Module Planning
 
-## Context
+You are planning **Module {MODULE_INDEX}** ({MODULE_NAME}) from scope:
+\`{SCOPE_PATH}\`
 
-Module: {{MODULE_NAME}}
-Requirements: {{REQUIREMENTS}}
+## Mission
 
-## Instructions
+Create detailed implementation steps for this module that can be executed autonomously.
 
-Create a focused plan for implementing this module:
+## Process
+
+1. **Read Context**
+   - Read the scope at \`{SCOPE_PATH}\`
+   - Read the plan file
+   - Focus on Module {MODULE_INDEX} requirements
 
-1. **Define Interface**
-   - Public API
-   - Types and interfaces
-   - Dependencies
+2. **Analyze Module**
+   - Understand what this module needs to accomplish
+   - Identify files to create or modify
+   - Note integration points with other modules
 
-2. **Implementation Steps**
-   - Core functionality
-   - Edge cases
-   - Error handling
+3. **Break Down Tasks**
+   - Create 3-7 concrete implementation tasks
+   - Each task should be completable in one session
+   - Order tasks by dependencies
 
-3. **Testing Strategy**
-   - Unit test scenarios
-   - Integration points
-   - Mock requirements
+4. **Define Acceptance Criteria**
+   - Create testable criteria for each task
+   - Map back to scope requirements
 
 ## Output
 
-Detailed steps for the module implementation.
+Update the plan file with detailed module plan:
+
+\`\`\`markdown
+### Module {MODULE_INDEX}: {MODULE_NAME}
+
+#### Overview
+[What this module implements]
+
+#### Tasks
+
+**Task 1: [Name]**
+- Description: [What to implement]
+- Files:
+  - Create: [new files]
+  - Modify: [existing files]
+- Steps:
+  1. [Specific step]
+  2. [Specific step]
+- AC: [Acceptance criteria]
+
+**Task 2: [Name]**
+- Description: [...]
+- Files: [...]
+- Steps: [...]
+- AC: [...]
+
+[Continue for all tasks...]
+
+#### Integration Points
+- [How this module connects to others]
+
+#### Test Strategy
+- [Unit tests needed]
+- [Integration tests needed]
+\`\`\`
+
+## Rules
+
+- Be specific - list actual file paths
+- Be actionable - steps should be clear enough for fresh-context execution
+- Be complete - don't leave gaps for "figuring out later"
+- Mark module status as "planned" when done
+- EXIT when complete
 `,
     },
-    // ralph-plan-validation.md
+    // ralph-plan-validation.md - Validation phase prompt (REQ-13)
     {
         path: '.claude/prompts/ralph-plan-validation.md',
-        content: `# Ralph Plan Validation Prompt
+        content: `# Ralph Plan Validation
 
-## Context
+You are validating the implementation plan created from scope:
+\`{SCOPE_PATH}\`
 
-Plan ID: {{PLAN_ID}}
-Plan Content: {{PLAN_CONTENT}}
-Scope Content: {{SCOPE_CONTENT}}
+## Mission
 
-## Instructions
+Ensure 100% requirement coverage and plan feasibility before execution begins.
 
-Validate that the plan adequately covers the scope:
+## Process
 
-1. **Requirement Coverage**
-   - Check each scope requirement has plan steps
-   - Verify acceptance criteria are addressable
-   - Note any gaps
+1. **Read Both Documents**
+   - Read the scope at \`{SCOPE_PATH}\`
+   - Read the complete plan file
 
-2. **Feasibility Check**
-   - Verify steps are concrete and actionable
-   - Check dependencies are identified
-   - Assess complexity estimates
+2. **Check Requirement Coverage**
+   - List every requirement from scope
+   - Verify each maps to at least one task
+   - Flag any gaps
 
-3. **Risk Assessment**
+3. **Check Acceptance Criteria**
+   - Verify scope ACs can be verified by plan tasks
+   - Ensure test strategy covers ACs
+
+4. **Check Feasibility**
+   - Verify tasks are specific and actionable
+   - Check for missing dependencies
    - Identify potential blockers
-   - Note technical risks
-   - Suggest mitigations
+
+5. **Final Review**
+   - Update coverage table
+   - Mark plan ready for execution
 
 ## Output
 
-Validation report with any issues or suggestions.
+Add validation section to plan:
+
+\`\`\`markdown
+## Validation Report
+
+### Validation Date
+[Date]
+
+### Requirement Coverage
+
+| Requirement | Description | Tasks | Status |
+|-------------|-------------|-------|--------|
+| REQ-1 | [desc] | Task 1.1, 1.2 | Covered |
+| REQ-2 | [desc] | Task 2.1 | Covered |
+| REQ-3 | [desc] | - | GAP |
+
+### Acceptance Criteria Coverage
+
+| AC | Description | Verification | Status |
+|----|-------------|--------------|--------|
+| AC-1 | [desc] | Task 1.3 test | Covered |
+| AC-2 | [desc] | Module 2 integration test | Covered |
+
+### Feasibility Assessment
+- [ ] All tasks are specific and actionable
+- [ ] Dependencies are clearly identified
+- [ ] No circular dependencies between modules
+- [ ] Test strategy is complete
+
+### Identified Risks
+- [Risk 1]: [Mitigation]
+- [Risk 2]: [Mitigation]
+
+### Gaps Found
+[List any gaps or issues, or "None - ready for execution"]
+
+### Recommendation
+- [ ] Ready for execution
+- [ ] Needs revision: [reasons]
+\`\`\`
+
+## Rules
+
+- Be thorough - missing coverage will cause execution failures
+- Be honest - flag issues now, not during execution
+- Update plan status to "ready" if validation passes
+- Update plan status to "needs_revision" if gaps found
+- EXIT when complete
 `,
     },
 ];

package/dist/core/repo/templates/claude-prompts.js.map

@@ -1 +1 @@
-{"version":3,"file":"claude-prompts.js","sourceRoot":"","sources":["../../../../src/core/repo/templates/claude-prompts.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,MAAM,CAAC,MAAM,aAAa,GAAmB;IAC3C,oBAAoB;IACpB;QACE,IAAI,EAAE,mCAAmC;QACzC,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDZ;KACE;IAED,qBAAqB;IACrB;QACE,IAAI,EAAE,oCAAoC;QAC1C,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BZ;KACE;IAED,mBAAmB;IACnB;QACE,IAAI,EAAE,kCAAkC;QACxC,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDZ;KACE;IAED,2BAA2B;IAC3B;QACE,IAAI,EAAE,0CAA0C;QAChD,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BZ;KACE;IAED,uBAAuB;IACvB;QACE,IAAI,EAAE,sCAAsC;QAC5C,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BZ;KACE;IAED,2BAA2B;IAC3B;QACE,IAAI,EAAE,0CAA0C;QAChD,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BZ;KACE;CACF,CAAC"}
+{"version":3,"file":"claude-prompts.js","sourceRoot":"","sources":["../../../../src/core/repo/templates/claude-prompts.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,MAAM,CAAC,MAAM,aAAa,GAAmB;IAC3C,oDAAoD;IACpD;QACE,IAAI,EAAE,mCAAmC;QACzC,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6EZ;KACE;IAED,qDAAqD;IACrD;QACE,IAAI,EAAE,oCAAoC;QAC1C,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkFZ;KACE;IAED,kDAAkD;IAClD;QACE,IAAI,EAAE,kCAAkC;QACxC,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8EZ;KACE;IAED,qEAAqE;IACrE;QACE,IAAI,EAAE,0CAA0C;QAChD,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkFZ;KACE;IAED,yDAAyD;IACzD;QACE,IAAI,EAAE,sCAAsC;QAC5C,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EZ;KACE;IAED,8DAA8D;IAC9D;QACE,IAAI,EAAE,0CAA0C;QAChD,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFZ;KACE;CACF,CAAC"}

package/dist/core/repo/templates/claude-scripts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claude-scripts.d.ts","sourceRoot":"","sources":["../../../../src/core/repo/templates/claude-scripts.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,eAAO,MAAM,aAAa,EAAE,YAAY,EA+MvC,CAAC"}
+{"version":3,"file":"claude-scripts.d.ts","sourceRoot":"","sources":["../../../../src/core/repo/templates/claude-scripts.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,eAAO,MAAM,aAAa,EAAE,YAAY,EA4pBvC,CAAC"}