@trac3er/oh-my-god 2.0.4 → 2.0.7

package/build/lib/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.7"
+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/eval_gate.py

@@ -0,0 +1,96 @@
+"""Reproducible evaluation results for release gating."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import getpass
+import json
+import os
+from pathlib import Path
+import platform
+import socket
+from typing import Any
+from uuid import uuid4
+
+
+EVAL_GATE_LATEST_REL_PATH = Path(".omg") / "evals" / "latest.json"
+EVAL_GATE_HISTORY_REL_PATH = Path(".omg") / "evals" / "history.jsonl"
+EVAL_GATE_TRACE_LINKS_REL_PATH = Path(".omg") / "evals" / "trace-links.jsonl"
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _executor() -> dict[str, str | int]:
+    return {
+        "user": getpass.getuser(),
+        "pid": os.getpid(),
+    }
+
+
+def _environment() -> dict[str, str]:
+    return {
+        "hostname": socket.gethostname(),
+        "platform": platform.platform(),
+    }
+
+
+def evaluate_trace(
+    project_dir: str,
+    *,
+    trace_id: str,
+    suites: list[str],
+    metrics: dict[str, float],
+    lineage: dict[str, Any] | None = None,
+    regression_threshold: float = 0.95,
+) -> dict[str, Any]:
+    eval_id = f"eval-{uuid4().hex}"
+    scorecard = {name: float(metrics.get(name, 0.0)) for name in suites}
+    regressed = any(score < regression_threshold for score in scorecard.values())
+    result = {
+        "schema": "EvalGateResult",
+        "eval_id": eval_id,
+        "trace_id": trace_id,
+        "lineage": lineage or {},
+        "evaluated_at": _now(),
+        "timestamp": _now(),
+        "executor": _executor(),
+        "environment": _environment(),
+        "status": "fail" if regressed else "ok",
+        "suites": suites,
+        "metrics": scorecard,
+        "summary": {
+            "regressed": regressed,
+            "regression_threshold": regression_threshold,
+        },
+    }
+
+    latest_path = Path(project_dir) / EVAL_GATE_LATEST_REL_PATH
+    latest_path.parent.mkdir(parents=True, exist_ok=True)
+    _ = latest_path.write_text(json.dumps(result, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+
+    _ = link_trace(project_dir, eval_id=eval_id, trace_id=trace_id)
+
+    history_path = Path(project_dir) / EVAL_GATE_HISTORY_REL_PATH
+    with history_path.open("a", encoding="utf-8") as handle:
+        _ = handle.write(json.dumps(result, ensure_ascii=True) + "\n")
+
+    result["path"] = EVAL_GATE_LATEST_REL_PATH.as_posix()
+    return result
+
+
+def link_trace(project_dir: str, *, eval_id: str, trace_id: str) -> dict[str, Any]:
+    link = {
+        "schema": "EvalTraceLink",
+        "eval_id": eval_id,
+        "trace_id": trace_id,
+        "timestamp": _now(),
+        "executor": _executor(),
+        "environment": _environment(),
+    }
+    path = Path(project_dir) / EVAL_GATE_TRACE_LINKS_REL_PATH
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as handle:
+        _ = handle.write(json.dumps(link, ensure_ascii=True) + "\n")
+    link["path"] = EVAL_GATE_TRACE_LINKS_REL_PATH.as_posix()
+    return link

package/build/lib/runtime/guide_assert.py

@@ -0,0 +1,45 @@
+"""Rule-based output assertions for OMG guide checks."""
+from __future__ import annotations
+
+from typing import Any
+
+
+def guide_assert(candidate: str, rules: dict[str, Any]) -> dict[str, Any]:
+    text = candidate or ""
+    lowered = text.lower()
+    violations: list[dict[str, str]] = []
+
+    for goal in _as_list(rules.get("goals")):
+        if "todo" in goal.lower() and "todo" in lowered:
+            violations.append({"rule_type": "goal", "rule": goal, "reason": "candidate still includes TODO markers"})
+
+    for non_goal in _as_list(rules.get("non_goals")):
+        if _mentions(lowered, non_goal):
+            violations.append({"rule_type": "non_goal", "rule": non_goal, "reason": "candidate mentions an explicit non-goal"})
+
+    for criterion in _as_list(rules.get("acceptance_criteria")):
+        if "production-ready" in criterion.lower() and any(token in lowered for token in ("todo", "insecure", "placeholder")):
+            violations.append({"rule_type": "acceptance_criteria", "rule": criterion, "reason": "candidate contains non-production wording"})
+
+    return {
+        "schema": "GuideAssertionResult",
+        "verdict": "fail" if violations else "pass",
+        "violations": violations,
+        "summary": {
+            "rule_count": sum(len(_as_list(rules.get(key))) for key in ("goals", "non_goals", "acceptance_criteria", "architecture_constraints", "style_rules", "risk_appetite")),
+            "violation_count": len(violations),
+        },
+    }
+
+
+def _as_list(value: Any) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [str(item) for item in value if str(item).strip()]
+
+
+def _mentions(lowered_candidate: str, rule: str) -> bool:
+    tokens = [token.lower() for token in rule.split() if len(token) >= 4]
+    if not tokens:
+        return False
+    return all(token in lowered_candidate for token in tokens)

package/build/lib/runtime/incident_replay.py

@@ -0,0 +1,47 @@
+"""Replayable incident pack generation."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+from typing import Any
+from uuid import uuid4
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def build_incident_pack(
+    project_dir: str,
+    *,
+    title: str,
+    failing_tests: list[str],
+    logs: list[str],
+    diff_summary: dict[str, Any],
+    trace_id: str | None = None,
+) -> dict[str, Any]:
+    incident_id = f"incident-{uuid4().hex}"
+    payload = {
+        "schema": "IncidentReplayPack",
+        "incident_id": incident_id,
+        "title": title,
+        "generated_at": _now(),
+        "trace_id": trace_id or "",
+        "failing_tests": failing_tests,
+        "logs": logs,
+        "diff_summary": diff_summary,
+        "reproduction_steps": [
+            "Replay the failing tests.",
+            "Inspect the attached logs.",
+            "Validate the diff summary before patching.",
+        ],
+        "regression_guards": failing_tests,
+    }
+
+    rel_path = Path(".omg") / "incidents" / f"{incident_id}.json"
+    path = Path(project_dir) / rel_path
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+    payload["path"] = rel_path.as_posix()
+    return payload

package/build/lib/runtime/legacy_compat.py

@@ -0,0 +1,7 @@
+"""Backward-compatible alias module.
+
+Primary implementation lives in `runtime.compat`.
+"""
+from __future__ import annotations
+
+from .compat import *  # noqa: F401,F403