@agentikos/omega-os 0.1.0 → 0.2.0

package/omega/Agentik_Engine/omega_engine/rag/router.py

@@ -0,0 +1,110 @@
+"""RAGRouter — classifies a query and picks the right inner strategy, then
+wraps the result in the Corrective envelope.
+
+Routing happens in two steps:
+  1. A cheap heuristic ("does the query look relational? mention an image
+     or PDF? have a 'why/how' shape?") gives a default.
+  2. The provider (role "rag-route") gets a chance to override; its choice
+     wins when it picks one of the registered strategies.
+
+The Corrective envelope wraps every dispatch — that's the project's stance:
+"check / recheck until 100%" applied to retrieval (ARCHITECTURE.md §7).
+"""
+from __future__ import annotations
+
+import re
+from typing import Iterable
+
+from omega_engine.provider import AgentProvider, AgentRequest
+from omega_engine.rag.base import RetrievalResult, Retriever
+from omega_engine.rag.corrective import CorrectiveRetriever
+
+
+_GRAPH_HINTS = re.compile(
+    r"\b(depend|related|connection|who|graph|owner|"
+    r"between|link|relation|adjacent|connected)\b",
+    re.IGNORECASE,
+)
+_MULTIMODAL_HINTS = re.compile(
+    r"\b(image|picture|screenshot|diagram|pdf|figure|chart|photo)\b",
+    re.IGNORECASE,
+)
+_AGENTIC_HINTS = re.compile(
+    r"\b(why|how|explain|compare|trace|step by step|deep dive)\b",
+    re.IGNORECASE,
+)
+
+
+class RAGRouter:
+    """Routes a query to one of the registered strategies, then wraps in CRAG."""
+
+    def __init__(
+        self,
+        strategies: dict[str, Retriever],
+        provider: AgentProvider,
+        *,
+        default: str = "hybrid",
+        corrective: bool = True,
+        threshold: float = 70.0,
+        max_retries: int = 2,
+    ) -> None:
+        if not strategies:
+            raise ValueError("RAGRouter needs at least one strategy")
+        self.strategies = dict(strategies)
+        self.provider = provider
+        self.default = default if default in self.strategies else next(iter(self.strategies))
+        self.corrective = corrective
+        self.threshold = threshold
+        self.max_retries = max_retries
+
+    def classify(self, query: str) -> str:
+        """Pick a strategy name. Heuristic first, provider may override."""
+        # 1. Cheap heuristic — works with no provider.
+        heuristic = self.default
+        if "multimodal" in self.strategies and _MULTIMODAL_HINTS.search(query):
+            heuristic = "multimodal"
+        elif "graph" in self.strategies and _GRAPH_HINTS.search(query):
+            heuristic = "graph"
+        elif "agentic" in self.strategies and _AGENTIC_HINTS.search(query):
+            heuristic = "agentic"
+
+        # 2. Provider override. If it returns a non-registered strategy, we
+        # ignore it (never trust a free-form provider blindly).
+        try:
+            result = self.provider.run(AgentRequest(
+                role="rag-route",
+                prompt=f"Classify retrieval strategy for: {query}",
+                context={
+                    "query": query,
+                    "available": sorted(self.strategies.keys()),
+                    "heuristic": heuristic,
+                },
+            ))
+            chosen = (result.artifacts or {}).get("strategy")
+            if isinstance(chosen, str) and chosen in self.strategies:
+                return chosen
+        except Exception:
+            # Provider misbehaved — keep the heuristic, never crash retrieval.
+            pass
+        return heuristic
+
+    def retrieve(self, query: str, k: int = 5) -> RetrievalResult:
+        name = self.classify(query)
+        inner = self.strategies[name]
+        if self.corrective:
+            wrapped = CorrectiveRetriever(
+                inner,
+                self.provider,
+                threshold=self.threshold,
+                max_retries=self.max_retries,
+            )
+            result = wrapped.retrieve(query, k=k)
+            # Surface the chosen inner strategy in the result for observability.
+            result.strategy = f"router({name})->{result.strategy}"
+            return result
+        result = inner.retrieve(query, k=k)
+        result.strategy = f"router({name})->{result.strategy}"
+        return result
+
+    def names(self) -> Iterable[str]:
+        return self.strategies.keys()

package/omega/Agentik_Engine/omega_engine/reducer.py

@@ -63,14 +63,32 @@ def reduce(state: Optional[TaskState], event: Event) -> TaskState:
     return _TRANSITIONS[key]
 
 
-def reduce_task(events: Iterable[Event]) -> TaskState:
+def reduce_task(events: Iterable[Event],
+                initial: Optional[TaskState] = None) -> TaskState:
     """Fold an ordered event stream into the current task state.
 
-    The events MUST be ordered (the Event Store returns them by `ts, id`).
+    The events MUST be ordered (the Event Store returns them by rowid).
+    `initial` lets a snapshot-aware caller start the fold from a known state
+    (`store.events_since_snapshot` + `snap.state`) instead of from genesis.
     """
-    state: Optional[TaskState] = None
+    state: Optional[TaskState] = initial
     for ev in events:
         state = reduce(state, ev)
     if state is None:
         raise IllegalTransition("empty event stream — task never created")
     return state
+
+
+def reduce_task_fast(store, task_id: str) -> TaskState:
+    """Reduce a task using its latest snapshot if available, else full replay.
+
+    Bounded reduction time on a long event log. Correctness is identical to
+    `reduce_task(store.events_for(task_id))`.
+    """
+    snap = store.latest_snapshot(task_id)
+    if snap is None:
+        return reduce_task(store.events_for(task_id))
+    events_after = store.events_since_snapshot(task_id)
+    if not events_after:
+        return snap["state"]
+    return reduce_task(events_after, initial=snap["state"])

package/omega/Agentik_Engine/omega_engine/store.py

@@ -47,6 +47,18 @@ CREATE TABLE IF NOT EXISTS events (
 );
 CREATE INDEX IF NOT EXISTS idx_events_task ON events(task_id, ts, id);
 CREATE INDEX IF NOT EXISTS idx_events_ts   ON events(ts, id);
+
+-- Snapshots: bounded reduction time on a growing log. A snapshot captures the
+-- reduced state of a task at a given event rowid; later reductions can start
+-- from the snapshot instead of replaying from genesis.
+CREATE TABLE IF NOT EXISTS snapshots (
+    task_id          TEXT NOT NULL,
+    state            TEXT NOT NULL,
+    ts               REAL NOT NULL,
+    last_event_rowid INTEGER NOT NULL,
+    PRIMARY KEY (task_id, ts)
+);
+CREATE INDEX IF NOT EXISTS idx_snapshots_task ON snapshots(task_id, ts DESC);
 """
 
 
@@ -88,10 +100,58 @@ class SQLiteStore(EventStore):
         cur = self._conn.execute("SELECT DISTINCT task_id FROM events")
         return [r["task_id"] for r in cur.fetchall()]
 
+    # --- snapshots --------------------------------------------------------
+    # Snapshots are an optional optimisation. Correctness depends only on
+    # events; snapshots merely bound reduction time as the log grows.
+
+    def snapshot(self, task_id: str) -> dict | None:
+        """Capture the current reduced state of a task at the latest event.
+        Returns the snapshot row, or None if the task has no events."""
+        cur = self._conn.execute(
+            "SELECT rowid FROM events WHERE task_id = ? ORDER BY rowid DESC LIMIT 1",
+            (task_id,),
+        )
+        row = cur.fetchone()
+        if not row:
+            return None
+        last_rowid = row[0]
+        # Local import to keep `store` importable without `reducer`-time deps.
+        from omega_engine.reducer import reduce_task
+        events = self.events_for(task_id)
+        state = reduce_task(events)
+        ts = events[-1].ts
+        self._conn.execute(
+            "INSERT OR REPLACE INTO snapshots (task_id, state, ts, last_event_rowid) "
+            "VALUES (?, ?, ?, ?)",
+            (task_id, state.value, ts, last_rowid),
+        )
+        return {"task_id": task_id, "state": state, "ts": ts,
+                "last_event_rowid": last_rowid}
+
+    def latest_snapshot(self, task_id: str) -> dict | None:
+        """Latest snapshot for a task, or None."""
+        cur = self._conn.execute(
+            "SELECT state, ts, last_event_rowid FROM snapshots "
+            "WHERE task_id = ? ORDER BY ts DESC LIMIT 1",
+            (task_id,),
+        )
+        row = cur.fetchone()
+        if not row:
+            return None
+        from omega_engine.task import TaskState
+        return {"state": TaskState(row["state"]), "ts": row["ts"],
+                "last_event_rowid": row["last_event_rowid"]}
+
+    def events_since_snapshot(self, task_id: str) -> list[Event]:
+        """Events appended since the latest snapshot, or all events if none."""
+        snap = self.latest_snapshot(task_id)
+        if not snap:
+            return self.events_for(task_id)
+        cur = self._conn.execute(
+            "SELECT * FROM events WHERE task_id = ? AND rowid > ? ORDER BY rowid",
+            (task_id, snap["last_event_rowid"]),
+        )
+        return [Event.from_row(dict(r)) for r in cur.fetchall()]
+
     def close(self) -> None:
         self._conn.close()
-
-# NOTE — snapshotting. An append-only log grows without bound. A future
-# `snapshots` table (state of every task at a checkpoint ts) lets `reduce_task`
-# start from the last snapshot instead of replaying from genesis. Snapshots live
-# in Agentik_Runtime/snapshots/. Not required for correctness — only for scale.

package/omega/Agentik_Engine/omega_engine/sync.py

@@ -0,0 +1,304 @@
+"""SST → provider projection — the `omega sync` engine.
+
+The SSOT is provider-neutral. Each provider adapter compiles
+`Agentik_SSOT/` into that provider's native shape. Re-running `omega sync` is
+idempotent: same SSOT in, same projection out — so the SSOT remains the only
+hand-edited surface.
+
+Today only the Claude Code adapter is fully wired. GLM / OpenAI / DeepSeek
+providers consume the SSOT directly via API calls and have no on-disk native
+layout, so their adapters log a no-op message. New providers add one adapter
+file; the SSOT does not change.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Iterable, Protocol, runtime_checkable
+
+
+def _omega_home(explicit: str | Path | None = None) -> Path:
+    return Path(explicit or os.environ.get("OMEGA_HOME", str(Path.home() / "Omega")))
+
+
+# --------------------------------------------------------------------------
+# Provider adapter contract
+# --------------------------------------------------------------------------
+
+
+@runtime_checkable
+class ProviderAdapter(Protocol):
+    """Each provider exposes a `project(omega_home)` that writes its native layout."""
+
+    id: str
+
+    def project(self, omega_home: Path) -> dict[str, Any]: ...
+
+
+class _StubAdapter:
+    """Adapter that has no on-disk native layout — logs and returns metadata."""
+
+    def __init__(self, provider_id: str, reason: str) -> None:
+        self.id = provider_id
+        self._reason = reason
+
+    def project(self, omega_home: Path) -> dict[str, Any]:
+        msg = f"[sync] {self.id}: {self._reason}"
+        print(msg)
+        return {"provider": self.id, "projected": False, "reason": self._reason}
+
+
+# --------------------------------------------------------------------------
+# Claude Code adapter — the only fully wired one for now
+# --------------------------------------------------------------------------
+
+
+class ClaudeCodeAdapter:
+    """Project the SSOT into Claude Code's native `.claude/` layout.
+
+    Native target tree (idempotent):
+        <target>/skills/<id>/SKILL.md
+        <target>/commands/<id>.md
+        <target>/agents/<id>.md
+        <target>/.mcp.json                       { "mcpServers": { ... } }
+        <target>/settings.json                   { ..., "hooks": {...} }
+
+    The SSOT is never modified — the adapter is one-way (SSOT → projection).
+    Default target: `<omega_home>/Agentik_AI/providers/claude-code/.claude/`.
+    """
+
+    id = "claude-code"
+
+    def __init__(self, target: str | Path | None = None) -> None:
+        self._explicit_target = Path(target) if target else None
+
+    # ----- helpers -------------------------------------------------------
+
+    def target_dir(self, omega_home: Path) -> Path:
+        if self._explicit_target is not None:
+            return self._explicit_target
+        return omega_home / "Agentik_AI" / "providers" / "claude-code" / ".claude"
+
+    @staticmethod
+    def _ensure(d: Path) -> Path:
+        d.mkdir(parents=True, exist_ok=True)
+        return d
+
+    @staticmethod
+    def _stem(path: Path) -> str:
+        return path.stem
+
+    # ----- skills / commands / agents (markdown surfaces) ----------------
+
+    def _project_markdown_dir(
+        self,
+        src: Path,
+        out_root: Path,
+        layout: str,  # "skill" | "command" | "agent"
+    ) -> list[str]:
+        """Copy `src/*.md` to the native layout. Returns list of written paths."""
+        if not src.is_dir():
+            return []
+        out_root = self._ensure(out_root)
+        written: list[str] = []
+        for md in sorted(src.glob("*.md")):
+            stem = self._stem(md)
+            if layout == "skill":
+                dest_dir = self._ensure(out_root / stem)
+                dest = dest_dir / "SKILL.md"
+            else:
+                dest = out_root / f"{stem}.md"
+            dest.write_text(md.read_text())
+            written.append(str(dest.relative_to(out_root.parent)))
+        return written
+
+    # ----- MCP config (.mcp.json) ---------------------------------------
+
+    def _project_mcp(self, omega_home: Path, out_root: Path) -> dict[str, Any]:
+        """Compile mcp-config.yaml + the tool registry → Claude Code .mcp.json.
+
+        Claude Code expects: { "mcpServers": { "<id>": { "command": "...",
+                                                          "args": [...],
+                                                          "env": {...} } } }
+        We resolve `command` from the tool registry invoke path when available.
+        """
+        try:
+            import yaml
+        except ImportError:
+            return {}
+
+        cfg_path = omega_home / "Agentik_SSOT" / "mcp" / "mcp-config.yaml"
+        catalog_path = omega_home / "Agentik_SSOT" / "mcp" / "mcp-catalog.yaml"
+
+        cfg: dict[str, Any] = {}
+        if cfg_path.exists():
+            cfg = yaml.safe_load(cfg_path.read_text()) or {}
+
+        catalog_by_id: dict[str, dict[str, Any]] = {}
+        if catalog_path.exists():
+            catalog = yaml.safe_load(catalog_path.read_text()) or {}
+            for e in catalog.get("catalog") or []:
+                catalog_by_id[str(e.get("id"))] = e
+
+        # The tool registry tells us where the binary is for each MCP id.
+        from omega_engine.tools import ToolRegistry  # local import — avoid cycle
+        reg = ToolRegistry.load(omega_home)
+        tool_by_id = {t.name: t for t in reg.list()}
+
+        mcp_servers: dict[str, Any] = {}
+        for server in cfg.get("servers") or []:
+            sid = str(server.get("id", "")).strip()
+            if not sid or not server.get("enabled", True):
+                continue
+            entry: dict[str, Any] = {}
+            tool = tool_by_id.get(sid)
+            cat = catalog_by_id.get(sid, {})
+            install = cat.get("install") or {}
+
+            # Prefer the locally installed binary; fall back to `npx <package>`.
+            if tool and tool.invoke:
+                entry["command"] = str(omega_home / tool.invoke)
+                entry["args"] = list(server.get("args") or [])
+            elif install.get("method") == "npx" and install.get("package"):
+                entry["command"] = "npx"
+                entry["args"] = ["-y", str(install["package"]), *(server.get("args") or [])]
+            else:
+                # nothing to invoke — skip rather than write a half-broken entry
+                continue
+
+            from_server = list(server.get("secret_refs") or [])
+            from_tool = list(tool.secret_refs) if tool else []
+            secret_refs = from_server or from_tool
+            if secret_refs:
+                # Claude Code's .mcp.json supports an `env` block; we project
+                # secret refs by name (the value is filled at runtime from the
+                # vault, never written to disk in plaintext).
+                entry["env"] = {ref: f"${{{ref}}}" for ref in secret_refs}
+
+            mcp_servers[sid] = entry
+
+        out_root = self._ensure(out_root)
+        target = out_root / ".mcp.json"
+        payload = {"mcpServers": mcp_servers}
+        target.write_text(json.dumps(payload, indent=2) + "\n")
+        return payload
+
+    # ----- hooks → settings.json -----------------------------------------
+
+    def _project_hooks(self, omega_home: Path, out_root: Path) -> dict[str, Any]:
+        """Merge `Agentik_SSOT/hooks/*` into <target>/settings.json `hooks`.
+
+        Each file under hooks/ is one of:
+          - *.json — already in Claude Code hook shape; merged shallow into hooks
+          - *.yaml/*.yml — same shape, parsed as YAML
+        Unknown extensions are ignored.
+        """
+        hooks_dir = omega_home / "Agentik_SSOT" / "hooks"
+        out_root = self._ensure(out_root)
+        settings_file = out_root / "settings.json"
+
+        settings: dict[str, Any] = {}
+        if settings_file.exists():
+            try:
+                settings = json.loads(settings_file.read_text() or "{}")
+            except json.JSONDecodeError:
+                settings = {}
+
+        hooks_block: dict[str, Any] = dict(settings.get("hooks") or {})
+
+        if hooks_dir.is_dir():
+            import yaml
+            for path in sorted(hooks_dir.iterdir()):
+                if not path.is_file():
+                    continue
+                if path.suffix == ".json":
+                    try:
+                        data = json.loads(path.read_text() or "{}")
+                    except json.JSONDecodeError:
+                        continue
+                elif path.suffix in {".yaml", ".yml"}:
+                    data = yaml.safe_load(path.read_text() or "") or {}
+                else:
+                    continue
+                if not isinstance(data, dict):
+                    continue
+                for k, v in data.items():
+                    hooks_block[k] = v
+
+        settings["hooks"] = hooks_block
+        settings_file.write_text(json.dumps(settings, indent=2) + "\n")
+        return hooks_block
+
+    # ----- entry point ---------------------------------------------------
+
+    def project(self, omega_home: Path) -> dict[str, Any]:
+        target = self.target_dir(omega_home)
+        self._ensure(target)
+        ssot = omega_home / "Agentik_SSOT"
+
+        skills = self._project_markdown_dir(ssot / "skills", target / "skills", "skill")
+        commands = self._project_markdown_dir(ssot / "commands", target / "commands", "command")
+        agents = self._project_markdown_dir(ssot / "agents", target / "agents", "agent")
+        mcp = self._project_mcp(omega_home, target)
+        hooks = self._project_hooks(omega_home, target)
+
+        return {
+            "provider": self.id,
+            "projected": True,
+            "target": str(target),
+            "skills_written": len(skills),
+            "commands_written": len(commands),
+            "agents_written": len(agents),
+            "mcp_servers": len(mcp.get("mcpServers", {})) if isinstance(mcp, dict) else 0,
+            "hooks": list(hooks.keys()),
+        }
+
+
+# --------------------------------------------------------------------------
+# Sync engine
+# --------------------------------------------------------------------------
+
+
+def _active_providers(omega_home: Path) -> list[str]:
+    """Read Agentik_Providers/registry.yaml; default to [claude] if missing."""
+    try:
+        import yaml
+    except ImportError:
+        return ["claude"]
+    path = omega_home / "Agentik_Providers" / "registry.yaml"
+    if not path.exists():
+        return ["claude"]
+    data = yaml.safe_load(path.read_text()) or {}
+    return [str(p.get("id")) for p in data.get("providers") or [] if p.get("id")]
+
+
+class SyncEngine:
+    """Run every active provider's adapter against the SSOT."""
+
+    def __init__(self, adapters: Iterable[ProviderAdapter] | None = None) -> None:
+        self._explicit = list(adapters) if adapters is not None else None
+
+    def adapters_for(self, omega_home: Path) -> list[ProviderAdapter]:
+        if self._explicit is not None:
+            return list(self._explicit)
+        active = _active_providers(omega_home)
+        result: list[ProviderAdapter] = []
+        for pid in active:
+            if pid == "claude":
+                result.append(ClaudeCodeAdapter())
+            else:
+                # GLM / OpenAI / DeepSeek don't have a native on-disk format;
+                # MCP/skills/commands are passed via API. Document this.
+                result.append(_StubAdapter(
+                    pid,
+                    "no native projection — used directly via API",
+                ))
+        return result
+
+    def sync_all(self, omega_home: str | Path | None = None) -> list[dict[str, Any]]:
+        home = _omega_home(omega_home)
+        outcomes: list[dict[str, Any]] = []
+        for adapter in self.adapters_for(home):
+            outcomes.append(adapter.project(home))
+        return outcomes