testpick 0.2.0__py3-none-any.whl

testpick/graph/node.py

@@ -0,0 +1,16 @@
+"""Module node representing a parsed source file."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from ..parser.base import ImportInfo
+
+
+@dataclass
+class ModuleNode:
+    filepath: Path
+    language: str
+    exports: list[str] = field(default_factory=list)
+    imports: list[ImportInfo] = field(default_factory=list)

testpick/parser/__init__.py

@@ -0,0 +1,18 @@
+"""Parser package for testpick: AST-based code analysis."""
+
+from .base import BaseParser, ImportInfo, ParseResult, Symbol, SymbolKind
+from .python import PythonParser
+from .registry import LANGUAGES, get_parser
+from .typescript import TypeScriptParser
+
+__all__ = [
+    "BaseParser",
+    "ImportInfo",
+    "ParseResult",
+    "Symbol",
+    "SymbolKind",
+    "PythonParser",
+    "TypeScriptParser",
+    "LANGUAGES",
+    "get_parser",
+]

testpick/parser/base.py

@@ -0,0 +1,46 @@
+"""Base parser interface and data models for testpick."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+
+
+class SymbolKind(Enum):
+    FUNCTION = "function"
+    CLASS = "class"
+    VARIABLE = "variable"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class Symbol:
+    name: str
+    kind: SymbolKind
+    line: int
+    is_exported: bool = False
+
+
+@dataclass
+class ImportInfo:
+    module: str
+    names: list[str] = field(default_factory=list)
+    kind: str = "import"  # "import" or "from"
+
+
+@dataclass
+class ParseResult:
+    symbols: list[Symbol] = field(default_factory=list)
+    imports: list[ImportInfo] = field(default_factory=list)
+    language: str = ""
+
+
+class BaseParser(ABC):
+    """Abstract base class for language-specific parsers."""
+
+    @abstractmethod
+    def parse(self, filepath: Path) -> ParseResult:
+        """Parse a source file and return extracted symbols and imports."""
+        ...

testpick/parser/python.py

@@ -0,0 +1,225 @@
+"""Python parser using tree-sitter AST."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from .base import BaseParser, ImportInfo, ParseResult, Symbol, SymbolKind
+
+try:
+    from tree_sitter import Language, Parser
+
+    import tree_sitter_python
+
+    _PY_LANGUAGE = Language(tree_sitter_python.language())
+    _HAS_TREE_SITTER = True
+except ImportError:
+    _HAS_TREE_SITTER = False
+
+
+def _node_text(node, source: bytes) -> str:
+    return source[node.start_byte:node.end_byte].decode("utf-8", errors="replace")
+
+
+def _get_name(node, source: bytes) -> str | None:
+    """Extract the name (identifier) from a definition node."""
+    for child in node.children:
+        if child.type == "identifier":
+            return _node_text(child, source)
+    return None
+
+
+class PythonParser(BaseParser):
+    def parse(self, filepath: Path) -> ParseResult:
+        source = filepath.read_bytes()
+        if _HAS_TREE_SITTER:
+            return self._parse_with_tree_sitter(source)
+        return self._parse_with_regex(source)
+
+    # ── tree-sitter path ──
+
+    def _parse_with_tree_sitter(self, source: bytes) -> ParseResult:
+        parser = Parser(_PY_LANGUAGE)
+        tree = parser.parse(source)
+        root = tree.root_node
+
+        symbols: list[Symbol] = []
+        imports: list[ImportInfo] = []
+        all_names: list[str] | None = None
+
+        for node in root.children:
+            ntype = node.type
+
+            if ntype == "function_definition":
+                name = _get_name(node, source)
+                if name:
+                    is_pub = not name.startswith("_") or name in ("__init__", "__str__", "__repr__")
+                    symbols.append(Symbol(name, SymbolKind.FUNCTION, node.start_point[0], is_pub))
+
+            elif ntype == "class_definition":
+                name = _get_name(node, source)
+                if name:
+                    is_pub = not name.startswith("_")
+                    symbols.append(Symbol(name, SymbolKind.CLASS, node.start_point[0], is_pub))
+
+            elif ntype == "expression_statement":
+                self._extract_assignment(node, source, symbols)
+
+            elif ntype == "import_statement":
+                imports.append(self._extract_import(node, source))
+
+            elif ntype == "import_from_statement":
+                imports.append(self._extract_from_import(node, source))
+
+        # Check __all__ for explicit exports
+        all_names = self._find_all(root, source)
+        if all_names is not None:
+            all_set = set(all_names)
+            for sym in symbols:
+                sym.is_exported = sym.name in all_set
+
+        return ParseResult(symbols=symbols, imports=imports, language="python")
+
+    def _extract_assignment(self, node, source: bytes, symbols: list[Symbol]) -> None:
+        for child in node.children:
+            if child.type == "assignment":
+                # left side is the target
+                target = child.children[0] if child.children else None
+                if target and target.type == "identifier":
+                    name = _node_text(target, source)
+                    is_pub = not name.startswith("_")
+                    symbols.append(Symbol(name, SymbolKind.VARIABLE, node.start_point[0], is_pub))
+
+    def _extract_import(self, node, source: bytes) -> ImportInfo:
+        names: list[str] = []
+        for child in node.children:
+            if child.type == "dotted_name":
+                names.append(_node_text(child, source))
+            elif child.type == "aliased_import":
+                alias = None
+                for sub in child.children:
+                    if sub.type == "identifier":
+                        alias = alias or _node_text(sub, source)
+                if alias:
+                    names.append(alias)
+        module = names[0] if names else ""
+        return ImportInfo(module=module, names=names, kind="import")
+
+    def _extract_from_import(self, node, source: bytes) -> ImportInfo:
+        module = ""
+        names: list[str] = []
+        first_dotted_seen = False
+        for child in node.children:
+            if child.type == "dotted_name":
+                if not first_dotted_seen:
+                    module = _node_text(child, source)
+                    first_dotted_seen = True
+                else:
+                    names.append(_node_text(child, source))
+            elif child.type == "relative_import":
+                # Handle relative imports like "from .foo import bar"
+                prefix = ""
+                import_name = ""
+                for sub in child.children:
+                    if sub.type == "import_prefix":
+                        prefix = _node_text(sub, source)
+                    elif sub.type == "dotted_name":
+                        import_name = _node_text(sub, source)
+                module = prefix + import_name
+                first_dotted_seen = True
+            elif child.type == "wildcard_import":
+                names.append("*")
+            elif child.type == "aliased_import":
+                for sub in child.children:
+                    if sub.type == "identifier":
+                        names.append(_node_text(sub, source))
+            elif child.type == "identifier":
+                names.append(_node_text(child, source))
+        return ImportInfo(module=module, names=names, kind="from")
+
+    def _find_all(self, root, source: bytes) -> list[str] | None:
+        """Look for __all__ = [...] at module level."""
+        for node in root.children:
+            if node.type == "expression_statement":
+                for child in node.children:
+                    if child.type == "assignment":
+                        left = child.children[0] if child.children else None
+                        if left and _node_text(left, source) == "__all__":
+                            right = child.children[2] if len(child.children) > 2 else None
+                            if right and right.type == "list":
+                                return self._extract_list_elements(right, source)
+        return None
+
+    def _extract_list_elements(self, node, source: bytes) -> list[str]:
+        result: list[str] = []
+        for child in node.children:
+            if child.type == "string":
+                text = _node_text(child, source).strip("'\"")
+                result.append(text)
+        return result
+
+    # ── regex fallback ──
+
+    def _parse_with_regex(self, source: bytes) -> ParseResult:
+        text = source.decode("utf-8", errors="replace")
+        lines = text.splitlines()
+
+        symbols: list[Symbol] = []
+        imports: list[ImportInfo] = []
+        all_names: list[str] | None = None
+
+        for i, line in enumerate(lines, start=1):
+            stripped = line.strip()
+
+            # Function definition
+            m = re.match(r"def\s+(\w+)\s*\(", stripped)
+            if m:
+                name = m.group(1)
+                is_pub = not name.startswith("_") or name in ("__init__", "__str__", "__repr__")
+                symbols.append(Symbol(name, SymbolKind.FUNCTION, i, is_pub))
+                continue
+
+            # Class definition
+            m = re.match(r"class\s+(\w+)", stripped)
+            if m:
+                name = m.group(1)
+                symbols.append(Symbol(name, SymbolKind.CLASS, i, not name.startswith("_")))
+                continue
+
+            # Variable assignment at module level
+            m = re.match(r"(\w+)\s*=\s*", stripped)
+            if m and not stripped.startswith("def ") and not stripped.startswith("class "):
+                name = m.group(1)
+                if name.isupper() or not name.startswith("_"):
+                    symbols.append(Symbol(name, SymbolKind.VARIABLE, i, not name.startswith("_")))
+                continue
+
+            # __all__
+            m = re.match(r'__all__\s*=\s*\[(.*?)\]', stripped)
+            if m:
+                raw = m.group(1)
+                all_names = re.findall(r"['\"](\w+)['\"]", raw)
+                continue
+
+            # import
+            m = re.match(r"import\s+(.+)", stripped)
+            if m:
+                names = [n.strip() for n in m.group(1).split(",")]
+                imports.append(ImportInfo(module=names[0], names=names, kind="import"))
+                continue
+
+            # from X import Y
+            m = re.match(r"from\s+(\S+)\s+import\s+(.+)", stripped)
+            if m:
+                module = m.group(1)
+                names = [n.strip() for n in m.group(2).split(",")]
+                imports.append(ImportInfo(module=module, names=names, kind="from"))
+                continue
+
+        if all_names is not None:
+            all_set = set(all_names)
+            for sym in symbols:
+                sym.is_exported = sym.name in all_set
+
+        return ParseResult(symbols=symbols, imports=imports, language="python")

testpick/parser/registry.py

@@ -0,0 +1,24 @@
+"""Parser registry: maps file extensions to parser instances."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .base import BaseParser
+from .python import PythonParser
+from .typescript import TypeScriptParser
+
+LANGUAGES: dict[str, BaseParser] = {
+    ".py": PythonParser(),
+    ".pyi": PythonParser(),
+    ".js": TypeScriptParser(),
+    ".jsx": TypeScriptParser(),
+    ".ts": TypeScriptParser(),
+    ".tsx": TypeScriptParser(),
+    ".mjs": TypeScriptParser(),
+    ".cjs": TypeScriptParser(),
+}
+
+
+def get_parser(filepath: Path) -> BaseParser | None:
+    return LANGUAGES.get(filepath.suffix.lower())

testpick/parser/typescript.py

@@ -0,0 +1,207 @@
+"""TypeScript / JavaScript parser using tree-sitter AST."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from .base import BaseParser, ImportInfo, ParseResult, Symbol, SymbolKind
+
+try:
+    from tree_sitter import Language, Parser
+
+    import tree_sitter_javascript
+    import tree_sitter_typescript
+
+    _TS_LANGUAGE = Language(tree_sitter_typescript.language_typescript())
+    _JS_LANGUAGE = Language(tree_sitter_javascript.language())
+    _HAS_TREE_SITTER = True
+except ImportError:
+    _HAS_TREE_SITTER = False
+
+
+def _node_text(node, source: bytes) -> str:
+    return source[node.start_byte:node.end_byte].decode("utf-8", errors="replace")
+
+
+def _get_name(node, source: bytes) -> str | None:
+    for child in node.children:
+        if child.type in ("identifier", "type_identifier"):
+            return _node_text(child, source)
+    return None
+
+
+def _has_export_keyword(node, source: bytes) -> bool:
+    """Check if a node is preceded by 'export'."""
+    text = source[:node.start_byte].decode("utf-8", errors="replace")
+    last_line = text.splitlines()[-1] if text.splitlines() else ""
+    return "export" in last_line
+
+
+class TypeScriptParser(BaseParser):
+    def parse(self, filepath: Path) -> ParseResult:
+        source = filepath.read_bytes()
+        ext = filepath.suffix.lower()
+
+        if _HAS_TREE_SITTER:
+            lang = _JS_LANGUAGE if ext in (".js", ".jsx", ".mjs", ".cjs") else _TS_LANGUAGE
+            return self._parse_with_tree_sitter(source, lang, "typescript")
+        return self._parse_with_regex(source, "typescript")
+
+    # ── tree-sitter path ──
+
+    def _parse_with_tree_sitter(self, source: bytes, language, lang_name: str) -> ParseResult:
+        parser = Parser(language)
+        tree = parser.parse(source)
+        root = tree.root_node
+
+        symbols: list[Symbol] = []
+        imports: list[ImportInfo] = []
+
+        for node in root.children:
+            ntype = node.type
+            exported = _has_export_keyword(node, source)
+
+            if ntype in ("function_declaration", "function"):
+                name = _get_name(node, source)
+                if name:
+                    symbols.append(Symbol(name, SymbolKind.FUNCTION, node.start_point[0], exported))
+
+            elif ntype == "class_declaration":
+                name = _get_name(node, source)
+                if name:
+                    symbols.append(Symbol(name, SymbolKind.CLASS, node.start_point[0], exported))
+
+            elif ntype in ("lexical_declaration", "variable_declaration"):
+                self._extract_var_declarations(node, source, symbols, exported, imports)
+
+            elif ntype == "import_statement":
+                imp = self._extract_ts_import(node, source)
+                if imp:
+                    imports.append(imp)
+
+            elif ntype == "export_statement":
+                self._extract_export(node, source, symbols)
+
+            elif ntype == "expression_statement":
+                self._extract_require(node, source, imports)
+
+        return ParseResult(symbols=symbols, imports=imports, language=lang_name)
+
+    def _extract_var_declarations(
+        self,
+        node,
+        source: bytes,
+        symbols: list[Symbol],
+        exported: bool,
+        imports: list[ImportInfo] | None = None,
+    ) -> None:
+        for child in node.children:
+            if child.type == "variable_declarator":
+                name_node = child.children[0] if child.children else None
+                if name_node and name_node.type == "identifier":
+                    name = _node_text(name_node, source)
+                    symbols.append(Symbol(name, SymbolKind.VARIABLE, node.start_point[0], exported))
+                # Check for require() in initializer
+                if imports is not None:
+                    for sub in child.children:
+                        if sub.type == "call_expression":
+                            self._extract_require(sub, source, imports)
+
+    def _extract_ts_import(self, node, source: bytes) -> ImportInfo | None:
+        text = _node_text(node, source)
+        # from 'module' import ... OR import ... from 'module'
+        m = re.search(r"""from\s+['"]([^'"]+)['"]""", text)
+        if not m:
+            # import 'module' style
+            m = re.search(r"""import\s+['"]([^'"]+)['"]""", text)
+            if m:
+                return ImportInfo(module=m.group(1), names=[], kind="import")
+            return None
+        module = m.group(1)
+
+        # Extract imported names
+        names: list[str] = []
+        # import { foo, bar } from ...
+        brace = re.search(r"\{([^}]*)\}", text)
+        if brace:
+            names = [n.strip().split(" as ")[-1].strip() for n in brace.group(1).split(",") if n.strip()]
+        else:
+            # import Foo from ... (default)
+            before_from = text[: text.find("from")].strip().replace("import", "").strip()
+            if before_from:
+                names = [before_from]
+
+        return ImportInfo(module=module, names=names, kind="from")
+
+    def _extract_export(self, node, source: bytes, symbols: list[Symbol]) -> None:
+        for child in node.children:
+            if child.type == "function_declaration":
+                name = _get_name(child, source)
+                if name:
+                    symbols.append(Symbol(name, SymbolKind.FUNCTION, node.start_point[0], True))
+            elif child.type == "class_declaration":
+                name = _get_name(child, source)
+                if name:
+                    symbols.append(Symbol(name, SymbolKind.CLASS, node.start_point[0], True))
+            elif child.type in ("lexical_declaration", "variable_declaration"):
+                self._extract_var_declarations(child, source, symbols, True)
+
+    def _extract_require(self, node, source: bytes, imports: list[ImportInfo]) -> None:
+        text = _node_text(node, source)
+        m = re.search(r"""require\s*\(\s*['"]([^'"]+)['"]\s*\)""", text)
+        if m:
+            imports.append(ImportInfo(module=m.group(1), names=[], kind="import"))
+
+    # ── regex fallback ──
+
+    def _parse_with_regex(self, source: bytes, lang_name: str) -> ParseResult:
+        text = source.decode("utf-8", errors="replace")
+        lines = text.splitlines()
+
+        symbols: list[Symbol] = []
+        imports: list[ImportInfo] = []
+
+        for i, line in enumerate(lines, start=1):
+            stripped = line.strip()
+
+            # Function declaration
+            m = re.match(r"(?:export\s+)?(?:async\s+)?function\s+(\w+)", stripped)
+            if m:
+                exported = "export" in stripped
+                symbols.append(Symbol(m.group(1), SymbolKind.FUNCTION, i, exported))
+                continue
+
+            # Class declaration
+            m = re.match(r"(?:export\s+)?class\s+(\w+)", stripped)
+            if m:
+                exported = "export" in stripped
+                symbols.append(Symbol(m.group(1), SymbolKind.CLASS, i, exported))
+                continue
+
+            # const/let/var declaration
+            m = re.match(r"(?:export\s+)?(?:const|let|var)\s+(\w+)", stripped)
+            if m:
+                exported = "export" in stripped
+                symbols.append(Symbol(m.group(1), SymbolKind.VARIABLE, i, exported))
+                continue
+
+            # import statement
+            m = re.match(r"""import\s+.*\s+from\s+['"]([^'"]+)['"]""", stripped)
+            if m:
+                names = re.findall(r"(\w+)", stripped.split("from")[0].replace("import", ""))
+                imports.append(ImportInfo(module=m.group(1), names=names, kind="from"))
+                continue
+
+            m = re.match(r"""import\s+['"]([^'"]+)['"]""", stripped)
+            if m:
+                imports.append(ImportInfo(module=m.group(1), names=[], kind="import"))
+                continue
+
+            # require()
+            m = re.search(r"""require\s*\(\s*['"]([^'"]+)['"]\s*\)""", stripped)
+            if m:
+                imports.append(ImportInfo(module=m.group(1), names=[], kind="import"))
+                continue
+
+        return ParseResult(symbols=symbols, imports=imports, language=lang_name)

testpick/reporter/__init__.py

@@ -0,0 +1,7 @@
+"""Reporter modules for testpick output."""
+
+from .json_reporter import JsonReporter
+from .github import GitHubReporter
+from .terminal import TerminalReporter
+
+__all__ = ["TerminalReporter", "JsonReporter", "GitHubReporter"]

testpick/reporter/github.py

@@ -0,0 +1,58 @@
+"""GitHub Actions annotation reporter for testpick."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+class GitHubReporter:
+    """Render results as GitHub Actions workflow annotations."""
+
+    def render(
+        self,
+        changed_files: list[tuple[str, str]],
+        test_files: list[Path],
+        dependency_chains: dict[Path, list[Path]],
+        stats: dict,
+    ) -> str:
+        lines: list[str] = []
+
+        # Summary header
+        lines.append("## testpick Results")
+        lines.append("")
+        lines.append(f"**Changed files:** {len(changed_files)}  ")
+        lines.append(f"**Affected tests:** {len(test_files)}  ")
+        lines.append(f"**Insertions:** +{stats.get('insertions', 0)}  ")
+        lines.append(f"**Deletions:** -{stats.get('deletions', 0)}")
+        lines.append("")
+
+        # Changed files as annotations
+        for status, filepath in changed_files:
+            icon = {"A": "🆕", "M": "📝", "D": "🗑️", "R": "🚚"}.get(status, "📄")
+            lines.append(f"### {icon} Changed: `{filepath}`")
+
+        lines.append("")
+
+        # Affected tests as warning annotations
+        if test_files:
+            lines.append("### ⚠️ Affected Tests")
+            lines.append("")
+            for test_file in test_files:
+                chain = dependency_chains.get(test_file, [])
+                if chain:
+                    chain_str = " → ".join(f"`{p.as_posix()}`" for p in chain)
+                    lines.append(f"- `{test_file.as_posix()}` (via {chain_str})")
+                else:
+                    lines.append(f"- `{test_file.as_posix()}`")
+            lines.append("")
+
+            # GitHub Actions annotations for each affected test
+            for test_file in test_files:
+                lines.append(
+                    f"::warning file={test_file.as_posix()}::This test may be affected by recent changes"
+                )
+        else:
+            lines.append("### ✅ No affected tests found")
+            lines.append("")
+
+        return "\n".join(lines)

testpick/reporter/json_reporter.py

@@ -0,0 +1,49 @@
+"""JSON reporter that outputs structured JSON data."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+class JsonReporter:
+    def render(
+        self,
+        changed_files: list[tuple[str, str]],
+        test_files: list[Path],
+        dependency_chains: dict[Path, list[Path]],
+        stats: dict,
+    ) -> str:
+        """Render the test selection results as a JSON string.
+
+        Args:
+            changed_files: List of (status, filepath) tuples from git diff.
+            test_files: List of selected test filepaths.
+            dependency_chains: Mapping from test file to its dependency chain.
+            stats: Statistics about the analysis.
+
+        Returns:
+            JSON string with structured data.
+        """
+        data: dict[str, Any] = {
+            "changed_files": [
+                {"status": status, "path": filepath}
+                for status, filepath in changed_files
+            ],
+            "test_files": [
+                {
+                    "path": test_file.as_posix(),
+                    "dependency_chain": [p.as_posix() for p in dependency_chains.get(test_file, [])],
+                }
+                for test_file in test_files
+            ],
+            "stats": {
+                "files_changed": stats.get("files_changed", 0),
+                "tests_selected": len(test_files),
+                "insertions": stats.get("insertions", 0),
+                "deletions": stats.get("deletions", 0),
+            },
+        }
+
+        return json.dumps(data, indent=2)