@agentikos/omega-os 0.1.0 → 0.19.5

package/omega/Agentik_Engine/omega_engine/sync.py

@@ -0,0 +1,445 @@
+"""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` AND `src/<name>/SKILL.md` to the native layout.
+
+        Both shapes are supported in the SSOT:
+          1. Flat:      ``Agentik_SSOT/skills/pursue.md``
+          2. Directory: ``Agentik_SSOT/skills/pursue/SKILL.md`` (+ optional
+             supporting files like ``scripts/`` or ``examples/``).
+
+        Directory-based skills are the Claude Code idiom — supporting files
+        sit next to ``SKILL.md`` and the agent can reference them via
+        ``${CLAUDE_SKILL_DIR}``. We copy the whole directory verbatim so
+        those references resolve at the destination.
+
+        Returns the list of written paths (relative to ``out_root.parent``).
+        """
+        if not src.is_dir():
+            return []
+        out_root = self._ensure(out_root)
+        written: list[str] = []
+
+        # 1. flat: src/<name>.md
+        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)))
+
+        # 2. directory: src/<name>/SKILL.md (+ supporting files)
+        if layout == "skill":
+            import shutil as _sh
+            for child in sorted(src.iterdir()):
+                if not child.is_dir():
+                    continue
+                skill_md = child / "SKILL.md"
+                if not skill_md.exists():
+                    continue
+                dest_dir = self._ensure(out_root / child.name)
+                # Copy SKILL.md plus any supporting files (scripts/, etc.)
+                for item in child.iterdir():
+                    target = dest_dir / item.name
+                    if item.is_dir():
+                        if target.exists():
+                            _sh.rmtree(target)
+                        _sh.copytree(item, target)
+                    else:
+                        target.write_text(item.read_text())
+                written.append(
+                    str((dest_dir / "SKILL.md").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
+
+    # ----- bridge to ~/.claude/ (the dir Claude Code actually reads) -----
+    #
+    # Why this exists
+    # ---------------
+    # ``project()`` writes the SSOT-derived layout into
+    # ``$OMEGA_HOME/Agentik_AI/providers/claude-code/.claude/`` — that tree
+    # stays under OmegaOS for portability (vault backup, audit trail, you
+    # name it). But the ``claude`` CLI on a real workstation reads skills /
+    # commands / agents / .mcp.json from ``~/.claude/`` (user-global) and
+    # ``.claude/`` (project-local).
+    #
+    # Without a bridge, the 24 SSOT skills NEVER become invokable slash
+    # commands. ``link_to_user_claude(home)`` is that bridge: for every
+    # skill we projected, we create a SYMLINK at
+    # ``~/.claude/skills/<id> → $OMEGA_HOME/.../skills/<id>``. This means:
+    #   - editing the SSOT + re-running ``omega sync`` updates the
+    #     skill in place (no duplicate copies),
+    #   - removing the SSOT skill nukes the symlink on the next sync,
+    #   - the operator's existing ``~/.claude/skills/<other>/`` are
+    #     untouched (we only manage entries whose targets are inside
+    #     ``$OMEGA_HOME``).
+
+    def link_to_user_claude(
+        self, omega_home: Path,
+        *,
+        user_claude: Path | None = None,
+    ) -> dict[str, Any]:
+        """Bridge the projected tree into ``~/.claude/`` via symlinks.
+
+        Returns ``{linked_skills, linked_commands, linked_agents,
+                   removed: [stale_paths]}``. Idempotent.
+        """
+        import os as _os
+        user = Path(user_claude) if user_claude else Path.home() / ".claude"
+        target = self.target_dir(omega_home)
+        out: dict[str, Any] = {
+            "user_claude": str(user),
+            "linked_skills": 0,
+            "linked_commands": 0,
+            "linked_agents": 0,
+            "removed": [],
+        }
+        # The provider-tree target must exist first (project() was called).
+        if not target.is_dir():
+            return out
+
+        for layout in ("skills", "commands", "agents"):
+            src_root = target / layout
+            if not src_root.is_dir():
+                continue
+            dest_root = self._ensure(user / layout)
+
+            # Remove stale symlinks we used to manage. A "managed" symlink
+            # points anywhere inside `target`. Real dirs and symlinks owned
+            # by the user are NEVER touched.
+            for child in list(dest_root.iterdir()):
+                if not child.is_symlink():
+                    continue
+                try:
+                    realpath = child.resolve()
+                except OSError:
+                    continue
+                # Only nuke our own — points inside the OmegaOS tree.
+                if str(realpath).startswith(str(target)) and not (src_root / child.name).exists():
+                    try:
+                        child.unlink()
+                        out["removed"].append(str(child))
+                    except OSError:
+                        pass
+
+            for src in sorted(src_root.iterdir()):
+                if not src.is_dir() and not src.suffix == ".md":
+                    continue
+                dest = dest_root / src.name
+                if dest.is_symlink():
+                    try:
+                        dest.unlink()
+                    except OSError:
+                        pass
+                elif dest.exists():
+                    # Don't clobber the user's hand-written content.
+                    continue
+                try:
+                    _os.symlink(src, dest)
+                    out[f"linked_{layout}"] += 1
+                except OSError:
+                    # Some filesystems (Windows WSL crossings) refuse symlinks;
+                    # in that case the user can re-run with --copy.
+                    pass
+        return out
+
+    # ----- 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)
+
+        # Bridge to ~/.claude/ so the projected skills actually become
+        # invokable slash-commands. Toggleable via env var (off → only the
+        # provider tree is written; user opts in later with `omega skill link`).
+        link_info: dict[str, Any] = {}
+        import os as _os
+        if _os.environ.get("OMEGA_SYNC_NO_LINK") != "1":
+            try:
+                link_info = self.link_to_user_claude(omega_home)
+            except OSError:
+                link_info = {}
+
+        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()),
+            "linked_to_user_claude": link_info,
+        }
+
+
+# --------------------------------------------------------------------------
+# 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

package/omega/Agentik_Engine/omega_engine/telegram_history.py

@@ -0,0 +1,260 @@
+"""Per-topic conversation history — fixes the "bot has no memory" bug.
+
+When the user types in a Telegram topic, the Telegram daemon used to call
+``run_mission(intent=text)`` with ONLY the new message. The Oracle saw a
+brand-new mission every turn — no idea what the user was actually talking
+about. The user's reply to a follow-up question landed without context.
+
+This module is the fix. It persists every inbound + outbound message per
+topic to a SQLite table; the daemon prepends the last N exchanges to the
+envelope's user message so the agent always has the conversation.
+
+Layout
+------
+``$OMEGA_HOME/Agentik_Runtime/telegram-history.db``
+
+::
+
+    CREATE TABLE messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        topic_id INTEGER NOT NULL,        -- forum topic id (or 0 for DM root)
+        role TEXT NOT NULL,                -- 'user' | 'bot'
+        text TEXT NOT NULL,
+        message_id INTEGER,                -- Telegram's own message_id
+        timestamp INTEGER NOT NULL
+    );
+
+Two indexes: one for per-topic recency, one for full-text-ish search.
+
+Public API
+----------
+``record_inbound(home, topic_id, text, message_id=None)``
+``record_outbound(home, topic_id, text, message_id=None)``
+``recent_messages(home, topic_id, limit=20) -> list[Message]``
+``build_context_prompt(home, topic_id, new_intent, limit=10) -> str``
+"""
+from __future__ import annotations
+
+import os
+import sqlite3
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterable
+
+
+@dataclass
+class Message:
+    id: int
+    topic_id: int
+    role: str           # "user" | "bot"
+    text: str
+    message_id: int | None
+    timestamp: int
+
+
+def _db_path(omega_home: str | Path) -> Path:
+    home = Path(omega_home)
+    runtime = home / "Agentik_Runtime"
+    runtime.mkdir(parents=True, exist_ok=True)
+    return runtime / "telegram-history.db"
+
+
+def _connect(omega_home: str | Path) -> sqlite3.Connection:
+    conn = sqlite3.connect(str(_db_path(omega_home)))
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS messages (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            topic_id INTEGER NOT NULL,
+            role TEXT NOT NULL CHECK(role IN ('user', 'bot')),
+            text TEXT NOT NULL,
+            message_id INTEGER,
+            timestamp INTEGER NOT NULL
+        )
+    """)
+    conn.execute("""
+        CREATE INDEX IF NOT EXISTS idx_messages_topic_time
+            ON messages(topic_id, timestamp DESC)
+    """)
+    return conn
+
+
+def _record(
+    omega_home: str | Path,
+    *,
+    topic_id: int,
+    role: str,
+    text: str,
+    message_id: int | None,
+) -> int:
+    """Persist one message. Returns the rowid."""
+    if role not in ("user", "bot"):
+        raise ValueError(f"role must be 'user' or 'bot', got {role!r}")
+    conn = _connect(omega_home)
+    try:
+        cur = conn.execute(
+            "INSERT INTO messages (topic_id, role, text, message_id, timestamp) "
+            "VALUES (?, ?, ?, ?, ?)",
+            (int(topic_id), role, text, message_id, int(time.time())),
+        )
+        conn.commit()
+        return int(cur.lastrowid)
+    finally:
+        conn.close()
+
+
+def record_inbound(
+    omega_home: str | Path,
+    topic_id: int,
+    text: str,
+    *,
+    message_id: int | None = None,
+) -> int:
+    """The user just sent this in the topic. Persist it."""
+    return _record(omega_home, topic_id=topic_id, role="user",
+                   text=text, message_id=message_id)
+
+
+def record_outbound(
+    omega_home: str | Path,
+    topic_id: int,
+    text: str,
+    *,
+    message_id: int | None = None,
+) -> int:
+    """The bot just posted this. Persist it so the next turn has context."""
+    return _record(omega_home, topic_id=topic_id, role="bot",
+                   text=text, message_id=message_id)
+
+
+def recent_messages(
+    omega_home: str | Path,
+    topic_id: int,
+    *,
+    limit: int = 20,
+) -> list[Message]:
+    """Return the last ``limit`` messages for this topic, oldest first.
+
+    The query selects by timestamp DESC then reverses — gives us
+    chronological order with a hard cap.
+    """
+    conn = _connect(omega_home)
+    try:
+        rows = conn.execute(
+            "SELECT * FROM messages WHERE topic_id = ? "
+            "ORDER BY timestamp DESC, id DESC LIMIT ?",
+            (int(topic_id), int(limit)),
+        ).fetchall()
+    finally:
+        conn.close()
+    return [
+        Message(
+            id=int(r["id"]),
+            topic_id=int(r["topic_id"]),
+            role=str(r["role"]),
+            text=str(r["text"]),
+            message_id=(int(r["message_id"])
+                        if r["message_id"] is not None else None),
+            timestamp=int(r["timestamp"]),
+        )
+        for r in reversed(rows)
+    ]
+
+
+def build_context_prompt(
+    omega_home: str | Path,
+    topic_id: int,
+    new_intent: str,
+    *,
+    limit: int = 10,
+) -> str:
+    """Compose a context-aware intent for ``run_mission``.
+
+    Format::
+
+        [Conversation history in topic <id>]
+        user (10 min ago): previous message
+        bot (8 min ago):   previous reply
+        user (just now):   ${new_intent}
+
+        Respond to the user's latest message — the messages above are
+        the conversation so far in this topic; keep your answer
+        consistent with them.
+
+    If there's no prior history, returns ``new_intent`` unchanged so a
+    cold conversation behaves as before.
+    """
+    history = recent_messages(omega_home, topic_id, limit=limit)
+    if not history:
+        return new_intent
+
+    now = int(time.time())
+    lines: list[str] = [
+        f"[Conversation history in topic {topic_id}]"
+    ]
+    for msg in history:
+        delta = now - msg.timestamp
+        when = _humanise_age(delta)
+        lines.append(f"  {msg.role} ({when}): {msg.text}")
+
+    lines.append("")
+    lines.append(f"user (just now): {new_intent}")
+    lines.append("")
+    lines.append(
+        "Respond to the user's latest message — the messages above are "
+        "the conversation so far in this topic; keep your answer "
+        "consistent with them."
+    )
+    return "\n".join(lines)
+
+
+def _humanise_age(seconds: int) -> str:
+    """Format an age in seconds as a short human string."""
+    if seconds < 60:
+        return f"{seconds}s ago"
+    if seconds < 3600:
+        return f"{seconds // 60}m ago"
+    if seconds < 86400:
+        return f"{seconds // 3600}h ago"
+    return f"{seconds // 86400}d ago"
+
+
+def prune(
+    omega_home: str | Path,
+    *,
+    older_than_days: int = 90,
+) -> int:
+    """Drop messages older than ``older_than_days``. Returns rows removed."""
+    cutoff = int(time.time()) - older_than_days * 86400
+    conn = _connect(omega_home)
+    try:
+        cur = conn.execute(
+            "DELETE FROM messages WHERE timestamp < ?", (cutoff,)
+        )
+        conn.commit()
+        return int(cur.rowcount)
+    finally:
+        conn.close()
+
+
+def topic_stats(omega_home: str | Path) -> list[dict]:
+    """For the doctor: a one-row-per-topic summary."""
+    conn = _connect(omega_home)
+    try:
+        rows = conn.execute(
+            "SELECT topic_id, COUNT(*) AS n_msgs, "
+            "       MAX(timestamp) AS last_seen "
+            "FROM messages GROUP BY topic_id ORDER BY last_seen DESC"
+        ).fetchall()
+    finally:
+        conn.close()
+    return [
+        {
+            "topic_id": int(r["topic_id"]),
+            "messages": int(r["n_msgs"]),
+            "last_seen": int(r["last_seen"]),
+        }
+        for r in rows
+    ]