@agentikos/omega-os 0.2.0 → 0.19.6

package/omega/Agentik_Engine/tests/test_hermes_and_ua.py

@@ -0,0 +1,387 @@
+"""Tests for the Hermes + Understand-Anything bridges.
+
+Both modules shell out to external binaries we cannot assume are present
+on the test host (``hermes``, ``claude``). We mock subprocess at the
+boundary so we exercise the real arg construction, env injection, error
+handling, and result parsing without ever running the upstream tools.
+
+The Claude credentials read is exercised against a tempfile so we don't
+touch ~/.claude on the dev workstation.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+from pathlib import Path
+from unittest import mock
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+from omega_engine import hermes as H                       # noqa: E402
+from omega_engine import understand_anything as UA          # noqa: E402
+
+
+# ---------------------------------------------------------------------------
+# Helpers — synthesize a realistic ~/.claude/.credentials.json
+# ---------------------------------------------------------------------------
+
+
+def _fake_creds(path: Path, *, token: str = "tk-AAAA-BBBB",
+                expires_at_ms: int | None = None,
+                sub: str = "max") -> Path:
+    payload = {
+        "claudeAiOauth": {
+            "accessToken": token,
+            "refreshToken": "rt-CCCC",
+            "expiresAt": expires_at_ms if expires_at_ms is not None
+                         else int((time.time() + 3600) * 1000),
+            "scopes": ["user:profile", "user:inference"],
+            "subscriptionType": sub,
+        }
+    }
+    path.write_text(json.dumps(payload))
+    return path
+
+
+# ---------------------------------------------------------------------------
+# Hermes — OAuth token plumbing
+# ---------------------------------------------------------------------------
+
+
+class TestClaudeOAuthRead(unittest.TestCase):
+    def test_token_extracted_from_creds_file(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            p = _fake_creds(Path(tmp) / "creds.json", token="tk-LIVE-12345")
+            self.assertEqual(H.claude_oauth_token(p), "tk-LIVE-12345")
+
+    def test_missing_file_raises_friendly_error(self):
+        with self.assertRaises(H.HermesError) as ctx:
+            H.claude_oauth_token(Path("/nope/does/not/exist.json"))
+        self.assertIn("Claude credentials not found", str(ctx.exception))
+
+    def test_malformed_json_raises(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            p = Path(tmp) / "bad.json"
+            p.write_text("{not valid json")
+            with self.assertRaises(H.HermesError) as ctx:
+                H.claude_oauth_token(p)
+            self.assertIn("failed to parse", str(ctx.exception))
+
+    def test_missing_access_token_raises(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            p = Path(tmp) / "empty.json"
+            p.write_text(json.dumps({"claudeAiOauth": {"foo": "bar"}}))
+            with self.assertRaises(H.HermesError) as ctx:
+                H.claude_oauth_token(p)
+            self.assertIn("no claudeAiOauth.accessToken", str(ctx.exception))
+
+    def test_token_expires_at_reads_ms_epoch(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            ts = int((time.time() + 7200) * 1000)
+            p = _fake_creds(Path(tmp) / "c.json", expires_at_ms=ts)
+            self.assertEqual(H.token_expires_at(p), ts)
+
+    def test_subscription_type_reads_string(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            p = _fake_creds(Path(tmp) / "c.json", sub="max")
+            self.assertEqual(H.subscription_type(p), "max")
+
+
+class TestBuildEnv(unittest.TestCase):
+    def test_env_includes_oauth_token_and_defaults(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            p = _fake_creds(Path(tmp) / "c.json", token="tk-Z")
+            env = H.build_env(creds_path=p)
+            self.assertEqual(env["CLAUDE_CODE_OAUTH_TOKEN"], "tk-Z")
+            self.assertEqual(env["HERMES_PROVIDER"], "anthropic")
+            self.assertEqual(env["HERMES_MODEL"], "claude-opus-4-7")
+
+    def test_env_extra_overrides_default(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            p = _fake_creds(Path(tmp) / "c.json")
+            env = H.build_env(creds_path=p,
+                              extra={"HERMES_MODEL": "claude-sonnet-4-7"})
+            self.assertEqual(env["HERMES_MODEL"], "claude-sonnet-4-7")
+
+    def test_env_missing_token_propagates_error(self):
+        with self.assertRaises(H.HermesError):
+            H.build_env(creds_path=Path("/no/such/file"))
+
+
+# ---------------------------------------------------------------------------
+# Hermes — install (mocked subprocess)
+# ---------------------------------------------------------------------------
+
+
+class TestInstall(unittest.TestCase):
+    def test_skip_when_already_installed_and_not_yes(self):
+        with mock.patch("omega_engine.hermes.shutil.which",
+                        return_value="/usr/local/bin/hermes"):
+            res = H.install(yes=False)
+        self.assertTrue(res.ok)
+        self.assertEqual(res.method, "skipped-already-installed")
+
+    def test_dry_run_emits_curl_command(self):
+        with mock.patch("omega_engine.hermes.shutil.which", return_value=None):
+            res = H.install(dry_run=True)
+        self.assertTrue(res.ok)
+        self.assertIn("curl -fsSL", res.detail)
+        self.assertIn("install.sh", res.detail)
+        self.assertIn("--skip-browser", res.detail)
+        self.assertIn("--skip-setup", res.detail)
+
+    def test_install_success_returns_ok(self):
+        completed = subprocess.CompletedProcess(
+            args=["bash", "-c", "..."], returncode=0,
+            stdout="✓ Hermes installed", stderr="",
+        )
+        with mock.patch("omega_engine.hermes.shutil.which", side_effect=[
+                None, "/usr/local/bin/hermes"]):
+            with mock.patch("omega_engine.hermes.subprocess.run",
+                            return_value=completed):
+                res = H.install(yes=False)
+        self.assertTrue(res.ok)
+        self.assertEqual(res.method, "curl-pipe")
+
+    def test_install_failure_propagates_tail(self):
+        completed = subprocess.CompletedProcess(
+            args=["bash", "-c", "..."], returncode=1,
+            stdout="", stderr="error: missing python3",
+        )
+        with mock.patch("omega_engine.hermes.shutil.which", return_value=None):
+            with mock.patch("omega_engine.hermes.subprocess.run",
+                            return_value=completed):
+                res = H.install(yes=False)
+        self.assertFalse(res.ok)
+        self.assertIn("missing python3", res.error)
+
+
+# ---------------------------------------------------------------------------
+# Hermes — link
+# ---------------------------------------------------------------------------
+
+
+class TestLink(unittest.TestCase):
+    def test_link_writes_omega_env_file(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            creds = _fake_creds(Path(tmp) / "c.json", token="tk-LINK")
+            home = Path(tmp) / "hermes_home"
+            with mock.patch.dict(os.environ, {"HERMES_HOME": str(home)}):
+                with mock.patch("omega_engine.hermes._CLAUDE_CREDS", creds):
+                    res = H.link()
+            self.assertTrue(res.ok, res.error)
+            cfg = home / "omega.env"
+            self.assertTrue(cfg.exists())
+            content = cfg.read_text()
+            self.assertIn("HERMES_PROVIDER='anthropic'", content)
+            self.assertIn("HERMES_MODEL='claude-opus-4-7'", content)
+            # Token literal must NOT be in the file — we want the live read.
+            self.assertNotIn("tk-LINK", content)
+            # mode 0600
+            mode = oct(cfg.stat().st_mode)[-3:]
+            self.assertEqual(mode, "600")
+
+    def test_link_dry_run_writes_nothing(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            creds = _fake_creds(Path(tmp) / "c.json")
+            home = Path(tmp) / "hermes_home"
+            with mock.patch.dict(os.environ, {"HERMES_HOME": str(home)}):
+                with mock.patch("omega_engine.hermes._CLAUDE_CREDS", creds):
+                    res = H.link(dry_run=True)
+            self.assertTrue(res.ok)
+            self.assertFalse((home / "omega.env").exists())
+
+    def test_link_returns_friendly_error_without_token(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            missing = Path(tmp) / "absent.json"
+            with mock.patch("omega_engine.hermes._CLAUDE_CREDS", missing):
+                res = H.link()
+            self.assertFalse(res.ok)
+            self.assertIn("Claude credentials", res.error)
+
+
+# ---------------------------------------------------------------------------
+# Hermes — status + ask
+# ---------------------------------------------------------------------------
+
+
+class TestStatus(unittest.TestCase):
+    def test_status_reports_not_installed_when_missing(self):
+        with mock.patch("omega_engine.hermes.shutil.which", return_value=None):
+            with mock.patch("omega_engine.hermes._CLAUDE_CREDS",
+                            Path("/nope")):
+                st = H.status()
+        self.assertFalse(st.installed)
+        self.assertFalse(st.oauth_token_present)
+
+    def test_status_with_token_present_but_no_binary(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            creds = _fake_creds(Path(tmp) / "c.json")
+            with mock.patch("omega_engine.hermes.shutil.which",
+                            return_value=None):
+                with mock.patch("omega_engine.hermes._CLAUDE_CREDS", creds):
+                    st = H.status()
+            self.assertFalse(st.installed)
+            self.assertTrue(st.oauth_token_present)
+            self.assertEqual(st.oauth_subscription, "max")
+
+
+class TestAsk(unittest.TestCase):
+    def test_ask_without_install_raises(self):
+        with mock.patch("omega_engine.hermes.shutil.which", return_value=None):
+            with self.assertRaises(H.HermesError):
+                H.ask("hello")
+
+    def test_ask_invokes_hermes_with_injected_env(self):
+        captured = {}
+
+        def fake_run(cmd, **kw):
+            captured["cmd"] = cmd
+            captured["env"] = kw.get("env", {})
+            return subprocess.CompletedProcess(
+                args=cmd, returncode=0,
+                stdout="hello back", stderr="",
+            )
+
+        with tempfile.TemporaryDirectory() as tmp:
+            creds = _fake_creds(Path(tmp) / "c.json", token="tk-ASK")
+            with mock.patch("omega_engine.hermes.shutil.which",
+                            return_value="/usr/local/bin/hermes"):
+                with mock.patch("omega_engine.hermes._CLAUDE_CREDS", creds):
+                    with mock.patch("omega_engine.hermes.subprocess.run",
+                                    side_effect=fake_run):
+                        rc, out, err = H.ask("hello")
+        self.assertEqual(rc, 0)
+        self.assertEqual(out, "hello back")
+        self.assertEqual(captured["cmd"], ["hermes", "hello"])
+        self.assertEqual(captured["env"]["CLAUDE_CODE_OAUTH_TOKEN"], "tk-ASK")
+        self.assertEqual(captured["env"]["HERMES_PROVIDER"], "anthropic")
+
+    def test_ask_empty_prompt_rejected(self):
+        with mock.patch("omega_engine.hermes.shutil.which",
+                        return_value="/usr/local/bin/hermes"):
+            with self.assertRaises(H.HermesError):
+                H.ask("   ")
+
+
+# ---------------------------------------------------------------------------
+# Understand-Anything — install + run + consume
+# ---------------------------------------------------------------------------
+
+
+class TestUAInstall(unittest.TestCase):
+    def test_install_dry_run(self):
+        with mock.patch("omega_engine.understand_anything.shutil.which",
+                        return_value="/usr/local/bin/claude"):
+            res = UA.install_plugin(dry_run=True)
+        self.assertTrue(res.ok)
+        self.assertIn("/plugin marketplace add Lum1104/Understand-Anything",
+                      res.detail)
+        self.assertIn("/plugin install understand-anything", res.detail)
+
+    def test_install_without_claude_fails(self):
+        with mock.patch("omega_engine.understand_anything.shutil.which",
+                        return_value=None):
+            res = UA.install_plugin()
+        self.assertFalse(res.ok)
+        self.assertIn("not on PATH", res.error)
+
+    def test_install_invokes_claude_p_with_two_slash_commands(self):
+        captured = {}
+
+        def fake_run(cmd, **kw):
+            captured["cmd"] = cmd
+            return subprocess.CompletedProcess(
+                args=cmd, returncode=0,
+                stdout="ok", stderr="",
+            )
+
+        with mock.patch("omega_engine.understand_anything.shutil.which",
+                        return_value="/usr/local/bin/claude"):
+            with mock.patch(
+                "omega_engine.understand_anything.subprocess.run",
+                side_effect=fake_run,
+            ):
+                res = UA.install_plugin()
+        self.assertTrue(res.ok)
+        # We pass the bare command name (PATH resolves it), not the
+        # absolute path returned by shutil.which.
+        self.assertEqual(captured["cmd"][0], "claude")
+        self.assertIn("-p", captured["cmd"])
+        idx = captured["cmd"].index("-p")
+        prompt = captured["cmd"][idx + 1]
+        self.assertIn("/plugin marketplace add", prompt)
+        self.assertIn("/plugin install understand-anything", prompt)
+        self.assertIn("--dangerously-skip-permissions", captured["cmd"])
+
+
+class TestUAConsume(unittest.TestCase):
+    def test_consume_produces_normalized_graph(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            project = Path(tmp) / "myproj"
+            (project / ".understand-anything").mkdir(parents=True)
+            (project / ".understand-anything" / "knowledge-graph.json").write_text(
+                json.dumps({
+                    "nodes": [{"id": "n1"}, {"id": "n2"}, {"id": "n3"}],
+                    "edges": [{"from": "n1", "to": "n2"}],
+                })
+            )
+            home = Path(tmp) / "Omega"
+            info = UA.consume_graph(project, omega_home=home)
+            self.assertEqual(info["nodes"], 3)
+            self.assertEqual(info["edges"], 1)
+            # Written file under Agentik_Runtime/memory/ — check INSIDE
+            # the with-block before tempdir is torn down.
+            out = Path(info["written_to"])
+            self.assertTrue(out.exists())
+            data = json.loads(out.read_text())
+            self.assertEqual(data["format"], "understand-anything")
+            self.assertEqual(len(data["nodes"]), 3)
+
+    def test_consume_missing_graph_raises(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            with self.assertRaises(UA.UnderstandAnythingError):
+                UA.consume_graph(Path(tmp))
+
+    def test_consume_supports_links_alias(self):
+        # Some graphify variants use "links" instead of "edges"
+        with tempfile.TemporaryDirectory() as tmp:
+            project = Path(tmp) / "myproj"
+            (project / ".understand-anything").mkdir(parents=True)
+            (project / ".understand-anything" / "knowledge-graph.json").write_text(
+                json.dumps({
+                    "nodes": [{"id": "a"}],
+                    "links": [{"source": "a", "target": "b"}],
+                })
+            )
+            home = Path(tmp) / "Omega"
+            info = UA.consume_graph(project, omega_home=home)
+        self.assertEqual(info["edges"], 1)
+
+
+class TestUARun(unittest.TestCase):
+    def test_run_requires_existing_project(self):
+        res = UA.run("/nope/no/such/dir")
+        self.assertFalse(res.ok)
+        self.assertIn("not a directory", res.error)
+
+    def test_run_requires_claude_cli(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            with mock.patch(
+                "omega_engine.understand_anything.shutil.which",
+                return_value=None,
+            ):
+                res = UA.run(tmp)
+        self.assertFalse(res.ok)
+        self.assertIn("not on PATH", res.error)
+
+
+if __name__ == "__main__":
+    unittest.main()