forgex-cli 0.1.0__py3-none-any.whl

forgex/cli/repl.py

@@ -0,0 +1,377 @@
+"""Persistent interactive REPL for FORGEX."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import shlex
+import sys
+from pathlib import Path
+from typing import Any
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.input import DummyInput, create_input
+from prompt_toolkit.output import DummyOutput, create_output
+from prompt_toolkit.styles import Style
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from forgex import __version__
+from forgex.cli.intent import IntentAction, classify_intent
+from forgex.cli.progress import render_pipeline_header, render_runtime_summary
+from forgex.cli.runtime import AutonomousRuntime
+from forgex.cli.session import Session
+from forgex.config.loader import global_config_path
+from forgex.schemas.error import ForgexError
+
+BANNER = r"""[bold cyan]
+███████╗ ██████╗ ██████╗  ██████╗ ███████╗██╗  ██╗
+██╔════╝██╔═══██╗██╔══██╗██╔════╝ ██╔════╝╚██╗██╔╝
+█████╗  ██║   ██║██████╔╝██║  ███╗█████╗   ╚███╔╝
+██╔══╝  ██║   ██║██╔══██╗██║   ██║██╔══╝   ██╔██╗
+██║     ╚██████╔╝██║  ██║╚██████╔╝███████╗██╔╝ ██╗
+╚═╝      ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝[/bold cyan]
+[dim]Autonomous Adaptive Multi-Model Software Engineering CLI[/dim]
+[dim]Just describe what you want. We Plan, Build, Verify & Repair.  (v{version})[/dim]
+"""
+
+COMMANDS = [
+    "do",
+    "init",
+    "plan",
+    "build",
+    "fix",
+    "review",
+    "verify",
+    "supervise",
+    "status",
+    "doctor",
+    "models",
+    "tools",
+    "checkpoint",
+    "rollback",
+    "diff",
+    "config",
+    "logs",
+    "task",
+    "context",
+    "run",
+    "cd",
+    "clear",
+    "help",
+    "exit",
+    "quit",
+]
+
+SLASH_COMMANDS = [f"/{cmd}" for cmd in COMMANDS]
+
+PROMPT_STYLE = Style.from_dict(
+    {
+        "brand": "#00d7ff bold",
+        "project": "#00ff87 bold",
+        "unattached": "#ffd700 dim",
+        "sep": "#666666",
+        "arrow": "#00ff87 bold",
+    }
+)
+
+
+class ForgexREPL:
+    """Interactive persistent shell session for FORGEX."""
+
+    def __init__(
+        self,
+        session: Session | None = None,
+        *,
+        output: Any = None,
+        input: Any = None,
+    ) -> None:
+        self.session = session or Session()
+        self.console = Console()
+        hist_dir = Path.home() / ".forgex"
+        try:
+            hist_dir.mkdir(parents=True, exist_ok=True)
+        except Exception:
+            pass
+        self.history_file = hist_dir / "repl_history"
+
+        # Safe input/output initialization to support headless CI & Windows non-console buffers
+        try:
+            pt_output = output or create_output()
+        except Exception:
+            pt_output = DummyOutput()
+
+        try:
+            pt_input = input or create_input()
+        except Exception:
+            pt_input = DummyInput()
+
+        try:
+            self.prompt_session: PromptSession = PromptSession(
+                history=FileHistory(str(self.history_file)),
+                completer=WordCompleter(COMMANDS + SLASH_COMMANDS, ignore_case=True),
+                style=PROMPT_STYLE,
+                output=pt_output,
+                input=pt_input,
+            )
+        except Exception:
+            self.prompt_session = PromptSession(
+                output=DummyOutput(),
+                input=DummyInput(),
+            )
+
+    def print_banner(self) -> None:
+        """Display the welcome banner and session overview."""
+        self.console.print(BANNER.format(version=__version__))
+
+        grid = Table.grid(padding=(0, 2))
+        grid.add_column(style="dim")
+        grid.add_column()
+
+        proj_display = (
+            f"[bold green]{self.session.project_root.name}[/bold green] [dim]({self.session.project_root})[/dim]"
+            if self.session.is_attached and self.session.project_root
+            else "[bold yellow]None[/bold yellow] [dim](Type 'init' or 'cd <dir>' to attach)[/dim]"
+        )
+        grid.add_row("Attached Project:", proj_display)
+
+        arch_model = f"{self.session.config.models.architect.provider}:{self.session.config.models.architect.model}"
+        grid.add_row("Default Model:", f"[cyan]{arch_model}[/cyan]")
+        grid.add_row("Permissions:", f"[magenta]{self.session.config.permissions.mode}[/magenta]")
+        if os.environ.get("FORGEX_OFFLINE") == "1":
+            grid.add_row("Network:", "[red]Offline mode active[/red]")
+
+        self.console.print(Panel(grid, title="[bold]Session Context[/bold]", border_style="cyan"))
+        self.console.print("[dim]Type [bold white]help[/bold white] for commands, or describe what to build in plain English.[/dim]\n")
+
+    def check_first_run(self) -> None:
+        """Guide the user through onboarding if global config does not exist."""
+        g_cfg = global_config_path()
+        if not g_cfg.is_file():
+            self.console.print(
+                Panel(
+                    "[bold yellow]First time using FORGEX?[/bold yellow]\n\n"
+                    "No global configuration was found at ~/.forgex/config.toml.\n"
+                    "Let's configure your AI model provider and local profile.",
+                    border_style="yellow",
+                )
+            )
+            if sys.stdin.isatty():
+                from rich.prompt import Confirm
+                if Confirm.ask("Launch the guided setup wizard now?", default=True):
+                    self._run_cli_command(["config", "setup"])
+
+    def print_help(self) -> None:
+        """Display help table for natural language usage and power user commands."""
+        self.console.print(
+            Panel(
+                "[bold white]Describe what you want to build in plain English:[/bold white]\n\n"
+                "  [cyan]❯[/cyan] [green]Build me a REST API with FastAPI and SQLite[/green]\n"
+                "  [cyan]❯[/cyan] [green]Add JWT authentication with refresh tokens[/green]\n"
+                "  [cyan]❯[/cyan] [green]Fix the failing tests in users.py[/green]\n"
+                "  [cyan]❯[/cyan] [green]Create a full-stack dashboard with React[/green]\n\n"
+                "[dim]FORGEX will automatically initialize, plan, build, verify, repair, and checkpoint.[/dim]",
+                title="[bold cyan]FORGEX Universal CLI — How It Works[/bold cyan]",
+                border_style="cyan",
+            )
+        )
+
+        table = Table(title="Power User Commands (Optional Granular Control)", border_style="dim", show_header=True)
+        table.add_column("Command", style="bold cyan", width=22)
+        table.add_column("Description")
+
+        workflows = [
+            ("do <request>", "Execute end-to-end autonomous pipeline directly"),
+            ("plan <goal>", "Run only Architect: planning & task breakdown"),
+            ("build", "Run build pipeline for existing plan tasks"),
+            ("fix", "Auto-repair errors until tests pass — no rebuild"),
+            ("verify", "Deterministic verification (tests, lint, typecheck)"),
+            ("review", "Senior engineer code review of diff"),
+            ("supervise", "Run verification + code audit + soft gates verdict"),
+            ("status", "Project state, task breakdown, branch, and token usage"),
+            ("diff", "Inspect current uncommitted git changes"),
+            ("checkpoint [msg]", "Create reversible snapshot of codebase state"),
+            ("rollback [id]", "Reversibly rollback to a checkpoint"),
+            ("init [dir]", "Initialize FORGEX in current or target directory"),
+            ("models [catalog|health]", "Inspect configured models and providers"),
+            ("tools [list|run]", "Inspect and manually execute system tools"),
+            ("config [show|set|setup]", "View or modify configuration"),
+            ("doctor", "Validate environment, dependencies, and network"),
+            ("cd <dir>", "Switch directory and auto-attach project"),
+            ("clear", "Clear terminal screen"),
+            ("exit / quit", "Exit the interactive session"),
+        ]
+        for cmd, desc in workflows:
+            table.add_row(cmd, desc)
+
+        self.console.print(table)
+
+    def get_prompt_text(self) -> HTML:
+        """Generate dynamic colored prompt based on session state."""
+        if self.session.is_attached and self.session.project_root:
+            name = self.session.project_root.name
+            return HTML(f"<brand>forgex</brand> <sep>[</sep><project>{name}</project><sep>]</sep> <arrow>❯</arrow> ")
+        return HTML("<brand>forgex</brand> <arrow>❯</arrow> ")
+
+    def dispatch(self, raw_input: str) -> None:
+        """Dispatch user input to built-ins, Typer commands, or natural language intent."""
+        text = raw_input.strip()
+        if not text:
+            return
+
+        self.session.history.append(text)
+
+        # Strip optional leading slash
+        if text.startswith("/"):
+            text = text[1:].strip()
+
+        tokens = shlex.split(text, posix=sys.platform != "win32")
+        if not tokens:
+            return
+
+        cmd = tokens[0].lower()
+        args = tokens[1:]
+
+        # Handle built-ins
+        if cmd in ("exit", "quit", "q"):
+            raise EOFError
+        if cmd in ("clear", "cls"):
+            self.console.clear()
+            return
+        if cmd in ("help", "?"):
+            self.print_help()
+            return
+        if cmd == "cd":
+            raw_target = text[len(tokens[0]):].strip() if len(tokens) > 0 else ""
+            if raw_target:
+                target = raw_target.strip("'\"")
+            else:
+                target = str(Path.home())
+            if not self.session.change_directory(target):
+                self.console.print(f"[red]Directory not found: {target}[/red]")
+            else:
+                self.console.print(f"[dim]Switched to {Path.cwd()}[/dim]")
+            return
+
+        if cmd == "do" and len(tokens) > 1:
+            req = " ".join(tokens[1:])
+            self._run_autonomous(req, raw_input=text)
+            return
+
+        # Commands that do not accept positional words: if followed by prose (e.g. "build me a ...",
+        # "fix the failing ..."), treat as natural language rather than CLI syntax.
+        nl_commands = {"build", "fix", "verify", "supervise", "status", "doctor", "diff", "logs", "do"}
+        if cmd in nl_commands and len(tokens) > 1 and not tokens[1].startswith("-"):
+            pass
+        elif cmd in COMMANDS:
+            self._run_cli_command(tokens)
+            return
+
+        # Natural language intent classification
+        intent = classify_intent(text)
+        if intent.action == IntentAction.AUTONOMOUS:
+            target_req = intent.raw_request or text
+            effective_req = self.session.context.enrich_request(target_req)
+            self._run_autonomous(effective_req, raw_input=text)
+            return
+        elif intent.action != IntentAction.UNKNOWN and intent.confidence >= 0.5:
+            steps_desc = " → ".join(" ".join(step) for step in intent.pipeline)
+            self.console.print(
+                f"[bold cyan]Intent recognized:[/bold cyan] {intent.description}\n"
+                f"[dim]Pipeline: {steps_desc}[/dim]"
+            )
+            self._run_pipeline(intent.pipeline)
+        else:
+            self.console.print(
+                f"[yellow]Unrecognized command: '{cmd}'.[/yellow] "
+                "Type [bold]help[/bold] for available commands or describe your task in plain English."
+            )
+
+    def _run_autonomous(self, request: str, raw_input: str) -> bool:
+        """Run the end-to-end autonomous pipeline directly."""
+        render_pipeline_header(request, console=self.console)
+        runtime = AutonomousRuntime(session=self.session, ui=self.session.ui)
+        try:
+            result = asyncio.run(runtime.execute(request))
+            render_runtime_summary(result, console=self.console)
+            self.session.context.record_run(
+                request=raw_input,
+                status=result.status,
+                changed_files=result.changed_files,
+                checkpoint_id=result.checkpoint_id,
+            )
+            return result.is_success
+        except KeyboardInterrupt:
+            self.console.print("\n[yellow]Autonomous run cancelled by user.[/yellow]")
+            return False
+        except Exception as exc:
+            self.console.print(f"[red]Autonomous run error:[/red] {exc}")
+            return False
+        finally:
+            self.session.refresh()
+
+    def _run_pipeline(self, pipeline: list[list[str]]) -> None:
+        """Execute a pipeline of CLI commands sequentially, stopping on failure."""
+        for i, step in enumerate(pipeline, start=1):
+            if len(pipeline) > 1:
+                self.console.print(f"\n[bold green]▶ Step {i}/{len(pipeline)}: {' '.join(step)}[/bold green]")
+            ok = self._run_cli_command(step)
+            if not ok:
+                self.console.print(f"[red]Pipeline stopped due to error in step: {' '.join(step)}[/red]")
+                break
+
+    def _run_cli_command(self, args: list[str]) -> bool:
+        """Invoke a Typer CLI command within the REPL session."""
+        from typer.testing import CliRunner
+
+        from forgex.cli.app import app
+
+        runner = CliRunner()
+        success = False
+        try:
+            result = runner.invoke(app, args, catch_exceptions=True)
+            if result.output:
+                # Print output directly
+                sys.stdout.write(result.output)
+                sys.stdout.flush()
+            if result.exit_code != 0 and result.exception:
+                if isinstance(result.exception, ForgexError):
+                    self.console.print(f"[red]✗[/red] {result.exception}")
+                elif not isinstance(result.exception, SystemExit):
+                    self.console.print(f"[red]Error:[/red] {result.exception}")
+            success = result.exit_code == 0
+        except ForgexError as exc:
+            self.console.print(f"[red]✗[/red] {exc}")
+        except KeyboardInterrupt:
+            self.console.print("\n[yellow]Operation cancelled by user.[/yellow]")
+        except Exception as exc:  # noqa: BLE001
+            self.console.print(f"[red]Unexpected error:[/red] {type(exc).__name__}: {exc}")
+        finally:
+            self.session.refresh()
+        return success
+
+    def run(self) -> None:
+        """Main REPL loop."""
+        self.print_banner()
+        self.check_first_run()
+
+        while True:
+            try:
+                line = self.prompt_session.prompt(self.get_prompt_text())
+                self.dispatch(line)
+            except KeyboardInterrupt:
+                self.console.print("\n[yellow]^C (Use 'exit' or Ctrl+D to quit)[/yellow]")
+                continue
+            except EOFError:
+                self.console.print("\n[dim]Goodbye! On-disk state is preserved.[/dim]")
+                break
+
+
+def start_repl(session: Session | None = None) -> None:
+    """Entry point to launch the FORGEX REPL."""
+    repl = ForgexREPL(session=session)
+    repl.run()

forgex/cli/runtime.py

@@ -0,0 +1,233 @@
+"""Autonomous runtime engine for FORGEX Universal CLI.
+
+Unifies project initialization, planning, building, verification,
+supervision, self-healing repairs, and git checkpoints into a single,
+frictionless autonomous pipeline.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import subprocess
+import time
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Literal
+
+from rich.console import Console
+
+from forgex.cli.build_views import format_progress
+from forgex.cli.session import Session
+from forgex.cli.ui import UI, Output, make_approval
+from forgex.config import load_config
+from forgex.orchestration.checkpoints import latest_checkpoint
+from forgex.orchestration.engine import BuildEngine, DryRunReport
+from forgex.orchestration.stores import open_stores
+from forgex.project import initialize_project
+from forgex.schemas.result import TestResults
+from forgex.utils.paths import find_project_root
+
+logger = logging.getLogger("forgex.runtime")
+
+ProgressFn = Callable[[str], None]
+
+
+@dataclass
+class RuntimeResult:
+    """Consolidated outcome of an autonomous execution."""
+
+    status: Literal["completed", "failed"]
+    request: str
+    phases_completed: list[str] = field(default_factory=list)
+    tasks_total: int = 0
+    tasks_completed: int = 0
+    changed_files: list[str] = field(default_factory=list)
+    tests: TestResults | None = None
+    build_ok: bool | None = None
+    checkpoint_id: str | None = None
+    reason: str = ""
+    warnings: list[str] = field(default_factory=list)
+    usage: dict[str, Any] | None = None
+    duration_seconds: float = 0.0
+
+    @property
+    def is_success(self) -> bool:
+        return self.status == "completed"
+
+
+class AutonomousRuntime:
+    """Unified autonomous pipeline executor for FORGEX.
+
+    Takes a high-level user request in natural language and drives:
+    1. Zero-friction project initialization if not already initialized
+    2. Architecture planning and task decomposition
+    3. Per-task implementation with builder & expert coder
+    4. Deterministic testing, linting, and build verification
+    5. Supervisor auditing and soft gates
+    6. Self-healing repair loops until green (bounded)
+    7. Automated git checkpoint snapshot on completion
+    """
+
+    def __init__(
+        self,
+        target_dir: Path | None = None,
+        session: Session | None = None,
+        ui: UI | None = None,
+        progress: ProgressFn | None = None,
+        approval: Callable[[str], bool] | None = None,
+    ) -> None:
+        self.target_dir = Path(target_dir).resolve() if target_dir else Path.cwd()
+        self.session = session
+        self.ui = ui or (session.ui if session else UI(mode=Output.RICH))
+        self.console = self.ui.console if hasattr(self.ui, "console") else Console()
+        self._custom_progress = progress
+        self._approval = approval or (make_approval(self.ui) if self.ui else None)
+
+    def _notify_progress(self, msg: str) -> None:
+        if self._custom_progress:
+            self._custom_progress(msg)
+        elif self.ui:
+            is_rich = getattr(self.ui, "mode", None) is Output.RICH
+            self.ui.text(format_progress(msg, rich_mode=is_rich))
+
+    def _ensure_project_initialized(self) -> tuple[Path, bool]:
+        """Check if target directory is a FORGEX project; auto-initialize if not."""
+        root = find_project_root(self.target_dir)
+        was_initialized = False
+
+        if root is None or not (root / ".forgex").is_dir():
+            self._notify_progress(f"Initializing project workspace at {self.target_dir}...")
+            # Auto-init git if git is available and repo doesn't exist
+            git_dir = self.target_dir / ".git"
+            if not git_dir.exists():
+                try:
+                    subprocess.run(
+                        ["git", "init"],
+                        cwd=self.target_dir,
+                        capture_output=True,
+                        text=True,
+                        check=False,
+                    )
+                except Exception as exc:
+                    logger.debug("git init failed: %s", exc)
+
+            root = initialize_project(self.target_dir)
+            was_initialized = True
+            if self.session:
+                self.session.refresh()
+            self._notify_progress("Project workspace initialized.")
+
+        return root, was_initialized
+
+    async def execute(
+        self,
+        request: str,
+        *,
+        resume: bool = False,
+        dry_run: bool = False,
+        agents: dict[str, Any] | None = None,
+    ) -> RuntimeResult:
+        """Run the full autonomous pipeline for the given task request."""
+        start_time = time.time()
+        phases: list[str] = []
+
+        root, was_newly_inited = self._ensure_project_initialized()
+        if was_newly_inited:
+            phases.append("init")
+
+        config = load_config(root)
+
+        with open_stores(root) as stores:
+            engine = BuildEngine(
+                stores=stores,
+                config=config,
+                approval=self._approval,
+                progress=self._notify_progress,
+                agents=agents,
+            )
+
+            build_result = await engine.run(
+                request=request,
+                dry_run=dry_run,
+                resume=resume,
+            )
+
+        duration = time.time() - start_time
+
+        if isinstance(build_result, DryRunReport):
+            phases.extend(["plan", "preview"])
+            return RuntimeResult(
+                status="completed",
+                request=request,
+                phases_completed=phases,
+                tasks_total=len(build_result.planned_tasks),
+                tasks_completed=0,
+                changed_files=build_result.planned_files,
+                reason="Dry run preview generated successfully",
+                duration_seconds=duration,
+            )
+
+        phases.extend(["plan", "build", "verify", "supervise"])
+
+        checkpoint_id = build_result.checkpoint
+        if build_result.status == "completed":
+            phases.append("checkpoint")
+            # If checkpoint wasn't automatically populated by git, look up latest checkpoint
+            if not checkpoint_id and (root / ".git").exists():
+                try:
+                    with open_stores(root) as stores:
+                        latest = latest_checkpoint(stores=stores)
+                        if latest:
+                            checkpoint_id = latest.git_commit
+                except Exception:
+                    pass
+
+        runtime_res = RuntimeResult(
+            status=build_result.status,
+            request=request,
+            phases_completed=phases,
+            tasks_total=build_result.tasks_total,
+            tasks_completed=build_result.tasks_completed,
+            changed_files=build_result.changed_files,
+            tests=build_result.tests,
+            build_ok=build_result.build_ok,
+            checkpoint_id=checkpoint_id,
+            reason=build_result.reason,
+            warnings=build_result.warnings,
+            usage=build_result.usage,
+            duration_seconds=duration,
+        )
+
+        if self.session:
+            self.session.refresh()
+
+        return runtime_res
+
+
+def execute_autonomous(
+    request: str,
+    target_dir: Path | None = None,
+    session: Session | None = None,
+    ui: UI | None = None,
+    dry_run: bool = False,
+    resume: bool = False,
+    approval: Callable[[str], bool] | None = None,
+    agents: dict[str, Any] | None = None,
+) -> RuntimeResult:
+    """Synchronous convenience wrapper for AutonomousRuntime.execute()."""
+    runtime = AutonomousRuntime(
+        target_dir=target_dir,
+        session=session,
+        ui=ui,
+        approval=approval,
+    )
+    return asyncio.run(
+        runtime.execute(
+            request=request,
+            dry_run=dry_run,
+            resume=resume,
+            agents=agents,
+        )
+    )