@agentikos/omega-os 0.2.0 → 0.19.6

package/omega/Agentik_Engine/omega_engine/understand_anything.py

@@ -0,0 +1,275 @@
+"""Understand-Anything bridge — register the Claude Code plugin + consume its graph.
+
+Understand-Anything is a popular Claude Code plugin (27k+ stars) that
+analyses a codebase with a multi-agent pipeline and produces an
+interactive knowledge graph at
+``.understand-anything/knowledge-graph.json``.
+
+It overlaps with OmegaOS's existing graphify integration, but the output
+shape is different (it's much richer — file/function/class/dependency
+nodes, business-domain layer, persona-adaptive views, language-concept
+overlays).
+
+This bridge gives operators a one-command path to:
+
+  1. Install the plugin into Claude Code via the marketplace (uses the
+     same OAuth as everything else — no API key, no separate auth).
+  2. After ``/understand`` runs in Claude Code, consume the resulting
+     ``.understand-anything/knowledge-graph.json`` into OmegaOS's
+     ``GraphRetriever`` (same path we use for graphify) so Oracle /
+     workers can answer "where in the code is X?" via Graph RAG.
+
+What this module does NOT do
+----------------------------
+
+  * Run the analysis pipeline itself — that's Claude Code's job via the
+    plugin. We trigger it (``/understand``) and consume the artefact.
+  * Replace graphify — both can coexist; ``omega graph`` already
+    consumes whichever JSON the operator points at.
+"""
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+_PLUGIN_MARKETPLACE = "Lum1104/Understand-Anything"
+_PLUGIN_NAME = "understand-anything"
+_OUTPUT_FILE = "knowledge-graph.json"
+_OUTPUT_DIR = ".understand-anything"
+
+
+# ---------------------------------------------------------------------------
+# Errors
+# ---------------------------------------------------------------------------
+
+
+class UnderstandAnythingError(RuntimeError):
+    pass
+
+
+# ---------------------------------------------------------------------------
+# Plugin install (via `claude` CLI's plugin system)
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class InstallResult:
+    ok: bool
+    method: str
+    detail: str = ""
+    error: str = ""
+
+
+def is_plugin_installed(home_claude: str | Path | None = None) -> bool:
+    """True iff the plugin dir already exists under ~/.claude/plugins/."""
+    base = Path(home_claude) if home_claude else Path.home() / ".claude"
+    # Claude Code stores marketplaces under plugins/marketplaces/<owner>-<repo>/
+    p = base / "plugins" / "marketplaces"
+    if not p.is_dir():
+        return False
+    # Best-effort match — different versions of Claude Code use slightly
+    # different dir naming conventions.
+    for child in p.iterdir():
+        n = child.name.lower()
+        if "understand-anything" in n or "lum1104" in n:
+            return True
+    return False
+
+
+def install_plugin(
+    *,
+    claude_cmd: str = "claude",
+    timeout_s: int = 120,
+    dry_run: bool = False,
+) -> InstallResult:
+    """Install the Understand-Anything plugin into Claude Code.
+
+    Mirrors the upstream instructions::
+
+        /plugin marketplace add Lum1104/Understand-Anything
+        /plugin install understand-anything
+
+    We invoke them via ``claude -p`` so the existing Max OAuth is the
+    auth — no API key, no marketplace login.
+    """
+    if shutil.which(claude_cmd) is None:
+        return InstallResult(
+            ok=False, method="skip",
+            error=f"`{claude_cmd}` not on PATH — install Claude Code first",
+        )
+    if dry_run:
+        return InstallResult(
+            ok=True, method="dry-run",
+            detail=(
+                f"would run: {claude_cmd} -p "
+                f"'/plugin marketplace add {_PLUGIN_MARKETPLACE} && "
+                f"/plugin install {_PLUGIN_NAME}'"
+            ),
+        )
+    # Two slash commands, one session.
+    prompt = (
+        f"/plugin marketplace add {_PLUGIN_MARKETPLACE}\n"
+        f"/plugin install {_PLUGIN_NAME}"
+    )
+    try:
+        proc = subprocess.run(
+            [claude_cmd, "-p", prompt, "--dangerously-skip-permissions"],
+            check=False, capture_output=True, text=True, timeout=timeout_s,
+        )
+    except subprocess.TimeoutExpired:
+        return InstallResult(
+            ok=False, method="claude-p",
+            error=f"`claude -p` timed out after {timeout_s}s",
+        )
+    if proc.returncode != 0:
+        tail = (proc.stdout + "\n" + proc.stderr).strip()[-400:]
+        return InstallResult(
+            ok=False, method="claude-p",
+            error=f"claude exited {proc.returncode}\n{tail}",
+        )
+    return InstallResult(
+        ok=True, method="claude-p",
+        detail=f"installed {_PLUGIN_NAME} from {_PLUGIN_MARKETPLACE}",
+    )
+
+
+# ---------------------------------------------------------------------------
+# Trigger an analysis run + consume the output
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class RunResult:
+    ok: bool
+    output_path: str = ""
+    nodes: int = 0
+    edges: int = 0
+    error: str = ""
+    elapsed_s: float = 0.0
+
+
+def run(
+    project_path: str | Path,
+    *,
+    claude_cmd: str = "claude",
+    language: str | None = None,
+    timeout_s: int = 1800,
+) -> RunResult:
+    """Trigger ``/understand`` in the given project directory.
+
+    Returns a RunResult pointing at the produced
+    ``.understand-anything/knowledge-graph.json`` and a node/edge count.
+    """
+    start = time.time()
+    project = Path(project_path).resolve()
+    if not project.is_dir():
+        return RunResult(ok=False, error=f"not a directory: {project}")
+    if shutil.which(claude_cmd) is None:
+        return RunResult(
+            ok=False,
+            error=f"`{claude_cmd}` not on PATH — install Claude Code first",
+        )
+    prompt = "/understand"
+    if language:
+        prompt += f" --language {language}"
+    try:
+        proc = subprocess.run(
+            [claude_cmd, "-p", prompt, "--add-dir", str(project),
+             "--dangerously-skip-permissions"],
+            check=False, capture_output=True, text=True, timeout=timeout_s,
+            cwd=str(project),
+        )
+    except subprocess.TimeoutExpired:
+        return RunResult(
+            ok=False, elapsed_s=round(time.time() - start, 2),
+            error=f"claude -p /understand timed out after {timeout_s}s",
+        )
+    if proc.returncode != 0:
+        tail = (proc.stdout + "\n" + proc.stderr).strip()[-400:]
+        return RunResult(
+            ok=False, elapsed_s=round(time.time() - start, 2),
+            error=f"claude exited {proc.returncode}\n{tail}",
+        )
+    out = project / _OUTPUT_DIR / _OUTPUT_FILE
+    if not out.exists():
+        return RunResult(
+            ok=False, elapsed_s=round(time.time() - start, 2),
+            error=f"expected output not found at {out}",
+        )
+    nodes, edges = _count_graph(out)
+    return RunResult(
+        ok=True, output_path=str(out),
+        nodes=nodes, edges=edges,
+        elapsed_s=round(time.time() - start, 2),
+    )
+
+
+def _count_graph(path: Path) -> tuple[int, int]:
+    try:
+        data = json.loads(path.read_text())
+    except (OSError, json.JSONDecodeError):
+        return 0, 0
+    if not isinstance(data, dict):
+        return 0, 0
+    n = len(data.get("nodes") or [])
+    e = len(data.get("edges") or data.get("links") or [])
+    return n, e
+
+
+# ---------------------------------------------------------------------------
+# Consume the produced graph into GraphRetriever
+# ---------------------------------------------------------------------------
+
+
+def consume_graph(
+    project_path: str | Path,
+    *,
+    omega_home: str | Path | None = None,
+) -> dict[str, Any]:
+    """Merge the knowledge-graph.json into OmegaOS's GraphRetriever.
+
+    Format adapter: Understand-Anything emits ``{nodes: [{id, type, …}],
+    edges: [{from, to, kind, …}]}``; we map that onto the engine's
+    ``GraphRetriever`` interface (which already powers the graphify
+    consumer at ``omega graph <path>``).
+
+    Returns ``{nodes, edges, written_to}``.
+    """
+    import os as _os
+    project = Path(project_path).resolve()
+    out = project / _OUTPUT_DIR / _OUTPUT_FILE
+    if not out.exists():
+        raise UnderstandAnythingError(
+            f"no graph at {out} — run `omega ua run {project}` first"
+        )
+    try:
+        data = json.loads(out.read_text())
+    except (OSError, json.JSONDecodeError) as exc:
+        raise UnderstandAnythingError(f"unreadable graph at {out}: {exc}") from exc
+
+    nodes = data.get("nodes") or []
+    edges = data.get("edges") or data.get("links") or []
+
+    # Project into the engine's memory dir.
+    home = Path(omega_home or _os.environ.get(
+        "OMEGA_HOME", str(Path.home() / "Omega")
+    ))
+    mem = home / "Agentik_Runtime" / "memory"
+    mem.mkdir(parents=True, exist_ok=True)
+    dest = mem / "understand-anything.graph.json"
+    # Normalised shape — same as graphify's output, so GraphRetriever
+    # can consume it via the existing ``omega graph`` pipeline.
+    normalised = {
+        "format": "understand-anything",
+        "source_project": str(project),
+        "nodes": nodes,
+        "edges": edges,
+    }
+    dest.write_text(json.dumps(normalised, indent=2))
+    return {"nodes": len(nodes), "edges": len(edges), "written_to": str(dest)}

package/omega/Agentik_Engine/omega_engine/updater.py

@@ -0,0 +1,70 @@
+"""Update checker — is a newer @agentikos/omega-os out?
+
+Queries the npm registry for the latest published version, compares
+against the running version. Pure-stdlib HTTP (no requests).
+
+CLI surface:
+
+  * ``omega update --check``    — print current + latest, exit 0
+  * ``omega update --apply``    — re-run install.sh --force (delegates
+                                   to ``omega upgrade`` which already
+                                   handles that path)
+"""
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+
+
+_REGISTRY = "https://registry.npmjs.org/@agentikos%2Fomega-os"
+
+
+@dataclass
+class UpdateInfo:
+    current: str
+    latest: str
+    is_outdated: bool
+    error: str = ""
+
+
+def _parse_semver(v: str) -> tuple[int, int, int]:
+    """Best-effort semver parse. Non-numeric components → 0."""
+    parts = v.split("-")[0].split(".")[:3]
+    out: list[int] = []
+    for p in parts:
+        try:
+            out.append(int(p))
+        except ValueError:
+            out.append(0)
+    while len(out) < 3:
+        out.append(0)
+    return out[0], out[1], out[2]
+
+
+def check_for_updates(current: str, *, timeout: int = 10) -> UpdateInfo:
+    """Compare ``current`` against the npm registry."""
+    try:
+        req = urllib.request.Request(
+            _REGISTRY,
+            headers={"Accept": "application/json"},
+        )
+        with urllib.request.urlopen(req, timeout=timeout) as resp:  # noqa: S310
+            data = json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        return UpdateInfo(
+            current=current, latest="?", is_outdated=False,
+            error=f"HTTP {exc.code}: {exc.reason}",
+        )
+    except Exception as exc:  # noqa: BLE001
+        return UpdateInfo(
+            current=current, latest="?", is_outdated=False,
+            error=f"network: {exc}"[:200],
+        )
+
+    latest = (data.get("dist-tags") or {}).get("latest", "?")
+    return UpdateInfo(
+        current=current, latest=latest,
+        is_outdated=_parse_semver(current) < _parse_semver(latest),
+    )

package/omega/Agentik_Engine/omega_engine/validate.py

@@ -0,0 +1,186 @@
+"""Validate provider credentials at install time + on demand.
+
+The install used to write provider config + credentials to the vault and
+then say "ok". The first mission would discover the key was wrong/expired
+and fail. This module closes the gap: ``omega validate providers`` does a
+1-token round-trip against each configured provider's real API.
+
+For each provider we know how to validate:
+
+  * **claude**     ``/v1/messages`` with max_tokens=1
+  * **glm**        ``/api/paas/v4/chat/completions`` with max_tokens=1
+  * **openai**     ``/v1/chat/completions`` with max_tokens=1
+  * **deepseek**   ``/v1/chat/completions`` with max_tokens=1
+
+Each provider's adapter already knows its endpoint + auth shape — we
+reuse it. A 200 OK is a pass; anything else is a fail with the API's
+error string surfaced.
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+@dataclass
+class ValidationResult:
+    provider: str
+    ok: bool
+    detail: str
+    elapsed_ms: int = 0
+
+
+def _read_router_config(omega_home: str | Path) -> list[dict[str, Any]]:
+    p = (Path(omega_home) / "Agentik_SSOT" / "providers" / "router.yaml")
+    if not p.exists():
+        return []
+    data = yaml.safe_load(p.read_text()) or {}
+    return list(data.get("providers") or [])
+
+
+def _read_secret(omega_home: str | Path, secret_ref: str) -> str:
+    if not secret_ref:
+        return ""
+    if env := os.environ.get(secret_ref):
+        return env
+    try:
+        from omega_engine.vault import vault_read
+        return vault_read(omega_home, secret_ref) or ""
+    except Exception:  # noqa: BLE001
+        return ""
+
+
+def _validate_claude(api_key: str) -> ValidationResult:
+    """1-token call against Anthropic /v1/messages."""
+    if not api_key:
+        return ValidationResult("claude", False, "no API key in env or vault")
+    import json
+    import time
+    import urllib.error
+    import urllib.request
+    start = time.time()
+    body = json.dumps({
+        "model": "claude-haiku-4-5",
+        "max_tokens": 1,
+        "messages": [{"role": "user", "content": "x"}],
+    }).encode()
+    req = urllib.request.Request(
+        "https://api.anthropic.com/v1/messages",
+        data=body, method="POST",
+        headers={
+            "Content-Type": "application/json",
+            "x-api-key": api_key,
+            "anthropic-version": "2023-06-01",
+        },
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:  # noqa: S310
+            resp.read()
+        return ValidationResult(
+            "claude", True, "ok", int((time.time() - start) * 1000),
+        )
+    except urllib.error.HTTPError as exc:
+        detail = exc.read().decode("utf-8", errors="replace")[:300] if exc.fp else ""
+        return ValidationResult(
+            "claude", False, f"HTTP {exc.code}: {detail or exc.reason}",
+            int((time.time() - start) * 1000),
+        )
+    except Exception as exc:  # noqa: BLE001
+        return ValidationResult(
+            "claude", False, f"network error: {exc}"[:200],
+            int((time.time() - start) * 1000),
+        )
+
+
+def _validate_openai_compat(
+    provider: str, api_key: str, base_url: str, model: str,
+) -> ValidationResult:
+    """1-token call against any OpenAI-compatible /chat/completions."""
+    if not api_key:
+        return ValidationResult(provider, False, "no API key in env or vault")
+    import json
+    import time
+    import urllib.error
+    import urllib.request
+    start = time.time()
+    body = json.dumps({
+        "model": model,
+        "max_tokens": 1,
+        "messages": [{"role": "user", "content": "x"}],
+    }).encode()
+    req = urllib.request.Request(
+        f"{base_url.rstrip('/')}/chat/completions",
+        data=body, method="POST",
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}",
+        },
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:  # noqa: S310
+            resp.read()
+        return ValidationResult(
+            provider, True, "ok", int((time.time() - start) * 1000),
+        )
+    except urllib.error.HTTPError as exc:
+        detail = exc.read().decode("utf-8", errors="replace")[:300] if exc.fp else ""
+        return ValidationResult(
+            provider, False, f"HTTP {exc.code}: {detail or exc.reason}",
+            int((time.time() - start) * 1000),
+        )
+    except Exception as exc:  # noqa: BLE001
+        return ValidationResult(
+            provider, False, f"network error: {exc}"[:200],
+            int((time.time() - start) * 1000),
+        )
+
+
+def validate_one(
+    omega_home: str | Path, provider_id: str,
+    *, secret_ref: str | None = None,
+) -> ValidationResult:
+    """Validate one provider by id. Reads secret from env or vault."""
+    secret_ref = (
+        secret_ref or f"{provider_id.upper()}_API_KEY"
+    )
+    key = _read_secret(omega_home, secret_ref)
+    pid = provider_id.lower()
+    if pid == "claude":
+        return _validate_claude(key)
+    if pid == "glm":
+        return _validate_openai_compat(
+            "glm", key,
+            "https://open.bigmodel.cn/api/paas/v4",
+            "glm-4-flash",
+        )
+    if pid == "openai":
+        return _validate_openai_compat(
+            "openai", key, "https://api.openai.com/v1", "gpt-4o-mini",
+        )
+    if pid == "deepseek":
+        return _validate_openai_compat(
+            "deepseek", key, "https://api.deepseek.com/v1", "deepseek-chat",
+        )
+    return ValidationResult(
+        provider_id, False,
+        f"no validator known for provider {provider_id!r}",
+    )
+
+
+def validate_all(omega_home: str | Path) -> list[ValidationResult]:
+    """Validate every provider in ``router.yaml``."""
+    out: list[ValidationResult] = []
+    for cfg in _read_router_config(omega_home):
+        if not bool(cfg.get("enabled", True)):
+            continue
+        pid = str(cfg.get("id", "")).strip()
+        if not pid:
+            continue
+        out.append(validate_one(
+            omega_home, pid, secret_ref=cfg.get("secret_ref"),
+        ))
+    return out