@agentikos/omega-os 0.2.0 → 0.19.5

package/omega/Agentik_Engine/omega_engine/cadence.py

@@ -0,0 +1,158 @@
+"""cadence — recurring / scheduled execution.
+
+The Agentik OS native equivalent of a "run this every N" beat. Takes a
+trigger spec and an intent, persists a charter to
+``Agentik_Orchestration/autonomous/cadence-<id>.yaml`` that the existing
+``AutonomousSupervisor`` picks up at its next tick.
+
+Three trigger types:
+  * ``cron <expr>`` — standard 5-field cron (``*/5 * * * *``)
+  * ``delay <seconds>`` — fire once after ``seconds`` from now
+  * ``self`` — let the agent self-pace (the supervisor still ticks, but the
+    agent decides whether to act)
+
+Why this exists:
+  Claude Code's bundled ``/loop`` schedules a prompt in the editor. We
+  re-implement it as an engine primitive so OmegaOS supervises the beat
+  itself — surviving Claude Code sessions, daemons, the whole system.
+"""
+from __future__ import annotations
+
+import os
+import time
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+VALID_TRIGGERS = {"cron", "delay", "self"}
+
+
+@dataclass
+class CadenceCharter:
+    id: str
+    trigger_type: str                       # "cron" | "delay" | "self"
+    schedule: str                           # cron expr, delay-secs, or "self"
+    intent: str
+    role: str = "worker"
+    enabled: bool = True
+    description: str = ""
+
+    def to_yaml_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "description": self.description or self.intent,
+            "enabled": self.enabled,
+            "trigger": {"type": self.trigger_type, "schedule": self.schedule},
+            "role": self.role,
+            "spec": {"intent": self.intent},
+        }
+
+
+def schedule_cadence(
+    intent: str,
+    trigger_type: str,
+    schedule: str,
+    *,
+    omega_home: str | Path | None = None,
+    charter_id: str | None = None,
+    role: str = "worker",
+    description: str | None = None,
+) -> Path:
+    """Persist a charter to the orchestration tree.
+
+    Args:
+        intent: the natural-language thing to do at each beat.
+        trigger_type: "cron" | "delay" | "self".
+        schedule: trigger-type-specific spec — a cron expression, a
+            delay-in-seconds, or the literal "self".
+        omega_home: ``$OMEGA_HOME`` (defaults to env or ``~/Omega``).
+        charter_id: stable id; one is generated if not given.
+        role: provider role to use for each beat (default ``worker``).
+        description: optional human description; defaults to the intent.
+
+    Returns: the path to the persisted charter YAML.
+    """
+    if trigger_type not in VALID_TRIGGERS:
+        raise ValueError(
+            f"trigger_type must be one of {VALID_TRIGGERS}, got {trigger_type!r}"
+        )
+    if trigger_type == "cron" and not schedule.strip():
+        raise ValueError("cron trigger requires a non-empty schedule")
+    if trigger_type == "delay":
+        try:
+            int(schedule)
+        except ValueError as exc:
+            raise ValueError(f"delay schedule must be an integer (seconds), got {schedule!r}") from exc
+
+    home = Path(omega_home or os.environ.get("OMEGA_HOME") or
+                Path.home() / "Omega")
+    cid = charter_id or "cadence-" + uuid.uuid4().hex[:8]
+
+    target_dir = home / "Agentik_Orchestration" / "autonomous"
+    target_dir.mkdir(parents=True, exist_ok=True)
+    charter = CadenceCharter(
+        id=cid, trigger_type=trigger_type, schedule=schedule,
+        intent=intent, role=role, enabled=True,
+        description=description or intent,
+    )
+    target = target_dir / f"{cid}.yaml"
+    target.write_text(yaml.safe_dump(charter.to_yaml_dict(),
+                                      sort_keys=False, default_flow_style=False))
+    return target
+
+
+def list_cadences(omega_home: str | Path | None = None) -> list[dict[str, Any]]:
+    """Return one summary dict per scheduled cadence on disk."""
+    home = Path(omega_home or os.environ.get("OMEGA_HOME") or
+                Path.home() / "Omega")
+    target = home / "Agentik_Orchestration" / "autonomous"
+    out: list[dict[str, Any]] = []
+    if not target.is_dir():
+        return out
+    for path in sorted(target.glob("cadence-*.yaml")):
+        try:
+            data = yaml.safe_load(path.read_text()) or {}
+        except yaml.YAMLError:
+            continue
+        out.append({
+            "id": data.get("id", path.stem),
+            "enabled": bool(data.get("enabled", True)),
+            "trigger": data.get("trigger") or {},
+            "intent": ((data.get("spec") or {}).get("intent")
+                       or data.get("description") or ""),
+            "path": str(path),
+        })
+    return out
+
+
+def disable_cadence(charter_id: str, *,
+                    omega_home: str | Path | None = None) -> bool:
+    """Set ``enabled: false`` on a cadence charter. Returns True if changed."""
+    home = Path(omega_home or os.environ.get("OMEGA_HOME") or
+                Path.home() / "Omega")
+    target = home / "Agentik_Orchestration" / "autonomous" / f"{charter_id}.yaml"
+    if not target.exists():
+        return False
+    data = yaml.safe_load(target.read_text()) or {}
+    if not data.get("enabled", True):
+        return False
+    data["enabled"] = False
+    target.write_text(yaml.safe_dump(data, sort_keys=False,
+                                      default_flow_style=False))
+    return True
+
+
+def remove_cadence(charter_id: str, *,
+                   omega_home: str | Path | None = None) -> bool:
+    """Delete a cadence charter. Returns True if it existed."""
+    home = Path(omega_home or os.environ.get("OMEGA_HOME") or
+                Path.home() / "Omega")
+    target = home / "Agentik_Orchestration" / "autonomous" / f"{charter_id}.yaml"
+    if not target.exists():
+        return False
+    target.unlink()
+    return True

package/omega/Agentik_Engine/omega_engine/classifier.py

@@ -0,0 +1,215 @@
+"""Task-complexity classifier — picks the right model for the job.
+
+The current router sends every task to one provider with one model. That
+wastes money on a tiny refactor (Sonnet/Opus when Haiku would do) and
+risks quality on a hard architectural task (Haiku when we needed Opus).
+
+This module classifies a task description into one of three buckets:
+
+  * ``simple``    — tiny change, formatting, rename, one-line fix
+  * ``moderate``  — implement a feature, fix a bug with context
+  * ``complex``   — design, architecture, multi-file refactor, security
+
+The classifier is a heuristic-first ladder:
+
+  1. **Hard signals** — keywords + length + file count. Returns
+     immediately when confident.
+  2. **Soft signals** — accumulates a score, picks the bucket above a
+     threshold.
+  3. **Optional LLM refinement** — when ``llm_router`` is provided and
+     the heuristic is uncertain, ask a Haiku call to decide. ~1 token
+     of cost; mostly free because Haiku is cheap.
+
+Returns ``(bucket, confidence, reason)`` so the router can log WHY a
+model was chosen — important for cost transparency.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any
+
+
+BUCKETS = ("simple", "moderate", "complex")
+
+
+@dataclass
+class Classification:
+    bucket: str               # "simple" | "moderate" | "complex"
+    confidence: str            # "low" | "medium" | "high"
+    reason: str
+    suggested_model: str       # e.g. "haiku" | "sonnet" | "opus"
+
+
+# Keywords. Order matters — complex wins ties.
+_COMPLEX_KEYWORDS = {
+    "architecture", "redesign", "refactor", "migration", "audit",
+    "security", "performance", "concurrency", "race condition",
+    "investigate", "analyze", "diagnose", "debug deep",
+    "build a", "design a", "implement a system",
+}
+_MODERATE_KEYWORDS = {
+    "implement", "build", "add a feature", "fix the bug",
+    "add support for", "wire up", "integrate", "extract",
+}
+_SIMPLE_KEYWORDS = {
+    "rename", "format", "lint", "fix typo", "fix a typo",
+    "update the readme", "add a comment", "change the message",
+    "bump version", "one-line", "remove unused",
+}
+
+# File-count signals (extracted from typical intents like "all 12 files")
+_FILE_COUNT_RE = re.compile(r"(\d+)\s+(?:file|tests?)", re.IGNORECASE)
+
+
+def _has_any(text: str, keywords: set[str]) -> bool:
+    t = text.lower()
+    return any(k in t for k in keywords)
+
+
+def _score(text: str) -> tuple[int, int, int]:
+    """Return (simple_score, moderate_score, complex_score)."""
+    t = text.lower()
+    s = sum(1 for k in _SIMPLE_KEYWORDS if k in t)
+    m = sum(1 for k in _MODERATE_KEYWORDS if k in t)
+    c = sum(1 for k in _COMPLEX_KEYWORDS if k in t)
+    return s, m, c
+
+
+def _suggest_model(bucket: str) -> str:
+    return {"simple": "haiku", "moderate": "sonnet", "complex": "opus"}.get(
+        bucket, "sonnet",
+    )
+
+
+def classify(
+    task_description: str,
+    *,
+    role: str = "worker",
+    llm_router=None,
+) -> Classification:
+    """Pick the right complexity bucket + model for a task.
+
+    Heuristic chain:
+
+      a) Always-complex roles (architect, oracle planning) get bumped up.
+      b) Hard signal: explicit complex keyword present → complex.
+      c) Hard signal: explicit simple keyword present + short text → simple.
+      d) Length-based fallback: long descriptions are usually complex.
+      e) When still uncertain AND llm_router is provided, ask a Haiku
+         classification call.
+    """
+    text = (task_description or "").strip()
+    if not text:
+        return Classification(
+            "simple", "high",
+            "empty task → trivially simple", _suggest_model("simple"),
+        )
+
+    # (a) Role-driven floor
+    if role in ("architect", "smith"):
+        # Architecture + reflection always need depth
+        return Classification(
+            "complex", "high",
+            f"role={role!r} → architecture/reflection task",
+            _suggest_model("complex"),
+        )
+    if role in ("oracle", "manager", "aisb"):
+        # Planning roles need solid reasoning but not always Opus
+        return Classification(
+            "moderate", "medium",
+            f"role={role!r} → dispatcher; sonnet is the sweet spot",
+            _suggest_model("moderate"),
+        )
+
+    # (b) Hard complex signals
+    s_score, m_score, c_score = _score(text)
+    if c_score >= 2 or (c_score >= 1 and len(text) > 400):
+        return Classification(
+            "complex", "high",
+            f"{c_score} complex keyword(s) + length={len(text)}",
+            _suggest_model("complex"),
+        )
+
+    # File-count signal
+    fc = _FILE_COUNT_RE.search(text)
+    if fc and int(fc.group(1)) >= 5:
+        return Classification(
+            "complex", "high",
+            f"task mentions {fc.group(1)}+ files",
+            _suggest_model("complex"),
+        )
+
+    # (c) Hard simple signals
+    if s_score >= 1 and len(text) < 250 and c_score == 0:
+        return Classification(
+            "simple", "high",
+            f"{s_score} simple keyword(s), short text",
+            _suggest_model("simple"),
+        )
+
+    # (d) Moderate keyword wins over a short-text "simple" guess —
+    # "implement X" is moderate even when phrased tersely.
+    word_count = len(text.split())
+    if m_score > 0:
+        return Classification(
+            "moderate", "medium" if m_score >= 2 else "low",
+            f"{m_score} moderate keyword(s)",
+            _suggest_model("moderate"),
+        )
+
+    # (e) Length-based fallback
+    if word_count > 80:
+        return Classification(
+            "complex", "medium",
+            f"long description ({word_count} words)",
+            _suggest_model("complex"),
+        )
+    if word_count < 12:
+        return Classification(
+            "simple", "medium",
+            f"short description ({word_count} words)",
+            _suggest_model("simple"),
+        )
+
+    # (f) Uncertain — moderate by default, or ask Haiku to break the tie
+    if llm_router is not None:
+        try:
+            return _llm_refine(text, llm_router)
+        except Exception:  # noqa: BLE001
+            pass
+
+    return Classification(
+        "moderate", "low",
+        f"no strong signal ({word_count} words, scores={s_score}/{m_score}/{c_score})",
+        _suggest_model("moderate"),
+    )
+
+
+def _llm_refine(text: str, router) -> Classification:
+    """Last-resort Haiku call for ambiguous cases. ~1 token cost."""
+    from omega_engine.provider import AgentRequest
+    prompt = (
+        "Classify this task into one of: simple, moderate, complex.\n"
+        "  simple   = trivial change, no design decisions\n"
+        "  moderate = implement/fix with context, single domain\n"
+        "  complex  = architecture, security, cross-cutting, multi-file\n\n"
+        f"TASK: {text[:1500]}\n\n"
+        "Reply with EXACTLY one word: simple, moderate, or complex."
+    )
+    provider = router.resolve("classifier")
+    result = provider.run(AgentRequest(
+        role="classifier", prompt=prompt,
+        context={"classifier": True},
+    ))
+    raw = (result.text or "").strip().lower().split()
+    bucket = "moderate"
+    for w in raw:
+        if w in BUCKETS:
+            bucket = w
+            break
+    return Classification(
+        bucket, "high",
+        "LLM-refined (Haiku 1-token call)",
+        _suggest_model(bucket),
+    )