patchwork-conventions 0.1.0__py3-none-any.whl

patchwork/miners/ast_base.py

@@ -0,0 +1,113 @@
+"""
+Tree-sitter parser cache + helpers shared across all miners.
+Lazy-loads language parsers on first use.
+"""
+from __future__ import annotations
+
+import re
+from functools import lru_cache
+from pathlib import Path
+from typing import Iterator
+
+try:
+    from tree_sitter import Language, Parser, Node
+    TS_AVAILABLE = True
+except ImportError:
+    TS_AVAILABLE = False
+
+# Registry of (language_tag → loader function)
+_LANGUAGE_LOADERS: dict[str, str] = {
+    "python": "tree_sitter_python",
+    "javascript": "tree_sitter_javascript",
+    "typescript": "tree_sitter_typescript",
+    "go": "tree_sitter_go",
+    "rust": "tree_sitter_rust",
+    "java": "tree_sitter_java",
+}
+
+
+@lru_cache(maxsize=None)
+def get_parser(lang: str) -> "Parser | None":
+    """Return a cached tree-sitter Parser for the given language, or None."""
+    if not TS_AVAILABLE:
+        return None
+    module_name = _LANGUAGE_LOADERS.get(lang)
+    if module_name is None:
+        return None
+    try:
+        mod = __import__(module_name)
+        language = Language(mod.language())
+        parser = Parser(language)
+        return parser
+    except Exception:
+        return None
+
+
+def parse_file(path: Path, lang: str) -> "Node | None":
+    """Parse a source file and return the root AST node, or None on failure."""
+    parser = get_parser(lang)
+    if parser is None:
+        return None
+    try:
+        source = path.read_bytes()
+        tree = parser.parse(source)
+        return tree.root_node
+    except Exception:
+        return None
+
+
+def parse_bytes(source: bytes, lang: str) -> "Node | None":
+    """Parse raw bytes and return the root AST node."""
+    parser = get_parser(lang)
+    if parser is None:
+        return None
+    try:
+        tree = parser.parse(source)
+        return tree.root_node
+    except Exception:
+        return None
+
+
+def walk(node: "Node") -> Iterator["Node"]:
+    """DFS walk over all nodes in the AST."""
+    cursor = node.walk()
+    reached_root = False
+    while not reached_root:
+        yield cursor.node
+        if cursor.goto_first_child():
+            continue
+        if cursor.goto_next_sibling():
+            continue
+        retracing = True
+        while retracing:
+            if not cursor.goto_parent():
+                reached_root = True
+                retracing = False
+            elif cursor.goto_next_sibling():
+                retracing = False
+
+
+def nodes_of_type(root: "Node", *types: str) -> list["Node"]:
+    """Collect all descendant nodes matching any of the given type names."""
+    return [n for n in walk(root) if n.type in types]
+
+
+def node_text(node: "Node", source: bytes) -> str:
+    """Extract the UTF-8 text of a node from the raw source bytes."""
+    return source[node.start_byte:node.end_byte].decode("utf-8", errors="replace")
+
+
+# ── Regex-based fallbacks (used when tree-sitter is unavailable or for langs
+#    without a grammar installed) ──────────────────────────────────────────────
+
+def regex_extract_identifiers(source: str, lang: str) -> list[str]:
+    """Very rough identifier extraction via regex (fallback path)."""
+    if lang == "python":
+        pattern = r"(?:def|class)\s+([A-Za-z_][A-Za-z0-9_]*)"
+    elif lang in ("javascript", "typescript"):
+        pattern = r"(?:function|class|const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)"
+    elif lang == "go":
+        pattern = r"(?:func|type|var|const)\s+([A-Z][A-Za-z0-9]*|[a-z][A-Za-z0-9]*)"
+    else:
+        pattern = r"\b([A-Za-z_][A-Za-z0-9_]{2,})\b"
+    return re.findall(pattern, source)

patchwork/miners/config_detector.py

@@ -0,0 +1,273 @@
+"""
+ConfigDetector — Reads config files to detect tech stack without AST parsing.
+Inspects: package.json, pyproject.toml, go.mod, Cargo.toml, Makefile, etc.
+"""
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+try:
+    import tomllib  # Python 3.11+
+except ImportError:
+    try:
+        import tomli as tomllib  # type: ignore
+    except ImportError:
+        tomllib = None  # type: ignore
+
+
+@dataclass
+class ProjectConfig:
+    name: str | None = None
+    version: str | None = None
+    language: str | None = None          # primary language
+    runtime: str | None = None           # e.g. 'Node.js 20', 'Python 3.11'
+    package_manager: str | None = None   # npm/yarn/pnpm/pip/uv/cargo/go
+    frameworks: list[str] = field(default_factory=list)
+    linters: list[str] = field(default_factory=list)
+    formatters: list[str] = field(default_factory=list)
+    type_checker: str | None = None
+    build_tool: str | None = None
+    scripts: dict[str, str] = field(default_factory=dict)
+    has_docker: bool = False
+    has_ci: bool = False
+    ci_platform: str | None = None
+    notes: list[str] = field(default_factory=list)
+
+
+_JS_FRAMEWORKS = [
+    "react", "next", "vue", "nuxt", "svelte", "sveltekit", "angular",
+    "solid", "remix", "astro", "qwik", "hono", "express", "fastify",
+    "nestjs", "@nestjs/core", "koa", "elysia",
+]
+_JS_LINTERS = ["eslint", "oxlint", "biome"]
+_JS_FORMATTERS = ["prettier", "biome", "@biomejs/biome"]
+_JS_TYPE_CHECKERS = ["typescript", "flow"]
+_JS_BUILD = ["vite", "webpack", "turbopack", "rollup", "esbuild", "bun", "parcel", "rspack"]
+
+_PY_FRAMEWORKS = [
+    "fastapi", "flask", "django", "starlette", "litestar", "tornado",
+    "aiohttp", "sanic", "falcon",
+]
+_PY_LINTERS = ["ruff", "flake8", "pylint", "pyflakes"]
+_PY_FORMATTERS = ["black", "ruff", "autopep8", "yapf"]
+_PY_TYPE = ["mypy", "pyright", "pytype"]
+
+_CI_PLATFORMS = {
+    ".github/workflows": "GitHub Actions",
+    ".gitlab-ci.yml": "GitLab CI",
+    ".circleci": "CircleCI",
+    "Jenkinsfile": "Jenkins",
+    ".travis.yml": "Travis CI",
+    "azure-pipelines.yml": "Azure Pipelines",
+    ".drone.yml": "Drone CI",
+    "bitbucket-pipelines.yml": "Bitbucket Pipelines",
+}
+
+
+class ConfigDetector:
+    def __init__(self, root: Path):
+        self.root = root
+
+    def detect(self) -> ProjectConfig:
+        cfg = ProjectConfig()
+
+        # Detect CI
+        for ci_path, ci_name in _CI_PLATFORMS.items():
+            if (self.root / ci_path).exists():
+                cfg.has_ci = True
+                cfg.ci_platform = ci_name
+                break
+
+        # Docker
+        if (self.root / "Dockerfile").exists() or (self.root / "docker-compose.yml").exists():
+            cfg.has_docker = True
+
+        # Node.js
+        pkg_json = self.root / "package.json"
+        if pkg_json.exists():
+            self._read_package_json(pkg_json, cfg)
+
+        # Python
+        pyproject = self.root / "pyproject.toml"
+        if pyproject.exists():
+            self._read_pyproject(pyproject, cfg)
+        elif (self.root / "setup.py").exists() or (self.root / "setup.cfg").exists():
+            cfg.language = "python"
+            cfg.package_manager = "pip"
+
+        # Go
+        go_mod = self.root / "go.mod"
+        if go_mod.exists():
+            self._read_go_mod(go_mod, cfg)
+
+        # Rust
+        cargo = self.root / "Cargo.toml"
+        if cargo.exists():
+            self._read_cargo(cargo, cfg)
+
+        # Package manager detection (node)
+        if (self.root / "pnpm-lock.yaml").exists():
+            cfg.package_manager = "pnpm"
+        elif (self.root / "yarn.lock").exists():
+            cfg.package_manager = "yarn"
+        elif (self.root / "bun.lockb").exists() or (self.root / "bun.lock").exists():
+            cfg.package_manager = "bun"
+        elif (self.root / "package-lock.json").exists() and cfg.package_manager is None:
+            cfg.package_manager = "npm"
+
+        # Python package manager
+        if (self.root / "uv.lock").exists():
+            cfg.package_manager = "uv"
+        elif (self.root / "poetry.lock").exists():
+            cfg.package_manager = "poetry"
+        elif (self.root / "Pipfile").exists():
+            cfg.package_manager = "pipenv"
+
+        return cfg
+
+    def _read_package_json(self, path: Path, cfg: ProjectConfig) -> None:
+        try:
+            data = json.loads(path.read_text())
+        except (json.JSONDecodeError, OSError):
+            return
+
+        cfg.language = "javascript/typescript"
+        cfg.name = data.get("name")
+        cfg.version = data.get("version")
+
+        all_deps = {
+            **data.get("dependencies", {}),
+            **data.get("devDependencies", {}),
+        }
+
+        for fw in _JS_FRAMEWORKS:
+            if fw in all_deps:
+                cfg.frameworks.append(fw)
+
+        for linter in _JS_LINTERS:
+            if linter in all_deps:
+                cfg.linters.append(linter)
+
+        for fmt in _JS_FORMATTERS:
+            if fmt in all_deps:
+                if fmt not in cfg.formatters:
+                    cfg.formatters.append(fmt)
+
+        for tc in _JS_TYPE_CHECKERS:
+            if tc in all_deps:
+                cfg.type_checker = tc
+
+        for bt in _JS_BUILD:
+            if bt in all_deps:
+                cfg.build_tool = bt
+                break
+
+        scripts = data.get("scripts", {})
+        important = {k: v for k, v in scripts.items()
+                     if k in ("dev", "start", "build", "test", "lint", "format", "typecheck")}
+        cfg.scripts.update(important)
+
+        # Runtime from engines field
+        engines = data.get("engines", {})
+        if "node" in engines:
+            cfg.runtime = f"Node.js {engines['node']}"
+
+    def _read_pyproject(self, path: Path, cfg: ProjectConfig) -> None:
+        cfg.language = "python"
+        if tomllib is None:
+            return
+        try:
+            data = tomllib.loads(path.read_text())
+        except Exception:
+            return
+
+        project = data.get("project", {})
+        tool = data.get("tool", {})
+
+        cfg.name = project.get("name")
+        cfg.version = project.get("version")
+
+        requires_python = project.get("requires-python", "")
+        if requires_python:
+            cfg.runtime = f"Python {requires_python}"
+
+        all_deps = list(project.get("dependencies", [])) + [
+            str(dep) for group in project.get("optional-dependencies", {}).values()
+            for dep in group
+        ]
+        dep_names = [re.split(r"[>=<!;[\s]", d)[0].lower() for d in all_deps]
+
+        for fw in _PY_FRAMEWORKS:
+            if fw in dep_names:
+                cfg.frameworks.append(fw)
+
+        for linter in _PY_LINTERS:
+            if linter in dep_names or linter in tool:
+                if linter not in cfg.linters:
+                    cfg.linters.append(linter)
+
+        for fmt in _PY_FORMATTERS:
+            if fmt in dep_names or fmt in tool:
+                if fmt not in cfg.formatters:
+                    cfg.formatters.append(fmt)
+
+        for tc in _PY_TYPE:
+            if tc in dep_names or tc in tool:
+                cfg.type_checker = tc
+                break
+
+        scripts_section = project.get("scripts", {})
+        cfg.scripts.update(scripts_section)
+
+    def _read_go_mod(self, path: Path, cfg: ProjectConfig) -> None:
+        cfg.language = "go"
+        cfg.package_manager = "go"
+        try:
+            text = path.read_text()
+        except OSError:
+            return
+        m = re.search(r'^module\s+(\S+)', text, re.MULTILINE)
+        if m:
+            cfg.name = m.group(1)
+        m2 = re.search(r'^go\s+([\d.]+)', text, re.MULTILINE)
+        if m2:
+            cfg.runtime = f"Go {m2.group(1)}"
+
+        # Detect popular Go frameworks from dependencies
+        go_frameworks = {
+            "gin-gonic/gin": "gin",
+            "labstack/echo": "echo",
+            "gofiber/fiber": "fiber",
+            "go-chi/chi": "chi",
+            "gorilla/mux": "gorilla/mux",
+        }
+        for dep, name in go_frameworks.items():
+            if dep in text:
+                cfg.frameworks.append(name)
+
+    def _read_cargo(self, path: Path, cfg: ProjectConfig) -> None:
+        cfg.language = "rust"
+        cfg.package_manager = "cargo"
+        if tomllib is None:
+            return
+        try:
+            data = tomllib.loads(path.read_text())
+        except Exception:
+            return
+        pkg = data.get("package", {})
+        cfg.name = pkg.get("name")
+        cfg.version = pkg.get("version")
+        cfg.runtime = f"Rust {pkg.get('edition', '2021')}"
+
+        # Detect web frameworks
+        rust_frameworks = {
+            "axum": "axum", "actix-web": "actix-web", "warp": "warp",
+            "rocket": "rocket", "tide": "tide",
+        }
+        all_deps = {**data.get("dependencies", {}), **data.get("dev-dependencies", {})}
+        for dep, name in rust_frameworks.items():
+            if dep in all_deps:
+                cfg.frameworks.append(name)

patchwork/miners/error_handling.py

@@ -0,0 +1,207 @@
+"""
+ErrorHandlingMiner — Detects error-handling conventions:
+  - try/except vs Result types vs callbacks vs promises
+  - Custom exception class naming
+  - Error propagation style (raise vs return vs log)
+  - Logging framework used
+  - Panic/recover (Go), ? operator (Rust), etc.
+"""
+from __future__ import annotations
+
+import re
+from collections import Counter
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from patchwork.miners.ast_base import parse_bytes, walk, node_text
+
+
+@dataclass
+class ErrorResult:
+    primary_pattern: str        # 'try/except' | 'Result<T>' | 'callbacks' | 'async/await' | 'Either'
+    exception_naming: str | None  # 'Error' suffix | 'Exception' suffix | 'mixed'
+    logging_framework: str | None
+    custom_exceptions: list[str]
+    propagation_style: str | None  # 'raise' | 'return' | 'log-and-continue' | 'mixed'
+    notes: list[str] = field(default_factory=list)
+
+
+_PY_RAISE = re.compile(r'\braise\b')
+_PY_TRY = re.compile(r'\btry\s*:')
+_PY_EXCEPT = re.compile(r'\bexcept\s+\w')
+_PY_CUSTOM_EX = re.compile(r'class\s+(\w+(?:Error|Exception))\s*\(')
+_PY_LOGGING = re.compile(r'\b(logging|structlog|loguru|logbook)\b')
+_PY_LOGGER_VAR = re.compile(r'logger\s*=\s*(logging|structlog|loguru)')
+
+_JS_TRY = re.compile(r'\btry\s*\{')
+_JS_CATCH = re.compile(r'\bcatch\s*\(')
+_JS_THROW = re.compile(r'\bthrow\s+new\s+\w+')
+_JS_PROMISE_CATCH = re.compile(r'\.catch\(')
+_JS_ASYNC_AWAIT = re.compile(r'\bawait\b')
+_JS_CUSTOM_ERROR = re.compile(r'class\s+(\w+Error)\s+extends\s+\w*Error')
+
+_GO_ERR = re.compile(r',\s*err\s*:?=')
+_GO_ERR_NIL = re.compile(r'if\s+err\s*!=\s*nil')
+_GO_CUSTOM_ERR = re.compile(r'type\s+(\w+Error)\s+struct')
+
+_RUST_RESULT = re.compile(r'Result<[^,\n]+,')
+_RUST_QUESTION = re.compile(r'\?;')
+_RUST_UNWRAP = re.compile(r'\.unwrap\(\)')
+_RUST_EXPECT = re.compile(r'\.expect\(')
+
+_LOGGING_FRAMEWORKS = {
+    "python": ["logging", "structlog", "loguru", "logbook"],
+    "javascript": ["winston", "pino", "bunyan", "loglevel", "debug", "console"],
+    "typescript": ["winston", "pino", "bunyan", "tslog", "pino-pretty"],
+    "go": ["log", "zap", "zerolog", "logrus", "slog"],
+    "rust": ["log", "tracing", "env_logger", "slog"],
+}
+
+
+def _detect_py_errors(paths: list[Path]) -> ErrorResult:
+    try_count = 0
+    raise_count = 0
+    promise_count = 0
+    custom_excs: list[str] = []
+    logging_counts: Counter[str] = Counter()
+
+    for path in paths[:150]:
+        try:
+            text = path.read_text(errors="replace")
+        except OSError:
+            continue
+        try_count += len(_PY_TRY.findall(text))
+        raise_count += len(_PY_RAISE.findall(text))
+        custom_excs.extend(_PY_CUSTOM_EX.findall(text))
+        for fw in _LOGGING_FRAMEWORKS.get("python", []):
+            if fw in text:
+                logging_counts[fw] += 1
+
+    pattern = "try/except"
+    exc_naming = None
+    if custom_excs:
+        error_suffix = sum(1 for e in custom_excs if e.endswith("Error"))
+        exc_suffix = sum(1 for e in custom_excs if e.endswith("Exception"))
+        exc_naming = "Error suffix" if error_suffix >= exc_suffix else "Exception suffix"
+
+    prop = "raise" if raise_count > try_count * 0.5 else "log-and-continue"
+    logging_fw = logging_counts.most_common(1)[0][0] if logging_counts else None
+
+    return ErrorResult(
+        primary_pattern=pattern,
+        exception_naming=exc_naming,
+        logging_framework=logging_fw,
+        custom_exceptions=list(dict.fromkeys(custom_excs))[:8],
+        propagation_style=prop,
+    )
+
+
+def _detect_js_errors(paths: list[Path], lang: str) -> ErrorResult:
+    try_count = 0
+    throw_count = 0
+    promise_catch = 0
+    async_await = 0
+    custom_errors: list[str] = []
+    logging_counts: Counter[str] = Counter()
+
+    for path in paths[:150]:
+        try:
+            text = path.read_text(errors="replace")
+        except OSError:
+            continue
+        try_count += len(_JS_TRY.findall(text))
+        throw_count += len(_JS_THROW.findall(text))
+        promise_catch += len(_JS_PROMISE_CATCH.findall(text))
+        async_await += len(_JS_ASYNC_AWAIT.findall(text))
+        custom_errors.extend(_JS_CUSTOM_ERROR.findall(text))
+        for fw in _LOGGING_FRAMEWORKS.get(lang, []):
+            if fw in text:
+                logging_counts[fw] += 1
+
+    total = try_count + promise_catch + async_await
+    if total == 0:
+        pattern = "try/catch"
+    elif async_await > promise_catch:
+        pattern = "async/await + try/catch"
+    else:
+        pattern = "Promise chains"
+
+    logging_fw = logging_counts.most_common(1)[0][0] if logging_counts else None
+
+    return ErrorResult(
+        primary_pattern=pattern,
+        exception_naming="Error suffix" if custom_errors else None,
+        logging_framework=logging_fw,
+        custom_exceptions=list(dict.fromkeys(custom_errors))[:8],
+        propagation_style="throw" if throw_count > 5 else "return",
+    )
+
+
+def _detect_go_errors(paths: list[Path]) -> ErrorResult:
+    err_check = 0
+    custom_errs: list[str] = []
+
+    for path in paths[:150]:
+        try:
+            text = path.read_text(errors="replace")
+        except OSError:
+            continue
+        err_check += len(_GO_ERR_NIL.findall(text))
+        custom_errs.extend(_GO_CUSTOM_ERR.findall(text))
+
+    notes = []
+    if err_check > 5:
+        notes.append("Idiomatic Go error handling: check `err != nil` after each call")
+
+    return ErrorResult(
+        primary_pattern="if err != nil",
+        exception_naming=None,
+        logging_framework=None,
+        custom_exceptions=list(dict.fromkeys(custom_errs))[:5],
+        propagation_style="return",
+        notes=notes,
+    )
+
+
+def _detect_rust_errors(paths: list[Path]) -> ErrorResult:
+    result_count = 0
+    question_count = 0
+    unwrap_count = 0
+
+    for path in paths[:150]:
+        try:
+            text = path.read_text(errors="replace")
+        except OSError:
+            continue
+        result_count += len(_RUST_RESULT.findall(text))
+        question_count += len(_RUST_QUESTION.findall(text))
+        unwrap_count += len(_RUST_UNWRAP.findall(text))
+
+    pattern = "Result<T,E> + ? operator" if question_count > unwrap_count else "Result<T,E> + unwrap/expect"
+    notes = []
+    if unwrap_count > question_count and question_count > 0:
+        notes.append("Mix of ? operator and .unwrap() — prefer ? in production code")
+
+    return ErrorResult(
+        primary_pattern=pattern,
+        exception_naming=None,
+        logging_framework=None,
+        custom_exceptions=[],
+        propagation_style="return",
+        notes=notes,
+    )
+
+
+class ErrorHandlingMiner:
+    def mine(self, by_lang: dict[str, list[Path]]) -> dict[str, ErrorResult]:
+        results: dict[str, ErrorResult] = {}
+        for lang, paths in by_lang.items():
+            if lang == "python":
+                results[lang] = _detect_py_errors(paths)
+            elif lang in ("javascript", "typescript"):
+                results[lang] = _detect_js_errors(paths, lang)
+            elif lang == "go":
+                results[lang] = _detect_go_errors(paths)
+            elif lang == "rust":
+                results[lang] = _detect_rust_errors(paths)
+        return results