fixforward 0.1.0__py3-none-any.whl

fixforward/__init__.py

@@ -0,0 +1,3 @@
+"""FixForward: incident-to-PR autopilot powered by GitHub Copilot CLI."""
+
+__version__ = "0.1.0"

fixforward/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as python -m fixforward."""
+
+from fixforward.cli import main
+
+main()

fixforward/classifier.py

@@ -0,0 +1,133 @@
+"""Failure classification engine using regex heuristics."""
+
+import re
+from enum import Enum
+from dataclasses import dataclass
+from typing import List
+
+from fixforward.detector import TestFailure, Ecosystem
+
+
+class FailureCategory(Enum):
+    SYNTAX_ERROR = "syntax_error"
+    DEPENDENCY = "dependency"
+    ENV_MISMATCH = "env_mismatch"
+    API_CHANGE = "api_change"
+    LINT = "lint"
+    FLAKY_TEST = "flaky_test"
+    ASSERTION = "assertion"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class ClassifiedFailure:
+    failure: TestFailure
+    category: FailureCategory
+    confidence: float
+    summary: str
+
+
+# Classification rules in priority order (first match wins).
+# Each rule: (category, confidence, [(pattern, summary_template)])
+RULES = [
+    (FailureCategory.SYNTAX_ERROR, 0.95, [
+        (r"SyntaxError:\s*(.+)", "Syntax error: {0}"),
+        (r"IndentationError:\s*(.+)", "Indentation error: {0}"),
+        (r"Unexpected token\s*(.+)", "Unexpected token: {0}"),
+        (r"parse error", "Parse error"),
+        (r"expected\s+.+,\s+found\s+(.+)", "Expected/found mismatch: {0}"),
+    ]),
+    (FailureCategory.DEPENDENCY, 0.90, [
+        (r"ModuleNotFoundError:\s*No module named '(\S+)'", "Missing module: {0}"),
+        (r"ImportError:\s*(.+)", "Import error: {0}"),
+        (r"Cannot find module '(\S+)'", "Missing Node module: {0}"),
+        (r"No module named '?(\S+?)'?", "Missing module: {0}"),
+        (r"unresolved import `(\S+)`", "Unresolved import: {0}"),
+        (r"package `(\S+)`.+not found", "Missing Rust crate: {0}"),
+        (r"Could not find a version that satisfies", "Dependency version conflict"),
+    ]),
+    (FailureCategory.ENV_MISMATCH, 0.80, [
+        (r"version mismatch", "Version mismatch"),
+        (r"requires Python\s*([\d.]+)", "Requires Python {0}"),
+        (r"engine .+ is incompatible", "Engine incompatible"),
+        (r"ENOENT.+?'(\S+)'", "Command not found: {0}"),
+        (r"command not found:\s*(\S+)", "Command not found: {0}"),
+        (r"minimum supported rust version", "Rust version too old"),
+    ]),
+    (FailureCategory.API_CHANGE, 0.85, [
+        (r"AttributeError:\s*'?(\w+)'?\s+object has no attribute '(\w+)'",
+         "{0} has no attribute '{1}'"),
+        (r"TypeError:\s*(\w+)\(\) (?:got an unexpected|missing \d+ required|takes \d+)",
+         "Wrong arguments for {0}()"),
+        (r"missing \d+ required (?:positional )?argument", "Missing required argument"),
+        (r"has no member named `(\w+)`", "No member: {0}"),
+        (r"no method named `(\w+)`", "No method: {0}"),
+        (r"is not a function", "Not a function"),
+        (r"is not defined", "Not defined"),
+    ]),
+    (FailureCategory.LINT, 0.75, [
+        (r"flake8", "Flake8 lint error"),
+        (r"eslint", "ESLint error"),
+        (r"clippy", "Clippy warning"),
+        (r"warning\[(\w+)\]", "Compiler warning: {0}"),
+        (r"formatting.+differ", "Formatting difference"),
+    ]),
+    (FailureCategory.FLAKY_TEST, 0.60, [
+        (r"timeout|timed?\s*out", "Test timed out"),
+        (r"flaky", "Flaky test"),
+        (r"intermittent", "Intermittent failure"),
+        (r"connection refused", "Connection refused"),
+        (r"ECONNRESET", "Connection reset"),
+        (r"Resource temporarily unavailable", "Resource unavailable"),
+    ]),
+    (FailureCategory.ASSERTION, 0.85, [
+        (r"AssertionError:\s*assert\s+(.+)", "Assertion failed: {0}"),
+        (r"AssertionError:\s*(.+)", "Assertion: {0}"),
+        (r"assert\s+[\d.]+\s*==\s*[\d.]+", "Assertion: value mismatch"),
+        (r"assert\s+(.+?)\s*==\s*(.+)", "Assertion: {0} != {1}"),
+        (r"assert_eq!.+left:\s*`(.+?)`,\s*right:\s*`(.+?)`",
+         "assert_eq! left={0}, right={1}"),
+        (r"expect\(.+\)\.to(?:Equal|Be)\((.+?)\)", "Expected {0}"),
+        (r"Expected\s+(.+?)\s+to (?:equal|be)\s+(.+)", "Expected {1}, got {0}"),
+        (r"expected:\s*(.+?)\s+but was:\s*(.+)", "Expected {0}, got {1}"),
+        (r"!=\s", "Value mismatch"),
+        (r"AssertionError", "Assertion error"),
+    ]),
+]
+
+
+def classify(
+    failures: List[TestFailure],
+    ecosystem: Ecosystem,
+) -> List[ClassifiedFailure]:
+    """Classify each test failure by category."""
+    return [_classify_one(f) for f in failures]
+
+
+def _classify_one(failure: TestFailure) -> ClassifiedFailure:
+    """Classify a single failure."""
+    text = f"{failure.error_message}\n{failure.full_output}"
+
+    for category, base_confidence, patterns in RULES:
+        for pattern, summary_template in patterns:
+            m = re.search(pattern, text, re.IGNORECASE)
+            if m:
+                try:
+                    summary = summary_template.format(*m.groups())
+                except (IndexError, KeyError):
+                    summary = summary_template
+                return ClassifiedFailure(
+                    failure=failure,
+                    category=category,
+                    confidence=base_confidence,
+                    summary=summary,
+                )
+
+    # No match
+    error_preview = failure.error_message[:80] if failure.error_message else "Unknown error"
+    return ClassifiedFailure(
+        failure=failure,
+        category=FailureCategory.UNKNOWN,
+        confidence=0.3,
+        summary=error_preview,
+    )

fixforward/cli.py

@@ -0,0 +1,222 @@
+"""CLI entry point for FixForward."""
+
+import argparse
+import sys
+import json
+
+from fixforward import __version__
+from fixforward.display import Display
+from fixforward.detector import detect, run_tests, Ecosystem
+from fixforward.classifier import classify
+from fixforward.copilot import generate_patch, explain_failure, CopilotError
+from fixforward.patcher import apply_patch, PatchError
+from fixforward.verifier import verify
+from fixforward.reporter import generate_report
+from fixforward.state import rollback, RollbackError
+
+
+def _cmd_run(args):
+    """Full autopilot: detect -> classify -> patch -> verify -> report."""
+    display = Display(animate=not args.no_animate)
+    display.show_banner()
+
+    # Step 1: Detect ecosystem
+    display.step(1, "Detecting project ecosystem...")
+    try:
+        ecosystem = detect(args.path)
+    except Exception as e:
+        display.error(f"Detection failed: {e}")
+        sys.exit(1)
+    display.ecosystem_found(ecosystem)
+
+    # Step 2: Run tests
+    display.step(2, "Running tests to capture failures...")
+    result = run_tests(args.path, ecosystem)
+
+    if result.passed:
+        display.all_tests_pass(result)
+        return
+
+    display.failures_found(result)
+
+    # Step 3: Classify failures
+    display.step(3, "Classifying failures...")
+    classifications = classify(result.failures, ecosystem)
+    display.show_classifications(classifications)
+
+    if args.dry_run:
+        display.dry_run_summary(classifications)
+        return
+
+    # Step 4: Generate patch via Copilot CLI
+    display.step(4, "Asking GitHub Copilot for a fix...")
+    try:
+        patch = generate_patch(
+            failures=classifications,
+            project_path=args.path,
+            ecosystem=ecosystem,
+            verbose=args.verbose,
+        )
+    except CopilotError as e:
+        display.error(f"Copilot failed: {e}")
+        sys.exit(1)
+
+    display.show_patch_preview(patch)
+
+    # Confirm
+    if not args.no_confirm:
+        if not display.confirm_apply():
+            display.aborted()
+            return
+
+    # Step 5: Apply patch
+    display.step(5, "Applying patch on a safe branch...")
+    try:
+        branch_info = apply_patch(patch, args.path)
+    except PatchError as e:
+        display.error(f"Patch failed: {e}")
+        sys.exit(1)
+    display.patch_applied(branch_info)
+
+    # Step 6: Verify
+    display.step(6, "Re-running tests to verify fix...")
+    verify_result = verify(args.path, ecosystem, result)
+    display.show_verification(verify_result)
+
+    # Generate report
+    pr_info = generate_report(
+        classifications=classifications,
+        patch=patch,
+        verify_result=verify_result,
+        ecosystem=ecosystem,
+    )
+    display.show_pr_report(pr_info)
+    display.done()
+
+
+def _cmd_diagnose(args):
+    """Detect and classify failures without fixing."""
+    display = Display(animate=not getattr(args, "no_animate", False))
+    display.show_banner()
+
+    display.step(1, "Detecting project ecosystem...")
+    try:
+        ecosystem = detect(args.path)
+    except Exception as e:
+        display.error(f"Detection failed: {e}")
+        sys.exit(1)
+    display.ecosystem_found(ecosystem)
+
+    display.step(2, "Running tests to capture failures...")
+    result = run_tests(args.path, ecosystem)
+
+    if result.passed:
+        display.all_tests_pass(result)
+        return
+
+    display.failures_found(result)
+
+    display.step(3, "Classifying failures...")
+    classifications = classify(result.failures, ecosystem)
+
+    if getattr(args, "json_output", False):
+        data = [
+            {
+                "test": c.failure.test_name,
+                "file": c.failure.file_path,
+                "line": c.failure.line_number,
+                "category": c.category.value,
+                "confidence": c.confidence,
+                "summary": c.summary,
+                "error": c.failure.error_message,
+            }
+            for c in classifications
+        ]
+        print(json.dumps(data, indent=2))
+    else:
+        display.show_classifications(classifications)
+
+        # Ask Copilot to explain each failure
+        display.step(4, "Asking Copilot to explain failures...")
+        for c in classifications:
+            try:
+                explanation = explain_failure(c, args.path)
+                display.show_explanation(c, explanation)
+            except CopilotError:
+                display.show_explanation(c, "(Copilot CLI unavailable)")
+
+    display.diagnose_done()
+
+
+def _cmd_rollback(args):
+    """Undo the last fixforward patch."""
+    display = Display(animate=False)
+    display.show_banner()
+
+    try:
+        info = rollback(args.path)
+        display.rollback_success(info)
+    except RollbackError as e:
+        display.error(f"Rollback failed: {e}")
+        sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="fixforward",
+        description="Incident-to-PR autopilot powered by GitHub Copilot CLI.",
+    )
+    parser.add_argument(
+        "--version", "-v", action="version", version=f"fixforward {__version__}"
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # run command
+    run_parser = subparsers.add_parser("run", help="Full autopilot: detect, fix, verify, report")
+    run_parser.add_argument("--path", "-p", default=".", help="Path to the project (default: .)")
+    run_parser.add_argument("--dry-run", "-n", action="store_true", help="Show plan without executing")
+    run_parser.add_argument("--no-confirm", action="store_true", help="Skip patch confirmation prompt")
+    run_parser.add_argument("--no-animate", action="store_true", help="Disable animations")
+    run_parser.add_argument("--verbose", action="store_true", help="Show raw Copilot output")
+
+    # diagnose command
+    diag_parser = subparsers.add_parser("diagnose", help="Detect and classify failures only")
+    diag_parser.add_argument("--path", "-p", default=".", help="Path to the project (default: .)")
+    diag_parser.add_argument("--json", dest="json_output", action="store_true", help="Output as JSON")
+    diag_parser.add_argument("--no-animate", action="store_true", help="Disable animations")
+
+    # rollback command
+    rb_parser = subparsers.add_parser("rollback", help="Undo the last fixforward patch")
+    rb_parser.add_argument("--path", "-p", default=".", help="Path to the project (default: .)")
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        # Default to run
+        args.command = "run"
+        args.path = "."
+        args.dry_run = False
+        args.no_confirm = False
+        args.no_animate = False
+        args.verbose = False
+
+    commands = {
+        "run": _cmd_run,
+        "diagnose": _cmd_diagnose,
+        "rollback": _cmd_rollback,
+    }
+
+    try:
+        commands[args.command](args)
+    except KeyboardInterrupt:
+        print("\nAborted.")
+        sys.exit(130)
+    except Exception as e:
+        from rich.console import Console
+        Console(stderr=True).print(f"[bold red]Error:[/] {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

fixforward/copilot.py

@@ -0,0 +1,287 @@
+"""GitHub Copilot CLI integration layer."""
+
+import subprocess
+import re
+import difflib
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+
+from fixforward.detector import Ecosystem
+from fixforward.classifier import ClassifiedFailure
+
+
+class CopilotError(Exception):
+    pass
+
+
+@dataclass
+class FileChange:
+    file_path: str
+    original_content: str
+    modified_content: str
+    diff: str
+
+
+@dataclass
+class PatchResult:
+    changes: List[FileChange]
+    explanation: str
+    raw_copilot_output: str
+
+
+def generate_patch(
+    failures: List[ClassifiedFailure],
+    project_path: str,
+    ecosystem: Ecosystem,
+    verbose: bool = False,
+) -> PatchResult:
+    """Ask Copilot CLI to generate a fix for classified failures."""
+    prompt = _build_fix_prompt(failures, project_path, ecosystem)
+
+    raw_output = _run_copilot(prompt, project_path)
+
+    if verbose:
+        from rich.console import Console
+        Console(stderr=True).print(f"[dim]Copilot raw output:\n{raw_output}[/]")
+
+    # Parse response into file changes
+    changes = _parse_response(raw_output, project_path)
+    explanation = _extract_explanation(raw_output)
+
+    if not changes:
+        raise CopilotError(
+            "Copilot did not produce any file changes. "
+            "Try running again or fixing manually."
+        )
+
+    return PatchResult(
+        changes=changes,
+        explanation=explanation,
+        raw_copilot_output=raw_output,
+    )
+
+
+def explain_failure(
+    classification: ClassifiedFailure,
+    project_path: str,
+) -> str:
+    """Ask Copilot CLI to explain a failure."""
+    prompt = (
+        f"Explain this test failure concisely:\n"
+        f"Test: {classification.failure.test_name}\n"
+        f"File: {classification.failure.file_path}\n"
+        f"Error: {classification.failure.error_message}\n"
+        f"Category: {classification.category.value}\n\n"
+        f"What is the likely root cause and how should it be fixed?"
+    )
+
+    try:
+        return _run_copilot(prompt, project_path)
+    except CopilotError:
+        return f"({classification.category.value}) {classification.summary}"
+
+
+def _run_copilot(prompt: str, project_path: str, allow_write: bool = False) -> str:
+    """Execute gh copilot in non-interactive mode with -p flag."""
+    # Check if gh is available
+    try:
+        check = subprocess.run(
+            ["gh", "copilot", "--", "--version"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except FileNotFoundError:
+        raise CopilotError(
+            "GitHub CLI (gh) is not installed. "
+            "Install it from: https://cli.github.com/"
+        )
+
+    # Build the command using non-interactive prompt mode
+    # gh copilot -- -p "prompt" --allow-all-tools --add-dir <path> --quiet
+    cmd = [
+        "gh", "copilot", "--",
+        "-p", prompt,
+        "--allow-all-tools",
+        "--add-dir", str(Path(project_path).resolve()),
+        "--silent",
+    ]
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            cwd=str(Path(project_path).resolve()),
+            timeout=180,
+        )
+    except subprocess.TimeoutExpired:
+        raise CopilotError("Copilot CLI timed out after 180 seconds.")
+
+    output = result.stdout + result.stderr
+    if not output.strip():
+        raise CopilotError("Copilot returned empty response.")
+
+    return output.strip()
+
+
+def _build_fix_prompt(
+    failures: List[ClassifiedFailure],
+    project_path: str,
+    ecosystem: Ecosystem,
+) -> str:
+    """Build a prompt for Copilot to generate a fix."""
+    failure_descriptions = []
+    source_context = []
+
+    for f in failures[:3]:  # Limit to top 3 failures
+        desc = (
+            f"- [{f.category.value}] {f.failure.test_name}\n"
+            f"  File: {f.failure.file_path}"
+        )
+        if f.failure.line_number:
+            desc += f":{f.failure.line_number}"
+        desc += f"\n  Error: {f.failure.error_message}"
+        failure_descriptions.append(desc)
+
+        # Read source file for context
+        src_path = Path(project_path) / f.failure.file_path
+        if src_path.exists():
+            try:
+                content = src_path.read_text()
+                source_context.append(
+                    f"--- {f.failure.file_path} ---\n{content}"
+                )
+            except Exception:
+                pass
+
+    failures_text = "\n".join(failure_descriptions)
+    sources_text = "\n\n".join(source_context) if source_context else "(no source files read)"
+
+    return (
+        f"I have a {ecosystem.value} project with failing tests. "
+        f"Generate a minimal fix.\n\n"
+        f"FAILURES:\n{failures_text}\n\n"
+        f"SOURCE FILES:\n{sources_text}\n\n"
+        f"Generate the smallest possible code change to fix these failures. "
+        f"Show the complete corrected file content for each file that needs changes. "
+        f"Format each fix as:\n"
+        f"FILE: <filepath>\n"
+        f"```\n<complete corrected file content>\n```\n\n"
+        f"Then explain what you changed and why."
+    )
+
+
+def _parse_response(raw_output: str, project_path: str) -> List[FileChange]:
+    """Parse Copilot's response to extract file changes."""
+    changes = []
+
+    # Strategy 1: Look for FILE: <path> followed by code blocks
+    # Handle markdown bold: **FILE: app.py** or FILE: app.py
+    file_pattern = re.compile(
+        r"\*{0,2}FILE:\s*(.+?)\*{0,2}\s*\n\s*```\w*\n(.+?)```",
+        re.DOTALL,
+    )
+    for m in file_pattern.finditer(raw_output):
+        file_path = m.group(1).strip().strip("*")
+        new_content = m.group(2)
+
+        original_path = Path(project_path) / file_path
+        original_content = ""
+        if original_path.exists():
+            original_content = original_path.read_text()
+
+        if new_content.strip() != original_content.strip():
+            diff = _make_diff(file_path, original_content, new_content)
+            changes.append(FileChange(
+                file_path=file_path,
+                original_content=original_content,
+                modified_content=new_content,
+                diff=diff,
+            ))
+
+    # Strategy 2: Look for diff blocks
+    if not changes:
+        diff_pattern = re.compile(r"```diff\n(.+?)```", re.DOTALL)
+        for m in diff_pattern.finditer(raw_output):
+            diff_text = m.group(1)
+            # Try to extract filename from diff header
+            file_match = re.search(r"[+-]{3}\s+[ab]/(.+)", diff_text)
+            if file_match:
+                file_path = file_match.group(1).strip()
+                changes.append(FileChange(
+                    file_path=file_path,
+                    original_content="",
+                    modified_content="",
+                    diff=diff_text,
+                ))
+
+    # Strategy 3: Look for any code blocks with identifiable file content
+    if not changes:
+        code_pattern = re.compile(r"```(\w+)\n(.+?)```", re.DOTALL)
+        for m in code_pattern.finditer(raw_output):
+            lang = m.group(1)
+            content = m.group(2)
+
+            # Try to match against existing project files
+            ext_map = {"python": ".py", "javascript": ".js", "rust": ".rs",
+                       "py": ".py", "js": ".js", "rs": ".rs"}
+            ext = ext_map.get(lang, "")
+            if ext:
+                project = Path(project_path)
+                for src_file in project.rglob(f"*{ext}"):
+                    if src_file.is_file():
+                        original = src_file.read_text()
+                        # Check if this looks like a modified version
+                        similarity = difflib.SequenceMatcher(
+                            None, original, content
+                        ).ratio()
+                        if 0.5 < similarity < 1.0:
+                            rel_path = str(src_file.relative_to(project))
+                            diff = _make_diff(rel_path, original, content)
+                            changes.append(FileChange(
+                                file_path=rel_path,
+                                original_content=original,
+                                modified_content=content,
+                                diff=diff,
+                            ))
+                            break
+
+    return changes
+
+
+def _extract_explanation(raw_output: str) -> str:
+    """Extract the explanation section from Copilot's response."""
+    # Look for common markers
+    markers = [
+        r"(?:explanation|what changed|changes made|summary):?\s*\n(.+)",
+        r"(?:I changed|I fixed|The fix|This fixes|The issue).+",
+    ]
+    for pattern in markers:
+        m = re.search(pattern, raw_output, re.IGNORECASE | re.DOTALL)
+        if m:
+            text = m.group(0) if m.lastindex is None else m.group(1)
+            # Trim to reasonable length
+            lines = text.strip().splitlines()
+            return "\n".join(lines[:10])
+
+    # Fallback: last paragraph
+    paragraphs = raw_output.strip().split("\n\n")
+    if paragraphs:
+        return paragraphs[-1][:500]
+    return ""
+
+
+def _make_diff(file_path: str, original: str, modified: str) -> str:
+    """Generate a unified diff string."""
+    original_lines = original.splitlines(keepends=True)
+    modified_lines = modified.splitlines(keepends=True)
+    diff = difflib.unified_diff(
+        original_lines,
+        modified_lines,
+        fromfile=f"a/{file_path}",
+        tofile=f"b/{file_path}",
+        lineterm="",
+    )
+    return "".join(diff)