testpick 0.2.0__py3-none-any.whl

testpick/__init__.py

@@ -0,0 +1,10 @@
+"""testpick - Select which tests to run based on code changes."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("testpick")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+
+__all__ = ["__version__"]

testpick/__main__.py

@@ -0,0 +1,3 @@
+from testpick.cli import main
+
+main()

testpick/cli.py

@@ -0,0 +1,228 @@
+"""CLI interface for testpick."""
+
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+
+import click
+from git.exc import GitError
+
+from . import __version__
+from .git.commit import (
+    get_branch_diff,
+    get_commit_files,
+    get_commit_message,
+    get_commit_stats,
+)
+from .git.diff import get_changed_files, get_diff_stats, get_repo_root
+from .git.interactive import InteractiveCommitPicker, is_interactive
+from .graph import DependencyGraph
+from .parser import LANGUAGES
+from .reporter import GitHubReporter, JsonReporter, TerminalReporter
+from .selector import DependencyWalker, TestMatcher
+
+LANGUAGE_FILTERS = {
+    "python": {".py", ".pyi"},
+    "typescript": {".ts", ".tsx"},
+    "javascript": {".js", ".jsx", ".mjs", ".cjs"},
+}
+
+LANGUAGE_ALIASES = {"py": "python", "ts": "typescript", "js": "javascript"}
+
+EXCLUDE_DIRS = {
+    "__pycache__",
+    "node_modules",
+    ".git",
+    "venv",
+    ".venv",
+    "dist",
+    "build",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".tox",
+    ".nox",
+    "site-packages",
+}
+
+
+def _language_extensions(languages: str | None) -> set[str]:
+    if not languages:
+        return set(LANGUAGES)
+    extensions: set[str] = set()
+    for name in languages.split(","):
+        key = name.strip().lower()
+        extensions |= LANGUAGE_FILTERS.get(LANGUAGE_ALIASES.get(key, key), set())
+    return extensions or set(LANGUAGES)
+
+
+def _discover_source_files(root: Path, languages: str | None) -> list[Path]:
+    extensions = _language_extensions(languages)
+    files: list[Path] = []
+    for path in root.rglob("*"):
+        if not path.is_file() or path.suffix.lower() not in extensions:
+            continue
+        if any(part in EXCLUDE_DIRS for part in path.parts):
+            continue
+        files.append(path)
+    return files
+
+
+def _relative(path: Path, root: Path) -> Path:
+    try:
+        return path.relative_to(root)
+    except ValueError:
+        return path
+
+
+def _enable_utf8_output() -> None:
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is None:
+            continue
+        try:
+            reconfigure(encoding="utf-8", errors="replace")
+        except (ValueError, OSError):
+            pass
+
+
+def _build_chains(
+    test_files: list[Path], parents: dict[Path, Path], changed_paths: set[Path]
+) -> dict[Path, list[Path]]:
+    chains: dict[Path, list[Path]] = {}
+    for test_file in test_files:
+        if test_file in changed_paths:
+            chains[test_file] = []
+            continue
+        chain = [test_file]
+        seen = {test_file}
+        current = test_file
+        while current in parents:
+            current = parents[current]
+            if current in seen:
+                break
+            seen.add(current)
+            chain.append(current)
+        chains[test_file] = chain
+    return chains
+
+
+def _resolve_commit(commit_arg: str | None) -> str | None:
+    if commit_arg is None:
+        return None
+    if commit_arg == "":
+        if not is_interactive():
+            click.echo(
+                "Error: '--commit' without a value requires an interactive terminal.",
+                err=True,
+            )
+            sys.exit(1)
+        selected = InteractiveCommitPicker().pick()
+        if not selected:
+            click.echo("No commit selected. Aborting.")
+            sys.exit(0)
+        return selected
+    return commit_arg
+
+
+def _fetch_changes(
+    commit: str | None, base: str
+) -> tuple[list[tuple[str, str]], dict]:
+    if commit is not None:
+        return get_commit_files(commit), get_commit_stats(commit)
+    if base == "HEAD":
+        return get_changed_files(base="HEAD"), get_diff_stats(base="HEAD")
+    return get_branch_diff(base=base), get_diff_stats(base=f"{base}...HEAD")
+
+
+@click.command()
+@click.option(
+    "--commit",
+    is_flag=False,
+    flag_value="",
+    default=None,
+    help="Analyze a specific commit. Run without a value to launch an interactive picker.",
+)
+@click.option(
+    "--base",
+    default="HEAD",
+    show_default=True,
+    help="Branch to compare against for committed changes",
+)
+@click.option(
+    "--format",
+    "output_format",
+    type=click.Choice(["terminal", "json", "github"]),
+    default="terminal",
+    show_default=True,
+)
+@click.option("--verbose", is_flag=True, help="Enable verbose output")
+@click.option("--languages", help="Comma-separated language filter, e.g. python,typescript")
+@click.version_option(version=__version__)
+def main(commit, base, output_format, verbose, languages):
+    """testpick - Select which tests to run based on code changes."""
+    start_time = time.time()
+    _enable_utf8_output()
+
+    try:
+        root = get_repo_root()
+
+        commit = _resolve_commit(commit)
+        changed_files, stats = _fetch_changes(commit, base)
+
+        if verbose and commit:
+            message = get_commit_message(commit)
+            first_line = message.splitlines()[0] if message else "(no message)"
+            click.echo(f"Commit {commit[:10]}: {first_line}")
+
+        if not changed_files:
+            click.echo("No changed files found.")
+            return
+
+        if verbose:
+            click.echo(f"Found {len(changed_files)} changed files")
+
+        graph = DependencyGraph()
+        graph.build_from_files(_discover_source_files(root, languages))
+
+        if verbose:
+            click.echo(f"Graph built with {len(graph.nodes)} nodes and {len(graph.edges)} edges")
+
+        absolute_changes = [(status, str(root / path)) for status, path in changed_files]
+        affected, parents = DependencyWalker().walk_from_files(absolute_changes, graph)
+
+        matcher = TestMatcher()
+        test_files = matcher.match(affected, graph)
+
+        if verbose:
+            click.echo(f"Found {len(affected)} affected files")
+            click.echo(f"Selected {len(test_files)} test files")
+
+        changed_paths = {Path(path).resolve() for _, path in absolute_changes}
+        chains = _build_chains(test_files, parents, changed_paths)
+
+        test_files = [_relative(path, root) for path in test_files]
+        chains = {
+            _relative(name, root): [_relative(p, root) for p in chain]
+            for name, chain in chains.items()
+        }
+
+        if output_format == "json":
+            click.echo(JsonReporter().render(changed_files, test_files, chains, stats))
+        elif output_format == "github":
+            click.echo(GitHubReporter().render(changed_files, test_files, chains, stats))
+        else:
+            TerminalReporter().render(changed_files, test_files, chains, stats)
+
+        if verbose:
+            click.echo(f"\nCompleted in {time.time() - start_time:.2f}s")
+
+    except GitError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

testpick/git/__init__.py

@@ -0,0 +1,21 @@
+from .diff import get_changed_files, get_file_diff, get_diff_stats, get_repo_root
+from .commit import (
+    get_commit_files,
+    get_commit_message,
+    get_commit_stats,
+    get_branch_diff,
+)
+from .interactive import InteractiveCommitPicker, is_interactive
+
+__all__ = [
+    "get_changed_files",
+    "get_file_diff",
+    "get_diff_stats",
+    "get_repo_root",
+    "get_commit_files",
+    "get_commit_message",
+    "get_commit_stats",
+    "get_branch_diff",
+    "InteractiveCommitPicker",
+    "is_interactive",
+]

testpick/git/commit.py

@@ -0,0 +1,28 @@
+"""Git commit analysis utilities."""
+
+from pathlib import Path
+
+from .diff import _get_repo, _parse_name_status, _parse_numstat
+
+
+def get_commit_files(commit_hash: str, cwd: Path | None = None) -> list[tuple[str, str]]:
+    repo = _get_repo(cwd)
+    output = repo.git.diff_tree("--no-commit-id", "-r", "--name-status", commit_hash)
+    if not output.strip():
+        output = repo.git.diff_tree("--root", "--no-commit-id", "-r", "--name-status", commit_hash)
+    return _parse_name_status(output)
+
+
+def get_commit_message(commit_hash: str, cwd: Path | None = None) -> str:
+    repo = _get_repo(cwd)
+    return repo.git.log("-1", "--format=%B", commit_hash).strip()
+
+
+def get_commit_stats(commit_hash: str, cwd: Path | None = None) -> dict:
+    repo = _get_repo(cwd)
+    return _parse_numstat(repo.git.show("--numstat", "--format=", commit_hash))
+
+
+def get_branch_diff(base: str = "main", cwd: Path | None = None) -> list[tuple[str, str]]:
+    repo = _get_repo(cwd)
+    return _parse_name_status(repo.git.diff("--name-status", f"{base}...HEAD"))

testpick/git/diff.py

@@ -0,0 +1,59 @@
+"""Git diff analysis utilities."""
+
+from pathlib import Path
+from git import Repo
+
+
+def _get_repo(cwd: Path | None = None) -> Repo:
+    return Repo(path=cwd, search_parent_directories=True)
+
+
+def get_repo_root(cwd: Path | None = None) -> Path:
+    return Path(_get_repo(cwd).working_dir).resolve()
+
+
+def _parse_name_status(output: str) -> list[tuple[str, str]]:
+    files: list[tuple[str, str]] = []
+    for line in output.strip().splitlines():
+        if not line:
+            continue
+        parts = line.split("\t")
+        if len(parts) >= 2:
+            files.append((parts[0].rstrip("0123456789"), parts[-1]))
+    return files
+
+
+def _parse_numstat(output: str) -> dict:
+    insertions = 0
+    deletions = 0
+    files_changed = 0
+    for line in output.strip().splitlines():
+        if not line:
+            continue
+        parts = line.split("\t")
+        if len(parts) >= 3:
+            files_changed += 1
+            if parts[0] != "-":
+                insertions += int(parts[0])
+            if parts[1] != "-":
+                deletions += int(parts[1])
+    return {
+        "files_changed": files_changed,
+        "insertions": insertions,
+        "deletions": deletions,
+    }
+
+
+def get_changed_files(base: str = "HEAD", cwd: Path | None = None) -> list[tuple[str, str]]:
+    repo = _get_repo(cwd)
+    return _parse_name_status(repo.git.diff("--name-status", base))
+
+
+def get_file_diff(filepath: str, base: str = "HEAD", cwd: Path | None = None) -> str:
+    repo = _get_repo(cwd)
+    return repo.git.diff(base, "--", filepath)
+
+
+def get_diff_stats(base: str = "HEAD", cwd: Path | None = None) -> dict:
+    repo = _get_repo(cwd)
+    return _parse_numstat(repo.git.diff("--numstat", base))

testpick/git/interactive.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import readchar
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from .diff import _get_repo
+
+
+def is_interactive() -> bool:
+    return sys.stdin.isatty() and sys.stdout.isatty()
+
+
+class InteractiveCommitPicker:
+    def __init__(self, limit: int = 50, cwd: Path | None = None) -> None:
+        self._repo = _get_repo(cwd)
+        self._limit = limit
+        self._console = Console()
+        self._selected = 0
+        self._commits: list[tuple[str, str, str, str]] = []
+        self._filter: str = ""
+
+    def _fetch_commits(self) -> None:
+        output = self._repo.git.log(f"-{self._limit}", "--format=%H%x00%ai%x00%an%x00%s")
+        for line in output.splitlines():
+            parts = line.split("\x00")
+            if len(parts) == 4:
+                self._commits.append(tuple(parts))
+
+    def _visible(self) -> list[tuple[str, str, str, str]]:
+        if not self._filter:
+            return self._commits
+        f = self._filter.lower()
+        return [c for c in self._commits if f in c[0].lower() or f in c[3].lower()]
+
+    def _render(self) -> None:
+        commits = self._visible()
+        self._console.print(Panel("[bold]testpick — Select a commit[/bold]", style="blue"))
+
+        tb = Table(show_header=True, header_style="bold cyan")
+        tb.add_column("#", width=5)
+        tb.add_column("Hash", width=10)
+        tb.add_column("Date", width=20)
+        tb.add_column("Author", width=18)
+        tb.add_column("Subject", overflow="fold")
+
+        for i, (h, d, a, s) in enumerate(commits):
+            marker = ">" if i == self._selected else " "
+            tb.add_row(
+                f"{marker} {i + 1}", h[:8], d[:19], a, s,
+                style="reverse" if i == self._selected else None,
+            )
+
+        self._console.print(tb)
+
+        total = len(commits)
+        pos = f"{self._selected + 1}/{total}" if total else "0/0"
+        filter_line = f"  [filter: {self._filter}]" if self._filter else ""
+        self._console.print(f"\n{pos}{filter_line}")
+        self._console.print("[↑/↓] navigate  [type] search  [Enter] select  [Esc] cancel")
+
+    def pick(self) -> str | None:
+        try:
+            self._fetch_commits()
+        except Exception:
+            self._console.print("[red]Could not read commit history.[/red]")
+            return None
+
+        if not self._commits:
+            self._console.print("[yellow]No commits found.[/yellow]")
+            return None
+
+        while True:
+            self._console.clear()
+            self._render()
+            key = readchar.readkey()
+
+            if key == readchar.key.UP:
+                commits = self._visible()
+                if commits:
+                    self._selected = (self._selected - 1) % len(commits)
+            elif key == readchar.key.DOWN:
+                commits = self._visible()
+                if commits:
+                    self._selected = (self._selected + 1) % len(commits)
+            elif key == readchar.key.ENTER:
+                commits = self._visible()
+                return commits[self._selected][0] if commits else None
+            elif key == readchar.key.ESC:
+                if self._filter:
+                    self._filter = ""
+                    self._selected = 0
+                else:
+                    return None
+            elif key in ("\x7f", "\x08"):
+                self._filter = self._filter[:-1]
+                self._selected = 0
+            elif key in ("\x03", "\x04"):
+                return None
+            elif len(key) == 1 and key.isprintable():
+                self._filter += key
+                self._selected = 0

testpick/graph/__init__.py

@@ -0,0 +1,7 @@
+"""Import dependency graph for testpick."""
+
+from .builder import DependencyGraph
+from .edge import ImportEdge
+from .node import ModuleNode
+
+__all__ = ["DependencyGraph", "ImportEdge", "ModuleNode"]

testpick/graph/builder.py

@@ -0,0 +1,201 @@
+"""Dependency graph builder that parses files and resolves imports."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ..parser.base import ImportInfo
+from ..parser.registry import LANGUAGES, get_parser
+from .edge import ImportEdge
+from .node import ModuleNode
+
+
+def _preferred_extensions(filepath: Path) -> tuple[str, ...]:
+    if filepath.suffix.lower() in (".py", ".pyi"):
+        return (".py", ".pyi")
+    return tuple(ext for ext in LANGUAGES if ext not in (".py", ".pyi"))
+
+
+class DependencyGraph:
+    def __init__(self) -> None:
+        self.nodes: dict[Path, ModuleNode] = {}
+        self.edges: dict[tuple[Path, Path], ImportEdge] = {}
+
+    def add_node(self, filepath: Path, node: ModuleNode) -> None:
+        self.nodes[filepath] = node
+
+    def add_edge(self, edge: ImportEdge) -> None:
+        key = (edge.source_file, edge.target_file)
+        self.edges[key] = edge
+
+    def build_from_files(self, filepaths: list[Path]) -> None:
+        for fp in filepaths:
+            self._parse_and_add(fp)
+        for fp, node in self.nodes.items():
+            for imp in node.imports:
+                targets = self.resolve_import(imp, fp)
+                for target in targets:
+                    # Ensure target is resolved for consistent comparison
+                    resolved_target = target.resolve()
+                    if resolved_target in self.nodes:
+                        edge = ImportEdge(
+                            source_file=fp,
+                            target_file=resolved_target,
+                            imported_names=imp.names,
+                        )
+                        self.add_edge(edge)
+
+    def _parse_and_add(self, filepath: Path) -> None:
+        parser = get_parser(filepath)
+        if parser is None:
+            return
+        result = parser.parse(filepath)
+        exports = [s.name for s in result.symbols if s.is_exported]
+        # Normalize to resolved path for consistent comparisons
+        resolved = filepath.resolve()
+        node = ModuleNode(
+            filepath=resolved,
+            language=result.language,
+            exports=exports,
+            imports=result.imports,
+        )
+        self.add_node(resolved, node)
+
+    def resolve_import(self, import_info: ImportInfo, current_file: Path) -> list[Path]:
+        module = import_info.module
+        preferred = _preferred_extensions(current_file)
+        if module.startswith("."):
+            return self._resolve_relative(module, current_file, preferred)
+        return self._resolve_absolute(module, current_file, preferred)
+
+    def _resolve_relative(
+        self, module: str, current_file: Path, preferred: tuple[str, ...]
+    ) -> list[Path]:
+        parent = current_file.parent
+        dots = 0
+        for ch in module:
+            if ch == ".":
+                dots += 1
+            else:
+                break
+        rest = module[dots:].lstrip("/")
+        for _ in range(dots - 1):
+            parent = parent.parent
+        if not rest:
+            init = (parent / "__init__.py").resolve()
+            return [init] if init.is_file() else []
+        return self._find_module_candidates(rest, parent, preferred)
+
+    def _resolve_absolute(
+        self, module: str, current_file: Path, preferred: tuple[str, ...]
+    ) -> list[Path]:
+        # Strategy 1: Find src/ directory and resolve from there
+        src_root = self._find_src_root(current_file)
+        if src_root:
+            candidates = self._find_module_candidates(module, src_root, preferred)
+            if candidates:
+                return candidates
+
+        # Strategy 2: Find project root (where pyproject.toml or setup.py lives)
+        project_root = self._find_project_root(current_file)
+        if project_root:
+            # Try src/ layout: project_root/src/package/...
+            src_dir = project_root / "src"
+            if src_dir.is_dir():
+                candidates = self._find_module_candidates(module, src_dir, preferred)
+                if candidates:
+                    return candidates
+            # Try flat layout: project_root/package/...
+            candidates = self._find_module_candidates(module, project_root, preferred)
+            if candidates:
+                return candidates
+
+        # Strategy 3: Relative to current file's directory
+        return self._find_module_candidates(module, current_file.parent, preferred)
+
+    def _find_src_root(self, start: Path) -> Path | None:
+        """Walk up from start to find a src/ directory."""
+        current = start
+        while current != current.parent:
+            if current.name == "src" and current.is_dir():
+                return current
+            # Also check if current IS the src root's child
+            if (current.parent / "src").is_dir() and current.parent.name != "src":
+                return current.parent / "src"
+            current = current.parent
+        return None
+
+    def _find_project_root(self, start: Path) -> Path | None:
+        """Walk up from start to find project root (has pyproject.toml or setup.py)."""
+        markers = ("pyproject.toml", "setup.py", "package.json", "tsconfig.json")
+        current = start
+        while current != current.parent:
+            if (current / ".git").exists() or any(
+                (current / marker).is_file() for marker in markers
+            ):
+                return current
+            current = current.parent
+        return None
+
+    def _find_module_candidates(
+        self, module_path: str, base_dir: Path, preferred: tuple[str, ...] = ()
+    ) -> list[Path]:
+        module_path = self._strip_source_extension(module_path)
+        if "/" in module_path:
+            bases = [base_dir.joinpath(*module_path.split("/"))]
+        else:
+            bases = [base_dir.joinpath(*module_path.split(".")), base_dir / module_path]
+
+        candidates = self._probe_bases(bases, preferred or tuple(LANGUAGES))
+        if not candidates and preferred:
+            candidates = self._probe_bases(bases, tuple(LANGUAGES))
+        return candidates
+
+    @staticmethod
+    def _probe_bases(bases: list[Path], extensions: tuple[str, ...]) -> list[Path]:
+        candidates: list[Path] = []
+        for base in bases:
+            for ext in extensions:
+                candidate = Path(str(base) + ext)
+                if candidate.is_file():
+                    candidates.append(candidate.resolve())
+            for stem in ("__init__", "index"):
+                for ext in extensions:
+                    candidate = base / f"{stem}{ext}"
+                    if candidate.is_file():
+                        candidates.append(candidate.resolve())
+        return list(dict.fromkeys(candidates))
+
+    @staticmethod
+    def _strip_source_extension(module_path: str) -> str:
+        for ext in LANGUAGES:
+            if module_path.endswith(ext) and len(module_path) > len(ext):
+                return module_path[: -len(ext)]
+        return module_path
+
+    def get_dependents(self, filepath: Path) -> set[Path]:
+        dependents = set()
+        for (source, _target), edge in self.edges.items():
+            if edge.target_file == filepath:
+                dependents.add(source)
+        return dependents
+
+    def is_test_file(self, filepath: Path) -> bool:
+        if filepath.suffix.lower() not in LANGUAGES:
+            return False
+        name = filepath.name
+        parts = filepath.parts
+        if "tests" in parts:
+            return True
+        stem = filepath.stem
+        if stem.startswith("test_") or stem.endswith("_test"):
+            return True
+        if name.endswith(
+            (".test.ts", ".test.tsx", ".test.js", ".test.jsx", ".test.mjs", ".test.cjs")
+        ):
+            return True
+        if name.endswith(
+            (".spec.ts", ".spec.tsx", ".spec.js", ".spec.jsx", ".spec.mjs", ".spec.cjs")
+        ):
+            return True
+        return False

testpick/graph/edge.py

@@ -0,0 +1,13 @@
+"""Import edge representing a dependency between two files."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class ImportEdge:
+    source_file: Path
+    target_file: Path
+    imported_names: list[str] = field(default_factory=list)