@agentikos/omega-os 0.1.0 → 0.2.0

package/omega/Agentik_Engine/tests/test_autonomous.py

@@ -0,0 +1,361 @@
+"""Autonomous-agent supervisor — charters, cron parser, and trigger firing.
+
+Standalone runner: ``python3 tests/test_autonomous.py``
+"""
+import os
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from omega_engine.autonomous import (              # noqa: E402
+    AutonomousSupervisor,
+    Charter,
+    load_charters,
+    next_fire,
+    parse_cron,
+)
+from omega_engine.events import Event, EventType   # noqa: E402
+from omega_engine.task import Lifecycle            # noqa: E402
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# fixture: a directory of example charters, identical in spirit to the file
+# shipped at Agentik_Orchestration/autonomous/example-agents.yaml
+# ─────────────────────────────────────────────────────────────────────────────
+
+_EXAMPLE_YAML = """\
+# autonomous-agent charters — mirror of example-agents.yaml
+template:
+  id: <agent-id>
+  role: <role-name>
+  lifecycle: persistent
+  charter: >
+    Placeholder.
+  trigger:
+    type: <cron|event|webhook|channel>
+    config: {}
+  channel:
+    telegram_topic: 0
+  budget:
+    max_iterations: 5
+    heartbeat_interval_s: 300
+
+support-agent:
+  id: support-agent
+  role: customer-support
+  lifecycle: persistent
+  charter: >
+    Watch the support channel. Triage every inbound message.
+  trigger:
+    type: channel
+    config: { telegram_topic: 4012 }
+  channel:
+    telegram_topic: 4012
+  budget:
+    max_iterations: 5
+    heartbeat_interval_s: 300
+  provider: glm
+  allowed:
+    skills: [classify-intent, draft-reply, rag-route]
+    mcp: [filesystem, github, linear]
+    topologies: [aisb-oracle-worker]
+  guardrails:
+    may_spawn_missions: true
+    may_ship: false
+
+growth-agent:
+  id: growth-agent
+  role: growth
+  lifecycle: persistent
+  charter: >
+    Every morning, pull yesterday's product metrics and open one mission.
+  trigger:
+    type: cron
+    config: { schedule: "0 7 * * *" }
+  channel:
+    telegram_topic: 4020
+  budget:
+    max_iterations: 3
+    heartbeat_interval_s: 600
+  provider: claude
+  allowed:
+    skills: [rag-route, metrics-read, prioritize]
+    mcp: [filesystem, postgres, github]
+    topologies: [aisb-oracle-worker]
+  guardrails:
+    may_spawn_missions: true
+    may_ship: false
+"""
+
+_EVENT_AGENT_YAML = """\
+fix-on-fail:
+  id: fix-on-fail
+  role: triage
+  lifecycle: persistent
+  charter: >
+    React to every task.failed.
+  trigger:
+    type: event
+    config: { event_type: "task.failed" }
+  channel:
+    telegram_topic: 5000
+  budget:
+    max_iterations: 1
+    heartbeat_interval_s: 60
+"""
+
+_WEBHOOK_YAML = """\
+ci-hook:
+  id: ci-hook
+  role: ci
+  lifecycle: persistent
+  charter: >
+    Run on every push.
+  trigger:
+    type: webhook
+    config: { webhook_path: /hooks/push }
+  channel:
+    telegram_topic: 6000
+  budget:
+    max_iterations: 1
+    heartbeat_interval_s: 60
+"""
+
+
+def _charter_dir() -> Path:
+    d = Path(tempfile.mkdtemp(prefix="omega-charters-"))
+    (d / "example-agents.yaml").write_text(_EXAMPLE_YAML)
+    (d / "fix-on-fail.yaml").write_text(_EVENT_AGENT_YAML)
+    (d / "ci-hook.yaml").write_text(_WEBHOOK_YAML)
+    return d
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# tests
+# ─────────────────────────────────────────────────────────────────────────────
+
+def test_load_charters_skips_template_block_and_loads_real_charters():
+    d = _charter_dir()
+    charters = load_charters(d)
+    ids = sorted(c.id for c in charters)
+    # the `template:` placeholder must NOT come through as a charter; the four
+    # real ones (support, growth, event, webhook) must.
+    assert ids == ["ci-hook", "fix-on-fail", "growth-agent", "support-agent"], ids
+    # every charter is a real Charter dataclass with the right fields populated
+    for c in charters:
+        assert isinstance(c, Charter)
+        assert c.lifecycle == Lifecycle.PERSISTENT.value
+        assert c.trigger_type in ("cron", "event", "webhook", "channel")
+        assert c.source_file and c.source_file.endswith(".yaml")
+    # spot-check the support charter mirrors the YAML
+    support = next(c for c in charters if c.id == "support-agent")
+    assert support.role == "customer-support"
+    assert support.trigger_type == "channel"
+    assert support.trigger_config == {"telegram_topic": 4012}
+    assert support.channel_topic == 4012
+    assert support.max_iterations == 5
+    assert support.heartbeat_interval_s == 300
+    assert support.provider == "glm"
+    assert "classify-intent" in support.allowed_skills
+    assert "linear" in support.allowed_mcp
+
+
+def test_load_charters_handles_missing_or_empty_dir():
+    # missing directory → empty list, no exception
+    assert load_charters(Path("/tmp/this/does/not/exist")) == []
+    # empty directory → empty list
+    empty = Path(tempfile.mkdtemp())
+    assert load_charters(empty) == []
+
+
+def test_parse_cron_basic_forms():
+    # the exact form used by growth-agent
+    minute, hour, dom, month, dow = parse_cron("0 7 * * *")
+    assert minute == {0}
+    assert hour == {7}
+    assert dom == set(range(1, 32))
+    assert month == set(range(1, 13))
+    assert dow == set(range(0, 7))
+
+    # */N step on every field
+    minute, *_ = parse_cron("*/5 * * * *")
+    assert minute == {0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55}
+
+    # comma lists + ranges
+    minute, hour, *_ = parse_cron("0,15,30,45 9-17 * * 1-5")
+    assert minute == {0, 15, 30, 45}
+    assert hour == set(range(9, 18))
+
+
+def test_next_fire_every_five_minutes_returns_now_plus_about_5_min():
+    now = time.time()
+    nf = next_fire("*/5 * * * *", now)
+    # the next */5 boundary is at most 5min away (300s); the search rounds up to
+    # the next whole minute, so the legal lower bound is 0s, upper bound 300s.
+    delta = nf - now
+    assert 0 < delta <= 300, f"delta={delta}"
+    # and the returned timestamp must actually be on a 5-minute boundary
+    assert time.localtime(nf).tm_min % 5 == 0
+
+
+def test_next_fire_daily_seven_am_lands_on_seven_am():
+    now = time.time()
+    nf = next_fire("0 7 * * *", now)
+    t = time.localtime(nf)
+    assert t.tm_hour == 7 and t.tm_min == 0
+    # and it's within the next 24 hours + a small margin
+    assert nf > now
+    assert nf - now <= 24 * 60 * 60 + 60
+
+
+def test_supervisor_cron_tick_invokes_runner():
+    """The crux: a cron trigger past its `next_fire_at` calls the runner."""
+    fired: list[dict] = []
+
+    def fake_runner(*, intent, omega_home, topic_id, telegram, charter):
+        fired.append({
+            "intent": intent, "topic_id": topic_id, "charter_id": charter.id,
+        })
+
+    d = _charter_dir()
+    charters = load_charters(d)
+    sup = AutonomousSupervisor(charters, runner=fake_runner)
+
+    # force the growth-agent's next_fire into the past, then tick
+    growth_sched = sup._schedules["growth-agent"]      # noqa: SLF001
+    growth_sched.next_fire_at = time.time() - 10
+    fired_ids = sup.tick(now=time.time())
+
+    assert "growth-agent" in fired_ids
+    assert any(f["charter_id"] == "growth-agent" for f in fired)
+    # the runner saw the bound topic id
+    growth = [f for f in fired if f["charter_id"] == "growth-agent"][0]
+    assert growth["topic_id"] == 4020
+    # the schedule rescheduled itself for the next fire — strictly in the future
+    assert growth_sched.next_fire_at is not None
+    assert growth_sched.next_fire_at > time.time()
+    # runs counter incremented; no errors
+    assert growth_sched.runs == 1
+    assert growth_sched.errors == 0
+
+
+def test_supervisor_channel_trigger_dispatches_on_inbound_message():
+    fired: list[dict] = []
+
+    def fake_runner(*, intent, omega_home, topic_id, telegram, charter):
+        fired.append({"charter": charter.id, "intent": intent, "topic": topic_id})
+
+    charters = load_charters(_charter_dir())
+    sup = AutonomousSupervisor(charters, runner=fake_runner)
+    # wrong topic → nothing
+    assert sup.on_channel_message(99999, "ignored") == []
+    assert fired == []
+    # correct topic → support-agent fires with the message as the intent
+    out = sup.on_channel_message(4012, "the printer is on fire")
+    assert out == ["support-agent"]
+    assert fired == [{"charter": "support-agent",
+                       "intent": "the printer is on fire",
+                       "topic": 4012}]
+
+
+def test_supervisor_webhook_trigger_fires_on_matching_path():
+    fired: list[str] = []
+
+    def fake_runner(*, intent, omega_home, topic_id, telegram, charter):
+        fired.append(charter.id)
+
+    charters = load_charters(_charter_dir())
+    sup = AutonomousSupervisor(charters, runner=fake_runner)
+    # non-matching path → nothing
+    assert sup.wake_webhook("/hooks/unknown", {}) == []
+    assert fired == []
+    # matching path → ci-hook fires
+    assert sup.wake_webhook("/hooks/push", {"intent": "deploy"}) == ["ci-hook"]
+    assert fired == ["ci-hook"]
+
+
+def test_supervisor_one_bad_charter_does_not_kill_the_others():
+    """A runner that raises must be caught — the supervisor never dies."""
+    fired: list[str] = []
+
+    def runner(*, intent, omega_home, topic_id, telegram, charter):
+        if charter.id == "growth-agent":
+            raise RuntimeError("boom")
+        fired.append(charter.id)
+
+    sup = AutonomousSupervisor(load_charters(_charter_dir()), runner=runner)
+    # force both an immediate-fire cron AND a channel-fire on the same tick
+    sup._schedules["growth-agent"].next_fire_at = time.time() - 10  # noqa: SLF001
+    sup.tick()
+    sup.on_channel_message(4012, "support please")
+    # the channel charter ran despite the crash inside the cron charter
+    assert fired == ["support-agent"]
+    growth_stats = sup.stats()["growth-agent"]
+    assert growth_stats["errors"] >= 1
+    assert growth_stats["last_error"].startswith("RuntimeError:")
+
+
+def test_supervisor_event_trigger_via_bus():
+    """An event trigger fires when a matching event hits the bus."""
+    fired: list[str] = []
+
+    def runner(*, intent, omega_home, topic_id, telegram, charter):
+        fired.append(charter.id)
+
+    class _FakeBus:
+        def __init__(self):
+            self.subs = []
+        def subscribe(self, fn):
+            self.subs.append(fn)
+        def publish(self, event):
+            for fn in self.subs:
+                fn(event)
+
+    bus = _FakeBus()
+    sup = AutonomousSupervisor(
+        load_charters(_charter_dir()), bus=bus, runner=runner)
+    # publishing a non-matching event does nothing
+    bus.publish(Event(task_id="t-1", type=EventType.STARTED))
+    assert fired == []
+    # publishing task.failed wakes the fix-on-fail charter
+    bus.publish(Event(task_id="t-1", type=EventType.FAILED,
+                       payload={"reason": "test"}))
+    assert fired == ["fix-on-fail"]
+
+
+def test_supervisor_with_no_charters_still_runs_one_tick_cleanly():
+    """A supervisor with zero charters must not crash on an empty tick."""
+    sup = AutonomousSupervisor([], runner=lambda **kw: None)
+    assert sup.charters() == []
+    assert sup.tick() == []
+    assert sup.stats() == {}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# standalone runner
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _run_all() -> bool:
+    tests = [(k, v) for k, v in sorted(globals().items())
+             if k.startswith("test_") and callable(v)]
+    passed = 0
+    for name, fn in tests:
+        try:
+            fn()
+        except AssertionError as exc:
+            print(f"  FAIL  {name}: {exc}")
+            continue
+        except Exception as exc:  # noqa: BLE001
+            print(f"  ERROR {name}: {type(exc).__name__}: {exc}")
+            continue
+        print(f"  PASS  {name}")
+        passed += 1
+    print(f"\n{passed}/{len(tests)} autonomous tests passed")
+    return passed == len(tests)
+
+
+if __name__ == "__main__":
+    sys.exit(0 if _run_all() else 1)

package/omega/Agentik_Engine/tests/test_educators.py

@@ -0,0 +1,233 @@
+"""The 8 educators — generators that produce SSOT artifacts under a quality gate.
+
+Each educator runs `.generate()` against the `MockProvider` and must return a
+valid `EducatorProposal` whose artifact targets the right SSOT path. The
+`StagingPipeline` then writes the proposal to a temp dir (the real one is
+`Agentik_Extra/staging/promotion/`).
+
+Standalone: python3 tests/test_educators.py
+"""
+import json
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from omega_engine.educators import (                # noqa: E402
+    ArtifactEducator,
+    AutomationEducator,
+    ClaudecodeEducator,
+    ConnectionEducator,
+    CoworkerEducator,
+    EducatorProposal,
+    EducatorRegistry,
+    LoopEducator,
+    PromptEducator,
+    SkillEducator,
+    StagingPipeline,
+)
+from omega_engine.provider import MockProvider     # noqa: E402
+
+
+# --------------------------------------------------------------------------
+# A table of (educator class, generation intent, context, expected path prefix)
+# — one row per educator. Drives every per-educator test.
+# --------------------------------------------------------------------------
+
+EDUCATOR_CASES = [
+    (
+        PromptEducator,
+        "oracle dispatches a fresh worker for a Linear feedback fix",
+        {"source": "oracle", "target": "worker"},
+        "Agentik_SSOT/prompts/oracle-to-worker.md",
+    ),
+    (
+        ArtifactEducator,
+        "a Linear ticket mission report after the worker ships",
+        {"artifact_kind": "mission-report"},
+        "Agentik_SSOT/templates/mission-report.md",
+    ),
+    (
+        SkillEducator,
+        "a /releasenotes skill that summarises the last 7 days of merged PRs",
+        {"skill_name": "releasenotes"},
+        "Agentik_SSOT/skills/releasenotes.md",
+    ),
+    (
+        CoworkerEducator,
+        "a react-specialist role focused on Next.js app-router work",
+        {"role_name": "react-specialist"},
+        "Agentik_SSOT/agents/react-specialist.md",
+    ),
+    (
+        ConnectionEducator,
+        "an MCP connector for Linear (issues + comments)",
+        {"connector_id": "linear-mcp"},
+        "Agentik_SSOT/mcp/configs/linear-mcp.yaml",
+    ),
+    (
+        AutomationEducator,
+        "a daily cron that aggregates yesterday's mission outcomes",
+        {"automation_id": "daily-mission-rollup"},
+        "Agentik_SSOT/automations/daily-mission-rollup.yaml",
+    ),
+    (
+        ClaudecodeEducator,
+        "the new native compaction primitive in Claude Code 2.1.155",
+        {"change_id": "native-compaction-2-1-155"},
+        "Agentik_AI/adapters/claude-code/notes.md",
+    ),
+    (
+        LoopEducator,
+        "the loop for a single-file UI bug fix — fast, 3 iterations max",
+        {"loop_id": "single-file-ui-fix"},
+        "Agentik_SSOT/loops/single-file-ui-fix.yaml",
+    ),
+]
+
+
+def test_registry_holds_the_eight():
+    """Every educator the README lists must be discoverable through the registry."""
+    reg = EducatorRegistry.default()
+    names = reg.names()
+    expected = {"prompt", "artifact", "skill", "coworker",
+                "connection", "automation", "claudecode", "loop"}
+    assert set(names) == expected, f"registry mismatch: {names}"
+    assert len(reg.all()) == 8
+    for name in expected:
+        e = reg.get(name)
+        assert e is not None, f"educator '{name}' missing"
+        assert hasattr(e, "generate"), f"'{name}' has no generate()"
+    print(f"        {len(names)} educators registered: {', '.join(names)}")
+
+
+def test_each_educator_produces_a_valid_proposal():
+    """Run every educator once with the MockProvider; assert the proposal shape."""
+    provider = MockProvider()
+    for cls, intent, ctx, expected_path in EDUCATOR_CASES:
+        educator = cls()
+        proposal = educator.generate(intent, ctx, provider)
+        # contract: a real EducatorProposal with a populated artifact
+        assert isinstance(proposal, EducatorProposal), \
+            f"{cls.__name__} did not return EducatorProposal"
+        assert proposal.educator == educator.name
+        # artifact body must be non-empty (the educator filled it from the mock)
+        assert proposal.artifact.content, \
+            f"{cls.__name__} produced empty artifact content"
+        # target_path is exactly what this educator advertises
+        assert proposal.artifact.target_path == expected_path, (
+            f"{cls.__name__}: expected target_path={expected_path}, "
+            f"got {proposal.artifact.target_path}"
+        )
+        # score must be machine-parseable; the mock returns >= 85
+        assert 0 <= proposal.score <= 100, \
+            f"{cls.__name__}: score out of range ({proposal.score})"
+        assert proposal.score >= 85, (
+            f"{cls.__name__}: mock score should be >= 85, got {proposal.score}"
+        )
+    print(f"        {len(EDUCATOR_CASES)} educators produced valid proposals")
+
+
+def test_staging_pipeline_writes_under_temp_root():
+    """`StagingPipeline.stage` lands proposals under a per-educator bucket."""
+    tmp = Path(tempfile.mkdtemp(prefix="omega-staging-"))
+    try:
+        staging = StagingPipeline(tmp)
+        assert staging.root == tmp and tmp.exists()
+
+        provider = MockProvider()
+        records = []
+        for cls, intent, ctx, _expected in EDUCATOR_CASES:
+            proposal = cls().generate(intent, ctx, provider)
+            record = staging.stage(proposal)
+            records.append((proposal, record))
+
+        # one staged artifact + one .json per educator
+        listed = staging.list()
+        assert len(listed) == len(EDUCATOR_CASES), \
+            f"expected {len(EDUCATOR_CASES)} staged proposals, got {len(listed)}"
+
+        # the on-disk content matches what the educator produced
+        for proposal, record in records:
+            assert record.artifact_path.exists()
+            assert record.proposal_path.exists()
+            assert record.target_path == proposal.artifact.target_path
+            on_disk = record.artifact_path.read_text()
+            assert on_disk == proposal.artifact.content
+            meta = json.loads(record.proposal_path.read_text())
+            assert meta["educator"] == proposal.educator
+            assert meta["artifact"]["target_path"] == proposal.artifact.target_path
+            # extension preserved (.md or .yaml)
+            expected_suffix = Path(proposal.artifact.target_path).suffix
+            assert record.artifact_path.suffix == expected_suffix
+
+        # clear() removes everything
+        removed = staging.clear()
+        assert removed >= len(EDUCATOR_CASES) * 2  # artifact + meta per proposal
+        assert staging.list() == []
+        print(f"        staged + cleared {len(EDUCATOR_CASES)} proposals in {tmp.name}")
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def test_educator_never_writes_to_ssot_directly():
+    """An educator returns a proposal — it must NEVER touch the filesystem itself.
+
+    We assert this structurally: every educator's `.generate()` returns an
+    `EducatorProposal` whose `artifact.target_path` is a *string*, not a side
+    effect. The only path that ever writes is `StagingPipeline.stage()`.
+    """
+    provider = MockProvider()
+    for cls, intent, ctx, _expected in EDUCATOR_CASES:
+        proposal = cls().generate(intent, ctx, provider)
+        target = proposal.artifact.target_path
+        # the target is a SSOT path, never an absolute path under the user's home
+        assert not target.startswith("/"), \
+            f"{cls.__name__}: target_path must be repo-relative, got {target}"
+        assert "Agentik_SSOT/" in target or "Agentik_AI/" in target, (
+            f"{cls.__name__}: target_path must live under Agentik_SSOT/ or "
+            f"Agentik_AI/, got {target}"
+        )
+    print("        every educator returns a SSOT-relative target_path")
+
+
+def test_router_role_naming():
+    """Educators address the provider with role 'educator-<name>' (per-domain LLM)."""
+    # We verify by spying on the role through a tiny provider wrapper.
+    seen_roles: list[str] = []
+
+    class SpyProvider:
+        id = "spy"
+
+        def run(self, req):
+            seen_roles.append(req.role)
+            return MockProvider().run(req)
+
+    provider = SpyProvider()
+    for cls, intent, ctx, _expected in EDUCATOR_CASES:
+        cls().generate(intent, ctx, provider)
+
+    expected_roles = {f"educator-{cls().name}" for cls, *_ in EDUCATOR_CASES}
+    assert set(seen_roles) == expected_roles, (
+        f"router role naming mismatch.\nseen: {sorted(seen_roles)}\n"
+        f"expected: {sorted(expected_roles)}"
+    )
+    print(f"        all 8 educators dispatched via 'educator-<name>' roles")
+
+
+def _run_all() -> bool:
+    tests = [v for k, v in sorted(globals().items())
+             if k.startswith("test_") and callable(v)]
+    passed = 0
+    for t in tests:
+        t()
+        print(f"  PASS  {t.__name__}")
+        passed += 1
+    print(f"\n{passed}/{len(tests)} educator tests passed")
+    return passed == len(tests)
+
+
+if __name__ == "__main__":
+    sys.exit(0 if _run_all() else 1)