unitsauce 0.1.0__py3-none-any.whl

unitsauce/analysis.py

@@ -0,0 +1,179 @@
+import ast
+import difflib
+import json
+import os
+from pathlib import Path
+import re
+import subprocess
+
+from rich.syntax import Syntax
+from rich.panel import Panel
+from rich.spinner import Spinner
+from rich.live import Live
+from .utils import console
+
+def show_diff(original, new, file_name):
+    diff = difflib.unified_diff(
+        original.splitlines(keepends=True),
+        new.splitlines(keepends=True),
+        fromfile=f"before/{file_name}",
+        tofile=f"after/{file_name}"
+    )
+    diff_text = ''.join(diff)
+    if diff_text:
+        syntax = Syntax(diff_text, "diff", theme="monokai", line_numbers=True)
+        console.print(Panel(syntax, title="Changes", border_style="green"))
+    
+    return diff_text
+
+def changed_lines(diff):
+    lines = []
+    new_ln = None
+
+    for line in diff.splitlines():
+        if line.startswith("@@"):
+            m = re.search(r"\+(\d+)", line)
+            new_ln = int(m.group(1)) - 1
+            continue
+        
+        if new_ln is None:
+            continue
+        if line.startswith("+") and not line.startswith("+++"):
+            new_ln += 1
+            lines.append(new_ln)
+        elif line.startswith("-") and not line.startswith("---"):
+            pass
+        else:
+            new_ln += 1
+
+    return lines
+
+def get_failing_tests(path):
+    with open(path + "/report.json") as f:
+        report = json.load(f)
+
+    failures = []
+    for test in report["tests"]:
+        if test["outcome"] == "failed":
+            failures.append({
+                "file": test["nodeid"].split("::")[0],
+                "function": test["nodeid"].split("::")[-1],
+                "error": test["call"]["crash"]["message"],
+            })
+
+    return failures
+
+def get_git_diff(path):
+    changed_files = subprocess.run(
+                    ["git", "diff", "--name-only", "HEAD~1", "--", ".", ":(exclude)tests"],
+                    cwd=path,
+                    capture_output=True,
+                    text=True,
+                    check=True
+                )
+
+    return changed_files.stdout.splitlines()
+
+def get_single_file_diff(path, changed_file_path):
+    changed_file_diff = subprocess.run(
+                    ["git", "diff", "HEAD~1", "--", changed_file_path],
+                    cwd=path,
+                    capture_output=True,
+                    text=True,
+                    check=True
+                )
+
+    return changed_file_diff.stdout
+
+def index_file_functions(source):
+    tree = ast.parse(source)
+    funcs = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            funcs.append({
+                "name": node.name,
+                "start": node.lineno,
+                "end": node.end_lineno,
+                "node": node,
+            })
+
+    return funcs
+
+def extract_function_source(code: str, func):
+    lines = code.splitlines()
+    return "\n".join(lines[func["start"] - 1 : func["end"]])
+
+
+def split_functions_raw(code):
+    """Split code into functions, keeping raw text with comments."""
+    lines = code.splitlines()
+    functions = {}
+    current_name = None
+    current_lines = []
+    
+    for line in lines:
+        if line.startswith('def '):
+            if current_name:
+                functions[current_name] = '\n'.join(current_lines)
+            current_name = line.split('(')[0].replace('def ', '').strip()
+            current_lines = [line]
+        elif current_name:
+            current_lines.append(line)
+    
+    if current_name:
+        functions[current_name] = '\n'.join(current_lines)
+    
+    return functions
+
+def read_file_content(file, path, is_file_path=False):
+    if is_file_path:
+        with open(file, 'r', encoding='utf-8', errors='ignore') as f:
+            file_content = f.read()
+        return file, file_content
+    
+    file_path = next(Path(path).rglob(file), None)
+    if not file_path:
+        return None, None
+    
+    with open(file_path, encoding='utf-8', errors='ignore') as open_file:
+        file_content = open_file.read()
+    
+    return file_path, file_content
+
+def gather_context(diff, function_code):
+    lines = changed_lines(diff)
+    funcs = index_file_functions(function_code)
+
+    affected = [] 
+
+    for f in funcs:
+        if any(f["start"] <= ln <= f["end"] for ln in lines):
+            affected.append(extract_function_source(function_code, f))
+
+    return affected
+
+def run_tests(path):
+    if os.path.exists(path):
+            with Live(Spinner("dots", text="Running tests..."), console=console):
+                result = subprocess.run(
+                    ["python", "-m", "pytest", "--tb=short", "--json-report", "--json-report-file=report.json"],
+                    cwd=path,
+                    capture_output=True,
+                    text=True
+                )
+            console.print()
+            return result
+
+def run_single_test(path, test_file, test_function):
+    test_id = f"{test_file}::{test_function}"
+    result = subprocess.run(
+        ["python", "-m", "pytest", test_id, "-v"],
+        cwd=path,
+        capture_output=True,
+        text=True
+    )
+    if result.returncode == 0:
+        return True, ""
+    else:
+        return False, result.stderr

unitsauce/fixer.py

@@ -0,0 +1,219 @@
+import os
+import re
+import shutil
+from .analysis import gather_context, get_single_file_diff, index_file_functions, read_file_content, run_single_test, run_tests, show_diff, split_functions_raw
+from anthropic import Anthropic
+from dotenv import load_dotenv
+
+from .models import FixContext, FixResult, VerifyContext
+from .prompts import fix_code_prompt, fix_test_prompt
+from rich.spinner import Spinner
+from rich.live import Live
+from .utils import backup_file, console
+
+load_dotenv()
+
+client = Anthropic(
+    api_key=os.getenv("ANTHROPIC_API_KEY")
+)
+
+def call_llm(fix_prompt, functions, test_code, error_message, diff):
+    with Live(Spinner("dots", text="Generating solution..."), console=console):
+        response = client.messages.create(
+                        max_tokens=8192*2,
+                        messages=[
+                            {
+                                "role": "user",
+                                "content": fix_prompt.format(function_code=functions, test_code=test_code, error_message=error_message, diff=diff),
+                            }
+                        ],
+                        model="claude-opus-4-5-20251101",
+                    )
+    console.print()
+    code = response.content[0].text
+    match = re.search(r'```python(.*?)```', code, re.DOTALL)
+
+    if match:
+        return match.group(1)
+    return None
+
+
+def apply_fix(file_path, generated_code):
+    backup = backup_file(file_path)
+
+    try:
+        source = file_path.read_text()
+        file_funcs_list = index_file_functions(source)
+        file_funcs = {f["name"]: f for f in file_funcs_list}
+
+        lines = source.splitlines()
+
+        raw_funcs = split_functions_raw(generated_code)
+
+        for name, raw_text in sorted(raw_funcs.items(), key=lambda x: file_funcs.get(x[0], {}).get("start", 0), reverse=True):
+            if name in file_funcs:
+                old = file_funcs[name]
+                start = old["start"] - 1
+                end = old["end"]
+                lines[start:end] = raw_text.splitlines()
+
+                file_path.write_text("\n".join(lines))
+
+        return {"success": True, "backup": backup}
+        
+    except SyntaxError as e:
+        console.print(f"[red]Claude returned invalid code: {e}[/red]")
+        shutil.copy2(backup, file_path)
+        backup.unlink()
+        return {"success": False, "backup": None}
+
+def verify_fix(ctx: VerifyContext):
+    test_passed, new_changes_result = run_single_test(ctx.repo_path, ctx.test_file, ctx.test_function)
+    if test_passed:
+        if ctx.fix_type == "code":
+            diff = show_diff(ctx.original_function_code, ctx.generated_code, ctx.test_function)
+        else:
+            diff = show_diff(ctx.test_code, ctx.generated_code, ctx.test_function)
+
+        result = run_tests(ctx.repo_path)
+        if result.returncode == 0:
+            ctx.backup_path.unlink()
+            return {"fixed": True, "diff": diff}
+        else:
+            return {"fixed": False, "diff": ""}
+    else:
+        if new_changes_result == ctx.original_error_message:
+            shutil.copy2(ctx.backup_path, ctx.file_path)
+            ctx.backup_path.unlink()
+            console.print("[red]Fix didn't work, restored original[/red]")
+
+        else:
+            ctx.backup_path.unlink()
+            console.print("[yellow]Different error now - keeping changes[/yellow]")
+        return {"fixed": False, "diff": ""}
+
+def fix(ctx: FixContext):
+    diff = get_single_file_diff(ctx.repo_path, ctx.function_name)
+    
+    affected = gather_context(diff, ctx.function_code)
+
+    generated_code = call_llm(ctx.prompt, affected, ctx.test_code, ctx.error_message, diff)
+
+    if generated_code is None:
+        console.print("[red]LLM returned no code block[/red]")
+        return False
+    
+    successful_fix = apply_fix(ctx.file_path, generated_code)
+    if not successful_fix["success"]:
+        return False
+    else:
+        verify_ctx = VerifyContext(
+            repo_path=ctx.repo_path,
+            file_path=ctx.file_path,
+            test_file=ctx.test_file,
+            test_code=ctx.test_code,
+            test_function=ctx.test_function,
+            original_function_code=ctx.function_code,
+            generated_code=generated_code,
+            backup_path=successful_fix["backup"],
+            original_error_message=ctx.error_message,
+            fix_type=ctx.fix_type
+        )
+        return verify_fix(verify_ctx)
+
+def try_fix_test(failure, test_file_path, test_code, source_file, source_code, path, fix_type):
+    """Attempt to fix the test file."""
+    context = FixContext(
+        prompt=fix_test_prompt,
+        function_name=failure['function'],
+        file_path=test_file_path,
+        function_code=source_code,
+        test_code=test_code,
+        error_message=failure['error'],
+        repo_path=path,
+        test_file=failure['file'],
+        test_function=failure['function'],
+        fix_type=fix_type
+    )
+    return fix(context)
+
+
+def try_fix_code(failure, test_code, source_file, source_code, path, fix_type):
+    """Attempt to fix the source code."""
+    context = FixContext(
+        prompt=fix_code_prompt,
+        function_name=source_file,
+        file_path=source_file,
+        function_code=source_code,
+        test_code=test_code,
+        error_message=failure['error'],
+        repo_path=path,
+        test_file=failure['file'],
+        test_function=failure['function'],
+        fix_type=fix_type
+    )
+    return fix(context)
+
+def attempt_fix(failure, changed_files, path, mode):
+    test_file_path, test_code = read_file_content(failure['file'], path)
+
+    guessed_name = failure['file'].split("/")[-1].replace("test_", "")
+
+    if guessed_name in changed_files:
+        files_to_try = [guessed_name] + [f for f in changed_files if f != guessed_name]
+    else:
+        files_to_try = changed_files
+
+    for source_file in files_to_try:
+        source_path, source_code = read_file_content(source_file, path)
+        if not source_path:
+            continue
+        
+        if mode == 'test':
+            result = try_fix_test(failure, test_file_path, test_code, source_path, source_code, path, mode)
+            if result["fixed"]:
+                return FixResult(
+                    test_file=failure['file'],
+                    test_function=failure['function'],
+                    error_message=failure['error'],
+                    fixed=result["fixed"],
+                    fix_type='test',
+                    file_changed=str(test_file_path),
+                    diff=result["diff"]
+                )
+                
+        elif mode == 'code':
+            result = try_fix_code(failure, test_file_path, test_code, source_path, source_code, path, mode)
+            if result["fixed"]:
+                return FixResult(
+                    test_file=failure['file'],
+                    test_function=failure['function'],
+                    error_message=failure['error'],
+                    fixed=result["fixed"],
+                    fix_type='test',
+                    file_changed=str(test_file_path),
+                    diff=result["diff"]
+                )
+                
+        elif mode == 'auto':
+            result = try_fix_test(failure, test_file_path, test_code, source_path, source_code, path, mode)
+            if result["fixed"]:
+                return FixResult(
+                    test_file=failure['file'],
+                    test_function=failure['function'],
+                    error_message=failure['error'],
+                    fixed=result["fixed"],
+                    fix_type='test',
+                    file_changed=str(test_file_path),
+                    diff=result["diff"]
+                )
+    
+    return FixResult(
+                    test_file=failure['file'],
+                    test_function=failure['function'],
+                    error_message=failure['error'],
+                    fixed=False,
+                    fix_type='auto',
+                    file_changed=str(test_file_path),
+                    diff=""
+                )

unitsauce/github.py

@@ -0,0 +1,92 @@
+import json
+import os
+
+import httpx
+
+def check_if_pull_request():
+    event_name = os.getenv("GITHUB_EVENT_NAME")
+    event_path = os.getenv("GITHUB_EVENT_PATH")
+    repo = os.getenv("GITHUB_REPOSITORY")
+
+    if event_name != "pull_request":
+        return None
+    
+    if not event_path or not os.path.exists(event_path):
+        return None
+        
+    with open(event_path) as f:
+        event_details = json.load(f)
+    
+    pr = event_details.get("pull_request", {})
+    
+    return {
+        "number": pr.get("number"),
+        "repo": repo,
+        "sha": pr.get("head", {}).get("sha")
+    }
+
+
+def post_pr_comment(repo, pr_number, body):
+    """Post a comment to a PR. Returns True if successful."""
+
+    token = os.getenv("GITHUB_TOKEN")
+    
+    if not token:
+        return False
+    
+    url = f"https://api.github.com/repos/{repo}/issues/{pr_number}/comments"
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": "application/vnd.github+json"
+    }
+    
+    # Use requests or httpx
+    response = httpx.post(url, json={"body": body}, headers=headers)
+    return response.status_code == 201
+
+
+def format_pr_comment(result):
+    """Format fix result as PR comment markdown."""
+    
+    if result.fixed:
+        status = "✅ Fixed"
+    else:
+        status = "❌ Could not fix"
+    
+    comment = f"## {status}: `{result.test_file}::{result.test_function}`\n\n"
+    comment += f"**Error:** `{result.error_message[:100]}`\n\n"
+    
+    if result.fixed:
+        comment += f"**Fixed by:** Updating `{result.fix_type}` in `{result.file_changed}`\n\n"
+        comment += f"**Apply this change:**\n\n"
+        comment += f"```python\n{result.generated_code}\n```\n"
+    
+    return comment
+
+
+def format_pr_comment_summary(results):
+    """Format all fix results as a single PR comment."""
+    
+    total = len(results)
+    fixed = sum(1 for r in results if r.fixed)
+    
+    # Header
+    comment = "## 🔧 UnitSauce Analysis\n\n"
+    comment += f"Found **{total}** failing test(s), fixed **{fixed}**.\n\n"
+    comment += "---\n\n"
+    
+    # Each result
+    for result in results:
+        if result.fixed:
+            comment += f"### ✅ `{result.test_file}::{result.test_function}`\n\n"
+            comment += f"**Error:** `{result.error_message[:100]}`\n\n"
+            comment += f"**Fixed by:** Updating `{result.fix_type}` in `{result.file_changed}`\n\n"
+            comment += f"```diff\n{result.diff}\n```\n\n"
+        else:
+            comment += f"### ❌ `{result.test_file}::{result.test_function}`\n\n"
+            comment += f"**Error:** `{result.error_message[:100]}`\n\n"
+            comment += "Could not auto-fix this failure.\n\n"
+        
+        comment += "---\n\n"
+    
+    return comment

unitsauce/main.py

@@ -0,0 +1,82 @@
+
+import argparse
+import sys
+from dotenv import load_dotenv
+from unitsauce.github import check_if_pull_request, format_pr_comment, format_pr_comment_summary, post_pr_comment
+from unitsauce.output import format_result, format_summary
+
+from .fixer import attempt_fix
+from .analysis import get_failing_tests, get_git_diff, read_file_content, run_tests
+from .utils import print_header, console
+
+
+load_dotenv()
+
+
+def main():
+
+    parser = argparse.ArgumentParser(
+        prog='unitsauce',
+        description='AI-powered test failure analysis and fix suggestions. Analyzes git diffs, identifies bugs causing test failures, and generates fixes.',
+        epilog='Examples:\n  unitsauce ./my-project\n  unitsauce ./my-project --mode code\n  unitsauce ./my-project --mode test --output markdown',
+        formatter_class=argparse.RawDescriptionHelpFormatter  # Preserves newlines in epilog
+    )
+    parser.add_argument("path")
+    parser.add_argument('--mode', choices=['auto', 'code', 'test'], default='auto', help='Fix mode (default: auto)')
+    parser.add_argument('--output', choices=['console', 'markdown', 'json'], default='console', help='Output format (default: console)')
+
+    args = parser.parse_args()
+
+    if len(sys.argv) < 2:
+        console.print("[yellow]Usage: python test_fixer.py <project_path>[/yellow]")
+        return
+
+    print_header()
+    
+    path = args.path
+    run_tests(path)
+    failures = get_failing_tests(path)
+
+    results = []
+    markdown_output = ""
+
+    if not failures:
+        console.print("[green]All tests pass![/green]")
+        return
+    
+    console.print(f"[yellow]Found {len(failures)} failing test(s)[/yellow]\n")
+    changed_files = get_git_diff(args.path)
+    changed_files = [f for f in changed_files if f.endswith('.py')]
+
+    
+    for failure in failures:
+        console.print(f"[red]FAILING:[/red] {failure['file']}::{failure['function']}")
+        console.print(f"[red]ERROR:[/red] {failure['error']}\n")
+        
+        result = attempt_fix(failure, changed_files, args.path, args.mode)
+        results.append(result)
+
+        if args.output == 'console':
+            format_result(result, 'console')
+        elif args.output == 'markdown':
+            markdown_output += format_result(result, 'markdown') + "\n"
+
+    pr = check_if_pull_request()
+
+    if pr:
+        comment = format_pr_comment_summary(results)
+        post_pr_comment(pr['repo'], pr['number'], comment)
+
+
+    if args.output == 'console':
+        format_summary(results, 'console')
+    elif args.output == 'markdown':
+        markdown_output += format_summary(results, 'markdown')
+        print(markdown_output)
+    elif args.output == 'json':
+        print(format_summary(results, 'json'))
+        
+
+
+if __name__ == "__main__":
+    main()

unitsauce/models.py

@@ -0,0 +1,58 @@
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass
+class FixContext:
+    # --- LLM / reasoning ---
+    prompt: str
+    error_message: str
+
+    # --- Code under fix ---
+    function_name: str
+    function_code: str
+    file_path: Path
+
+    # --- Test context ---
+    test_code: str
+    test_file: Path
+    test_function: str
+
+    # --- Repo / execution ---
+    repo_path: Path
+    fix_type: str
+
+
+@dataclass(frozen=True)
+class VerifyContext:
+    # --- Repo / execution ---
+    repo_path: Path
+    file_path: Path
+    fix_type: str
+
+    # --- Test ---
+    test_file: Path
+    test_function: str
+    test_code: str
+
+    # --- Code ---
+    original_function_code: str
+    generated_code: str
+    backup_path: Path
+
+    # --- Failure ---
+    original_error_message: Optional[str] = None
+
+@dataclass
+class FixResult:
+    test_file: str
+    test_function: str
+
+    error_message: str
+    fixed: bool
+    fix_type: str
+    
+    diff: str
+    file_changed: str

unitsauce/output.py

@@ -0,0 +1,114 @@
+import json
+from rich.panel import Panel
+from rich.table import Table
+from rich.syntax import Syntax
+from .utils import console
+
+def format_result(result, format_type):
+    if format_type == 'console':
+        return _format_console(result)
+    elif format_type == 'markdown':
+        return _format_markdown(result)
+    elif format_type == 'json':
+        return _format_json(result)
+    
+def format_summary(results, format_type):
+    """Format summary of all results."""
+    if format_type == 'console':
+        return _format_console_summary(results)
+    elif format_type == 'markdown':
+        return _format_markdown_summary(results)
+    elif format_type == 'json':
+        return _format_json_summary(results)
+    
+
+def _format_console(result):
+    """Format a single fix result for console output."""
+    
+
+    if result.fixed:
+        status = "[green]✓ FIXED[/green]"
+    else:
+        status = "[red]✗ NOT FIXED[/red]"
+    
+    console.print(f"\n{status} [bold]{result.test_file}::{result.test_function}[/bold]")
+    
+    console.print(f"[dim]Error:[/dim] {result.error_message[:100]}...")
+    
+    if result.fixed:
+        console.print(f"[dim]Fixed by:[/dim] Updating [cyan]{result.fix_type}[/cyan] in [cyan]{result.file_changed}[/cyan]")
+        
+        if result.diff:
+            syntax = Syntax(result.diff, "diff", theme="monokai", line_numbers=True)
+            console.print(Panel(syntax, title="Changes", border_style="green"))
+
+def _format_console_summary(results):
+    total = len(results)
+    fixed = sum(1 for r in results if r.fixed)
+    failed = total - fixed
+    
+    table = Table(title="Summary")
+    table.add_column("Status", style="bold")
+    table.add_column("Count", justify="right")
+    table.add_row("[green]Fixed[/green]", str(fixed))
+    table.add_row("[red]Failed[/red]", str(failed))
+    table.add_row("Total", str(total))
+    
+    console.print("\n")
+    console.print(table)
+
+def _format_markdown(result):
+    if result.fixed:
+        status = "✅ FIXED"
+    else:
+        status = "❌ NOT FIXED"
+    
+    md = f"## {status}: `{result.test_file}::{result.test_function}`\n\n"
+    md += f"**Error:** `{result.error_message[:100]}...`\n\n"
+    
+    if result.fixed:
+        md += f"**Fixed by:** Updating `{result.fix_type}` in `{result.file_changed}`\n\n"
+        if result.diff:
+            md += f"```diff\n{result.diff}\n```\n"
+    
+    return md
+
+def _format_markdown_summary(results):
+    total = len(results)
+    fixed = sum(1 for r in results if r.fixed)
+    failed = total - fixed
+    
+    md = "## Summary\n\n"
+    md += f"| Status | Count |\n"
+    md += f"|--------|-------|\n"
+    md += f"| ✅ Fixed | {fixed} |\n"
+    md += f"| ❌ Failed | {failed} |\n"
+    md += f"| Total | {total} |\n"
+    
+    return md
+
+def _format_json(result):
+    return {
+        "test_file": result.test_file,
+        "test_function": result.test_function,
+        "error_message": result.error_message,
+        "fixed": result.fixed,
+        "fix_type": result.fix_type,
+        "file_changed": result.file_changed,
+        "diff": result.diff
+    }
+
+def _format_json_summary(results):
+    total = len(results)
+    fixed = sum(1 for r in results if r.fixed)
+    
+    output = {
+        "failures": [_format_json(r) for r in results],
+        "summary": {
+            "total": total,
+            "fixed": fixed,
+            "failed": total - fixed
+        }
+    }
+    
+    return json.dumps(output, indent=2)

unitsauce/prompts.py

@@ -0,0 +1,53 @@
+fix_code_prompt = """
+    You are an expert Python developer fixing a bug in code.
+
+    IMPORTANT RULES:
+    - Return ONLY the fixed function(s), nothing else
+    - Preserve ALL comments - they explain important logic
+    - Keep the same code structure and style
+    - Make the MINIMAL change needed to fix the issue
+    - Do NOT reformat or rewrite working code
+    - Do NOT change variable order or logic flow unless that's the bug
+    - Return all fixed functions in a SINGLE code block, not separate blocks.
+
+    Here are the functions that were modified and may contain the bug:
+    {function_code}
+
+    Here is the git diff showing what changed:
+    {diff}
+
+    Here is the failing test:
+    {test_code}
+
+    Here is the error:
+    {error_message}
+
+    Fix the bug with minimal changes. Preserve all comments.
+    """
+
+fix_test_prompt = """
+    You are an expert Python developer updating a test to match intentional code changes.
+
+    IMPORTANT RULES:
+    - Return ONLY the fixed test function(s), nothing else
+    - Preserve ALL comments - they explain important logic
+    - Keep the same test structure and style
+    - Make the MINIMAL change needed to match new behavior
+    - Do NOT reformat or rewrite working test code
+    - Update assertions to match the new expected values
+    - Return all fixed functions in a SINGLE code block, not separate blocks.
+
+    Here are the source functions that were intentionally changed:
+    {function_code}
+
+    Here is the git diff showing what changed:
+    {diff}
+
+    Here is the failing test that needs updating:
+    {test_code}
+
+    Here is the error:
+    {error_message}
+
+    Update the test to match the new code behavior. Preserve all comments.
+    """

unitsauce/utils.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+import shutil
+import art
+from rich.console import Console
+
+console = Console()
+
+def print_header():
+    text = art.text2art("UnitSauce")
+
+    print("```")
+    print(text.rstrip())
+    print("```")
+    print("*AI-powered test fixer*")
+
+def backup_file(file_path):
+    src = Path(file_path)
+
+    if not src.exists():
+        raise FileNotFoundError(src)
+
+    backup = src.with_suffix(src.suffix + ".bak")
+    shutil.copy2(src, backup)
+
+    return backup

unitsauce-0.1.0.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: unitsauce
+Version: 0.1.0
+Summary: AI-powered test failure analysis and fix suggestions
+Author: Zan Starasinic
+License: MIT
+Project-URL: Homepage, https://github.com/zanstarasinic/unitsauce
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: anthropic
+Requires-Dist: python-dotenv
+Requires-Dist: art
+Requires-Dist: rich
+Requires-Dist: pytest
+Requires-Dist: pytest-json-report
+
+# UnitSauce
+
+AI-powered test fixer for Python projects.
+
+## What it does
+
+Analyzes failing tests, identifies bugs in recent code changes, and suggests fixes using Claude.
+
+## Install
+```bash
+pip install -r requirements.txt
+cp .env.example .env
+# Add your Anthropic API key to .env
+```
+
+## Usage
+```bash
+python main.py /path/to/your/project
+```
+
+The tool will:
+1. Run pytest and detect failures
+2. Analyze git diff to find recent changes
+3. Ask if you want to fix the code or update the test
+4. Generate and apply a fix
+5. Verify the fix works
+
+## Requirements
+
+- Python 3.10+
+- Anthropic API key
+- Project must be a git repository

unitsauce-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+unitsauce/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+unitsauce/analysis.py,sha256=Zz0d-aOr2yI2YG9OoOz7SRNl7Wz-_9meJfwyUKdS_i0,5158
+unitsauce/fixer.py,sha256=3SHjqLbIEPnvzmt_6JwnrfXtVGtwiUJK-zt-e_pe_78,8023
+unitsauce/github.py,sha256=9JfO-a1v9H96_dZUXA1YacVoM_UZZm4NV0ebjU8_1Dg,2746
+unitsauce/main.py,sha256=QLOVhxkmrjYW4IoglR3TChncyXpdoD8_wehAMtAjkOw,2760
+unitsauce/models.py,sha256=l40OcAAoFrysma83A1vpbUi_5uD2Yh5TmGfGzd_AgWc,1001
+unitsauce/output.py,sha256=wLnFEBq0o2Qms0FMOF6Fu7MLWTTBCw-zqFzdMupc7Aw,3447
+unitsauce/prompts.py,sha256=2xaOEkYrXB-XawdJGoJOryaZjGX9YHQPF0bapnfsS8U,1708
+unitsauce/utils.py,sha256=-XnwUGgsydBalq4GtSV0GJ63PeiPkf6jZBCs2BykxWw,476
+unitsauce-0.1.0.dist-info/METADATA,sha256=NFBhV4L4CSi2qwJXoNJwb4AhXq0pRUioPykhzxkVgoc,1062
+unitsauce-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+unitsauce-0.1.0.dist-info/entry_points.txt,sha256=QFdjrO3Rj2jkNqfwe0aY8JT5gYbHOWPPkvwxAsVynu8,50
+unitsauce-0.1.0.dist-info/top_level.txt,sha256=44KP-G6eKDbMYc6daSbp1vcEDez-Q99MEWNqGL3Tx5E,10
+unitsauce-0.1.0.dist-info/RECORD,,

unitsauce-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

unitsauce-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+unitsauce = unitsauce.main:main

unitsauce-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+unitsauce