agentrepocoach 0.2.0__py3-none-any.whl

agentrepocoach/adapters/rust.py

@@ -0,0 +1,304 @@
+"""Rust language adapter.
+
+Detects Rust repos via ``Cargo.toml`` presence. Walks ``src/`` for production
+``.rs`` files and scans for error-creation patterns. Rust uses ``Result<T, E>``
+rather than exceptions — this adapter maps error-creation sites (``panic!``,
+custom error types, ``anyhow!``, ``bail!``) to the ``ThrowSite`` model.
+
+Declarations are detected via ``pub fn``, ``pub struct``, ``pub enum``, etc.
+Doc comments use ``///`` (outer) or ``//!`` (inner) prefixes.
+
+All analysis is regex-based — no AST parsing, stdlib only.
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Iterable
+
+from .base import (
+    Declaration,
+    LanguageAdapter,
+    ThrowSite,
+    count_file_loc,
+    iter_source_files,
+    read_text_safely,
+)
+
+_RUST_SUFFIX: tuple[str, ...] = (".rs",)
+
+# Error-creation patterns.
+_PANIC_PATTERN = re.compile(r"\bpanic!\s*\(")
+_ANYHOW_PATTERN = re.compile(r"\b(?:anyhow!|bail!)\s*\(")
+_CUSTOM_ERROR_RETURN = re.compile(r"\bErr\s*\(\s*([A-Z][A-Za-z0-9_]*(?:::[A-Z]\w*)?)\s*[({]")
+
+# Declaration patterns.
+_PUB_DECL_PATTERN = re.compile(
+    r"^pub(?:\s*\(crate\))?\s+(?:async\s+)?(?:fn|struct|enum|trait|type|const|static|mod)\s+([A-Za-z_]\w*)"
+)
+_PRIVATE_DECL_PATTERN = re.compile(
+    r"^(?:async\s+)?(?:fn|struct|enum|trait|type|const|static)\s+([A-Za-z_]\w*)"
+)
+
+# Test function pattern.
+_TEST_FN_PATTERN = re.compile(r"^\s*(?:async\s+)?fn\s+(test_\w+)\s*\(")
+_TEST_ATTR_PATTERN = re.compile(r"^\s*#\[test\]")
+# Rust test naming: test_something_does_something.
+_TEST_NAMING_PATTERN = re.compile(r"^test_[a-z][a-z0-9_]*_[a-z0-9_]+$")
+
+# Generic panic types.
+_GENERIC_ERROR_NAMES: frozenset[str] = frozenset({
+    "panic!",
+    "anyhow!",
+    "bail!",
+})
+
+_FIX_HINT_KEYWORDS: tuple[str, ...] = (
+    "hint:", "fix:", "see ", "try ", "use ", "check ", "did you mean",
+    "suggested fix", "to fix", "to resolve", "example:", "ensure",
+    "expected", "must be", "should be",
+)
+
+
+class RustAdapter(LanguageAdapter):
+    """Rust adapter."""
+
+    name = "rust"
+
+    # ------------------------------------------------------------------
+    # Detection
+    # ------------------------------------------------------------------
+
+    def detect(self, repo_path: Path) -> float:
+        if (repo_path / "Cargo.toml").is_file():
+            return 1.0
+        if any(repo_path.rglob("*.rs")):
+            return 0.5
+        return 0.0
+
+    # ------------------------------------------------------------------
+    # File discovery
+    # ------------------------------------------------------------------
+
+    def find_production_files(self, repo_path: Path) -> list[Path]:
+        src_dir = repo_path / "src"
+        if src_dir.is_dir():
+            return iter_source_files(src_dir, suffixes=_RUST_SUFFIX)
+        return iter_source_files(repo_path, suffixes=_RUST_SUFFIX)
+
+    def find_test_files(self, repo_path: Path) -> list[Path]:
+        results: list[Path] = []
+        tests_dir = repo_path / "tests"
+        if tests_dir.is_dir():
+            results.extend(iter_source_files(tests_dir, suffixes=_RUST_SUFFIX))
+        # In Rust, test modules are often inline (#[cfg(test)]) in prod files.
+        # We also look for dedicated test files in src/.
+        return results
+
+    def find_production_modules(self, repo_path: Path) -> list[str]:
+        """Return crate name from Cargo.toml and top-level module names."""
+        modules: set[str] = set()
+        cargo = repo_path / "Cargo.toml"
+        if cargo.is_file():
+            text = read_text_safely(cargo)
+            m = re.search(r'name\s*=\s*"([^"]+)"', text)
+            if m:
+                modules.add(m.group(1))
+        src_dir = repo_path / "src"
+        if src_dir.is_dir():
+            for entry in src_dir.iterdir():
+                if entry.is_dir() and any(entry.rglob("*.rs")):
+                    modules.add(entry.name)
+                elif entry.is_file() and entry.suffix == ".rs" and entry.name not in ("main.rs", "lib.rs"):
+                    modules.add(entry.stem)
+        return sorted(modules)
+
+    # ------------------------------------------------------------------
+    # Throw-site analysis (Rust: panic!, bail!, Err(CustomError))
+    # ------------------------------------------------------------------
+
+    def scan_throw_sites(
+        self,
+        files: Iterable[Path],
+        hint_marker: str,
+        domain_exception_types: set[str],
+    ) -> list[ThrowSite]:
+        sites: list[ThrowSite] = []
+        for path in files:
+            text = read_text_safely(path)
+            if not text:
+                continue
+
+            # panic!() sites
+            for match in _PANIC_PATTERN.finditer(text):
+                context = _extract_context(text, match.start())
+                line_no = text.count("\n", 0, match.start()) + 1
+                sites.append(
+                    ThrowSite(
+                        file=path,
+                        line=line_no,
+                        exception_type="panic!",
+                        has_fix_hint=_has_fix_hint(context, hint_marker),
+                        is_user_defined=False,
+                        is_generic=True,
+                    )
+                )
+
+            # anyhow!/bail! sites
+            for match in _ANYHOW_PATTERN.finditer(text):
+                context = _extract_context(text, match.start())
+                line_no = text.count("\n", 0, match.start()) + 1
+                err_type = "anyhow!" if "anyhow!" in match.group() else "bail!"
+                sites.append(
+                    ThrowSite(
+                        file=path,
+                        line=line_no,
+                        exception_type=err_type,
+                        has_fix_hint=_has_fix_hint(context, hint_marker),
+                        is_user_defined=False,
+                        is_generic=True,
+                    )
+                )
+
+            # Err(CustomError{}) or Err(CustomError(...))
+            for match in _CUSTOM_ERROR_RETURN.finditer(text):
+                error_type = match.group(1)
+                context = _extract_context(text, match.start())
+                line_no = text.count("\n", 0, match.start()) + 1
+                sites.append(
+                    ThrowSite(
+                        file=path,
+                        line=line_no,
+                        exception_type=error_type,
+                        has_fix_hint=_has_fix_hint(context, hint_marker),
+                        is_user_defined=error_type in domain_exception_types,
+                        is_generic=False,
+                    )
+                )
+        return sites
+
+    def generic_exception_names(self) -> set[str]:
+        return set(_GENERIC_ERROR_NAMES)
+
+    # ------------------------------------------------------------------
+    # Declarations
+    # ------------------------------------------------------------------
+
+    def scan_declarations(self, files: Iterable[Path]) -> list[Declaration]:
+        declarations: list[Declaration] = []
+        for path in files:
+            text = read_text_safely(path)
+            if not text:
+                continue
+            declarations.extend(self._scan_declarations_in_text(path, text))
+        return declarations
+
+    def _scan_declarations_in_text(self, path: Path, text: str) -> list[Declaration]:
+        lines = text.splitlines()
+        results: list[Declaration] = []
+        for i, line in enumerate(lines):
+            # Try pub declarations first.
+            m = _PUB_DECL_PATTERN.match(line)
+            if m:
+                visibility = "internal" if "pub(crate)" in line else "public"
+                results.append(
+                    Declaration(
+                        file=path,
+                        line=i + 1,
+                        name=m.group(1),
+                        visibility=visibility,
+                        has_doc_comment=_has_preceding_doc_comment(lines, i),
+                    )
+                )
+                continue
+            # Try private (no pub) declarations — only at column 0.
+            if not line.startswith(" ") and not line.startswith("\t"):
+                m = _PRIVATE_DECL_PATTERN.match(line)
+                if m:
+                    results.append(
+                        Declaration(
+                            file=path,
+                            line=i + 1,
+                            name=m.group(1),
+                            visibility="private",
+                            has_doc_comment=_has_preceding_doc_comment(lines, i),
+                        )
+                    )
+        return results
+
+    # ------------------------------------------------------------------
+    # Test methods
+    # ------------------------------------------------------------------
+
+    def find_test_methods(self, files: Iterable[Path]) -> list[tuple[Path, str]]:
+        """Find test functions in both dedicated test files and inline #[test] modules."""
+        results: list[tuple[Path, str]] = []
+        all_files = list(files)
+        # Also scan production files for inline tests.
+        for path in all_files:
+            text = read_text_safely(path)
+            if not text:
+                continue
+            lines = text.splitlines()
+            for i, line in enumerate(lines):
+                m = _TEST_FN_PATTERN.match(line)
+                if m:
+                    results.append((path, m.group(1)))
+                    continue
+                # Also detect functions preceded by #[test] attribute.
+                if _TEST_ATTR_PATTERN.match(line):
+                    # Next non-blank, non-attribute line should be the fn.
+                    for j in range(i + 1, min(i + 5, len(lines))):
+                        fn_match = re.match(r"^\s*(?:async\s+)?fn\s+(\w+)\s*\(", lines[j])
+                        if fn_match:
+                            results.append((path, fn_match.group(1)))
+                            break
+        return results
+
+    def test_naming_pattern(self) -> re.Pattern[str]:
+        return _TEST_NAMING_PATTERN
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _extract_context(text: str, start: int, max_chars: int = 500) -> str:
+    """Extract text from start through the next closing paren/brace."""
+    end = min(start + max_chars, len(text))
+    depth = 0
+    for i in range(start, end):
+        ch = text[i]
+        if ch in ("(", "{"):
+            depth += 1
+        elif ch in (")", "}"):
+            depth -= 1
+            if depth == 0:
+                return text[start:i + 1]
+    return text[start:end]
+
+
+def _has_fix_hint(text: str, hint_marker: str) -> bool:
+    lower = text.lower()
+    if hint_marker and hint_marker.lower() in lower:
+        return True
+    for keyword in _FIX_HINT_KEYWORDS:
+        if keyword in lower:
+            return True
+    return False
+
+
+def _has_preceding_doc_comment(lines: list[str], index: int) -> bool:
+    """Return True if the line above is a Rust doc comment (``///`` or ``//!``)."""
+    j = index - 1
+    while j >= 0:
+        stripped = lines[j].strip()
+        if stripped == "":
+            j -= 1
+            continue
+        return stripped.startswith("///") or stripped.startswith("//!")
+    return False
+
+
+RustAdapter.count_file_loc = staticmethod(count_file_loc)  # type: ignore[attr-defined]

agentrepocoach/adapters/typescript.py

@@ -0,0 +1,351 @@
+"""TypeScript language adapter.
+
+Detects TypeScript repos via ``tsconfig.json`` / ``package.json`` presence.
+Walks ``src/`` for production files and ``tests/`` / ``test/`` / ``__tests__/``
+for test files. Scans ``throw new`` statements, classifies error types, and
+detects JSDoc presence above top-level declarations.
+
+All analysis is regex-based against file text — no AST parsing, no runtime
+dependencies beyond the Python 3.11+ standard library.
+"""
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Iterable
+
+from .base import (
+    Declaration,
+    LanguageAdapter,
+    ThrowSite,
+    count_file_loc,
+    iter_source_files,
+    read_text_safely,
+)
+
+_TS_SUFFIX: tuple[str, ...] = (".ts", ".tsx")
+_TS_EXCLUDE_SUFFIXES: tuple[str, ...] = (".d.ts",)
+_TS_TEST_SUFFIXES: tuple[str, ...] = (".test.ts", ".test.tsx", ".spec.ts", ".spec.tsx")
+
+# Throw-site scanning.
+_THROW_PATTERN = re.compile(r"\bthrow\s+new\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(")
+
+# Declaration scanning — exported (public).
+_EXPORT_CLASS_PATTERN = re.compile(
+    r"^export\s+(?:default\s+|abstract\s+)*(?:class|interface)\s+([A-Za-z_]\w*)"
+)
+_EXPORT_FUNCTION_PATTERN = re.compile(
+    r"^export\s+(?:default\s+|async\s+)*function\s+([A-Za-z_]\w*)"
+)
+_EXPORT_ENUM_PATTERN = re.compile(
+    r"^export\s+(?:const\s+)?enum\s+([A-Za-z_]\w*)"
+)
+_EXPORT_TYPE_PATTERN = re.compile(
+    r"^export\s+type\s+([A-Za-z_]\w*)\s*[=<{]"
+)
+_EXPORT_CONST_PATTERN = re.compile(
+    r"^export\s+const\s+([A-Za-z_]\w*)\s*[=:]"
+)
+
+# Non-exported (internal) declarations.
+_INTERNAL_CLASS_PATTERN = re.compile(
+    r"^(?:abstract\s+)?class\s+([A-Za-z_]\w*)"
+)
+_INTERNAL_FUNCTION_PATTERN = re.compile(
+    r"^(?:async\s+)?function\s+([A-Za-z_]\w*)"
+)
+_INTERNAL_CONST_PATTERN = re.compile(
+    r"^const\s+([A-Za-z_]\w*)\s*[=:]"
+)
+
+# Test method patterns (Jest/Vitest/Mocha).
+_TEST_IT_PATTERN = re.compile(r"""\bit\s*\(\s*(['"`])(.+?)\1""")
+_TEST_TEST_PATTERN = re.compile(r"""\btest\s*\(\s*(['"`])(.+?)\1""")
+
+# Test naming: descriptive string — we accept anything with at least 3 words.
+_TEST_DESCRIPTIVE_PATTERN = re.compile(r"^.+\s.+\s.+")
+
+# Language-stdlib error types considered "too generic" for good agent UX.
+_GENERIC_EXCEPTION_NAMES: frozenset[str] = frozenset({
+    "Error",
+    "TypeError",
+    "RangeError",
+    "ReferenceError",
+    "SyntaxError",
+})
+
+_FIX_HINT_KEYWORDS: tuple[str, ...] = (
+    "hint:", "fix:", "see ", "try ", "use ", "check ", "did you mean",
+    "suggested fix", "to fix", "to resolve", "example:", "ensure",
+    "install", "provide", "verify", "configure",
+)
+
+_PROD_DIR_CANDIDATES: tuple[str, ...] = ("src", "lib")
+_TEST_DIR_CANDIDATES: tuple[str, ...] = ("tests", "test", "__tests__")
+
+
+class TypeScriptAdapter(LanguageAdapter):
+    """TypeScript / JavaScript adapter."""
+
+    name = "typescript"
+
+    # ------------------------------------------------------------------
+    # Detection
+    # ------------------------------------------------------------------
+
+    def detect(self, repo_path: Path) -> float:
+        if (repo_path / "tsconfig.json").is_file():
+            return 1.0
+        pkg_json = repo_path / "package.json"
+        if pkg_json.is_file():
+            try:
+                data = json.loads(read_text_safely(pkg_json))
+                deps = {**data.get("dependencies", {}), **data.get("devDependencies", {})}
+                if "typescript" in deps:
+                    return 0.8
+            except (json.JSONDecodeError, TypeError):
+                pass
+            return 0.3
+        return 0.0
+
+    # ------------------------------------------------------------------
+    # File discovery
+    # ------------------------------------------------------------------
+
+    def find_production_files(self, repo_path: Path) -> list[Path]:
+        production_roots = self._production_roots(repo_path)
+        results: list[Path] = []
+        for root in production_roots:
+            for f in iter_source_files(
+                root,
+                suffixes=_TS_SUFFIX,
+                exclude_suffixes=_TS_EXCLUDE_SUFFIXES,
+            ):
+                if not _is_test_file(f):
+                    results.append(f)
+        return results
+
+    def find_test_files(self, repo_path: Path) -> list[Path]:
+        results: list[Path] = []
+        # Conventional test directories.
+        for name in _TEST_DIR_CANDIDATES:
+            candidate = repo_path / name
+            if candidate.is_dir():
+                results.extend(
+                    iter_source_files(candidate, suffixes=_TS_SUFFIX, exclude_suffixes=_TS_EXCLUDE_SUFFIXES)
+                )
+        # Also pick up co-located test files in production directories.
+        for root in self._production_roots(repo_path):
+            for f in iter_source_files(root, suffixes=_TS_SUFFIX, exclude_suffixes=_TS_EXCLUDE_SUFFIXES):
+                if _is_test_file(f) and f not in results:
+                    results.append(f)
+        return results
+
+    def find_production_modules(self, repo_path: Path) -> list[str]:
+        """Top-level directories under src/ that contain .ts files."""
+        modules: set[str] = set()
+        for root in self._production_roots(repo_path):
+            for entry in root.iterdir():
+                if entry.is_dir() and any(entry.rglob("*.ts")):
+                    modules.add(entry.name)
+            # If src/ has direct .ts files but no subdirectories, use the root name.
+            if not modules:
+                ts_files = list(root.glob("*.ts"))
+                if ts_files:
+                    modules.add(root.name)
+        return sorted(modules)
+
+    def _production_roots(self, repo_path: Path) -> list[Path]:
+        roots: list[Path] = []
+        for name in _PROD_DIR_CANDIDATES:
+            candidate = repo_path / name
+            if candidate.is_dir():
+                roots.append(candidate)
+        return roots
+
+    # ------------------------------------------------------------------
+    # Throw-site analysis
+    # ------------------------------------------------------------------
+
+    def scan_throw_sites(
+        self,
+        files: Iterable[Path],
+        hint_marker: str,
+        domain_exception_types: set[str],
+    ) -> list[ThrowSite]:
+        sites: list[ThrowSite] = []
+        for path in files:
+            text = read_text_safely(path)
+            if not text:
+                continue
+            for match in _THROW_PATTERN.finditer(text):
+                exception_type = match.group(1)
+                line_no = text.count("\n", 0, match.start()) + 1
+                # Extract text from throw to closing paren/semicolon for
+                # fix-hint detection (message often spans multiple lines).
+                context_text = _extract_throw_context(text, match.start())
+                sites.append(
+                    ThrowSite(
+                        file=path,
+                        line=line_no,
+                        exception_type=exception_type,
+                        has_fix_hint=_has_fix_hint(context_text, hint_marker),
+                        is_user_defined=exception_type in domain_exception_types,
+                        is_generic=exception_type in _GENERIC_EXCEPTION_NAMES,
+                    )
+                )
+        return sites
+
+    def generic_exception_names(self) -> set[str]:
+        return set(_GENERIC_EXCEPTION_NAMES)
+
+    # ------------------------------------------------------------------
+    # Declarations
+    # ------------------------------------------------------------------
+
+    def scan_declarations(self, files: Iterable[Path]) -> list[Declaration]:
+        declarations: list[Declaration] = []
+        for path in files:
+            text = read_text_safely(path)
+            if not text:
+                continue
+            declarations.extend(self._scan_declarations_in_text(path, text))
+        return declarations
+
+    def _scan_declarations_in_text(self, path: Path, text: str) -> list[Declaration]:
+        lines = text.splitlines()
+        results: list[Declaration] = []
+        for i, line in enumerate(lines):
+            stripped = line.strip()
+
+            # Try exported (public) patterns first.
+            name = _match_exported(stripped)
+            if name is not None:
+                results.append(
+                    Declaration(
+                        file=path,
+                        line=i + 1,
+                        name=name,
+                        visibility="public",
+                        has_doc_comment=_has_preceding_jsdoc(lines, i),
+                    )
+                )
+                continue
+
+            # Try non-exported (internal) patterns — only at column 0.
+            if line and not line[0].isspace():
+                name = _match_internal(stripped)
+                if name is not None:
+                    results.append(
+                        Declaration(
+                            file=path,
+                            line=i + 1,
+                            name=name,
+                            visibility="internal",
+                            has_doc_comment=_has_preceding_jsdoc(lines, i),
+                        )
+                    )
+        return results
+
+    # ------------------------------------------------------------------
+    # Test methods
+    # ------------------------------------------------------------------
+
+    def find_test_methods(self, files: Iterable[Path]) -> list[tuple[Path, str]]:
+        results: list[tuple[Path, str]] = []
+        for path in files:
+            text = read_text_safely(path)
+            if not text:
+                continue
+            for match in _TEST_IT_PATTERN.finditer(text):
+                results.append((path, match.group(2)))
+            for match in _TEST_TEST_PATTERN.finditer(text):
+                results.append((path, match.group(2)))
+        return results
+
+    def test_naming_pattern(self) -> re.Pattern[str]:
+        return _TEST_DESCRIPTIVE_PATTERN
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _extract_throw_context(text: str, start: int, max_chars: int = 500) -> str:
+    """Extract text from a throw statement through the closing paren.
+
+    Walks forward from ``start`` up to ``max_chars`` or the matching close
+    paren, whichever comes first. This captures multi-line throw messages.
+    """
+    end = min(start + max_chars, len(text))
+    depth = 0
+    for i in range(start, end):
+        if text[i] == "(":
+            depth += 1
+        elif text[i] == ")":
+            depth -= 1
+            if depth == 0:
+                return text[start:i + 1]
+    return text[start:end]
+
+
+def _is_test_file(path: Path) -> bool:
+    name = path.name
+    return any(name.endswith(sfx) for sfx in _TS_TEST_SUFFIXES)
+
+
+def _has_fix_hint(text: str, hint_marker: str) -> bool:
+    lower = text.lower()
+    if hint_marker and hint_marker.lower() in lower:
+        return True
+    for keyword in _FIX_HINT_KEYWORDS:
+        if keyword in lower:
+            return True
+    return False
+
+
+def _match_exported(line: str) -> str | None:
+    """Return the declaration name if line is an export declaration, else None."""
+    for pattern in (
+        _EXPORT_CLASS_PATTERN,
+        _EXPORT_FUNCTION_PATTERN,
+        _EXPORT_ENUM_PATTERN,
+        _EXPORT_TYPE_PATTERN,
+        _EXPORT_CONST_PATTERN,
+    ):
+        m = pattern.match(line)
+        if m:
+            return m.group(1)
+    return None
+
+
+def _match_internal(line: str) -> str | None:
+    """Return the declaration name if line is a non-exported top-level declaration."""
+    for pattern in (
+        _INTERNAL_CLASS_PATTERN,
+        _INTERNAL_FUNCTION_PATTERN,
+        _INTERNAL_CONST_PATTERN,
+    ):
+        m = pattern.match(line)
+        if m:
+            return m.group(1)
+    return None
+
+
+def _has_preceding_jsdoc(lines: list[str], index: int) -> bool:
+    """Walk backwards from ``index``. Return True if the first non-blank line
+    above ends with ``*/`` (closing a JSDoc block).
+    """
+    j = index - 1
+    while j >= 0:
+        stripped = lines[j].strip()
+        if stripped == "":
+            j -= 1
+            continue
+        return stripped.endswith("*/")
+    return False
+
+
+TypeScriptAdapter.count_file_loc = staticmethod(count_file_loc)  # type: ignore[attr-defined]