@trac3er/oh-my-god 2.0.0 → 2.0.2

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 = "1.0.0"
+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/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

package/runtime/mcp_config_writers.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import cast
+
+
+def _atomic_write_text(path: Path, content: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = path.with_name(f"{path.name}.tmp")
+    _ = tmp_path.write_text(content)
+    _ = os.replace(tmp_path, path)
+
+
+def _load_json(path: Path) -> dict[str, object]:
+    if not path.exists():
+        return {}
+    try:
+        parsed = cast(object, json.loads(path.read_text()))
+        if isinstance(parsed, dict):
+            return cast(dict[str, object], parsed)
+        return {}
+    except (json.JSONDecodeError, ValueError):
+        return {}
+
+
+def _write_json(path: Path, data: dict[str, object]) -> None:
+    _atomic_write_text(path, json.dumps(data, indent=2) + "\n")
+
+
+def write_claude_mcp_config(project_dir: str, server_url: str, server_name: str = "memory-server") -> None:
+    config_path = Path(project_dir) / ".mcp.json"
+    config = _load_json(config_path)
+    mcp_servers = config.get("mcpServers")
+    if not isinstance(mcp_servers, dict):
+        mcp_servers = {}
+        config["mcpServers"] = mcp_servers
+    mcp_servers[server_name] = {"type": "http", "url": server_url}
+    _write_json(config_path, config)
+
+
+def write_codex_mcp_config(server_url: str, server_name: str = "memory-server") -> None:
+    config_path = Path.home() / ".codex" / "config.toml"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    existing = config_path.read_text() if config_path.exists() else ""
+    lines = existing.splitlines(keepends=True)
+
+    header_unquoted = f"[mcp_servers.{server_name}]"
+    header_quoted = f"[mcp_servers.\"{server_name}\"]"
+    headers = {header_unquoted, header_quoted}
+
+    start_idx: int | None = None
+    for idx, line in enumerate(lines):
+        if line.strip() in headers:
+            start_idx = idx
+            break
+
+    block = [
+        f"{header_unquoted}\n",
+        'type = "http"\n',
+        f'url = "{server_url}"\n',
+        "\n",
+    ]
+
+    if start_idx is None:
+        if existing and not existing.endswith("\n"):
+            existing += "\n"
+        content = existing + "".join(block)
+        _atomic_write_text(config_path, content)
+        return
+
+    end_idx = len(lines)
+    for idx in range(start_idx + 1, len(lines)):
+        stripped = lines[idx].strip()
+        if stripped.startswith("[") and stripped.endswith("]"):
+            end_idx = idx
+            break
+
+    updated_lines = lines[:start_idx] + block + lines[end_idx:]
+    _atomic_write_text(config_path, "".join(updated_lines))
+
+
+def write_gemini_mcp_config(server_url: str, server_name: str = "memory-server") -> None:
+    config_path = Path.home() / ".gemini" / "settings.json"
+    config = _load_json(config_path)
+    mcp_servers = config.get("mcpServers")
+    if not isinstance(mcp_servers, dict):
+        mcp_servers = {}
+        config["mcpServers"] = mcp_servers
+    mcp_servers[server_name] = {"httpUrl": server_url}
+    _write_json(config_path, config)
+
+
+def write_opencode_mcp_config(server_url: str, server_name: str = "memory-server") -> None:
+    config_path = Path.home() / ".config" / "opencode" / "opencode.json"
+    config = _load_json(config_path)
+    mcp = config.get("mcp")
+    if not isinstance(mcp, dict):
+        mcp = {}
+        config["mcp"] = mcp
+    mcp[server_name] = {"type": "remote", "url": server_url}
+    _write_json(config_path, config)
+
+
+def write_kimi_mcp_config(server_url: str, server_name: str = "memory-server") -> None:
+    config_path = Path.home() / ".kimi" / "mcp.json"
+    config = _load_json(config_path)
+    mcp_servers = config.get("mcpServers")
+    if not isinstance(mcp_servers, dict):
+        mcp_servers = {}
+        config["mcpServers"] = mcp_servers
+    mcp_servers[server_name] = {"type": "http", "url": server_url}
+    _write_json(config_path, config)

package/runtime/mcp_lifecycle.py

@@ -0,0 +1,153 @@
+"""MCP server lifecycle manager — start/stop/health/ensure."""
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+
+def get_pid_file_path() -> str:
+    """Return path to the PID file for the memory server."""
+    return str(Path.home() / ".omg" / "shared-memory" / "server.pid")
+
+
+def get_server_url() -> str:
+    """Return the MCP server URL using host/port from mcp_memory_server."""
+    from runtime.mcp_memory_server import get_host, get_port
+
+    return f"http://{get_host()}:{get_port()}/mcp"
+
+
+def _read_pid() -> int | None:
+    """Read PID from PID file. Returns None if missing or invalid."""
+    try:
+        return int(Path(get_pid_file_path()).read_text().strip())
+    except (FileNotFoundError, ValueError):
+        return None
+
+
+def is_server_running() -> bool:
+    """Check if the memory server process is alive."""
+    pid = _read_pid()
+    if pid is None:
+        return False
+    try:
+        os.kill(pid, 0)
+        return True
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True  # Process exists but we can't signal it
+
+
+def _wait_for_health(url: str, timeout: float = 5.0) -> bool:
+    """Wait for server health endpoint to respond."""
+    import urllib.request
+
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        try:
+            with urllib.request.urlopen(url, timeout=1) as resp:
+                if resp.status == 200:
+                    return True
+        except Exception:
+            time.sleep(0.1)
+    return False
+
+
+def _wait_for_exit(pid: int, timeout: float = 5.0) -> bool:
+    """Wait for a process to exit."""
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        try:
+            os.kill(pid, 0)
+            time.sleep(0.1)
+        except (ProcessLookupError, PermissionError):
+            return True
+    return False
+
+
+def start_memory_server() -> dict[str, Any]:
+    """Start the MCP memory server as a background process."""
+    if is_server_running():
+        return {"status": "already_running", "url": get_server_url()}
+
+    pid_path = Path(get_pid_file_path())
+    pid_path.parent.mkdir(parents=True, exist_ok=True)
+
+    try:
+        server_script = str(Path(__file__).parent / "mcp_memory_server.py")
+        proc = subprocess.Popen(
+            [sys.executable, server_script],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+        pid_path.write_text(str(proc.pid))
+
+        health_url = get_server_url().replace("/mcp", "/health")
+        if _wait_for_health(health_url):
+            return {"status": "started", "pid": proc.pid, "url": get_server_url()}
+        else:
+            return {
+                "status": "error",
+                "message": "Server did not respond within timeout",
+            }
+    except Exception as exc:
+        return {"status": "error", "message": str(exc)}
+
+
+def stop_memory_server() -> dict[str, Any]:
+    """Stop the MCP memory server."""
+    if not is_server_running():
+        return {"status": "not_running"}
+
+    pid = _read_pid()
+    if pid is None:
+        return {"status": "not_running"}
+
+    try:
+        os.kill(pid, signal.SIGTERM)
+        _wait_for_exit(pid)
+
+        pid_path = Path(get_pid_file_path())
+        if pid_path.exists():
+            pid_path.unlink()
+
+        return {"status": "stopped", "pid": pid}
+    except ProcessLookupError:
+        pid_path = Path(get_pid_file_path())
+        if pid_path.exists():
+            pid_path.unlink()
+        return {"status": "stopped", "pid": pid}
+    except Exception as exc:
+        return {"status": "error", "message": str(exc)}
+
+
+def check_memory_server() -> dict[str, Any]:
+    """Check the memory server status."""
+    running = is_server_running()
+    if not running:
+        return {"running": False, "url": None, "pid": None}
+
+    return {
+        "running": True,
+        "url": get_server_url(),
+        "pid": _read_pid(),
+    }
+
+
+def ensure_memory_server() -> dict[str, Any]:
+    """Ensure the memory server is running (idempotent)."""
+    if is_server_running():
+        return {"status": "already_running", "url": get_server_url()}
+    return start_memory_server()
+
+
+# Feature flag: auto-start on import
+if os.environ.get("OMG_MEMORY_AUTOSTART") == "1":
+    ensure_memory_server()