flarebisect 0.3.1__py3-none-any.whl

flarebisect/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.1"

flarebisect/ai_explain.py

@@ -0,0 +1,37 @@
+"""Ask the configured LLM for a short root-cause read on the culprit commit."""
+
+from __future__ import annotations
+
+from .bisect import BisectOutcome
+from .providers import ProviderConfig, complete
+
+PROMPT_TEMPLATE = """A commit changed a test's failure rate. Diagnose the likely cause.
+
+commit {sha}: "{subject}"
+
+flake rate before: {before_rate:.0%}
+flake rate after:  {culprit_rate:.0%}
+bisection threshold: {threshold:.0%}
+verdict: {verdict}
+
+diff:
+```diff
+{diff}
+```
+
+Answer in exactly 1-2 short sentences, no preamble, no restating the numbers above.
+Point at the specific code change responsible (shared state, missing lock, timing/ordering
+assumption, resource leak, off-by-one, whatever it actually is)."""
+
+
+def explain(outcome: BisectOutcome, diff: str, threshold: float, provider_cfg: ProviderConfig) -> str:
+    prompt = PROMPT_TEMPLATE.format(
+        sha=outcome.culprit.sha[:12],
+        subject=outcome.culprit.subject,
+        before_rate=outcome.before.result.flake_rate,
+        culprit_rate=outcome.culprit.result.flake_rate,
+        threshold=threshold,
+        verdict=outcome.verdict,
+        diff=diff[:6000],
+    )
+    return complete(provider_cfg, prompt)

flarebisect/bisect.py

@@ -0,0 +1,145 @@
+"""Flake-rate bisection: binary search over commits for the point where the
+flake rate jumps by >= threshold relative to the known-good baseline."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable
+
+from . import git_ops
+from .runner import RunResult, measure_flake_rate, worker_count_for
+
+
+@dataclass
+class CommitMeasurement:
+    sha: str
+    subject: str
+    result: RunResult
+    position: int  # -1 = good baseline, 0..n-1 = index within the good..bad range
+    status: str = ""  # filled in once the culprit is known: good/stable/wobbling/flare/bad
+
+
+@dataclass
+class BisectOutcome:
+    culprit: CommitMeasurement
+    before: CommitMeasurement  # last known-good-ish measurement (parent side)
+    good_baseline: RunResult
+    bad_baseline: RunResult
+    verdict: str  # "clean break" | "flakiness regression"
+    measurements: list[CommitMeasurement]  # every distinct commit measured, in range order
+    total_commits: int
+    runs: int
+    workers: int
+    elapsed_seconds: float
+
+
+def _measure(repo: Path, sha: str, test_cmd: str, runs: int, position: int) -> CommitMeasurement:
+    wt = git_ops.add_worktree(repo, sha)
+    try:
+        result = measure_flake_rate(test_cmd, wt.path, runs)
+    finally:
+        git_ops.remove_worktree(repo, wt)
+    return CommitMeasurement(
+        sha=sha,
+        subject=git_ops.commit_subject(repo, sha),
+        result=result,
+        position=position,
+    )
+
+
+def classify(good_rate: float, culprit_rate: float) -> str:
+    if culprit_rate >= 0.9 and good_rate <= 0.1:
+        return "clean break"
+    return "flakiness regression"
+
+
+def status_label(rate: float, is_first: bool, is_last: bool, is_culprit: bool) -> str:
+    if is_culprit:
+        return "flare"
+    if is_last:
+        return "bad"
+    if rate <= 0.0:
+        return "good" if is_first else "stable"
+    return "wobbling"
+
+
+def run_bisect(
+    repo: Path,
+    good: str,
+    bad: str,
+    test_cmd: str,
+    runs: int = 5,
+    threshold: float = 0.3,
+    on_measure: Callable[[str, CommitMeasurement], None] | None = None,
+) -> BisectOutcome:
+    started = time.perf_counter()
+
+    good_sha = git_ops.resolve_sha(repo, good)
+    bad_sha = git_ops.resolve_sha(repo, bad)
+
+    good_m = _measure(repo, good_sha, test_cmd, runs, position=-1)
+    if on_measure:
+        on_measure("good", good_m)
+
+    commits = git_ops.commit_list(repo, good_sha, bad_sha)
+    if not commits:
+        raise ValueError("no commits between good and bad")
+
+    baseline_rate = good_m.result.flake_rate
+
+    cache: dict[str, CommitMeasurement] = {}
+
+    def measure_idx(idx: int) -> CommitMeasurement:
+        sha = commits[idx]
+        if sha not in cache:
+            m = _measure(repo, sha, test_cmd, runs, position=idx)
+            cache[sha] = m
+            if on_measure:
+                on_measure(f"candidate[{idx}]", m)
+        return cache[sha]
+
+    bad_m = measure_idx(len(commits) - 1)
+
+    lo, hi = 0, len(commits) - 1
+    culprit_idx = hi  # fall back to bad commit if search never narrows
+    culprit_measurement = bad_m
+
+    while lo <= hi:
+        mid = (lo + hi) // 2
+        m = measure_idx(mid)
+        jumped = (m.result.flake_rate - baseline_rate) >= threshold
+        if jumped:
+            culprit_idx = mid
+            culprit_measurement = m
+            hi = mid - 1
+        else:
+            lo = mid + 1
+
+    before_measurement = measure_idx(culprit_idx - 1) if culprit_idx > 0 else good_m
+
+    verdict = classify(before_measurement.result.flake_rate, culprit_measurement.result.flake_rate)
+
+    last_idx = len(commits) - 1
+    ordered = [good_m] + [cache[sha] for sha in commits if sha in cache]
+    for m in ordered:
+        m.status = status_label(
+            m.result.flake_rate,
+            is_first=(m.position == -1),
+            is_last=(m.position == last_idx),
+            is_culprit=(m.sha == culprit_measurement.sha),
+        )
+
+    return BisectOutcome(
+        culprit=culprit_measurement,
+        before=before_measurement,
+        good_baseline=good_m.result,
+        bad_baseline=bad_m.result,
+        verdict=verdict,
+        measurements=ordered,
+        total_commits=len(commits),
+        runs=runs,
+        workers=worker_count_for(runs),
+        elapsed_seconds=time.perf_counter() - started,
+    )

flarebisect/cli.py

@@ -0,0 +1,309 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+
+from . import __version__, ai_explain, config as config_store, git_ops, hardware, report
+from .bisect import run_bisect
+from .providers import DEFAULT_BASE_URLS, DEFAULT_MODELS, NO_KEY_REQUIRED, PROVIDERS, ProviderError
+
+app = typer.Typer(add_completion=False, help="git bisect that treats flakiness as a signal, not noise.")
+config_app = typer.Typer(add_completion=False, help="Manage stored AI provider settings.")
+models_app = typer.Typer(add_completion=False, help="Detect your GPU/VRAM and manage local Ollama models.")
+app.add_typer(config_app, name="config")
+app.add_typer(models_app, name="models")
+
+PROVIDER_BLURBS = {
+    "anthropic": "Claude, cloud, needs an API key",
+    "openai": "GPT models, cloud, needs an API key",
+    "google": "Gemini, cloud, needs an API key",
+    "ollama": "local model via Ollama, no key needed",
+    "custom": "any OpenAI-compatible endpoint (LM Studio, llama.cpp, vLLM...)",
+}
+
+
+@app.command()
+def version() -> None:
+    """Show the flarebisect version."""
+    typer.echo(__version__)
+
+
+@app.command()
+def run(
+    good: str = typer.Option(..., "--good", help="Known-good commit/ref."),
+    bad: str = typer.Option(..., "--bad", help="Known-bad (or known-flaky) commit/ref."),
+    test: str = typer.Option(..., "--test", help="Test command to run, e.g. 'pytest -k my_test'."),
+    repo: Path = typer.Option(Path.cwd(), "--repo", help="Path to the git repository."),
+    runs: int = typer.Option(20, "--runs", help="Test runs per commit."),
+    threshold: float = typer.Option(0.3, "--threshold", help="Flake-rate jump that counts as the culprit (0-1)."),
+    explain: bool = typer.Option(True, "--explain/--no-explain", help="Call an LLM for a root-cause explanation."),
+    provider: Optional[str] = typer.Option(
+        None, "--provider", help=f"Override the default provider ({', '.join(PROVIDERS)})."
+    ),
+    api_key: Optional[str] = typer.Option(None, "--api-key", help="Override the stored/env API key for this run."),
+    model: Optional[str] = typer.Option(None, "--model", help="Override the model for this run."),
+    base_url: Optional[str] = typer.Option(
+        None, "--base-url", help="Override the API base URL (for local/self-hosted servers)."
+    ),
+) -> None:
+    """Bisect on flake-rate jump instead of pass/fail."""
+    repo = repo.resolve()
+
+    try:
+        git_ops.resolve_sha(repo, good)
+        git_ops.resolve_sha(repo, bad)
+    except git_ops.GitError as e:
+        report.print_error(str(e))
+        raise typer.Exit(1)
+
+    def on_measure(label: str, m) -> None:
+        pass  # table is rendered once, after the search completes
+
+    try:
+        outcome = run_bisect(
+            repo=repo,
+            good=good,
+            bad=bad,
+            test_cmd=test,
+            runs=runs,
+            threshold=threshold,
+            on_measure=on_measure,
+        )
+    except ValueError as e:
+        report.print_error(str(e))
+        raise typer.Exit(1)
+
+    report.print_progress_line(outcome.total_commits, outcome.runs, outcome.workers)
+    report.print_table(outcome.measurements)
+
+    explanation: Optional[str] = None
+    if explain:
+        provider_cfg = config_store.resolve(provider=provider, api_key=api_key, model=model, base_url=base_url)
+        diff = git_ops.commit_diff(repo, outcome.culprit.sha)
+        try:
+            explanation = ai_explain.explain(outcome, diff, threshold, provider_cfg)
+        except ProviderError as e:
+            report.print_error(str(e))
+
+    report.print_result(outcome, threshold, explanation)
+    report.print_footer(outcome.elapsed_seconds, len(outcome.measurements), outcome.workers)
+
+
+@config_app.callback(invoke_without_command=True)
+def config_main(ctx: typer.Context) -> None:
+    """Manage stored AI provider settings. Run with no subcommand for a guided setup."""
+    if ctx.invoked_subcommand is None:
+        config_wizard()
+
+
+def config_wizard() -> None:
+    console = report.console
+    console.print()
+    console.print(Panel.fit("[bold]flarebisect setup[/bold] — pick an AI provider for root-cause explanations", border_style="grey50"))
+
+    console.print()
+    console.print("[bold]step 1/4[/bold] — provider")
+    for i, name in enumerate(PROVIDERS, start=1):
+        console.print(f"  [cyan]{i}[/cyan]) {name:<10} [dim]{PROVIDER_BLURBS[name]}[/dim]")
+    choice = Prompt.ask("  choose", choices=[str(i) for i in range(1, len(PROVIDERS) + 1)], default="1")
+    provider = PROVIDERS[int(choice) - 1]
+
+    base_url = None
+    api_key = None
+
+    if provider in ("ollama", "custom"):
+        console.print()
+        console.print("[bold]step 2/4[/bold] — endpoint")
+        default_url = DEFAULT_BASE_URLS.get(provider, "http://localhost:11434/v1")
+        base_url = Prompt.ask("  base URL", default=default_url)
+
+        if provider in NO_KEY_REQUIRED:
+            needs_key = Confirm.ask("  does this endpoint require an API key?", default=False)
+        else:
+            needs_key = True
+        if needs_key:
+            api_key = Prompt.ask("  API key", password=True)
+    else:
+        console.print()
+        console.print("[bold]step 2/4[/bold] — API key")
+        console.print(f"  [dim]leave blank to fall back to the {config_store.ENV_KEYS.get(provider)} env var[/dim]")
+        entered = Prompt.ask("  API key", password=True, default="", show_default=False)
+        api_key = entered or None
+
+    console.print()
+    console.print("[bold]step 3/4[/bold] — model")
+    default_model = DEFAULT_MODELS.get(provider, "")
+    if provider == "ollama":
+        gpu = hardware.detect_gpu()
+        recommended, desc = hardware.recommend_model_with_desc(gpu.vram_gb)
+        if gpu.vendor == "none":
+            console.print("  [dim]no dedicated GPU detected — recommending a small CPU-friendly model[/dim]")
+        else:
+            console.print(f"  [dim]detected {gpu.name} (~{gpu.vram_gb} GB VRAM)[/dim]")
+        console.print(f"  [dim]recommended: {recommended} — {desc}[/dim]")
+        default_model = recommended
+    model = Prompt.ask("  model", default=default_model)
+
+    console.print()
+    console.print("[bold]step 4/4[/bold] — confirm")
+    make_active = Confirm.ask(f"  set '{provider}' as the active provider?", default=True)
+
+    if api_key:
+        config_store.set_key(provider, api_key)
+    if model:
+        config_store.set_model(provider, model)
+    if base_url:
+        config_store.set_base_url(provider, base_url)
+    if make_active:
+        config_store.use_provider(provider)
+
+    if provider == "ollama":
+        if hardware.ollama_available():
+            if Confirm.ask(f"  pull '{model}' now via ollama?", default=True):
+                console.print()
+                try:
+                    hardware.pull_model(model)
+                    console.print(f"[green]pulled {model}[/green]")
+                except (RuntimeError, subprocess.CalledProcessError) as e:
+                    report.print_error(f"pull failed: {e}")
+        else:
+            console.print(
+                "  [yellow]ollama not found on PATH[/yellow] — install it from https://ollama.com, "
+                "then run `flarebisect models pull`"
+            )
+
+    masked_key = f"...{api_key[-4:]}" if api_key and len(api_key) > 4 else ("(none)" if not api_key else "(set)")
+    console.print()
+    console.print(
+        Panel.fit(
+            f"[bold green]saved[/bold green] — provider={provider}  model={model}\n"
+            f"key={masked_key}"
+            + (f"  base_url={base_url}" if base_url else "")
+            + f"\n\n[dim]config file: {config_store.config_path()}[/dim]\n"
+            f"[dim]next: flarebisect run --good <sha> --bad <sha> --test \"...\"[/dim]",
+            border_style="green",
+        )
+    )
+
+
+@config_app.command("set-key")
+def config_set_key(
+    provider: str = typer.Argument(..., help=f"one of {', '.join(PROVIDERS)}"),
+    api_key: str = typer.Argument(..., help="API key for this provider."),
+) -> None:
+    """Store an API key for a provider (local servers like Ollama usually don't need one)."""
+    if provider not in PROVIDERS:
+        report.print_error(f"unknown provider '{provider}' (expected one of {', '.join(PROVIDERS)})")
+        raise typer.Exit(1)
+    config_store.set_key(provider, api_key)
+    typer.echo(f"stored API key for {provider} in {config_store.config_path()}")
+
+
+@config_app.command("set-model")
+def config_set_model(
+    provider: str = typer.Argument(..., help=f"one of {', '.join(PROVIDERS)}"),
+    model: str = typer.Argument(...),
+) -> None:
+    """Set the default model used for a provider."""
+    if provider not in PROVIDERS:
+        report.print_error(f"unknown provider '{provider}' (expected one of {', '.join(PROVIDERS)})")
+        raise typer.Exit(1)
+    config_store.set_model(provider, model)
+    typer.echo(f"{provider} model set to {model}")
+
+
+@config_app.command("set-base-url")
+def config_set_base_url(
+    provider: str = typer.Argument(..., help=f"one of {', '.join(PROVIDERS)}"),
+    base_url: str = typer.Argument(..., help="e.g. http://localhost:11434/v1 for Ollama."),
+) -> None:
+    """Point a provider at a self-hosted / local endpoint."""
+    if provider not in PROVIDERS:
+        report.print_error(f"unknown provider '{provider}' (expected one of {', '.join(PROVIDERS)})")
+        raise typer.Exit(1)
+    config_store.set_base_url(provider, base_url)
+    typer.echo(f"{provider} base URL set to {base_url}")
+
+
+@config_app.command("use")
+def config_use(provider: str = typer.Argument(..., help=f"one of {', '.join(PROVIDERS)}")) -> None:
+    """Set the default provider used by `flarebisect run`."""
+    if provider not in PROVIDERS:
+        report.print_error(f"unknown provider '{provider}' (expected one of {', '.join(PROVIDERS)})")
+        raise typer.Exit(1)
+    config_store.use_provider(provider)
+    typer.echo(f"default provider set to {provider}")
+
+
+@config_app.command("show")
+def config_show() -> None:
+    """Show the current provider config (API keys masked)."""
+    data = config_store.load()
+    active = data.get("provider", config_store.DEFAULT_PROVIDER)
+    typer.echo(f"active provider: {active}")
+    typer.echo(f"config file: {config_store.config_path()}")
+    typer.echo()
+    for name in PROVIDERS:
+        stored = data.get("providers", {}).get(name, {})
+        key = stored.get("api_key")
+        masked = f"...{key[-4:]}" if key and len(key) > 4 else ("(set)" if key else "(none)")
+        marker = "*" if name == active else " "
+        typer.echo(
+            f"{marker} {name:<10} key={masked:<10} model={stored.get('model') or '(default)':<20} "
+            f"base_url={stored.get('base_url') or '(default)'}"
+        )
+
+
+@models_app.command("detect")
+def models_detect() -> None:
+    """Detect your GPU/VRAM and show the recommended local model."""
+    console = report.console
+    gpu = hardware.detect_gpu()
+    model, desc = hardware.recommend_model_with_desc(gpu.vram_gb)
+    console.print()
+    if gpu.vendor == "none":
+        console.print("[yellow]no dedicated GPU detected[/yellow] — falling back to a small CPU-friendly model")
+    else:
+        console.print(f"GPU: [bold]{gpu.name}[/bold] ({gpu.vendor}) — ~{gpu.vram_gb} GB VRAM")
+    console.print(f"recommended model: [bold cyan]{model}[/bold cyan] — {desc}")
+    console.print("[dim]run `flarebisect models pull` to download it[/dim]")
+
+
+@models_app.command("pull")
+def models_pull(
+    model: Optional[str] = typer.Argument(None, help="Model tag to pull (default: auto-detected from your GPU)."),
+    set_active: bool = typer.Option(
+        True, "--set-active/--no-set-active", help="Set ollama as the active provider with this model."
+    ),
+) -> None:
+    """Download a local model via Ollama, sized to your GPU's VRAM."""
+    console = report.console
+    gpu = hardware.detect_gpu()
+    chosen = model or hardware.recommend_model(gpu.vram_gb)
+    if not model:
+        console.print(f"detected [bold]{gpu.name}[/bold] (~{gpu.vram_gb} GB VRAM) — pulling [bold cyan]{chosen}[/bold cyan]")
+    else:
+        console.print(f"pulling [bold cyan]{chosen}[/bold cyan]")
+
+    try:
+        hardware.pull_model(chosen)
+    except RuntimeError as e:
+        report.print_error(str(e))
+        raise typer.Exit(1)
+    except subprocess.CalledProcessError as e:
+        report.print_error(f"ollama pull failed: {e}")
+        raise typer.Exit(1)
+
+    if set_active:
+        config_store.set_model("ollama", chosen)
+        config_store.use_provider("ollama")
+        console.print(f"[green]saved[/green] — active provider set to ollama / {chosen}")
+
+
+if __name__ == "__main__":
+    app()

flarebisect/config.py

@@ -0,0 +1,89 @@
+"""Persisted CLI settings: default provider + per-provider api key/model/base_url.
+
+Stored as JSON under the OS config dir so `flarebisect config set-key ...` sticks
+across shells and reboots without env vars. Falls back to per-provider env vars
+(ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_API_KEY) when nothing is stored."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+from .providers import ProviderConfig
+
+ENV_KEYS = {
+    "anthropic": "ANTHROPIC_API_KEY",
+    "openai": "OPENAI_API_KEY",
+    "google": "GOOGLE_API_KEY",
+}
+
+DEFAULT_PROVIDER = "anthropic"
+
+
+def config_dir() -> Path:
+    if os.name == "nt":
+        base = os.environ.get("APPDATA", str(Path.home()))
+    else:
+        base = os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))
+    return Path(base) / "flarebisect"
+
+
+def config_path() -> Path:
+    return config_dir() / "config.json"
+
+
+def load() -> dict:
+    path = config_path()
+    if not path.exists():
+        return {"provider": DEFAULT_PROVIDER, "providers": {}}
+    return json.loads(path.read_text())
+
+
+def save(data: dict) -> None:
+    path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2) + "\n")
+    if os.name != "nt":
+        path.chmod(0o600)
+
+
+def set_key(provider: str, api_key: str) -> None:
+    data = load()
+    data.setdefault("providers", {}).setdefault(provider, {})["api_key"] = api_key
+    save(data)
+
+
+def set_model(provider: str, model: str) -> None:
+    data = load()
+    data.setdefault("providers", {}).setdefault(provider, {})["model"] = model
+    save(data)
+
+
+def set_base_url(provider: str, base_url: str) -> None:
+    data = load()
+    data.setdefault("providers", {}).setdefault(provider, {})["base_url"] = base_url
+    save(data)
+
+
+def use_provider(provider: str) -> None:
+    data = load()
+    data["provider"] = provider
+    save(data)
+
+
+def resolve(
+    provider: str | None = None,
+    api_key: str | None = None,
+    model: str | None = None,
+    base_url: str | None = None,
+) -> ProviderConfig:
+    data = load()
+    name = provider or data.get("provider", DEFAULT_PROVIDER)
+    stored = data.get("providers", {}).get(name, {})
+
+    resolved_key = api_key or stored.get("api_key") or os.environ.get(ENV_KEYS.get(name, ""), None)
+    resolved_model = model or stored.get("model")
+    resolved_base_url = base_url or stored.get("base_url")
+
+    return ProviderConfig(name=name, api_key=resolved_key, model=resolved_model, base_url=resolved_base_url)

flarebisect/git_ops.py

@@ -0,0 +1,70 @@
+"""Thin wrapper around git subprocess calls. Never touches the caller's
+working tree — every candidate commit is checked out into its own
+`git worktree`, which git guarantees is isolated from the main tree."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+
+class GitError(RuntimeError):
+    pass
+
+
+def _run(args: list[str], cwd: Path) -> str:
+    try:
+        result = subprocess.run(
+            ["git", *args],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+        )
+    except FileNotFoundError as e:
+        raise GitError("git not found on PATH — install git and make sure it's on PATH") from e
+    if result.returncode != 0:
+        raise GitError(f"git {' '.join(args)} failed: {result.stderr.strip()}")
+    return result.stdout.strip()
+
+
+def resolve_sha(repo: Path, ref: str) -> str:
+    return _run(["rev-parse", ref], repo)
+
+
+def commit_list(repo: Path, good: str, bad: str) -> list[str]:
+    """Oldest -> newest commits strictly after `good`, up to and including `bad`."""
+    out = _run(["rev-list", "--reverse", f"{good}..{bad}"], repo)
+    return [line for line in out.splitlines() if line]
+
+
+def commit_subject(repo: Path, sha: str) -> str:
+    return _run(["log", "-1", "--format=%s", sha], repo)
+
+
+def commit_diff(repo: Path, sha: str) -> str:
+    return _run(["show", "--format=", sha], repo)
+
+
+@dataclass
+class Worktree:
+    path: Path
+    sha: str
+
+
+def add_worktree(repo: Path, sha: str) -> Worktree:
+    tmp_root = Path(tempfile.mkdtemp(prefix="flarebisect-"))
+    wt_path = tmp_root / sha[:12]
+    _run(["worktree", "add", "--detach", str(wt_path), sha], repo)
+    return Worktree(path=wt_path, sha=sha)
+
+
+def remove_worktree(repo: Path, wt: Worktree) -> None:
+    try:
+        _run(["worktree", "remove", "--force", str(wt.path)], repo)
+    except GitError:
+        # worktree metadata already gone; just clean the directory
+        pass
+    shutil.rmtree(wt.path.parent, ignore_errors=True)

flarebisect/hardware.py

@@ -0,0 +1,141 @@
+"""GPU/VRAM detection and local-model sizing.
+
+Best-effort across NVIDIA (nvidia-smi), AMD (rocm-smi), Apple Silicon
+(unified memory via sysctl), and Windows (WMI via PowerShell). Falls back to
+"no GPU" if nothing is found, which still yields a usable (small) model
+recommendation instead of an error.
+"""
+
+from __future__ import annotations
+
+import json
+import platform
+import re
+import shutil
+import subprocess
+from dataclasses import dataclass
+
+# (vram_gb_ceiling, ollama_tag, description) - first tier whose ceiling exceeds
+# the detected VRAM wins. Sizes assume 4-bit quantization with headroom for context.
+MODEL_TIERS: list[tuple[float, str, str]] = [
+    (3.0, "qwen2.5:0.5b", "tiny CPU-friendly model (~0.4GB)"),
+    (6.0, "llama3.2:3b", "small, fast model (~2GB)"),
+    (10.0, "llama3.1:8b", "solid general-purpose model (~5GB)"),
+    (16.0, "qwen2.5:14b", "stronger reasoning (~9GB)"),
+    (40.0, "qwen2.5:32b", "large, high-quality model (~18GB)"),
+]
+FALLBACK_MODEL: tuple[str, str] = ("llama3.1:70b", "flagship-scale model (~40GB), needs serious VRAM")
+
+
+@dataclass
+class GPUInfo:
+    vendor: str  # "nvidia", "amd", "apple", "unknown", "none"
+    name: str
+    vram_gb: float
+
+
+def _run(cmd: list[str]) -> str | None:
+    if not shutil.which(cmd[0]):
+        return None
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if result.returncode != 0 or not result.stdout.strip():
+        return None
+    return result.stdout.strip()
+
+
+def _detect_nvidia() -> GPUInfo | None:
+    out = _run(["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader,nounits"])
+    if not out:
+        return None
+    try:
+        name, mib = (part.strip() for part in out.splitlines()[0].split(","))
+        return GPUInfo(vendor="nvidia", name=name, vram_gb=round(float(mib) / 1024, 1))
+    except ValueError:
+        return None
+
+
+def _detect_amd() -> GPUInfo | None:
+    out = _run(["rocm-smi", "--showproductname", "--showmeminfo", "vram"])
+    if not out:
+        return None
+    vram_match = re.search(r"VRAM Total Memory \(B\):\s*(\d+)", out)
+    if not vram_match:
+        return None
+    name_match = re.search(r"Card series:\s*(.+)", out)
+    vram_gb = round(int(vram_match.group(1)) / (1024 ** 3), 1)
+    name = name_match.group(1).strip() if name_match else "AMD GPU"
+    return GPUInfo(vendor="amd", name=name, vram_gb=vram_gb)
+
+
+def _detect_apple_silicon() -> GPUInfo | None:
+    if platform.system() != "Darwin" or platform.machine() != "arm64":
+        return None
+    mem_out = _run(["sysctl", "-n", "hw.memsize"])
+    if not mem_out:
+        return None
+    try:
+        total_gb = int(mem_out) / (1024 ** 3)
+    except ValueError:
+        return None
+    # Unified memory is shared with the OS and other apps, so only a fraction
+    # is realistically usable for model weights.
+    usable_gb = round(total_gb * 0.7, 1)
+    name = _run(["sysctl", "-n", "machdep.cpu.brand_string"]) or "Apple Silicon"
+    return GPUInfo(vendor="apple", name=name, vram_gb=usable_gb)
+
+
+def _detect_windows_wmi() -> GPUInfo | None:
+    if platform.system() != "Windows":
+        return None
+    out = _run(
+        [
+            "powershell",
+            "-NoProfile",
+            "-Command",
+            "Get-CimInstance Win32_VideoController | Select-Object -First 1 Name,AdapterRAM | ConvertTo-Json",
+        ]
+    )
+    if not out:
+        return None
+    try:
+        data = json.loads(out)
+    except ValueError:
+        return None
+    name = data.get("Name") or "GPU"
+    ram = data.get("AdapterRAM")
+    if not ram:
+        return None
+    vendor = "nvidia" if "nvidia" in name.lower() else "amd" if ("amd" in name.lower() or "radeon" in name.lower()) else "unknown"
+    return GPUInfo(vendor=vendor, name=name, vram_gb=round(int(ram) / (1024 ** 3), 1))
+
+
+def detect_gpu() -> GPUInfo:
+    for detector in (_detect_nvidia, _detect_amd, _detect_apple_silicon, _detect_windows_wmi):
+        info = detector()
+        if info:
+            return info
+    return GPUInfo(vendor="none", name="no dedicated GPU detected", vram_gb=0.0)
+
+
+def recommend_model_with_desc(vram_gb: float) -> tuple[str, str]:
+    for ceiling, model, desc in MODEL_TIERS:
+        if vram_gb < ceiling:
+            return model, desc
+    return FALLBACK_MODEL
+
+
+def recommend_model(vram_gb: float) -> str:
+    return recommend_model_with_desc(vram_gb)[0]
+
+
+def ollama_available() -> bool:
+    return shutil.which("ollama") is not None
+
+
+def pull_model(model: str) -> None:
+    if not ollama_available():
+        raise RuntimeError("ollama not found on PATH - install it from https://ollama.com first")
+    subprocess.run(["ollama", "pull", model], check=True)

flarebisect/providers.py

@@ -0,0 +1,109 @@
+"""LLM backend abstraction.
+
+Claude talks over Anthropic's native SDK. Everything else - OpenAI, Gemini,
+Ollama, LM Studio, llama.cpp server, vLLM, Groq, OpenRouter, whatever -
+speaks the same OpenAI-style chat completions shape, so one client covers
+all of them by swapping base_url."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+PROVIDERS = ("anthropic", "openai", "google", "ollama", "custom")
+
+DEFAULT_BASE_URLS = {
+    "openai": "https://api.openai.com/v1",
+    "google": "https://generativelanguage.googleapis.com/v1beta/openai/",
+    "ollama": "http://localhost:11434/v1",
+}
+
+DEFAULT_MODELS = {
+    "anthropic": "claude-sonnet-5",
+    "openai": "gpt-4.1-mini",
+    "google": "gemini-2.5-flash",
+    "ollama": "llama3.1",
+}
+
+# local/self-hosted servers usually don't check the key at all
+NO_KEY_REQUIRED = {"ollama", "custom"}
+
+
+@dataclass
+class ProviderConfig:
+    name: str
+    api_key: str | None = None
+    model: str | None = None
+    base_url: str | None = None
+
+    def resolved_model(self) -> str:
+        return self.model or DEFAULT_MODELS.get(self.name, "gpt-4o-mini")
+
+    def resolved_base_url(self) -> str | None:
+        return self.base_url or DEFAULT_BASE_URLS.get(self.name)
+
+
+class ProviderError(RuntimeError):
+    pass
+
+
+def complete(cfg: ProviderConfig, prompt: str, max_tokens: int = 300) -> str:
+    if cfg.name not in PROVIDERS:
+        raise ProviderError(f"unknown provider '{cfg.name}' (expected one of {', '.join(PROVIDERS)})")
+
+    if cfg.name == "anthropic":
+        return _complete_anthropic(cfg, prompt, max_tokens)
+    return _complete_openai_compatible(cfg, prompt, max_tokens)
+
+
+def _complete_anthropic(cfg: ProviderConfig, prompt: str, max_tokens: int) -> str:
+    try:
+        import anthropic
+    except ImportError as e:
+        raise ProviderError("anthropic package not installed (pip install anthropic)") from e
+
+    if not cfg.api_key:
+        raise ProviderError(
+            "no Anthropic API key configured. Run `flarebisect config set-key anthropic <key>` "
+            "or set ANTHROPIC_API_KEY"
+        )
+
+    client = anthropic.Anthropic(api_key=cfg.api_key)
+    try:
+        message = client.messages.create(
+            model=cfg.resolved_model(),
+            max_tokens=max_tokens,
+            messages=[{"role": "user", "content": prompt}],
+        )
+    except anthropic.APIError as e:
+        raise ProviderError(str(e)) from e
+
+    return "".join(block.text for block in message.content if hasattr(block, "text")).strip()
+
+
+def _complete_openai_compatible(cfg: ProviderConfig, prompt: str, max_tokens: int) -> str:
+    try:
+        import openai
+    except ImportError as e:
+        raise ProviderError("openai package not installed (pip install openai)") from e
+
+    api_key = cfg.api_key
+    if not api_key:
+        if cfg.name in NO_KEY_REQUIRED:
+            api_key = "not-needed"
+        else:
+            raise ProviderError(
+                f"no API key configured for '{cfg.name}'. Run "
+                f"`flarebisect config set-key {cfg.name} <key>` or set the matching env var"
+            )
+
+    client = openai.OpenAI(api_key=api_key, base_url=cfg.resolved_base_url())
+    try:
+        response = client.chat.completions.create(
+            model=cfg.resolved_model(),
+            max_tokens=max_tokens,
+            messages=[{"role": "user", "content": prompt}],
+        )
+    except openai.APIError as e:
+        raise ProviderError(str(e)) from e
+
+    return (response.choices[0].message.content or "").strip()

flarebisect/report.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from rich import box
+from rich.bar import Bar
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from .bisect import BisectOutcome, CommitMeasurement
+
+console = Console()
+
+BAR_WIDTH = 42
+TRACK_COLOR = "grey19"
+
+STATUS_STYLE = {
+    "good": "green3",
+    "stable": "green3",
+    "wobbling": "gold3",
+    "flare": "bold dark_orange",
+    "bad": "red3",
+}
+
+BAR_COLOR = {
+    "good": "grey19",
+    "stable": "grey19",
+    "wobbling": "gold3",
+    "flare": "dark_orange",
+    "bad": "red3",
+}
+
+
+def print_progress_line(total_commits: int, runs: int, workers: int) -> None:
+    console.print()
+    console.print(
+        f"[dim]{total_commits} commits in range · {runs} runs per commit · "
+        f"parallel worktrees ({workers} workers)[/dim]"
+    )
+    console.print()
+
+
+def _row(m: CommitMeasurement) -> tuple:
+    short_sha = m.sha[:7]
+    is_flare = m.status == "flare"
+    commit_text = Text(short_sha, style="bold white" if is_flare else "grey70")
+
+    bar = Bar(
+        size=1.0,
+        begin=0,
+        end=m.result.flake_rate,
+        width=BAR_WIDTH,
+        color=BAR_COLOR.get(m.status, "grey50"),
+        bgcolor=TRACK_COLOR,
+    )
+
+    result_text = Text(f"{m.result.passed}/{m.result.runs}", style="bold white" if is_flare else "grey70")
+    status_text = Text(m.status, style=STATUS_STYLE.get(m.status, "grey70"))
+
+    return commit_text, bar, result_text, status_text
+
+
+def print_table(measurements: list[CommitMeasurement]) -> None:
+    table = Table(box=None, show_header=True, header_style="dim", padding=(0, 2, 0, 0))
+    table.add_column("commit")
+    table.add_column("flake rate")
+    table.add_column("result", justify="right")
+    table.add_column("status")
+
+    for m in measurements:
+        table.add_row(*_row(m))
+
+    console.print(table)
+
+
+def print_result(outcome: BisectOutcome, threshold: float, explanation: str | None = None) -> None:
+    before_pct = outcome.before.result.flake_rate
+    after_pct = outcome.culprit.result.flake_rate
+
+    header = Text.from_markup(
+        f"[bold]✦ culprit found[/bold] · commit [bold]{outcome.culprit.sha[:7]}[/bold]"
+    )
+    body_lines = [
+        header,
+        Text(""),
+        Text.from_markup(
+            f"flake rate jumped [bold]{before_pct:.0%} → {after_pct:.0%}[/bold] at this commit"
+        ),
+        Text(f'"{outcome.culprit.subject}"', style="italic grey70"),
+    ]
+
+    renderables = [*body_lines]
+    if explanation:
+        renderables.append(Text(""))
+        renderables.append(
+            Panel(
+                Text(f"💡 likely cause — {explanation}"),
+                border_style="grey35",
+                box=box.MINIMAL,
+                style="on grey11",
+                padding=(0, 2),
+            )
+        )
+
+    console.print()
+    console.print(Panel(Group(*renderables), border_style="red3", padding=(1, 2)))
+
+
+def print_footer(elapsed_seconds: float, checked: int, workers: int) -> None:
+    console.print(
+        f"[dim]⏱ {elapsed_seconds:.1f}s    ⚡ {checked} checked    ⚙ {workers} parallel workers[/dim]"
+    )
+    console.print()
+
+
+def print_error(message: str) -> None:
+    console.print(f"[bold red]error:[/bold red] {message}")

flarebisect/runner.py

@@ -0,0 +1,45 @@
+"""Run a test command N times against a worktree and compute a flake rate."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class RunResult:
+    passed: int
+    failed: int
+    runs: int
+
+    @property
+    def flake_rate(self) -> float:
+        return self.failed / self.runs if self.runs else 0.0
+
+
+def worker_count_for(runs: int) -> int:
+    """Don't oversubscribe more parallel test runs than the machine has cores."""
+    cores = os.cpu_count() or 4
+    return max(1, min(runs, cores))
+
+
+def _one_run(test_cmd: str, cwd: Path) -> bool:
+    result = subprocess.run(
+        test_cmd,
+        shell=True,
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+    )
+    return result.returncode == 0
+
+
+def measure_flake_rate(test_cmd: str, cwd: Path, runs: int) -> RunResult:
+    with ThreadPoolExecutor(max_workers=worker_count_for(runs)) as pool:
+        outcomes = list(pool.map(lambda _: _one_run(test_cmd, cwd), range(runs)))
+    passed = sum(outcomes)
+    failed = runs - passed
+    return RunResult(passed=passed, failed=failed, runs=runs)

flarebisect-0.3.1.dist-info/METADATA

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: flarebisect
+Version: 0.3.1
+Summary: git bisect that treats flakiness as a signal, not noise
+Project-URL: Homepage, https://github.com/kaorii-ako/FlareBisect
+Project-URL: Repository, https://github.com/kaorii-ako/FlareBisect
+Project-URL: Issues, https://github.com/kaorii-ako/FlareBisect/issues
+Author: Tawin Tangsukson
+License: MIT
+License-File: LICENSE
+Keywords: bisect,cli,debugging,flaky-tests,git,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.10
+Requires-Dist: anthropic>=0.40
+Requires-Dist: openai>=1.40
+Requires-Dist: rich>=13.7
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# FlareBisect 🔥
+
+[![PyPI](https://img.shields.io/pypi/v/flarebisect.svg)](https://pypi.org/project/flarebisect/)
+[![CI](https://github.com/kaorii-ako/FlareBisect/actions/workflows/ci.yml/badge.svg)](https://github.com/kaorii-ako/FlareBisect/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+FlareBisect finds the commit that made your tests flaky, not just the one
+that broke them: it bisects on flake-rate drift instead of pass/fail, then
+flares the culprit with an AI-written root cause.
+
+`git bisect` gives you confidently wrong answers when the test you're
+bisecting on is flaky — it treats every run as a clean pass/fail signal, so
+a test that was already unstable *before* you started bisecting can point
+straight at an innocent commit.
+
+`flarebisect` bisects on **flake rate**, not pass/fail. It runs each
+candidate commit's test N times in parallel, computes a failure rate, and
+finds the commit where that rate jumps — then asks an LLM to explain, in
+plain English, whether the commit broke the test cleanly or made it flakier.
+
+```
+12 commits in range · 20 runs per commit · parallel worktrees
+
+commit   flake rate                                  result  status
+a1b2c3                                                  5/5  good
+4f9e21                                                  5/5  stable
+7d3aa0   ███████                                        4/5  wobbling
+9c1f88   ████████████████████████████                   1/5  flare
+HEAD     ████████████████████████████                   1/5  bad
+
+╭────────────────────────────────────────────────────────────────╮
+│ ✦ culprit found · commit 9c1f88                                    │
+│                                                                        │
+│ flake rate jumped 20% → 80% at this commit                             │
+│ "add request counter for rate limiting"                                │
+│                                                                        │
+│   💡 likely cause — shared counter incremented without a lock.        │
+│   concurrent test workers race on the same variable.                   │
+╰────────────────────────────────────────────────────────────────╯
+⏱ 8.4s    ⚡ 5 checked    ⚙ 4 parallel workers
+```
+
+## Install
+
+```bash
+pip install flarebisect
+```
+
+For local development:
+
+```bash
+pip install -e ".[dev]"
+pytest -q
+```
+
+Works on Linux, macOS, and Windows — the only external dependency is `git`
+on your `PATH`. Every candidate commit runs in its own `git worktree` under a
+temp directory; your actual working tree and index are never touched.
+
+## AI provider setup
+
+The root-cause explanation step works with Claude, OpenAI, Gemini, or a
+local model — anything speaking an OpenAI-compatible chat API (Ollama, LM
+Studio, llama.cpp server, vLLM, and similar all qualify).
+
+```bash
+# cloud
+flarebisect config set-key anthropic sk-ant-...
+flarebisect config set-key openai sk-...
+flarebisect config set-key google AI...
+
+# local, no key needed - just have Ollama running
+flarebisect config use ollama
+flarebisect config set-model ollama llama3.1
+
+# or let flarebisect pick a model sized to your GPU and pull it for you
+flarebisect models detect   # shows detected GPU/VRAM + recommended model
+flarebisect models pull     # downloads it and sets it active (run with no args)
+
+# any other OpenAI-compatible endpoint
+flarebisect config use custom
+flarebisect config set-base-url custom http://localhost:8080/v1
+flarebisect config set-key custom sk-local
+```
+
+Run `flarebisect config` with no arguments for a guided setup wizard — for
+Ollama it detects your GPU/VRAM, prefills a right-sized model, and offers to
+pull it on the spot.
+
+`flarebisect config show` lists the active provider and stored settings
+(keys are masked). Config lives in a JSON file under the OS config dir
+(`~/.config/flarebisect/config.json` on Linux/macOS, `%APPDATA%` on Windows),
+written with owner-only permissions.
+
+Per-run overrides skip the config file entirely:
+
+```bash
+flarebisect run ... --provider openai --model gpt-4o-mini --api-key sk-...
+flarebisect run ... --provider ollama --base-url http://localhost:11434/v1
+```
+
+Env vars (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GOOGLE_API_KEY`) work too,
+as a fallback under whatever's in the config file.
+
+## Usage
+
+```bash
+flarebisect run \
+  --repo /path/to/repo \
+  --good <known-good-sha> \
+  --bad <known-bad-sha> \
+  --test "pytest -k my_flaky_test" \
+  --runs 20 \
+  --threshold 0.3
+```
+
+- `--runs` — test executions per commit (default 20), run in parallel
+  (capped at your core count so it doesn't oversubscribe). Lower counts are
+  faster but noisier — a low sample can misattribute the culprit near the
+  threshold boundary.
+- `--threshold` — flake-rate jump (0-1) vs. the `good` baseline required to
+  call a commit the culprit (default 0.3).
+- `--no-explain` — skip the LLM root-cause call entirely (fully offline).
+
+## Demo
+
+See [`demo/`](demo/) for a self-contained, seeded-flaky-bug repo you can
+bisect against with no network access required for the bisection itself.
+
+## How it works
+
+1. Measure the flake rate at `good` and `bad` as baselines.
+2. Binary-search the commit range between them.
+3. At each candidate, run the test `N` times in an isolated worktree and
+   compute `failed / N`.
+4. The culprit is the first commit whose flake rate jumps by `>= threshold`
+   over the `good` baseline.
+5. Verdict: **clean break** (rate goes ~0% → ~100%) vs. **flakiness
+   regression** (rate goes ~0% → somewhere in between).
+6. The configured LLM gets the culprit's diff + the flake-rate evidence and
+   returns a short root-cause read (race condition, shared mutable state,
+   timing assumption, etc.).
+
+Binary search assumes the flake rate is roughly monotonic across the range,
+same as ordinary `git bisect` assumes pass/fail is. At low `--runs` counts
+a noisy sample can occasionally violate that near the threshold boundary —
+bump `--runs` if a result looks off.
+
+## Releasing
+
+Version is single-sourced from `src/flarebisect/__init__.py`. Bump it, commit,
+tag (`vX.Y.Z`), and cut a GitHub Release — `.github/workflows/publish.yml`
+builds and publishes to PyPI via trusted publishing (OIDC, no stored token).
+
+## License
+
+MIT

flarebisect-0.3.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+flarebisect/__init__.py,sha256=r4xAFihOf72W9TD-lpMi6ntWSTKTP2SlzKP1ytkjRbI,22
+flarebisect/ai_explain.py,sha256=O0xW49W6pFQOrP3DB0EO7cd1AYtLxIdWGOQP2cTl4a0,1184
+flarebisect/bisect.py,sha256=SCgOcAJZ7U0o87anYm_ZdMO4d7Hz7uodv722nkZHdVA,4330
+flarebisect/cli.py,sha256=H-4DLj_F7BE-FSx8fqPPWZlKyMSQ8yKSKCTNhr6q9wo,12753
+flarebisect/config.py,sha256=JpI7vPpfTPTPkNGIa_4GZM0AtbSZE-5Dsw3SM1WzIbg,2527
+flarebisect/git_ops.py,sha256=XOq5LH9AaZXpfSIvcDxWxlZ0iP3Z_NczMysh7YY-U7c,2050
+flarebisect/hardware.py,sha256=SkiLOM1yMH1pl4-L595bzU27LN3hgG1W2Fkb5e6bE-g,4755
+flarebisect/providers.py,sha256=57P_Tu598TNpiNt6PBNVnqcg8rKR9Z0hMtK2Aj50BTA,3520
+flarebisect/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flarebisect/report.py,sha256=Chr28w7MGNCNn01gRXOGG5H5wNKZgnwkUjNmZ4uVkfE,3275
+flarebisect/runner.py,sha256=EriLrFVH3dx9h4R95hqzUqjfg5QYsu-U5s6HwPT3d0g,1200
+flarebisect-0.3.1.dist-info/METADATA,sha256=G5sGUSY1_FSbXKqCqBL9D3hgJBWnBcu3l2yQihaAXuc,8228
+flarebisect-0.3.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+flarebisect-0.3.1.dist-info/entry_points.txt,sha256=cWg78Ga7VgIQD9vE_lrVlD4GmWzVTsi1Xd3DuceiZOI,52
+flarebisect-0.3.1.dist-info/licenses/LICENSE,sha256=PHi-k4j6Jr3rg_5SrM1w_x5iqcJhk3fx2bPQlB6MAJE,1073
+flarebisect-0.3.1.dist-info/RECORD,,

flarebisect-0.3.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

flarebisect-0.3.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+flarebisect = flarebisect.cli:app

flarebisect-0.3.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tawin Tangsukson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.