forge-dev 0.1.0__py3-none-any.whl

forge_core/cli.py

@@ -0,0 +1,552 @@
+"""Forge CLI — AI-Native Development Workflow Engine.
+
+Global CLI commands for managing Forge projects.
+Installed as `forge` command via pip.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+console = Console()
+
+
+@click.group()
+@click.version_option(package_name="forge-dev")
+def main() -> None:
+    """Forge — AI-Native Development Workflow Engine.
+    
+    Transform requirements into production-ready, audited, observable code.
+    """
+    pass
+
+
+@main.command()
+@click.option("--name", "-n", help="Project name (default: directory name)")
+@click.option("--backend", "-b", help="Backend framework override")
+@click.option("--no-interactive", is_flag=True, help="Skip interactive questions")
+def init(name: str | None, backend: str | None, no_interactive: bool) -> None:
+    """Initialize Forge in the current directory.
+    
+    Detects the project state and adapts:
+    - Empty folder → guided setup conversation
+    - Has docs → analyzes documents, generates brief
+    - Has code → detects stack, offers assessment
+    - Has .forge/ → offers to continue or re-evaluate
+    """
+    from forge_core.detector import detect_project
+    from forge_core.phases.context import (
+        get_questions_for_empty_project,
+        resolve_context,
+        save_context,
+    )
+    from forge_core.registry import ensure_registry, load_user_config
+
+    # Ensure global registry exists
+    ensure_registry()
+    user_config = load_user_config()
+
+    # Detect what's in this directory
+    project_path = Path.cwd()
+    detection = detect_project(project_path)
+
+    console.print()
+    console.print(Panel(
+        f"[bold]Forge Init[/bold]\n{detection.summary()}",
+        title="🔥 Forge",
+        border_style="bright_red",
+    ))
+    console.print()
+
+    if detection.has_forge:
+        console.print("[yellow]This project already has Forge initialized.[/yellow]")
+        console.print("Options:")
+        console.print("  forge status    — see current state")
+        console.print("  forge assess    — re-evaluate against latest standards")
+        console.print("  forge audit     — run audit agents")
+        return
+
+    if detection.is_empty:
+        console.print("[cyan]Empty directory detected. Let's set up your project.[/cyan]")
+        console.print()
+
+        if no_interactive:
+            # Use defaults for everything
+            overrides = {}
+            if name:
+                overrides["name"] = name
+            if backend:
+                overrides["backend"] = backend
+            context = resolve_context(detection, user_config, project_name=name, overrides=overrides)
+        else:
+            # Interactive setup
+            questions = get_questions_for_empty_project(user_config)
+            overrides = {}
+
+            for q in questions:
+                if q["type"] == "text":
+                    answer = click.prompt(f"  {q['question']}")
+                    overrides[q["id"]] = answer
+                elif q["type"] == "choice":
+                    console.print(f"  {q['question']}")
+                    for i, opt in enumerate(q["options"], 1):
+                        default_marker = " [default]" if opt == q.get("default") else ""
+                        console.print(f"    {i}. {opt}{default_marker}")
+                    idx = click.prompt("  Choice", default="1", type=int)
+                    overrides[q["id"]] = q["options"][min(idx - 1, len(q["options"]) - 1)]
+                elif q["type"] == "boolean":
+                    answer = click.confirm(f"  {q['question']}", default=q.get("default", True))
+                    overrides[q["id"]] = answer
+                elif q["type"] == "multi_choice":
+                    console.print(f"  {q['question']}")
+                    for i, opt in enumerate(q["options"], 1):
+                        console.print(f"    {i}. {opt}")
+                    selected = click.prompt("  Select (comma-separated numbers)", default="")
+                    if selected:
+                        indices = [int(x.strip()) - 1 for x in selected.split(",")]
+                        overrides[q["id"]] = [q["options"][i] for i in indices if 0 <= i < len(q["options"])]
+                    else:
+                        overrides[q["id"]] = q.get("default", [])
+
+            # Map question IDs to context fields
+            context_overrides = {}
+            if "mission" in overrides:
+                context_overrides["description"] = overrides["mission"]
+            if "type" in overrides:
+                context_overrides["type"] = overrides["type"]
+            if "regulatory" in overrides:
+                context_overrides["regulatory"] = overrides["regulatory"]
+            if "backend" in overrides:
+                context_overrides["backend"] = overrides["backend"]
+            elif backend:
+                context_overrides["backend"] = backend
+            if "ai_enabled" in overrides:
+                context_overrides["ai"] = {"enabled": overrides["ai_enabled"]}
+
+            context = resolve_context(
+                detection, user_config,
+                project_name=name,
+                overrides=context_overrides,
+            )
+
+    elif detection.has_existing_code:
+        console.print("[cyan]Existing code detected. Analyzing stack...[/cyan]")
+        context = resolve_context(detection, user_config, project_name=name)
+        console.print(f"[green]Detected: {detection.detected_stack}[/green]")
+
+    else:  # has_docs
+        console.print("[cyan]Documents found. Analyzing...[/cyan]")
+        console.print(f"  Found {len(detection.doc_files)} document(s):")
+        for doc in detection.doc_files[:10]:
+            console.print(f"    📄 {doc.name}")
+        console.print()
+        console.print("[dim]Run `forge intake` to process these documents into a Forge Brief.[/dim]")
+        context = resolve_context(detection, user_config, project_name=name)
+
+    # Save context
+    context_path = save_context(context, project_path)
+
+    # Create journal
+    journal_path = project_path / ".forge" / "journal.md"
+    if not journal_path.exists():
+        journal_path.write_text(
+            f"# {context.name} — Forge Journal\n\n"
+            "Record project-specific learnings, workarounds, and nuances here.\n"
+            "Forge agents read this file to understand project-specific context.\n\n"
+            "## Entries\n\n"
+        )
+
+    # Record in global history
+    from forge_core.registry import record_project
+    record_project(
+        context.name,
+        str(project_path),
+        {"type": context.type, "backend": context.backend, "cloud": context.cloud},
+    )
+
+    console.print()
+    console.print(Panel(
+        f"[green]✓ Forge initialized for [bold]{context.name}[/bold][/green]\n\n"
+        f"Context: {context_path}\n"
+        f"Journal: {journal_path}\n\n"
+        f"Stack: {context.backend.value} + {context.frontend.value}\n"
+        f"Cloud: {context.cloud.value}\n"
+        f"Auth: {context.auth.value}\n\n"
+        "Next steps:\n"
+        "  forge intake <file>  — process a requirement document\n"
+        "  forge plan           — generate implementation plan\n"
+        "  forge audit          — run audit agents",
+        title="🔥 Ready",
+        border_style="green",
+    ))
+
+
+@main.command()
+@click.argument("file", required=False, type=click.Path(exists=True))
+@click.option("--text", "-t", help="Inline requirement text")
+def intake(file: str | None, text: str | None) -> None:
+    """Process a requirement into a Forge Brief.
+    
+    Accepts a file (markdown, text, PDF) or inline text.
+    Produces a normalized brief in .forge/brief.yaml.
+    """
+    from forge_core.phases.intake import (
+        build_intake_prompt,
+        classify_requirement,
+        save_brief,
+    )
+
+    project_path = Path.cwd()
+    forge_dir = project_path / ".forge"
+
+    if not forge_dir.exists():
+        console.print("[red]No Forge project found. Run `forge init` first.[/red]")
+        sys.exit(1)
+
+    # Get the requirement content
+    if file:
+        content = Path(file).read_text(errors="ignore")
+        console.print(f"[cyan]Reading requirement from: {file}[/cyan]")
+    elif text:
+        content = text
+    else:
+        console.print("[yellow]No file or text provided.[/yellow]")
+        console.print("Usage:")
+        console.print("  forge intake requirements.md")
+        console.print("  forge intake --text 'Build a user dashboard with...'")
+        return
+
+    # Classify and build prompt
+    req_type = classify_requirement(content)
+    console.print(f"[dim]Classified as: {req_type.value}[/dim]")
+
+    prompt = build_intake_prompt(content, req_type)
+
+    console.print()
+    console.print(Panel(
+        "[bold]Intake Analysis Prompt Generated[/bold]\n\n"
+        "The intake prompt has been generated for LLM analysis.\n"
+        "In a full Forge setup, this would be sent to Claude/GPT\n"
+        "to produce the brief automatically.\n\n"
+        f"Requirement type: {req_type.value}\n"
+        f"Content length: {len(content)} chars\n\n"
+        "For now, the prompt is saved to .forge/intake_prompt.md\n"
+        "You can send it to an LLM manually or via Claude Code.",
+        title="📋 Intake",
+        border_style="cyan",
+    ))
+
+    # Save the prompt for LLM processing
+    prompt_path = forge_dir / "intake_prompt.md"
+    prompt_path.write_text(prompt)
+    console.print(f"\n[dim]Prompt saved to: {prompt_path}[/dim]")
+
+
+@main.command()
+def status() -> None:
+    """Show current Forge project status."""
+    from forge_core.phases.context import load_context
+    from forge_core.phases.intake import load_brief
+    from forge_core.registry import get_forge_version
+
+    project_path = Path.cwd()
+    forge_dir = project_path / ".forge"
+
+    if not forge_dir.exists():
+        console.print("[red]No Forge project found. Run `forge init` first.[/red]")
+        return
+
+    context = load_context(project_path)
+    brief = load_brief(project_path)
+    version = get_forge_version()
+
+    table = Table(title=f"🔥 Forge Status — {context.name if context else 'Unknown'}")
+    table.add_column("Component", style="cyan")
+    table.add_column("Status", style="green")
+
+    table.add_row("Forge Version", version)
+    table.add_row("Context", "✓" if context else "✗ Run `forge init`")
+    table.add_row("Brief", "✓" if brief else "— Run `forge intake`")
+    table.add_row("Plan", "✓" if (forge_dir / "plan.yaml").exists() else "— Run `forge plan`")
+    table.add_row("Journal", "✓" if (forge_dir / "journal.md").exists() else "—")
+
+    if context:
+        table.add_row("", "")
+        table.add_row("Stack", f"{context.backend.value} + {context.frontend.value}")
+        table.add_row("Cloud", context.cloud.value)
+        table.add_row("Auth", context.auth.value)
+        table.add_row("AI", "Enabled" if context.ai.enabled else "Disabled")
+        table.add_row("Type", context.type.value)
+        if context.regulatory:
+            table.add_row("Regulatory", ", ".join(r.value for r in context.regulatory))
+
+    console.print()
+    console.print(table)
+
+
+@main.command()
+@click.argument("entry", required=False)
+def journal(entry: str | None) -> None:
+    """Add an entry to the project journal.
+    
+    Records learnings, workarounds, and nuances specific to this project.
+    Forge agents read the journal for project-specific context.
+    """
+    from datetime import datetime, timezone
+
+    project_path = Path.cwd()
+    journal_path = project_path / ".forge" / "journal.md"
+
+    if not journal_path.exists():
+        console.print("[red]No Forge project found. Run `forge init` first.[/red]")
+        return
+
+    if entry is None:
+        entry = click.prompt("Journal entry")
+
+    timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M")
+    with open(journal_path, "a") as f:
+        f.write(f"\n### {timestamp}\n{entry}\n")
+
+    console.print(f"[green]✓ Journal entry added[/green]")
+
+
+@main.command()
+@click.option("--name", "-n", required=True, help="Standard name")
+@click.option("--area", "-a", required=True, help="Area this standard governs")
+@click.option("--description", "-d", required=True, help="What the standard requires")
+def standards(name: str, area: str, description: str) -> None:
+    """Add or view standards.
+    
+    When adding a new standard, runs the coherence checker first.
+    """
+    import yaml as _yaml
+
+    from forge_core.phases.coherence import check_new_standard
+    from forge_core.registry import load_standards, version_workflow
+
+    existing = load_standards()
+
+    new_standard = {
+        "name": name,
+        "area": area,
+        "description": description,
+    }
+
+    # Run coherence check
+    report = check_new_standard(new_standard, existing)
+    console.print()
+    console.print(report.summary())
+
+    if not report.passed:
+        console.print("\n[red]Cannot add standard — resolve errors first.[/red]")
+        return
+
+    if report.issues:
+        if not click.confirm("\nProceed despite warnings?"):
+            return
+
+    # Save the standard
+    from forge_core.registry import USER_DIR
+    standards_dir = USER_DIR / "standards"
+    standards_dir.mkdir(parents=True, exist_ok=True)
+
+    std_path = standards_dir / f"{name.lower().replace(' ', '-')}.yaml"
+    with open(std_path, "w") as f:
+        _yaml.dump(new_standard, f, default_flow_style=False)
+
+    # Version the workflow change
+    version_id = version_workflow(f"Added standard: {name}")
+    console.print(f"\n[green]✓ Standard '{name}' added[/green]")
+    console.print(f"[dim]Workflow versioned: {version_id}[/dim]")
+
+
+@main.command()
+def upgrade() -> None:
+    """Upgrade Forge core from upstream.
+    
+    Updates ~/.forge/core/ while preserving ~/.forge/user/.
+    Project .forge/ directories are never touched.
+    """
+    console.print("[yellow]Forge upgrade would pull latest from GitHub.[/yellow]")
+    console.print("[dim]Not yet implemented — will use git pull + migration check.[/dim]")
+    console.print()
+    console.print("The upgrade process will:")
+    console.print("  1. Pull latest core/ from GitHub")
+    console.print("  2. Run migration check for breaking changes")
+    console.print("  3. Run coherence check against your user/ customizations")
+    console.print("  4. Show impact report before applying")
+    console.print("  5. Never touch project .forge/ directories")
+
+
+@main.command()
+def assess() -> None:
+    """Assess an existing project against current Forge standards.
+    
+    Produces a maturity report with opportunities for improvement.
+    """
+    from forge_core.detector import detect_project
+    from forge_core.registry import load_standards
+
+    project_path = Path.cwd()
+    detection = detect_project(project_path)
+
+    if detection.is_empty:
+        console.print("[red]Nothing to assess — directory is empty.[/red]")
+        return
+
+    standards_list = load_standards()
+
+    console.print(Panel(
+        f"[bold]Maturity Assessment[/bold]\n\n"
+        f"Project: {project_path.name}\n"
+        f"Code files: {len(detection.code_files)}\n"
+        f"Detected stack: {detection.detected_stack}\n"
+        f"Standards to check: {len(standards_list)}\n\n"
+        "[dim]Full assessment requires LLM analysis.\n"
+        "The assessment prompt will be generated for processing.[/dim]",
+        title="📊 Assess",
+        border_style="yellow",
+    ))
+
+
+@main.command()
+def mcps() -> None:
+    """View and manage the MCP registry."""
+    from forge_core.registry import load_mcps
+
+    mcp_list = load_mcps()
+
+    if not mcp_list:
+        console.print("[dim]No MCPs configured. Edit ~/.forge/user/mcps.yaml[/dim]")
+        return
+
+    table = Table(title="MCP Registry")
+    table.add_column("Name", style="cyan")
+    table.add_column("Description")
+    table.add_column("Auto-suggest", style="green")
+    table.add_column("Transport")
+
+    for mcp in mcp_list:
+        table.add_row(
+            mcp.name,
+            mcp.description,
+            "✓" if mcp.auto_suggest else "—",
+            mcp.transport,
+        )
+
+    console.print()
+    console.print(table)
+
+
+@main.command()
+@click.option(
+    "--format", "-f",
+    type=click.Choice(["claude", "cursor", "copilot", "generic", "all"]),
+    default="claude",
+    help="Editor format to generate",
+)
+def sync(format: str) -> None:
+    """Generate editor instruction files from Forge governance.
+    
+    Translates ALL Forge knowledge (standards, patterns, journal,
+    context) into a CLAUDE.md, .cursorrules, or equivalent file
+    that the AI editor reads and follows.
+    
+    This is the core value of Forge — it bridges governance to the editor.
+    """
+    from forge_core.editor_bridge import write_editor_file
+    from forge_core.phases.context import load_context
+
+    project_path = Path.cwd()
+    context = load_context(project_path)
+
+    if not context:
+        console.print("[red]No Forge project found. Run `forge init` first.[/red]")
+        return
+
+    if format == "all":
+        formats = ["claude", "cursor", "copilot", "generic"]
+    else:
+        formats = [format]
+
+    for fmt in formats:
+        path = write_editor_file(project_path, context, fmt)
+        console.print(f"[green]✓ Generated: {path}[/green]")
+
+    console.print()
+    console.print("[dim]The editor will read this file automatically.[/dim]")
+    console.print("[dim]Re-run `forge sync` after changing standards or context.[/dim]")
+
+
+@main.command()
+@click.argument("files", nargs=-1, type=click.Path(exists=True))
+@click.option("--full", is_flag=True, help="Audit entire project")
+def audit(files: tuple[str, ...], full: bool) -> None:
+    """Run audit agents against code.
+    
+    Generates an audit prompt with all standards, then produces
+    a structured report of findings with fixes.
+    
+    Examples:
+      forge audit src/api/claims.py     — audit specific file
+      forge audit --full                — audit entire project
+    """
+    from forge_core.auditor import build_audit_prompt, build_file_audit_prompt
+    from forge_core.phases.context import load_context
+    from forge_core.registry import load_standards
+
+    project_path = Path.cwd()
+    context = load_context(project_path)
+
+    if not context:
+        console.print("[red]No Forge project found. Run `forge init` first.[/red]")
+        return
+
+    standards = load_standards()
+
+    if files:
+        # Audit specific files
+        for file_path in files:
+            content = Path(file_path).read_text(errors="ignore")
+            prompt = build_file_audit_prompt(content, file_path, context, standards)
+            
+            # Save prompt for LLM processing
+            prompt_path = project_path / ".forge" / "audit" / f"audit_prompt_{Path(file_path).stem}.md"
+            prompt_path.parent.mkdir(parents=True, exist_ok=True)
+            prompt_path.write_text(prompt)
+            
+            console.print(f"[cyan]Audit prompt generated for: {file_path}[/cyan]")
+            console.print(f"[dim]Saved to: {prompt_path}[/dim]")
+    else:
+        # Full project audit
+        target_files = None
+        if not full:
+            console.print("[yellow]Specify files or use --full for entire project.[/yellow]")
+            console.print("  forge audit src/api/claims.py")
+            console.print("  forge audit --full")
+            return
+
+        prompt = build_audit_prompt(project_path, context, standards)
+        prompt_path = project_path / ".forge" / "audit" / "full_audit_prompt.md"
+        prompt_path.parent.mkdir(parents=True, exist_ok=True)
+        prompt_path.write_text(prompt)
+
+        console.print("[cyan]Full project audit prompt generated.[/cyan]")
+        console.print(f"[dim]Saved to: {prompt_path}[/dim]")
+        console.print()
+        console.print(
+            "[dim]Send this prompt to Claude Code or your AI editor "
+            "to perform the audit.[/dim]"
+        )
+
+
+if __name__ == "__main__":
+    main()