# ai_bisect.py
import anthropic
import subprocess
import tempfile
import os
import sys

client = anthropic.Anthropic()


def generate_bisect_script(
    bug_description: str,
    repo_path: str,
    language: str = "auto"
) -> str:
    """Generate a git bisect test script from a bug description."""

    # Get repo context
    result = subprocess.run(
        ["git", "log", "--oneline", "-20"],
        cwd=repo_path, capture_output=True, text=True
    )
    recent_commits = result.stdout

    result = subprocess.run(
        ["ls", "package.json", "requirements.txt", "go.mod", "Makefile"],
        cwd=repo_path, capture_output=True, text=True
    )
    project_files = result.stdout

    system_prompt = """You are a git bisect test script generator. Generate a bash script that:
1. Tests for the described bug
2. Exits 0 if the bug is NOT present (commit is good)
3. Exits 1 if the bug IS present (commit is bad)
4. Exits 125 if the test can't run (skip this commit)

The script should be minimal and fast. Use grep, curl, or run the test suite.
Start with #!/bin/bash and set -e. Return ONLY the script, no explanations."""

    message = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=2048,
        system=system_prompt,
        messages=[{
            "role": "user",
            "content": f"""Bug description: {bug_description}

Recent commits:
{recent_commits}

Project files present: {project_files}

Generate a bisect test script."""
        }]
    )

    return message.content[0].text


def run_bisect(
    repo_path: str,
    good_commit: str,
    bad_commit: str,
    test_script_content: str
) -> dict:
    """Run git bisect with the generated script."""

    # Write test script to temp file
    with tempfile.NamedTemporaryFile(
        mode='w', suffix='.sh', delete=False, dir='/tmp'
    ) as f:
        f.write(test_script_content)
        script_path = f.name

    os.chmod(script_path, 0o755)

    try:
        # Start bisect
        subprocess.run(["git", "bisect", "start"], cwd=repo_path, check=True)
        subprocess.run(["git", "bisect", "bad", bad_commit], cwd=repo_path, check=True)
        subprocess.run(["git", "bisect", "good", good_commit], cwd=repo_path, check=True)

        # Run bisect
        result = subprocess.run(
            ["git", "bisect", "run", script_path],
            cwd=repo_path,
            capture_output=True,
            text=True,
            timeout=300  # 5 minute timeout
        )

        bisect_output = result.stdout + result.stderr

        # Get the bad commit hash from output
        bad_commit_line = next(
            (line for line in bisect_output.split('\n')
             if 'is the first bad commit' in line),
            None
        )

        return {
            "success": result.returncode == 0,
            "output": bisect_output,
            "bad_commit": bad_commit_line,
        }

    finally:
        # Always reset bisect state
        subprocess.run(["git", "bisect", "reset"], cwd=repo_path, check=False)
        os.unlink(script_path)


def analyze_bad_commit(repo_path: str, commit_hash: str, bug_description: str) -> str:
    """Use Claude to analyze the bad commit and explain the root cause."""

    # Get the diff of the bad commit
    diff_result = subprocess.run(
        ["git", "show", "--stat", "--patch", commit_hash],
        cwd=repo_path, capture_output=True, text=True
    )

    message_result = subprocess.run(
        ["git", "log", "-1", "--format=%B", commit_hash],
        cwd=repo_path, capture_output=True, text=True
    )

    message = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=2048,
        messages=[{
            "role": "user",
            "content": f"""Git bisect identified this commit as the first bad commit.

Bug description: {bug_description}

Commit message:
{message_result.stdout}

Diff:
{diff_result.stdout[:6000]}  # Truncate large diffs

Explain:
1. What change in this commit causes the bug
2. Which specific lines are responsible
3. How to fix it"""
        }]
    )

    return message.content[0].text

# ai_bisect_cli.py
import click
from ai_bisect import generate_bisect_script, run_bisect, analyze_bad_commit
import re

@click.command()
@click.option('--repo', default='.', help='Repository path')
@click.option('--good', required=True, help='Known good commit/tag')
@click.option('--bad', default='HEAD', help='Known bad commit/tag')
@click.option('--bug', required=True, help='Bug description')
@click.option('--dry-run', is_flag=True, help='Show test script only, do not run bisect')
def bisect(repo, good, bad, bug, dry_run):
    """AI-powered git bisect automation."""

    click.echo(f"Generating test script for: {bug}")
    script = generate_bisect_script(bug, repo)

    click.echo("\nGenerated test script:")
    click.echo("=" * 40)
    click.echo(script)
    click.echo("=" * 40)

    if dry_run:
        click.echo("\nDry run mode — not running bisect.")
        return

    if not click.confirm("\nRun bisect with this script?"):
        return

    click.echo(f"\nRunning bisect between {good} and {bad}...")
    result = run_bisect(repo, good, bad, script)

    click.echo("\nBisect output:")
    click.echo(result['output'])

    if result['bad_commit']:
        # Extract commit hash from the output line
        hash_match = re.search(r'([0-9a-f]{40})', result['bad_commit'])
        if hash_match:
            commit_hash = hash_match.group(1)
            click.echo(f"\nAnalyzing bad commit: {commit_hash}")
            analysis = analyze_bad_commit(repo, commit_hash, bug)
            click.echo("\nRoot cause analysis:")
            click.echo(analysis)


if __name__ == '__main__':
    bisect()