vibe-fabric 0.1.0

package/dist/core/project.js

@@ -0,0 +1,810 @@
+import { mkdir, writeFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import path from 'path';
+import { saveConfig } from './config.js';
+import { generatePlanningHubCommands, ensureCustomCommandsDir } from './commands.js';
+/**
+ * Planning hub directory structure
+ */
+const DIRECTORY_STRUCTURE = [
+    'docs/prd/vision',
+    'docs/prd/modules',
+    'docs/scopes/drafts',
+    'docs/scopes/ready',
+    'docs/scopes/sent',
+    'docs/scopes/completed',
+    'docs/sync-cache',
+    '.claude/commands',
+    '.claude/scripts',
+    '.claude/prompts',
+];
+/**
+ * Create a new planning hub directory structure
+ */
+export async function createPlanningHub(projectPath, projectName, projectType) {
+    // Create root directory if it doesn't exist
+    if (!existsSync(projectPath)) {
+        await mkdir(projectPath, { recursive: true });
+    }
+    // Create all subdirectories
+    for (const dir of DIRECTORY_STRUCTURE) {
+        const dirPath = path.join(projectPath, dir);
+        await mkdir(dirPath, { recursive: true });
+    }
+    // Create initial config
+    const config = {
+        project: {
+            name: projectName,
+            created: new Date().toISOString(),
+            type: projectType,
+        },
+        repos: [],
+    };
+    await saveConfig(projectPath, config);
+    // Create initial files
+    await createInitialFiles(projectPath, projectName);
+    // Generate Claude commands for planning hub
+    await generatePlanningHubCommands(projectPath);
+    await ensureCustomCommandsDir(projectPath);
+    // Copy vibe-runner.py to .claude/scripts/
+    await createRunnerScript(projectPath);
+}
+/**
+ * Create initial files for the planning hub
+ */
+async function createInitialFiles(projectPath, projectName) {
+    // CLAUDE.md - Project context for AI
+    const claudeMd = `# ${projectName}
+
+> Project context for Claude Code
+
+## Overview
+
+This is a vibe-fabric planning hub for coordinating development across repositories.
+
+## Structure
+
+- \`docs/prd/\` - Product Requirements Documents
+- \`docs/scopes/\` - Scope briefs for development
+- \`docs/sync-cache/\` - Synced data from repositories
+- \`.claude/\` - Claude Code commands and scripts
+
+## Getting Started
+
+1. Add repositories: \`vibe repo add\`
+2. Create PRD: \`vibe prd\`
+3. Create scopes: \`vibe scope\`
+4. Send to repos: \`vibe send <scope-id>\`
+5. Sync progress: \`vibe sync\`
+
+## Commands
+
+Run \`vibe --help\` for available commands.
+`;
+    // .gitignore for the planning hub
+    const gitignore = `# Environment
+.env
+.env.local
+
+# Claude runner artifacts
+.claude/vibe-state.json
+.claude/outputs/
+.claude/temp-prompt.md
+
+# Sync cache (large, can be regenerated)
+docs/sync-cache/*/maps/
+
+# OS files
+.DS_Store
+Thumbs.db
+`;
+    // PRD index
+    const prdIndex = `# ${projectName} - Product Requirements
+
+> Living PRD managed by vibe-fabric
+
+## Status
+
+| Metric | Value |
+|--------|-------|
+| Modules | 0 |
+| Requirements | 0 |
+| Coverage | 0% |
+
+## Modules
+
+_No modules yet. Run \`vibe prd\` to create requirements._
+
+---
+
+*Last updated: ${new Date().toISOString().split('T')[0]}*
+`;
+    // Write files
+    await writeFile(path.join(projectPath, 'CLAUDE.md'), claudeMd, 'utf-8');
+    await writeFile(path.join(projectPath, '.gitignore'), gitignore, 'utf-8');
+    await writeFile(path.join(projectPath, 'docs/prd/_index.md'), prdIndex, 'utf-8');
+}
+/**
+ * Check if a path is inside an existing vibe-fabric project
+ */
+export function isInsideVibeProject(dirPath) {
+    let currentPath = dirPath;
+    while (currentPath !== path.dirname(currentPath)) {
+        if (existsSync(path.join(currentPath, 'vibe-fabric.toml'))) {
+            return true;
+        }
+        currentPath = path.dirname(currentPath);
+    }
+    return false;
+}
+/**
+ * Get the root of the current vibe-fabric project
+ */
+export function findProjectRoot(startPath) {
+    let currentPath = startPath;
+    while (currentPath !== path.dirname(currentPath)) {
+        if (existsSync(path.join(currentPath, 'vibe-fabric.toml'))) {
+            return currentPath;
+        }
+        currentPath = path.dirname(currentPath);
+    }
+    return null;
+}
+/**
+ * Create the vibe-runner.py script in .claude/scripts/
+ */
+async function createRunnerScript(projectPath) {
+    const runnerScript = `#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "rich>=13.0.0",
+#     "pydantic>=2.0.0",
+# ]
+# ///
+"""
+Unified vibe-fabric runner for AI operations.
+
+This script orchestrates multi-session Claude interactions using the
+Assess → Break → Execute → Approve pattern.
+
+Usage:
+    uv run vibe-runner.py --operation prd --project /path/to/project
+    uv run vibe-runner.py --operation prd --project /path/to/project --loop
+    uv run vibe-runner.py --resume
+    uv run vibe-runner.py --cancel
+"""
+
+import argparse
+import json
+import os
+import shutil
+import signal
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+console = Console()
+
+# Constants
+STATE_FILE = ".claude/vibe-state.json"
+OUTPUT_DIR = ".claude/outputs"
+PROMPTS_DIR = ".claude/prompts"
+TEMP_PROMPT_FILE = ".claude/temp-prompt.md"
+
+
+class Task(BaseModel):
+    """Represents a single task in the operation."""
+
+    id: int
+    name: str
+    description: str
+    prompt: str
+    interactive: bool = False
+    context: dict[str, Any] = Field(default_factory=dict)
+    status: str = "pending"  # pending, in_progress, complete, failed
+
+
+class OperationState(BaseModel):
+    """Persistent state for an operation."""
+
+    operation: str
+    project_path: str
+    phase: str = "assess"  # assess, execute, approve, complete
+    total_tasks: int = 0
+    current_task: int = 0
+    tasks: list[Task] = Field(default_factory=list)
+    outputs: list[str] = Field(default_factory=list)
+    discovery_output: dict[str, Any] = Field(default_factory=dict)
+    started_at: str = ""
+    updated_at: str = ""
+
+
+def get_timestamp() -> str:
+    """Get current UTC timestamp in ISO format."""
+    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def save_state(state: OperationState) -> None:
+    """Save operation state to file."""
+    state.updated_at = get_timestamp()
+    state_path = Path(state.project_path) / STATE_FILE
+    state_path.parent.mkdir(parents=True, exist_ok=True)
+    state_path.write_text(state.model_dump_json(indent=2))
+
+
+def load_state(project_path: str) -> Optional[OperationState]:
+    """Load operation state from file."""
+    state_path = Path(project_path) / STATE_FILE
+    try:
+        content = state_path.read_text()
+        return OperationState.model_validate_json(content)
+    except FileNotFoundError:
+        return None
+    except Exception as e:
+        console.print(f"[red]Error loading state: {e}[/red]")
+        return None
+
+
+def delete_state(project_path: str) -> None:
+    """Delete state file."""
+    state_path = Path(project_path) / STATE_FILE
+    state_path.unlink(missing_ok=True)
+
+
+def clear_claude_cache() -> None:
+    """Clear Claude cache for fresh context.
+
+    This ensures each task starts with a clean context.
+    The cache location varies by platform.
+    """
+    # Common Claude cache locations
+    cache_dirs = [
+        Path.home() / ".claude" / "cache",
+        Path.home() / ".cache" / "claude",
+    ]
+
+    for cache_dir in cache_dirs:
+        if cache_dir.exists():
+            try:
+                shutil.rmtree(cache_dir)
+            except Exception:
+                pass  # Ignore errors - cache clearing is best effort
+
+
+def parse_prompt_variables(template: str) -> list[dict[str, Any]]:
+    """Parse the Variables table from a prompt template.
+
+    Returns list of dicts with keys: name, description, required
+    """
+    import re
+
+    variables = []
+
+    # Find the Variables section table
+    variables_match = re.search(
+        r'## Variables\\s*\\n\\n\\|[^\\n]+\\|\\s*\\n\\|[-|\\s]+\\|\\s*\\n((?:\\|[^\\n]+\\|\\s*\\n?)+)',
+        template
+    )
+    if not variables_match:
+        return variables
+
+    table_rows = variables_match.group(1).strip().split('\\n')
+
+    for row in table_rows:
+        # Parse table row: | {VAR} | Description | Required |
+        cells = [c.strip() for c in row.split('|') if c.strip()]
+        if len(cells) >= 2:
+            var_match = re.search(r'\\{([A-Z][A-Z0-9_]*)\\}', cells[0])
+            if var_match:
+                variables.append({
+                    'name': var_match.group(1),
+                    'description': cells[1],
+                    'required': cells[2].lower() == 'yes' if len(cells) > 2 else True
+                })
+
+    return variables
+
+
+def extract_template_variables(template: str) -> set[str]:
+    """Extract all variable references from a template."""
+    import re
+    return set(re.findall(r'\\{([A-Z][A-Z0-9_]*)\\}', template))
+
+
+def validate_variables(template: str, variables: dict[str, str]) -> tuple[bool, list[str]]:
+    """Validate that all required variables are provided.
+
+    Returns (valid, list of error messages).
+    """
+    errors = []
+
+    # Parse declared variables
+    declared_vars = parse_prompt_variables(template)
+    provided_keys = set(variables.keys())
+
+    # Check required variables
+    for declared in declared_vars:
+        if declared['required'] and declared['name'] not in provided_keys:
+            errors.append(f"Missing required variable: {{{declared['name']}}}")
+
+    return len(errors) == 0, errors
+
+
+def check_unsubstituted_variables(content: str) -> list[str]:
+    """Check for any remaining unsubstituted variables in content."""
+    return list(extract_template_variables(content))
+
+
+def fill_prompt_template(template_path: Path, variables: dict[str, str]) -> str:
+    """Fill a prompt template with variables.
+
+    Raises ValueError if required variables are missing or unsubstituted.
+    """
+    if not template_path.exists():
+        raise FileNotFoundError(f"Prompt template not found: {template_path}")
+
+    template = template_path.read_text()
+
+    # Validate required variables before substitution
+    valid, errors = validate_variables(template, variables)
+    if not valid:
+        error_msg = "Variable validation failed:\\n  " + "\\n  ".join(errors)
+        raise ValueError(error_msg)
+
+    # Replace {VARIABLE} patterns
+    result = template
+    for key, value in variables.items():
+        result = result.replace(f"{{{key}}}", str(value))
+
+    # Check for unsubstituted variables (fail fast)
+    remaining = check_unsubstituted_variables(result)
+    if remaining:
+        raise ValueError(f"Unsubstituted variables in template: {remaining}")
+
+    return result
+
+
+def spawn_claude_session(
+    project_path: str,
+    prompt_content: str,
+    interactive: bool = True,
+) -> bool:
+    """Spawn a Claude Code session with the given prompt.
+
+    Returns True if session completed successfully.
+    """
+    # Write prompt to temp file
+    temp_prompt = Path(project_path) / TEMP_PROMPT_FILE
+    temp_prompt.parent.mkdir(parents=True, exist_ok=True)
+    temp_prompt.write_text(prompt_content)
+
+    try:
+        # Spawn Claude with the prompt
+        # Using --print for non-interactive mode, regular for interactive
+        cmd = ["claude"]
+        if not interactive:
+            cmd.extend(["--print"])
+        cmd.extend(["--prompt", str(temp_prompt)])
+
+        result = subprocess.run(
+            cmd,
+            cwd=project_path,
+            check=False,
+        )
+
+        return result.returncode == 0
+
+    except FileNotFoundError:
+        console.print(
+            "[red]Error: Claude Code not found. Please install Claude Code first.[/red]"
+        )
+        console.print(
+            "[dim]Visit: https://claude.ai/code[/dim]"
+        )
+        return False
+
+    except Exception as e:
+        console.print(f"[red]Error spawning Claude: {e}[/red]")
+        return False
+
+    finally:
+        # Clean up temp prompt file
+        temp_prompt.unlink(missing_ok=True)
+
+
+def run_assessment(state: OperationState) -> bool:
+    """Run the assessment/discovery phase.
+
+    This phase:
+    1. Analyzes current state (PRD, maps, scopes)
+    2. Identifies issues and opportunities
+    3. Asks user about their intent
+    4. Creates a task list
+
+    Returns True if successful.
+    """
+    console.print()
+    console.print(
+        Panel(
+            "[bold blue]Discovery Phase[/bold blue]\\n"
+            "Analyzing PRD state and determining tasks...",
+            title="Phase 1/3",
+            border_style="blue",
+        )
+    )
+    console.print()
+
+    prompt_path = (
+        Path(state.project_path) / PROMPTS_DIR / state.operation / "assess.md"
+    )
+    output_file = Path(state.project_path) / OUTPUT_DIR / f"{state.operation}-assess.json"
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    # Fill template
+    try:
+        prompt_content = fill_prompt_template(
+            prompt_path,
+            {
+                "PROJECT_PATH": state.project_path,
+                "OUTPUT_FILE": str(output_file),
+            },
+        )
+    except FileNotFoundError:
+        console.print(f"[red]Prompt template not found: {prompt_path}[/red]")
+        console.print(
+            "[dim]Run 'vibe init' to set up prompt templates.[/dim]"
+        )
+        return False
+
+    # Clear cache and run Claude
+    clear_claude_cache()
+    success = spawn_claude_session(state.project_path, prompt_content, interactive=True)
+
+    if not success:
+        console.print("[red]Discovery phase failed.[/red]")
+        return False
+
+    # Load tasks from assessment output
+    if output_file.exists():
+        try:
+            result = json.loads(output_file.read_text())
+            state.tasks = [Task(**t) for t in result.get("tasks", [])]
+            state.total_tasks = len(state.tasks)
+            state.discovery_output = result
+            console.print(
+                f"[green]Created {state.total_tasks} task(s) to execute.[/green]"
+            )
+        except Exception as e:
+            console.print(f"[yellow]Warning: Could not parse assessment output: {e}[/yellow]")
+            # Continue even if parsing fails - Claude may have handled it differently
+
+    state.phase = "execute"
+    save_state(state)
+    return True
+
+
+def run_task(state: OperationState, task: Task) -> bool:
+    """Execute a single task.
+
+    Returns True if successful.
+    """
+    console.print()
+    console.print(
+        f"[bold]Task {task.id}/{state.total_tasks}:[/bold] {task.description}"
+    )
+
+    if task.interactive:
+        console.print("[dim]This task requires your input.[/dim]")
+    else:
+        console.print("[dim]Running silently...[/dim]")
+
+    prompt_path = (
+        Path(state.project_path) / PROMPTS_DIR / state.operation / f"{task.prompt}.md"
+    )
+    output_file = (
+        Path(state.project_path) / OUTPUT_DIR / f"{state.operation}-task-{task.id:02d}.json"
+    )
+
+    # Build variables for template
+    variables = {
+        "PROJECT_PATH": state.project_path,
+        "TASK_NAME": task.name,
+        "TASK_DESCRIPTION": task.description,
+        "OUTPUT_FILE": str(output_file),
+        "PREVIOUS_OUTPUTS": json.dumps(state.outputs),
+    }
+    variables.update({k.upper(): str(v) for k, v in task.context.items()})
+
+    try:
+        prompt_content = fill_prompt_template(prompt_path, variables)
+    except FileNotFoundError:
+        console.print(f"[red]Prompt template not found: {prompt_path}[/red]")
+        task.status = "failed"
+        save_state(state)
+        return False
+
+    # Clear cache and run Claude
+    clear_claude_cache()
+    task.status = "in_progress"
+    save_state(state)
+
+    success = spawn_claude_session(
+        state.project_path, prompt_content, interactive=task.interactive
+    )
+
+    if success:
+        task.status = "complete"
+        if output_file.exists():
+            state.outputs.append(str(output_file))
+        state.current_task = task.id
+        console.print(f"[green]✓ Task {task.id} complete[/green]")
+    else:
+        task.status = "failed"
+        console.print(f"[red]✗ Task {task.id} failed[/red]")
+
+    save_state(state)
+    return success
+
+
+def run_approval(state: OperationState) -> bool:
+    """Run the approval/synthesis phase.
+
+    This phase:
+    1. Loads all task outputs
+    2. Presents summary of changes
+    3. Gets user approval
+    4. Applies changes to PRD
+
+    Returns True if successful.
+    """
+    console.print()
+    console.print(
+        Panel(
+            "[bold green]Approval Phase[/bold green]\\n"
+            "Review and approve the changes...",
+            title="Phase 3/3",
+            border_style="green",
+        )
+    )
+    console.print()
+
+    prompt_path = (
+        Path(state.project_path) / PROMPTS_DIR / state.operation / "synthesize.md"
+    )
+
+    # Fill template
+    try:
+        prompt_content = fill_prompt_template(
+            prompt_path,
+            {
+                "PROJECT_PATH": state.project_path,
+                "TASK_OUTPUTS": json.dumps(state.outputs),
+                "TOTAL_TASKS": str(state.total_tasks),
+            },
+        )
+    except FileNotFoundError:
+        console.print(f"[red]Prompt template not found: {prompt_path}[/red]")
+        return False
+
+    # Clear cache and run Claude
+    clear_claude_cache()
+    success = spawn_claude_session(state.project_path, prompt_content, interactive=True)
+
+    if success:
+        state.phase = "complete"
+        save_state(state)
+        console.print("[green]Changes applied successfully.[/green]")
+    else:
+        console.print("[red]Approval phase failed.[/red]")
+
+    return success
+
+
+def show_status(state: OperationState) -> None:
+    """Show current operation status."""
+    table = Table(title="Operation Status")
+    table.add_column("Field", style="cyan")
+    table.add_column("Value")
+
+    table.add_row("Operation", state.operation)
+    table.add_row("Phase", state.phase)
+    table.add_row("Tasks", f"{state.current_task}/{state.total_tasks}")
+    table.add_row("Started", state.started_at)
+    table.add_row("Updated", state.updated_at)
+
+    console.print(table)
+
+
+def main() -> int:
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Vibe-fabric AI runner",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--operation",
+        choices=["prd", "scope", "gaps", "analyze"],
+        help="Operation to run",
+    )
+    parser.add_argument(
+        "--project",
+        help="Path to project directory",
+    )
+    parser.add_argument(
+        "--resume",
+        action="store_true",
+        help="Resume interrupted operation",
+    )
+    parser.add_argument(
+        "--loop",
+        action="store_true",
+        help="Run all phases automatically",
+    )
+    parser.add_argument(
+        "--cancel",
+        action="store_true",
+        help="Cancel current operation",
+    )
+    parser.add_argument(
+        "--status",
+        action="store_true",
+        help="Show current operation status",
+    )
+    args = parser.parse_args()
+
+    # Determine project path
+    project_path = args.project or os.getcwd()
+
+    # Handle graceful shutdown
+    state: Optional[OperationState] = None
+
+    def handle_signal(sig: int, frame: Any) -> None:
+        console.print("\\n[yellow]Interrupted. State saved for resume.[/yellow]")
+        if state:
+            save_state(state)
+        sys.exit(130)
+
+    signal.signal(signal.SIGINT, handle_signal)
+    signal.signal(signal.SIGTERM, handle_signal)
+
+    # Handle cancel
+    if args.cancel:
+        delete_state(project_path)
+        console.print("[green]Operation cancelled. State cleared.[/green]")
+        return 0
+
+    # Handle status
+    if args.status:
+        state = load_state(project_path)
+        if state:
+            show_status(state)
+        else:
+            console.print("[yellow]No operation in progress.[/yellow]")
+        return 0
+
+    # Load or create state
+    if args.resume:
+        state = load_state(project_path)
+        if not state:
+            console.print("[red]Error: No saved state to resume.[/red]")
+            console.print("[dim]Start a new operation with --operation[/dim]")
+            return 1
+        console.print(f"[green]Resuming {state.operation} operation from {state.phase} phase...[/green]")
+    else:
+        if not args.operation:
+            parser.error("--operation is required unless using --resume, --cancel, or --status")
+
+        # Check for existing operation
+        existing = load_state(project_path)
+        if existing and existing.phase != "complete":
+            console.print(
+                f"[yellow]Operation '{existing.operation}' is already in progress.[/yellow]"
+            )
+            console.print()
+            console.print("Options:")
+            console.print("  --resume    Continue the existing operation")
+            console.print("  --cancel    Cancel and start fresh")
+            return 1
+
+        state = OperationState(
+            operation=args.operation,
+            project_path=project_path,
+            phase="assess",
+            started_at=get_timestamp(),
+            updated_at=get_timestamp(),
+        )
+        save_state(state)
+
+    # Ensure output directory exists
+    output_dir = Path(project_path) / OUTPUT_DIR
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Run phases
+    try:
+        # Assessment phase
+        if state.phase == "assess":
+            success = run_assessment(state)
+            if not success:
+                return 1
+            if not args.loop:
+                console.print()
+                console.print("[dim]Run with --loop to continue automatically,[/dim]")
+                console.print("[dim]or run again with --resume to continue.[/dim]")
+                return 0
+
+        # Execution phase
+        if state.phase == "execute":
+            console.print()
+            console.print(
+                Panel(
+                    "[bold yellow]Execution Phase[/bold yellow]\\n"
+                    f"Running {state.total_tasks} task(s)...",
+                    title="Phase 2/3",
+                    border_style="yellow",
+                )
+            )
+
+            for task in state.tasks:
+                if task.status in ("complete", "failed"):
+                    continue  # Skip completed or failed tasks
+
+                success = run_task(state, task)
+                if not success and not args.loop:
+                    console.print(
+                        "[dim]Task failed. Fix issues and run with --resume.[/dim]"
+                    )
+                    return 1
+
+                if not args.loop:
+                    console.print()
+                    console.print("[dim]Run again with --resume to continue.[/dim]")
+                    return 0
+
+            state.phase = "approve"
+            save_state(state)
+
+        # Approval phase
+        if state.phase == "approve":
+            success = run_approval(state)
+            if not success:
+                return 1
+
+        # Complete
+        if state.phase == "complete":
+            delete_state(project_path)
+            console.print()
+            console.print(
+                Panel(
+                    "[bold green]Operation Complete![/bold green]\\n"
+                    "All phases finished successfully.",
+                    border_style="green",
+                )
+            )
+            return 0
+
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        if state:
+            save_state(state)
+            console.print("[dim]State saved. Run with --resume to retry.[/dim]")
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+`;
+    const scriptPath = path.join(projectPath, '.claude', 'scripts', 'vibe-runner.py');
+    await writeFile(scriptPath, runnerScript, 'utf-8');
+}
+//# sourceMappingURL=project.js.map