testgap 0.1.0a0__py3-none-any.whl

testgap/__init__.py

@@ -0,0 +1,8 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("testgap")
+except PackageNotFoundError:
+    __version__ = "0.0.0+unknown"
+
+__all__ = ["__version__"]

testgap/__main__.py

@@ -0,0 +1,4 @@
+from testgap.cli import app
+
+if __name__ == "__main__":
+    app()

testgap/cli.py

@@ -0,0 +1,274 @@
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.markup import escape
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+
+from testgap import __version__
+from testgap.config.init_wizard import (
+    analyze,
+    build_config,
+    ensure_gitignore_entry,
+    provider_status,
+    suggest_model,
+    write_config,
+)
+from testgap.config.loader import CONFIG_FILENAME, ConfigError, load_config
+from testgap.generator import LLMClient
+from testgap.pipeline import DiffRunReport, FunctionSuggestion, run_diff
+
+app = typer.Typer(
+    name="testgap",
+    help="AI-powered test generator that closes coverage gaps in your PRs.",
+    add_completion=False,
+    no_args_is_help=True,
+)
+console = Console()
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        console.print(f"testgap {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        None, "--version", callback=_version_callback, is_eager=True, help="Show version and exit."
+    ),
+) -> None:
+    pass
+
+
+@app.command()
+def init(
+    path: Path | None = typer.Option(
+        None, "--path", "-p", help="Project root to initialize.", file_okay=False
+    ),
+    yes: bool = typer.Option(
+        False, "--yes", "-y", help="Accept all detected defaults without prompts."
+    ),
+) -> None:
+    """Initialize TestGap in the current project (creates .testgap.yml)."""
+    root = (path or Path.cwd()).resolve()
+    if not root.is_dir():
+        console.print(f"[red]✗[/] {root} is not a directory")
+        raise typer.Exit(code=1)
+
+    console.print(f"[bold]Analyzing[/] {root}")
+    report = analyze(root)
+
+    if not report.pytest_signals:
+        console.print("[red]✗[/] No pytest project detected.")
+        console.print("  Install pytest first: [cyan]pip install pytest[/]")
+        raise typer.Exit(code=1)
+
+    console.print(f"[green]✓[/] pytest detected ({escape(report.pytest_signals[0])})")
+
+    if not report.has_git:
+        console.print(
+            "[yellow]![/] Not a git repository — `testgap diff` will not work until you `git init`."
+        )
+
+    existing = root / CONFIG_FILENAME
+    if existing.is_file() and not yes:
+        action = Prompt.ask(
+            f"[yellow]{CONFIG_FILENAME} already exists.[/] Action?",
+            choices=["overwrite", "backup", "cancel"],
+            default="cancel",
+        )
+        if action == "cancel":
+            console.print("Aborted.")
+            raise typer.Exit(code=0)
+        if action == "backup":
+            backup_path = existing.with_suffix(existing.suffix + ".bak")
+            backup_path.write_bytes(existing.read_bytes())
+            console.print(f"  Backed up to {backup_path.name}")
+
+    source_paths = _choose_source_paths(report, yes=yes)
+    test_paths = report.test_paths or ["tests/"]
+    if not report.test_paths:
+        console.print(f"[yellow]![/] No tests/ directory found — defaulting to {test_paths[0]}")
+    else:
+        console.print(f"[green]✓[/] test directory: {test_paths[0]}")
+
+    model = _choose_model(yes=yes)
+
+    config = build_config(source_paths=source_paths, test_paths=test_paths, model=model)
+    config_path = write_config(config, root)
+    console.print(f"[green]✓[/] wrote {config_path.relative_to(root)}")
+
+    if ensure_gitignore_entry(root):
+        console.print("[green]✓[/] added .testgap/ to .gitignore")
+
+    console.print()
+    console.print("[bold]Next steps:[/]")
+    console.print("  [cyan]testgap diff --review[/]   suggest tests for uncovered changes")
+
+
+def _choose_source_paths(report, *, yes: bool) -> list[str]:
+    if report.source_paths and not report.layout_ambiguous:
+        console.print(f"[green]✓[/] source path: {report.source_paths[0]}")
+        return report.source_paths
+
+    if report.layout_ambiguous and not yes:
+        console.print("[yellow]?[/] multiple source candidates found:")
+        for i, p in enumerate(report.source_paths, 1):
+            console.print(f"   [{i}] {p}")
+        choice = Prompt.ask(
+            "  pick one",
+            choices=[str(i) for i in range(1, len(report.source_paths) + 1)],
+            default="1",
+        )
+        return [report.source_paths[int(choice) - 1]]
+
+    if not report.source_paths:
+        if yes:
+            console.print("[yellow]![/] no source layout detected — defaulting to src/")
+            return ["src/"]
+        custom = Prompt.ask(
+            "[yellow]?[/] no source layout detected. Source path?", default="src/"
+        )
+        return [custom]
+
+    return report.source_paths
+
+
+@app.command()
+def diff(
+    base: str | None = typer.Option(
+        None, "--base", "-b", help="Base git ref. Defaults to origin/HEAD then main/master."
+    ),
+    head: str = typer.Option("HEAD", "--head", help="Head ref. Defaults to HEAD."),
+    max_functions: int | None = typer.Option(
+        None, "--max-functions", "-n", help="Limit number of functions processed."
+    ),
+    path: Path | None = typer.Option(None, "--path", "-p", file_okay=False),
+) -> None:
+    """Analyze the diff and propose tests for uncovered changes (non-interactive)."""
+    root = (path or Path.cwd()).resolve()
+
+    try:
+        config = load_config()
+    except ConfigError as e:
+        console.print(f"[red]✗[/] {escape(str(e))}")
+        raise typer.Exit(code=1) from e
+
+    console.print(f"[bold]Analyzing diff[/] in {root}")
+
+    llm_client = LLMClient(model=config.llm.model, max_retries=config.llm.max_retries)
+
+    try:
+        report = run_diff(
+            project_root=root,
+            config=config,
+            llm_client=llm_client,
+            base_ref=base,
+            head_ref=head,
+            max_functions=max_functions,
+        )
+    except Exception as e:  # surface user-facing errors from coverage/git layers
+        console.print(f"[red]✗[/] {escape(str(e))}")
+        raise typer.Exit(code=1) from e
+
+    _print_diff_report(report)
+
+    if report.suggestions and not all(s.succeeded for s in report.suggestions):
+        raise typer.Exit(code=1)
+
+
+def _print_diff_report(report: DiffRunReport) -> None:
+    console.print(f"[dim]base[/] {report.base_ref} → [dim]head[/] {report.head_ref}")
+
+    if report.skipped_reason:
+        console.print(f"[green]✓[/] {report.skipped_reason}")
+        return
+
+    summary = (
+        f"changed lines: {report.changed_total}   "
+        f"covered: {report.covered_total}   "
+        f"diff coverage: {report.diff_coverage_pct}%"
+    )
+    console.print(summary)
+    console.print()
+
+    for i, suggestion in enumerate(report.suggestions, 1):
+        _print_suggestion(i, len(report.suggestions), suggestion)
+
+    console.print()
+    console.print(f"[dim]LLM cost this run:[/] ${report.cost_total:.4f}")
+
+
+def _print_suggestion(idx: int, total: int, s: FunctionSuggestion) -> None:
+    file_label = escape(f"{s.function.file.name}::{s.function.qualname}")
+    header = f"[{idx}/{total}] {file_label}"
+    console.print(f"[bold]{header}[/]")
+    lines_str = ", ".join(str(n) for n in s.function.uncovered_lines[:8])
+    if len(s.function.uncovered_lines) > 8:
+        lines_str += ", …"
+    console.print(f"  uncovered lines: {lines_str}")
+
+    if s.error:
+        console.print(f"  [red]✗[/] {escape(s.error)}")
+        return
+
+    if s.validator_result is None or s.generated is None:
+        console.print("  [yellow]![/] no result captured")
+        return
+
+    if s.validator_result.environment_error:
+        console.print(f"  [red]✗[/] {escape(s.validator_result.environment_error)}")
+        return
+
+    accepted_n = len(s.accepted_cases)
+    discarded_n = len(s.discarded_cases)
+    total_n = accepted_n + discarded_n
+    cost_label = f"${s.cost_usd:.4f}" if s.cost_usd > 0 else "$0 (cost unknown)"
+    retried_marker = " [retried]" if s.attempts == 2 else ""
+
+    if s.fully_passed:
+        console.print(
+            f"  [green]✓[/] {accepted_n}/{total_n} tests passed   {cost_label}{retried_marker}"
+        )
+    elif s.succeeded:
+        console.print(
+            f"  [yellow]![/] {accepted_n} kept / {discarded_n} discarded   "
+            f"{cost_label}{retried_marker}"
+        )
+    else:
+        console.print(
+            f"  [yellow]![/] {accepted_n} pass / {discarded_n} fail of {total_n}   "
+            f"{cost_label}{retried_marker}"
+        )
+
+    if s.retry_skipped_reason:
+        console.print(f"  [yellow]![/] retry skipped: {escape(s.retry_skipped_reason)}")
+
+    for case in s.discarded_cases[:3]:
+        console.print(f"    [red]·[/] {escape(case.name)}")
+
+
+def _choose_model(*, yes: bool) -> str:
+    suggested = suggest_model()
+    if yes:
+        return suggested
+
+    table = Table(show_header=True, header_style="bold", title="Available LLM providers")
+    table.add_column("model")
+    table.add_column("status")
+    rows = provider_status()
+    options: list[str] = []
+    for model, status in rows:
+        marker = "→" if model == suggested else " "
+        table.add_row(f"{marker} {model}", status)
+        options.append(model)
+    console.print(table)
+
+    use_default = Confirm.ask(f"Use suggested model [cyan]{suggested}[/]?", default=True)
+    if use_default:
+        return suggested
+    choice = Prompt.ask("Enter model id", default=suggested)
+    return choice or suggested

testgap/config/__init__.py

@@ -0,0 +1,15 @@
+from testgap.config.schema import (
+    CoverageConfig,
+    GenerationConfig,
+    LLMConfig,
+    ProjectConfig,
+    TestGapConfig,
+)
+
+__all__ = [
+    "TestGapConfig",
+    "ProjectConfig",
+    "CoverageConfig",
+    "LLMConfig",
+    "GenerationConfig",
+]

testgap/config/init_wizard.py

@@ -0,0 +1,113 @@
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from testgap.config.loader import CONFIG_FILENAME, dump_config
+from testgap.config.schema import (
+    CoverageConfig,
+    GenerationConfig,
+    LLMConfig,
+    ProjectConfig,
+    TestGapConfig,
+)
+from testgap.detect import detect_layout, detect_pytest, detect_source_paths, detect_test_dirs
+
+
+@dataclass
+class DetectionReport:
+    pytest_signals: list[str]
+    source_paths: list[str]
+    test_paths: list[str]
+    layout_kind: str
+    layout_ambiguous: bool
+    has_git: bool
+
+
+def analyze(root: Path) -> DetectionReport:
+    pytest = detect_pytest(root)
+    layout = detect_layout(root)
+    test_dirs = detect_test_dirs(root)
+
+    source_paths = detect_source_paths(root)
+    ambiguous = layout.kind.value == "flat" and len(layout.candidates) > 1
+
+    test_paths = sorted({f"{p.relative_to(root).as_posix()}/" for p in test_dirs.paths})
+
+    return DetectionReport(
+        pytest_signals=pytest.signals,
+        source_paths=source_paths,
+        test_paths=test_paths,
+        layout_kind=layout.kind.value,
+        layout_ambiguous=ambiguous,
+        has_git=(root / ".git").exists(),
+    )
+
+
+_KNOWN_PROVIDERS = (
+    ("anthropic/claude-sonnet-4-6", "ANTHROPIC_API_KEY"),
+    ("openai/gpt-4o", "OPENAI_API_KEY"),
+    ("gemini/gemini-2.0-flash", "GEMINI_API_KEY"),
+    ("ollama/qwen2.5-coder", None),
+)
+
+
+def suggest_model() -> str:
+    """Pick the first provider whose API key is set in env; fall back to Ollama."""
+    for model, env_var in _KNOWN_PROVIDERS:
+        if env_var is None:
+            continue
+        if os.environ.get(env_var):
+            return model
+    return "ollama/qwen2.5-coder"
+
+
+def provider_status() -> list[tuple[str, str]]:
+    """Return (model, status) pairs for display in the wizard."""
+    rows: list[tuple[str, str]] = []
+    for model, env_var in _KNOWN_PROVIDERS:
+        if env_var is None:
+            rows.append((model, "local model"))
+        elif os.environ.get(env_var):
+            rows.append((model, f"{env_var} found"))
+        else:
+            rows.append((model, f"{env_var} not set"))
+    return rows
+
+
+def build_config(
+    *,
+    source_paths: list[str],
+    test_paths: list[str],
+    model: str,
+) -> TestGapConfig:
+    return TestGapConfig(
+        project=ProjectConfig(
+            source_paths=source_paths or ["src/"],
+            test_paths=test_paths or ["tests/"],
+        ),
+        coverage=CoverageConfig(),
+        llm=LLMConfig(model=model),
+        generation=GenerationConfig(),
+    )
+
+
+def write_config(config: TestGapConfig, root: Path) -> Path:
+    path = root / CONFIG_FILENAME
+    dump_config(config, path)
+    return path
+
+
+def ensure_gitignore_entry(root: Path, entry: str = ".testgap/") -> bool:
+    """Append entry to .gitignore if missing. Returns True if file was modified."""
+    gitignore = root / ".gitignore"
+    if not gitignore.is_file():
+        gitignore.write_text(f"# TestGap\n{entry}\n", encoding="utf-8")
+        return True
+    content = gitignore.read_text(encoding="utf-8")
+    lines = {line.strip() for line in content.splitlines()}
+    if entry.strip() in lines or entry.rstrip("/") in lines:
+        return False
+    suffix = "" if content.endswith("\n") or not content else "\n"
+    with gitignore.open("a", encoding="utf-8") as f:
+        f.write(f"{suffix}\n# TestGap\n{entry}\n")
+    return True

testgap/config/loader.py

@@ -0,0 +1,54 @@
+from pathlib import Path
+
+import yaml
+from pydantic import ValidationError
+
+from testgap.config.schema import TestGapConfig
+
+CONFIG_FILENAME = ".testgap.yml"
+
+
+class ConfigError(Exception):
+    pass
+
+
+class ConfigNotFoundError(ConfigError):
+    pass
+
+
+class ConfigInvalidError(ConfigError):
+    pass
+
+
+def find_config(start: Path | None = None) -> Path:
+    cwd = (start or Path.cwd()).resolve()
+    for parent in [cwd, *cwd.parents]:
+        candidate = parent / CONFIG_FILENAME
+        if candidate.is_file():
+            return candidate
+    raise ConfigNotFoundError(
+        f"{CONFIG_FILENAME} not found in {cwd} or any parent directory. "
+        "Run `testgap init` to create one."
+    )
+
+
+def load_config(path: Path | None = None) -> TestGapConfig:
+    config_path = path or find_config()
+    try:
+        raw = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+    except yaml.YAMLError as e:
+        raise ConfigInvalidError(f"Failed to parse {config_path}: {e}") from e
+
+    if not isinstance(raw, dict):
+        raise ConfigInvalidError(f"{config_path}: root must be a mapping, got {type(raw).__name__}")
+
+    try:
+        return TestGapConfig.model_validate(raw)
+    except ValidationError as e:
+        raise ConfigInvalidError(f"Invalid config at {config_path}:\n{e}") from e
+
+
+def dump_config(config: TestGapConfig, path: Path) -> None:
+    data = config.model_dump(mode="json")
+    yaml_text = yaml.safe_dump(data, sort_keys=False, allow_unicode=True, default_flow_style=False)
+    path.write_text(yaml_text, encoding="utf-8")

testgap/config/schema.py

@@ -0,0 +1,48 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class ProjectConfig(BaseModel):
+    language: Literal["python"] = "python"
+    test_framework: Literal["pytest"] = "pytest"
+    source_paths: list[str] = Field(default_factory=lambda: ["src/"])
+    test_paths: list[str] = Field(default_factory=lambda: ["tests/"])
+
+
+class CoverageConfig(BaseModel):
+    threshold: int = Field(default=80, ge=0, le=100)
+    diff_threshold: int = Field(default=90, ge=0, le=100)
+    exclude: list[str] = Field(
+        default_factory=lambda: ["**/migrations/**", "**/__init__.py"]
+    )
+
+
+class LLMConfig(BaseModel):
+    model: str = "anthropic/claude-sonnet-4-6"
+    max_cost_per_run: float = Field(default=2.0, gt=0)
+    max_retries: int = Field(default=2, ge=0, le=5)
+
+
+class GenerationConfig(BaseModel):
+    style: Literal["match_existing", "minimal"] = "match_existing"
+    include_docstrings: bool = True
+    max_tests_per_function: int = Field(default=3, ge=1, le=10)
+    test_timeout_seconds: int = Field(default=30, ge=1, le=600)
+
+
+class TestGapConfig(BaseModel):
+    __test__ = False  # not a pytest test class despite the name
+
+    version: int = 1
+    project: ProjectConfig = Field(default_factory=ProjectConfig)
+    coverage: CoverageConfig = Field(default_factory=CoverageConfig)
+    llm: LLMConfig = Field(default_factory=LLMConfig)
+    generation: GenerationConfig = Field(default_factory=GenerationConfig)
+
+    @field_validator("version")
+    @classmethod
+    def _check_version(cls, v: int) -> int:
+        if v != 1:
+            raise ValueError(f"Unsupported config version: {v}. Only version 1 is supported.")
+        return v

testgap/cost/__init__.py

@@ -0,0 +1,3 @@
+from testgap.cost.tracker import BudgetExceeded, CostTracker
+
+__all__ = ["CostTracker", "BudgetExceeded"]

testgap/cost/tracker.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass, field
+
+
+class BudgetExceeded(Exception):
+    pass
+
+
+@dataclass
+class CostEntry:
+    label: str
+    cost_usd: float
+    input_tokens: int = 0
+    output_tokens: int = 0
+
+
+@dataclass
+class CostTracker:
+    max_cost_per_run: float
+    entries: list[CostEntry] = field(default_factory=list)
+
+    @property
+    def spent(self) -> float:
+        return round(sum(e.cost_usd for e in self.entries), 6)
+
+    @property
+    def remaining(self) -> float:
+        return max(0.0, round(self.max_cost_per_run - self.spent, 6))
+
+    def would_exceed(self, estimated: float) -> bool:
+        return (self.spent + estimated) > self.max_cost_per_run
+
+    def near_limit(self, ratio: float = 0.8) -> bool:
+        return self.spent >= self.max_cost_per_run * ratio
+
+    def record(
+        self, *, label: str, cost_usd: float, input_tokens: int = 0, output_tokens: int = 0
+    ) -> CostEntry:
+        if self.spent + cost_usd > self.max_cost_per_run:
+            raise BudgetExceeded(
+                f"recording ${cost_usd:.4f} would exceed budget "
+                f"${self.max_cost_per_run:.2f} (already spent ${self.spent:.4f})"
+            )
+        entry = CostEntry(
+            label=label, cost_usd=cost_usd, input_tokens=input_tokens, output_tokens=output_tokens
+        )
+        self.entries.append(entry)
+        return entry

testgap/coverage/__init__.py

@@ -0,0 +1,22 @@
+from testgap.coverage.ast_grouping import UncoveredFunction, group_by_function
+from testgap.coverage.diff_coverage import (
+    DiffCoverageReport,
+    UncoveredLine,
+    compute_diff_coverage,
+)
+from testgap.coverage.git_diff import GitDiffError, changed_lines, resolve_base_ref
+from testgap.coverage.runner import CoverageError, CoverageRunResult, run_pytest_with_coverage
+
+__all__ = [
+    "UncoveredFunction",
+    "group_by_function",
+    "DiffCoverageReport",
+    "UncoveredLine",
+    "compute_diff_coverage",
+    "GitDiffError",
+    "changed_lines",
+    "resolve_base_ref",
+    "CoverageError",
+    "CoverageRunResult",
+    "run_pytest_with_coverage",
+]