forgex-cli 0.1.0__py3-none-any.whl

forgex/cli/commands/tools.py

@@ -0,0 +1,116 @@
+"""`forgex tools` — inspect and manually run tools (agent debugging surface)."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Annotated
+
+import typer
+from rich.table import Table
+
+from forgex.cli.ui import JsonFlag, Output, PlainFlag, make_approval, ui_from
+from forgex.config import load_config
+from forgex.orchestration.stores import open_stores
+from forgex.sandbox.permissions import permission_set_for
+from forgex.schemas.agent import AgentRole
+from forgex.schemas.error import ConfigError, PermissionDeniedError, ProjectError
+from forgex.tools import ToolCall, ToolExecutor, ToolResult, build_tool_registry, create_context
+from forgex.utils.paths import find_project_root
+
+app = typer.Typer(no_args_is_help=True, help="Inspect and manually run FORGEX tools.")
+
+
+@app.command("list")
+def list_command(
+    ctx: typer.Context,
+    json_out: JsonFlag = False,
+    plain: PlainFlag = False,
+) -> None:
+    """List all tools with their required permissions."""
+    ui = ui_from(ctx, json_out=json_out, plain=plain)
+    registry = build_tool_registry()
+    payload = [
+        {
+            "name": t.name,
+            "description": t.description,
+            "permissions": sorted(p.value for p in t.required_permissions),
+            "parameters": t.parameters_schema(),
+        }
+        for t in registry.tools()
+    ]
+    ui.data({"tools": payload})
+    if ui.mode is Output.RICH:
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("Tool")
+        table.add_column("Permissions")
+        table.add_column("Description", overflow="fold")
+        for item in payload:
+            perms_str = ", ".join(item["permissions"]) if isinstance(item["permissions"], list) else str(item["permissions"])
+            table.add_row(str(item["name"]), perms_str or "—", str(item["description"]))
+        ui.console.print(table)
+    elif ui.mode is Output.PLAIN:
+        for item in payload:
+            perms_str = ",".join(item["permissions"]) if isinstance(item["permissions"], list) else str(item["permissions"])
+            ui.console.print(f"{item['name']} [{perms_str}]: {item['description']}")
+
+
+@app.command("run")
+def run_command(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Tool name, e.g. read_file")],
+    agent: Annotated[str, typer.Option("--agent", "-a", help="Act as this agent role.")] = "builder",
+    args_json: Annotated[str | None, typer.Option("--args", help="JSON object of tool arguments.")] = "{}",
+    json_out: JsonFlag = False,
+    plain: PlainFlag = False,
+) -> None:
+    """Run one tool as one agent."""
+    ui = ui_from(ctx, json_out=json_out, plain=plain)
+    root = find_project_root()
+    if root is None:
+        raise ProjectError("Not inside a FORGEX project — run `forgex init` first.")
+
+    try:
+        role = AgentRole(agent)
+    except ValueError as exc:
+        valid = ", ".join(r.value for r in AgentRole)
+        raise ConfigError(f"Unknown agent role '{agent}'. Valid: {valid}") from exc
+
+    try:
+        arguments = json.loads(args_json or "{}")
+        if not isinstance(arguments, dict):
+            raise TypeError("args must be a JSON object")
+    except Exception as exc:
+        raise ConfigError(f"--args must be a valid JSON object: {exc}") from exc
+
+    config = load_config(root)
+    registry = build_tool_registry()
+    with open_stores(root) as stores:
+        tool_ctx = create_context(
+            workspace=root,
+            config=config,
+            events=stores.recorder,
+            approval=make_approval(ui),
+            agent=role,
+        )
+        executor = ToolExecutor(
+            registry=registry,
+            permissions=permission_set_for(role),
+            context=tool_ctx,
+        )
+        try:
+            result = asyncio.run(executor.execute(ToolCall(name=name, arguments=arguments)))
+        except PermissionDeniedError as exc:
+            result = ToolResult(ok=False, denied=True, error=str(exc))
+
+    payload = {
+        "tool": name,
+        "agent": role.value,
+        "ok": result.ok,
+        "denied": result.denied,
+        "error": result.error,
+        "output": result.output,
+        "data": result.data,
+    }
+    ui.console.print(json.dumps(payload, indent=2, default=str), soft_wrap=True, highlight=False)
+    raise typer.Exit(code=0 if result.ok else 1)

forgex/cli/commands/verify.py

@@ -0,0 +1,65 @@
+"""`forgex verify` — deterministic verification harness (tests/build/lint)."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Annotated
+
+import typer
+
+from forgex.cli.ui import JsonFlag, PlainFlag, make_approval, ui_from
+from forgex.config import load_config
+from forgex.orchestration.stores import open_stores
+from forgex.schemas.agent import AgentRole
+from forgex.schemas.error import ProjectError
+from forgex.tools import create_context
+from forgex.tools.verification import run_verification
+from forgex.utils.paths import find_project_root
+
+
+def verify_command(
+    ctx: typer.Context,
+    no_build: Annotated[bool, typer.Option("--no-build", help="Skip the build step.")] = False,
+    no_lint: Annotated[bool, typer.Option("--no-lint", help="Skip the lint step.")] = False,
+    json_out: JsonFlag = False,
+    plain: PlainFlag = False,
+) -> None:
+    """Run tests, build, and lint — deterministic, no LLM."""
+    ui = ui_from(ctx, json_out=json_out, plain=plain)
+    root = find_project_root()
+    if root is None:
+        raise ProjectError("Not inside a FORGEX project — run `forgex init` first.")
+
+    config = load_config(root)
+    with open_stores(root) as stores:
+        tool_ctx = create_context(
+            workspace=root,
+            config=config,
+            events=stores.recorder,
+            approval=make_approval(ui),
+            agent=AgentRole.SUPERVISOR,
+        )
+        outcome = asyncio.run(
+            run_verification(
+                root=root,
+                executor=tool_ctx.executor,
+                events=stores.recorder,
+                include_build=not no_build,
+                include_lint=not no_lint,
+            )
+        )
+
+    ui.data(outcome.model_dump(mode="json"))
+    steps = [("Tests", outcome.tests), ("Build", outcome.build), ("Lint", outcome.lint)]
+    for name, step in steps:
+        if step is None:
+            ui.text(f"{name:<6} — not detected / not configured")
+        elif step.ok:
+            ui.ok(f"{name:<6} {' '.join(step.command)}")
+        else:
+            ui.error(f"{name:<6} FAILED (exit {step.exit_code}{', timed out' if step.timed_out else ''})")
+            if step.output_tail:
+                ui.text(step.output_tail[-1500:])
+
+    ran = [s for _, s in steps if s is not None]
+    raise typer.Exit(code=0 if all(s.ok for s in ran) else 1)

forgex/cli/context_memory.py

@@ -0,0 +1,62 @@
+"""Conversational memory and follow-up context tracker for FORGEX Universal CLI."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+FOLLOWUP_PATTERNS = [
+    r"\b(?:it|that|those|them|these)\b",
+    r"\b(?:now\s+add|also\s+add|and\s+also|next\s+add)\b",
+    r"\b(?:fix\s+the\s+test|fix\s+tests?|make\s+it\s+pass)\b",
+    r"\b(?:refactor\s+it|update\s+it|change\s+it)\b",
+    r"\b(?:same\s+thing|previous\s+task)\b",
+]
+
+
+@dataclass
+class ConversationContext:
+    """Maintains recent task context across interactive prompts."""
+
+    history: list[str] = field(default_factory=list)
+    last_request: str | None = None
+    last_changed_files: list[str] = field(default_factory=list)
+    last_status: str | None = None
+    last_checkpoint_id: str | None = None
+
+    def record_run(
+        self,
+        request: str,
+        status: str,
+        changed_files: list[str],
+        checkpoint_id: str | None = None,
+    ) -> None:
+        """Update context memory with latest execution results."""
+        self.history.append(request)
+        self.last_request = request
+        self.last_status = status
+        self.last_changed_files = list(changed_files)
+        self.last_checkpoint_id = checkpoint_id
+
+    def is_followup(self, text: str) -> bool:
+        """Detect if the new prompt refers back to the previous conversation context."""
+        if not self.last_request:
+            return False
+        clean = text.strip().lower()
+        return any(re.search(pat, clean) for pat in FOLLOWUP_PATTERNS)
+
+    def enrich_request(self, request: str) -> str:
+        """If request is a follow-up, prepend context from previous runs."""
+        clean = request.strip()
+        if not self.is_followup(clean):
+            return clean
+
+        context_parts = []
+        if self.last_request:
+            context_parts.append(f"Previous task: {self.last_request}")
+        if self.last_changed_files:
+            file_sample = ", ".join(self.last_changed_files[:5])
+            context_parts.append(f"Modified files: {file_sample}")
+
+        context_str = " | ".join(context_parts)
+        return f"[Context: {context_str}] {clean}"

forgex/cli/intent.py

@@ -0,0 +1,209 @@
+"""Natural language intent classification for FORGEX REPL."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class IntentAction(str, Enum):
+    PLAN = "plan"
+    PLAN_AND_BUILD = "plan_and_build"
+    AUTONOMOUS = "autonomous"
+    BUILD = "build"
+    FIX = "fix"
+    REVIEW = "review"
+    VERIFY = "verify"
+    SUPERVISE = "supervise"
+    STATUS = "status"
+    DOCTOR = "doctor"
+    MODELS = "models"
+    DIFF = "diff"
+    CHECKPOINT = "checkpoint"
+    ROLLBACK = "rollback"
+    INIT = "init"
+    HELP = "help"
+    CHAT = "chat"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class IntentResult:
+    action: IntentAction
+    confidence: float
+    command_args: list[str]
+    description: str
+    pipeline: list[list[str]] = field(default_factory=list)
+    raw_request: str = ""
+
+    def __post_init__(self) -> None:
+        if not self.pipeline and self.command_args:
+            self.pipeline = [self.command_args]
+
+
+_INTENT_PATTERNS = [
+    # Plan and build patterns (e.g. "build me a REST API", "plan and build a service")
+    (
+        r"^(?:please\s+)?(?:build\s+me\s+|plan\s+and\s+build\s+)(.+)$",
+        IntentAction.PLAN_AND_BUILD,
+        lambda m: [["plan", m.group(1).strip()], ["build"]],
+        "Plan architecture and execute build pipeline",
+    ),
+    # Dedicated plan patterns
+    (
+        r"^(?:please\s+)?(?:plan|design|architect|spec|outline)\s+(.+)$",
+        IntentAction.PLAN,
+        lambda m: [["plan", m.group(1).strip()]],
+        "Create an architectural plan",
+    ),
+    (
+        r"^(?:create|implement|add)\s+(?:a|an|the)?\s*(.+)$",
+        IntentAction.PLAN,
+        lambda m: [["plan", m.group(1).strip()]],
+        "Plan and prepare implementation",
+    ),
+    # Build patterns
+    (
+        r"^(?:please\s+)?(?:build|execute\s+plan|run\s+build|start\s+build)$",
+        IntentAction.BUILD,
+        lambda m: [["build"]],
+        "Execute full build pipeline",
+    ),
+    # Fix patterns
+    (
+        r"^(?:please\s+)?(?:fix|repair|auto-?fix|heal|resolve\s+errors?|debug)(?:\s+(.*))?$",
+        IntentAction.FIX,
+        lambda m: [["fix"]],
+        "Verify, supervise, and auto-repair until green",
+    ),
+    # Review patterns
+    (
+        r"^(?:please\s+)?(?:review|audit|check\s+code|inspect\s+changes?)(?:\s+(.*))?$",
+        IntentAction.REVIEW,
+        lambda m: [["review"]],
+        "Run expert code review",
+    ),
+    # Verify patterns
+    (
+        r"^(?:please\s+)?(?:verify|test|run\s+tests?|check\s+tests?|lint)(?:\s+(.*))?$",
+        IntentAction.VERIFY,
+        lambda m: [["verify"]],
+        "Run deterministic verification (tests/lint/typecheck)",
+    ),
+    # Supervise patterns
+    (
+        r"^(?:please\s+)?(?:supervise|audit\s+and\s+verify|full\s+audit)(?:\s+(.*))?$",
+        IntentAction.SUPERVISE,
+        lambda m: [["supervise"]],
+        "Run full supervision and verification",
+    ),
+    # Status patterns
+    (
+        r"^(?:how\s+is\s+the\s+project|show\s+status|status\s+check|project\s+info|where\s+are\s+we)\b.*$",
+        IntentAction.STATUS,
+        lambda m: [["status"]],
+        "Show project status and metrics",
+    ),
+    # Doctor patterns
+    (
+        r"^(?:check\s+environment|check\s+system|doctor|health\s+check|diagnose)\b.*$",
+        IntentAction.DOCTOR,
+        lambda m: [["doctor"]],
+        "Run environment diagnostic checks",
+    ),
+    # Diff patterns
+    (
+        r"^(?:show\s+diff|git\s+diff|what\s+changed|changes)\b.*$",
+        IntentAction.DIFF,
+        lambda m: [["diff"]],
+        "Show current git diff",
+    ),
+    # Checkpoint patterns
+    (
+        r"^(?:create\s+checkpoint|checkpoint|save\s+state|snapshot)(?:\s+(.+))?$",
+        IntentAction.CHECKPOINT,
+        lambda m: [["checkpoint", m.group(1).strip()]] if m.group(1) else [["checkpoint"]],
+        "Create git checkpoint",
+    ),
+    # Rollback patterns
+    (
+        r"^(?:rollback|undo|revert\s+changes?)\b.*$",
+        IntentAction.ROLLBACK,
+        lambda m: [["rollback"]],
+        "Reversible rollback to previous checkpoint",
+    ),
+    # Init patterns
+    (
+        r"^(?:init|initialize\s+project|create\s+project)\b.*$",
+        IntentAction.INIT,
+        lambda m: [["init"]],
+        "Initialize FORGEX in project directory",
+    ),
+    # Models patterns
+    (
+        r"^(?:show\s+models|list\s+models|models?\s+catalog|which\s+models)\b.*$",
+        IntentAction.MODELS,
+        lambda m: [["models", "catalog"]],
+        "List model bindings and catalog",
+    ),
+    # Help patterns
+    (
+        r"^(?:what\s+can\s+you\s+do|commands|help\s+me)\b.*$",
+        IntentAction.HELP,
+        lambda m: [["help"]],
+        "Show available commands and usage",
+    ),
+]
+
+
+def classify_intent(text: str) -> IntentResult:
+    """Classify free-form natural language input into an action and CLI command pipeline."""
+    clean = text.strip()
+    if not clean:
+        return IntentResult(
+            action=IntentAction.UNKNOWN,
+            confidence=0.0,
+            command_args=[],
+            description="Empty input",
+            raw_request=clean,
+        )
+
+    for pattern, action, pipeline_builder, desc in _INTENT_PATTERNS:
+        match = re.search(pattern, clean, re.IGNORECASE)
+        if match:
+            pipeline = pipeline_builder(match)
+            command_args = pipeline[0] if pipeline else []
+            raw_req = (
+                match.group(1).strip()
+                if match.groups() and match.group(1) is not None
+                else clean
+            )
+            return IntentResult(
+                action=action,
+                confidence=0.9,
+                command_args=command_args,
+                description=desc,
+                pipeline=pipeline,
+                raw_request=raw_req,
+            )
+
+    # Fallback: if text looks like a task or requirement, route to Architect planning
+    if len(clean.split()) >= 3:
+        args = ["plan", clean]
+        return IntentResult(
+            action=IntentAction.PLAN,
+            confidence=0.6,
+            command_args=args,
+            description=f"Plan architectural approach for: '{clean}'",
+            pipeline=[args],
+            raw_request=clean,
+        )
+
+    return IntentResult(
+        action=IntentAction.UNKNOWN,
+        confidence=0.0,
+        command_args=[],
+        description="Could not determine intent",
+        raw_request=clean,
+    )

forgex/cli/progress.py

@@ -0,0 +1,101 @@
+"""Rich terminal progress and summary rendering for FORGEX Universal CLI."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+
+def render_pipeline_header(request: str, console: Console | None = None) -> None:
+    """Print an eye-catching start header for an autonomous build run."""
+    c = console or Console()
+    c.print(
+        Panel(
+            f"[bold cyan]Task:[/bold cyan] {request}\n"
+            "[dim]Autonomous Pipeline: Auto-Init ➔ Plan ➔ Build ➔ Verify ➔ Repair ➔ Checkpoint[/dim]",
+            title="[bold green]FORGEX Autonomous Execution[/bold green]",
+            border_style="cyan",
+        )
+    )
+
+
+def render_runtime_summary(
+    result: Any,
+    console: Console | None = None,
+) -> None:
+    """Render a comprehensive result panel after autonomous pipeline completion."""
+    c = console or Console()
+
+    grid = Table.grid(padding=(0, 2))
+    grid.add_column(style="dim", justify="right")
+    grid.add_column()
+
+    # Status
+    if result.status == "completed":
+        status_text = "[bold green]✔ SUCCESS[/bold green] (Verified & Approved)"
+        border = "green"
+    else:
+        status_text = f"[bold red]✖ FAILED[/bold red] ({result.reason or 'Unresolved errors'})"
+        border = "red"
+
+    grid.add_row("Outcome:", status_text)
+    grid.add_row("Task Request:", f"[bold white]{result.request}[/bold white]")
+
+    # Tasks
+    tasks_text = f"{result.tasks_completed}/{result.tasks_total} completed"
+    if result.tasks_completed == result.tasks_total and result.tasks_total > 0:
+        tasks_text = f"[green]{tasks_text}[/green]"
+    grid.add_row("Tasks Executed:", tasks_text)
+
+    # Changed files
+    if result.changed_files:
+        files_text = f"{len(result.changed_files)} file(s) modified/created"
+        grid.add_row("Code Changes:", files_text)
+
+    # Verification / Tests
+    if result.tests:
+        t = result.tests
+        test_summary = f"[green]{t.passed} passed[/green]"
+        if t.failed > 0:
+            test_summary += f", [red]{t.failed} failed[/red]"
+        if t.skipped > 0:
+            test_summary += f", [yellow]{t.skipped} skipped[/yellow]"
+        grid.add_row("Deterministic Tests:", test_summary)
+
+    # Build status
+    if result.build_ok is not None:
+        build_str = "[green]Passing[/green]" if result.build_ok else "[red]Failing[/red]"
+        grid.add_row("Build/Typecheck:", build_str)
+
+    # Checkpoint
+    if result.checkpoint_id:
+        grid.add_row("Git Checkpoint:", f"[cyan]{result.checkpoint_id[:8]}[/cyan] [dim](reversible snapshot)[/dim]")
+
+    # Duration
+    if getattr(result, "duration_seconds", 0) > 0:
+        grid.add_row("Pipeline Duration:", f"{result.duration_seconds:.1f}s")
+
+    # Token & Cost Usage
+    if getattr(result, "usage", None):
+        u = result.usage
+        prompt_t = u.get("prompt_tokens", 0)
+        compl_t = u.get("completion_tokens", 0)
+        cost = u.get("cost_usd", 0.0)
+        grid.add_row(
+            "Model Usage:",
+            f"{prompt_t:,} prompt + {compl_t:,} completion tokens [dim](${cost:.4f})[/dim]",
+        )
+
+    title = "[bold green]Autonomous Run Complete[/bold green]" if result.is_success else "[bold red]Autonomous Run Incomplete[/bold red]"
+    c.print(Panel(grid, title=title, border_style=border))
+
+    # Show list of files if any
+    if result.changed_files:
+        c.print("[dim]Modified files:[/dim]")
+        for f in result.changed_files[:10]:
+            c.print(f"  [dim]•[/dim] [cyan]{f}[/cyan]")
+        if len(result.changed_files) > 10:
+            c.print(f"  [dim]... and {len(result.changed_files) - 10} more files[/dim]")