@agentikos/omega-os 0.1.0 → 0.19.5

package/omega/Agentik_Engine/tests/test_pursue_cadence.py

@@ -0,0 +1,217 @@
+"""Tests for the Agentik OS native primitives `pursue` and `cadence`.
+
+These are the Agentik OS equivalents of Claude Code's bundled /goal and
+/loop, re-implemented as engine primitives that run on the Claude Code Max
+subscription with no per-API-call surcharge. The tests exercise:
+
+  * `pursue()` — goal-driven loop. Uses the MockProvider so we can drive
+    the loop deterministically + a verify_cmd whose exit code we control
+    by touching a sentinel file.
+  * `cadence` — charter persistence (schedule / list / disable / remove)
+    and the round-trip with the autonomous supervisor on disk.
+  * `sync` — the directory-based SKILL.md layout is picked up and
+    projected to a Claude Code-shaped skills tree.
+"""
+from __future__ import annotations
+
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+import yaml
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+from omega_engine.cadence import (  # noqa: E402
+    disable_cadence,
+    list_cadences,
+    remove_cadence,
+    schedule_cadence,
+)
+from omega_engine.done_signal import read_done  # noqa: E402
+from omega_engine.provider import MockProvider  # noqa: E402
+from omega_engine.pursue import pursue  # noqa: E402
+from omega_engine.router import ModelRouter  # noqa: E402
+
+
+class TestPursueSuccessOnFirstIteration(unittest.TestCase):
+    def test_verify_passes_first_try(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            router = ModelRouter.single(MockProvider())
+            result = pursue(
+                intent="hello world",
+                verify_cmd="true",                # always exits 0
+                omega_home=home,
+                max_iterations=3,
+                router=router,
+                cwd=str(home),
+            )
+            self.assertEqual(result.status, "done_clean")
+            self.assertEqual(result.iterations, 1)
+            self.assertEqual(result.final_verify_exit, 0)
+            self.assertTrue(result.log_path.exists())
+            self.assertTrue(result.done_path.exists())
+            sig = read_done(home, result.task_id)
+            self.assertEqual(sig.status, "done_clean")
+            self.assertIn("hello world", sig.summary)
+
+
+class TestPursueExhaustsBudget(unittest.TestCase):
+    def test_verify_never_passes_returns_failed(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            router = ModelRouter.single(MockProvider())
+            result = pursue(
+                intent="impossible",
+                verify_cmd="false",               # always exits 1
+                omega_home=home,
+                max_iterations=3,
+                router=router,
+                cwd=str(home),
+            )
+            self.assertEqual(result.status, "failed")
+            self.assertEqual(result.iterations, 3)
+            self.assertEqual(result.final_verify_exit, 1)
+            # Per-iteration log has 3 lines
+            lines = result.log_path.read_text().strip().splitlines()
+            self.assertEqual(len(lines), 3)
+            sig = read_done(home, result.task_id)
+            self.assertEqual(sig.status, "failed")
+            self.assertEqual(len(sig.artifacts["attempts"]), 3)
+
+
+class TestPursueEventualSuccess(unittest.TestCase):
+    def test_sentinel_appears_mid_run(self):
+        """A verify_cmd that passes only after a sentinel file exists.
+
+        We simulate "the agent's edit landed at iter N" by pre-creating the
+        sentinel file after the loop starts is impossible (synchronous test),
+        so we use a verify_cmd whose first call fails and second call passes
+        via a touch in the cmd itself (every odd attempt creates, every even
+        attempt reads — but exit-code 0 only when the file already existed).
+        """
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            sentinel = home / "GOAL"
+            # First call: touch the file, exit 1. Second call: file exists, exit 0.
+            verify_cmd = (
+                f"test -f {sentinel} || (touch {sentinel} && exit 1)"
+            )
+            router = ModelRouter.single(MockProvider())
+            result = pursue(
+                intent="reach the sentinel",
+                verify_cmd=verify_cmd,
+                omega_home=home,
+                max_iterations=5,
+                router=router,
+                cwd=str(home),
+            )
+            self.assertEqual(result.status, "done_clean")
+            self.assertEqual(result.iterations, 2)
+
+
+class TestCadenceSchedule(unittest.TestCase):
+    def test_schedule_cron_writes_yaml(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            path = schedule_cadence(
+                intent="ping the API",
+                trigger_type="cron",
+                schedule="*/5 * * * *",
+                omega_home=home,
+            )
+            self.assertTrue(path.exists())
+            data = yaml.safe_load(path.read_text())
+            self.assertTrue(data["id"].startswith("cadence-"))
+            self.assertEqual(data["trigger"]["type"], "cron")
+            self.assertEqual(data["trigger"]["schedule"], "*/5 * * * *")
+            self.assertEqual(data["spec"]["intent"], "ping the API")
+            self.assertTrue(data["enabled"])
+
+    def test_schedule_delay_validates_integer(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            with self.assertRaises(ValueError):
+                schedule_cadence(
+                    intent="x", trigger_type="delay", schedule="not-int",
+                    omega_home=home,
+                )
+
+    def test_schedule_rejects_unknown_trigger(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            with self.assertRaises(ValueError):
+                schedule_cadence(
+                    intent="x", trigger_type="hourly", schedule="1",
+                    omega_home=home,
+                )
+
+    def test_list_returns_each_charter(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            schedule_cadence("first", "cron", "* * * * *", omega_home=home,
+                             charter_id="cadence-aaa")
+            schedule_cadence("second", "delay", "60", omega_home=home,
+                             charter_id="cadence-bbb")
+            entries = list_cadences(home)
+            ids = {e["id"] for e in entries}
+            self.assertEqual(ids, {"cadence-aaa", "cadence-bbb"})
+
+    def test_disable_flips_enabled_field(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            schedule_cadence("x", "cron", "* * * * *", omega_home=home,
+                             charter_id="cadence-x")
+            self.assertTrue(disable_cadence("cadence-x", omega_home=home))
+            entries = list_cadences(home)
+            self.assertFalse(entries[0]["enabled"])
+            # Second disable is a no-op.
+            self.assertFalse(disable_cadence("cadence-x", omega_home=home))
+
+    def test_remove_deletes_charter(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            schedule_cadence("x", "cron", "* * * * *", omega_home=home,
+                             charter_id="cadence-x")
+            self.assertTrue(remove_cadence("cadence-x", omega_home=home))
+            self.assertEqual(list_cadences(home), [])
+            self.assertFalse(remove_cadence("cadence-x", omega_home=home))
+
+
+class TestSyncSkillProjection(unittest.TestCase):
+    def test_directory_layout_projected_to_claude_code(self):
+        """A SKILL.md in a sub-directory must be projected to the native shape."""
+        from omega_engine.sync import SyncEngine
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            # Source layout: Agentik_SSOT/skills/pursue/SKILL.md (+ supporting)
+            src_skill = home / "Agentik_SSOT" / "skills" / "pursue"
+            src_skill.mkdir(parents=True)
+            (src_skill / "SKILL.md").write_text("---\nname: pursue\n---\n# pursue")
+            (src_skill / "examples.md").write_text("an example")
+            (src_skill / "scripts").mkdir()
+            (src_skill / "scripts" / "helper.sh").write_text("#!/bin/sh\n")
+            # Run sync directly against this home.
+            outcomes = SyncEngine().sync_all(home)
+            # We just need to know the projection didn't crash + skills were written.
+            self.assertTrue(any(o.get("skills_written", 0) >= 1 for o in outcomes),
+                            msg=f"no skill projected; outcomes={outcomes}")
+
+    def test_flat_layout_still_works(self):
+        from omega_engine.sync import SyncEngine
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            src_dir = home / "Agentik_SSOT" / "skills"
+            src_dir.mkdir(parents=True)
+            (src_dir / "legacy.md").write_text("# legacy flat skill")
+            outcomes = SyncEngine().sync_all(home)
+            self.assertTrue(any(o.get("skills_written", 0) >= 1 for o in outcomes),
+                            msg=f"flat layout not projected; outcomes={outcomes}")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/omega/Agentik_Engine/tests/test_rag.py

@@ -0,0 +1,287 @@
+"""Tests for the multi-RAG subsystem — five real retrievers + router.
+
+Every retriever is exercised end-to-end on real data:
+
+* HybridRetriever indexes a small corpus into a temp SQLite WAL store and
+  the right doc surfaces for a known-good query.
+* GraphRetriever adds typed edges and asserts depth-limited expansion.
+* AgenticRetriever multi-hops on top of HybridRetriever, terminates within
+  `max_hops`, and accumulates docs without duplicates.
+* CorrectiveRetriever exercises the refine-on-low-score path (the
+  MockProvider returns 40 then 90, so a retry MUST happen).
+* RAGRouter classifies, picks an inner strategy, wraps it in CRAG, and
+  returns a `RetrievalResult` with a strategy string that names the pick.
+
+Standalone runner: `python3 tests/test_rag.py`. Temp dir cleans up at end.
+"""
+from __future__ import annotations
+
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from omega_engine.provider import MockProvider                     # noqa: E402
+from omega_engine.rag import (                                    # noqa: E402
+    AgenticRetriever,
+    CorrectiveRetriever,
+    Document,
+    GraphRetriever,
+    HybridRetriever,
+    RAGRouter,
+    RetrievalResult,
+)
+
+
+# Three docs whose lexical and semantic separation is clear enough that a
+# simple BM25+cosine blend should rank the right one first for a focused query.
+_CORPUS: list[Document] = [
+    Document(
+        id="payments",
+        text=("The pricing service computes invoice totals and applies "
+              "promotional discounts before sending receipts."),
+        metadata={"topic": "billing"},
+    ),
+    Document(
+        id="auth",
+        text=("The authentication module validates JWT tokens, manages "
+              "session refresh, and enforces role-based access control."),
+        metadata={"topic": "auth"},
+    ),
+    Document(
+        id="telemetry",
+        text=("The telemetry layer emits structured events to the SQLite "
+              "WAL store and exposes a Prometheus endpoint."),
+        metadata={"topic": "ops"},
+    ),
+]
+
+
+def _hybrid(tmp_dir: Path, alpha: float = 0.5) -> HybridRetriever:
+    """Helper — build a HybridRetriever with the corpus already indexed."""
+    h = HybridRetriever(tmp_dir / "rag.db", alpha=alpha)
+    n = h.index(_CORPUS)
+    assert n == len(_CORPUS), f"indexed {n}, expected {len(_CORPUS)}"
+    return h
+
+
+def test_hybrid_surfaces_the_right_doc():
+    tmp = Path(tempfile.mkdtemp(prefix="omega_rag_"))
+    h = _hybrid(tmp)
+    try:
+        result = h.retrieve("how is the JWT session refresh handled?", k=3)
+        assert isinstance(result, RetrievalResult)
+        assert result.strategy == "hybrid"
+        assert result.documents, "expected at least one document"
+        # The auth doc is the only one that talks about JWT/session.
+        top_ids = [d.id for d in result.documents]
+        assert top_ids[0] == "auth", f"got {top_ids}"
+        # And every result carries its blended score in metadata.
+        assert "score" in result.documents[0].metadata
+        # k=3 means we should see up to 3 — never more.
+        assert len(result.documents) <= 3
+    finally:
+        h.close()
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def test_hybrid_dense_and_sparse_both_contribute():
+    """At alpha=1 (dense only) and alpha=0 (sparse only) the top doc for an
+    auth-flavoured query stays the auth doc — both legs are real.
+
+    Uses dim=4096 because the hashing-trick collision rate at the default
+    dim=256 is too high for short documents to reliably separate.  In a
+    real corpus you'd pick dim per the expected vocabulary size; for a
+    3-doc test we want headroom.
+    """
+    tmp = Path(tempfile.mkdtemp(prefix="omega_rag_"))
+    try:
+        for a in (0.0, 1.0):
+            h = HybridRetriever(tmp / f"rag_{a}.db", alpha=a, dim=4096)
+            h.index(_CORPUS)
+            r = h.retrieve("JWT token validation", k=1)
+            assert r.documents, f"alpha={a}: empty result"
+            assert r.documents[0].id == "auth", (
+                f"alpha={a}: top doc was {r.documents[0].id}"
+            )
+            h.close()
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def test_graph_expansion_and_persistence():
+    tmp = Path(tempfile.mkdtemp(prefix="omega_rag_"))
+    try:
+        g = GraphRetriever(tmp / "graph.json")
+        g.add_node("auth", text="authentication service",
+                   metadata={"owner": "alice"})
+        g.add_node("payments", text="payments service",
+                   metadata={"owner": "bob"})
+        g.add_node("billing", text="billing dashboard")
+        g.add_node("telemetry", text="metrics + tracing")
+        g.add_edge("auth", "payments", "depends_on")
+        g.add_edge("payments", "billing", "renders_into")
+        g.add_edge("billing", "telemetry", "emits_to")
+
+        # Depth 1 from auth = direct neighbours only.
+        n1 = g.neighbors("auth", depth=1)
+        assert "payments" in n1 and "billing" not in n1, n1
+        # Depth 2 reaches one more hop.
+        n2 = g.neighbors("auth", depth=2)
+        assert "billing" in n2 and "telemetry" not in n2, n2
+        # Depth 3 spans the whole graph.
+        n3 = g.neighbors("auth", depth=3)
+        assert {"payments", "billing", "telemetry"}.issubset(set(n3)), n3
+
+        # Query path: seed picks `auth` (token match), depth=2 expansion.
+        r = g.retrieve("what does auth depend on?", k=4, depth=2)
+        ids = [d.id for d in r.documents]
+        assert "auth" in ids and "payments" in ids, ids
+        assert r.strategy == "graph"
+
+        # Persistence: a fresh GraphRetriever on the same path should see
+        # every edge we just wrote.
+        g2 = GraphRetriever(tmp / "graph.json")
+        assert "billing" in g2.neighbors("payments", depth=1)
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def test_agentic_multihop_terminates():
+    tmp = Path(tempfile.mkdtemp(prefix="omega_rag_"))
+    h = _hybrid(tmp)
+    try:
+        provider = MockProvider()  # rag-agent terminates after 2 calls
+        a = AgenticRetriever(h, provider, max_hops=3, k_per_hop=2)
+        r = a.retrieve("explain authentication", k=4)
+        assert r.strategy == "agentic"
+        assert r.documents, "agentic returned no docs"
+        # Hop metadata stamped on every doc.
+        hops = {d.metadata.get("hop") for d in r.documents}
+        # Must have at least one hop and never more than max_hops - 1
+        # (since hop indices are 0-based).
+        assert hops, "no hop metadata"
+        assert max(hops) <= 2, f"hops={hops}"
+        # De-duplication: every id appears once.
+        ids = [d.id for d in r.documents]
+        assert len(ids) == len(set(ids)), f"duplicates in {ids}"
+    finally:
+        h.close()
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def test_corrective_grades_and_retries_on_low_score():
+    """MockProvider returns 40 (below threshold) then 90 — the Corrective
+    envelope MUST call the inner retriever twice."""
+    tmp = Path(tempfile.mkdtemp(prefix="omega_rag_"))
+    h = _hybrid(tmp)
+    try:
+        provider = MockProvider()
+        c = CorrectiveRetriever(h, provider, threshold=70.0, max_retries=2)
+        r = c.retrieve("auth", k=3)
+        assert r.documents, "corrective returned no docs"
+        assert r.strategy.startswith("corrective+"), r.strategy
+        # The grader stamps `grader_avg` on each document; final value must
+        # be the SECOND call's score (90), proving the retry happened.
+        avgs = {d.metadata.get("grader_avg") for d in r.documents}
+        assert avgs == {90.0}, f"grader_avg={avgs} (retry never fired?)"
+        # Provider call counter is the most direct proof.
+        assert provider._grader_calls == 2, provider._grader_calls
+    finally:
+        h.close()
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def test_corrective_settles_quickly_when_score_is_already_high():
+    """If the first grade is already above threshold, no retry happens."""
+    tmp = Path(tempfile.mkdtemp(prefix="omega_rag_"))
+    h = _hybrid(tmp)
+    try:
+        provider = MockProvider()
+        # threshold below the FIRST grade (40) → corrective is satisfied
+        # on the first try and never refines.
+        c = CorrectiveRetriever(h, provider, threshold=30.0, max_retries=2)
+        r = c.retrieve("auth", k=3)
+        assert r.documents
+        assert provider._grader_calls == 1, provider._grader_calls
+        assert r.strategy.startswith("corrective+"), r.strategy
+    finally:
+        h.close()
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def test_router_classifies_and_wraps_in_corrective():
+    tmp = Path(tempfile.mkdtemp(prefix="omega_rag_"))
+    h = _hybrid(tmp)
+    try:
+        g = GraphRetriever(tmp / "graph.json")
+        g.add_edge("auth", "payments", "depends_on")
+        provider = MockProvider()
+        router = RAGRouter(
+            strategies={"hybrid": h, "graph": g},
+            provider=provider,
+            default="hybrid",
+            threshold=70.0,
+            max_retries=2,
+        )
+        r = router.retrieve("JWT session refresh", k=3)
+        assert isinstance(r, RetrievalResult)
+        assert r.documents, "router returned no docs"
+        # Strategy string names the inner pick AND the corrective wrap.
+        assert r.strategy.startswith("router(")
+        assert "corrective+" in r.strategy, r.strategy
+        # Provider override returned "hybrid", and the heuristic also
+        # defaults to hybrid for this query — so the inner pick is hybrid.
+        assert "router(hybrid)" in r.strategy, r.strategy
+    finally:
+        h.close()
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def test_router_heuristic_picks_graph_for_relational_query():
+    tmp = Path(tempfile.mkdtemp(prefix="omega_rag_"))
+    h = _hybrid(tmp)
+    try:
+        g = GraphRetriever(tmp / "graph.json")
+        g.add_edge("auth", "payments", "depends_on")
+
+        # Stub provider that returns no override → heuristic decides.
+        class HeuristicOnlyProvider(MockProvider):
+            def run(self, req):  # type: ignore[override]
+                if req.role == "rag-route":
+                    # Return empty artifact so router falls back to heuristic.
+                    from omega_engine.provider import AgentResult
+                    return AgentResult(text="no override", claimed_done=True,
+                                       artifacts={})
+                return super().run(req)
+
+        provider = HeuristicOnlyProvider()
+        router = RAGRouter(
+            strategies={"hybrid": h, "graph": g},
+            provider=provider,
+            corrective=False,    # disable corrective for cleaner assertion
+        )
+        # Query has "depend" and "between" — graph heuristic must fire.
+        chosen = router.classify("what does auth depend on?")
+        assert chosen == "graph", chosen
+    finally:
+        h.close()
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def _run_all() -> bool:
+    tests = [v for k, v in sorted(globals().items())
+             if k.startswith("test_") and callable(v)]
+    passed = 0
+    for t in tests:
+        t()
+        print(f"  PASS  {t.__name__}")
+        passed += 1
+    print(f"\n{passed}/{len(tests)} rag tests passed")
+    return passed == len(tests)
+
+
+if __name__ == "__main__":
+    sys.exit(0 if _run_all() else 1)