terminal-agent-cli 0.1.0__py3-none-any.whl

terminal_agent/cli/commands/setup.py

@@ -0,0 +1,229 @@
+"""Interactive CLI setup command for configuring model providers."""
+
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Optional
+import typer
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+
+from terminal_agent.cli.theme import SYM_CHECK, SYM_CROSS, SYM_WARN, console
+from terminal_agent.cli.ui import render_header
+from terminal_agent.config.schema import ProviderConfig, ProviderType, TerminalAgentConfig
+from terminal_agent.config.settings import load_config
+from terminal_agent.providers.detector import OllamaStatus, detect_ollama, detect_all_providers
+import yaml
+
+
+def setup_command(
+    working_dir: Optional[Path] = typer.Option(None, "--cwd", "-C", help="Target repository directory"),
+) -> None:
+    """Interactively configure the model provider (Ollama, OpenAI, Anthropic, Gemini)."""
+    render_header()
+    target_dir = (working_dir or Path.cwd()).resolve()
+    config_file = target_dir / "terminal-agent.config.yaml"
+    config = load_config(config_file)
+
+    panel_text = (
+        "[bold agent.accent]Terminal Agent Model Provider Setup[/bold agent.accent]\n"
+        "[agent.muted]Configure your local or cloud LLM provider to start using Terminal Agent.[/agent.muted]"
+    )
+    console.print(Panel(panel_text, border_style="agent.border"))
+
+    console.print("\n[agent.accent]Select a model provider:[/agent.accent]")
+    console.print("  [bold]1.[/bold] Ollama (Local open-source models, Free, Private)")
+    console.print("  [bold]2.[/bold] OpenAI (GPT-4o, GPT-4o-mini)")
+    console.print("  [bold]3.[/bold] Anthropic Claude (Claude 3.5 Sonnet)")
+    console.print("  [bold]4.[/bold] Google Gemini (Gemini 1.5 Pro/Flash)")
+    console.print("  [bold]5.[/bold] Mock Provider (Deterministic Testing/Offline)")
+
+    choice = Prompt.ask("\nChoose option", choices=["1", "2", "3", "4", "5"], default="1")
+
+    if choice == "1":
+        _setup_ollama(config, config_file, target_dir)
+    elif choice == "2":
+        _setup_cloud_provider(
+            provider_type=ProviderType.OPENAI,
+            provider_name="OpenAI",
+            env_var_name="OPENAI_API_KEY",
+            default_model="gpt-4o",
+            config=config,
+            config_file=config_file,
+            target_dir=target_dir
+        )
+    elif choice == "3":
+        _setup_cloud_provider(
+            provider_type=ProviderType.ANTHROPIC,
+            provider_name="Anthropic",
+            env_var_name="ANTHROPIC_API_KEY",
+            default_model="claude-3-5-sonnet-20241022",
+            config=config,
+            config_file=config_file,
+            target_dir=target_dir
+        )
+    elif choice == "4":
+        _setup_cloud_provider(
+            provider_type=ProviderType.GEMINI,
+            provider_name="Google Gemini",
+            env_var_name="GEMINI_API_KEY",
+            default_model="gemini-1.5-pro",
+            config=config,
+            config_file=config_file,
+            target_dir=target_dir
+        )
+    elif choice == "5":
+        _save_provider_config(config, config_file, ProviderType.MOCK, "mock-model")
+        console.print(f"\n{SYM_CHECK} [agent.success]Configured Mock Provider for deterministic offline testing.[/agent.success]")
+
+
+def _setup_ollama(config: TerminalAgentConfig, config_file: Path, target_dir: Path) -> None:
+    """Setup and diagnostic flow for Ollama local provider."""
+    console.print("\n[agent.accent]Checking local Ollama installation...[/agent.accent]")
+    target_model = Prompt.ask("Enter target Ollama model name", default="qwen2.5-coder")
+    
+    ollama_res = detect_ollama(target_model=target_model)
+
+    if ollama_res.status == OllamaStatus.OLLAMA_NOT_INSTALLED:
+        console.print(f"\n{SYM_WARN} [agent.warning]Ollama executable was not found in your PATH.[/agent.warning]")
+        console.print("[agent.muted]To install Ollama, visit:[/agent.muted] [bold cyan]https://ollama.com/download[/bold cyan]")
+        console.print(f"\nAfter installing, start Ollama and run: [agent.accent]ollama pull {target_model}[/agent.accent]")
+        
+        save_anyway = Confirm.ask("Do you want to save Ollama as the configured provider anyway?", default=True)
+        if save_anyway:
+            _save_provider_config(config, config_file, ProviderType.OLLAMA, target_model)
+            console.print(f"{SYM_CHECK} [agent.success]Saved Ollama configuration.[/agent.success]")
+        return
+
+    elif ollama_res.status == OllamaStatus.OLLAMA_NOT_RUNNING:
+        console.print(f"\n{SYM_WARN} [agent.warning]Ollama is installed ({ollama_res.cli_path}), but the Ollama server is not running.[/agent.warning]")
+        console.print("[agent.muted]Please start the Ollama application or run in a terminal:[/agent.muted]")
+        console.print("  [bold agent.accent]ollama serve[/bold agent.accent]\n")
+        
+        _save_provider_config(config, config_file, ProviderType.OLLAMA, target_model)
+        console.print(f"{SYM_CHECK} [agent.success]Saved Ollama configuration with model '{target_model}'.[/agent.success]")
+        return
+
+    elif ollama_res.status == OllamaStatus.OLLAMA_MODEL_MISSING:
+        console.print(f"\n{SYM_WARN} [agent.warning]Ollama server is online, but model '{target_model}' is not installed locally.[/agent.warning]")
+        if ollama_res.installed_models:
+            console.print(f"[agent.muted]Currently installed models:[/agent.muted] {', '.join(ollama_res.installed_models)}")
+        
+        should_pull = Confirm.ask(f"Would you like to run 'ollama pull {target_model}' now?", default=False)
+        if should_pull:
+            console.print(f"\n[agent.accent]Pulling model '{target_model}' via Ollama CLI...[/agent.accent]")
+            try:
+                subprocess.run(["ollama", "pull", target_model], check=True)
+                console.print(f"{SYM_CHECK} [agent.success]Successfully pulled model '{target_model}'![/agent.success]")
+            except Exception as e:
+                console.print(f"{SYM_CROSS} [agent.error]Failed to pull model: {e}[/agent.error]")
+                console.print(f"You can pull it manually later with: [bold]ollama pull {target_model}[/bold]")
+        else:
+            console.print(f"[agent.muted]You can pull it manually with: [bold]ollama pull {target_model}[/bold][/agent.muted]")
+
+        _save_provider_config(config, config_file, ProviderType.OLLAMA, target_model)
+        console.print(f"\n{SYM_CHECK} [agent.success]Configured Ollama with model '{target_model}'.[/agent.success]")
+
+    elif ollama_res.status == OllamaStatus.OLLAMA_READY:
+        console.print(f"\n{SYM_CHECK} [agent.success]Ollama server is online and model '{target_model}' is ready to use.[/agent.success]")
+        _save_provider_config(config, config_file, ProviderType.OLLAMA, target_model)
+        console.print(f"{SYM_CHECK} [agent.success]Configured Ollama with model '{target_model}'.[/agent.success]")
+
+    else:
+        console.print(f"\n{SYM_CROSS} [agent.error]Ollama check returned error: {ollama_res.message}[/agent.error]")
+        _save_provider_config(config, config_file, ProviderType.OLLAMA, target_model)
+
+
+def _setup_cloud_provider(
+    provider_type: ProviderType,
+    provider_name: str,
+    env_var_name: str,
+    default_model: str,
+    config: TerminalAgentConfig,
+    config_file: Path,
+    target_dir: Path
+) -> None:
+    """Setup flow for cloud API providers (OpenAI, Anthropic, Gemini)."""
+    console.print(f"\n[agent.accent]Configuring {provider_name}...[/agent.accent]")
+    
+    # Check existing environment variable
+    existing_key = os.environ.get(env_var_name)
+    model = Prompt.ask("Model identifier", default=default_model)
+
+    if existing_key and len(existing_key.strip()) > 5:
+        masked = existing_key[:4] + "..." + existing_key[-4:] if len(existing_key) > 8 else "****"
+        console.print(f"{SYM_CHECK} Found {env_var_name} in environment: [bold agent.muted]{masked}[/bold agent.muted]")
+    else:
+        console.print(f"[agent.muted]No {env_var_name} detected in your current shell environment.[/agent.muted]")
+        api_key = typer.prompt(f"Enter your {provider_name} API Key (input will be hidden)", hide_input=True)
+        
+        if api_key and len(api_key.strip()) > 5:
+            save_to_env = Confirm.ask(f"Save this key to local '.env' file in {target_dir.name}? (Excluded from git)", default=True)
+            if save_to_env:
+                env_file = target_dir / ".env"
+                _append_or_update_env_file(env_file, env_var_name, api_key.strip())
+                console.print(f"{SYM_CHECK} [agent.success]Saved {env_var_name} to {env_file.name}.[/agent.success]")
+            else:
+                console.print("[agent.muted]To set this manually in your shell, run:[/agent.muted]")
+                console.print(f"  [bold]export {env_var_name}='your-api-key'[/bold] (Linux/macOS)")
+                console.print(f"  [bold]$env:{env_var_name}='your-api-key'[/bold] (Windows PowerShell)")
+
+    _save_provider_config(config, config_file, provider_type, model)
+    console.print(f"\n{SYM_CHECK} [agent.success]Successfully configured {provider_name} (Model: {model}).[/agent.success]")
+    console.print("[agent.muted]Next step: Run [bold]terminal-agent doctor[/bold] or start a task with [bold]terminal-agent run \"...\"[/bold][/agent.muted]")
+
+
+def _append_or_update_env_file(env_file: Path, key: str, value: str) -> None:
+    """Helper to safely write or update key-value in a local .env file."""
+    lines: list[str] = []
+    found = False
+    if env_file.exists():
+        lines = env_file.read_text(encoding="utf-8").splitlines()
+        for i, line in enumerate(lines):
+            if line.strip().startswith(f"{key}=") or line.strip().startswith(f"export {key}="):
+                lines[i] = f"{key}={value}"
+                found = True
+                break
+
+    if not found:
+        lines.append(f"{key}={value}")
+
+    env_file.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def _save_provider_config(
+    config: TerminalAgentConfig,
+    config_file: Path,
+    provider_type: ProviderType,
+    model: str
+) -> None:
+    """Persist non-secret provider preferences into terminal-agent.config.yaml."""
+    config.provider.name = provider_type
+    config.provider.model = model
+
+    raw_data = {}
+    if config_file.exists():
+        try:
+            with open(config_file, "r", encoding="utf-8") as f:
+                loaded = yaml.safe_load(f)
+                if isinstance(loaded, dict):
+                    raw_data = loaded
+        except Exception:
+            raw_data = {}
+
+    if "provider" not in raw_data:
+        raw_data["provider"] = {}
+
+    raw_data["provider"]["name"] = provider_type.value
+    raw_data["provider"]["model"] = model
+
+    if not raw_data or len(raw_data) <= 1:
+        raw_data = config.model_dump(mode="json")
+        raw_data["provider"]["name"] = provider_type.value
+        raw_data["provider"]["model"] = model
+        if "api_key" in raw_data["provider"] and raw_data["provider"]["api_key"]:
+            raw_data["provider"]["api_key"] = None
+
+    with open(config_file, "w", encoding="utf-8") as f:
+        yaml.dump(raw_data, f, sort_keys=False, indent=2)

terminal_agent/cli/commands/status.py

@@ -0,0 +1,62 @@
+"""CLI status command inspecting active repository and latest session state."""
+
+from pathlib import Path
+from typing import Optional
+import typer
+from rich.panel import Panel
+from rich.table import Table
+
+from terminal_agent.cli.theme import SYM_CHECK, SYM_CROSS, console
+from terminal_agent.cli.ui import render_header, render_plan, render_task_card
+from terminal_agent.git.adapter import GitAdapter
+from terminal_agent.session.manager import SessionManager
+
+
+def status_command(
+    working_dir: Optional[Path] = typer.Option(None, "--cwd", "-C", help="Target repository directory"),
+) -> None:
+    """Inspect repository status and latest agent session."""
+    render_header()
+    target_dir = (working_dir or Path.cwd()).resolve()
+
+    # Git Status
+    git_adapter = GitAdapter(target_dir)
+    status = git_adapter.get_status()
+    diff_stats = git_adapter.get_diff_stats()
+
+    t_git = Table(box=None, show_header=False)
+    t_git.add_column(style="agent.muted", width=16)
+    t_git.add_column(style="agent.text")
+
+    t_git.add_row("GIT REPO", "[agent.success]Yes[/agent.success]" if status.is_repo else "[agent.muted]No[/agent.muted]")
+    if status.is_repo:
+        t_git.add_row("BRANCH", status.branch)
+        t_git.add_row("WORKING TREE", "[agent.success]Clean[/agent.success]" if status.is_clean else "[agent.warning]Modified[/agent.warning]")
+        t_git.add_row("MODIFIED FILES", f"{len(status.modified_files)} ({', '.join(status.modified_files) if status.modified_files else 'None'})")
+        t_git.add_row("UNTRACKED FILES", f"{len(status.untracked_files)} ({', '.join(status.untracked_files) if status.untracked_files else 'None'})")
+        t_git.add_row("DIFF STATS", f"+{diff_stats.insertions} / -{diff_stats.deletions} lines across {diff_stats.files_changed} files")
+
+    console.print(Panel(t_git, title="[agent.accent]REPOSITORY STATUS[/agent.accent]", border_style="agent.border"))
+
+    # Session Status
+    session_mgr = SessionManager(target_dir)
+    latest = session_mgr.get_latest_session()
+
+    if latest:
+        t_sess = Table(box=None, show_header=False)
+        t_sess.add_column(style="agent.muted", width=16)
+        t_sess.add_column(style="agent.text")
+
+        t_sess.add_row("SESSION ID", latest.session_id)
+        t_sess.add_row("STATUS", f"[agent.accent]{latest.current_status.value}[/agent.accent]")
+        t_sess.add_row("TASK", latest.task_description)
+        t_sess.add_row("STEPS COMPLETED", str(len(latest.completed_steps)))
+        t_sess.add_row("RETRIES", str(len(latest.failures)))
+        t_sess.add_row("LAST UPDATED", latest.updated_at)
+
+        console.print(Panel(t_sess, title="[agent.accent]LATEST AGENT SESSION[/agent.accent]", border_style="agent.border"))
+        if latest.plan:
+            render_plan(latest.plan)
+    else:
+        console.print("[agent.muted]No previous agent sessions recorded in this workspace.[/agent.muted]")
+

terminal_agent/cli/commands/test.py

@@ -0,0 +1,38 @@
+"""CLI test command running independent verification suite."""
+
+from pathlib import Path
+from typing import Optional
+import typer
+
+from terminal_agent.cli.theme import console
+from terminal_agent.cli.ui import render_header, render_verification_result
+from terminal_agent.config.settings import load_config
+from terminal_agent.git.adapter import GitAdapter
+from terminal_agent.sandbox.local import LocalSandbox
+from terminal_agent.security.secrets import SecretGuard
+from terminal_agent.session.models import VerificationStatus
+from terminal_agent.verifier.engine import IndependentVerifier
+
+
+def test_command(
+    test_cmd: Optional[str] = typer.Option(None, "--cmd", "-c", help="Custom test command override"),
+    working_dir: Optional[Path] = typer.Option(None, "--cwd", "-C", help="Target repository directory"),
+) -> None:
+    """Run independent verification test suite on current workspace."""
+    render_header()
+    target_dir = (working_dir or Path.cwd()).resolve()
+
+    config = load_config(target_dir / "terminal-agent.config.yaml")
+    secret_guard = SecretGuard(blocked_patterns=config.security.blocked_paths, working_dir=target_dir)
+    sandbox = LocalSandbox(working_dir=target_dir, default_timeout=config.sandbox.timeout_seconds, secret_guard=secret_guard)
+    git_adapter = GitAdapter(target_dir)
+
+    verifier = IndependentVerifier(sandbox, git_adapter, config.verification, target_dir)
+
+    console.print(f"[agent.muted]Running independent verification in {target_dir}...[/agent.muted]\n")
+    result = verifier.verify(custom_test_cmd=test_cmd)
+    render_verification_result(result)
+
+    if result.status != VerificationStatus.VERIFIED:
+        raise typer.Exit(1)
+

terminal_agent/cli/commands/trace.py

@@ -0,0 +1,60 @@
+"""CLI trace command inspecting telemetry event streams."""
+
+from pathlib import Path
+from typing import Optional
+import typer
+from rich.table import Table
+
+from terminal_agent.cli.theme import SYM_CHECK, SYM_CROSS, console
+from terminal_agent.cli.ui import render_header
+from terminal_agent.session.manager import SessionManager
+from terminal_agent.telemetry.events import TelemetryLogger
+
+
+def trace_command(
+    session_id: Optional[str] = typer.Argument(None, help="Session ID to inspect (defaults to latest)"),
+    working_dir: Optional[Path] = typer.Option(None, "--cwd", "-C", help="Target repository directory"),
+) -> None:
+    """Inspect structured telemetry event trace of an agent session."""
+    render_header()
+    target_dir = (working_dir or Path.cwd()).resolve()
+
+    if not session_id:
+        session_mgr = SessionManager(target_dir)
+        latest = session_mgr.get_latest_session()
+        if latest:
+            session_id = latest.session_id
+        else:
+            console.print("[agent.error]No active or past sessions found.[/agent.error]")
+            raise typer.Exit(1)
+
+    events = TelemetryLogger.read_trace(session_id, working_dir=target_dir)
+
+    if not events:
+        console.print(f"[agent.muted]No trace events recorded for session '{session_id}'.[/agent.muted]")
+        return
+
+    table = Table(title=f"[agent.accent]TELEMETRY TRACE: {session_id}[/agent.accent]", border_style="agent.border")
+    table.add_column("Time", style="agent.muted")
+    table.add_column("Step", style="agent.accent", width=6)
+    table.add_column("Event", style="agent.text", width=14)
+    table.add_column("Tool", style="agent.accent", width=16)
+    table.add_column("Status", width=8)
+    table.add_column("Duration", style="agent.muted", width=10)
+    table.add_column("Reason / Context", style="agent.text")
+
+    for ev in events:
+        time_str = ev.timestamp[11:19]
+        status_sym = SYM_CHECK if ev.status == "success" else SYM_CROSS
+        table.add_row(
+            time_str,
+            str(ev.step),
+            ev.event_type,
+            ev.tool or "-",
+            status_sym,
+            f"{ev.duration_ms}ms",
+            ev.reason or "-"
+        )
+
+    console.print(table)
+

terminal_agent/cli/main.py

@@ -0,0 +1,94 @@
+"""Main Typer CLI entrypoint for Terminal Agent."""
+
+import importlib.metadata
+import sys
+from pathlib import Path
+from typing import Optional
+import typer
+
+from terminal_agent.cli.commands.checkpoint import checkpoint_app, rollback_command
+from terminal_agent.cli.commands.config_cmd import config_command
+from terminal_agent.cli.commands.diff import diff_command
+from terminal_agent.cli.commands.doctor import doctor_command
+from terminal_agent.cli.commands.resume import resume_command
+from terminal_agent.cli.commands.run import run_command
+from terminal_agent.cli.commands.setup import setup_command
+from terminal_agent.cli.commands.status import status_command
+from terminal_agent.cli.commands.test import test_command
+from terminal_agent.cli.commands.clean import clean_command
+from terminal_agent.cli.commands.trace import trace_command
+
+
+def version_callback(value: bool):
+    if value:
+        try:
+            ver = importlib.metadata.version("terminal-agent-cli")
+        except Exception:
+            try:
+                ver = importlib.metadata.version("terminal-agent")
+            except Exception:
+                from terminal_agent import __version__ as ver
+
+        typer.echo(f"terminal-agent v{ver}")
+        raise typer.Exit()
+    
+
+app = typer.Typer(
+    name="terminal-agent",
+    help="Terminal Agent: Build. Verify. Ship. Autonomous terminal-based coding agent.",
+    no_args_is_help=False
+)
+
+
+@app.callback()
+def main(
+    version: Optional[bool] = typer.Option(
+        None,
+        "--version",
+        "-v",
+        callback=version_callback,
+        is_eager=True,
+        help="Show the version and exit.",
+    )
+):
+    pass
+
+
+# Register Subcommands
+app.command(name="run", help="Run an autonomous coding task.")(run_command)
+app.command(name="setup", help="Interactively configure model providers (Ollama, OpenAI, Claude, Gemini).")(setup_command)
+app.command(name="resume", help="Resume an interrupted agent session.")(resume_command)
+app.command(name="status", help="Inspect workspace git status and active session.")(status_command)
+app.command(name="diff", help="View working tree git diff and stats.")(diff_command)
+app.command(name="test", help="Execute independent verification test suite.")(test_command)
+app.add_typer(checkpoint_app, name="checkpoint")
+app.command(name="rollback", help="Restore repository state to a previous checkpoint.")(rollback_command)
+app.command(name="doctor", help="Check system health, sandboxing, and provider status.")(doctor_command)
+app.command(name="trace", help="View structured telemetry trace for a session.")(trace_command)
+app.command(name="config", help="View or initialize configuration file.")(config_command)
+app.command(name="clean", help="Prune old sessions, checkpoints, and telemetry files.")(clean_command)
+
+KNOWN_COMMANDS = {
+    "run", "setup", "resume", "status", "diff", "test", "checkpoint",
+    "rollback", "doctor", "trace", "config", "clean", "--help", "-h",
+    "--version", "-v"
+}
+
+
+def cli():
+    """Main CLI entrypoint handling automatic default 'run' routing."""
+    args = sys.argv[1:]
+    if args:
+        first_arg = args[0]
+        if first_arg not in KNOWN_COMMANDS and not first_arg.startswith("-"):
+            # Route bare string task to 'run' subcommand
+            sys.argv.insert(1, "run")
+    elif len(sys.argv) == 1:
+        # Bare terminal-agent invocation -> prompt in run command
+        sys.argv.append("run")
+
+    app()
+
+
+if __name__ == "__main__":
+    cli()

terminal_agent/cli/theme.py

@@ -0,0 +1,55 @@
+"""Rich theme and color definitions adhering to Terminal Agent monochrome aesthetic."""
+
+import os
+import sys
+from rich.console import Console
+from rich.theme import Theme
+
+# Force UTF-8 on Windows terminal if available
+if sys.platform == "win32":
+    try:
+        if hasattr(sys.stdout, "reconfigure"):
+            sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+        if hasattr(sys.stderr, "reconfigure"):
+            sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+# Terminal Agent Monochrome Palette
+PALETTE = {
+    "bg": "#0A0A0A",
+    "text": "#EDEDED",
+    "muted": "#8A8A8A",
+    "success": "#69F0AE",
+    "warning": "#FFC857",
+    "error": "#FF5F56",
+    "accent": "#F5F5F5",
+    "cyan_accent": "#00E5FF",
+    "orange_accent": "#FF9100",
+}
+
+TERMINAL_AGENT_THEME = Theme({
+    "agent.title": f"bold {PALETTE['accent']}",
+    "agent.tagline": f"italic {PALETTE['muted']}",
+    "agent.text": PALETTE["text"],
+    "agent.muted": PALETTE["muted"],
+    "agent.success": f"bold {PALETTE['success']}",
+    "agent.warning": f"bold {PALETTE['warning']}",
+    "agent.error": f"bold {PALETTE['error']}",
+    "agent.accent": f"bold {PALETTE['accent']}",
+    "agent.cyan": PALETTE["cyan_accent"],
+    "agent.orange": PALETTE["orange_accent"],
+    "agent.code": f"{PALETTE['accent']} on #1E1E1E",
+    "agent.border": "#333333",
+})
+
+console = Console(theme=TERMINAL_AGENT_THEME, legacy_windows=False)
+error_console = Console(theme=TERMINAL_AGENT_THEME, stderr=True, legacy_windows=False)
+
+# Symbols (Safe UTF-8 with fallback)
+SYM_CHECK = "[agent.success]✓[/agent.success]"
+SYM_CROSS = "[agent.error]✗[/agent.error]"
+SYM_ARROW = "[agent.accent]→[/agent.accent]"
+SYM_BULLET = "[agent.muted]•[/agent.muted]"
+SYM_WARN = "[agent.warning]![/agent.warning]"
+