@trac3er/oh-my-god 2.0.0 → 2.0.2

package/plugins/viz/native_parsers.py

@@ -0,0 +1,259 @@
+"""Native toolchain dependency parsers for Go, TypeScript, and Rust.
+
+Shells out to `go list -json`, `tsc --listFiles`, and `cargo metadata`
+for higher-accuracy dependency graphs (~95%) compared to regex parsers.
+
+Standalone extension — graph_builder.py can optionally import this module.
+Feature-gated behind CODEBASE_VIZ.
+
+All subprocess calls use argv lists (never shell=True) with timeout=30.
+All functions handle exceptions gracefully and never raise to the caller.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from typing import Any
+
+
+def is_toolchain_available(toolchain: str) -> bool:
+    """Check if a toolchain binary is installed and on PATH.
+
+    Args:
+        toolchain: Name of the binary (e.g. ``"go"``, ``"tsc"``, ``"cargo"``).
+
+    Returns:
+        True if the binary is found, False otherwise.
+    """
+    try:
+        return shutil.which(toolchain) is not None
+    except Exception:
+        return False
+
+
+def _error_result(language: str, message: str) -> dict[str, Any]:
+    """Build a standardised error result dict."""
+    return {
+        "error": message,
+        "accuracy": "N/A",
+        "graph": {},
+        "language": language,
+    }
+
+
+def _run_subprocess(
+    argv: list[str],
+    cwd: str,
+) -> tuple[str | None, str | None]:
+    """Run a subprocess safely with timeout.
+
+    Returns:
+        (stdout, None) on success, (None, error_message) on failure.
+    """
+    try:
+        proc = subprocess.run(
+            argv,
+            capture_output=True,
+            text=True,
+            cwd=cwd,
+            timeout=30,
+        )
+    except subprocess.TimeoutExpired:
+        return None, f"timeout: {argv[0]} timed out after 30s"
+    except OSError as exc:
+        return None, f"os-error: {exc}"
+    except Exception as exc:
+        return None, f"unexpected-error: {exc}"
+
+    if proc.returncode != 0:
+        stderr_snippet = (proc.stderr or "").strip()[:200]
+        return None, f"{argv[0]} exited with code {proc.returncode}: {stderr_snippet}"
+
+    return proc.stdout, None
+
+
+# ---------------------------------------------------------------------------
+# Go: go list -json ./...
+# ---------------------------------------------------------------------------
+
+def _parse_concatenated_json(raw: str) -> list[dict[str, Any]]:
+    """Parse concatenated JSON objects (go list -json output format).
+
+    ``go list -json`` emits multiple JSON objects concatenated together,
+    not a JSON array.  We use ``json.JSONDecoder.raw_decode`` to stream
+    through the buffer.
+    """
+    decoder = json.JSONDecoder()
+    objects: list[dict[str, Any]] = []
+    idx = 0
+    length = len(raw)
+
+    while idx < length:
+        # Skip whitespace
+        while idx < length and raw[idx] in " \t\n\r":
+            idx += 1
+        if idx >= length:
+            break
+        try:
+            obj, end_idx = decoder.raw_decode(raw, idx)
+            objects.append(obj)
+            idx = end_idx
+        except json.JSONDecodeError:
+            break
+
+    return objects
+
+
+def parse_go_native(project_dir: str) -> dict[str, Any]:
+    """Parse Go dependencies using ``go list -json ./...``.
+
+    Returns an adjacency list keyed by Go import path.
+    Accuracy: native-95% when Go toolchain is available.
+    """
+    try:
+        if not is_toolchain_available("go"):
+            return _error_result("go", "go toolchain not found")
+
+        stdout, err = _run_subprocess(
+            ["go", "list", "-json", "./..."],
+            cwd=project_dir,
+        )
+        if err is not None:
+            return _error_result("go", err)
+
+        packages = _parse_concatenated_json(stdout or "")
+        graph: dict[str, list[str]] = {}
+
+        for pkg in packages:
+            import_path = pkg.get("ImportPath", "")
+            imports = pkg.get("Imports") or []
+            if import_path:
+                graph[import_path] = list(imports)
+
+        return {
+            "graph": graph,
+            "accuracy": "native-95%",
+            "language": "go",
+        }
+
+    except Exception as exc:
+        return _error_result("go", f"unexpected-error: {exc}")
+
+
+# ---------------------------------------------------------------------------
+# TypeScript: tsc --listFiles --noEmit
+# ---------------------------------------------------------------------------
+
+def parse_typescript_native(project_dir: str) -> dict[str, Any]:
+    """Parse TypeScript project files using ``tsc --listFiles --noEmit``.
+
+    Extracts module names from file paths, excluding ``node_modules``.
+    Accuracy: native-95% when tsc is available.
+    """
+    try:
+        if not is_toolchain_available("tsc"):
+            return _error_result("typescript", "tsc toolchain not found")
+
+        stdout, err = _run_subprocess(
+            ["tsc", "--listFiles", "--noEmit"],
+            cwd=project_dir,
+        )
+        if err is not None:
+            return _error_result("typescript", err)
+
+        graph: dict[str, list[str]] = {}
+        lines = (stdout or "").strip().splitlines()
+
+        for line in lines:
+            file_path = line.strip()
+            if not file_path:
+                continue
+            # Skip node_modules and .d.ts declaration files from stdlib
+            if "node_modules" in file_path:
+                continue
+
+            # Derive a module name from the file path relative to project_dir
+            module_name = _ts_module_name(file_path, project_dir)
+            if module_name:
+                graph[module_name] = []
+
+        return {
+            "graph": graph,
+            "accuracy": "native-95%",
+            "language": "typescript",
+        }
+
+    except Exception as exc:
+        return _error_result("typescript", f"unexpected-error: {exc}")
+
+
+def _ts_module_name(file_path: str, project_dir: str) -> str:
+    """Derive a TypeScript module name from a file path."""
+    try:
+        # Normalise paths
+        fp = file_path.replace("\\", "/")
+        pd = project_dir.rstrip("/").replace("\\", "/") + "/"
+
+        if fp.startswith(pd):
+            rel = fp[len(pd):]
+        else:
+            rel = fp
+
+        # Strip extensions
+        for ext in (".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs"):
+            if rel.endswith(ext):
+                rel = rel[: -len(ext)]
+                break
+
+        # Convert path separators to dots
+        return rel.replace("/", ".")
+    except Exception:
+        return ""
+
+
+# ---------------------------------------------------------------------------
+# Rust: cargo metadata --format-version=1 --no-deps
+# ---------------------------------------------------------------------------
+
+def parse_rust_native(project_dir: str) -> dict[str, Any]:
+    """Parse Rust dependencies using ``cargo metadata``.
+
+    Returns an adjacency list keyed by crate name.
+    Accuracy: native-95% when Cargo toolchain is available.
+    """
+    try:
+        if not is_toolchain_available("cargo"):
+            return _error_result("rust", "cargo toolchain not found")
+
+        stdout, err = _run_subprocess(
+            ["cargo", "metadata", "--format-version=1", "--no-deps"],
+            cwd=project_dir,
+        )
+        if err is not None:
+            return _error_result("rust", err)
+
+        try:
+            metadata = json.loads(stdout or "{}")
+        except json.JSONDecodeError as exc:
+            return _error_result("rust", f"json-parse-error: {exc}")
+
+        graph: dict[str, list[str]] = {}
+        packages = metadata.get("packages") or []
+
+        for pkg in packages:
+            name = pkg.get("name", "")
+            deps = pkg.get("dependencies") or []
+            dep_names = [d.get("name", "") for d in deps if d.get("name")]
+            if name:
+                graph[name] = dep_names
+
+        return {
+            "graph": graph,
+            "accuracy": "native-95%",
+            "language": "rust",
+        }
+
+    except Exception as exc:
+        return _error_result("rust", f"unexpected-error: {exc}")

package/plugins/viz/regex_parser.py

@@ -0,0 +1,112 @@
+"""Regex-based import parsers for JavaScript/TypeScript and Go.
+
+These parsers are intentionally lightweight and best-effort.
+"""
+
+from pathlib import Path
+import re
+from typing import NotRequired, TypedDict, cast
+
+
+class ParseResult(TypedDict):
+    imports: list[str]
+    accuracy: str
+    language: str
+    error: NotRequired[str]
+
+
+def _read_text_file(file_path: str) -> tuple[str | None, str | None]:
+    """Read UTF-8 text safely, returning (text, error)."""
+    try:
+        raw = Path(file_path).read_bytes()
+    except OSError as exc:
+        return None, f"file-read-error: {exc}"
+
+    if b"\x00" in raw:
+        return None, "unparseable-file: binary content detected"
+
+    try:
+        return raw.decode("utf-8"), None
+    except UnicodeDecodeError as exc:
+        return None, f"unparseable-file: {exc}"
+
+
+def _result(imports: list[str], accuracy: str, language: str, error: str | None) -> ParseResult:
+    result: ParseResult = {
+        "imports": imports,
+        "accuracy": accuracy,
+        "language": language,
+    }
+    if error:
+        result["error"] = error
+    return result
+
+
+def _unique(values: list[str]) -> list[str]:
+    seen: set[str] = set()
+    ordered: list[str] = []
+    for value in values:
+        if value not in seen:
+            seen.add(value)
+            ordered.append(value)
+    return ordered
+
+
+def parse_js_imports(file_path: str) -> ParseResult:
+    """Parse JS/TS import specifiers from a file via regex (~70% accuracy).
+
+    Accuracy: ~70% ("regex-70%").
+    Known misses: dynamic imports with variables/template literals,
+    complex transpiler syntax, and imports hidden in non-UTF8 files.
+    """
+    text, error = _read_text_file(file_path)
+    if text is None:
+        return _result([], "regex-70%", "javascript", error)
+
+    imports: list[str] = []
+
+    static_import_re = re.compile(
+        r"^\s*import\s+(?:[\w*$\s{},]+\s+from\s+)?['\"]([^'\"]+)['\"]",
+        re.MULTILINE,
+    )
+    require_re = re.compile(r"require\s*\(\s*['\"]([^'\"]+)['\"]\s*\)")
+    export_from_re = re.compile(
+        r"^\s*export\s+\*\s+from\s+['\"]([^'\"]+)['\"]",
+        re.MULTILINE,
+    )
+    dynamic_import_re = re.compile(r"import\s*\(\s*['\"]([^'\"]+)['\"]\s*\)")
+
+    imports.extend(static_import_re.findall(text))
+    imports.extend(require_re.findall(text))
+    imports.extend(export_from_re.findall(text))
+    imports.extend(dynamic_import_re.findall(text))
+
+    return _result(_unique(imports), "regex-70%", "javascript", None)
+
+
+def parse_go_imports(file_path: str) -> ParseResult:
+    """Parse Go import paths from a file via regex (~80% accuracy).
+
+    Accuracy: ~80% ("regex-80%").
+    Known misses: imports gated by build tags/conditional file inclusion,
+    and non-UTF8 or unparseable files.
+    """
+    text, error = _read_text_file(file_path)
+    if text is None:
+        return _result([], "regex-80%", "go", error)
+
+    imports: list[str] = []
+
+    single_or_alias_re = re.compile(
+        r'^\s*import\s+(?:[A-Za-z_][\w.]*)?\s*"([^"]+)"',
+        re.MULTILINE,
+    )
+    block_re = re.compile(r"import\s*\((.*?)\)", re.DOTALL)
+    block_entry_re = re.compile(r'(?:[A-Za-z_][\w.]*)?\s*"([^"]+)"')
+
+    imports.extend(single_or_alias_re.findall(text))
+
+    for block in cast(list[str], block_re.findall(text)):
+        imports.extend(block_entry_re.findall(block))
+
+    return _result(_unique(imports), "regex-80%", "go", None)

package/pyproject.toml

@@ -0,0 +1,81 @@
+[build-system]
+requires = ["setuptools>=65.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "oh-my-god"
+version = "2.0.0b1"
+description = "OMG (Oh My God) — Multi-agent orchestration, intelligent model routing, and durable session state for Claude Code"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+    {name = "trac3er00", email = "trac3er00@example.com"}
+]
+keywords = ["claude", "claude-code", "orchestration", "multi-agent", "ai", "llm", "codex", "gemini"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "fastmcp>=2.0",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+]
+mcp = [
+    "fastmcp>=2.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/trac3er00/OMG"
+Repository = "https://github.com/trac3er00/OMG.git"
+Issues = "https://github.com/trac3er00/OMG/issues"
+
+[tool.setuptools]
+packages = ["hooks", "runtime", "agents", "commands"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = [
+    "--strict-markers",
+    "--cov=.",
+    "--cov-report=term-missing",
+    "--cov-report=html",
+]
+markers = [
+    "slow: marks tests as slow",
+    "integration: marks tests as integration tests",
+    "unit: marks tests as unit tests",
+]
+
+[tool.coverage.run]
+source = ["."]
+omit = [
+    "tests/*",
+    "*/__pycache__/*",
+    ".venv/*",
+    "setup.py",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+]

package/rules/contextual/write-verify.md

@@ -3,7 +3,7 @@
 When any file write or edit operation shows an error, warning, or hook error:
 
 1. **NEVER claim success** without reading the file to verify changes are present
-2. **Hook errors from external plugins** (e.g. `security_reminder_hook.ts`) are warnings — the write may have succeeded. READ the file to check.
+2. **Hook errors from external plugins** (e.g. security_reminder_hook.py) are warnings — the write may have succeeded. READ the file to check.
 3. **"Error editing file"** means the Edit tool failed. Use an alternative:
    - Try `Write` tool (creates new file)
    - Try Bash: `cat > path/to/file << 'EOF'\n[content]\nEOF`
@@ -13,7 +13,7 @@ When any file write or edit operation shows an error, warning, or hook error:
 
 ## Common Hook Error Pattern
 ```
-Error: PreToolUse:Write hook error: [bun .../security_reminder_hook.ts]: warning emitted by external hook
+Error: PreToolUse:Write hook error: [python3 .../security_reminder_hook.py]: ⚠️ Security Warning: ...
 ```
 This means an external hook emitted a warning. The file write likely succeeded.
 **Action:** Read the file to verify, then continue. Do NOT retry blindly.

package/rules/core/00-truth.md

@@ -17,4 +17,4 @@ NEVER claim a state you haven't verified. Period.
 
 Forbidden without evidence: "done", "LGTM", "fixed", "works now", "tests passed"
 
-> Enforced: stop-gate.ts checks evidence. tool-ledger.ts logs tool calls.
+> Enforced: stop-gate.py checks evidence. tool-ledger.py logs tool calls.

package/rules/core/01-surgical.md

@@ -16,4 +16,4 @@ For 3+ file changes: create .omg/state/_plan.md + _checklist.md BEFORE coding.
 Mark [x] immediately as steps complete. Update plan when approach changes.
 If stuck 2x: STOP. Try different approach or /OMG:escalate.
 
-> Enforced: stop-gate.ts checks diff budget. circuit-breaker.ts catches loops.
+> Enforced: stop-gate.py checks diff budget. circuit-breaker.py catches loops.

package/rules/core/02-circuit-breaker.md

@@ -16,7 +16,7 @@ Options:
 - **Force-Fixer:** Immediately try to fix without understanding root cause
 
 ## Auto-Escalation
-After 3 failures: circuit-breaker.ts suggests /OMG:escalate with specific context.
+After 3 failures: circuit-breaker.py suggests /OMG:escalate with specific context.
 After 5 failures: HARD BLOCK. Must escalate or get user input.
 
-> Enforced: circuit-breaker.ts tracks patterns + auto-escalates.
+> Enforced: circuit-breaker.py tracks patterns + auto-escalates.

package/rules/core/03-ensemble.md

@@ -13,8 +13,8 @@
 - Stuck on anything for 3+ attempts → /OMG:escalate to relevant model
 
 ## Auto-Detection
-prompt-enhancer.ts detects keywords and suggests the right model.
-circuit-breaker.ts auto-suggests escalation after failures.
+prompt-enhancer.py detects keywords and suggests the right model.
+circuit-breaker.py auto-suggests escalation after failures.
 
 ## Plugins & MCPs
 - Installed plugins: USE them (they're installed for a reason)
@@ -25,4 +25,4 @@ circuit-breaker.ts auto-suggests escalation after failures.
 Say: "This touches auth — let me get Codex to check the security."
 NOT: "Invoking cross-model review protocol for backend analysis."
 
-> Enforced: prompt-enhancer.ts + session-start.ts detect available tools.
+> Enforced: prompt-enhancer.py + session-start.py detect available tools.

package/rules/core/04-testing.md

@@ -24,7 +24,7 @@ Then write tests for THOSE scenarios.
 
 ## Quality Gate
 Every change runs: format → lint → typecheck (if typed) → test
-If quality-gate.json exists, quality-runner.ts enforces this.
+If quality-gate.json exists, quality-runner.py enforces this.
 
-> Enforced: test-generator-hook.ts catches missing coverage follow-up for generated tests.
-> quality-runner.ts runs QA commands.
+> Enforced: test-validator.py catches fake/boilerplate tests.
+> quality-runner.py runs QA commands.

package/runtime/__init__.py

@@ -0,0 +1,32 @@
+"""Runtime package for OMG."""
+
+from .compat import (
+    build_compat_gap_report,
+    build_omg_gap_report,
+    dispatch_compat_skill,
+    dispatch_omg_skill,
+    get_compat_skill_contract,
+    get_omg_skill_contract,
+    list_compat_skill_contracts,
+    list_compat_skills,
+    list_omg_skill_contracts,
+    list_omg_skills,
+)
+from .ecosystem import ecosystem_status, list_ecosystem_repos, resolve_ecosystem_selection, sync_ecosystem_repos
+
+__all__ = [
+    "build_compat_gap_report",
+    "build_omg_gap_report",
+    "dispatch_compat_skill",
+    "dispatch_omg_skill",
+    "get_compat_skill_contract",
+    "get_omg_skill_contract",
+    "list_compat_skill_contracts",
+    "list_compat_skills",
+    "list_omg_skill_contracts",
+    "list_omg_skills",
+    "ecosystem_status",
+    "list_ecosystem_repos",
+    "resolve_ecosystem_selection",
+    "sync_ecosystem_repos",
+]

package/runtime/adapters/__init__.py

@@ -0,0 +1,13 @@
+"""Runtime adapters for OMG v1."""
+
+from .claude import ClaudeAdapter
+from .gpt import GPTAdapter
+from .local import LocalAdapter
+
+
+def get_adapters():
+    return {
+        "claude": ClaudeAdapter(),
+        "gpt": GPTAdapter(),
+        "local": LocalAdapter(),
+    }

package/runtime/adapters/claude.py

@@ -0,0 +1,60 @@
+"""Claude runtime adapter (v1 stub)."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+
+class ClaudeAdapter:
+    runtime = "claude"
+
+    def plan(self, idea: dict[str, Any]) -> dict[str, Any]:
+        goal = str(idea.get("goal", "")).strip() or "unspecified-goal"
+        return {
+            "runtime": self.runtime,
+            "phase": "plan",
+            "status": "planned",
+            "goal": goal,
+            "steps": [
+                "analyze-goal",
+                "generate-plan",
+                "emit-checklist",
+            ],
+        }
+
+    def execute(self, plan: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "runtime": self.runtime,
+            "phase": "execute",
+            "status": "executed",
+            "operations": [
+                "apply-plan",
+                "collect-diff",
+            ],
+            "errors": [],
+        }
+
+    def verify(self, execution_result: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "runtime": self.runtime,
+            "phase": "verify",
+            "status": "verified",
+            "ok": True,
+            "checks": [
+                {"name": "tests", "passed": True},
+                {"name": "security", "passed": True},
+            ],
+        }
+
+    def collect_evidence(self, verify_result: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "runtime": self.runtime,
+            "phase": "evidence",
+            "status": "collected",
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            "tests": verify_result.get("checks", []),
+            "security_scans": [],
+            "diff_summary": {},
+            "reproducibility": {"seed": "deterministic"},
+            "unresolved_risks": [],
+        }

package/runtime/adapters/gpt.py

@@ -0,0 +1,53 @@
+"""GPT runtime adapter (v1 stub)."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+
+class GPTAdapter:
+    runtime = "gpt"
+
+    def plan(self, idea: dict[str, Any]) -> dict[str, Any]:
+        goal = str(idea.get("goal", "")).strip() or "unspecified-goal"
+        return {
+            "runtime": self.runtime,
+            "phase": "plan",
+            "status": "planned",
+            "goal": goal,
+            "steps": ["analyze-goal", "generate-plan", "emit-checklist"],
+        }
+
+    def execute(self, plan: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "runtime": self.runtime,
+            "phase": "execute",
+            "status": "executed",
+            "operations": ["apply-plan", "collect-diff"],
+            "errors": [],
+        }
+
+    def verify(self, execution_result: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "runtime": self.runtime,
+            "phase": "verify",
+            "status": "verified",
+            "ok": True,
+            "checks": [
+                {"name": "tests", "passed": True},
+                {"name": "security", "passed": True},
+            ],
+        }
+
+    def collect_evidence(self, verify_result: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "runtime": self.runtime,
+            "phase": "evidence",
+            "status": "collected",
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            "tests": verify_result.get("checks", []),
+            "security_scans": [],
+            "diff_summary": {},
+            "reproducibility": {"seed": "deterministic"},
+            "unresolved_risks": [],
+        }