@trac3er/oh-my-god 2.0.0 → 2.0.2

package/plugins/testgen/framework_detector.py

@@ -0,0 +1,271 @@
+"""
+Framework Detector — detect test frameworks from project configuration files.
+
+Scans a project directory for known config files (package.json, pyproject.toml,
+setup.cfg, Cargo.toml, go.mod, Gemfile) and returns a FrameworkInfo dataclass
+describing the detected framework(s).
+
+Feature flag: TEST_GENERATION (default False) — detection works regardless.
+Stdlib only: json, pathlib, re, dataclasses.
+"""
+import json
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class FrameworkInfo:
+    """Describes a detected test framework and its conventions."""
+
+    framework: str = "unknown"
+    config_file: str = ""
+    test_dir: str = ""
+    assertion_style: str = ""
+    mock_library: str = ""
+    multi_framework: list[str] = field(default_factory=list)
+
+
+# --- JS/TS framework metadata ---
+
+_JS_FRAMEWORKS = {
+    "vitest": {
+        "framework": "vitest",
+        "assertion_style": "expect",
+        "mock_library": "vi.mock",
+        "test_dir": "__tests__",
+    },
+    "jest": {
+        "framework": "jest",
+        "assertion_style": "expect",
+        "mock_library": "jest.mock",
+        "test_dir": "__tests__",
+    },
+    "mocha": {
+        "framework": "mocha",
+        "assertion_style": "assert",
+        "mock_library": "sinon",
+        "test_dir": "test",
+    },
+    "@playwright/test": {
+        "framework": "playwright",
+        "assertion_style": "expect",
+        "mock_library": "",
+        "test_dir": "tests",
+    },
+}
+
+# Detection priority: vitest > jest > mocha (vitest first because projects
+# migrating from jest often keep jest in devDeps alongside vitest)
+_JS_PRIORITY = ["vitest", "jest", "mocha", "@playwright/test"]
+
+
+def _detect_from_package_json(project_dir: str) -> FrameworkInfo | None:
+    """Detect JS/TS framework from package.json devDependencies and scripts."""
+    pkg_path = Path(project_dir) / "package.json"
+    if not pkg_path.is_file():
+        return None
+
+    try:
+        with open(pkg_path, "r", encoding="utf-8") as f:
+            pkg = json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return None
+
+    dev_deps = pkg.get("devDependencies", {})
+    deps = pkg.get("dependencies", {})
+    scripts = pkg.get("scripts", {})
+    all_deps = {**deps, **dev_deps}
+
+    # Also check scripts for framework names
+    scripts_text = " ".join(str(v) for v in scripts.values())
+
+    detected = []
+    for fw_key in _JS_PRIORITY:
+        if fw_key in all_deps:
+            detected.append(fw_key)
+        elif fw_key.lstrip("@").split("/")[-1] in scripts_text:
+            detected.append(fw_key)
+
+    if not detected:
+        return None
+
+    primary_key = detected[0]
+    meta = _JS_FRAMEWORKS[primary_key]
+
+    multi = []
+    if len(detected) > 1:
+        multi = [_JS_FRAMEWORKS[k]["framework"] for k in detected]
+
+    return FrameworkInfo(
+        framework=meta["framework"],
+        config_file="package.json",
+        test_dir=meta["test_dir"],
+        assertion_style=meta["assertion_style"],
+        mock_library=meta["mock_library"],
+        multi_framework=multi,
+    )
+
+
+def _detect_from_pyproject_toml(project_dir: str) -> FrameworkInfo | None:
+    """Detect pytest from pyproject.toml [tool.pytest.*] section."""
+    path = Path(project_dir) / "pyproject.toml"
+    if not path.is_file():
+        return None
+
+    try:
+        content = path.read_text(encoding="utf-8")
+    except OSError:
+        return None
+
+    if re.search(r"\[tool\.pytest", content):
+        # Try to extract testpaths
+        test_dir = "tests"
+        m = re.search(r'testpaths\s*=\s*\["?([^"\]\s]+)', content)
+        if m:
+            test_dir = m.group(1)
+
+        return FrameworkInfo(
+            framework="pytest",
+            config_file="pyproject.toml",
+            test_dir=test_dir,
+            assertion_style="assert",
+            mock_library="unittest.mock",
+            multi_framework=[],
+        )
+
+    # Check for pytest in dependencies
+    if re.search(r"pytest", content):
+        return FrameworkInfo(
+            framework="pytest",
+            config_file="pyproject.toml",
+            test_dir="tests",
+            assertion_style="assert",
+            mock_library="unittest.mock",
+            multi_framework=[],
+        )
+
+    return None
+
+
+def _detect_from_setup_cfg(project_dir: str) -> FrameworkInfo | None:
+    """Detect pytest from setup.cfg [tool:pytest] section."""
+    path = Path(project_dir) / "setup.cfg"
+    if not path.is_file():
+        return None
+
+    try:
+        content = path.read_text(encoding="utf-8")
+    except OSError:
+        return None
+
+    if re.search(r"\[tool:pytest\]", content):
+        test_dir = "tests"
+        m = re.search(r"testpaths\s*=\s*(\S+)", content)
+        if m:
+            test_dir = m.group(1)
+
+        return FrameworkInfo(
+            framework="pytest",
+            config_file="setup.cfg",
+            test_dir=test_dir,
+            assertion_style="assert",
+            mock_library="unittest.mock",
+            multi_framework=[],
+        )
+
+    return None
+
+
+def _detect_from_go_mod(project_dir: str) -> FrameworkInfo | None:
+    """Detect Go test from go.mod presence."""
+    path = Path(project_dir) / "go.mod"
+    if not path.is_file():
+        return None
+
+    return FrameworkInfo(
+        framework="go test",
+        config_file="go.mod",
+        test_dir=".",
+        assertion_style="testing.T",
+        mock_library="testify/mock",
+        multi_framework=[],
+    )
+
+
+def _detect_from_cargo_toml(project_dir: str) -> FrameworkInfo | None:
+    """Detect Rust/cargo test from Cargo.toml presence."""
+    path = Path(project_dir) / "Cargo.toml"
+    if not path.is_file():
+        return None
+
+    return FrameworkInfo(
+        framework="cargo test",
+        config_file="Cargo.toml",
+        test_dir="tests",
+        assertion_style="assert!",
+        mock_library="mockall",
+        multi_framework=[],
+    )
+
+
+def _detect_from_gemfile(project_dir: str) -> FrameworkInfo | None:
+    """Detect RSpec from Gemfile containing 'rspec'."""
+    path = Path(project_dir) / "Gemfile"
+    if not path.is_file():
+        return None
+
+    try:
+        content = path.read_text(encoding="utf-8")
+    except OSError:
+        return None
+
+    if re.search(r"['\"]rspec['\"]", content):
+        return FrameworkInfo(
+            framework="rspec",
+            config_file="Gemfile",
+            test_dir="spec",
+            assertion_style="expect",
+            mock_library="rspec-mocks",
+            multi_framework=[],
+        )
+
+    return None
+
+
+# Ordered detector chain — first match wins (except multi-framework from JS)
+_DETECTORS = [
+    _detect_from_package_json,
+    _detect_from_pyproject_toml,
+    _detect_from_setup_cfg,
+    _detect_from_go_mod,
+    _detect_from_cargo_toml,
+    _detect_from_gemfile,
+]
+
+
+def detect_test_framework(project_dir: str) -> FrameworkInfo:
+    """Detect test framework(s) in a project directory.
+
+    Scans known config files in priority order. Returns FrameworkInfo with
+    framework='unknown' if nothing detected (never crashes).
+
+    Feature flag TEST_GENERATION gates downstream generation — detection
+    itself always works.
+
+    Args:
+        project_dir: Absolute or relative path to the project root.
+
+    Returns:
+        FrameworkInfo dataclass with detected framework metadata.
+    """
+    try:
+        for detector in _DETECTORS:
+            result = detector(project_dir)
+            if result is not None:
+                return result
+    except Exception:
+        # Crash isolation: return unknown on any unexpected error
+        pass
+
+    return FrameworkInfo()

package/plugins/testgen/skeleton_generator.py

@@ -0,0 +1,219 @@
+"""Generate lightweight test skeletons from source files.
+
+Python symbol extraction uses ``ast`` for precise parsing of top-level public
+functions, classes, and class methods.
+
+JavaScript/TypeScript symbol extraction uses regular expressions for exported
+declarations (``export function``, ``export const``, ``export default
+function``, ``export class``). This regex approach is intentionally lightweight
+and expected to be about 70-80% accurate for common code styles.
+"""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+import re
+
+
+_RE_JS_EXPORT_FUNCTION = re.compile(r"(?:^|\s)export\s+function\s+([A-Za-z_$][\w$]*)\s*\(")
+_RE_JS_EXPORT_CONST = re.compile(r"(?:^|\s)export\s+const\s+([A-Za-z_$][\w$]*)\s*=")
+_RE_JS_EXPORT_DEFAULT_FUNCTION = re.compile(
+    r"(?:^|\s)export\s+default\s+function(?:\s+([A-Za-z_$][\w$]*))?\s*\("
+)
+_RE_JS_EXPORT_CLASS = re.compile(r"(?:^|\s)export\s+class\s+([A-Za-z_$][\w$]*)\b")
+
+
+def generate_test_skeleton(source_file: str, framework_info: dict[str, object]) -> str:
+    path = Path(source_file)
+    if not path.exists():
+        return ""
+
+    source_text = path.read_text(encoding="utf-8")
+    if not source_text.strip():
+        return ""
+
+    framework = str(framework_info.get("framework", "")).lower()
+
+    functions: list[str]
+    classes: dict[str, list[str]]
+    if path.suffix == ".py":
+        functions, classes = _extract_python_symbols(source_text)
+    else:
+        functions, classes = _extract_js_ts_symbols(source_text)
+
+    if framework == "pytest":
+        return _render_pytest(functions, classes)
+    if framework in {"jest", "vitest"}:
+        return _render_jest_vitest(functions, classes)
+    if framework == "go":
+        return _render_go(functions, classes)
+    return _render_generic(functions, classes)
+
+
+def _extract_python_symbols(source_text: str) -> tuple[list[str], dict[str, list[str]]]:
+    functions: list[str] = []
+    classes: dict[str, list[str]] = {}
+
+    tree = ast.parse(source_text)
+    for node in tree.body:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and not node.name.startswith("_"):
+            functions.append(node.name)
+        elif isinstance(node, ast.ClassDef) and not node.name.startswith("_"):
+            public_methods: list[str] = []
+            for member in node.body:
+                if isinstance(member, (ast.FunctionDef, ast.AsyncFunctionDef)) and not member.name.startswith("_"):
+                    public_methods.append(member.name)
+            classes[node.name] = public_methods
+
+    return functions, classes
+
+
+def _extract_js_ts_symbols(source_text: str) -> tuple[list[str], dict[str, list[str]]]:
+    functions: list[str] = []
+    classes: dict[str, list[str]] = {}
+
+    functions.extend(_RE_JS_EXPORT_FUNCTION.findall(source_text))
+    functions.extend(_RE_JS_EXPORT_CONST.findall(source_text))
+
+    for match in _RE_JS_EXPORT_DEFAULT_FUNCTION.findall(source_text):
+        functions.append(match or "defaultExport")
+
+    for class_name in _RE_JS_EXPORT_CLASS.findall(source_text):
+        classes[class_name] = []
+
+    return _dedupe(functions), classes
+
+
+def _render_pytest(functions: list[str], classes: dict[str, list[str]]) -> str:
+    lines: list[str] = []
+
+    for func_name in functions:
+        lines.extend(
+            [
+                f"def test_{func_name}_happy_path():",
+                "    # TODO: implement test",
+                "    # happy path",
+                "    assert True",
+                "",
+                f"def test_{func_name}_error_case():",
+                "    # TODO: implement test",
+                "    # error case",
+                "    assert True",
+                "",
+            ]
+        )
+
+    for class_name, methods in classes.items():
+        lines.append(f"class Test{class_name}:")
+        if not methods:
+            lines.extend(["    # TODO: implement test", "    pass", ""])
+            continue
+
+        for method_name in methods:
+            lines.extend(
+                [
+                    f"    def test_{method_name}_happy_path(self):",
+                    "        # TODO: implement test",
+                    "        # happy path",
+                    "        assert True",
+                    "",
+                    f"    def test_{method_name}_error_case(self):",
+                    "        # TODO: implement test",
+                    "        # error case",
+                    "        assert True",
+                    "",
+                ]
+            )
+
+    return "\n".join(lines).rstrip()
+
+
+def _render_jest_vitest(functions: list[str], classes: dict[str, list[str]]) -> str:
+    names = functions + list(classes.keys())
+    blocks: list[str] = []
+
+    for name in names:
+        blocks.extend(
+            [
+                f"describe('{name}', () => {{",
+                "  it('should happy path', () => {",
+                "    // TODO: implement test",
+                "    // happy path",
+                "    expect(value).toBe(expected);",
+                "  });",
+                "",
+                "  it('should error case', () => {",
+                "    // TODO: implement test",
+                "    // error case",
+                "    expect(value).toBe(expected);",
+                "  });",
+                "});",
+                "",
+            ]
+        )
+
+    return "\n".join(blocks).rstrip()
+
+
+def _render_go(functions: list[str], classes: dict[str, list[str]]) -> str:
+    names = functions + list(classes.keys())
+    if not names:
+        return ""
+
+    lines = [
+        "package main",
+        "",
+        'import "testing"',
+        "",
+    ]
+
+    for name in names:
+        test_name = _to_pascal_case(name)
+        lines.extend(
+            [
+                f"func Test{test_name}(t *testing.T) {{",
+                "    // TODO: implement test",
+                "    // happy path",
+                "    // error case",
+                "}",
+                "",
+            ]
+        )
+
+    return "\n".join(lines).rstrip()
+
+
+def _render_generic(functions: list[str], classes: dict[str, list[str]]) -> str:
+    names = functions + list(classes.keys())
+    if not names:
+        return ""
+
+    lines = []
+    for name in names:
+        lines.extend(
+            [
+                f"# Test skeleton for {name}",
+                "# TODO: implement test",
+                "# happy path",
+                "# error case",
+                "",
+            ]
+        )
+
+    return "\n".join(lines).rstrip()
+
+
+def _dedupe(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 _to_pascal_case(name: str) -> str:
+    parts = re.split(r"[^A-Za-z0-9]+", name)
+    return "".join(part[:1].upper() + part[1:] for part in parts if part) or "Generated"

package/plugins/viz/ast_parser.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import ast
+import json
+from pathlib import Path
+from typing import override
+
+
+def parse_python_imports(file_path: str) -> list[str]:
+    source = Path(file_path).read_text(encoding="utf-8")
+    tree = ast.parse(source)
+    collector = _ImportCollector()
+    collector.visit(tree)
+    return collector.imports
+
+
+def build_dependency_graph(project_dir: str) -> dict[str, object]:
+    root = Path(project_dir)
+    py_files = sorted(root.rglob("*.py"))
+
+    graph: dict[str, list[str]] = {}
+    for py_file in py_files:
+        module_name = _module_name_for_path(root, py_file)
+        imports = parse_python_imports(str(py_file))
+        graph[module_name] = _dedupe_preserve_order(imports)
+
+    cycles = _detect_cycles(graph)
+    stats = {
+        "module_count": len(graph),
+        "edge_count": sum(len(edges) for edges in graph.values()),
+        "max_depth": _compute_max_depth(graph),
+        "has_cycles": bool(cycles),
+    }
+
+    payload: dict[str, object] = {
+        "graph": graph,
+        "cycles": cycles,
+        "stats": stats,
+    }
+
+    output_path = root / ".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")
+
+    return payload
+
+
+class _ImportCollector(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.imports: list[str] = []
+
+    @override
+    def visit_Import(self, node: ast.Import) -> None:  # noqa: N802
+        for alias in node.names:
+            self.imports.append(alias.name)
+
+    @override
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:  # noqa: N802
+        if node.level > 0:
+            prefix = "." * node.level
+            self.imports.append(f"{prefix}{node.module or ''}")
+            return
+
+        if node.module:
+            self.imports.append(node.module)
+
+
+def _module_name_for_path(root: Path, py_file: Path) -> str:
+    rel = py_file.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]:
+    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 _detect_cycles(graph: dict[str, list[str]]) -> list[list[str]]:
+    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(cycle) for cycle in sorted(cycle_set)]
+
+
+def _canonical_cycle(cycle: list[str]) -> tuple[str, ...]:
+    core = cycle[:-1]
+    if not core:
+        return tuple(cycle)
+
+    rotations = [tuple(core[idx:] + core[:idx]) for idx in range(len(core))]
+    minimal = min(rotations)
+    return minimal + (minimal[0],)
+
+
+def _compute_max_depth(graph: dict[str, list[str]]) -> int:
+    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