vibe-fabric 0.1.0

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

@@ -0,0 +1,258 @@
+/**
+ * .claude/prompts/ templates
+ */
+export const claudePrompts = [
+    // ralph-research.md
+    {
+        path: '.claude/prompts/ralph-research.md',
+        content: `# Ralph Research Prompt
+
+## Context
+
+Plan ID: {{PLAN_ID}}
+Session Number: {{SESSION_NUMBER}}
+Previous Sessions: {{PREVIOUS_SESSIONS}}
+
+## Instructions
+
+Prepare for the next execution session by:
+
+1. **Review Progress**
+   - Read the plan file
+   - Check the progress log
+   - Identify completed vs pending steps
+
+2. **Gather Context**
+   - Read relevant source files
+   - Check knowledge base for related entries
+   - Review any error logs from previous sessions
+
+3. **Plan Next Steps**
+   - Identify 2-3 steps to accomplish this session
+   - Note any dependencies or blockers
+   - Prepare code context
+
+## Output Format
+
+\`\`\`markdown
+# Session {{SESSION_NUMBER}} Brief
+
+## Progress Summary
+- Steps completed: X/Y
+- Last completed: [step description]
+- Blockers: [any issues]
+
+## Next Steps
+1. [Step to do]
+2. [Step to do]
+
+## Context Files
+- path/to/file1.ts
+- path/to/file2.ts
+
+## Notes
+[Any relevant context or warnings]
+\`\`\`
+`,
+    },
+    // ralph-execution.md
+    {
+        path: '.claude/prompts/ralph-execution.md',
+        content: `# Ralph Execution Prompt
+
+## Context
+
+Plan ID: {{PLAN_ID}}
+Session Brief: {{SESSION_BRIEF}}
+Steps to Execute: {{STEPS}}
+
+## Instructions
+
+Execute the planned steps for this session:
+
+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
+
+## Guidelines
+
+- Make focused, incremental changes
+- Test after each significant change
+- Document any deviations from the plan
+- Note any issues for the cleanup phase
+
+## Output
+
+After execution, provide:
+- Summary of changes made
+- Files modified
+- Test results
+- Any issues encountered
+`,
+    },
+    // ralph-cleanup.md
+    {
+        path: '.claude/prompts/ralph-cleanup.md',
+        content: `# Ralph Cleanup Prompt
+
+## Context
+
+Plan ID: {{PLAN_ID}}
+Session Number: {{SESSION_NUMBER}}
+Execution Summary: {{EXECUTION_SUMMARY}}
+
+## Instructions
+
+Verify and clean up after the execution session:
+
+1. **Verify Changes**
+   - Review all modified files
+   - Ensure changes are correct
+   - Check for any leftover debug code
+
+2. **Run Tests**
+   - Run relevant unit tests
+   - Run integration tests if applicable
+   - Check for regressions
+
+3. **Update Documentation**
+   - Update progress log in the plan
+   - Check off completed acceptance criteria
+   - Add any KB entries for learnings
+
+4. **Prepare Handoff**
+   - Note any unfinished work
+   - Document blockers for next session
+   - Update plan status if complete
+
+## Output Format
+
+\`\`\`markdown
+# Session {{SESSION_NUMBER}} Summary
+
+## Changes Made
+- file1.ts: [description]
+- file2.ts: [description]
+
+## Test Results
+- [x] Unit tests pass
+- [ ] Integration tests pass
+
+## Acceptance Criteria
+- [x] AC-1: ...
+- [ ] AC-2: ...
+
+## Issues
+- [Issue description]
+
+## Next Session
+- [What to do next]
+\`\`\`
+`,
+    },
+    // ralph-plan-extraction.md
+    {
+        path: '.claude/prompts/ralph-plan-extraction.md',
+        content: `# Ralph Plan Extraction Prompt
+
+## Context
+
+Scope ID: {{SCOPE_ID}}
+Scope Content: {{SCOPE_CONTENT}}
+
+## Instructions
+
+Extract a detailed implementation plan from the scope:
+
+1. **Analyze Requirements**
+   - Identify all functional requirements
+   - Note acceptance criteria
+   - Understand technical constraints
+
+2. **Plan Architecture**
+   - Determine files to create/modify
+   - Identify dependencies
+   - Plan data flow
+
+3. **Break Down Steps**
+   - Create concrete implementation steps
+   - Order by dependencies
+   - Estimate complexity
+
+## Output Format
+
+Follow the PLAN_TEMPLATE.md structure.
+`,
+    },
+    // ralph-plan-module.md
+    {
+        path: '.claude/prompts/ralph-plan-module.md',
+        content: `# Ralph Module Plan Prompt
+
+## Context
+
+Module: {{MODULE_NAME}}
+Requirements: {{REQUIREMENTS}}
+
+## Instructions
+
+Create a focused plan for implementing this module:
+
+1. **Define Interface**
+   - Public API
+   - Types and interfaces
+   - Dependencies
+
+2. **Implementation Steps**
+   - Core functionality
+   - Edge cases
+   - Error handling
+
+3. **Testing Strategy**
+   - Unit test scenarios
+   - Integration points
+   - Mock requirements
+
+## Output
+
+Detailed steps for the module implementation.
+`,
+    },
+    // ralph-plan-validation.md
+    {
+        path: '.claude/prompts/ralph-plan-validation.md',
+        content: `# Ralph Plan Validation Prompt
+
+## Context
+
+Plan ID: {{PLAN_ID}}
+Plan Content: {{PLAN_CONTENT}}
+Scope Content: {{SCOPE_CONTENT}}
+
+## Instructions
+
+Validate that the plan adequately covers the scope:
+
+1. **Requirement Coverage**
+   - Check each scope requirement has plan steps
+   - Verify acceptance criteria are addressable
+   - Note any gaps
+
+2. **Feasibility Check**
+   - Verify steps are concrete and actionable
+   - Check dependencies are identified
+   - Assess complexity estimates
+
+3. **Risk Assessment**
+   - Identify potential blockers
+   - Note technical risks
+   - Suggest mitigations
+
+## Output
+
+Validation report with any issues or suggestions.
+`,
+    },
+];
+//# sourceMappingURL=claude-prompts.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,6 @@
+/**
+ * .claude/scripts/ templates
+ */
+import type { TemplateFile } from './index.js';
+export declare const claudeScripts: TemplateFile[];
+//# sourceMappingURL=claude-scripts.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,212 @@
+/**
+ * .claude/scripts/ templates
+ */
+export const claudeScripts = [
+    // ralph-runner.py - Unified Ralph executor
+    {
+        path: '.claude/scripts/ralph-runner.py',
+        content: `#!/usr/bin/env -S uv run --quiet --script
+# /// script
+# requires-python = ">=3.11"
+# dependencies = ["pydantic", "rich"]
+# ///
+"""
+Ralph Runner - Autonomous multi-session executor for vibe-fabric.
+
+This script manages autonomous execution loops for implementing plans
+or creating plans from scopes. It handles:
+- Session state persistence
+- Progress tracking
+- Error recovery
+- Notification hooks
+
+Usage:
+    uv run ralph-runner.py --mode execute --plan PLAN-ID --loop
+    uv run ralph-runner.py --mode plan --scope SCOPE-ID --loop
+    uv run ralph-runner.py --status
+    uv run ralph-runner.py --cancel
+"""
+
+import argparse
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+try:
+    from pydantic import BaseModel
+    from rich.console import Console
+    from rich.panel import Panel
+except ImportError:
+    print("Dependencies not available. Run with: uv run ralph-runner.py")
+    sys.exit(1)
+
+console = Console()
+
+# State file location
+STATE_FILE = Path(".claude/ralph-state.json")
+
+
+class RalphState(BaseModel):
+    """Persistent state for Ralph sessions."""
+    active: bool = False
+    mode: str = "execute"  # execute or plan
+    target_id: str = ""  # PLAN-ID or SCOPE-ID
+    session_number: int = 0
+    started_at: Optional[str] = None
+    last_session_at: Optional[str] = None
+    sessions_completed: int = 0
+    status: str = "idle"  # idle, running, paused, completed, failed
+
+
+def load_state() -> RalphState:
+    """Load state from file."""
+    if STATE_FILE.exists():
+        try:
+            data = json.loads(STATE_FILE.read_text())
+            return RalphState(**data)
+        except Exception:
+            return RalphState()
+    return RalphState()
+
+
+def save_state(state: RalphState) -> None:
+    """Save state to file."""
+    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    STATE_FILE.write_text(state.model_dump_json(indent=2))
+
+
+def show_status() -> None:
+    """Display current Ralph status."""
+    state = load_state()
+
+    if not state.active:
+        console.print("[dim]Ralph is not active[/dim]")
+        return
+
+    status_color = {
+        "running": "green",
+        "paused": "yellow",
+        "completed": "blue",
+        "failed": "red",
+    }.get(state.status, "white")
+
+    console.print(Panel(
+        f"[bold]Mode:[/bold] {state.mode}\\n"
+        f"[bold]Target:[/bold] {state.target_id}\\n"
+        f"[bold]Status:[/bold] [{status_color}]{state.status}[/{status_color}]\\n"
+        f"[bold]Sessions:[/bold] {state.sessions_completed}\\n"
+        f"[bold]Started:[/bold] {state.started_at or 'N/A'}\\n"
+        f"[bold]Last Session:[/bold] {state.last_session_at or 'N/A'}",
+        title="Ralph Status",
+    ))
+
+
+def start_session(mode: str, target_id: str, loop: bool) -> None:
+    """Start a Ralph session."""
+    state = load_state()
+
+    if state.active and state.status == "running":
+        console.print("[red]Ralph is already running. Use --cancel first.[/red]")
+        return
+
+    state.active = True
+    state.mode = mode
+    state.target_id = target_id
+    state.status = "running"
+    state.started_at = datetime.now().isoformat()
+    state.session_number += 1
+
+    save_state(state)
+
+    console.print(f"[green]Starting Ralph {mode} for {target_id}[/green]")
+
+    if mode == "execute":
+        run_execute_session(target_id, state.session_number)
+    else:
+        run_plan_session(target_id, state.session_number)
+
+    # Update state after session
+    state = load_state()
+    state.sessions_completed += 1
+    state.last_session_at = datetime.now().isoformat()
+
+    if not loop:
+        state.active = False
+        state.status = "completed"
+
+    save_state(state)
+
+
+def run_execute_session(plan_id: str, session_number: int) -> None:
+    """Run an execution session."""
+    console.print(f"[cyan]Session {session_number}: Executing {plan_id}[/cyan]")
+
+    # In a real implementation, this would:
+    # 1. Call Claude Code with the research agent
+    # 2. Call Claude Code with execution prompts
+    # 3. Call Claude Code with cleanup agent
+
+    console.print("[yellow]Note: Ralph loop not fully implemented yet.[/yellow]")
+    console.print("Use /implement-plan for interactive execution.")
+
+
+def run_plan_session(scope_id: str, session_number: int) -> None:
+    """Run a planning session."""
+    console.print(f"[cyan]Session {session_number}: Planning from {scope_id}[/cyan]")
+
+    # In a real implementation, this would:
+    # 1. Read the scope
+    # 2. Call Claude Code with planning prompts
+    # 3. Create the plan file
+
+    console.print("[yellow]Note: Ralph loop not fully implemented yet.[/yellow]")
+    console.print("Use /plan-from-scope for interactive planning.")
+
+
+def cancel_session() -> None:
+    """Cancel the active Ralph session."""
+    state = load_state()
+
+    if not state.active:
+        console.print("[dim]No active Ralph session[/dim]")
+        return
+
+    state.active = False
+    state.status = "cancelled"
+    save_state(state)
+
+    console.print("[yellow]Ralph session cancelled[/yellow]")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Ralph autonomous executor")
+    parser.add_argument("--mode", choices=["execute", "plan"], help="Execution mode")
+    parser.add_argument("--plan", help="Plan ID for execute mode")
+    parser.add_argument("--scope", help="Scope ID for plan mode")
+    parser.add_argument("--loop", action="store_true", help="Run in loop mode")
+    parser.add_argument("--status", action="store_true", help="Show status")
+    parser.add_argument("--cancel", action="store_true", help="Cancel active session")
+
+    args = parser.parse_args()
+
+    if args.status:
+        show_status()
+    elif args.cancel:
+        cancel_session()
+    elif args.mode == "execute" and args.plan:
+        start_session("execute", args.plan, args.loop)
+    elif args.mode == "plan" and args.scope:
+        start_session("plan", args.scope, args.loop)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()
+`,
+    },
+];
+//# sourceMappingURL=claude-scripts.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claude-scripts.js","sourceRoot":"","sources":["../../../../src/core/repo/templates/claude-scripts.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,MAAM,CAAC,MAAM,aAAa,GAAmB;IAC3C,2CAA2C;IAC3C;QACE,IAAI,EAAE,iCAAiC;QACvC,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyMZ;KACE;CACF,CAAC"}

package/dist/core/repo/templates/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Framework file templates for dev repository injection
+ *
+ * These templates are injected into dev repositories when running `vibe repo add`.
+ * They create the vibe/ and .claude/ folder structure.
+ */
+/**
+ * Template file definition
+ */
+export interface TemplateFile {
+    path: string;
+    content: string;
+}
+/**
+ * Get all framework files to inject
+ */
+export declare function getFrameworkFiles(): TemplateFile[];
+/**
+ * Get all framework file paths (for detection)
+ */
+export declare function getFrameworkFilePaths(): string[];
+//# sourceMappingURL=index.d.ts.map

package/dist/core/repo/templates/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/repo/templates/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,YAAY,EAAE,CAiClD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,EAAE,CAEhD"}

package/dist/core/repo/templates/index.js

@@ -0,0 +1,121 @@
+/**
+ * Framework file templates for dev repository injection
+ *
+ * These templates are injected into dev repositories when running `vibe repo add`.
+ * They create the vibe/ and .claude/ folder structure.
+ */
+import { vibeReadmes } from './vibe-readme.js';
+import { claudeCommands } from './claude-commands.js';
+import { claudeAgents } from './claude-agents.js';
+import { claudePrompts } from './claude-prompts.js';
+import { claudeScripts } from './claude-scripts.js';
+import { vibeScripts } from './vibe-scripts.js';
+/**
+ * Get all framework files to inject
+ */
+export function getFrameworkFiles() {
+    return [
+        // vibe/ folder
+        ...vibeReadmes,
+        ...vibeScripts,
+        // .claude/ folder
+        ...claudeCommands,
+        ...claudeAgents,
+        ...claudePrompts,
+        ...claudeScripts,
+        // .claude/CLAUDE.md
+        {
+            path: '.claude/CLAUDE.md',
+            content: getCLAUDEmd(),
+        },
+        // .claude/settings.local.json
+        {
+            path: '.claude/settings.local.json',
+            content: getSettingsLocalJson(),
+        },
+        // Gitkeep files for empty directories
+        { path: 'vibe/incoming-scopes/processed/.gitkeep', content: '' },
+        { path: 'vibe/implementation-plans/active/.gitkeep', content: '' },
+        { path: 'vibe/implementation-plans/completed/.gitkeep', content: '' },
+        { path: 'vibe/implementation-plans/archived/.gitkeep', content: '' },
+        { path: 'vibe/maps/.gitkeep', content: '' },
+        { path: 'vibe/graphs/.gitkeep', content: '' },
+        { path: '.claude/rules/.gitkeep', content: '' },
+    ];
+}
+/**
+ * Get all framework file paths (for detection)
+ */
+export function getFrameworkFilePaths() {
+    return getFrameworkFiles().map((f) => f.path);
+}
+/**
+ * CLAUDE.md template - project context for Claude Code
+ */
+function getCLAUDEmd() {
+    return `# Project Context
+
+This repository is managed with vibe-fabric, an AI-collaborative development system.
+
+## Framework Structure
+
+- \`vibe/incoming-scopes/\` - Scope briefs from planning hub
+- \`vibe/implementation-plans/\` - Implementation plans for scopes
+- \`vibe/knowledge-base/\` - Accumulated learnings and documentation
+- \`vibe/maps/\` - Generated codebase maps
+- \`vibe/graphs/\` - Dependency analysis
+
+## Workflow
+
+1. Scopes arrive in \`vibe/incoming-scopes/\`
+2. Create implementation plan: \`/plan-from-scope SCOPE-XXX\`
+3. Implement the plan: \`/implement-plan PLAN-XXX\` or use Ralph
+4. Document learnings in \`vibe/knowledge-base/\`
+5. Move completed plans to \`implementation-plans/completed/\`
+
+## Available Commands
+
+- \`/plan-from-scope\` - Create implementation plan from scope
+- \`/implement-plan\` - Execute plan interactively
+- \`/ralph execute\` - Autonomous multi-session execution
+- \`/ralph plan\` - Autonomous planning from scope
+- \`/kb\` - Search knowledge base
+- \`/kb-add\` - Add entry to knowledge base
+- \`/sync\` - Generate codebase map
+- \`/deps\` - Analyze dependencies
+- \`/impact\` - Analyze change impact
+
+## Tech Stack
+
+<!-- Auto-detected or manually specified -->
+- **Framework:** [To be detected]
+- **Language:** [To be detected]
+- **Build:** [To be detected]
+
+## Key Patterns
+
+<!-- Add project-specific patterns here -->
+
+## Important Files
+
+<!-- Add key files to be aware of -->
+`;
+}
+/**
+ * settings.local.json template - Claude Code permissions
+ */
+function getSettingsLocalJson() {
+    return JSON.stringify({
+        permissions: {
+            allow: [
+                'Bash(npm run typecheck:*)',
+                'Bash(npm run lint:*)',
+                'Bash(npm run build:*)',
+                'Bash(npm run test:*)',
+                'Bash(npx tsx:*)',
+                'Bash(uv run:*)',
+            ],
+        },
+    }, null, 2);
+}
+//# sourceMappingURL=index.js.map

package/dist/core/repo/templates/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/core/repo/templates/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAUhD;;GAEG;AACH,MAAM,UAAU,iBAAiB;IAC/B,OAAO;QACL,eAAe;QACf,GAAG,WAAW;QACd,GAAG,WAAW;QAEd,kBAAkB;QAClB,GAAG,cAAc;QACjB,GAAG,YAAY;QACf,GAAG,aAAa;QAChB,GAAG,aAAa;QAEhB,oBAAoB;QACpB;YACE,IAAI,EAAE,mBAAmB;YACzB,OAAO,EAAE,WAAW,EAAE;SACvB;QAED,8BAA8B;QAC9B;YACE,IAAI,EAAE,6BAA6B;YACnC,OAAO,EAAE,oBAAoB,EAAE;SAChC;QAED,sCAAsC;QACtC,EAAE,IAAI,EAAE,yCAAyC,EAAE,OAAO,EAAE,EAAE,EAAE;QAChE,EAAE,IAAI,EAAE,2CAA2C,EAAE,OAAO,EAAE,EAAE,EAAE;QAClE,EAAE,IAAI,EAAE,8CAA8C,EAAE,OAAO,EAAE,EAAE,EAAE;QACrE,EAAE,IAAI,EAAE,6CAA6C,EAAE,OAAO,EAAE,EAAE,EAAE;QACpE,EAAE,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,EAAE,EAAE;QAC3C,EAAE,IAAI,EAAE,sBAAsB,EAAE,OAAO,EAAE,EAAE,EAAE;QAC7C,EAAE,IAAI,EAAE,wBAAwB,EAAE,OAAO,EAAE,EAAE,EAAE;KAChD,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,qBAAqB;IACnC,OAAO,iBAAiB,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAChD,CAAC;AAED;;GAEG;AACH,SAAS,WAAW;IAClB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CR,CAAC;AACF,CAAC;AAED;;GAEG;AACH,SAAS,oBAAoB;IAC3B,OAAO,IAAI,CAAC,SAAS,CACnB;QACE,WAAW,EAAE;YACX,KAAK,EAAE;gBACL,2BAA2B;gBAC3B,sBAAsB;gBACtB,uBAAuB;gBACvB,sBAAsB;gBACtB,iBAAiB;gBACjB,gBAAgB;aACjB;SACF;KACF,EACD,IAAI,EACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/core/repo/templates/vibe-readme.d.ts

@@ -0,0 +1,6 @@
+/**
+ * vibe/ folder README templates
+ */
+import type { TemplateFile } from './index.js';
+export declare const vibeReadmes: TemplateFile[];
+//# sourceMappingURL=vibe-readme.d.ts.map

package/dist/core/repo/templates/vibe-readme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vibe-readme.d.ts","sourceRoot":"","sources":["../../../../src/core/repo/templates/vibe-readme.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,eAAO,MAAM,WAAW,EAAE,YAAY,EA4MrC,CAAC"}