@agentikos/omega-os 0.2.0 → 0.19.6

package/omega/Agentik_Engine/tests/test_graphify.py

@@ -0,0 +1,190 @@
+"""Tests for the graphify integration.
+
+Reality check: `graphify` is a Claude Code SKILL. The CLI (`graphifyy` on
+PyPI) only manages the skill (`install`, `uninstall`) and queries an
+existing graph (`path`, `explain`, `diagnose`). The graph itself is built
+inside Claude Code by typing `/graphify .`.
+
+So this test suite verifies:
+
+  1. `is_graphify_installed()` correctly reflects PATH state.
+  2. `graphify_install_skill()` calls the CLI with `install --platform <p>`
+     and surfaces failures.
+  3. `graphify_load_graph(target)` reads an existing
+     `<target>/graphify-out/graph.json` and parses nodes/edges/summary.
+  4. Missing graph.json raises the dedicated `GraphifyGraphMissing` error
+     with a helpful message.
+  5. `graphify_into_rag(report, GraphRetriever)` merges into a real
+     retriever and the merged nodes are queryable.
+"""
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))  # Agentik_Engine/
+
+from omega_engine.integrations import (  # noqa: E402
+    GraphifyError,
+    GraphifyGraphMissing,
+    GraphifyNotInstalled,
+    GraphifyReport,
+    graphify_install_skill,
+    graphify_into_rag,
+    graphify_load_graph,
+    is_graphify_installed,
+)
+from omega_engine.rag import GraphRetriever  # noqa: E402
+
+
+def _write_graph(dir: Path, payload: dict) -> Path:
+    out = dir / "graphify-out"
+    out.mkdir(parents=True, exist_ok=True)
+    p = out / "graph.json"
+    p.write_text(json.dumps(payload))
+    return p
+
+
+class TestGraphifyDetection(unittest.TestCase):
+    def test_not_installed_returns_false(self):
+        with mock.patch("shutil.which", return_value=None):
+            self.assertFalse(is_graphify_installed())
+
+    def test_install_skill_raises_when_not_installed(self):
+        with mock.patch("shutil.which", return_value=None):
+            with self.assertRaises(GraphifyNotInstalled):
+                graphify_install_skill()
+
+
+class TestGraphifyInstallSkill(unittest.TestCase):
+    def test_install_invokes_graphify_install_with_platform(self):
+        captured = {}
+
+        def _run(argv, *args, **kwargs):
+            captured["argv"] = list(argv)
+            return subprocess.CompletedProcess(
+                argv, returncode=0,
+                stdout="installed skill at ~/.claude/skills/graphify/",
+                stderr="",
+            )
+
+        with mock.patch("shutil.which", return_value="/fake/graphify"), \
+             mock.patch(
+                 "omega_engine.integrations.graphify.subprocess.run",
+                 side_effect=_run,
+             ):
+            result = graphify_install_skill(platform="claude")
+
+        self.assertEqual(captured["argv"][0], "graphify")
+        self.assertEqual(captured["argv"][1], "install")
+        self.assertIn("--platform", captured["argv"])
+        self.assertIn("claude", captured["argv"])
+        self.assertEqual(result["platform"], "claude")
+        self.assertIn("installed skill", result["stdout"])
+
+    def test_install_failure_raises(self):
+        with mock.patch("shutil.which", return_value="/fake/graphify"), \
+             mock.patch(
+                 "omega_engine.integrations.graphify.subprocess.run",
+                 return_value=subprocess.CompletedProcess(
+                     ["graphify"], returncode=2, stdout="", stderr="nope",
+                 ),
+             ):
+            with self.assertRaises(GraphifyError) as ctx:
+                graphify_install_skill()
+        self.assertIn("nope", str(ctx.exception))
+
+
+class TestGraphifyLoadGraph(unittest.TestCase):
+    def test_loads_existing_graph_json(self):
+        payload = {
+            "version": "1.0",
+            "mode": "deep",
+            "nodes": [
+                {"id": "auth.py", "kind": "module"},
+                {"id": "login", "kind": "function"},
+            ],
+            "edges": [
+                {"source": "auth.py", "target": "login", "kind": "defines"},
+            ],
+        }
+        with tempfile.TemporaryDirectory() as td:
+            repo = Path(td) / "repo"
+            repo.mkdir()
+            _write_graph(repo, payload)
+
+            report = graphify_load_graph(repo)
+
+            self.assertIsInstance(report, GraphifyReport)
+            self.assertEqual(len(report.nodes), 2)
+            self.assertEqual(len(report.edges), 1)
+            self.assertEqual(report.summary.get("version"), "1.0")
+            self.assertEqual(report.summary.get("mode"), "deep")
+            self.assertTrue(report.json_path.exists())
+
+    def test_missing_graph_raises_friendly_error(self):
+        with tempfile.TemporaryDirectory() as td:
+            repo = Path(td) / "repo"
+            repo.mkdir()
+            with self.assertRaises(GraphifyGraphMissing) as ctx:
+                graphify_load_graph(repo)
+        msg = str(ctx.exception)
+        self.assertIn("graph.json", msg)
+        self.assertIn("/graphify", msg)
+
+    def test_custom_json_path_overrides_default(self):
+        with tempfile.TemporaryDirectory() as td:
+            custom = Path(td) / "weird-location" / "g.json"
+            custom.parent.mkdir(parents=True)
+            custom.write_text(json.dumps({"nodes": [], "edges": []}))
+
+            report = graphify_load_graph("/does/not/exist", json_path=custom)
+        self.assertEqual(report.json_path, custom)
+
+    def test_unparsable_json_raises(self):
+        with tempfile.TemporaryDirectory() as td:
+            repo = Path(td) / "repo"
+            repo.mkdir()
+            out = repo / "graphify-out"
+            out.mkdir()
+            (out / "graph.json").write_text("{not valid json")
+            with self.assertRaises(GraphifyError):
+                graphify_load_graph(repo)
+
+
+class TestGraphifyIntoRag(unittest.TestCase):
+    def test_merges_into_graph_retriever(self):
+        report = GraphifyReport(
+            output_dir=Path("/tmp/unused"),
+            nodes=[
+                {"id": "auth.py", "name": "auth.py", "kind": "module"},
+                {"id": "login", "name": "login", "kind": "function"},
+                {"id": "session", "name": "session", "kind": "class"},
+                {"name": "bare_name"},  # only `name` — falls back to that
+            ],
+            edges=[
+                {"source": "auth.py", "target": "login", "kind": "defines"},
+                {"source": "login", "target": "session", "kind": "uses"},
+                {"target": "session"},  # malformed — should be dropped
+            ],
+        )
+        with tempfile.TemporaryDirectory() as td:
+            graph = GraphRetriever(json_path=Path(td) / "g.json")
+            counts = graphify_into_rag(report, graph)
+
+        self.assertEqual(counts["nodes"], 4)
+        self.assertEqual(counts["edges"], 2)  # malformed edge dropped
+        node_set = set(graph.nodes())
+        self.assertIn("login", node_set)
+        self.assertIn("session", node_set)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/omega/Agentik_Engine/tests/test_handoff.py

@@ -0,0 +1,311 @@
+"""Tests for omega_engine.handoff — 5-section session-end memo.
+
+Covers: dataclass round-trip (json + markdown), atomic write, project +
+task target resolution, archive accumulation, from_done_signal draft.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+from pathlib import Path
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+from omega_engine import handoff as H               # noqa: E402
+from omega_engine.done_signal import DoneSignal, write_done  # noqa: E402
+from omega_engine.worker import WorkerBrief, write_brief     # noqa: E402
+
+
+def _fresh_handoff() -> H.Handoff:
+    return H.Handoff(
+        mission="Implement OAuth login + green tests/auth.test.ts",
+        state=(
+            "- Works: sign-in redirects to /dashboard, screenshot at "
+            "audits/.flow/auth.png\n"
+            "- Broken: /api/profile PATCH returns 500 — TypeError line 142\n"
+            "- Verified by: `npm test -- tests/auth.test.ts`"
+        ),
+        files_touched=[
+            "apps/web/src/routes/api/auth/google.ts",
+            "apps/web/src/components/SignInForm.tsx:42-78",
+            "tests/auth.test.ts",
+        ],
+        dead_ends=[
+            "Tried Authorization header for /userinfo — got 401. Don't.",
+            "Tried next-auth v5 beta — incompatible with Next 14. Don't.",
+        ],
+        next_steps=[
+            "Add NEXTAUTH_SECRET to .env.local",
+            "Wire the new endpoint into [...nextauth]/route.ts",
+            "Re-run `npm test -- tests/auth.test.ts`",
+        ],
+        author="worker:t-oauth-123",
+        project="myapp",
+        task_id="t-oauth-123",
+        mission_id="m-oauth",
+    )
+
+
+# ---------------------------------------------------------------------------
+# Dataclass round-trips
+# ---------------------------------------------------------------------------
+
+
+class TestRoundTrip(unittest.TestCase):
+    def test_to_json_and_back(self):
+        ho = _fresh_handoff()
+        loaded = H.Handoff.from_dict(json.loads(ho.to_json()))
+        self.assertEqual(loaded.mission, ho.mission)
+        self.assertEqual(loaded.files_touched, ho.files_touched)
+        self.assertEqual(loaded.dead_ends, ho.dead_ends)
+        self.assertEqual(loaded.next_steps, ho.next_steps)
+        self.assertEqual(loaded.project, ho.project)
+
+    def test_markdown_has_five_sections(self):
+        md = _fresh_handoff().to_markdown()
+        for n in range(1, 6):
+            self.assertIn(f"## {n}.", md, f"missing section {n}")
+
+    def test_markdown_parse_back(self):
+        ho = _fresh_handoff()
+        md = ho.to_markdown()
+        parsed = H.Handoff.from_markdown(md)
+        self.assertEqual(parsed.mission, ho.mission)
+        self.assertEqual(parsed.files_touched, ho.files_touched)
+        self.assertEqual(parsed.dead_ends, ho.dead_ends)
+        self.assertEqual(parsed.next_steps, ho.next_steps)
+
+    def test_empty_sections_round_trip(self):
+        ho = H.Handoff(
+            mission="quick fix",
+            state="",
+            files_touched=[],
+            dead_ends=[],
+            next_steps=[],
+            project="x",
+        )
+        md = ho.to_markdown()
+        parsed = H.Handoff.from_markdown(md)
+        self.assertEqual(parsed.files_touched, [])
+        self.assertEqual(parsed.dead_ends, [])
+        self.assertEqual(parsed.next_steps, [])
+
+
+# ---------------------------------------------------------------------------
+# write_handoff — project / task / both targets
+# ---------------------------------------------------------------------------
+
+
+class TestWriteHandoff(unittest.TestCase):
+    def test_project_target_writes_latest_and_archive(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            ho = _fresh_handoff()
+            res = H.write_handoff(home, ho, target="project")
+            self.assertEqual(len(res["written"]), 2)
+            latest = H.project_latest_path(home, "myapp")
+            self.assertTrue(latest.exists())
+            self.assertIn("## 1. Mission", latest.read_text())
+            # Archive copy
+            archive_dir = H.project_handoff_dir(home, "myapp")
+            archived = list(archive_dir.glob("*.md"))
+            self.assertEqual(len(archived), 1)
+
+    def test_task_target_writes_session_dir(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            ho = _fresh_handoff()
+            res = H.write_handoff(home, ho, target="task")
+            self.assertEqual(len(res["written"]), 1)
+            p = H.task_handoff_path(home, "t-oauth-123")
+            self.assertTrue(p.exists())
+            self.assertIn("Mission", p.read_text())
+
+    def test_both_target_writes_three_paths(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            ho = _fresh_handoff()
+            res = H.write_handoff(home, ho, target="both")
+            self.assertEqual(len(res["written"]), 3)
+            self.assertTrue(H.project_latest_path(home, "myapp").exists())
+            self.assertTrue(H.task_handoff_path(home, "t-oauth-123").exists())
+
+    def test_project_target_requires_project(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            ho = H.Handoff(mission="x", state="", files_touched=[],
+                           dead_ends=[], next_steps=[])
+            with self.assertRaises(ValueError):
+                H.write_handoff(home, ho, target="project")
+
+    def test_task_target_requires_task_id(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            ho = H.Handoff(mission="x", state="", files_touched=[],
+                           dead_ends=[], next_steps=[], project="x")
+            with self.assertRaises(ValueError):
+                H.write_handoff(home, ho, target="task")
+
+    def test_archive_accumulates_across_writes(self):
+        """Each write_handoff adds a new archive file; latest is overwritten."""
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            ho1 = _fresh_handoff()
+            ho1.created_at = "2026-05-23T10:00:00+00:00"
+            H.write_handoff(home, ho1, target="project")
+            ho2 = _fresh_handoff()
+            ho2.created_at = "2026-05-23T11:00:00+00:00"
+            ho2.mission = "Second pass on the auth bug"
+            H.write_handoff(home, ho2, target="project")
+            archived = sorted(H.project_handoff_dir(home, "myapp").glob("*.md"))
+            self.assertEqual(len(archived), 2)
+            # Latest has the most recent content
+            latest_text = H.project_latest_path(home, "myapp").read_text()
+            self.assertIn("Second pass", latest_text)
+
+
+# ---------------------------------------------------------------------------
+# read_handoff + list_handoffs
+# ---------------------------------------------------------------------------
+
+
+class TestReadAndList(unittest.TestCase):
+    def test_read_returns_none_when_missing(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            self.assertIsNone(H.read_handoff(Path(tmp), project="nope"))
+            self.assertIsNone(H.read_handoff(Path(tmp), task_id="nope"))
+
+    def test_read_project_after_write(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            ho = _fresh_handoff()
+            H.write_handoff(home, ho, target="project")
+            loaded = H.read_handoff(home, project="myapp")
+            self.assertIsNotNone(loaded)
+            self.assertEqual(loaded.mission, ho.mission)
+            self.assertEqual(loaded.files_touched, ho.files_touched)
+
+    def test_list_chronological_newest_first(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            for ts, mission in [
+                ("2026-05-23T10:00:00+00:00", "older mission"),
+                ("2026-05-23T11:00:00+00:00", "middle mission"),
+                ("2026-05-23T12:00:00+00:00", "latest mission"),
+            ]:
+                ho = _fresh_handoff()
+                ho.created_at = ts
+                ho.mission = mission
+                H.write_handoff(home, ho, target="project")
+            rows = H.list_handoffs(home, "myapp")
+            self.assertEqual(len(rows), 3)
+            # The archive filename starts with the timestamp; sorted reverse
+            # therefore puts newest first.
+            self.assertIn("latest", rows[0]["mission"])
+
+    def test_read_requires_project_or_task_id(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            with self.assertRaises(ValueError):
+                H.read_handoff(Path(tmp))
+
+
+# ---------------------------------------------------------------------------
+# from_done_signal — auto-draft
+# ---------------------------------------------------------------------------
+
+
+class TestFromDoneSignal(unittest.TestCase):
+    def test_draft_pulls_summary_and_files(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            # Seed a brief + a .done.json
+            brief = WorkerBrief(
+                task_id="t-draft", role="worker",
+                intent="Add OAuth login",
+            )
+            write_brief(home, brief)
+            sig = DoneSignal(
+                status="done_clean",
+                summary="OAuth endpoint added; tests green",
+                files_changed=["apps/web/src/auth/google.ts"],
+            )
+            write_done(home, "t-draft", sig)
+            draft = H.from_done_signal(home, "t-draft")
+            self.assertIn("OAuth", draft.mission)
+            self.assertIn("OAuth", draft.state)
+            self.assertIn("apps/web/src/auth/google.ts", draft.files_touched)
+            self.assertEqual(draft.task_id, "t-draft")
+
+    def test_draft_for_pending_status_seeds_next_steps(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            brief = WorkerBrief(task_id="t-pending", role="worker",
+                                intent="Finish the auth bug")
+            write_brief(home, brief)
+            sig = DoneSignal(
+                status="pending",
+                summary="Most of the bug fixed; one edge case remains",
+                files_changed=["auth.ts"],
+                pending_actions=["handle expired refresh_token edge case",
+                                 "add test for the edge case"],
+            )
+            write_done(home, "t-pending", sig)
+            draft = H.from_done_signal(home, "t-pending")
+            self.assertEqual(len(draft.next_steps), 2)
+            self.assertIn("refresh_token", draft.next_steps[0])
+
+    def test_draft_when_no_done_or_brief(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            # No brief, no done — still returns a Handoff with the task_id.
+            draft = H.from_done_signal(home, "t-missing")
+            self.assertIn("t-missing", draft.mission)
+            self.assertEqual(draft.task_id, "t-missing")
+
+    def test_git_diff_augments_files(self):
+        """When --cwd points at a git repo with uncommitted edits, files_touched
+        is enriched with `git diff --name-only HEAD`."""
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            # Mini git repo
+            repo = Path(tmp) / "repo"
+            repo.mkdir()
+            subprocess.run(["git", "init", "-q"], cwd=repo, check=True, timeout=10)
+            subprocess.run(["git", "config", "user.email", "t@t.com"],
+                           cwd=repo, check=True, timeout=5)
+            subprocess.run(["git", "config", "user.name", "t"],
+                           cwd=repo, check=True, timeout=5)
+            (repo / "a.py").write_text("# initial\n")
+            subprocess.run(["git", "add", "."], cwd=repo, check=True, timeout=5)
+            subprocess.run(["git", "commit", "-q", "-m", "init"],
+                           cwd=repo, check=True, timeout=10)
+            # Edit + add a new file
+            (repo / "a.py").write_text("# edited\n")
+            (repo / "b.py").write_text("# new\n")
+            subprocess.run(["git", "add", "b.py"], cwd=repo, check=True, timeout=5)
+            # No .done.json — draft built only from git
+            draft = H.from_done_signal(home, "t-git", cwd=repo)
+            self.assertIn("a.py", draft.files_touched)
+            self.assertIn("b.py", draft.files_touched)
+
+
+# ---------------------------------------------------------------------------
+# Template / CLI shape (smoke)
+# ---------------------------------------------------------------------------
+
+
+class TestTemplate(unittest.TestCase):
+    def test_template_has_five_sections(self):
+        for n in range(1, 6):
+            self.assertIn(f"## {n}.", H.TEMPLATE)
+
+
+if __name__ == "__main__":
+    unittest.main()