@trac3er/oh-my-god 2.0.4 → 2.0.7

package/build/lib/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/build/lib/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/build/lib/registry/__init__.py

@@ -0,0 +1 @@
+"""Registry package for OMG."""

package/build/lib/registry/bundles/algorithms.yaml

@@ -0,0 +1,45 @@
+id: algorithms
+kind: domain-pack
+version: 2.0.7
+title: OMG Algorithms Pack
+description: Determinism and benchmark attachments for algorithm-heavy work.
+hosts:
+  - claude
+  - codex
+assets:
+  references:
+    - runtime/domain_packs.py
+invocation_policy:
+  user_invocable: true
+  model_invocable: true
+  allow_implicit_invocation: false
+tool_policy:
+  side_effect_level: medium
+  allowed_tools:
+    claude:
+      - Read
+    codex:
+      - Read
+lifecycle_hooks:
+  native:
+    - PostToolUse
+  emulated:
+    - TaskCompleted
+mcp_contract:
+  servers:
+    - omg-control
+lsp_contract:
+  languages:
+    - python
+evidence_outputs:
+  artifacts:
+    - .omg/evals/latest.json
+execution_contract:
+  modes:
+    - embedded
+    - local_supervisor
+channel_overrides:
+  public:
+    benchmarks: advisory
+  enterprise:
+    benchmarks: required

package/build/lib/registry/bundles/api-twin.yaml

@@ -0,0 +1,48 @@
+id: api-twin
+kind: simulation
+version: 2.0.7
+title: OMG API Twin
+description: Versioned endpoint cassette replay with latency, drift, and cost reporting.
+hosts:
+  - claude
+  - codex
+assets:
+  references:
+    - runtime/api_twin.py
+    - commands/OMG:api-twin.md
+invocation_policy:
+  user_invocable: true
+  model_invocable: true
+  allow_implicit_invocation: false
+tool_policy:
+  side_effect_level: medium
+  allowed_tools:
+    claude:
+      - Read
+      - Bash(python3:*)
+    codex:
+      - Read
+      - Bash(python3:*)
+lifecycle_hooks:
+  native:
+    - PostToolUse
+  emulated:
+    - TaskCompleted
+mcp_contract:
+  servers:
+    - omg-control
+lsp_contract:
+  languages:
+    - python
+evidence_outputs:
+  artifacts:
+    - .omg/state/api_twin.json
+execution_contract:
+  modes:
+    - embedded
+    - local_supervisor
+channel_overrides:
+  public:
+    fidelity: validated
+  enterprise:
+    fidelity: policy-required

package/build/lib/registry/bundles/claim-judge.yaml

@@ -0,0 +1,49 @@
+id: claim-judge
+kind: proof
+version: 2.0.7
+title: OMG Claim Judge
+description: Evidence-backed claim validator for structured release and completion claims.
+hosts:
+  - claude
+  - codex
+assets:
+  references:
+    - runtime/claim_judge.py
+invocation_policy:
+  user_invocable: true
+  model_invocable: true
+  allow_implicit_invocation: false
+tool_policy:
+  side_effect_level: low
+  allowed_tools:
+    claude:
+      - Read
+      - Grep
+      - Bash(python3:*)
+    codex:
+      - Read
+      - Grep
+      - Bash(python3:*)
+lifecycle_hooks:
+  native:
+    - PostToolUse
+  emulated:
+    - TaskCompleted
+mcp_contract:
+  servers:
+    - omg-control
+lsp_contract:
+  languages:
+    - python
+evidence_outputs:
+  artifacts:
+    - .omg/evidence/claim-judge-*.json
+execution_contract:
+  modes:
+    - embedded
+    - local_supervisor
+channel_overrides:
+  public:
+    posture: self-serve
+  enterprise:
+    posture: managed

package/build/lib/registry/bundles/control-plane.yaml

@@ -0,0 +1,151 @@
+id: control-plane
+kind: skill
+version: 2.0.7
+title: OMG Control Plane
+description: Canonical production control plane bundle for Claude and Codex.
+hosts:
+  - claude
+  - codex
+assets:
+  references:
+    - OMG_COMPAT_CONTRACT.md
+    - docs/release-checklist.md
+invocation_policy:
+  user_invocable: true
+  model_invocable: false
+  allow_implicit_invocation: false
+tool_policy:
+  side_effect_level: medium
+  allowed_tools:
+    claude:
+      - Read
+      - Grep
+      - Bash(python3:*)
+    codex:
+      - Read
+      - Grep
+      - Bash(python3:*)
+lifecycle_hooks:
+  native:
+    - SessionStart
+    - PreToolUse
+    - PostToolUse
+  emulated:
+    - PreCompact
+    - WorktreeCreate
+    - WorktreeRemove
+mcp_contract:
+  servers:
+    - omg-control
+    - omg-memory
+  prompts:
+    - omg_contract_summary
+  resources:
+    - resource://omg/contract
+    - resource://omg/release-checklist
+lsp_contract:
+  languages:
+    - python
+    - typescript
+evidence_outputs:
+  artifacts:
+    - .omg/evidence/control-plane-compile.json
+execution_contract:
+  modes:
+    - embedded
+    - local_supervisor
+policy_model:
+  trust_tiers:
+    - name: safe
+      level: 0
+      label: Safe
+      allowed_sources:
+        - local_repo
+        - trusted_registry
+    - name: balanced
+      level: 1
+      label: Balanced
+      allowed_sources:
+        - local_repo
+        - trusted_registry
+        - reviewed_external
+    - name: interop
+      level: 2
+      label: Interop
+      allowed_sources:
+        - local_repo
+        - trusted_registry
+        - reviewed_external
+        - migration_bridge
+    - name: labs
+      level: 3
+      label: Labs
+      allowed_sources:
+        - local_repo
+        - trusted_registry
+        - reviewed_external
+        - experimental
+  tool_policies:
+    - tool_name: Read
+      allowed_tiers: [safe, balanced, interop, labs]
+      requires_approval: false
+    - tool_name: Grep
+      allowed_tiers: [safe, balanced, interop, labs]
+      requires_approval: false
+    - tool_name: Bash(python3:*)
+      allowed_tiers: [balanced, interop, labs]
+      requires_approval: true
+  protected_paths:
+    - path_pattern: .omg/**
+      required_tier: balanced
+    - path_pattern: .agents/**
+      required_tier: balanced
+    - path_pattern: .codex/**
+      required_tier: balanced
+    - path_pattern: .claude/**
+      required_tier: balanced
+  evidence_contract:
+    timestamp: timestamp
+    executor: executor
+    trace_id: trace_id
+    lineage: lineage
+  host_rules:
+    claude:
+      compilation_targets:
+        - .claude-plugin/plugin.json
+        - .claude-plugin/marketplace.json
+        - .mcp.json
+        - settings.json
+      hooks:
+        - SessionStart
+        - PreToolUse
+        - PostToolUse
+        - PreCompact
+      subagents:
+        - local_supervisor
+        - workers
+      skills:
+        - omg/control-plane
+        - omg/hook-governor
+    codex:
+      compilation_targets:
+        - .agents/skills/omg/<bundle>/SKILL.md
+        - .agents/skills/omg/<bundle>/openai.yaml
+        - .agents/skills/omg/AGENTS.fragment.md
+        - .agents/skills/omg/codex-mcp.toml
+      skills:
+        - omg/control-plane
+        - omg/mcp-fabric
+      agents_fragments:
+        - .agents/skills/omg/AGENTS.fragment.md
+      rules:
+        - protected_paths
+        - explicit_invocation
+      automations:
+        - contract-compile
+        - release-readiness
+channel_overrides:
+  public:
+    posture: self-serve
+  enterprise:
+    posture: managed