@agentikos/omega-os 0.1.0 → 0.19.5

package/omega/Agentik_Engine/omega_engine/completions.py

@@ -0,0 +1,260 @@
+"""Shell completion scripts for ``omega``.
+
+Generates bash + zsh + fish completion files from the live argparse tree
+so the file always reflects the current command surface — no hand-edited
+completion list to drift.
+
+Files land at:
+
+  * ``$OMEGA_HOME/Agentik_Tools/completions/omega.bash``
+  * ``$OMEGA_HOME/Agentik_Tools/completions/_omega``        (zsh)
+  * ``$OMEGA_HOME/Agentik_Tools/completions/omega.fish``
+
+The ``omega completions install`` CLI sources / symlinks them into the
+right place per shell. Idempotent.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class CommandNode:
+    """One node in the omega command tree."""
+    name: str
+    help_text: str = ""
+    subcommands: list["CommandNode"] = None  # type: ignore[assignment]
+
+    def __post_init__(self) -> None:
+        if self.subcommands is None:
+            self.subcommands = []
+
+
+def extract_tree(parser: argparse.ArgumentParser) -> CommandNode:
+    """Walk an argparse parser and produce a CommandNode tree."""
+    root = CommandNode(name="omega", help_text="Omega OS control CLI")
+    # The top-level parser has one subparsers action — find it.
+    for action in parser._actions:                              # noqa: SLF001
+        if isinstance(action, argparse._SubParsersAction):       # noqa: SLF001
+            for name, sub_parser in action.choices.items():
+                root.subcommands.append(_walk(name, sub_parser))
+            break
+    return root
+
+
+def _walk(name: str, parser: argparse.ArgumentParser) -> CommandNode:
+    node = CommandNode(name=name, help_text=(parser.description or "").strip())
+    for action in parser._actions:                              # noqa: SLF001
+        if isinstance(action, argparse._SubParsersAction):       # noqa: SLF001
+            for sub_name, sub_parser in action.choices.items():
+                node.subcommands.append(_walk(sub_name, sub_parser))
+            break
+    return node
+
+
+# ---------------------------------------------------------------------------
+# Bash
+# ---------------------------------------------------------------------------
+
+
+def render_bash(root: CommandNode) -> str:
+    """Generate a bash completion script for the command tree."""
+    # Build a flat map: "omega" → first-level subs;
+    #                  "omega <sub>" → that sub's children, etc.
+    lines: list[str] = [
+        "#!/usr/bin/env bash",
+        "# omega — bash completion (auto-generated by omega completions)",
+        "",
+        "_omega_complete() {",
+        "    local cur prev words cword",
+        "    _init_completion || return",
+        "",
+    ]
+
+    # We compute completion by walking COMP_WORDS skipping flags.
+    lines += [
+        '    local commands="' + " ".join(s.name for s in root.subcommands) + '"',
+        '    if [ $cword -eq 1 ]; then',
+        '        COMPREPLY=( $(compgen -W "$commands" -- "$cur") )',
+        '        return 0',
+        '    fi',
+    ]
+
+    for sub in root.subcommands:
+        if not sub.subcommands:
+            continue
+        children = " ".join(c.name for c in sub.subcommands)
+        lines += [
+            f'    if [ "${{words[1]}}" = "{sub.name}" ] && [ $cword -eq 2 ]; then',
+            f'        COMPREPLY=( $(compgen -W "{children}" -- "$cur") )',
+             '        return 0',
+             '    fi',
+        ]
+
+    lines += [
+        '    COMPREPLY=( $(compgen -f -- "$cur") )',
+        "}",
+        "complete -F _omega_complete omega",
+        "",
+    ]
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Zsh
+# ---------------------------------------------------------------------------
+
+
+def render_zsh(root: CommandNode) -> str:
+    """Generate a zsh completion script (uses _arguments / _describe)."""
+    lines: list[str] = [
+        "#compdef omega",
+        "# omega — zsh completion (auto-generated by omega completions)",
+        "",
+        "_omega() {",
+        "    local context state line",
+        "    typeset -A opt_args",
+        "",
+        '    _arguments -C \\',
+        "        '1: :->command' \\",
+        "        '*::arg:->args'",
+        "",
+        "    case $state in",
+        "        command)",
+        "            local -a commands",
+        "            commands=(",
+    ]
+    for sub in root.subcommands:
+        help_one = sub.help_text.split("\n")[0].replace("'", "'\\''")
+        lines.append(f"                '{sub.name}:{help_one[:60]}'")
+    lines += [
+        "            )",
+        "            _describe -t commands 'omega command' commands",
+        "            ;;",
+        "        args)",
+        "            case $line[1] in",
+    ]
+    for sub in root.subcommands:
+        if not sub.subcommands:
+            continue
+        lines += [
+            f"                {sub.name})",
+            "                    local -a subs",
+            "                    subs=(",
+        ]
+        for child in sub.subcommands:
+            help_one = child.help_text.split("\n")[0].replace("'", "'\\''")
+            lines.append(f"                        '{child.name}:{help_one[:60]}'")
+        lines += [
+            "                    )",
+            f"                    _describe -t subcommands '{sub.name}' subs",
+            "                    ;;",
+        ]
+    lines += [
+        "            esac",
+        "            ;;",
+        "    esac",
+        "}",
+        "",
+        "_omega \"$@\"",
+        "",
+    ]
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Fish
+# ---------------------------------------------------------------------------
+
+
+def render_fish(root: CommandNode) -> str:
+    """Generate a fish completion script."""
+    lines: list[str] = [
+        "# omega — fish completion (auto-generated by omega completions)",
+        "",
+    ]
+    for sub in root.subcommands:
+        desc = sub.help_text.split("\n")[0].replace("'", "\\'")[:60]
+        lines.append(
+            f"complete -c omega -n '__fish_use_subcommand' -a '{sub.name}' "
+            f"-d '{desc}'"
+        )
+    for sub in root.subcommands:
+        if not sub.subcommands:
+            continue
+        for child in sub.subcommands:
+            desc = child.help_text.split("\n")[0].replace("'", "\\'")[:60]
+            lines.append(
+                f"complete -c omega -n '__fish_seen_subcommand_from "
+                f"{sub.name}' -a '{child.name}' -d '{desc}'"
+            )
+    lines.append("")
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Install
+# ---------------------------------------------------------------------------
+
+
+def write_all(omega_home: str | Path, root: CommandNode) -> dict[str, Path]:
+    """Write all three completion files. Returns paths."""
+    out = Path(omega_home) / "Agentik_Tools" / "completions"
+    out.mkdir(parents=True, exist_ok=True)
+    bash = out / "omega.bash"
+    zsh = out / "_omega"
+    fish = out / "omega.fish"
+    bash.write_text(render_bash(root))
+    zsh.write_text(render_zsh(root))
+    fish.write_text(render_fish(root))
+    return {"bash": bash, "zsh": zsh, "fish": fish}
+
+
+def install_for_shell(
+    omega_home: str | Path, shell: str,
+) -> dict[str, str]:
+    """Hook the completion into the operator's shell.
+
+    For each shell we know the conventional install location:
+
+      bash → ``~/.bash_completion.d/omega`` (if it exists) or sourced
+             from ``~/.bashrc``
+      zsh  → ``~/.zsh/completion/_omega`` (fpath addition in ``~/.zshrc``)
+      fish → ``~/.config/fish/completions/omega.fish``
+
+    We never overwrite an existing operator file; we symlink. Returns a
+    summary dict.
+    """
+    home = Path(omega_home)
+    completions = home / "Agentik_Tools" / "completions"
+    if not completions.is_dir():
+        return {"status": "error",
+                "detail": f"{completions} does not exist — "
+                          "run `omega completions write` first"}
+    shell = shell.lower()
+    if shell == "bash":
+        target_dir = Path.home() / ".bash_completion.d"
+        target_dir.mkdir(parents=True, exist_ok=True)
+        link = target_dir / "omega"
+        src = completions / "omega.bash"
+    elif shell == "zsh":
+        target_dir = Path.home() / ".zsh" / "completion"
+        target_dir.mkdir(parents=True, exist_ok=True)
+        link = target_dir / "_omega"
+        src = completions / "_omega"
+    elif shell == "fish":
+        target_dir = Path.home() / ".config" / "fish" / "completions"
+        target_dir.mkdir(parents=True, exist_ok=True)
+        link = target_dir / "omega.fish"
+        src = completions / "omega.fish"
+    else:
+        return {"status": "error", "detail": f"unknown shell: {shell}"}
+
+    if link.is_symlink() or link.exists():
+        link.unlink()
+    link.symlink_to(src)
+    return {"status": "ok", "link": str(link), "src": str(src), "shell": shell}

package/omega/Agentik_Engine/omega_engine/costs.py

@@ -0,0 +1,100 @@
+"""Provider cost rate cards — turn token usage into $.
+
+The ``BillingAggregator`` already aggregates input/output tokens per
+account from the event log. This module multiplies by a per-provider
+rate card and surfaces $ in the CLI.
+
+Rate cards are kept in code (not a YAML the operator edits) because:
+
+  1. Anthropic / OpenAI / Zhipu publish public list prices.
+  2. An out-of-date rate card → wrong projections, but the underlying
+     usage numbers are unaffected. The risk is only in the dashboard,
+     not in any state we depend on.
+  3. We document the rate card date so the operator knows when it was
+     last refreshed.
+
+Updating the rate card is a one-line edit when a provider changes prices.
+The doctor surfaces "rate card from <date>; check if your provider has
+changed prices since" so it's never silent.
+
+NOTE: Rates here are USD per million tokens, current at the date below.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+RATE_CARD_DATE = "2026-05-23"
+
+
+@dataclass(frozen=True)
+class Rates:
+    """USD per MILLION tokens, input and output."""
+    input_per_million: float
+    output_per_million: float
+
+
+# Most-common models per provider. The model field on the event payload
+# determines which row we use; fall back to a sensible default per provider.
+_RATES: dict[str, dict[str, Rates]] = {
+    "claude": {
+        "claude-opus-4-7":   Rates(input_per_million=15.00, output_per_million=75.00),
+        "claude-sonnet-4-6": Rates(input_per_million= 3.00, output_per_million=15.00),
+        "claude-haiku-4-5":  Rates(input_per_million= 0.25, output_per_million= 1.25),
+        # fallback
+        "default":           Rates(input_per_million= 3.00, output_per_million=15.00),
+    },
+    "openai": {
+        "gpt-4o":        Rates(input_per_million= 2.50, output_per_million=10.00),
+        "gpt-4o-mini":   Rates(input_per_million= 0.15, output_per_million= 0.60),
+        "default":       Rates(input_per_million= 2.50, output_per_million=10.00),
+    },
+    "glm": {
+        "glm-4-plus":  Rates(input_per_million= 5.00, output_per_million=15.00),
+        "glm-4-flash": Rates(input_per_million= 0.00, output_per_million= 0.00),
+        "default":     Rates(input_per_million= 1.00, output_per_million= 2.00),
+    },
+    "deepseek": {
+        "deepseek-chat":      Rates(input_per_million=0.14, output_per_million=0.28),
+        "deepseek-reasoner":  Rates(input_per_million=0.55, output_per_million=2.19),
+        "default":            Rates(input_per_million=0.14, output_per_million=0.28),
+    },
+}
+
+
+def estimate_cost(
+    provider: str,
+    *,
+    input_tokens: int,
+    output_tokens: int,
+    model: str = "default",
+) -> float:
+    """Return cost in USD for the given usage."""
+    table = _RATES.get(provider.lower())
+    if not table:
+        return 0.0
+    rates = table.get(model) or table["default"]
+    return (
+        (input_tokens / 1_000_000) * rates.input_per_million
+        + (output_tokens / 1_000_000) * rates.output_per_million
+    )
+
+
+def project_account_cost(
+    provider: str, account_totals: dict, model: str = "default",
+) -> float:
+    """Take a BillingAggregator row + a provider hint, return $."""
+    return estimate_cost(
+        provider,
+        input_tokens=int(account_totals.get("input_tokens", 0)),
+        output_tokens=int(account_totals.get("output_tokens", 0)),
+        model=model,
+    )
+
+
+def rate_card_summary() -> dict:
+    """For the doctor: the date + which providers we cover."""
+    return {
+        "date": RATE_CARD_DATE,
+        "providers": sorted(_RATES.keys()),
+    }

package/omega/Agentik_Engine/omega_engine/daemons/__init__.py

@@ -0,0 +1,14 @@
+"""24/7 service layer for Omega OS.
+
+Three long-running daemons backed by systemd user units:
+
+* :mod:`omega_engine.daemons.engine`      — the event-store keeper + heartbeat
+* :mod:`omega_engine.daemons.telegram`    — long-polls Telegram, routes inbound
+  messages to either the autonomous supervisor or :func:`run_mission`
+* :mod:`omega_engine.daemons.autonomous`  — runs the autonomous-agent
+  supervisor
+
+Each daemon exposes a ``main()`` entry point invoked by ``omega daemon <name>``.
+"""
+
+__all__ = ["engine", "telegram", "autonomous"]

package/omega/Agentik_Engine/omega_engine/daemons/autonomous.py

@@ -0,0 +1,56 @@
+"""The autonomous-agent daemon.
+
+Loads every charter under
+``$OMEGA_HOME/Agentik_Orchestration/autonomous/``, builds an
+:class:`omega_engine.autonomous.AutonomousSupervisor`, and runs it until
+SIGTERM/SIGINT.
+
+This daemon owns the cron + event triggers. Channel triggers are routed in
+from the Telegram daemon; webhook triggers are awakened by whatever HTTP shim
+your operator put in front (the supervisor exposes ``wake_webhook`` for them).
+"""
+from __future__ import annotations
+
+import logging
+import os
+
+from omega_engine.autonomous import build_supervisor_from_home
+
+logger = logging.getLogger("omega.daemon.autonomous")
+
+
+def main() -> int:
+    logging.basicConfig(
+        level=os.environ.get("OMEGA_LOG_LEVEL", "INFO"),
+        format="%(asctime)s %(name)s %(levelname)s %(message)s",
+    )
+    # Optional outbound Telegram bridge — used by the supervisor to deliver
+    # progress + reports for missions it spawns. Best-effort: missing vault
+    # token means "no Telegram", not "abort".
+    telegram = None
+    try:
+        from omega_engine.telegram import TelegramBridge
+        telegram = TelegramBridge.from_vault()
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("autonomous daemon: no outbound Telegram (%s)", exc)
+
+    supervisor = build_supervisor_from_home(telegram=telegram)
+    charters = supervisor.charters()
+    if not charters:
+        logger.warning(
+            "autonomous daemon: no charters found — idling. Drop a YAML in "
+            "Agentik_Orchestration/autonomous/ and restart."
+        )
+    else:
+        for c in charters:
+            logger.info("autonomous: loaded charter %s (%s, trigger=%s)",
+                        c.id, c.role, c.trigger_type)
+
+    # blocks until SIGTERM / SIGINT (the supervisor wires both)
+    supervisor.run()
+    logger.info("autonomous daemon stopped")
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

package/omega/Agentik_Engine/omega_engine/daemons/engine.py

@@ -0,0 +1,236 @@
+"""The engine daemon — keeps the event store alive 24/7.
+
+What it actually does:
+
+* opens ``$OMEGA_HOME/Agentik_Runtime/eventlog/omega.db`` (WAL-mode SQLite)
+* periodically appends a ``system.heartbeat`` event so the store always has a
+  fresh "this engine is alive" anchor
+* exposes a small stdlib HTTP API on ``127.0.0.1:OMEGA_ENGINE_PORT`` so the
+  other daemons (telegram, autonomous) can ask the engine to run a mission
+  inside *one* process tree (avoids each daemon spinning its own duplicate
+  executor stack)
+* exits cleanly on SIGTERM / SIGINT (systemd `Restart=always` handles the rest)
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import signal
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+from omega_engine.bus import EventBus
+from omega_engine.events import Event, EventType
+from omega_engine.store import SQLiteStore
+
+logger = logging.getLogger("omega.daemon.engine")
+
+# the heartbeat event lives outside the task FSM, so we reuse the HEARTBEAT
+# event type but with a system-level task id.
+_SYSTEM_TASK_ID = "system.engine"
+_HEARTBEAT_PERIOD_S = 60.0
+
+
+def _omega_home() -> Path:
+    return Path(os.environ.get("OMEGA_HOME", str(Path.home() / "Omega")))
+
+
+def _store_path(home: Path) -> Path:
+    return home / "Agentik_Runtime" / "eventlog" / "omega.db"
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# HTTP API — local-only mission dispatch
+# ─────────────────────────────────────────────────────────────────────────────
+
+class _EngineHandler(BaseHTTPRequestHandler):
+    """A tiny REST-ish surface. JSON in/out. Loopback only.
+
+    Endpoints:
+
+    * ``GET  /health``          -- liveness
+    * ``POST /mission``         -- body: ``{"intent": "..."}``; runs a mission
+                                   synchronously and returns the result. Used
+                                   by the telegram daemon for project-bound
+                                   topics.
+    """
+
+    # silence stock access log → use our logger
+    def log_message(self, fmt: str, *args) -> None:  # noqa: A003
+        logger.debug("http: " + fmt, *args)
+
+    def _reply(self, status: int, payload: dict) -> None:
+        body = json.dumps(payload).encode()
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self) -> None:  # noqa: N802 — required by BaseHTTPRequestHandler
+        if self.path == "/health":
+            self._reply(200, {"ok": True, "ts": time.time()})
+            return
+        self._reply(404, {"error": "not found"})
+
+    def do_POST(self) -> None:  # noqa: N802
+        # /webhook/<id> — inbound HMAC-signed webhooks (GitHub/Linear/generic)
+        if self.path.startswith("/webhook/"):
+            return self._handle_webhook()
+        if self.path != "/mission":
+            self._reply(404, {"error": "not found"})
+            return
+        length = int(self.headers.get("Content-Length", "0"))
+        raw = self.rfile.read(length).decode() if length else "{}"
+        try:
+            body = json.loads(raw) if raw else {}
+        except json.JSONDecodeError:
+            self._reply(400, {"error": "invalid json"})
+            return
+        intent = body.get("intent")
+        topic_id = body.get("topic_id")
+        if not intent:
+            self._reply(400, {"error": "missing intent"})
+            return
+        try:
+            from omega_engine.mission import run_mission
+            outcome = run_mission(
+                intent=intent,
+                topic_id=topic_id,
+                telegram=None,  # the telegram daemon supplies its own bridge
+            )
+            self._reply(200, {
+                "mission_id": outcome.result.mission_id,
+                "verified": outcome.result.verified,
+                "final_state": outcome.result.final_state.value,
+                "progress_pct": outcome.progress_pct,
+                "report_pdf": (
+                    str(outcome.report_pdf) if outcome.report_pdf else None
+                ),
+            })
+        except Exception as exc:  # noqa: BLE001
+            logger.exception("engine HTTP: mission failed")
+            self._reply(500, {"error": str(exc)})
+
+    def _handle_webhook(self) -> None:
+        """Inbound webhook gate: verify signature → wake supervisor charters."""
+        from omega_engine.webhooks import handle_webhook
+        length = int(self.headers.get("Content-Length", "0"))
+        body = self.rfile.read(length) if length else b""
+        # Collect headers as a plain dict for the gate.
+        headers = {k: v for k, v in self.headers.items()}
+        # The engine daemon's supervisor is built in main() and exposed
+        # via the handler class attribute (set just before serving).
+        supervisor = getattr(self.server, "supervisor", None)
+        try:
+            result = handle_webhook(
+                _omega_home(), path=self.path,
+                headers=headers, body=body, supervisor=supervisor,
+            )
+        except Exception as exc:  # noqa: BLE001
+            logger.exception("engine HTTP: webhook failed")
+            self._reply(500, {"ok": False, "error": str(exc)})
+            return
+        self._reply(result["status"], {
+            "ok": result["ok"],
+            "reason": result.get("reason", ""),
+            "fired": result.get("fired", []),
+        })
+
+
+def _serve_http(
+    port: int, stop: threading.Event, supervisor=None,
+) -> None:
+    """Run the HTTP API until ``stop`` is set.
+
+    The ``supervisor`` is exposed as a server attribute so the
+    ``/webhook/<id>`` handler can fire charters on a verified inbound.
+    """
+    httpd = ThreadingHTTPServer(("127.0.0.1", port), _EngineHandler)
+    httpd.timeout = 1.0
+    # Stash on the server so the handler can find it via self.server.
+    httpd.supervisor = supervisor  # type: ignore[attr-defined]
+    logger.info("engine HTTP API on 127.0.0.1:%d (webhooks: %s)",
+                port, "wired" if supervisor else "disabled")
+    while not stop.is_set():
+        httpd.handle_request()
+    httpd.server_close()
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Main loop
+# ─────────────────────────────────────────────────────────────────────────────
+
+def main() -> int:
+    logging.basicConfig(
+        level=os.environ.get("OMEGA_LOG_LEVEL", "INFO"),
+        format="%(asctime)s %(name)s %(levelname)s %(message)s",
+    )
+    home = _omega_home()
+    db_path = _store_path(home)
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+
+    store = SQLiteStore(db_path)
+    bus = EventBus(store)
+    logger.info("engine daemon online — store=%s", db_path)
+
+    stop = threading.Event()
+    signal.signal(signal.SIGTERM, lambda *_: stop.set())
+    signal.signal(signal.SIGINT, lambda *_: stop.set())
+
+    port = int(os.environ.get("OMEGA_ENGINE_PORT", "8731"))
+    # Build the supervisor once at startup so the HTTP server can fire
+    # webhook-triggered charters. Best-effort: if no charters are
+    # configured, the supervisor is still safe to pass — wake_webhook
+    # just returns an empty list.
+    supervisor = None
+    try:
+        from omega_engine.autonomous import build_supervisor_from_home
+        supervisor = build_supervisor_from_home(home)
+    except Exception:  # noqa: BLE001
+        logger.warning("engine daemon: supervisor unavailable — webhooks disabled",
+                       exc_info=True)
+    http_thread = threading.Thread(
+        target=_serve_http, args=(port, stop, supervisor),
+        daemon=True, name="omega-engine-http",
+    )
+    http_thread.start()
+
+    # first heartbeat at startup so `omega status` immediately shows the engine
+    bus.publish(Event(
+        task_id=_SYSTEM_TASK_ID,
+        type=EventType.HEARTBEAT,
+        payload={"daemon": "engine", "event": "start"},
+    ))
+
+    last_beat = time.time()
+    try:
+        while not stop.is_set():
+            now = time.time()
+            if now - last_beat >= _HEARTBEAT_PERIOD_S:
+                try:
+                    bus.publish(Event(
+                        task_id=_SYSTEM_TASK_ID,
+                        type=EventType.HEARTBEAT,
+                        payload={"daemon": "engine", "ts": now},
+                    ))
+                except Exception:  # noqa: BLE001 — never die on a heartbeat
+                    logger.exception("engine daemon: heartbeat publish failed")
+                last_beat = now
+            stop.wait(1.0)
+    finally:
+        bus.publish(Event(
+            task_id=_SYSTEM_TASK_ID,
+            type=EventType.HEARTBEAT,
+            payload={"daemon": "engine", "event": "stop"},
+        ))
+        store.close()
+        logger.info("engine daemon stopped")
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())