minima-cli 0.4.9__py3-none-any.whl

minima_harness/tui/bridge.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+from minima_harness.agent.events import (
+    AgentEndEvent,
+    AgentStartEvent,
+    MessageEndEvent,
+    MessageStartEvent,
+    MessageUpdateEvent,
+    ToolExecutionEndEvent,
+    ToolExecutionStartEvent,
+    ToolExecutionUpdateEvent,
+    TurnEndEvent,
+    TurnStartEvent,
+)
+from minima_harness.ai.events import TextDeltaEvent, ThinkingDeltaEvent
+
+_log = logging.getLogger("minima_harness.tui.bridge")
+
+
+@dataclass
+class EventBridge:
+    """Agent subscribe-listener that turns AgentEvents into a renderable transcript model.
+
+    The app passes ``on_*`` callbacks (wired to widgets) via :meth:`bind`; absent
+    callbacks are no-ops so the bridge is unit-testable in isolation.
+    """
+
+    assistant_text: str = field(default="")
+    tools: list[dict[str, Any]] = field(default_factory=list)
+    turns: int = 0
+    finished: bool = False
+    error: str | None = None
+
+    def __post_init__(self) -> None:
+        self._on_text = None
+        self._on_thinking = None
+        self._on_tool_start = None
+        self._on_tool_end = None
+        self._on_turn = None
+        self._on_finish = None
+
+    def bind(
+        self,
+        *,
+        on_text=None,
+        on_thinking=None,
+        on_tool_start=None,
+        on_tool_end=None,
+        on_turn=None,
+        on_finish=None,
+    ) -> None:
+        self._on_text = on_text
+        self._on_thinking = on_thinking
+        self._on_tool_start = on_tool_start
+        self._on_tool_end = on_tool_end
+        self._on_turn = on_turn
+        self._on_finish = on_finish
+
+    def _safe(self, cb, *args) -> None:
+        if cb is None:
+            return
+        try:
+            cb(*args)
+        except Exception:  # noqa: BLE001 - the hot path must never break on rendering
+            _log.warning("bridge_callback_failed", exc_info=True)
+
+    async def __call__(self, event) -> None:  # noqa: ANN001 - AgentEvent union
+        if isinstance(event, AgentStartEvent):
+            self.assistant_text = ""
+            self.tools = []
+            self.turns = 0
+            self.finished = False
+        elif isinstance(event, TurnStartEvent):
+            pass
+        elif isinstance(event, MessageStartEvent):
+            pass
+        elif isinstance(event, MessageUpdateEvent):
+            stream = event.assistant_message_event
+            if isinstance(stream, TextDeltaEvent) and stream.delta:
+                self.assistant_text += stream.delta
+                self._safe(self._on_text, stream.delta)
+            elif isinstance(stream, ThinkingDeltaEvent) and stream.delta:
+                self._safe(self._on_thinking, stream.delta)
+        elif isinstance(event, MessageEndEvent):
+            pass
+        elif isinstance(event, ToolExecutionStartEvent):
+            rec = {"id": event.tool_call_id, "name": event.tool_name, "args": event.args}
+            self.tools.append(rec)
+            self._safe(self._on_tool_start, rec)
+        elif isinstance(event, ToolExecutionUpdateEvent):
+            pass
+        elif isinstance(event, ToolExecutionEndEvent):
+            self._safe(self._on_tool_end, event.tool_call_id, event.result, event.is_error)
+        elif isinstance(event, TurnEndEvent):
+            self.turns += 1
+            self._safe(self._on_turn, event)
+        elif isinstance(event, AgentEndEvent):
+            self.finished = True
+            self._safe(self._on_finish, event)

minima_harness/tui/cli.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+from minima_harness.minima.config import HarnessConfig
+from minima_harness.minima.meter import CostMeter
+from minima_harness.minima.runtime import MinimaAgent
+from minima_harness.session import SessionManager, SessionStore
+from minima_harness.tui.app import HarnessApp
+from minima_harness.tui.context import build_system_prompt
+from minima_harness.tui.packages import packages_cli
+
+# .env files (in cwd) auto-loaded so `minima-harness` works without `make`/`--env-file`.
+_ENV_FILES = (".env.harness", ".env")
+_PKG_COMMANDS = ("install", "list", "remove")
+
+
+def _load_env_files() -> None:
+    for name in _ENV_FILES:
+        path = Path(name)
+        if not path.is_file():
+            continue
+        for line in path.read_text().splitlines():
+            line = line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            key, _, val = line.partition("=")
+            val = val.strip().strip('"').strip("'")
+            os.environ.setdefault(key.strip(), val)  # real env / --env-file wins
+    # Per-user store (OS keyring + ~/.minima-harness/config.env) — lowest precedence, so the
+    # CLI works from any directory while shell env and project .env files still override it.
+    try:
+        from minima_harness.tui.config_store import hydrate_env
+
+        hydrate_env()
+    except Exception:  # noqa: BLE001 - config must never block startup
+        pass
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="minima", description="Minima CLI — cost-aware model-routing coding agent."
+    )
+    p.add_argument(
+        "prompt", nargs="*", help="optional initial prompt (used by --print/--mode json)"
+    )
+    p.add_argument("--provider")
+    p.add_argument("--model")
+    p.add_argument("--thinking", default="off")
+    p.add_argument("-c", "--continue", dest="continue_last", action="store_true")
+    p.add_argument("-r", "--resume", action="store_true")
+    p.add_argument("--session")
+    p.add_argument("--fork")
+    p.add_argument("--no-session", action="store_true")
+    p.add_argument("-n", "--name")
+    p.add_argument("-t", "--tools", help="comma-separated allowlist")
+    p.add_argument("-xt", "--exclude-tools", help="comma-separated denylist")
+    p.add_argument("-nt", "--no-tools", action="store_true")
+    p.add_argument("--offline", action="store_true")
+    p.add_argument("-p", "--print", action="store_true", help="one-shot: print the reply and exit")
+    p.add_argument(
+        "--mode",
+        choices=("interactive", "print", "json"),
+        default="interactive",
+        help="run mode (interactive TUI, one-shot print, or JSON event stream)",
+    )
+    p.add_argument(
+        "--mouse",
+        action=argparse.BooleanOptionalAction,
+        default=None,  # resolved per-terminal below (see _resolve_mouse)
+        help="capture the mouse: scroll-wheel + in-app drag-select & copy. Default ON, except "
+        "macOS Terminal.app — it doesn't report mouse motion (xterm 1003), so in-app drag-select "
+        "can't work and capture would only block its native selection; defaults OFF there (select "
+        "natively, scroll with PageUp/PageDown). Override with --mouse/--no-mouse; /mouse toggles.",
+    )
+    p.add_argument(
+        "--dangerously-skip-permissions",
+        action="store_true",
+        help="don't ask before write/edit/bash (YOLO). Off by default — the TUI asks first.",
+    )
+    return p
+
+
+def _resolve_mouse(flag: bool | None) -> bool:
+    """Resolve the mouse-capture default. Explicit --mouse/--no-mouse wins. Otherwise ON,
+    except macOS Terminal.app, which doesn't report mouse motion (xterm mode 1003) — so in-app
+    drag-select can't work there and capturing the mouse would only suppress its rock-solid native
+    selection. Default OFF there so users can select+copy out of the box."""
+    if flag is not None:
+        return flag
+    return os.environ.get("TERM_PROGRAM") != "Apple_Terminal"
+
+
+def _tools_for(args: argparse.Namespace):
+    from minima_harness.tools import default_toolset
+
+    tools = [] if args.no_tools else default_toolset()
+    if args.tools:
+        allow = {t.strip() for t in args.tools.split(",")}
+        tools = [t for t in tools if t.name in allow]
+    if args.exclude_tools:
+        deny = {t.strip() for t in args.exclude_tools.split(",")}
+        tools = [t for t in tools if t.name not in deny]
+    return tools
+
+
+def _register_providers(cwd: Path) -> None:
+    from minima_harness.ai.provider_catalog import provider_key_present, register_catalog_models
+    from minima_harness.ai.providers import ensure_providers_registered
+    from minima_harness.tui.extra_models import register_extra_models
+
+    ensure_providers_registered()
+    # Register the curated multi-provider catalog, but only for providers whose key is
+    # configured — so the model picker stays relevant (you see models you can actually run).
+    register_catalog_models()
+    # OpenRouter is an aggregator: one key unlocks its *entire* live model list (cached +
+    # offline-safe), not just a few curated ids. Register it when the key is present.
+    if provider_key_present("openrouter"):
+        try:
+            from minima_harness.ai.openrouter_catalog import register_openrouter_models
+
+            register_openrouter_models()
+        except Exception:  # noqa: BLE001 - never block startup on the OpenRouter catalog
+            pass
+    register_extra_models(cwd)
+
+
+def _overlay_minima_prices(config: HarnessConfig) -> None:
+    """Best-effort: overlay Minima's authoritative live pricing onto the registered models.
+
+    So the cost the harness reports for a call matches the cost the server routed against
+    (keeps est-vs-actual honest). Offline-safe and quick: skipped without a Minima URL, short
+    timeout, and any failure is swallowed (the seeded prices stand)."""
+    if not (config.minima_url or "").strip():
+        return
+    try:
+        from minima_client import MinimaClient
+
+        from minima_harness.minima.mapping import sync_catalog
+
+        with MinimaClient(
+            config.minima_url, config.minima_api_key, timeout=min(config.timeout, 8.0)
+        ) as client:
+            sync_catalog(client)
+    except Exception:  # noqa: BLE001 - pricing overlay must never block startup
+        pass
+
+
+def main(argv: list[str] | None = None) -> int:
+    _load_env_files()
+    raw = sys.argv[1:] if argv is None else list(argv)
+
+    # `minima-harness config …` — credential setup (no TUI; works before any keys exist).
+    if raw and raw[0] == "config":
+        from minima_harness.tui.config_cli import config_cli
+
+        return config_cli(raw[1:])
+
+    # `minima-harness install|list|remove …` — package management (no TUI).
+    if raw and raw[0] in _PKG_COMMANDS:
+        return packages_cli(raw[0], raw[1:])
+
+    args = _build_parser().parse_args(raw)
+    config = HarnessConfig.from_env()
+    if args.offline:
+        config.minima_url = ""
+    cwd = Path.cwd()
+    _register_providers(cwd)
+    # Gate the routing candidate pool to models whose provider key is configured (after
+    # registration so newly-added providers count) — Minima won't be offered a model the
+    # user can't run. No-op when keys for the defaults (Anthropic/Gemini) are present.
+    from minima_harness.ai.provider_catalog import runnable_candidates
+
+    config.candidates = runnable_candidates(config.candidates)
+    _overlay_minima_prices(config)
+    tools = _tools_for(args)
+
+    noninteractive = args.print or args.mode in ("print", "json")
+    if noninteractive:
+        prompt = " ".join(args.prompt).strip()
+        if not prompt:
+            print("minima-harness: --print/--mode json requires a prompt", file=sys.stderr)
+            return 2
+        agent = MinimaAgent(
+            config, tools=tools, meter=CostMeter(), system_prompt=build_system_prompt(cwd)
+        )
+        from minima_harness.tui.run_modes import run_json, run_print
+
+        runner = run_json if args.mode == "json" else run_print
+        return asyncio.run(runner(agent, prompt))
+
+    mgr = SessionManager()
+    load_on_start = False
+    try:
+        if args.no_session:
+            session = SessionStore.in_memory()
+        elif args.session or args.continue_last:
+            session = mgr.open(cwd, session_id=args.session)
+            load_on_start = True
+        else:
+            session = mgr.new(cwd, name=args.name)
+        if args.name:
+            session.display_name = args.name
+    except FileNotFoundError as exc:
+        print(f"minima-harness: {exc}", file=sys.stderr)
+        return 2
+
+    app = HarnessApp(
+        config,
+        session=session,
+        tools=tools,
+        cwd=cwd,
+        system_prompt=build_system_prompt(cwd),
+        load_session=load_on_start,
+        skip_permissions=args.dangerously_skip_permissions,
+        mouse=(mouse := _resolve_mouse(args.mouse)),
+    )
+    app.run(mouse=mouse)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

minima_harness/tui/clipboard.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import base64
+import shutil
+import subprocess
+import sys
+
+
+def _platform_command() -> list[str] | None:
+    if sys.platform == "darwin":
+        return ["pbcopy"]
+    if shutil.which("wl-copy"):
+        return ["wl-copy"]
+    if shutil.which("xclip"):
+        return ["xclip", "-selection", "clipboard"]
+    if shutil.which("xsel"):
+        return ["xsel", "--clipboard", "--input"]
+    if sys.platform == "win32":
+        return ["clip"]
+    return None
+
+
+def _osc52_copy(text: str) -> bool:
+    """Emit an OSC 52 clipboard sequence to the controlling terminal.
+
+    Works through tmux/SSH and modern terminals (iTerm2, kitty, wezterm, alacritty,
+    Windows Terminal). Best-effort: harmless if the terminal ignores it.
+    """
+    if sys.platform == "win32":
+        return False
+    seq = f"\x1b]52;c;{base64.b64encode(text.encode('utf-8')).decode('ascii')}\x07"
+    for target in ("/dev/tty",):  # write straight to the controlling terminal
+        try:
+            with open(target, "w", encoding="utf-8") as tty:
+                tty.write(seq)
+                tty.flush()
+            return True
+        except OSError:
+            continue
+    return False
+
+
+def copy_to_clipboard(text: str) -> bool:
+    """Copy ``text`` to the clipboard. Returns True if any method wrote without error.
+
+    Full-screen TUI apps capture the mouse, so native selection/copy usually fails.
+    Tries the platform clipboard tool (pbcopy/xclip/xsel/wl-copy/clip) AND OSC 52 (which
+    reaches the clipboard even through tmux/SSH).
+    """
+    ok = False
+    cmd = _platform_command()
+    if cmd is not None:
+        try:
+            subprocess.run(cmd, input=text.encode("utf-8"), check=True)  # noqa: S603
+            ok = True
+        except Exception:  # noqa: BLE001
+            pass
+    if _osc52_copy(text):
+        ok = True
+    return ok

minima_harness/tui/commands.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+Handler = Callable[[Any, str], Awaitable[str | None]]
+
+
+@dataclass(slots=True)
+class Command:
+    name: str
+    handler: Handler
+    description: str = ""
+    hidden: bool = False  # dispatchable via get(), but omitted from listings (aliases)
+
+
+@dataclass(slots=True)
+class CommandRegistry:
+    _cmds: dict[str, Command] = field(default_factory=dict)
+
+    def register(
+        self, name: str, *, description: str = "", hidden: bool = False
+    ) -> Callable[[Handler], Handler]:
+        def deco(fn: Handler) -> Handler:
+            self._cmds[name] = Command(
+                name=name, handler=fn, description=description, hidden=hidden
+            )
+            return fn
+
+        return deco
+
+    def get(self, name: str) -> Command | None:
+        return self._cmds.get(name)
+
+    def add_command(self, cmd: Command) -> None:
+        self._cmds[cmd.name] = cmd
+
+    def remove_command(self, name: str) -> None:
+        self._cmds.pop(name, None)
+
+    def all(self) -> list[Command]:
+        # Hidden aliases stay dispatchable (via get) but out of the palette/help/completion.
+        return sorted((c for c in self._cmds.values() if not c.hidden), key=lambda c: c.name)
+
+    def help_text(self) -> str:
+        width = max((len(c.name) for c in self._cmds.values()), default=4)
+        lines = [f"  /{c.name.ljust(width)}  {c.description}".rstrip() for c in self.all()]
+        return "Commands:\n" + "\n".join(lines)

minima_harness/tui/compaction.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from minima_harness.ai import Context, Message, complete
+from minima_harness.ai.types import Model
+from minima_harness.tui.context import SUMMARY_SYSTEM, SUMMARY_USER
+
+
+async def summarize(messages: list[Message], model: Model, *, instructions: str = "") -> str:
+    """Summarize ``messages`` into a compact context note via ``complete``."""
+    convo = list(messages)
+    convo.append(Message(role="user", content=instructions.strip() or SUMMARY_USER))
+    resp = await complete(
+        model,
+        Context(system_prompt=SUMMARY_SYSTEM, messages=convo),
+        options={"timeout": 60.0},
+    )
+    return resp.text.strip()

minima_harness/tui/config_cli.py

@@ -0,0 +1,141 @@
+"""``minima config`` — the pre-TUI credential setup command.
+
+Sectioned guided setup plus non-interactive ``list``/``get``/``set``/``unset``/``doctor``/
+``path``. Secrets are never echoed: interactive entry uses ``getpass``, and ``list``/``get``
+mask values to the last 4 characters. Backed by :mod:`minima_harness.tui.config_store`.
+"""
+
+from __future__ import annotations
+
+import getpass
+import os
+import sys
+
+from minima_harness.minima.config import DEFAULT_MINIMA_URL
+from minima_harness.tui import config_store as store
+
+_USAGE = (
+    "usage: minima config "
+    "[list | get <KEY> | set <KEY> <VALUE> | unset <KEY> | doctor | path]\n"
+    "       minima config            # interactive guided setup"
+)
+
+
+def _list() -> int:
+    print(f"config file:     {store.CONFIG_FILE}")
+    print(f"secrets backend: {store.backend_name()} (service '{store.KEYRING_SERVICE}')\n")
+    for section in store.SECTIONS:
+        print(f"[{section.title}]")
+        for f in section.fields:
+            val = store.get(f.key)
+            if val:
+                shown = store.mask(val) if f.secret else val
+                print(f"  {f.key:<20} {shown:<26} ({store.location(f.key)})")
+            else:
+                print(f"  {f.key:<20} {'—':<26} ({'optional' if f.optional else 'MISSING'})")
+        print()
+    return 0
+
+
+def _interactive() -> int:
+    print("minima config — press Enter to keep the current value.\n")
+    for section in store.SECTIONS:
+        print(f"# {section.title} — {section.note}")
+        for f in section.fields:
+            cur = store.get(f.key)
+            if f.secret:
+                shown = store.mask(cur) if cur else "unset"
+                entered = getpass.getpass(f"  {f.key} [{shown}]: ").strip()
+            else:
+                shown = cur or f.default or "unset"
+                entered = input(f"  {f.key} [{shown}]: ").strip()
+            if entered:
+                print(f"    saved → {store.set_value(f.key, entered)}")
+            elif not cur and f.default and not f.secret:
+                store.set_value(f.key, f.default)
+                print(f"    saved default → {f.default}")
+        print()
+    print("done. Run `minima config doctor` to verify.")
+    return 0
+
+
+def _doctor() -> int:
+    store.hydrate_env()
+    print("config doctor\n")
+    providers = [
+        ("Anthropic", "ANTHROPIC_API_KEY"),
+        ("Gemini", "GEMINI_API_KEY"),
+        ("OpenAI", "OPENAI_API_KEY"),
+        ("Mubit", "MUBIT_API_KEY"),
+    ]
+    for label, key in providers:
+        ok = bool(os.environ.get(key))
+        print(f"  [{'ok' if ok else '  '}] {label:<10} {key:<18} {'present' if ok else 'missing'}")
+
+    url = os.environ.get("MINIMA_URL", DEFAULT_MINIMA_URL)
+    print(f"\n  Minima endpoint: {url}")
+    import httpx
+
+    reachable = False
+    try:
+        resp = httpx.get(url.rstrip("/") + "/v1/health", timeout=5.0)
+        print(f"  health: HTTP {resp.status_code}")
+        reachable = True
+    except Exception as exc:  # noqa: BLE001 - any failure is just 'unreachable'
+        print(f"  health: unreachable ({type(exc).__name__})")
+
+    # Authenticated probe: /v1/health is unauthenticated, so it can't tell a valid key from a
+    # bad one. A minimal recommend with the key actually exercises the routing auth path.
+    key = os.environ.get("MINIMA_API_KEY") or os.environ.get("MUBIT_API_KEY")
+    if not reachable:
+        return 0
+    if not key:
+        print("  auth: no MUBIT_API_KEY/MINIMA_API_KEY set — routing falls back to offline")
+        return 0
+    try:
+        r = httpx.post(
+            url.rstrip("/") + "/v1/recommend",
+            headers={"authorization": f"Bearer {key}"},
+            json={"task": {"task": "minima config doctor probe"}, "cost_quality_tradeoff": 5},
+            timeout=15.0,
+        )
+        if r.status_code == 200:
+            print("  auth: OK — key accepted")
+        elif r.status_code in (401, 403):
+            print(f"  auth: FAILED — key rejected (HTTP {r.status_code})")
+        else:
+            print(f"  auth: HTTP {r.status_code}")
+    except Exception as exc:  # noqa: BLE001
+        print(f"  auth: probe failed ({type(exc).__name__})")
+    return 0
+
+
+def config_cli(args: list[str]) -> int:
+    if not args:
+        return _interactive()
+    cmd, rest = args[0], args[1:]
+    if cmd == "list":
+        return _list()
+    if cmd == "path":
+        print(store.CONFIG_FILE)
+        print(f"secrets backend: {store.backend_name()} (service '{store.KEYRING_SERVICE}')")
+        return 0
+    if cmd == "doctor":
+        return _doctor()
+    if cmd == "get" and rest:
+        val = store.get(rest[0])
+        if val is None:
+            print(f"{rest[0]}: unset", file=sys.stderr)
+            return 1
+        f = store.field_for(rest[0])
+        print(store.mask(val) if (f is None or f.secret) else val)  # secrets stay masked
+        return 0
+    if cmd == "set" and len(rest) >= 2:
+        print(f"set {rest[0]} → {store.set_value(rest[0], rest[1])}")
+        return 0
+    if cmd == "unset" and rest:
+        store.unset(rest[0])
+        print(f"unset {rest[0]}")
+        return 0
+    print(_USAGE, file=sys.stderr)
+    return 2