@agentikos/omega-os 0.2.0 → 0.19.5

package/bootstrap/lib/llm-clis.py

@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+"""Install + verify the LLM coding CLIs the operator chose.
+
+Called by ``step_llm_clis`` in ``bootstrap/lib/steps.sh``. Reads the
+install manifest's ``llm_clis:`` block (or falls back to the interactive
+whiptail selection from the shell side) and runs the right install
+command for each — npm-global for the JS CLIs, uv-tool for the Python
+ones. Verifies each by spawning ``<cli> --version`` and surfaces a
+human-readable summary.
+
+We CANNOT assume any of these are already on PATH. We DON'T assume that
+the operator wants every CLI. We DO refuse to silently swallow install
+failures — the caller decides whether to abort the install or continue.
+
+Available CLIs:
+
+* ``claude_code``    — Anthropic's official Claude Code CLI
+                        (`npm install -g @anthropic-ai/claude-code`)
+* ``gemini_cli``     — Google's Gemini CLI
+                        (`npm install -g @google/gemini-cli`)
+* ``codex``          — OpenAI's Codex CLI
+                        (`npm install -g @openai/codex`)
+* ``glm_sdk``        — Z.ai / ZhipuAI Python SDK
+                        (`uv tool install zhipuai` — no official CLI)
+* ``aider``          — community Aider chat
+                        (`uv tool install aider-chat`)
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+@dataclass
+class CliSpec:
+    """One installable LLM CLI."""
+    id: str
+    label: str
+    bin_name: str                       # what shows up on PATH after install
+    install_cmd: list[str]
+    version_cmd: list[str] = field(default_factory=list)
+    description: str = ""
+
+    def is_installed(self) -> bool:
+        return shutil.which(self.bin_name) is not None
+
+    def installed_version(self) -> str | None:
+        if not self.is_installed():
+            return None
+        cmd = self.version_cmd or [self.bin_name, "--version"]
+        try:
+            proc = subprocess.run(
+                cmd, check=False, capture_output=True, text=True, timeout=15,
+            )
+        except (OSError, subprocess.SubprocessError):
+            return None
+        out = (proc.stdout or proc.stderr or "").strip()
+        return out.splitlines()[0][:80] if out else "(unknown)"
+
+
+# The catalogue of supported CLIs. Order matters — it's the install /
+# whiptail order. Recommend default = the user can flip them off.
+_CATALOG: list[CliSpec] = [
+    CliSpec(
+        id="claude_code", label="Claude Code (Anthropic)",
+        bin_name="claude",
+        install_cmd=["npm", "install", "-g", "@anthropic-ai/claude-code"],
+        description="Anthropic's official agentic CLI (`claude`)",
+    ),
+    CliSpec(
+        id="gemini_cli", label="Gemini CLI (Google)",
+        bin_name="gemini",
+        install_cmd=["npm", "install", "-g", "@google/gemini-cli"],
+        description="Google's Gemini agentic CLI (`gemini`)",
+    ),
+    CliSpec(
+        id="codex", label="Codex CLI (OpenAI)",
+        bin_name="codex",
+        install_cmd=["npm", "install", "-g", "@openai/codex"],
+        description="OpenAI's Codex coding CLI (`codex`)",
+    ),
+    CliSpec(
+        id="glm_sdk", label="GLM / ZhipuAI Python SDK",
+        bin_name="zhipuai",  # there's no shipped binary; we test importability
+        install_cmd=[],     # filled at runtime — uv tool install / pip
+        version_cmd=["python3", "-c", "import zhipuai; print(zhipuai.__version__)"],
+        description="Z.ai / ZhipuAI GLM Python SDK (no official CLI)",
+    ),
+    CliSpec(
+        id="aider", label="Aider (community)",
+        bin_name="aider",
+        install_cmd=[],     # filled at runtime
+        description="Community aider-chat (`aider`)",
+    ),
+]
+
+
+# ---------------------------------------------------------------------------
+# manifest parsing
+# ---------------------------------------------------------------------------
+
+
+def _selection_from_manifest(manifest_path: str | Path) -> set[str] | None:
+    """Read `llm_clis:` from the manifest. Returns None if absent.
+
+    Supported shapes::
+
+        llm_clis:
+          - claude_code
+          - gemini_cli
+
+        llm_clis:
+          claude_code: true
+          gemini_cli: true
+          codex: false
+    """
+    p = Path(manifest_path)
+    if not p.exists():
+        return None
+    try:
+        data = yaml.safe_load(p.read_text()) or {}
+    except yaml.YAMLError:
+        return None
+    block = data.get("llm_clis")
+    if block is None:
+        return None
+    if isinstance(block, list):
+        return {str(x).strip() for x in block if str(x).strip()}
+    if isinstance(block, dict):
+        return {k for k, v in block.items() if bool(v)}
+    return set()
+
+
+# ---------------------------------------------------------------------------
+# install runners
+# ---------------------------------------------------------------------------
+
+
+def _have(binary: str) -> bool:
+    return shutil.which(binary) is not None
+
+
+def _resolve_install_cmd(spec: CliSpec) -> list[str] | None:
+    """Pick the right install command at runtime when not hardcoded."""
+    if spec.install_cmd:
+        return spec.install_cmd
+    if spec.id == "glm_sdk":
+        # Prefer uv tool, fall back to pip --user.
+        if _have("uv"):
+            return ["uv", "tool", "install", "zhipuai"]
+        if _have("pip"):
+            return ["pip", "install", "--user", "zhipuai"]
+        if _have("pip3"):
+            return ["pip3", "install", "--user", "zhipuai"]
+        return None
+    if spec.id == "aider":
+        if _have("uv"):
+            return ["uv", "tool", "install", "aider-chat"]
+        if _have("pipx"):
+            return ["pipx", "install", "aider-chat"]
+        if _have("pip"):
+            return ["pip", "install", "--user", "aider-chat"]
+        return None
+    return None
+
+
+def install_cli(spec: CliSpec, *, force: bool = False) -> dict[str, Any]:
+    """Install one CLI. Returns a status dict.
+
+    Skips silently if already installed AND not ``force``.
+    """
+    if spec.is_installed() and not force:
+        return {
+            "id": spec.id, "status": "skip",
+            "reason": "already installed",
+            "version": spec.installed_version(),
+        }
+    cmd = _resolve_install_cmd(spec)
+    if cmd is None:
+        return {
+            "id": spec.id, "status": "error",
+            "reason": f"no install command available for {spec.id} "
+            "(missing uv/pipx/pip?)",
+        }
+    if not _have(cmd[0]):
+        return {
+            "id": spec.id, "status": "error",
+            "reason": f"{cmd[0]} not on PATH — install it first",
+        }
+    try:
+        proc = subprocess.run(
+            cmd, check=False, capture_output=True, text=True, timeout=600,
+        )
+    except (OSError, subprocess.SubprocessError) as exc:
+        return {
+            "id": spec.id, "status": "error",
+            "reason": f"install crashed: {exc}"[:300],
+        }
+    if proc.returncode != 0:
+        return {
+            "id": spec.id, "status": "error",
+            "reason": (proc.stderr or proc.stdout or "").strip()[:300],
+        }
+    # Re-check.
+    version = spec.installed_version()
+    if version is None:
+        return {
+            "id": spec.id, "status": "warn",
+            "reason": "installed but `<cli> --version` did not respond — "
+            "may need a shell restart to pick up PATH",
+        }
+    return {"id": spec.id, "status": "ok", "version": version}
+
+
+# ---------------------------------------------------------------------------
+# uninstall — `omega uninstall --include-llm-clis`
+# ---------------------------------------------------------------------------
+
+
+def uninstall_cli(spec: CliSpec) -> dict[str, Any]:
+    """Best-effort uninstall. Returns a status dict."""
+    if not spec.is_installed():
+        return {"id": spec.id, "status": "skip", "reason": "not installed"}
+    install_cmd = _resolve_install_cmd(spec)
+    if install_cmd is None:
+        return {"id": spec.id, "status": "error",
+                "reason": "no install command known — can't reverse"}
+    # Mirror the install command shape: npm/uv/pip/pipx all have an
+    # `uninstall` subcommand at the same position.
+    tool = install_cmd[0]
+    if tool == "npm":
+        cmd = ["npm", "uninstall", "-g", install_cmd[-1]]
+    elif tool == "uv":
+        # `uv tool uninstall <pkg>`
+        cmd = ["uv", "tool", "uninstall", install_cmd[-1]]
+    elif tool == "pipx":
+        cmd = ["pipx", "uninstall", install_cmd[-1]]
+    elif tool == "pip" or tool == "pip3":
+        cmd = [tool, "uninstall", "-y", install_cmd[-1]]
+    else:
+        return {"id": spec.id, "status": "error",
+                "reason": f"unknown tool {tool}"}
+    try:
+        proc = subprocess.run(
+            cmd, check=False, capture_output=True, text=True, timeout=300,
+        )
+    except (OSError, subprocess.SubprocessError) as exc:
+        return {"id": spec.id, "status": "error", "reason": str(exc)[:300]}
+    if proc.returncode != 0:
+        return {"id": spec.id, "status": "error",
+                "reason": (proc.stderr or proc.stdout or "")[:300]}
+    return {"id": spec.id, "status": "ok"}
+
+
+# ---------------------------------------------------------------------------
+# CLI surface used by the shell side
+# ---------------------------------------------------------------------------
+
+
+def _print_summary(results: list[dict[str, Any]]) -> None:
+    by_status = {"ok": [], "skip": [], "warn": [], "error": []}
+    for r in results:
+        by_status.setdefault(r["status"], []).append(r)
+    for r in results:
+        marker = {"ok": "ok", "skip": "--", "warn": "!!", "error": "FAIL"}.get(r["status"], "??")
+        line = f"  [{marker}] {r['id']:<14}"
+        if r.get("version"):
+            line += f"  {r['version'][:60]}"
+        if r.get("reason"):
+            line += f"  ({r['reason'][:80]})"
+        print(line)
+
+
+def _list_known() -> int:
+    print("LLM CLIs OmegaOS can install:")
+    for spec in _CATALOG:
+        installed = "✓" if spec.is_installed() else " "
+        print(f"  [{installed}] {spec.id:<14} {spec.label}")
+        print(f"      {spec.description}")
+    return 0
+
+
+def _install_selection(selection: set[str], *, force: bool) -> int:
+    unknown = selection - {s.id for s in _CATALOG}
+    if unknown:
+        print(f"unknown llm_clis ids: {sorted(unknown)}")
+        return 2
+    results = [
+        install_cli(spec, force=force)
+        for spec in _CATALOG if spec.id in selection
+    ]
+    if not results:
+        print("(no LLM CLIs selected — skipping)")
+        return 0
+    _print_summary(results)
+    return 0 if all(r["status"] in ("ok", "skip", "warn") for r in results) else 1
+
+
+def main(argv: list[str]) -> int:
+    if len(argv) < 2:
+        print("usage: llm-clis.py <list|install|uninstall> [args...]")
+        return 2
+    cmd = argv[1]
+    if cmd == "list":
+        return _list_known()
+    if cmd == "install":
+        # Two paths: manifest selection OR explicit ids.
+        if len(argv) >= 3 and Path(argv[2]).exists():
+            selection = _selection_from_manifest(argv[2])
+            if selection is None:
+                print("manifest has no `llm_clis:` block — skipping")
+                return 0
+        else:
+            selection = set(argv[2:])
+        force = "--force" in selection
+        selection.discard("--force")
+        return _install_selection(selection, force=force)
+    if cmd == "uninstall":
+        ids = set(argv[2:])
+        unknown = ids - {s.id for s in _CATALOG}
+        if unknown:
+            print(f"unknown ids: {sorted(unknown)}")
+            return 2
+        results = [
+            uninstall_cli(spec) for spec in _CATALOG if spec.id in ids
+        ]
+        _print_summary(results)
+        return 0
+    print(f"unknown llm-clis subcommand: {cmd}")
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))