patchwork-conventions 0.1.0__py3-none-any.whl

patchwork/miners/git_patterns.py

@@ -0,0 +1,169 @@
+"""
+GitPatternMiner — Mines git history for workflow conventions:
+  - Commit message style (conventional commits / semantic / free-form)
+  - Branch naming convention
+  - PR/merge frequency
+  - Average commit size (files changed)
+  - Co-change pairs (files that always change together)
+"""
+from __future__ import annotations
+
+import re
+import subprocess
+from collections import Counter, defaultdict
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class GitResult:
+    commit_style: str | None        # 'conventional' | 'semantic' | 'free-form'
+    commit_examples: list[str]
+    branch_style: str | None        # 'feature/name' | 'feat/name' | 'JIRA-123' | 'free-form'
+    avg_files_per_commit: float
+    total_commits_sampled: int
+    cochange_pairs: list[tuple[str, str, int]]  # (fileA, fileB, count)
+    notes: list[str] = field(default_factory=list)
+
+
+_CONVENTIONAL_RE = re.compile(
+    r'^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?!?:\s+.+'
+)
+_SEMANTIC_RE = re.compile(
+    r'^(add|update|remove|fix|change|bump|improve|rename|move|delete|merge)\s+',
+    re.IGNORECASE
+)
+_BRANCH_FEATURE = re.compile(r'^(feature|feat)/[\w/-]+$')
+_BRANCH_JIRA = re.compile(r'^[A-Z]+-\d+')
+_BRANCH_FIX = re.compile(r'^(fix|hotfix|bugfix)/[\w/-]+$')
+
+
+def _run_git(args: list[str], cwd: Path, max_bytes: int = 500_000) -> str:
+    try:
+        result = subprocess.run(
+            ["git"] + args,
+            cwd=str(cwd),
+            capture_output=True,
+            timeout=10,
+        )
+        return result.stdout[:max_bytes].decode("utf-8", errors="replace")
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        return ""
+
+
+def _is_git_repo(root: Path) -> bool:
+    return (root / ".git").exists()
+
+
+class GitPatternMiner:
+    def __init__(self, root: Path):
+        self.root = root
+
+    def mine(self) -> GitResult | None:
+        if not _is_git_repo(self.root):
+            return None
+
+        # Sample last 200 commit messages
+        log_out = _run_git(
+            ["log", "--oneline", "-200", "--pretty=format:%s"],
+            self.root,
+        )
+        messages = [m.strip() for m in log_out.splitlines() if m.strip()]
+
+        if not messages:
+            return None
+
+        # Commit style detection
+        conventional = sum(1 for m in messages if _CONVENTIONAL_RE.match(m))
+        semantic = sum(1 for m in messages if _SEMANTIC_RE.match(m))
+        total = len(messages)
+
+        if conventional / total > 0.5:
+            style = "conventional commits"
+        elif semantic / total > 0.4:
+            style = "semantic prefixes"
+        else:
+            style = "free-form"
+
+        examples = messages[:5]
+
+        # Branch names
+        branches_out = _run_git(
+            ["branch", "-a", "--format=%(refname:short)"],
+            self.root,
+        )
+        branches = [b.strip() for b in branches_out.splitlines() if b.strip()]
+        branch_style = _detect_branch_style(branches)
+
+        # Average files per commit
+        diff_stat = _run_git(
+            ["log", "--oneline", "-100", "--stat"],
+            self.root,
+        )
+        file_counts = re.findall(r'(\d+) files? changed', diff_stat)
+        avg_files = (
+            round(sum(int(x) for x in file_counts) / len(file_counts), 1)
+            if file_counts else 0.0
+        )
+
+        # Co-change analysis (files that often change together)
+        co_change = _detect_cochange(self.root)
+
+        notes: list[str] = []
+        if style == "conventional commits":
+            notes.append(
+                "Uses Conventional Commits — always prefix messages with type(scope): description"
+            )
+
+        return GitResult(
+            commit_style=style,
+            commit_examples=examples,
+            branch_style=branch_style,
+            avg_files_per_commit=avg_files,
+            total_commits_sampled=total,
+            cochange_pairs=co_change[:5],
+            notes=notes,
+        )
+
+
+def _detect_branch_style(branches: list[str]) -> str | None:
+    if not branches:
+        return None
+    feature = sum(1 for b in branches if _BRANCH_FEATURE.match(b))
+    fix = sum(1 for b in branches if _BRANCH_FIX.match(b))
+    jira = sum(1 for b in branches if _BRANCH_JIRA.match(b))
+    total = len(branches)
+    if (feature + fix) / total > 0.4:
+        return "feature/name + fix/name"
+    if jira / total > 0.4:
+        return "JIRA-123 ticket keys"
+    return "free-form"
+
+
+def _detect_cochange(root: Path) -> list[tuple[str, str, int]]:
+    """Find file pairs that change together frequently."""
+    log_out = _run_git(
+        ["log", "--name-only", "--pretty=format:--COMMIT--", "-100"],
+        root,
+        max_bytes=200_000,
+    )
+    commits: list[list[str]] = []
+    current: list[str] = []
+    for line in log_out.splitlines():
+        if line == "--COMMIT--":
+            if current:
+                commits.append(current)
+            current = []
+        elif line.strip() and not line.startswith("diff"):
+            current.append(line.strip())
+    if current:
+        commits.append(current)
+
+    pair_counts: Counter[tuple[str, str]] = Counter()
+    for commit_files in commits:
+        files = sorted(set(commit_files))
+        for i, f1 in enumerate(files):
+            for f2 in files[i + 1:]:
+                pair_counts[(f1, f2)] += 1
+
+    return [(a, b, count) for (a, b), count in pair_counts.most_common(10) if count >= 2]

patchwork/miners/imports.py

@@ -0,0 +1,158 @@
+"""
+ImportMiner — Detects import style conventions:
+  - Absolute vs relative imports
+  - Path alias usage (e.g. @/, ~/, src/)
+  - Import grouping (stdlib / third-party / local)
+  - Barrel file patterns (index.ts re-exports)
+  - Destructuring vs namespace imports
+"""
+from __future__ import annotations
+
+import re
+from collections import Counter
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class ImportResult:
+    style: str                      # 'absolute' | 'relative' | 'mixed'
+    relative_confidence: float
+    aliases_used: list[str]         # e.g. ['@/', 'src/']
+    grouping: str | None            # 'grouped' | 'ungrouped'
+    destructuring: str | None       # 'destructuring' | 'namespace' | 'mixed'
+    barrel_files: list[str]         # relative paths of index.{ts,js}
+    common_stdlib: list[str]        # most imported stdlib modules
+    common_third_party: list[str]   # most imported third-party packages
+    notes: list[str] = field(default_factory=list)
+
+
+_PY_RELATIVE = re.compile(r'^\s*from\s+\.', re.MULTILINE)
+_PY_ABSOLUTE = re.compile(r'^\s*(?:import|from)\s+(?!\.)', re.MULTILINE)
+_PY_IMPORT = re.compile(r'^\s*(?:from\s+([\w.]+)\s+import|import\s+([\w.,\s]+))', re.MULTILINE)
+
+_JS_RELATIVE = re.compile(r"""(?:import|require)\s*\(?['"](\./|\.\./)""", re.MULTILINE)
+_JS_ABSOLUTE_ALIAS = re.compile(r"""(?:import|require)\s*\(?['"](@\w+/|~/)""", re.MULTILINE)
+_JS_IMPORT_FROM = re.compile(r"""import\s+(?:\{[^}]+\}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]""")
+_JS_DESTRUCTURE = re.compile(r"""import\s+\{[^}]+\}\s+from""")
+_JS_NAMESPACE = re.compile(r"""import\s+\*\s+as\s+\w+\s+from""")
+_JS_SIDE_EFFECT = re.compile(r"""import\s+['"][^'"]+['"]""")
+
+_STDLIB_PY = {
+    "os", "sys", "re", "json", "pathlib", "typing", "dataclasses",
+    "collections", "itertools", "functools", "io", "time", "datetime",
+    "logging", "unittest", "asyncio", "threading", "subprocess",
+    "hashlib", "base64", "copy", "math", "random",
+}
+
+
+def _detect_py_imports(paths: list[Path]) -> ImportResult:
+    relative_count = 0
+    absolute_count = 0
+    all_modules: list[str] = []
+    aliases: set[str] = set()
+
+    for path in paths[:200]:
+        try:
+            text = path.read_text(errors="replace")
+        except OSError:
+            continue
+        relative_count += len(_PY_RELATIVE.findall(text))
+        absolute_count += len(_PY_ABSOLUTE.findall(text))
+        for m in _PY_IMPORT.finditer(text):
+            mod = (m.group(1) or m.group(2) or "").strip().split(".")[0]
+            if mod:
+                all_modules.append(mod)
+        # Detect src/ or similar path aliases in pyproject/setup.cfg
+        if "@" in text or "from src." in text:
+            aliases.add("src/")
+
+    total = relative_count + absolute_count
+    rel_conf = relative_count / total if total else 0.0
+    style = "relative" if rel_conf > 0.6 else ("mixed" if rel_conf > 0.2 else "absolute")
+
+    counts = Counter(all_modules)
+    stdlib = [m for m, _ in counts.most_common(30) if m in _STDLIB_PY][:5]
+    third_party = [m for m, _ in counts.most_common(30) if m not in _STDLIB_PY][:8]
+
+    return ImportResult(
+        style=style,
+        relative_confidence=round(rel_conf, 2),
+        aliases_used=list(aliases),
+        grouping=None,
+        destructuring=None,
+        barrel_files=[],
+        common_stdlib=stdlib,
+        common_third_party=third_party,
+    )
+
+
+def _detect_js_imports(paths: list[Path], lang: str) -> ImportResult:
+    relative_count = 0
+    alias_count = 0
+    alias_prefixes: Counter[str] = Counter()
+    destructure_count = 0
+    namespace_count = 0
+    all_packages: list[str] = []
+    barrel_files: list[str] = []
+
+    for path in paths[:200]:
+        try:
+            text = path.read_text(errors="replace")
+        except OSError:
+            continue
+
+        relative_count += len(_JS_RELATIVE.findall(text))
+        found_aliases = _JS_ABSOLUTE_ALIAS.findall(text)
+        alias_count += len(found_aliases)
+        for a in found_aliases:
+            alias_prefixes[a] += 1
+
+        destructure_count += len(_JS_DESTRUCTURE.findall(text))
+        namespace_count += len(_JS_NAMESPACE.findall(text))
+
+        for m in _JS_IMPORT_FROM.finditer(text):
+            pkg = m.group(1)
+            if not pkg.startswith(".") and not pkg.startswith("@"):
+                top = pkg.split("/")[0]
+                all_packages.append(top)
+
+        # Barrel file detection
+        if path.stem == "index" and lang == "typescript":
+            if "export" in text and "from" in text:
+                barrel_files.append(str(path.name))
+
+    total = relative_count + alias_count
+    rel_conf = relative_count / total if total else 0.5
+    style = "relative" if rel_conf > 0.7 else ("mixed" if rel_conf > 0.3 else "absolute")
+
+    aliases = [a for a, _ in alias_prefixes.most_common(5)]
+
+    destr = None
+    if destructure_count + namespace_count > 0:
+        ratio = destructure_count / (destructure_count + namespace_count)
+        destr = "destructuring" if ratio > 0.7 else ("namespace" if ratio < 0.3 else "mixed")
+
+    third_party = [m for m, _ in Counter(all_packages).most_common(10)]
+
+    return ImportResult(
+        style=style,
+        relative_confidence=round(rel_conf, 2),
+        aliases_used=aliases,
+        grouping=None,
+        destructuring=destr,
+        barrel_files=barrel_files[:5],
+        common_stdlib=[],
+        common_third_party=third_party,
+    )
+
+
+class ImportMiner:
+    def mine(self, by_lang: dict[str, list[Path]]) -> dict[str, ImportResult]:
+        results: dict[str, ImportResult] = {}
+        for lang, paths in by_lang.items():
+            if lang == "python":
+                results[lang] = _detect_py_imports(paths)
+            elif lang in ("javascript", "typescript"):
+                results[lang] = _detect_js_imports(paths, lang)
+        return results

patchwork/miners/naming.py

@@ -0,0 +1,277 @@
+"""
+NamingMiner — Detects naming conventions across functions, classes, variables,
+constants, files. Uses tree-sitter AST when available; falls back to regex.
+
+Detects:
+  - camelCase / PascalCase / snake_case / SCREAMING_SNAKE / kebab-case
+  - Consistency score per category
+  - Language-specific override rules (e.g. Go unexported = lowercase)
+"""
+from __future__ import annotations
+
+import re
+from collections import Counter, defaultdict
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from patchwork.miners.ast_base import parse_file, walk, node_text
+
+
+@dataclass
+class NamingConvention:
+    style: str           # 'snake_case' | 'camelCase' | 'PascalCase' | 'SCREAMING_SNAKE' | 'mixed'
+    confidence: float    # 0.0 – 1.0
+    examples: list[str] = field(default_factory=list)
+    counter_examples: list[str] = field(default_factory=list)
+
+
+@dataclass
+class NamingResult:
+    functions: NamingConvention | None = None
+    classes: NamingConvention | None = None
+    variables: NamingConvention | None = None
+    constants: NamingConvention | None = None
+    files: NamingConvention | None = None
+    private_prefix: str | None = None   # e.g. '_' or '__'
+    test_prefix: str | None = None      # e.g. 'test_' or 'Test'
+    notes: list[str] = field(default_factory=list)
+
+
+# ── Naming style detection ────────────────────────────────────────────────────
+
+_RE_SNAKE = re.compile(r'^[a-z][a-z0-9]*(_[a-z0-9]+)*$')
+_RE_CAMEL = re.compile(r'^[a-z][a-zA-Z0-9]*$')
+_RE_PASCAL = re.compile(r'^[A-Z][a-zA-Z0-9]*$')
+_RE_SCREAMING = re.compile(r'^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$')
+_RE_KEBAB = re.compile(r'^[a-z][a-z0-9]*(-[a-z0-9]+)*$')
+_RE_PRIVATE_SINGLE = re.compile(r'^_[a-z]')
+_RE_PRIVATE_DOUBLE = re.compile(r'^__[a-z]')
+
+
+def _classify(name: str) -> str:
+    if _RE_SCREAMING.match(name):
+        return "SCREAMING_SNAKE"
+    if _RE_SNAKE.match(name):
+        return "snake_case"
+    if _RE_CAMEL.match(name):
+        return "camelCase"
+    if _RE_PASCAL.match(name):
+        return "PascalCase"
+    if _RE_KEBAB.match(name):
+        return "kebab-case"
+    return "mixed"
+
+
+def _majority_convention(names: list[str]) -> NamingConvention:
+    if not names:
+        return NamingConvention(style="mixed", confidence=0.0)
+    counts: Counter[str] = Counter(_classify(n) for n in names)
+    top_style, top_count = counts.most_common(1)[0]
+    confidence = top_count / len(names)
+    examples = [n for n in names if _classify(n) == top_style][:5]
+    counter_examples = [n for n in names if _classify(n) != top_style][:3]
+    return NamingConvention(
+        style=top_style,
+        confidence=round(confidence, 2),
+        examples=examples,
+        counter_examples=counter_examples,
+    )
+
+
+# ── Language-specific AST extraction ─────────────────────────────────────────
+
+_FUNCTION_TYPES = {
+    "python": ("function_definition", "async_function_definition"),
+    "javascript": ("function_declaration", "arrow_function", "method_definition"),
+    "typescript": ("function_declaration", "arrow_function", "method_definition"),
+    "go": ("function_declaration", "method_declaration"),
+    "rust": ("function_item",),
+    "java": ("method_declaration", "constructor_declaration"),
+}
+
+_CLASS_TYPES = {
+    "python": ("class_definition",),
+    "javascript": ("class_declaration",),
+    "typescript": ("class_declaration",),
+    "go": ("type_declaration",),
+    "rust": ("struct_item", "enum_item", "trait_item"),
+    "java": ("class_declaration", "interface_declaration", "enum_declaration"),
+}
+
+_VAR_TYPES = {
+    "python": ("assignment",),
+    "javascript": ("variable_declarator",),
+    "typescript": ("variable_declarator",),
+    "go": ("short_var_decl", "var_spec"),
+    "rust": ("let_declaration",),
+    "java": ("variable_declarator",),
+}
+
+
+def _extract_function_names(root, source: bytes, lang: str) -> list[str]:
+    types = _FUNCTION_TYPES.get(lang, ())
+    names = []
+    for node in walk(root):
+        if node.type in types:
+            name_node = node.child_by_field_name("name")
+            if name_node:
+                names.append(node_text(name_node, source))
+    return names
+
+
+def _extract_class_names(root, source: bytes, lang: str) -> list[str]:
+    types = _CLASS_TYPES.get(lang, ())
+    names = []
+    for node in walk(root):
+        if node.type in types:
+            name_node = node.child_by_field_name("name")
+            if name_node:
+                names.append(node_text(name_node, source))
+    return names
+
+
+def _extract_var_names(root, source: bytes, lang: str) -> list[str]:
+    types = _VAR_TYPES.get(lang, ())
+    names = []
+    for node in walk(root):
+        if node.type in types:
+            name_node = node.child_by_field_name("name")
+            if name_node:
+                t = node_text(name_node, source)
+                if len(t) > 1 and not t.startswith("_"):
+                    names.append(t)
+    return names[:200]  # cap to avoid noise
+
+
+# ── Regex fallback ────────────────────────────────────────────────────────────
+
+_FALLBACK_PATTERNS = {
+    "python": {
+        "functions": re.compile(r'^def\s+([A-Za-z_][A-Za-z0-9_]*)', re.MULTILINE),
+        "classes": re.compile(r'^class\s+([A-Za-z_][A-Za-z0-9_]*)', re.MULTILINE),
+        "constants": re.compile(r'^([A-Z][A-Z0-9_]{2,})\s*=', re.MULTILINE),
+    },
+    "javascript": {
+        "functions": re.compile(r'(?:function\s+|const\s+|let\s+|var\s+)([A-Za-z_$][A-Za-z0-9_$]*)\s*(?:=\s*(?:async\s+)?(?:function|\()|{|\()'),
+        "classes": re.compile(r'class\s+([A-Za-z_$][A-Za-z0-9_$]*)'),
+        "constants": re.compile(r'const\s+([A-Z_]{2,}[A-Z0-9_]*)\s*='),
+    },
+    "typescript": {
+        "functions": re.compile(r'(?:function\s+|const\s+|let\s+|async\s+function\s+)([A-Za-z_$][A-Za-z0-9_$]*)'),
+        "classes": re.compile(r'class\s+([A-Za-z_$][A-Za-z0-9_$]*)'),
+        "constants": re.compile(r'const\s+([A-Z_]{2,}[A-Z0-9_]*)\s*='),
+    },
+    "go": {
+        "functions": re.compile(r'^func\s+(?:\([^)]+\)\s+)?([A-Za-z][A-Za-z0-9]*)', re.MULTILINE),
+        "classes": re.compile(r'^type\s+([A-Za-z][A-Za-z0-9]*)\s+struct', re.MULTILINE),
+        "constants": re.compile(r'const\s+([A-Z][A-Za-z0-9]*)\s', re.MULTILINE),
+    },
+}
+
+
+def _regex_mine(paths: list[Path], lang: str) -> dict[str, list[str]]:
+    patterns = _FALLBACK_PATTERNS.get(lang, {})
+    result: dict[str, list[str]] = defaultdict(list)
+    for path in paths[:100]:
+        try:
+            text = path.read_text(errors="replace")
+        except OSError:
+            continue
+        for category, pat in patterns.items():
+            result[category].extend(pat.findall(text))
+    return result
+
+
+# ── Public miner ─────────────────────────────────────────────────────────────
+
+class NamingMiner:
+    def mine(self, by_lang: dict[str, list[Path]]) -> dict[str, NamingResult]:
+        """Return a NamingResult per language."""
+        results: dict[str, NamingResult] = {}
+
+        for lang, paths in by_lang.items():
+            all_funcs: list[str] = []
+            all_classes: list[str] = []
+            all_vars: list[str] = []
+            all_consts: list[str] = []
+
+            for path in paths[:150]:  # cap for performance
+                try:
+                    source = path.read_bytes()
+                except OSError:
+                    continue
+
+                from patchwork.miners.ast_base import parse_bytes
+                root = parse_bytes(source, lang)
+
+                if root is not None:
+                    src_str = source.decode("utf-8", errors="replace")
+                    all_funcs.extend(_extract_function_names(root, source, lang))
+                    all_classes.extend(_extract_class_names(root, source, lang))
+                    all_vars.extend(_extract_var_names(root, source, lang))
+                    # Detect constants: names that are SCREAMING_SNAKE in assignments
+                    all_consts.extend(
+                        n for n in all_vars if _RE_SCREAMING.match(n)
+                    )
+                else:
+                    # Regex fallback
+                    mined = _regex_mine([path], lang)
+                    all_funcs.extend(mined.get("functions", []))
+                    all_classes.extend(mined.get("classes", []))
+                    all_consts.extend(mined.get("constants", []))
+
+            # Deduplicate and build result
+            all_funcs = list(dict.fromkeys(all_funcs))
+            all_classes = list(dict.fromkeys(all_classes))
+            all_vars = list(dict.fromkeys(all_vars))
+            all_consts = list(dict.fromkeys(all_consts))
+
+            # Detect private naming convention
+            private_prefix = None
+            if lang == "python":
+                dunder = [f for f in all_funcs if f.startswith("__") and not f.endswith("__")]
+                single = [f for f in all_funcs if f.startswith("_") and not f.startswith("__")]
+                if dunder:
+                    private_prefix = "__"
+                elif single:
+                    private_prefix = "_"
+
+            # Detect test prefix
+            test_prefix = None
+            test_funcs = [f for f in all_funcs if f.startswith("test_")]
+            Test_funcs = [f for f in all_funcs if f.startswith("Test")]
+            if test_funcs:
+                test_prefix = "test_"
+            elif Test_funcs:
+                test_prefix = "Test"
+
+            notes = []
+            if lang == "go":
+                exported = [f for f in all_funcs if f and f[0].isupper()]
+                unexported = [f for f in all_funcs if f and f[0].islower()]
+                if exported and unexported:
+                    notes.append(
+                        "Go convention: PascalCase for exported identifiers, camelCase for unexported"
+                    )
+
+            results[lang] = NamingResult(
+                functions=_majority_convention(
+                    [f for f in all_funcs if not f.startswith("_")]
+                ) if all_funcs else None,
+                classes=_majority_convention(all_classes) if all_classes else None,
+                variables=_majority_convention(
+                    [v for v in all_vars if not _RE_SCREAMING.match(v)]
+                ) if all_vars else None,
+                constants=_majority_convention(all_consts) if all_consts else None,
+                files=_file_naming(paths),
+                private_prefix=private_prefix,
+                test_prefix=test_prefix,
+                notes=notes,
+            )
+
+        return results
+
+
+def _file_naming(paths: list[Path]) -> NamingConvention:
+    stems = [p.stem for p in paths if p.stem and p.stem not in ("__init__", "index", "main")]
+    return _majority_convention(stems)