minima-cli 0.4.9__py3-none-any.whl

minima_harness/tui/config_store.py

@@ -0,0 +1,237 @@
+"""Per-user credential store for the harness — keyring-first, 0600-file fallback.
+
+Mirrors how best-in-class coding-agent CLIs persist secrets (Claude Code: macOS Keychain,
+else ``~/.<tool>/...`` at mode 0600). Secrets go to the OS keyring when a real backend is
+available; otherwise they fall back to ``~/.minima-harness/config.env`` written 0600.
+Non-secret config (URLs) always lives in the file — no point keychaining a URL.
+
+The harness itself reads everything from environment variables (provider keys via
+``resolve_api_key``, Mubit via ``os.environ``), so :func:`hydrate_env` materialises stored
+values into ``os.environ`` at startup with ``setdefault`` — keeping the store the *lowest*
+precedence (real shell env and project ``.env`` files still win).
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+
+from minima_harness.minima.config import DEFAULT_MINIMA_URL
+from minima_harness.tui.customize import GLOBAL_DIR
+
+CONFIG_FILE = GLOBAL_DIR / "config.env"
+KEYRING_SERVICE = "minima-harness"
+
+
+def _keyring():  # noqa: ANN202 - the keyring module type is optional/dynamic
+    """Return the keyring module iff a *real* (non-fail) backend is available, else None."""
+    try:
+        import keyring
+        from keyring.backends import fail
+
+        if isinstance(keyring.get_keyring(), fail.Keyring):
+            return None
+        return keyring
+    except Exception:  # noqa: BLE001 - keyring is optional; any failure → file fallback
+        return None
+
+
+@dataclass(frozen=True, slots=True)
+class Field:
+    """One configurable value. ``secret`` fields are masked + keyring-eligible."""
+
+    key: str
+    label: str
+    secret: bool = True
+    optional: bool = False
+    default: str = ""
+    aliases: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class Section:
+    title: str
+    note: str
+    fields: tuple[Field, ...] = field(default_factory=tuple)
+
+
+def _provider_fields() -> tuple[Field, ...]:
+    """Build the LLM-provider key fields from the provider catalog (single source of truth)."""
+    from minima_harness.ai.provider_catalog import config_providers
+
+    fields: list[Field] = []
+    for p in config_providers():
+        primary, *alts = p.env_vars
+        label = f"{p.display_name} — {p.blurb}" if p.blurb else f"{p.display_name} API key"
+        fields.append(Field(primary, label, optional=True, aliases=tuple(alts)))
+    return tuple(fields)
+
+
+SECTIONS: tuple[Section, ...] = (
+    Section(
+        title="LLM provider keys",
+        note="Keys to RUN the chosen model — set any one (or several). More providers "
+        "(Fireworks, DeepInfra, Cerebras, Perplexity, Cohere, …) work by exporting their env "
+        "var; local runtimes (Ollama, vLLM, LM Studio) need no key.",
+        fields=_provider_fields(),
+    ),
+    Section(
+        title="Mubit / Minima routing",
+        note="Mubit memory backend + the Minima recommender endpoint.",
+        fields=(
+            Field("MUBIT_API_KEY", "Mubit API key (memory + routing auth)"),
+            Field(
+                "MINIMA_URL",
+                "Minima endpoint URL",
+                secret=False,
+                optional=True,
+                default=DEFAULT_MINIMA_URL,
+            ),
+            Field(
+                "MINIMA_API_KEY",
+                "Minima auth (optional; falls back to MUBIT_API_KEY)",
+                optional=True,
+            ),
+            Field("MUBIT_ENDPOINT", "Mubit endpoint URL", secret=False, optional=True),
+        ),
+    ),
+)
+
+
+def all_fields() -> list[Field]:
+    return [f for section in SECTIONS for f in section.fields]
+
+
+def field_for(key: str) -> Field | None:
+    return next((f for f in all_fields() if f.key == key), None)
+
+
+def backend_name() -> str:
+    """The active secrets backend label, for display."""
+    return "keyring" if _keyring() is not None else "file"
+
+
+def mask(value: str | None) -> str:
+    """Show only the last 4 chars of a secret (never the whole thing)."""
+    if not value:
+        return ""
+    if len(value) <= 4:
+        return "•" * len(value)
+    return "•" * 4 + value[-4:]
+
+
+# --- file backend (env-format, mode 0600) ---------------------------------------------
+
+
+def _read_file() -> dict[str, str]:
+    out: dict[str, str] = {}
+    if not CONFIG_FILE.is_file():
+        return out
+    for raw in CONFIG_FILE.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        k, _, v = line.partition("=")
+        out[k.strip()] = v.strip().strip('"').strip("'")
+    return out
+
+
+def _write_file(data: dict[str, str]) -> None:
+    GLOBAL_DIR.mkdir(parents=True, exist_ok=True)
+    lines = [f"{k}={v}" for k, v in sorted(data.items()) if v != ""]
+    body = "\n".join(["# minima-harness config — managed by `minima-harness config`", *lines])
+    # O_CREAT with 0600 so the file is owner-only from the moment it exists.
+    fd = os.open(CONFIG_FILE, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    try:
+        os.write(fd, (body + "\n").encode("utf-8"))
+    finally:
+        os.close(fd)
+    try:  # tighten perms even if the file pre-existed with looser ones
+        os.chmod(CONFIG_FILE, 0o600)
+    except OSError:
+        pass
+
+
+def _file_set(key: str, value: str) -> None:
+    data = _read_file()
+    data[key] = value
+    _write_file(data)
+
+
+def _file_delete(key: str) -> None:
+    data = _read_file()
+    if key in data:
+        del data[key]
+        _write_file(data)
+
+
+# --- public get / set / unset ----------------------------------------------------------
+
+
+def get(key: str) -> str | None:
+    """Read a stored value: keyring first for secrets, then the file."""
+    f = field_for(key)
+    secret = f.secret if f else True
+    if secret:
+        kr = _keyring()
+        if kr is not None:
+            try:
+                val = kr.get_password(KEYRING_SERVICE, key)
+                if val:
+                    return val
+            except Exception:  # noqa: BLE001
+                pass
+    return _read_file().get(key)
+
+
+def set_value(key: str, value: str) -> str:
+    """Persist ``value``. Returns the backend used: ``"keyring"`` or ``"file"``."""
+    f = field_for(key)
+    secret = f.secret if f else True
+    if secret:
+        kr = _keyring()
+        if kr is not None:
+            try:
+                kr.set_password(KEYRING_SERVICE, key, value)
+                _file_delete(key)  # don't leave a stale plaintext copy behind
+                return "keyring"
+            except Exception:  # noqa: BLE001
+                pass
+    _file_set(key, value)
+    return "file"
+
+
+def unset(key: str) -> None:
+    kr = _keyring()
+    if kr is not None:
+        try:
+            kr.delete_password(KEYRING_SERVICE, key)
+        except Exception:  # noqa: BLE001
+            pass
+    _file_delete(key)
+
+
+def location(key: str) -> str:
+    """Where ``key`` is stored: ``"keyring"`` | ``"file"`` | ``"—"`` (unset)."""
+    f = field_for(key)
+    secret = f.secret if f else True
+    if secret:
+        kr = _keyring()
+        if kr is not None:
+            try:
+                if kr.get_password(KEYRING_SERVICE, key):
+                    return "keyring"
+            except Exception:  # noqa: BLE001
+                pass
+    return "file" if key in _read_file() else "—"
+
+
+def hydrate_env() -> None:
+    """Load stored config into ``os.environ`` (setdefault → real env / project files win)."""
+    for f in all_fields():
+        val = get(f.key)
+        if not val:
+            continue
+        os.environ.setdefault(f.key, val)
+        for alias in f.aliases:
+            os.environ.setdefault(alias, val)

minima_harness/tui/context.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from minima_harness.session.format import EntryType
+
+CONTEXT_FILES = ("AGENTS.md", "CLAUDE.md")
+GLOBAL_DIR = Path.home() / ".minima-harness"
+
+BASE_SYSTEM = (
+    "You are an interactive coding agent running in the user's terminal. Use the provided "
+    "tools (read, write, edit, bash, grep, find, ls) to explore and modify the codebase. "
+    "Be concise and direct; explain only when asked."
+)
+
+SUMMARY_SYSTEM = (
+    "You compact a coding-agent conversation. Summarize the work done so far: key decisions, "
+    "file paths touched, current state, and open questions. Be concise. Output only the summary."
+)
+SUMMARY_USER = "Summarize the conversation above for context continuity."
+
+
+def _read(path: Path) -> str | None:
+    try:
+        text = path.read_text(encoding="utf-8")
+        return text.strip() or None
+    except OSError:  # noqa: BLE001
+        return None
+
+
+def load_agents_md(cwd: Path) -> str:
+    """Concatenate AGENTS.md/CLAUDE.md from the global dir + cwd's parent chain (root → cwd)."""
+    chunks: list[str] = []
+    for name in CONTEXT_FILES:
+        g = _read(GLOBAL_DIR / name)
+        if g:
+            chunks.append(f"# ({name}, global)\n{g}")
+
+    parts: list[Path] = []
+    node = cwd.resolve()
+    while True:
+        parts.append(node)
+        if node.parent == node:
+            break
+        node = node.parent
+    for d in reversed(parts):  # rootward first, cwd last
+        for name in CONTEXT_FILES:
+            t = _read(d / name)
+            if t:
+                chunks.append(f"# ({name}, {d.name})\n{t}")
+    return "\n\n".join(chunks)
+
+
+def build_system_prompt_parts(cwd: Path) -> list[tuple[str, str]]:
+    """The local system prompt as labeled parts: always ``("base", ...)``, plus
+    ``("agents.md", ...)`` when project context exists.
+
+    ``build_system_prompt`` joins these into one string; splitting them lets the prompt
+    inspector show the base prompt and project context (AGENTS.md/CLAUDE.md) as distinct
+    layers without duplicating the assembly logic.
+    """
+    replace = _read(cwd / "SYSTEM.md") or _read(GLOBAL_DIR / "SYSTEM.md")
+    append = _read(cwd / "APPEND_SYSTEM.md") or _read(GLOBAL_DIR / "APPEND_SYSTEM.md")
+    base = replace if replace else BASE_SYSTEM
+    if append:
+        base = f"{base}\n\n{append}"
+    parts: list[tuple[str, str]] = [("base", base)]
+    agents = load_agents_md(cwd)
+    if agents:
+        parts.append(("agents.md", agents))
+    return parts
+
+
+def build_system_prompt(cwd: Path) -> str:
+    """Base prompt + AGENTS.md context + SYSTEM.md (replace) / APPEND_SYSTEM.md (append)."""
+    parts = build_system_prompt_parts(cwd)
+    prompt = parts[0][1]
+    for _name, text in parts[1:]:  # only "agents.md" follows base today
+        prompt = f"{prompt}\n\n# Project context\n{text}"
+    return prompt
+
+
+def get_session_override(store) -> str:
+    """Read the most recent session-level system-prompt override (a SYSTEM entry)."""
+    for entry in reversed(store.entries):
+        if entry.type == EntryType.SYSTEM and "override" in entry.payload:
+            return entry.payload.get("override", "")
+    return ""
+
+
+def set_session_override(store, text: str) -> None:
+    """Persist a session-level system-prompt override."""
+    store.append(EntryType.SYSTEM, {"override": text})

minima_harness/tui/customize.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+GLOBAL_DIR = Path.home() / ".minima-harness"
+PACKAGES_DIR = GLOBAL_DIR / "packages"
+
+# Theme palette keys a theme JSON file may set.
+_THEME_KEYS = ("user", "assistant", "tool", "warning", "muted", "accent")
+
+
+def package_roots() -> list[Path]:
+    """Installed package roots (``~/.minima-harness/packages/*/``)."""
+    if not PACKAGES_DIR.is_dir():
+        return []
+    return [d for d in sorted(PACKAGES_DIR.iterdir()) if d.is_dir()]
+
+
+def _theme_dirs(cwd: Path) -> list[Path]:
+    return [GLOBAL_DIR / "themes", cwd / ".pi" / "themes", *(p / "themes" for p in package_roots())]
+
+
+def _prompt_dirs(cwd: Path) -> list[Path]:
+    return [
+        GLOBAL_DIR / "prompts",
+        cwd / ".pi" / "prompts",
+        *(p / "prompts" for p in package_roots()),
+    ]
+
+
+def _skill_dirs(cwd: Path) -> list[Path]:
+    # Agent Skills standard: ~/.agents/skills and .agents/skills (cwd); plus our dirs + packages.
+    return [
+        GLOBAL_DIR / "skills",
+        Path.home() / ".agents" / "skills",
+        cwd / ".agents" / "skills",
+        cwd / ".pi" / "skills",
+        *(p / "skills" for p in package_roots()),
+    ]
+
+
+def load_file_themes(cwd: Path) -> dict[str, dict[str, str]]:
+    """Discover ``*.json`` theme files → {name: palette} (palettes keyed by _THEME_KEYS)."""
+    out: dict[str, dict[str, str]] = {}
+    for base in _theme_dirs(cwd):
+        if not base.is_dir():
+            continue
+        for f in sorted(base.glob("*.json")):
+            try:
+                data = json.loads(f.read_text(encoding="utf-8"))
+            except Exception:  # noqa: BLE001 - one bad file must not break themes
+                continue
+            if isinstance(data, dict):
+                palette = {k: str(v) for k, v in data.items() if k in _THEME_KEYS}
+                if palette:
+                    out[f.stem] = palette
+    return out
+
+
+def load_templates(cwd: Path) -> dict[str, str]:
+    """Discover ``*.md`` prompt templates → {name (stem): body}."""
+    out: dict[str, str] = {}
+    for base in _prompt_dirs(cwd):
+        if not base.is_dir():
+            continue
+        for f in sorted(base.glob("*.md")):
+            try:
+                body = f.read_text(encoding="utf-8").strip()
+            except Exception:  # noqa: BLE001
+                continue
+            if body:
+                out[f.stem] = body
+    return out
+
+
+def load_skills(cwd: Path) -> dict[str, str]:
+    """Discover ``<dir>/<name>/SKILL.md`` skill packages → {name: body}."""
+    out: dict[str, str] = {}
+    for base in _skill_dirs(cwd):
+        if not base.is_dir():
+            continue
+        for d in sorted(base.iterdir()):
+            if not d.is_dir():
+                continue
+            skill = d / "SKILL.md"
+            if d.name in out or not skill.is_file():
+                continue
+            try:
+                body = skill.read_text(encoding="utf-8").strip()
+            except Exception:  # noqa: BLE001
+                continue
+            if body:
+                out[d.name] = body
+    return out

minima_harness/tui/diff.py

@@ -0,0 +1,53 @@
+"""Render a mutating tool call (edit/write) as a unified diff for the approval modal."""
+
+from __future__ import annotations
+
+import difflib
+from pathlib import Path
+from typing import Any
+
+_MAX_LINES = 240
+
+
+def render_tool_diff(tool_name: str, args: Any) -> str:
+    """Unified-diff preview of what an edit/write tool would change. Pure (reads the file)."""
+    if tool_name == "write":
+        return _write_diff(args)
+    if tool_name == "edit":
+        return _edit_diff(args)
+    return f"{tool_name}: {args}"
+
+
+def _read_lines(path: str) -> list[str] | None:
+    try:
+        return Path(path).expanduser().read_text(encoding="utf-8").splitlines()
+    except Exception:  # noqa: BLE001 - missing/binary file -> treat as new
+        return None
+
+
+def _edit_diff(args: Any) -> str:
+    path = getattr(args, "path", "?")
+    old = getattr(args, "old_string", "").splitlines()
+    new = getattr(args, "new_string", "").splitlines()
+    diff = difflib.unified_diff(old, new, fromfile=f"a/{path}", tofile=f"b/{path}", lineterm="")
+    return _truncate("\n".join(diff) or f"edit {path} (no textual change)")
+
+
+def _write_diff(args: Any) -> str:
+    path = getattr(args, "path", "?")
+    new = getattr(args, "content", "").splitlines()
+    current = _read_lines(path)
+    if current is None:
+        body = "\n".join(f"+{line}" for line in new)
+        return _truncate(f"--- /dev/null\n+++ b/{path} (new file)\n{body}")
+    diff = difflib.unified_diff(
+        current, new, fromfile=f"a/{path}", tofile=f"b/{path}", lineterm=""
+    )
+    return _truncate("\n".join(diff) or f"write {path} (no change)")
+
+
+def _truncate(text: str, n: int = _MAX_LINES) -> str:
+    lines = text.splitlines()
+    if len(lines) <= n:
+        return text
+    return "\n".join(lines[:n]) + f"\n… (+{len(lines) - n} more lines)"

minima_harness/tui/editor.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+
+def parse_submission(text: str) -> dict:
+    """Classify raw editor text into a command / bash / message submission."""
+    t = text.strip()
+    if t.startswith("/"):
+        name, _, args = t[1:].partition(" ")
+        return {"kind": "command", "name": name, "args": args.strip()}
+    if t.startswith("!!"):
+        return {"kind": "bash", "command": t[2:], "feed": False}
+    if t.startswith("!"):
+        return {"kind": "bash", "command": t[1:], "feed": True}
+    return {"kind": "message", "text": expand_at_files(t)}
+
+
+def expand_at_files(text: str) -> str:
+    """Inline-expand ``@path`` tokens that point at real files into fenced content."""
+    out: list[str] = []
+    for token in text.split():
+        if token.startswith("@") and len(token) > 1:
+            p = Path(token[1:]).expanduser()
+            if p.is_file():
+                try:
+                    out.append(f'<file path="{p}">\n{p.read_text(encoding="utf-8")}\n</file>')
+                    continue
+                except OSError:  # noqa: BLE001
+                    pass
+        out.append(token)
+    return " ".join(out)
+
+
+async def run_bash(command: str) -> str:
+    proc = await asyncio.create_subprocess_shell(
+        command,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+    )
+    out, _ = await proc.communicate()
+    return out.decode("utf-8", errors="replace")

minima_harness/tui/extensions.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import importlib.util
+import logging
+from collections.abc import Callable
+from pathlib import Path
+
+from minima_harness.tui.commands import Command
+from minima_harness.tui.customize import GLOBAL_DIR, package_roots
+
+_log = logging.getLogger("minima_harness.tui.extensions")
+
+# Extension event-hook keys (the fanout maps AgentEvent types onto these).
+HOOK_KEYS = ("text", "tool_start", "tool_end", "turn", "finish")
+
+
+class ExtensionAPI:
+    """Surface an extension uses to add tools, commands, and event hooks.
+
+    A Python extension is a module in ``~/.minima-harness/extensions/`` (or
+    ``.pi/extensions/``) that defines ``register(api: ExtensionAPI)``.
+    """
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.tools: list = []
+        self.commands: dict[str, Command] = {}
+        self.hooks: dict[str, list[Callable]] = {k: [] for k in HOOK_KEYS}
+
+    def tool(self, tool) -> None:  # noqa: ANN001
+        """Register an :class:`AgentTool`."""
+        self.tools.append(tool)
+
+    def command(self, name: str, *, description: str = "") -> Callable:
+        """Register an async slash-command handler ``async def(app, args) -> str|None``."""
+
+        def deco(fn: Callable) -> Callable:
+            self.commands[name] = Command(name=name, handler=fn, description=description)
+            return fn
+
+        return deco
+
+    def on(self, event_key: str) -> Callable:
+        """Register an event hook (``text``/``tool_start``/``tool_end``/``turn``/``finish``)."""
+
+        def deco(fn: Callable) -> Callable:
+            self.hooks.setdefault(event_key, []).append(fn)
+            return fn
+
+        return deco
+
+
+def load_extensions(cwd: Path) -> list[ExtensionAPI]:
+    """Discover and load Python extension modules from the extensions dirs."""
+    dirs = [
+        GLOBAL_DIR / "extensions",
+        cwd / ".pi" / "extensions",
+        *(p / "extensions" for p in package_roots()),
+    ]
+    apis: list[ExtensionAPI] = []
+    seen: set[str] = set()
+    for base in dirs:
+        if not base.is_dir():
+            continue
+        for f in sorted(base.glob("*.py")):
+            if f.name.startswith("_") or f.stem in seen:
+                continue
+            api = ExtensionAPI(f.stem)
+            try:
+                spec = importlib.util.spec_from_file_location(f"minima_harness_ext.{f.stem}", f)
+                if spec is None or spec.loader is None:
+                    continue
+                mod = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(mod)
+                register = getattr(mod, "register", None)
+                if register is None:
+                    continue
+                register(api)
+            except Exception:  # noqa: BLE001 - one broken extension must not break startup
+                _log.warning("extension_load_failed: %s", f, exc_info=True)
+                continue
+            seen.add(f.stem)
+            apis.append(api)
+    return apis

minima_harness/tui/extra_models.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+
+from minima_harness.ai.types import Model, ModelCost
+from minima_harness.tui.customize import GLOBAL_DIR
+
+_log = logging.getLogger("minima_harness.tui.extra_models")
+
+
+def load_extra_models(cwd: Path) -> list[Model]:
+    """Read ``models.json`` (global + project) → OpenAI-compatible Model list."""
+    out: list[Model] = []
+    for path in (GLOBAL_DIR / "models.json", cwd / ".pi" / "models.json"):
+        if not path.is_file():
+            continue
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except Exception:  # noqa: BLE001
+            continue
+        entries = data.get("models", []) if isinstance(data, dict) else data
+        for m in entries:
+            if not isinstance(m, dict) or "id" not in m:
+                continue
+            try:
+                out.append(
+                    Model(
+                        id=m["id"],
+                        provider=m.get("provider", "openai-compat"),
+                        api="openai-completions",
+                        name=str(m.get("name") or m["id"]),
+                        cost=ModelCost(
+                            input=float(m.get("input_cost", 0.0)),
+                            output=float(m.get("output_cost", 0.0)),
+                        ),
+                        context_window=int(m.get("context_window", 128_000)),
+                        max_tokens=int(m.get("max_tokens", 4096)),
+                        base_url=m.get("base_url"),
+                    )
+                )
+            except Exception:  # noqa: BLE001
+                _log.warning("bad models.json entry: %s", m)
+    return out
+
+
+def register_extra_models(cwd: Path) -> None:
+    from minima_harness.ai import register_model
+
+    for model in load_extra_models(cwd):
+        register_model(model)