@agentikos/omega-os 0.2.0 → 0.19.5

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

@@ -0,0 +1,144 @@
+"""Per-version migrations.
+
+How it works
+------------
+
+Each file in this package named ``v<major>_<minor>_<patch>.py`` declares a
+single function::
+
+    def migrate(omega_home: pathlib.Path) -> None:
+        # idempotent — safe to run twice
+        ...
+
+The migration is applied when the engine upgrades from a previous version
+to this one. ``run_migrations(home, from_v, to_v)`` finds every migration
+whose declared version is strictly greater than ``from_v`` and less than
+or equal to ``to_v``, and runs them in semver order.
+
+A ``_applied.json`` journal under ``Agentik_Extra/var/migrations/`` records
+which migration ran when. Re-running is idempotent: each ``migrate()``
+must be safe to call multiple times (use ``CREATE TABLE IF NOT EXISTS``,
+``INSERT OR IGNORE``, etc.). The journal exists purely for observability.
+
+Why we need this
+----------------
+
+When v0.13's SQLite schema gains a column in v0.14, simply re-running the
+``CREATE TABLE IF NOT EXISTS`` SQL DOES NOT migrate existing rows. A
+``migrate()`` for v0.14 issues the ``ALTER TABLE ... ADD COLUMN`` once,
+checks for already-applied state, and is safe to no-op on re-run.
+
+Same idea for data migrations (JSON file shape changes, vault entry
+renames, charter YAML format bumps).
+"""
+from __future__ import annotations
+
+import importlib
+import json
+import pkgutil
+import re
+import time
+from pathlib import Path
+from typing import Any, Callable
+
+
+_VERSION_RE = re.compile(r"^v(\d+)_(\d+)_(\d+)$")
+
+
+def _parse(name: str) -> tuple[int, int, int] | None:
+    m = _VERSION_RE.match(name)
+    if not m:
+        return None
+    return tuple(int(g) for g in m.groups())  # type: ignore[return-value]
+
+
+def _semver(s: str) -> tuple[int, int, int]:
+    parts = s.split("-")[0].split(".")[:3]
+    out: list[int] = []
+    for p in parts:
+        try:
+            out.append(int(p))
+        except ValueError:
+            out.append(0)
+    while len(out) < 3:
+        out.append(0)
+    return out[0], out[1], out[2]
+
+
+def discover() -> list[tuple[tuple[int, int, int], str, Callable[[Path], None]]]:
+    """Return every migration found in this package, sorted ascending."""
+    import omega_engine.migrations as pkg
+    found: list[tuple[tuple[int, int, int], str, Callable[[Path], None]]] = []
+    for _, name, _ in pkgutil.iter_modules(pkg.__path__):
+        ver = _parse(name)
+        if ver is None:
+            continue
+        mod = importlib.import_module(f"omega_engine.migrations.{name}")
+        fn = getattr(mod, "migrate", None)
+        if callable(fn):
+            found.append((ver, name, fn))
+    found.sort(key=lambda x: x[0])
+    return found
+
+
+def _journal_path(home: Path) -> Path:
+    return home / "Agentik_Extra" / "var" / "migrations" / "_applied.json"
+
+
+def _load_journal(home: Path) -> dict[str, Any]:
+    p = _journal_path(home)
+    if not p.exists():
+        return {"applied": []}
+    try:
+        return json.loads(p.read_text())
+    except (OSError, ValueError):
+        return {"applied": []}
+
+
+def _save_journal(home: Path, data: dict[str, Any]) -> None:
+    p = _journal_path(home)
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(json.dumps(data, indent=2))
+
+
+def run_migrations(
+    home: str | Path, from_version: str, to_version: str,
+) -> list[dict[str, Any]]:
+    """Run every migration v such that from_version < v <= to_version.
+
+    Returns the list of applied migrations (each ``{name, version,
+    duration_s}``). Idempotent: re-running with the same range is a no-op
+    because we check the journal first AND each migrate() is responsible
+    for being idempotent itself.
+    """
+    home = Path(home)
+    lo = _semver(from_version)
+    hi = _semver(to_version)
+    journal = _load_journal(home)
+    applied_names = {entry["name"] for entry in journal["applied"]}
+    out: list[dict[str, Any]] = []
+    for ver, name, fn in discover():
+        if not (lo < ver <= hi):
+            continue
+        if name in applied_names:
+            continue
+        started = time.time()
+        try:
+            fn(home)
+        except Exception as exc:  # noqa: BLE001
+            journal["applied"].append({
+                "name": name, "version": ".".join(str(x) for x in ver),
+                "ok": False, "error": str(exc)[:300],
+                "applied_at": time.time(),
+            })
+            _save_journal(home, journal)
+            raise
+        entry = {
+            "name": name, "version": ".".join(str(x) for x in ver),
+            "ok": True, "duration_s": round(time.time() - started, 3),
+            "applied_at": time.time(),
+        }
+        journal["applied"].append(entry)
+        out.append(entry)
+    _save_journal(home, journal)
+    return out

package/omega/Agentik_Engine/omega_engine/migrations/v0_14_0.py

@@ -0,0 +1,29 @@
+"""v0.14.0 migration — record the upgrade journal anchor.
+
+This migration is the first one shipped with the migrations framework
+itself. All it does is touch an anchor file so post-upgrade tools can
+prove the journal was wired correctly. Schema-wise, v0.14.0 is a no-op
+for SQLite (all the v0.13 CREATE TABLE IF NOT EXISTS statements still
+match).
+
+Pattern for future migrations
+-----------------------------
+
+  * idempotent (safe to run multiple times)
+  * narrow scope (one logical change per migration)
+  * tested independently (tests/test_migrations.py)
+"""
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+
+
+def migrate(omega_home: Path) -> None:
+    """Touch an anchor file proving the migration framework ran."""
+    anchor = omega_home / "Agentik_Extra" / "var" / "migrations" / ".v0_14_0"
+    anchor.parent.mkdir(parents=True, exist_ok=True)
+    payload = {"applied_at": time.time(), "name": "v0_14_0"}
+    # write_text is idempotent — overwriting with the same content is fine
+    anchor.write_text(json.dumps(payload, indent=2))

package/omega/Agentik_Engine/omega_engine/mission.py

@@ -31,19 +31,22 @@ def _omega_home(explicit: str | Path | None = None) -> Path:
 
 
 def build_router() -> ModelRouter:
-    """Real Claude when a key is present, else the deterministic MockProvider —
-    so `omega run` always works, with or without credentials."""
-    use_claude = (
-        os.environ.get("ANTHROPIC_API_KEY")
-        and os.environ.get("OMEGA_PROVIDER", "") != "mock"
-    )
-    if use_claude:
-        try:
-            import anthropic  # noqa: F401
-            return ModelRouter.single(ClaudeProvider())
-        except ImportError:
-            pass
-    return ModelRouter.single(MockProvider())
+    """Resolve the best provider for this host.
+
+    Preference order (matches ``ModelRouter.auto``):
+
+      1. ``claude`` CLI on PATH + logged in → ClaudeMaxProvider
+         (uses the operator's Claude Code Max subscription via OAuth;
+         no API key, real USD cost tracked per call).
+      2. ``ANTHROPIC_API_KEY`` env var set → ClaudeProvider (API).
+      3. Otherwise → MockProvider (deterministic, offline).
+
+    ``OMEGA_PROVIDER=mock`` forces the MockProvider — useful for
+    deterministic tests on hosts that happen to have ``claude`` installed.
+    """
+    if os.environ.get("OMEGA_PROVIDER", "") == "mock":
+        return ModelRouter.single(MockProvider())
+    return ModelRouter.auto()
 
 
 @dataclass