@trac3r/oh-my-god 2.2.11

package/runtime/ecosystem.py

@@ -0,0 +1,371 @@
+"""Optional upstream ecosystem sync and integration helpers for OMG."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import subprocess
+from typing import Any
+
+ECOSYSTEM_SCHEMA = "OmgEcosystemCatalog"
+ECOSYSTEM_CATALOG_VERSION = "2.0.8"
+ECOSYSTEM_LOCK_SCHEMA = "OmgEcosystemLock"
+DEFAULT_ECOSYSTEM_REPO_DIR = ".omg/ecosystem/repos"
+DEFAULT_ECOSYSTEM_LOCK_PATH = ".omg/state/ecosystem-lock.json"
+DEFAULT_ECOSYSTEM_PLAYBOOK_DIR = ".omg/knowledge/ecosystem"
+MAX_SELECTION = 32
+
+
+ECOSYSTEM_REPOS: tuple[dict[str, Any], ...] = (
+    {
+        "name": "omg-superpowers",
+        "aliases": ("omg-superpowers",),
+        "repo": "https://github.com/trac3r00/OMG.git",
+        "ref": "main",
+        "route": "plan",
+        "category": "tdd",
+        "capabilities": ("tdd", "planning", "execution"),
+        "notes": "Primary source for strict red-green-refactor and plan execution discipline.",
+    },
+    {
+        "name": "ralph-wiggum",
+        "aliases": ("ralph-wiggum", "ralph wiggum", "ralph"),
+        "repo": "https://github.com/anthropics/claude-code.git",
+        "ref": "main",
+        "sparse_path": "plugins/ralph-wiggum",
+        "route": "runtime_ship",
+        "category": "persistent-loop",
+        "capabilities": ("persistent-mode", "completion-promises", "iteration"),
+        "notes": "Provides loop-style persistent execution patterns via stop-hook based iteration.",
+    },
+    {
+        "name": "claude-flow",
+        "aliases": ("claude-flow",),
+        "repo": "https://github.com/ruvnet/claude-flow.git",
+        "ref": "main",
+        "route": "ccg",
+        "category": "orchestration",
+        "capabilities": ("multi-agent", "coordination", "task-routing"),
+        "notes": "Informs CCG-style orchestrated task dispatch and multi-agent coordination.",
+    },
+    {
+        "name": "claude-mem",
+        "aliases": ("claude-mem",),
+        "repo": "https://github.com/thedotmack/claude-mem.git",
+        "ref": "main",
+        "route": "memory",
+        "category": "memory",
+        "capabilities": ("session-memory", "knowledge-capture", "recall"),
+        "notes": "Complements OMG knowledge/state artifacts with memory-centric workflows.",
+    },
+    {
+        "name": "memsearch",
+        "aliases": ("memsearch", "memory-search"),
+        "repo": "https://github.com/rjyo/memory-search.git",
+        "ref": "main",
+        "route": "memory",
+        "category": "memory-search",
+        "capabilities": ("semantic-search", "retrieval", "indexing"),
+        "notes": "Adds focused memory retrieval and search patterns for long-running sessions.",
+    },
+    {
+        "name": "beads",
+        "aliases": ("beads",),
+        "repo": "https://github.com/steveyegge/beads.git",
+        "ref": "main",
+        "route": "maintainer",
+        "category": "context-engineering",
+        "capabilities": ("context", "workflow", "agent-patterns"),
+        "notes": "Source of context-engineering and disciplined workflow patterns.",
+    },
+    {
+        "name": "planning-with-files",
+        "aliases": ("planning-with-files", "planning with files"),
+        "repo": "https://github.com/OthmanAdi/planning-with-files.git",
+        "ref": "master",
+        "route": "plan",
+        "category": "planning",
+        "capabilities": ("file-based-plans", "checklists", "handoff"),
+        "notes": "Reinforces file-native planning artifacts and execution checklists.",
+    },
+    {
+        "name": "hooks-mastery",
+        "aliases": ("hooks-mastery", "hooks mastery"),
+        "repo": "https://github.com/disler/claude-code-hooks-mastery.git",
+        "ref": "main",
+        "route": "health",
+        "category": "hooks",
+        "capabilities": ("hook-design", "hook-hardening", "hook-automation"),
+        "notes": "Hardening references for robust, low-noise hook behavior.",
+    },
+    {
+        "name": "compound-engineering",
+        "aliases": ("compound-engineering", "compounding-engineering"),
+        "repo": "https://github.com/EveryInc/compounding-engineering-plugin.git",
+        "ref": "main",
+        "route": "ccg",
+        "category": "compound-workflows",
+        "capabilities": ("iterative-improvement", "compound-results", "workflow-composition"),
+        "notes": "Compound engineering workflow patterns for iterative gains over multiple passes.",
+    },
+)
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _canonical(value: str) -> str:
+    return value.strip().lower().replace("_", "-").replace(" ", "-")
+
+
+def _run_git(args: list[str], *, cwd: Path | None = None) -> str:
+    proc = subprocess.run(
+        ["git", *args],
+        cwd=str(cwd) if cwd else None,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if proc.returncode != 0:
+        stderr = proc.stderr.strip()
+        raise RuntimeError(f"git {' '.join(args)} failed: {stderr or 'unknown error'}")
+    return proc.stdout.strip()
+
+
+def list_ecosystem_repos() -> list[dict[str, Any]]:
+    repos: list[dict[str, Any]] = []
+    for repo in ECOSYSTEM_REPOS:
+        cloned = dict(repo)
+        cloned["aliases"] = list(repo.get("aliases", ()))
+        cloned["capabilities"] = list(repo.get("capabilities", ()))
+        repos.append(cloned)
+    return repos
+
+
+def resolve_ecosystem_repo(name: str) -> dict[str, Any] | None:
+    if not name.strip():
+        return None
+    wanted = _canonical(name)
+    for repo in ECOSYSTEM_REPOS:
+        if wanted == _canonical(str(repo["name"])):
+            return dict(repo)
+        for alias in repo.get("aliases", ()):
+            if wanted == _canonical(str(alias)):
+                return dict(repo)
+    return None
+
+
+def resolve_ecosystem_selection(names: list[str] | None) -> tuple[list[dict[str, Any]], list[str]]:
+    if not names:
+        return list_ecosystem_repos(), []
+    selected: list[dict[str, Any]] = []
+    unknown: list[str] = []
+    seen: set[str] = set()
+    for raw in names[:MAX_SELECTION]:
+        repo = resolve_ecosystem_repo(raw)
+        if repo is None:
+            unknown.append(raw)
+            continue
+        key = str(repo["name"])
+        if key in seen:
+            continue
+        seen.add(key)
+        selected.append(repo)
+    return selected, unknown
+
+
+def _read_lock(lock_path: Path) -> dict[str, Any]:
+    if not lock_path.exists():
+        return {}
+    try:
+        payload = json.loads(lock_path.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+    if not isinstance(payload, dict):
+        return {}
+    return payload
+
+
+def _clone_or_update_repo(
+    *,
+    repo: dict[str, Any],
+    target: Path,
+    update: bool,
+    depth: int,
+) -> dict[str, Any]:
+    ref = str(repo.get("ref", "main"))
+    repo_url = str(repo["repo"])
+    sparse_path = str(repo.get("sparse_path", "")).strip()
+    action = "cached"
+
+    if not target.exists():
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if sparse_path:
+            _run_git(["clone", "--depth", str(depth), "--filter=blob:none", "--sparse", repo_url, str(target)])
+            _run_git(["-C", str(target), "sparse-checkout", "set", sparse_path])
+            if ref and ref != "main":
+                _run_git(["-C", str(target), "checkout", ref])
+        else:
+            _run_git(
+                [
+                    "clone",
+                    "--depth",
+                    str(depth),
+                    "--filter=blob:none",
+                    "--branch",
+                    ref,
+                    "--single-branch",
+                    repo_url,
+                    str(target),
+                ]
+            )
+        action = "cloned"
+    elif update:
+        _run_git(["-C", str(target), "fetch", "--depth", str(depth), "origin", ref])
+        _run_git(["-C", str(target), "checkout", "-B", ref, "FETCH_HEAD"])
+        action = "updated"
+
+    commit = _run_git(["-C", str(target), "rev-parse", "HEAD"])
+    branch = _run_git(["-C", str(target), "rev-parse", "--abbrev-ref", "HEAD"])
+    return {
+        "name": repo["name"],
+        "repo": repo_url,
+        "ref": ref,
+        "repo_segments": [".omg", "ecosystem", "repos", str(repo["name"])],
+        "action": action,
+        "commit": commit,
+        "branch": branch,
+        "sparse_path": sparse_path,
+    }
+
+
+def _write_playbook(project_dir: Path, selected: list[dict[str, Any]]) -> list[str]:
+    base = project_dir / DEFAULT_ECOSYSTEM_PLAYBOOK_DIR
+    base.mkdir(parents=True, exist_ok=True)
+    written: list[str] = []
+    for repo in selected:
+        path = base / f"{repo['name']}.md"
+        capabilities = ", ".join(repo.get("capabilities", []))
+        content = (
+            f"# {repo['name']} Integration Notes\n\n"
+            f"- Route: `{repo.get('route', '')}`\n"
+            f"- Category: `{repo.get('category', '')}`\n"
+            f"- Capabilities: {capabilities}\n"
+            f"- Source: {repo.get('repo', '')}\n\n"
+            f"{repo.get('notes', '').strip()}\n"
+        )
+        path.write_text(content, encoding="utf-8")
+        written.append(str(path))
+    return written
+
+
+def sync_ecosystem_repos(
+    *,
+    project_dir: str,
+    names: list[str] | None = None,
+    update: bool = False,
+    depth: int = 1,
+) -> dict[str, Any]:
+    root = Path(project_dir)
+    selected, unknown = resolve_ecosystem_selection(names)
+    repo_root = root / DEFAULT_ECOSYSTEM_REPO_DIR
+    lock_path = root / DEFAULT_ECOSYSTEM_LOCK_PATH
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+
+    entries: list[dict[str, Any]] = []
+    for repo in selected:
+        target = repo_root / str(repo["name"])
+        try:
+            synced = _clone_or_update_repo(repo=repo, target=target, update=update, depth=depth)
+            synced["status"] = "ok"
+            entries.append(synced)
+        except Exception as exc:
+            entries.append(
+                {
+                    "name": repo["name"],
+                    "repo": repo["repo"],
+                    "ref": repo.get("ref", "main"),
+                    "repo_segments": [".omg", "ecosystem", "repos", str(repo["name"])],
+                    "status": "error",
+                    "error": str(exc),
+                }
+            )
+
+    playbook_files = _write_playbook(root, selected)
+    previous = _read_lock(lock_path)
+    payload = {
+        "schema": ECOSYSTEM_LOCK_SCHEMA,
+        "catalog_schema": ECOSYSTEM_SCHEMA,
+        "catalog_version": ECOSYSTEM_CATALOG_VERSION,
+        "generated_at": _now(),
+        "selected_count": len(selected),
+        "unknown_count": len(unknown),
+        "selected": [repo["name"] for repo in selected],
+        "unknown": unknown,
+        "entries": entries,
+        "playbook_files": playbook_files,
+        "previous_generated_at": previous.get("generated_at", ""),
+    }
+    lock_path.write_text(json.dumps(payload, indent=2, ensure_ascii=True), encoding="utf-8")
+    return {
+        "status": "ok",
+        "schema": ECOSYSTEM_LOCK_SCHEMA,
+        "catalog_version": ECOSYSTEM_CATALOG_VERSION,
+        "lock_path": str(lock_path),
+        "repo_dir": str(repo_root),
+        "selected": payload["selected"],
+        "unknown": unknown,
+        "entries": entries,
+        "playbook_files": playbook_files,
+    }
+
+
+def ecosystem_status(*, project_dir: str) -> dict[str, Any]:
+    root = Path(project_dir)
+    repo_root = root / DEFAULT_ECOSYSTEM_REPO_DIR
+    lock_path = root / DEFAULT_ECOSYSTEM_LOCK_PATH
+    lock = _read_lock(lock_path)
+
+    repos = list_ecosystem_repos()
+    statuses: list[dict[str, Any]] = []
+    for repo in repos:
+        target = repo_root / str(repo["name"])
+        if not target.exists():
+            statuses.append(
+                {
+                    "name": repo["name"],
+                    "installed": False,
+                    "repo_segments": [".omg", "ecosystem", "repos", str(repo["name"])],
+                }
+            )
+            continue
+        commit = ""
+        branch = ""
+        error = ""
+        try:
+            commit = _run_git(["-C", str(target), "rev-parse", "HEAD"])
+            branch = _run_git(["-C", str(target), "rev-parse", "--abbrev-ref", "HEAD"])
+        except Exception as exc:
+            error = str(exc)
+        statuses.append(
+            {
+                "name": repo["name"],
+                "installed": True,
+                "repo_segments": [".omg", "ecosystem", "repos", str(repo["name"])],
+                "commit": commit,
+                "branch": branch,
+                "error": error,
+            }
+        )
+
+    return {
+        "status": "ok",
+        "schema": ECOSYSTEM_LOCK_SCHEMA,
+        "catalog_schema": ECOSYSTEM_SCHEMA,
+        "catalog_version": ECOSYSTEM_CATALOG_VERSION,
+        "lock_exists": lock_path.exists(),
+        "lock_generated_at": lock.get("generated_at", ""),
+        "repo_dir": str(repo_root),
+        "repos": statuses,
+    }

package/runtime/equalizer.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+import importlib
+import os
+import shutil
+from typing import Any
+
+from runtime.canonical_surface import is_canonical_parity_host
+from runtime.cli_provider import get_provider
+
+
+_PROVIDERS = ("claude", "codex", "gemini", "kimi")
+
+_COST_TIERS: dict[str, str] = {
+    "kimi": "low",
+    "gemini": "low",
+    "codex": "medium",
+    "claude": "high",
+}
+
+_COST_SCORE: dict[str, int] = {
+    "low": 3,
+    "medium": 2,
+    "high": 1,
+}
+
+_DOMAIN_KEYWORDS: dict[str, tuple[str, ...]] = {
+    "ui_frontend": (
+        "ui",
+        "ux",
+        "frontend",
+        "responsive",
+        "layout",
+        "css",
+        "design",
+        "component",
+        "visual",
+    ),
+    "code_refactor": (
+        "code",
+        "refactor",
+        "bug",
+        "fix",
+        "debug",
+        "backend",
+        "function",
+        "api",
+        "test",
+    ),
+    "complex_architecture": (
+        "architecture",
+        "complex",
+        "system",
+        "tradeoff",
+        "strategy",
+        "multi-step",
+        "cross-functional",
+        "distributed",
+    ),
+    "fast_simple": (
+        "quick",
+        "simple",
+        "minor",
+        "small",
+        "fast",
+        "typo",
+        "rename",
+        "trivial",
+    ),
+}
+
+_DOMAIN_PROVIDER_PREFS: dict[str, tuple[str, ...]] = {
+    "ui_frontend": ("gemini", "claude", "codex", "kimi"),
+    "code_refactor": ("codex", "claude", "gemini", "kimi"),
+    "complex_architecture": ("claude", "codex", "gemini", "kimi"),
+    "fast_simple": ("kimi", "codex", "gemini", "claude"),
+    "general": ("codex", "claude", "gemini", "kimi"),
+}
+
+
+def _extract_provider_telemetry(provider: str, telemetry: dict[str, Any] | None) -> dict[str, Any]:
+    if not telemetry:
+        return {}
+    providers = telemetry.get("providers")
+    if isinstance(providers, dict):
+        data = providers.get(provider)
+        return data if isinstance(data, dict) else {}
+    data = telemetry.get(provider)
+    return data if isinstance(data, dict) else {}
+
+
+def _extract_critic_outcomes(
+    provider: str,
+    context_packet: dict[str, Any] | None,
+    telemetry: dict[str, Any] | None,
+) -> dict[str, Any]:
+    for container in (telemetry, context_packet):
+        if not isinstance(container, dict):
+            continue
+        outcomes = container.get("prior_critic_outcomes") or container.get("critic_outcomes")
+        if isinstance(outcomes, dict):
+            by_provider = outcomes.get("providers") if isinstance(outcomes.get("providers"), dict) else outcomes
+            if isinstance(by_provider, dict):
+                provider_outcomes = by_provider.get(provider)
+                if isinstance(provider_outcomes, dict):
+                    return provider_outcomes
+                if provider in by_provider:
+                    return {}
+                return by_provider
+    return {}
+
+
+def _domain_fit(task_text: str) -> str:
+    lowered = task_text.lower()
+    scores: dict[str, int] = {}
+    for domain, keywords in _DOMAIN_KEYWORDS.items():
+        scores[domain] = sum(1 for kw in keywords if kw in lowered)
+    best_domain = "general"
+    best_score = 0
+    for domain, score in scores.items():
+        if score > best_score:
+            best_score = score
+            best_domain = domain
+    if best_score <= 0:
+        return "general"
+    return best_domain
+
+
+def _probe_provider(provider: str) -> tuple[bool, bool | None, str]:
+    if os.environ.get("OMG_TEST_FAKE_PROVIDER_HEALTH", "").strip() == "1":
+        return True, True, "test-health-override"
+
+    normalized_provider = str(provider).strip().lower()
+    if normalized_provider == "claude":
+        claude_bin = os.environ.get("OMG_CLAUDE_BIN", "claude")
+        worker_cmd = os.environ.get("OMG_CLAUDE_WORKER_CMD", "").strip()
+        if worker_cmd or shutil.which(claude_bin) is not None:
+            return True, None, "cli-detected"
+        return False, False, "provider CLI unavailable"
+
+    if not is_canonical_parity_host(normalized_provider):
+        return False, False, "unsupported provider"
+
+    module_name = f"runtime.providers.{normalized_provider}_provider"
+    try:
+        _ = importlib.import_module(module_name)
+    except Exception as exc:
+        return False, False, f"provider module import failed: {exc}"
+
+    cli_provider = get_provider(normalized_provider)
+    if cli_provider is None:
+        return False, False, "provider not registered"
+
+    try:
+        available = bool(cli_provider.detect())
+    except Exception as exc:
+        return False, None, f"provider detect failed: {exc}"
+
+    if not available:
+        return False, False, "provider CLI unavailable"
+
+    auth_ok: bool | None
+    try:
+        auth_ok, _msg = cli_provider.check_auth()
+    except Exception as exc:
+        return True, None, f"auth check error: {exc}"
+    return True, auth_ok, "ok"
+
+
+def _score_provider(
+    provider: str,
+    domain_fit: str,
+    context_packet: dict[str, Any] | None,
+    telemetry: dict[str, Any] | None,
+) -> tuple[float, list[str], bool]:
+    available, auth_ok, status = _probe_provider(provider)
+    reasons: list[str] = [status]
+    score = 0.0
+
+    ranked = _DOMAIN_PROVIDER_PREFS.get(domain_fit, _DOMAIN_PROVIDER_PREFS["general"])
+    if provider in ranked:
+        score += float(max(0, 5 - ranked.index(provider)))
+        reasons.append(f"domain-rank={ranked.index(provider) + 1}")
+
+    cost_tier = _COST_TIERS.get(provider, "high")
+    score += float(_COST_SCORE.get(cost_tier, 0))
+    reasons.append(f"cost={cost_tier}")
+
+    if available:
+        score += 3.0
+        reasons.append("available")
+    else:
+        score -= 50.0
+        reasons.append("unavailable")
+
+    if auth_ok is True:
+        score += 2.0
+        reasons.append("auth-ok")
+    elif auth_ok is False:
+        score -= 8.0
+        reasons.append("auth-failed")
+    else:
+        score -= 1.0
+        reasons.append("auth-unknown")
+
+    provider_telemetry = _extract_provider_telemetry(provider, telemetry)
+    latency_ms = provider_telemetry.get("latency_ms")
+    if isinstance(latency_ms, (int, float)):
+        latency_penalty = min(5.0, float(latency_ms) / 250.0)
+        score -= latency_penalty
+        reasons.append(f"latency={int(latency_ms)}ms")
+
+    failure_rate = provider_telemetry.get("failure_rate")
+    if isinstance(failure_rate, (int, float)):
+        fr = min(max(float(failure_rate), 0.0), 1.0)
+        score -= fr * 6.0
+        reasons.append(f"failure-rate={fr:.2f}")
+
+    critic = _extract_critic_outcomes(provider, context_packet, telemetry)
+    if critic:
+        for critic_name in ("skeptic", "hallucination_auditor"):
+            critic_result = critic.get(critic_name)
+            if not isinstance(critic_result, dict):
+                continue
+            verdict = str(critic_result.get("verdict", "pass")).lower()
+            if verdict == "fail":
+                score -= 8.0
+                reasons.append(f"{critic_name}=fail")
+            elif verdict == "warn":
+                score -= 3.0
+                reasons.append(f"{critic_name}=warn")
+            else:
+                score += 0.5
+                reasons.append(f"{critic_name}=pass")
+
+    return score, reasons, available
+
+
+def select_provider(
+    task_text: str,
+    project_dir: str,
+    context_packet: dict[str, Any] | None = None,
+    telemetry: dict[str, Any] | None = None,
+) -> dict[str, str]:
+    _ = project_dir
+    domain_fit = _domain_fit(task_text)
+
+    scored: list[tuple[str, float, list[str], bool]] = []
+    for provider in _PROVIDERS:
+        score, reasons, available = _score_provider(provider, domain_fit, context_packet, telemetry)
+        scored.append((provider, score, reasons, available))
+
+    scored.sort(key=lambda row: row[1], reverse=True)
+    selected_provider, _score, selected_reasons, selected_available = scored[0]
+
+    if not selected_available:
+        selected_provider = "claude"
+        selected_reasons = ["fallback=claude", *selected_reasons]
+
+    return {
+        "provider": selected_provider,
+        "reason": "; ".join(selected_reasons[:5]),
+        "cost_tier": _COST_TIERS.get(selected_provider, "high"),
+        "domain_fit": domain_fit,
+    }
+
+
+__all__ = ["select_provider"]