vibe-fabric 0.4.0 → 0.4.2

package/.claude/prompts/ralph-cleanup.md

@@ -0,0 +1,86 @@
+# Ralph Cleanup Phase
+
+You are in **Ralph Cleanup Phase** for plan: `{PLAN_PATH}`
+
+All tasks have been executed. Your job is to verify and finalize.
+
+## CRITICAL RULES
+
+1. **DO NOT modify implementation** - Verification only
+2. **Run ALL quality checks**
+3. **Document final status**
+4. **EXIT when done**
+
+## Verification Steps
+
+### 1. Verify All Tasks Complete
+
+Read `{PLAN_PATH}` and check:
+- All tasks marked complete in Progress Log
+- No PLAN_BLOCKED markers remain
+- All acceptance criteria addressed
+
+### 2. Run Quality Checks
+
+```bash
+# TypeScript compilation
+npm run build
+
+# Linting
+npm run lint
+
+# Tests
+npm test
+```
+
+All must pass. If any fail:
+- Note the failures
+- Do NOT attempt fixes (that's a new task)
+- Mark in final status
+
+### 3. Verify File Changes
+
+Check that expected files were created/modified:
+- Compare against plan's "Key Files" section
+- Verify no unexpected changes
+
+### 4. Update Plan Final Status
+
+Add completion summary to plan:
+
+```markdown
+## Completion Summary
+
+**Status:** Complete / Partial / Blocked
+**Date:** [today]
+**Sessions:** [total sessions used]
+
+### Quality Check Results
+- Build: PASS / FAIL
+- Lint: PASS / FAIL
+- Tests: PASS / FAIL
+
+### Files Changed
+- `src/file1.ts` - Created
+- `src/file2.ts` - Modified
+
+### Notes
+[Any observations or follow-up items]
+```
+
+### 5. Checklist
+
+Mark in plan:
+- [ ] All tasks executed
+- [ ] Build passes
+- [ ] Lint passes
+- [ ] Tests pass
+- [ ] Progress log complete
+- [ ] Completion summary added
+
+## Exit Protocol
+
+1. Verify completion summary is in plan
+2. EXIT immediately
+
+The runner will move the plan to `completed/` folder.

package/.claude/prompts/ralph-execution.md

@@ -0,0 +1,82 @@
+# Ralph Task Execution
+
+You are executing **Task {CURRENT_TASK} of {TOTAL_TASKS}** from plan: `{PLAN_PATH}`
+
+## CRITICAL RULES
+
+1. **Complete ONLY Task {CURRENT_TASK}**
+   - Do NOT attempt other tasks
+   - Do NOT continue after this task
+
+2. **Fresh Context**
+   - You don't remember previous tasks
+   - Read the "Ralph Research Context" section for background
+   - Read the Progress Log for what's already done
+
+3. **Validation Required**
+   - Run `npm run build` after code changes
+   - Run `npm run lint` after code changes
+   - Fix issues before marking complete
+
+4. **Exit Protocol**
+   - Update Progress Log in plan
+   - Mark task complete
+   - EXIT immediately
+
+## Process
+
+### 1. Read Plan & Context
+
+```
+1. Read {PLAN_PATH}
+2. Find Task {CURRENT_TASK} specification
+3. Read "Ralph Research Context" section
+4. Read "Progress Log" for completed work
+```
+
+### 2. Execute Task
+
+Follow the task specification exactly:
+- Create/modify the specified files
+- Follow the conventions noted in research context
+- Use patterns from similar existing code
+
+### 3. Validate
+
+```bash
+npm run build   # Must pass
+npm run lint    # Must pass
+```
+
+Fix any errors before proceeding.
+
+### 4. Update Progress Log
+
+In the plan file, update the Progress Log table:
+
+```markdown
+| Task | Status | Started | Completed | Notes |
+|------|--------|---------|-----------|-------|
+| {CURRENT_TASK} | complete | [time] | [now] | [brief note] |
+```
+
+### 5. EXIT
+
+Do NOT continue to other tasks. Ralph runner handles session management.
+
+## Blocker Protocol
+
+If you cannot complete this task after 3 attempts:
+
+1. Add to plan: `### PLAN_BLOCKED: {description of blocker}`
+2. Document what you tried
+3. EXIT immediately
+
+The runner will detect the blocker and pause execution.
+
+## Remember
+
+- ONE task only
+- VALIDATE before marking complete
+- UPDATE progress log
+- EXIT when done

package/.claude/prompts/ralph-plan-extraction.md

@@ -0,0 +1,101 @@
+# Ralph Planning - Extraction Phase
+
+You are extracting requirements from scope: `{SCOPE_PATH}`
+
+## Your Mission
+
+Parse the scope into discrete modules/components that can each be planned in a separate session. This enables Ralph to create detailed plans without context exhaustion.
+
+## CRITICAL RULES
+
+1. **DO NOT create detailed plans yet** - Extraction only
+2. **Identify logical modules/components**
+3. **Save module list to state**
+4. **EXIT when done**
+
+## Process
+
+### 1. Read the Scope
+
+Read `{SCOPE_PATH}` completely. Understand:
+- All requirements (REQ-*)
+- Acceptance criteria (AC-*)
+- Technical constraints
+- Dependencies
+
+### 2. Identify Modules
+
+Break the scope into logical modules based on:
+- Functional boundaries (auth, API, UI, etc.)
+- File/directory structure
+- Dependency order
+
+Each module should be:
+- Self-contained enough to plan independently
+- Small enough for one planning session
+- Clear in its boundaries
+
+### 3. Create Tracker File
+
+Create `vibe/implementation-plans/active/{SCOPE_ID}-tracker.md`:
+
+```markdown
+# Planning Tracker: {SCOPE_ID}
+
+## Scope
+- Path: {SCOPE_PATH}
+- Status: planning
+
+## Modules
+
+| # | Module | Status | Plan File |
+|---|--------|--------|-----------|
+| 1 | {module-1} | pending | - |
+| 2 | {module-2} | pending | - |
+| 3 | {module-3} | pending | - |
+
+## Requirements Coverage
+
+| Requirement | Module |
+|-------------|--------|
+| REQ-1 | Module 1 |
+| REQ-2 | Module 2 |
+
+## Notes
+[Any extraction observations]
+```
+
+### 4. Create Requirements JSON
+
+Create `vibe/implementation-plans/active/{SCOPE_ID}-requirements.json`:
+
+```json
+{
+  "scope_id": "{SCOPE_ID}",
+  "scope_path": "{SCOPE_PATH}",
+  "modules": [
+    {
+      "id": 1,
+      "name": "module-name",
+      "requirements": ["REQ-1", "REQ-2"],
+      "dependencies": []
+    }
+  ],
+  "requirements": [
+    {
+      "id": "REQ-1",
+      "description": "...",
+      "acceptance_criteria": ["AC-1", "AC-2"]
+    }
+  ]
+}
+```
+
+## Exit Protocol
+
+1. Verify tracker file created
+2. Verify requirements JSON created
+3. Report module count
+4. EXIT immediately
+
+Do NOT proceed to module planning. Ralph runner will start fresh sessions.

package/.claude/prompts/ralph-plan-module.md

@@ -0,0 +1,101 @@
+# Ralph Planning - Module {MODULE_INDEX}
+
+You are planning **Module {MODULE_INDEX}: {MODULE_NAME}** for scope: `{SCOPE_PATH}`
+
+## CRITICAL RULES
+
+1. **Plan ONLY this module**
+2. **Fresh context** - Read tracker for what's planned
+3. **Create detailed implementation plan**
+4. **EXIT when done**
+
+## Process
+
+### 1. Read Context
+
+```
+1. Read {SCOPE_PATH} for full requirements
+2. Read tracker file for module list and status
+3. Read requirements JSON for module details
+4. Read any completed module plans for patterns
+```
+
+### 2. Analyze Module
+
+For this module, understand:
+- Which requirements it addresses
+- Dependencies on other modules
+- Files that will be created/modified
+- Technical approach
+
+### 3. Create Module Plan
+
+Create `vibe/implementation-plans/active/{SCOPE_ID}-{MODULE_NAME}.md`:
+
+```markdown
+# Module Plan: {MODULE_NAME}
+
+## Metadata
+
+| Field | Value |
+|-------|-------|
+| **Scope** | {SCOPE_ID} |
+| **Module** | {MODULE_INDEX} of N |
+| **Status** | planned |
+
+## Requirements Covered
+
+- REQ-X: Description
+- REQ-Y: Description
+
+## Implementation Phases
+
+### Phase 1: {Title}
+
+**Goal:** What this phase accomplishes
+
+**Tasks:**
+1. Task description
+2. Task description
+
+**Files:**
+- `src/path/file.ts` - What changes
+
+**Validation:**
+- How to verify this phase works
+
+### Phase 2: {Title}
+
+...
+
+## Dependencies
+
+- Depends on: [other modules]
+- Blocks: [modules waiting for this]
+
+## Risks
+
+- [Potential issues]
+- [Mitigation strategies]
+
+## Estimated Effort
+
+- Phases: N
+- Complexity: S/M/L
+```
+
+### 4. Update Tracker
+
+In the tracker file, update this module's row:
+
+```markdown
+| {MODULE_INDEX} | {MODULE_NAME} | planned | {plan-file-path} |
+```
+
+## Exit Protocol
+
+1. Verify module plan created
+2. Verify tracker updated
+3. EXIT immediately
+
+Do NOT proceed to other modules. Ralph runner handles session management.

package/.claude/prompts/ralph-plan-validation.md

@@ -0,0 +1,140 @@
+# Ralph Planning - Validation Phase
+
+All modules have been planned. Your job is to validate coverage and create the final combined plan.
+
+## CRITICAL RULES
+
+1. **DO NOT add new modules**
+2. **Verify 100% requirement coverage**
+3. **Create combined plan**
+4. **EXIT when done**
+
+## Process
+
+### 1. Load All Plans
+
+Read:
+- Tracker file for module list
+- Requirements JSON for all requirements
+- Each module plan file
+
+### 2. Verify Coverage
+
+Check that every requirement is covered:
+
+```
+For each REQ-* in scope:
+  - Find which module(s) address it
+  - Verify phases exist for implementation
+  - Check acceptance criteria are testable
+```
+
+Create coverage matrix:
+
+```markdown
+## Coverage Matrix
+
+| Requirement | Module | Phases | Status |
+|-------------|--------|--------|--------|
+| REQ-1 | auth | 1, 2 | Covered |
+| REQ-2 | api | 3 | Covered |
+| REQ-3 | - | - | MISSING |
+```
+
+### 3. Check Dependencies
+
+Verify module order is achievable:
+- No circular dependencies
+- Dependencies are planned before dependents
+- Clear execution order
+
+### 4. Create Combined Plan
+
+Create `vibe/implementation-plans/active/{PLAN_ID}.md`:
+
+```markdown
+# Implementation Plan: {SCOPE_TITLE}
+
+## Metadata
+
+| Field | Value |
+|-------|-------|
+| **Plan ID** | ILS-{YYYY}-{XXX} |
+| **Scope** | {SCOPE_ID} |
+| **Status** | active |
+| **Created** | {date} |
+| **Modules** | {count} |
+| **Total Phases** | {count} |
+
+## Summary
+
+{Description of what this plan implements}
+
+## Module Execution Order
+
+1. {module-1} - {brief description}
+2. {module-2} - {brief description}
+
+## Requirements Coverage
+
+| Requirement | Module | Status |
+|-------------|--------|--------|
+| REQ-1 | Module 1 | Covered |
+
+## Combined Phases
+
+### Phase 1 (Module: {name})
+{Include from module plan}
+
+### Phase 2 (Module: {name})
+{Include from module plan}
+
+...
+
+## Progress Log
+
+| Phase | Status | Started | Completed | Notes |
+|-------|--------|---------|-----------|-------|
+| 1 | pending | - | - | - |
+
+## Quality Checklist
+
+- [ ] All phases complete
+- [ ] Build passes
+- [ ] Lint passes
+- [ ] Tests pass
+```
+
+### 5. Update Tracker
+
+Mark planning complete:
+
+```markdown
+## Status: complete
+## Combined Plan: {plan-path}
+```
+
+## Validation Report
+
+If gaps found, report:
+
+```markdown
+## VALIDATION FAILED
+
+### Missing Coverage
+- REQ-X: Not covered by any module
+
+### Circular Dependencies
+- Module A depends on B depends on A
+
+### Recommendations
+- Add module for REQ-X
+- Reorder modules to break cycle
+```
+
+## Exit Protocol
+
+1. Verify coverage is 100% OR gaps documented
+2. Verify combined plan created
+3. Verify tracker updated
+4. EXIT immediately

package/.claude/prompts/ralph-research.md

@@ -0,0 +1,86 @@
+# Ralph Research Phase
+
+You are in **Ralph Research Phase** for plan: `{PLAN_PATH}`
+
+## Your Mission
+
+Gather all context needed for subsequent task execution sessions. Each task session will start with FRESH context, so your research must be comprehensive and saved to the plan file.
+
+## CRITICAL RULES
+
+1. **DO NOT execute any tasks** - Research only
+2. **Save ALL findings to the plan file** - Future sessions depend on this
+3. **Be thorough** - This is the only research phase
+4. **EXIT when done** - Do not continue to task execution
+
+## Research Steps
+
+### 1. Read the Plan
+
+Read `{PLAN_PATH}` completely. Understand:
+- All phases/tasks
+- Requirements being addressed
+- Acceptance criteria
+
+### 2. Analyze Codebase
+
+For each task, identify:
+- Key files that will be modified
+- Related files for context
+- Existing patterns to follow
+- Potential conflicts or dependencies
+
+### 3. Search Knowledge Base
+
+Check `vibe/knowledge-base/` for relevant entries:
+- Similar problems solved before
+- Patterns and conventions
+- Known gotchas
+
+### 4. Review Similar Work
+
+Look at:
+- `vibe/implementation-plans/completed/` for similar plans
+- Recent git commits for patterns
+- Existing code for conventions
+
+### 5. Document Findings
+
+Add a "Ralph Research Context" section to the plan with:
+
+```markdown
+## Ralph Research Context
+
+### Codebase Summary
+- Main patterns: [patterns found]
+- Key abstractions: [relevant classes/functions]
+- Test approach: [how tests are structured]
+
+### Key Files Per Task
+**Task 1:**
+- Primary: `src/path/file.ts`
+- Related: `src/path/related.ts`
+
+**Task 2:**
+- Primary: `src/path/other.ts`
+- Related: `tests/other.test.ts`
+
+### Knowledge Base Findings
+- [Entry title] - [relevance]
+
+### Potential Blockers
+- [Any issues discovered]
+
+### Conventions to Follow
+- [Naming conventions]
+- [Code style patterns]
+- [Import patterns]
+```
+
+## Exit Protocol
+
+1. Verify research context is saved to plan
+2. Verify all tasks have key files identified
+3. EXIT immediately
+
+Do NOT proceed to task execution. Ralph runner will start fresh sessions for tasks.

package/dist/cli/commands/analyze.d.ts

@@ -12,6 +12,7 @@ export declare class AnalyzeCommand extends Command {
     resume: boolean;
     repo: string | undefined;
     cancel: boolean;
+    force: boolean;
     execute(): Promise<number>;
     /**
      * Handle --cancel flag

package/dist/cli/commands/analyze.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/analyze.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAU,MAAM,WAAW,CAAC;AAY5C,qBAAa,cAAe,SAAQ,OAAO;IACzC,OAAgB,KAAK,aAAiB;IAEtC,OAAgB,KAAK,4BAmBlB;IAEH,KAAK,UAEF;IAEH,MAAM,UAEH;IAEH,IAAI,qBAED;IAEH,MAAM,UAEH;IAEG,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAuEhC;;OAEG;YACW,YAAY;IAwC1B;;OAEG;YACW,QAAQ;IAsBtB;;OAEG;YACW,cAAc;IA0D5B;;OAEG;YACW,WAAW;CAwE1B"}
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/analyze.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAU,MAAM,WAAW,CAAC;AAY5C,qBAAa,cAAe,SAAQ,OAAO;IACzC,OAAgB,KAAK,aAAiB;IAEtC,OAAgB,KAAK,4BAoBlB;IAEH,KAAK,UAEF;IAEH,MAAM,UAEH;IAEH,IAAI,qBAED;IAEH,MAAM,UAEH;IAEH,KAAK,UAEF;IAEG,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAuEhC;;OAEG;YACW,YAAY;IA2C1B;;OAEG;YACW,QAAQ;IAsBtB;;OAEG;YACW,cAAc;IAiE5B;;OAEG;YACW,WAAW;CAwE1B"}

package/dist/cli/commands/analyze.js

@@ -30,6 +30,7 @@ export class AnalyzeCommand extends Command {
             ['Check what would be analyzed', 'vibe analyze --check'],
             ['Resume interrupted analysis', 'vibe analyze --resume'],
             ['Cancel current operation', 'vibe analyze --cancel'],
+            ['Cancel and start fresh', 'vibe analyze --force'],
         ],
     });
     check = Option.Boolean('--check,-c', false, {
@@ -44,6 +45,9 @@ export class AnalyzeCommand extends Command {
     cancel = Option.Boolean('--cancel', false, {
         description: 'Cancel current operation',
     });
+    force = Option.Boolean('--force,-f', false, {
+        description: 'Cancel existing operation and start fresh without prompting',
+    });
     async execute() {
         // Find project root
         const projectRoot = findProjectRoot(process.cwd());
@@ -104,13 +108,16 @@ export class AnalyzeCommand extends Command {
             this.context.stdout.write(chalk.gray('Use the corresponding command to cancel it.\n'));
             return 1;
         }
-        const confirmed = await confirm({
-            message: 'Cancel analyze operation?',
-            default: false,
-        });
-        if (!confirmed) {
-            this.context.stdout.write(chalk.gray('Cancelled.\n'));
-            return 0;
+        // If --force is set, cancel without confirmation
+        if (!this.force) {
+            const confirmed = await confirm({
+                message: 'Cancel analyze operation?',
+                default: false,
+            });
+            if (!confirmed) {
+                this.context.stdout.write(chalk.gray('Cancelled.\n'));
+                return 0;
+            }
         }
         try {
             await cancelOperation(projectRoot);
@@ -149,6 +156,12 @@ export class AnalyzeCommand extends Command {
         // Check for existing operation
         const existing = await checkOperationInProgress(projectRoot);
         if (existing && !this.resume) {
+            // If --force is set, automatically cancel and start fresh
+            if (this.force) {
+                await cancelOperation(projectRoot);
+                this.context.stdout.write(chalk.green('Previous operation cancelled.\n\n'));
+                return this.startRunner(projectRoot, false);
+            }
             // Check if it's an analyze operation
             if (existing.operation !== 'analyze') {
                 this.context.stdout.write('\n');