@trac3er/oh-my-god 2.2.3 → 2.3.0

package/build/lib/plugins/viz/graph_builder.py

@@ -1,444 +0,0 @@
-"""Unified multi-language dependency graph builder.
-
-Combines Python AST parser and JS/TS/Go regex parsers into
-a single project-wide dependency graph with metrics and persistence.
-
-Feature-gated behind CODEBASE_VIZ (default: off).
-"""
-
-from __future__ import annotations
-
-import importlib
-import json
-import os
-import sys
-from pathlib import Path
-from typing import Any
-
-# ---------------------------------------------------------------------------
-# Language extension mapping
-# ---------------------------------------------------------------------------
-_PYTHON_EXTS: frozenset[str] = frozenset({".py"})
-_JS_EXTS: frozenset[str] = frozenset({".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"})
-_GO_EXTS: frozenset[str] = frozenset({".go"})
-
-# ---------------------------------------------------------------------------
-# Lazy parser imports — crash-safe
-# ---------------------------------------------------------------------------
-
-_project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-if _project_root not in sys.path:
-    sys.path.insert(0, _project_root)
-
-
-def _import_parsers() -> tuple[Any, Any]:
-    """Import ast_parser and regex_parser lazily. Returns (ast_mod, regex_mod)."""
-    try:
-        ast_mod = importlib.import_module("plugins.viz.ast_parser")
-    except Exception:
-        ast_mod = None
-    try:
-        regex_mod = importlib.import_module("plugins.viz.regex_parser")
-    except Exception:
-        regex_mod = None
-    return ast_mod, regex_mod
-
-
-def _get_feature_flag(name: str, default: bool = False) -> bool:
-    """Get feature flag value, importing hooks._common if available."""
-    # Environment variable always takes precedence
-    env_key = f"OMG_{name.upper()}_ENABLED"
-    env_val = os.environ.get(env_key, "").lower()
-    if env_val in ("1", "true", "yes"):
-        return True
-    if env_val in ("0", "false", "no"):
-        return False
-    # Try hooks._common
-    try:
-        _common = importlib.import_module("hooks._common")
-        return _common.get_feature_flag(name, default)
-    except Exception:
-        return default
-
-
-# ---------------------------------------------------------------------------
-# Module naming
-# ---------------------------------------------------------------------------
-
-def _module_name_for_path(root: Path, file_path: Path) -> str:
-    """Convert a file path to a dotted module name relative to root."""
-    rel = file_path.relative_to(root).with_suffix("")
-    parts = list(rel.parts)
-    if parts and parts[-1] == "__init__":
-        parts = parts[:-1]
-    return ".".join(parts) if parts else "__init__"
-
-
-def _dedupe_preserve_order(values: list[str]) -> list[str]:
-    """Deduplicate list while preserving insertion order."""
-    seen: set[str] = set()
-    ordered: list[str] = []
-    for v in values:
-        if v not in seen:
-            seen.add(v)
-            ordered.append(v)
-    return ordered
-
-
-# ---------------------------------------------------------------------------
-# File collection
-# ---------------------------------------------------------------------------
-
-def _collect_files(root: Path) -> dict[str, list[Path]]:
-    """Collect project files by language category, excluding hidden/venv dirs."""
-    result: dict[str, list[Path]] = {"python": [], "js": [], "go": []}
-    if not root.is_dir():
-        return result
-
-    skip_dirs = {".omg", ".git", ".venv", "venv", "node_modules", "__pycache__", ".tox"}
-
-    for item in sorted(root.rglob("*")):
-        if not item.is_file():
-            continue
-        # Skip hidden/venv directories
-        rel_parts = item.relative_to(root).parts
-        if any(p in skip_dirs or p.startswith(".") for p in rel_parts[:-1]):
-            continue
-
-        ext = item.suffix
-        if ext in _PYTHON_EXTS:
-            result["python"].append(item)
-        elif ext in _JS_EXTS:
-            result["js"].append(item)
-        elif ext in _GO_EXTS:
-            result["go"].append(item)
-
-    return result
-
-
-# ---------------------------------------------------------------------------
-# Per-language parsing
-# ---------------------------------------------------------------------------
-
-def _parse_python_files(
-    root: Path,
-    files: list[Path],
-    ast_mod: Any,
-    cached_graph: dict[str, list[str]],
-    cached_mtimes: dict[str, float],
-    new_mtimes: dict[str, float],
-) -> dict[str, list[str]]:
-    """Parse Python files into adjacency list entries."""
-    graph: dict[str, list[str]] = {}
-    if ast_mod is None:
-        return graph
-
-    parse_fn = getattr(ast_mod, "parse_python_imports", None)
-    if parse_fn is None:
-        return graph
-
-    for py_file in files:
-        module_name = _module_name_for_path(root, py_file)
-        rel_key = str(py_file.relative_to(root))
-        current_mtime = py_file.stat().st_mtime
-
-        # Incremental: reuse cached result if mtime unchanged
-        if (
-            rel_key in cached_mtimes
-            and cached_mtimes[rel_key] == current_mtime
-            and module_name in cached_graph
-        ):
-            graph[module_name] = cached_graph[module_name]
-        else:
-            try:
-                imports = parse_fn(str(py_file))
-                graph[module_name] = _dedupe_preserve_order(imports)
-            except Exception:
-                graph[module_name] = []
-
-        new_mtimes[rel_key] = current_mtime
-
-    return graph
-
-
-def _parse_js_files(
-    root: Path,
-    files: list[Path],
-    regex_mod: Any,
-    cached_graph: dict[str, list[str]],
-    cached_mtimes: dict[str, float],
-    new_mtimes: dict[str, float],
-) -> dict[str, list[str]]:
-    """Parse JS/TS files into adjacency list entries."""
-    graph: dict[str, list[str]] = {}
-    if regex_mod is None:
-        return graph
-
-    parse_fn = getattr(regex_mod, "parse_js_imports", None)
-    if parse_fn is None:
-        return graph
-
-    for js_file in files:
-        module_name = _module_name_for_path(root, js_file)
-        rel_key = str(js_file.relative_to(root))
-        current_mtime = js_file.stat().st_mtime
-
-        if (
-            rel_key in cached_mtimes
-            and cached_mtimes[rel_key] == current_mtime
-            and module_name in cached_graph
-        ):
-            graph[module_name] = cached_graph[module_name]
-        else:
-            try:
-                result = parse_fn(str(js_file))
-                graph[module_name] = _dedupe_preserve_order(result.get("imports", []))
-            except Exception:
-                graph[module_name] = []
-
-        new_mtimes[rel_key] = current_mtime
-
-    return graph
-
-
-def _parse_go_files(
-    root: Path,
-    files: list[Path],
-    regex_mod: Any,
-    cached_graph: dict[str, list[str]],
-    cached_mtimes: dict[str, float],
-    new_mtimes: dict[str, float],
-) -> dict[str, list[str]]:
-    """Parse Go files into adjacency list entries."""
-    graph: dict[str, list[str]] = {}
-    if regex_mod is None:
-        return graph
-
-    parse_fn = getattr(regex_mod, "parse_go_imports", None)
-    if parse_fn is None:
-        return graph
-
-    for go_file in files:
-        module_name = _module_name_for_path(root, go_file)
-        rel_key = str(go_file.relative_to(root))
-        current_mtime = go_file.stat().st_mtime
-
-        if (
-            rel_key in cached_mtimes
-            and cached_mtimes[rel_key] == current_mtime
-            and module_name in cached_graph
-        ):
-            graph[module_name] = cached_graph[module_name]
-        else:
-            try:
-                result = parse_fn(str(go_file))
-                graph[module_name] = _dedupe_preserve_order(result.get("imports", []))
-            except Exception:
-                graph[module_name] = []
-
-        new_mtimes[rel_key] = current_mtime
-
-    return graph
-
-
-# ---------------------------------------------------------------------------
-# Cycle detection (DFS-based)
-# ---------------------------------------------------------------------------
-
-def _detect_cycles(graph: dict[str, list[str]]) -> list[list[str]]:
-    """Detect circular dependency cycles via DFS."""
-    visited: set[str] = set()
-    on_stack: set[str] = set()
-    stack: list[str] = []
-    cycle_set: set[tuple[str, ...]] = set()
-
-    def dfs(node: str) -> None:
-        visited.add(node)
-        on_stack.add(node)
-        stack.append(node)
-
-        for nxt in graph.get(node, []):
-            if nxt not in graph:
-                continue
-            if nxt not in visited:
-                dfs(nxt)
-            elif nxt in on_stack:
-                start_idx = stack.index(nxt)
-                cycle = stack[start_idx:] + [nxt]
-                cycle_set.add(_canonical_cycle(cycle))
-
-        stack.pop()
-        on_stack.remove(node)
-
-    for module in graph:
-        if module not in visited:
-            dfs(module)
-
-    return [list(c) for c in sorted(cycle_set)]
-
-
-def _canonical_cycle(cycle: list[str]) -> tuple[str, ...]:
-    """Normalize a cycle to a canonical rotation for deduplication."""
-    core = cycle[:-1]
-    if not core:
-        return tuple(cycle)
-    rotations = [tuple(core[i:] + core[:i]) for i in range(len(core))]
-    minimal = min(rotations)
-    return minimal + (minimal[0],)
-
-
-# ---------------------------------------------------------------------------
-# Max depth computation
-# ---------------------------------------------------------------------------
-
-def _compute_max_depth(graph: dict[str, list[str]]) -> int:
-    """Compute the longest dependency chain depth."""
-    def depth(node: str, path: set[str]) -> int:
-        best = 0
-        for nxt in graph.get(node, []):
-            if nxt not in graph or nxt in path:
-                continue
-            best = max(best, 1 + depth(nxt, path | {nxt}))
-        return best
-
-    best_depth = 0
-    for module in graph:
-        best_depth = max(best_depth, depth(module, {module}))
-    return best_depth
-
-
-# ---------------------------------------------------------------------------
-# Metrics computation
-# ---------------------------------------------------------------------------
-
-def _compute_metrics(graph: dict[str, list[str]], cycles: list[list[str]]) -> dict[str, object]:
-    """Compute graph metrics."""
-    module_count = len(graph)
-    edge_count = sum(len(deps) for deps in graph.values())
-    max_depth = _compute_max_depth(graph)
-    coupling_score = edge_count / module_count if module_count > 0 else 0.0
-
-    return {
-        "module_count": module_count,
-        "edge_count": edge_count,
-        "max_depth": max_depth,
-        "circular_deps": cycles,
-        "coupling_score": coupling_score,
-    }
-
-
-# ---------------------------------------------------------------------------
-# Persistence
-# ---------------------------------------------------------------------------
-
-def _load_cached_state(project_dir: Path) -> tuple[dict[str, list[str]], dict[str, float]]:
-    """Load previously persisted graph and mtime cache."""
-    state_path = project_dir / ".omg" / "state" / "dependency-graph.json"
-    if not state_path.exists():
-        return {}, {}
-    try:
-        data = json.loads(state_path.read_text(encoding="utf-8"))
-        graph = data.get("graph", {})
-        mtimes = data.get("_mtime_cache", {})
-        return graph, mtimes
-    except Exception:
-        return {}, {}
-
-
-def _persist(project_dir: Path, payload: dict[str, object]) -> None:
-    """Save full graph + metrics to .omg/state/dependency-graph.json."""
-    try:
-        output_path = project_dir / ".omg" / "state" / "dependency-graph.json"
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        output_path.write_text(
-            json.dumps(payload, indent=2, sort_keys=True),
-            encoding="utf-8",
-        )
-    except Exception:
-        pass  # Crash isolation: never raise to caller
-
-
-# ---------------------------------------------------------------------------
-# Public API
-# ---------------------------------------------------------------------------
-
-_EMPTY_RESULT: dict[str, object] = {
-    "graph": {},
-    "metrics": {
-        "module_count": 0,
-        "edge_count": 0,
-        "max_depth": 0,
-        "circular_deps": [],
-        "coupling_score": 0.0,
-    },
-}
-
-
-def build_project_graph(project_dir: str) -> dict[str, object]:
-    """Build unified dependency graph across all detected languages.
-
-    Combines Python AST parser and JS/TS/Go regex parsers into a single
-    adjacency-list graph with computed metrics.
-
-    Feature-gated behind ``CODEBASE_VIZ`` (default: disabled).
-    Supports incremental updates via file mtime tracking.
-
-    Returns:
-        dict with keys ``graph`` (adjacency list) and ``metrics``.
-    """
-    try:
-        # Feature flag gate
-        if not _get_feature_flag("CODEBASE_VIZ", default=False):
-            return dict(_EMPTY_RESULT)
-
-        root = Path(project_dir)
-        if not root.is_dir():
-            return dict(_EMPTY_RESULT)
-
-        # Load cached state for incremental updates
-        cached_graph, cached_mtimes = _load_cached_state(root)
-        new_mtimes: dict[str, float] = {}
-
-        # Import parsers
-        ast_mod, regex_mod = _import_parsers()
-
-        # Collect files by language
-        files_by_lang = _collect_files(root)
-
-        # Parse each language
-        unified_graph: dict[str, list[str]] = {}
-
-        py_graph = _parse_python_files(
-            root, files_by_lang["python"], ast_mod, cached_graph, cached_mtimes, new_mtimes
-        )
-        unified_graph.update(py_graph)
-
-        js_graph = _parse_js_files(
-            root, files_by_lang["js"], regex_mod, cached_graph, cached_mtimes, new_mtimes
-        )
-        unified_graph.update(js_graph)
-
-        go_graph = _parse_go_files(
-            root, files_by_lang["go"], regex_mod, cached_graph, cached_mtimes, new_mtimes
-        )
-        unified_graph.update(go_graph)
-
-        # Compute metrics
-        cycles = _detect_cycles(unified_graph)
-        metrics = _compute_metrics(unified_graph, cycles)
-
-        # Build payload
-        payload: dict[str, object] = {
-            "graph": unified_graph,
-            "metrics": metrics,
-            "_mtime_cache": new_mtimes,
-        }
-
-        # Persist
-        _persist(root, payload)
-
-        return payload
-
-    except Exception:
-        # Crash isolation: never raise to caller
-        return dict(_EMPTY_RESULT)

package/build/lib/plugins/viz/native_parsers.py

@@ -1,259 +0,0 @@
-"""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}")