@agentikos/omega-os 0.2.0 → 0.19.6

package/omega/Agentik_Engine/tests/test_intelligence.py

@@ -0,0 +1,285 @@
+"""Tests for the v0.9 "intelligence" layer:
+
+  classifier.py        — task complexity classification
+  memory.py            — cross-source semantic search
+  learning.py          — Smith reflection on audit + worker history
+  agent_messages.py    — worker ↔ oracle messaging
+"""
+from __future__ import annotations
+
+import json
+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))
+
+
+# ---------------------------------------------------------------------------
+# classifier.py
+# ---------------------------------------------------------------------------
+
+
+class TestClassifier(unittest.TestCase):
+    def test_empty_is_simple(self):
+        from omega_engine.classifier import classify
+        c = classify("")
+        self.assertEqual(c.bucket, "simple")
+        self.assertEqual(c.confidence, "high")
+
+    def test_architect_role_always_complex(self):
+        from omega_engine.classifier import classify
+        c = classify("rename a variable", role="architect")
+        self.assertEqual(c.bucket, "complex")
+
+    def test_oracle_role_is_moderate(self):
+        from omega_engine.classifier import classify
+        c = classify("anything", role="oracle")
+        self.assertEqual(c.bucket, "moderate")
+
+    def test_complex_keywords(self):
+        from omega_engine.classifier import classify
+        c = classify(
+            "design a security architecture for the auth refactor",
+            role="worker",
+        )
+        self.assertEqual(c.bucket, "complex")
+        self.assertEqual(c.suggested_model, "opus")
+
+    def test_simple_keyword_short(self):
+        from omega_engine.classifier import classify
+        c = classify("rename Foo to Bar in utils.py", role="worker")
+        self.assertEqual(c.bucket, "simple")
+        self.assertEqual(c.suggested_model, "haiku")
+
+    def test_file_count_complex(self):
+        from omega_engine.classifier import classify
+        c = classify("update 12 files for the new API", role="worker")
+        self.assertEqual(c.bucket, "complex")
+
+    def test_long_description_complex(self):
+        from omega_engine.classifier import classify
+        long_text = (
+            "We need to investigate the recent performance regression on "
+            "the dashboard route. The user reports load times went from "
+            "1.2s to 4.5s in the last two weeks. Look at the bundle, "
+            "the database queries, the cache, and the rendering "
+            "pipeline. Identify the regression and propose a fix that "
+            "we can ship today."
+        )
+        c = classify(long_text, role="worker")
+        # Has "investigate", "performance" → complex
+        self.assertEqual(c.bucket, "complex")
+
+    def test_moderate_keyword(self):
+        from omega_engine.classifier import classify
+        # 'implement' + medium length but no complex keyword → moderate
+        c = classify("implement the password validator function",
+                      role="worker")
+        self.assertEqual(c.bucket, "moderate")
+        self.assertEqual(c.suggested_model, "sonnet")
+
+
+# ---------------------------------------------------------------------------
+# memory.py
+# ---------------------------------------------------------------------------
+
+
+class TestMemory(unittest.TestCase):
+    def _seed(self, home: Path):
+        # Telegram history
+        from omega_engine.telegram_history import (
+            record_inbound, record_outbound,
+        )
+        record_inbound(home, topic_id=1, text="we decided to use age for vault encryption")
+        record_outbound(home, topic_id=1, text="confirmed; vault keys live in Agentik_Extra")
+        record_inbound(home, topic_id=2, text="the login bug returns 500 on Safari")
+        # .done.json
+        from omega_engine.done_signal import DoneSignal, write_done
+        write_done(home, "t-abc", DoneSignal(
+            status="done_clean", summary="fixed the login bug for Safari",
+            files_changed=["src/auth.py"],
+        ))
+        # Audit history
+        from omega_engine.audits.history import (
+            AuditRun, make_run_id, now, record_run,
+        )
+        record_run(home, AuditRun(
+            run_id=make_run_id(), audit_id="codeaudit",
+            scope=".", timestamp=now(),
+            score=88, verified=True, finding_count=2,
+            verdict={"summary": "code passes with two minor warnings",
+                     "findings": []},
+        ))
+
+    def test_reindex_counts_each_source(self):
+        from omega_engine import memory
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            self._seed(home)
+            counts = memory.reindex(home)
+            self.assertGreaterEqual(counts["telegram"], 3)
+            self.assertGreaterEqual(counts["done_json"], 1)
+            self.assertGreaterEqual(counts["audit"], 1)
+            self.assertEqual(counts["total"],
+                              counts["telegram"] + counts["done_json"]
+                              + counts["audit"])
+
+    def test_search_finds_across_sources(self):
+        from omega_engine import memory
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            self._seed(home)
+            memory.reindex(home)
+            hits = memory.search(home, "vault", k=5)
+            sources = {h.source for h in hits}
+            # We seeded "vault encryption" in telegram — should find it.
+            self.assertIn("telegram", sources)
+
+    def test_search_returns_login_bug_done_json(self):
+        from omega_engine import memory
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            self._seed(home)
+            memory.reindex(home)
+            hits = memory.search(home, "login bug", k=5)
+            # The .done.json text mentions "login bug" — should appear.
+            sources = {h.source for h in hits}
+            self.assertTrue("done_json" in sources or "telegram" in sources)
+
+    def test_index_stats(self):
+        from omega_engine import memory
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            self._seed(home)
+            memory.reindex(home)
+            stats = memory.index_stats(home)
+            self.assertTrue(stats["indexed"])
+            self.assertGreater(stats["total"], 0)
+
+
+# ---------------------------------------------------------------------------
+# learning.py — Smith reflection
+# ---------------------------------------------------------------------------
+
+
+class TestLearning(unittest.TestCase):
+    def test_weak_audit_insight(self):
+        from omega_engine.audits.history import (
+            AuditRun, make_run_id, record_run,
+        )
+        from omega_engine.learning import reflect
+        with tempfile.TemporaryDirectory() as td:
+            now_s = int(time.time())
+            # Seed 4 codeaudit runs all below threshold.
+            for i in range(4):
+                record_run(td, AuditRun(
+                    run_id=make_run_id(), audit_id="codeaudit",
+                    scope=".", timestamp=now_s - i * 3600,
+                    score=55 + i * 2, verified=False, finding_count=10,
+                    verdict={"findings": []},
+                ))
+            report = reflect(td, write_proposals=False)
+            kinds = {i.kind for i in report.insights}
+            self.assertIn("weak_audit", kinds)
+            titles = " ".join(i.title for i in report.insights)
+            self.assertIn("codeaudit", titles)
+
+    def test_repeated_pending_action_insight(self):
+        from omega_engine.done_signal import DoneSignal, write_done
+        from omega_engine.learning import reflect
+        with tempfile.TemporaryDirectory() as td:
+            for i in range(12):
+                write_done(td, f"t-{i}", DoneSignal(
+                    status="pending",
+                    summary=f"part {i}",
+                    pending_actions=["write the unit test for X"],
+                ))
+            report = reflect(td, write_proposals=False)
+            kinds = [i.kind for i in report.insights]
+            self.assertIn("skill_suggestion", kinds)
+
+    def test_write_proposals_creates_files(self):
+        from omega_engine.audits.history import (
+            AuditRun, make_run_id, record_run,
+        )
+        from omega_engine.learning import reflect
+        with tempfile.TemporaryDirectory() as td:
+            now_s = int(time.time())
+            for i in range(4):
+                record_run(td, AuditRun(
+                    run_id=make_run_id(), audit_id="seoaudit",
+                    scope=".", timestamp=now_s - i * 3600,
+                    score=40, verified=False, finding_count=10,
+                    verdict={"findings": []},
+                ))
+            report = reflect(td, write_proposals=True)
+            staging = Path(td) / "Agentik_Extra" / "staging" / "promotion"
+            files = list(staging.glob("smith-*.json"))
+            self.assertGreater(len(files), 0)
+            # Each file is parseable JSON with the expected schema.
+            data = json.loads(files[0].read_text())
+            self.assertIn("kind", data)
+            self.assertIn("title", data)
+
+
+# ---------------------------------------------------------------------------
+# agent_messages.py
+# ---------------------------------------------------------------------------
+
+
+class TestAgentMessages(unittest.TestCase):
+    def test_send_and_read_round_trip(self):
+        from omega_engine import agent_messages as am
+        with tempfile.TemporaryDirectory() as td:
+            am.send(td, "t-1", from_="worker", to="oracle",
+                    type="question", text="should I bump the version?")
+            am.send(td, "t-1", from_="oracle", to="worker",
+                    type="answer", text="yes, semver minor.")
+            msgs = am.read(td, "t-1")
+            self.assertEqual(len(msgs), 2)
+            self.assertEqual(msgs[0].type, "question")
+            self.assertEqual(msgs[1].type, "answer")
+
+    def test_recipient_filter(self):
+        from omega_engine import agent_messages as am
+        with tempfile.TemporaryDirectory() as td:
+            am.send(td, "t-2", from_="worker", to="oracle",
+                    type="question", text="for oracle")
+            am.send(td, "t-2", from_="worker", to="manager",
+                    type="question", text="for manager")
+            for_oracle = am.read(td, "t-2", for_recipient="oracle")
+            self.assertEqual(len(for_oracle), 1)
+            self.assertEqual(for_oracle[0].text, "for oracle")
+
+    def test_open_questions(self):
+        from omega_engine import agent_messages as am
+        with tempfile.TemporaryDirectory() as td:
+            # task A: question without answer
+            am.send(td, "task-A", from_="worker", to="oracle",
+                    type="question", text="answer me")
+            # task B: question with answer (no longer open)
+            am.send(td, "task-B", from_="worker", to="oracle",
+                    type="question", text="x")
+            am.send(td, "task-B", from_="oracle", to="worker",
+                    type="answer", text="y")
+            opens = am.list_open_questions(td)
+            tasks = {pair[0] for pair in opens}
+            self.assertIn("task-A", tasks)
+            self.assertNotIn("task-B", tasks)
+
+    def test_rejects_unknown_type(self):
+        from omega_engine import agent_messages as am
+        with tempfile.TemporaryDirectory() as td:
+            with self.assertRaises(ValueError):
+                am.send(td, "t-3", from_="a", to="b",
+                        type="invalid", text="x")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/omega/Agentik_Engine/tests/test_llm_clis_and_uninstall.py

@@ -0,0 +1,228 @@
+"""Tests for the LLM CLI helper + omega uninstall + omega upgrade.
+
+The helper is at ``bootstrap/lib/llm-clis.py`` — loadable as a module
+via importlib.util because of the hyphen in the filename. We exercise:
+
+  * CliSpec.is_installed() resolves to PATH presence.
+  * _selection_from_manifest reads the list AND dict forms.
+  * install_cli short-circuits on already-installed.
+  * uninstall_cli reverses npm/uv/pip commands.
+  * cmd_uninstall removes the 8-block tree and strips settings.json
+    keys (idempotent + safe with a fake HOME).
+"""
+from __future__ import annotations
+
+import importlib.util
+import io
+import json
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+import yaml
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+REPO_ROOT = HERE.parent.parent.parent
+HELPER = REPO_ROOT / "bootstrap" / "lib" / "llm-clis.py"
+
+
+def _load_helper():
+    """Load bootstrap/lib/llm-clis.py as a module.
+
+    Python 3.13's dataclasses inspects ``sys.modules[cls.__module__]``,
+    so we must register the freshly loaded module BEFORE exec_module
+    runs the class-definitions inside.
+    """
+    spec = importlib.util.spec_from_file_location("llm_clis", str(HELPER))
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["llm_clis"] = mod
+    spec.loader.exec_module(mod)  # type: ignore[union-attr]
+    return mod
+
+
+class TestCliSpec(unittest.TestCase):
+    def test_is_installed_false_when_missing(self):
+        mod = _load_helper()
+        spec = mod.CliSpec(
+            id="x", label="x", bin_name="definitely-not-a-real-binary-1234",
+            install_cmd=["npm", "install", "-g", "x"],
+        )
+        self.assertFalse(spec.is_installed())
+        self.assertIsNone(spec.installed_version())
+
+    def test_is_installed_true_when_present(self):
+        mod = _load_helper()
+        # `python3` is always on PATH in our test env.
+        spec = mod.CliSpec(
+            id="py", label="python", bin_name="python3",
+            install_cmd=["echo", "noop"],
+            version_cmd=["python3", "--version"],
+        )
+        self.assertTrue(spec.is_installed())
+        v = spec.installed_version()
+        self.assertIsNotNone(v)
+        self.assertIn("Python", v or "")
+
+
+class TestManifestParsing(unittest.TestCase):
+    def test_list_form(self):
+        mod = _load_helper()
+        with tempfile.TemporaryDirectory() as td:
+            p = Path(td) / "m.yaml"
+            p.write_text(yaml.safe_dump({
+                "llm_clis": ["claude_code", "gemini_cli"],
+            }))
+            self.assertEqual(
+                mod._selection_from_manifest(p),
+                {"claude_code", "gemini_cli"},
+            )
+
+    def test_dict_form_filters_false(self):
+        mod = _load_helper()
+        with tempfile.TemporaryDirectory() as td:
+            p = Path(td) / "m.yaml"
+            p.write_text(yaml.safe_dump({
+                "llm_clis": {
+                    "claude_code": True,
+                    "gemini_cli": True,
+                    "codex": False,
+                },
+            }))
+            self.assertEqual(
+                mod._selection_from_manifest(p),
+                {"claude_code", "gemini_cli"},
+            )
+
+    def test_no_block_returns_none(self):
+        mod = _load_helper()
+        with tempfile.TemporaryDirectory() as td:
+            p = Path(td) / "m.yaml"
+            p.write_text(yaml.safe_dump({"profile": "vps"}))
+            self.assertIsNone(mod._selection_from_manifest(p))
+
+
+class TestInstallShortCircuits(unittest.TestCase):
+    def test_already_installed_skips(self):
+        mod = _load_helper()
+        spec = mod.CliSpec(
+            id="py", label="python", bin_name="python3",
+            install_cmd=["echo", "noop"],
+            version_cmd=["python3", "--version"],
+        )
+        result = mod.install_cli(spec, force=False)
+        self.assertEqual(result["status"], "skip")
+        self.assertEqual(result["reason"], "already installed")
+
+    def test_unknown_tool_errors_cleanly(self):
+        mod = _load_helper()
+        spec = mod.CliSpec(
+            id="x", label="x", bin_name="not-real-x-1234",
+            install_cmd=["definitely-not-a-real-tool-9999",
+                         "install", "x"],
+        )
+        result = mod.install_cli(spec)
+        self.assertEqual(result["status"], "error")
+        self.assertIn("not on PATH", result["reason"])
+
+
+class TestUninstallCommand(unittest.TestCase):
+    def test_uninstall_strips_settings_keys(self):
+        # Simulate a settings.json that was previously merged by step 33.
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td) / "Omega"
+            home.mkdir(parents=True)
+            # Minimal 8-block tree.
+            for b in ("Agentik_SSOT", "Agentik_Engine", "Agentik_Orchestration",
+                      "Agentik_Providers", "Agentik_Coding", "Agentik_Tools",
+                      "Agentik_Runtime", "Agentik_Extra"):
+                (home / b).mkdir()
+
+            fake_home = Path(td) / "fake-home"
+            settings = fake_home / ".claude" / "settings.json"
+            settings.parent.mkdir(parents=True)
+            settings.write_text(json.dumps({
+                "env": {
+                    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1",
+                    "OPERATOR_OWN_KEY": "preserve me",
+                },
+                "permissions": {"defaultMode": "bypassPermissions"},
+                "hooks": {
+                    "Stop": [
+                        {"tag": "omega-audit-gate",
+                         "hooks": [{"type": "command", "command": "x"}]},
+                        {"tag": "operator-own-hook",
+                         "hooks": [{"type": "command", "command": "y"}]},
+                    ],
+                },
+            }))
+
+            # Run the uninstall.
+            from omega_engine.cli import cmd_uninstall
+            ns = mock.Mock(yes=True, purge=False, include_llm_clis=False)
+            with mock.patch.dict(os.environ, {
+                "OMEGA_HOME": str(home),
+                "HOME": str(fake_home),
+            }), mock.patch("pathlib.Path.home", return_value=fake_home):
+                rc = cmd_uninstall(ns)
+            self.assertEqual(rc, 0)
+            # Tree gone.
+            self.assertFalse(home.exists())
+            # Settings cleaned, operator keys preserved.
+            data = json.loads(settings.read_text())
+            self.assertNotIn(
+                "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS", data.get("env", {}),
+            )
+            self.assertEqual(data["env"]["OPERATOR_OWN_KEY"], "preserve me")
+            tags = [
+                e.get("tag") for e in data["hooks"]["Stop"]
+                if isinstance(e, dict)
+            ]
+            self.assertNotIn("omega-audit-gate", tags)
+            self.assertIn("operator-own-hook", tags)
+
+    def test_uninstall_backs_up_vault_by_default(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td) / "Omega"
+            home.mkdir()
+            secrets = home / "Agentik_Extra" / "etc" / "secrets"
+            secrets.mkdir(parents=True)
+            (secrets / "CLAUDE_OAUTH_max_TOKEN.age").write_text("encrypted")
+            fake_home = Path(td) / "fake-home"
+            fake_home.mkdir()
+
+            from omega_engine.cli import cmd_uninstall
+            ns = mock.Mock(yes=True, purge=False, include_llm_clis=False)
+            with mock.patch.dict(os.environ, {"OMEGA_HOME": str(home)}), \
+                 mock.patch("pathlib.Path.home", return_value=fake_home):
+                cmd_uninstall(ns)
+
+            backups = list(fake_home.glob(".omega-vault-backup-*"))
+            self.assertEqual(len(backups), 1)
+            self.assertTrue(
+                (backups[0] / "CLAUDE_OAUTH_max_TOKEN.age").exists()
+            )
+
+    def test_uninstall_purge_drops_vault(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td) / "Omega"
+            home.mkdir()
+            (home / "Agentik_Extra" / "etc" / "secrets").mkdir(parents=True)
+            (home / "Agentik_Extra" / "etc" / "secrets" / "x.age").write_text("x")
+            fake_home = Path(td) / "fake-home"; fake_home.mkdir()
+
+            from omega_engine.cli import cmd_uninstall
+            ns = mock.Mock(yes=True, purge=True, include_llm_clis=False)
+            with mock.patch.dict(os.environ, {"OMEGA_HOME": str(home)}), \
+                 mock.patch("pathlib.Path.home", return_value=fake_home):
+                cmd_uninstall(ns)
+            self.assertEqual(list(fake_home.glob(".omega-vault-backup-*")), [])
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)