cli.py

import sys
import ast
from rich.console import Console

from config import WORKSPACE_DIR, MAX_LLM_CALLS
from agent.normalize import normalize_command
from agent.cache import (
    load_cached_hybrid,
    save_cached_hybrid,
    load_last_good,
)
from agent.engine import ForgePilotEngine
from agent.generator import generate_project
from agent.validator import run_validation
from agent.budget import LLMBudget
from agent.operations import apply_operations
from agent.git_rollback import rollback_last_change
from agent.workspace import (
    list_workspace_files,
    get_workspace_snapshot,
    clear_workspace,
)

console = Console()


# ----------------------------
# Utilities
# ----------------------------

def write_files(files: dict):
    """
    Replace workspace contents with the generated file set
    using the shared operation safety layer.
    """
    clear_workspace()

    operations = [
        {
            "type": "write_file",
            "path": filename,
            "content": content,
        }
        for filename, content in files.items()
    ]

    apply_operations(operations)

    for filename in files:
        console.print(
            f"[green]✓ wrote[/green] {filename}"
        )

def validate_result_structure(result: dict, phase: str):
    """
    Ensure LLM output has the expected structure.
    """
    if not isinstance(result, dict):
        raise RuntimeError(f"{phase}: result is not a dict")

    if "files" not in result:
        raise RuntimeError(f"{phase}: missing top-level key 'files'")

    if not isinstance(result["files"], dict):
        raise RuntimeError(f"{phase}: 'files' must be a dict")

    if not result["files"]:
        raise RuntimeError(f"{phase}: 'files' must not be empty")


# ----------------------------
# Main Orchestration
# ----------------------------

def main():
    if len(sys.argv) < 2:
        console.print(
            "[red]Error:[/red] Please provide a command.\n"
            "Example:\n"
            '  python cli.py "Build a CLI that converts temperatures"\n'
            '  python cli.py --new-project "Build a Snake game"'
        )
        sys.exit(1)

    new_project = sys.argv[1] == "--new-project"

    if new_project:
        if len(sys.argv) < 3:
            console.print(
                "[red]Error:[/red] --new-project requires a goal."
            )
            sys.exit(1)

        goal = sys.argv[2]
    else:
        goal = sys.argv[1]

    if normalize_command(goal) == "rollback":
        try:
            commit = rollback_last_change()

            console.print(
                "[bold green]✓ Last ForgePilot change rolled back[/bold green]"
            )
            console.print(
                f"[dim]Rollback commit: {commit[:8]}[/dim]"
            )

        except Exception as e:
            console.print(
                f"[bold red]Rollback failed:[/bold red] {e}"
            )

        return
    normalized = normalize_command(goal)
    budget = LLMBudget(MAX_LLM_CALLS)

    workspace_files = list_workspace_files()

    if new_project:
        console.rule("[bold yellow]New Project[/bold yellow]")
        console.print(
            "[yellow]Creating a new project from a clean workspace[/yellow]"
        )

    console.rule("[bold blue]AI Cursor Agent")
    console.print(f"[bold]Goal:[/bold] {goal}")
    console.print(f"[dim]Normalized:[/dim] {normalized}")
    console.print(f"[dim]LLM budget:[/dim] {budget.remaining}")

    # ----------------------------
    # Cache Lookup
    # ----------------------------

    cached = None
    cache_type = None

    # Cached entries are complete generated projects, and replaying one
    # clears the workspace. Only consult the cache when there is no
    # existing project to overwrite.
    if not new_project and not workspace_files:
        cached, cache_type = load_cached_hybrid(normalized)

    if cached is not None:

        if cache_type == "exact":
            console.print("[green]✓ Exact cache hit[/green]")

            result = ast.literal_eval(cached)
            write_files(result["files"])

            console.print("[bold green]Done (no LLM calls used)[/bold green]")
            return

        elif cache_type == "semantic":
            console.print("[green]✓ Semantic cache candidate found[/green]")

            result = ast.literal_eval(cached)
            write_files(result["files"])

            ok, err = run_validation()

            if ok:
                console.print("[bold green]✓ Semantic cache validated[/bold green]")
                console.print("[bold green]Done (no LLM calls used)[/bold green]")
                return

            console.print("[yellow]Semantic cache candidate failed validation[/yellow]")

    if not new_project and not workspace_files:
        console.print("[yellow]Cache miss — generating project[/yellow]")

    # ----------------------------
    # Generation / Coding Agent Phase
    # ----------------------------

    if new_project or workspace_files:
        # ========================================================
        # NEW OR EXISTING PROJECT → AUTONOMOUS CODING ENGINE
        #
        # The engine owns the task checkpoint, so a failed
        # --new-project run restores the previous project.
        # ========================================================

        console.rule(
            "[bold yellow]ForgePilot Autonomous Engine[/bold yellow]"
        )

        if not new_project:
            console.print(
                f"[cyan]Existing workspace detected: "
                f"{len(workspace_files)} files[/cyan]"
            )

        try:
            engine = ForgePilotEngine(
                budget=budget,
                max_repair_attempts=3,
                new_project=new_project,
            )

            result = engine.run(goal)

            if result["status"] == "verified":
                console.print(
                    "[bold green]✓ ForgePilot verified the changes[/bold green]"
                )
                console.print(
                    f"[dim]Repair attempts: "
                    f"{result['repair_attempts']}[/dim]"
                )
                console.print(
                    f"[dim]Validation attempts: "
                    f"{result['validation_attempts']}[/dim]"
                )
                context_available = result["context_chars_available"]
                context_selected = result["context_chars_selected"]
                reduction = (
                    (1 - context_selected / context_available) * 100
                    if context_available
                    else 0.0
                )

                console.print("[dim]Context:[/dim]")
                console.print(
                    f"[dim]  Files: "
                    f"{result['context_files_selected']}/"
                    f"{result['context_files_available']}[/dim]"
                )
                console.print(
                    f"[dim]  Chunks: "
                    f"{result['context_chunks_selected']}/"
                    f"{result['context_chunks_available']}[/dim]"
                )
                console.print(
                    f"[dim]  Characters: "
                    f"{context_selected:,}/"
                    f"{context_available:,}[/dim]"
                )
                console.print(
                    f"[dim]  Reduction: {reduction:.1f}%[/dim]"
                )

                if new_project:
                    save_cached_hybrid(
                        normalized,
                        str({"files": get_workspace_snapshot()}),
                        validated=True,
                    )

            else:
                console.print(
                    "[bold red]✗ ForgePilot could not verify the changes[/bold red]"
                )
                console.print(
                    "[yellow]↩ Workspace restored to pre-task state[/yellow]"
                )
                console.print(
                    f"[dim]Repair attempts: "
                    f"{result['repair_attempts']}[/dim]"
                )
                console.print(
                    f"[dim]Validation attempts: "
                    f"{result['validation_attempts']}[/dim]"
                )
                console.print(
                    f"[red]{result['error']}[/red]"
                )

        except Exception as e:
            console.print(
                f"[bold red]ForgePilot engine failed:[/bold red] {e}"
            )

        return

    else:
        # ========================================================
        # EMPTY PROJECT → PROJECT GENERATOR
        # ========================================================

        console.rule("[bold yellow]LLM Generation[/bold yellow]")

        try:
            console.print(f"Remaining LLM budget: {budget.remaining}")

            result = generate_project(goal, budget,)

            validate_result_structure(result, "Generation")

            write_files(
                result["files"]
            )

        except Exception as e:
            console.print(f"[bold red]Generation failed:[/bold red] {e}")
            return

    # ----------------------------
    # Validation Phase
    # ----------------------------
    console.rule("[bold magenta]Validation (pytest)")
    ok, err = run_validation()

    if ok:
        console.print("[bold green]✓ Validation passed[/bold green]")

        if not workspace_files:
            workspace = get_workspace_snapshot()
            save_cached_hybrid(
                normalized,
                str({"files": workspace,}),
                validated=True,
            )

            console.print("[green]✓ Cached result and saved as last-known-good[/green]")

        return

    console.rule("[bold red]Validation Failed")
    console.print(err)

    # ----------------------------
    # Fallback: Last Known Good
    # ----------------------------
    if not workspace_files:
        console.rule("[bold yellow]Fallback[/bold yellow]")

        fallback = load_last_good(normalized)

        if fallback:
            console.print("[yellow]Restoring last-known-good output[/yellow]")
            result = ast.literal_eval(fallback)
            write_files(result["files"])
            console.print("[green]✓ Restored last-known-good project[/green]")
        else:
            console.print("[red]No last-known-good output available[/red]")


if __name__ == "__main__":
    main()