@trac3er/oh-my-god 2.2.2 → 2.3.0

package/build/lib/runtime/ecosystem.py

@@ -1,371 +0,0 @@
-"""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/trac3er00/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/build/lib/runtime/equalizer.py

@@ -1,265 +0,0 @@
-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]:
-    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"]