@agentikos/omega-os 0.1.0 → 0.2.0

package/omega/Agentik_Engine/tests/test_tools_and_sync.py

@@ -0,0 +1,312 @@
+"""ToolRegistry + SyncEngine / ClaudeCodeAdapter end-to-end test.
+
+Seeds a tempdir OMEGA_HOME with one skill, one command, one MCP-config entry,
+one catalog entry, one tool, and one hook. Asserts the projection produces the
+expected Claude Code native layout (skills/<id>/SKILL.md, commands/<id>.md,
+.mcp.json with mcpServers, settings.json with hooks).
+
+Standalone: python3 tests/test_tools_and_sync.py
+"""
+import json
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from omega_engine import cli                                       # noqa: E402
+from omega_engine.sync import ClaudeCodeAdapter, SyncEngine        # noqa: E402
+from omega_engine.tools import (                                    # noqa: E402
+    Tool,
+    ToolRegistry,
+    load_catalog,
+    merge_mcp_config,
+)
+
+
+# --------------------------------------------------------------------------
+# Tempdir helpers
+# --------------------------------------------------------------------------
+
+
+def _seed_home() -> Path:
+    home = Path(tempfile.mkdtemp(prefix="omega-tools-sync-test-"))
+    # 8-block scaffolding (only what the test touches)
+    for b in ("Agentik_SSOT", "Agentik_Tools", "Agentik_Providers"):
+        (home / b).mkdir(parents=True, exist_ok=True)
+    # SSOT subdirs
+    ssot = home / "Agentik_SSOT"
+    (ssot / "skills").mkdir(parents=True, exist_ok=True)
+    (ssot / "commands").mkdir(parents=True, exist_ok=True)
+    (ssot / "agents").mkdir(parents=True, exist_ok=True)
+    (ssot / "hooks").mkdir(parents=True, exist_ok=True)
+    (ssot / "mcp").mkdir(parents=True, exist_ok=True)
+    return home
+
+
+def _seed_skill(home: Path, sid: str, body: str) -> None:
+    (home / "Agentik_SSOT" / "skills" / f"{sid}.md").write_text(body)
+
+
+def _seed_command(home: Path, cid: str, body: str) -> None:
+    (home / "Agentik_SSOT" / "commands" / f"{cid}.md").write_text(body)
+
+
+def _seed_agent(home: Path, aid: str, body: str) -> None:
+    (home / "Agentik_SSOT" / "agents" / f"{aid}.md").write_text(body)
+
+
+def _seed_hook(home: Path, fname: str, payload: dict) -> None:
+    (home / "Agentik_SSOT" / "hooks" / fname).write_text(json.dumps(payload))
+
+
+def _seed_catalog(home: Path) -> None:
+    import yaml
+    cat = {
+        "version": 1,
+        "catalog": [
+            {"id": "filesystem", "name": "Filesystem",
+             "description": "sandboxed file access",
+             "category": "core",
+             "install": {"method": "npx",
+                         "package": "@modelcontextprotocol/server-filesystem"},
+             "recommended": True},
+            {"id": "github", "name": "GitHub",
+             "description": "issues + PRs",
+             "category": "dev",
+             "install": {"method": "npx",
+                         "package": "@modelcontextprotocol/server-github"},
+             "secrets": ["GITHUB_TOKEN"],
+             "recommended": True},
+        ],
+    }
+    (home / "Agentik_SSOT" / "mcp" / "mcp-catalog.yaml").write_text(
+        yaml.safe_dump(cat, sort_keys=False))
+
+
+def _seed_mcp_config(home: Path) -> None:
+    merge_mcp_config(home, {"id": "filesystem", "secret_refs": [], "enabled": True})
+    merge_mcp_config(home, {"id": "github", "secret_refs": ["GITHUB_TOKEN"],
+                            "enabled": True})
+
+
+def _seed_providers(home: Path) -> None:
+    import yaml
+    reg = {
+        "version": 1,
+        "providers": [{"id": "claude", "adapter": "claude"}],
+    }
+    (home / "Agentik_Providers" / "registry.yaml").write_text(
+        yaml.safe_dump(reg, sort_keys=False))
+
+
+# --------------------------------------------------------------------------
+# 1. ToolRegistry — install / list / remove + idempotent save/load
+# --------------------------------------------------------------------------
+
+
+def test_registry_install_list_remove():
+    home = _seed_home()
+    try:
+        reg = ToolRegistry.load(home)
+        assert reg.list() == []
+
+        t = Tool(name="filesystem", version="1.2.3",
+                 path="Agentik_Tools/filesystem/",
+                 invoke="Agentik_Tools/filesystem/bin/server-filesystem",
+                 source="mcp:filesystem")
+        reg.install(t)
+        reg.save(home)
+        assert reg.installed_path("filesystem") == home / "Agentik_Tools" / "filesystem"
+
+        # round-trip
+        reg2 = ToolRegistry.load(home)
+        assert len(reg2.list()) == 1
+        assert reg2.get("filesystem").version == "1.2.3"
+
+        # remove
+        assert reg2.remove("filesystem") is True
+        reg2.save(home)
+        assert ToolRegistry.load(home).list() == []
+    finally:
+        shutil.rmtree(home, ignore_errors=True)
+
+
+# --------------------------------------------------------------------------
+# 2. catalog round-trip
+# --------------------------------------------------------------------------
+
+
+def test_catalog_loads():
+    home = _seed_home()
+    try:
+        _seed_catalog(home)
+        cat = load_catalog(home)
+        ids = {e["id"] for e in cat["catalog"]}
+        assert ids == {"filesystem", "github"}
+    finally:
+        shutil.rmtree(home, ignore_errors=True)
+
+
+# --------------------------------------------------------------------------
+# 3. ClaudeCodeAdapter.project() — full projection
+# --------------------------------------------------------------------------
+
+
+def test_claude_code_projection():
+    home = _seed_home()
+    try:
+        # seed an SSOT
+        _seed_skill(home, "frontend-design",
+                    "# Frontend design\n\nProduction-grade UI.\n")
+        _seed_command(home, "uiuxaudit",
+                      "# /uiuxaudit\n\nUI/UX forensic audit.\n")
+        _seed_agent(home, "oracle",
+                    "# Oracle\n\nClassify and route.\n")
+        _seed_hook(home, "stop.json",
+                   {"Stop": [{"matcher": "*", "hooks": [{"type": "command",
+                                                          "command": "echo stop"}]}]})
+        _seed_catalog(home)
+        _seed_mcp_config(home)
+        _seed_providers(home)
+
+        # pre-register one tool so .mcp.json gets a real command path
+        reg = ToolRegistry.load(home)
+        reg.install(Tool(
+            name="filesystem",
+            path="Agentik_Tools/filesystem/",
+            invoke="Agentik_Tools/filesystem/bin/server-filesystem",
+            source="mcp:filesystem",
+        ))
+        reg.save(home)
+
+        adapter = ClaudeCodeAdapter()
+        out = adapter.project(home)
+        assert out["projected"]
+        target = Path(out["target"])
+        assert target.is_dir()
+        assert (target / "skills" / "frontend-design" / "SKILL.md").exists()
+        assert "Production-grade UI" in (
+            target / "skills" / "frontend-design" / "SKILL.md").read_text()
+        assert (target / "commands" / "uiuxaudit.md").exists()
+        assert (target / "agents" / "oracle.md").exists()
+
+        # .mcp.json — both servers projected; filesystem has a local command,
+        # github falls back to npx.
+        mcp = json.loads((target / ".mcp.json").read_text())
+        servers = mcp["mcpServers"]
+        assert "filesystem" in servers and "github" in servers
+        assert servers["filesystem"]["command"].endswith(
+            "Agentik_Tools/filesystem/bin/server-filesystem")
+        assert servers["github"]["command"] == "npx"
+        assert "@modelcontextprotocol/server-github" in servers["github"]["args"]
+        # secret refs projected as env placeholders
+        assert servers["github"]["env"] == {"GITHUB_TOKEN": "${GITHUB_TOKEN}"}
+
+        # settings.json — hooks block merged
+        settings = json.loads((target / "settings.json").read_text())
+        assert "Stop" in settings["hooks"]
+
+        # idempotency: re-running produces the same outcome
+        out2 = adapter.project(home)
+        assert out2["skills_written"] == out["skills_written"]
+        assert out2["mcp_servers"] == out["mcp_servers"]
+        # the .mcp.json content stays the same
+        mcp2 = json.loads((target / ".mcp.json").read_text())
+        assert mcp == mcp2
+    finally:
+        shutil.rmtree(home, ignore_errors=True)
+
+
+# --------------------------------------------------------------------------
+# 4. SyncEngine.sync_all() over the providers registry
+# --------------------------------------------------------------------------
+
+
+def test_sync_engine_iterates_providers():
+    home = _seed_home()
+    try:
+        _seed_skill(home, "frontend-design", "# Skill\n")
+        _seed_catalog(home)
+        _seed_mcp_config(home)
+        # both claude (real adapter) and glm (stub adapter)
+        import yaml
+        (home / "Agentik_Providers" / "registry.yaml").write_text(yaml.safe_dump({
+            "version": 1,
+            "providers": [{"id": "claude"}, {"id": "glm"}],
+        }))
+        outcomes = SyncEngine().sync_all(home)
+        by_id = {o["provider"]: o for o in outcomes}
+        assert by_id["claude-code"]["projected"] is True
+        assert by_id["glm"]["projected"] is False
+        assert "no native projection" in by_id["glm"]["reason"]
+    finally:
+        shutil.rmtree(home, ignore_errors=True)
+
+
+# --------------------------------------------------------------------------
+# 5. CLI: `omega sync` returns 0
+# --------------------------------------------------------------------------
+
+
+def test_cli_sync_returns_zero(monkeypatch=None):
+    home = _seed_home()
+    try:
+        _seed_skill(home, "frontend-design", "# Skill\n")
+        _seed_catalog(home)
+        _seed_mcp_config(home)
+        _seed_providers(home)
+
+        import os
+        old = os.environ.get("OMEGA_HOME")
+        os.environ["OMEGA_HOME"] = str(home)
+        try:
+            rc = cli.main(["sync"])
+        finally:
+            if old is None:
+                os.environ.pop("OMEGA_HOME", None)
+            else:
+                os.environ["OMEGA_HOME"] = old
+        assert rc == 0
+    finally:
+        shutil.rmtree(home, ignore_errors=True)
+
+
+# --------------------------------------------------------------------------
+# 6. CLI: `omega tool list` returns 0 on empty registry
+# --------------------------------------------------------------------------
+
+
+def test_cli_tool_list_empty():
+    home = _seed_home()
+    try:
+        import os
+        old = os.environ.get("OMEGA_HOME")
+        os.environ["OMEGA_HOME"] = str(home)
+        try:
+            rc = cli.main(["tool", "list"])
+        finally:
+            if old is None:
+                os.environ.pop("OMEGA_HOME", None)
+            else:
+                os.environ["OMEGA_HOME"] = old
+        assert rc == 0
+    finally:
+        shutil.rmtree(home, 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)} tools+sync tests passed")
+    return passed == len(tests)
+
+
+if __name__ == "__main__":
+    sys.exit(0 if _run_all() else 1)

package/omega/Agentik_SSOT/skills/rag-route.md

@@ -0,0 +1,73 @@
+# /rag-route — Classify a query, pick a retrieval strategy
+
+> An agentic skill. Wraps `omega_engine.rag.RAGRouter`. Classifies the
+> incoming query and dispatches to the right inner retriever, always behind
+> the Corrective RAG envelope.
+
+---
+
+## What it does
+
+Given a natural-language query, `/rag-route`:
+
+1. Applies a cheap heuristic to detect query shape:
+   - Relational ("depends", "between", "who owns") → **graph**
+   - Modal ("diagram", "screenshot", "pdf") → **multimodal**
+   - Investigative ("why", "how", "explain") → **agentic**
+   - Otherwise → **hybrid** (the default — dense + BM25)
+2. Asks the provider (role `rag-route`) to confirm or override.
+3. Runs the chosen retriever, wrapped in `CorrectiveRetriever` so the
+   result is graded and re-retrieved if quality is low.
+4. Returns a `RetrievalResult` with `strategy = "router(<inner>)->corrective+<inner>"`.
+
+## Why route at all?
+
+A single retriever wins for a single shape of query. Real workloads mix
+shapes — code search (hybrid), dependency questions (graph), screenshot
+recall (multimodal), causal explanations (agentic). Routing keeps each
+strategy honest at what it's best at, and the Corrective envelope keeps
+the overall quality floor explicit.
+
+## How to call it (Python)
+
+```python
+from omega_engine import (
+    RAGRouter, HybridRetriever, GraphRetriever, MockProvider,
+)
+
+provider = MockProvider()
+router = RAGRouter(
+    strategies={
+        "hybrid": HybridRetriever("/path/to/rag.db"),
+        "graph":  GraphRetriever("/path/to/graph.json"),
+    },
+    provider=provider,
+    default="hybrid",
+    threshold=70.0,
+    max_retries=2,
+)
+result = router.retrieve("what does the auth service depend on?", k=5)
+# result.strategy → "router(graph)->corrective+graph"
+# result.documents → ranked Documents
+```
+
+## Where its pieces live
+
+Following the OmegaOS placement rule (engine ≠ config ≠ runtime):
+
+- **Engine** — `omega/Agentik_Engine/omega_engine/rag/` (the retrievers + router).
+- **Runtime** — `<omega_home>/Agentik_Runtime/memory/rag.db` (hybrid corpus)
+  and `<omega_home>/Agentik_Runtime/memory/graph.json` (graph).
+- **Config (this skill)** — `omega/Agentik_SSOT/skills/rag-route.md`.
+
+## Provider contract
+
+Mock-friendly. The provider receives `AgentRequest(role="rag-route", ...)`
+and is expected to return an `AgentResult` whose `artifacts["strategy"]` is
+one of the names registered with the router. Anything else is ignored —
+the router falls back to the heuristic.
+
+## Tests
+
+`omega/Agentik_Engine/tests/test_rag.py` exercises classification, the
+inner strategies, and the Corrective wrap end to end with `MockProvider`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentikos/omega-os",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Omega OS — installable agentic operating system with verified-completion orchestration. Event-sourced engine, 8-block rack, autonomous agents, MCP.",
   "bin": {
     "omega-os": "bin/omega-os.js"