fixfleet 0.3.0__py3-none-any.whl

bugfixer/__init__.py

@@ -0,0 +1,6 @@
+"""FixFleet — Fleet of AI agents fixing GitLab bugs."""
+
+__version__ = "0.3.0"
+__name_pretty__ = "FixFleet"
+__tagline__ = "Fleet of AI agents fixing GitLab bugs"
+__author__ = "Yash Koladiya"

bugfixer/backends/__init__.py

@@ -0,0 +1 @@
+"""Pluggable backends — CLI tools and API clients that fix bugs."""

bugfixer/backends/_subprocess.py

@@ -0,0 +1,82 @@
+"""Shared subprocess runner with stdout tee (live print + capture)."""
+
+import os
+import subprocess
+import sys
+import threading
+import time
+from typing import List
+
+from .base import RunResult
+
+
+def run_with_tee(cmd: List[str], cwd: str, timeout: int = 600,
+                 stdin_data: str = None, env: dict = None) -> RunResult:
+    """Run subprocess, stream stdout/stderr to terminal, also capture for parsing."""
+
+    captured_out: list = []
+    captured_err: list = []
+
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            cwd=cwd,
+            stdin=subprocess.PIPE if stdin_data is not None else None,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1,
+            env={**os.environ, **(env or {})},
+        )
+    except FileNotFoundError as e:
+        return RunResult(returncode=127, stderr=str(e))
+
+    if stdin_data is not None:
+        try:
+            proc.stdin.write(stdin_data)
+            proc.stdin.close()
+        except (BrokenPipeError, OSError):
+            pass
+
+    def reader(stream, sink_list, dest):
+        try:
+            for line in iter(stream.readline, ""):
+                sink_list.append(line)
+                dest.write(line)
+                dest.flush()
+        finally:
+            try:
+                stream.close()
+            except Exception:
+                pass
+
+    t_out = threading.Thread(target=reader, args=(proc.stdout, captured_out, sys.stdout), daemon=True)
+    t_err = threading.Thread(target=reader, args=(proc.stderr, captured_err, sys.stderr), daemon=True)
+    t_out.start()
+    t_err.start()
+
+    deadline = time.time() + timeout
+    while True:
+        rc = proc.poll()
+        if rc is not None:
+            break
+        if time.time() > deadline:
+            proc.kill()
+            t_out.join(timeout=2)
+            t_err.join(timeout=2)
+            return RunResult(
+                returncode=-1,
+                stdout="".join(captured_out),
+                stderr="".join(captured_err),
+                timed_out=True,
+            )
+        time.sleep(0.1)
+
+    t_out.join(timeout=2)
+    t_err.join(timeout=2)
+
+    return RunResult(
+        returncode=proc.returncode,
+        stdout="".join(captured_out),
+        stderr="".join(captured_err),
+    )

bugfixer/backends/api/__init__.py

@@ -0,0 +1 @@
+"""API-based backends (HTTP clients to LLM providers)."""

bugfixer/backends/api/openai_compat.py

@@ -0,0 +1,183 @@
+"""OpenAI-compatible API backend.
+
+Works with: Groq, OpenRouter, Gemini (compat endpoint), Cerebras, Mistral,
+Together, DeepSeek, Ollama (localhost), LM Studio, vLLM, etc.
+
+Strategy: send prompt + a hint about repo structure, expect a unified diff
+back. Apply the diff with `git apply` (or `patch`) inside project_dir.
+No agentic tool-use loop — keeps token usage minimal.
+"""
+
+import json
+import re
+import subprocess
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+from ..base import Backend, RunResult
+
+
+SYSTEM_PROMPT = """You are an expert software engineer fixing bugs in a codebase.
+
+You CANNOT execute tools. You will be given a bug description and a list of likely-relevant files (with their contents inlined where possible). Output a fix as a unified diff.
+
+OUTPUT FORMAT (strict):
+1. Brief explanation (2-4 lines) of the root cause.
+2. A unified diff inside a single fenced block tagged ```diff
+3. End with the FIX REPORT block exactly as instructed in the user prompt.
+
+The diff MUST:
+- Use standard unified-diff format (--- a/path, +++ b/path, @@ hunks).
+- Use forward-slash paths relative to the repo root.
+- Include enough context (3 lines) for `git apply` to work.
+- Not contain any prose between the fence markers.
+"""
+
+
+class OpenAICompatBackend(Backend):
+    name = "openai_compat"
+    display_name = "OpenAI-Compatible API"
+    requires_binary = ""  # network-only
+
+    def __init__(self, base_url: str, api_key: str, model: str,
+                 max_output_tokens: int = 4096, temperature: float = 0.1,
+                 apply_diff: bool = True):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.model = model
+        self.max_output_tokens = max_output_tokens
+        self.temperature = temperature
+        self.apply_diff = apply_diff
+
+    def available(self) -> bool:
+        return bool(self.base_url) and bool(self.model)
+
+    def version(self) -> str:
+        return f"{self.model} @ {self.base_url}"
+
+    def _chat(self, messages: list, timeout: int) -> dict:
+        url = f"{self.base_url}/chat/completions"
+        body = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+        }
+        data = json.dumps(body).encode()
+        req = urllib.request.Request(
+            url,
+            data=data,
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.api_key}" if self.api_key else "",
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read().decode())
+
+    def run(self, prompt: str, project_dir: str, timeout: int = 600) -> RunResult:
+        messages = [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": prompt},
+        ]
+
+        try:
+            response = self._chat(messages, timeout=timeout)
+        except urllib.error.HTTPError as e:
+            err_body = e.read().decode(errors="ignore")
+            return RunResult(returncode=e.code, stderr=f"HTTP {e.code}: {err_body[:500]}")
+        except urllib.error.URLError as e:
+            return RunResult(returncode=2, stderr=f"Network error: {e.reason}")
+        except Exception as e:
+            return RunResult(returncode=3, stderr=f"Unexpected error: {e}")
+
+        try:
+            content = response["choices"][0]["message"]["content"] or ""
+        except (KeyError, IndexError):
+            return RunResult(returncode=4, stderr=f"Bad response shape: {json.dumps(response)[:500]}")
+
+        # Echo to user so they can read the model's reasoning live.
+        print(content, flush=True)
+
+        usage = response.get("usage", {}) or {}
+        token_summary = (
+            f"\n[tokens] prompt={usage.get('prompt_tokens', '?')} "
+            f"completion={usage.get('completion_tokens', '?')} "
+            f"total={usage.get('total_tokens', '?')}\n"
+        )
+        print(token_summary, file=sys.stderr, flush=True)
+
+        if not self.apply_diff:
+            return RunResult(returncode=0, stdout=content)
+
+        diff = _extract_diff(content)
+        if not diff:
+            # Model didn't produce a diff — surface to user but treat as no-op fail.
+            return RunResult(
+                returncode=5,
+                stdout=content,
+                stderr="Model did not return a unified diff. No changes applied.",
+            )
+
+        rc, msg = _apply_diff(diff, project_dir)
+        if rc != 0:
+            return RunResult(returncode=rc, stdout=content, stderr=f"Diff apply failed: {msg}")
+
+        return RunResult(returncode=0, stdout=content + "\n[diff applied successfully]")
+
+
+# ── Diff extraction + apply ────────────────────────────────────
+
+DIFF_FENCE_RE = re.compile(r"```(?:diff|patch)?\s*\n(.*?)\n```", re.DOTALL)
+
+
+def _extract_diff(text: str) -> str:
+    """Pull the first fenced diff block out of the model output."""
+    matches = DIFF_FENCE_RE.findall(text)
+    for m in matches:
+        if "---" in m and "+++" in m and "@@" in m:
+            return m.strip() + "\n"
+    # Fallback: maybe model emitted raw diff without fences
+    if text.lstrip().startswith("---") and "+++" in text:
+        return text.strip() + "\n"
+    return ""
+
+
+def _apply_diff(diff_text: str, project_dir: str) -> tuple:
+    """Try `git apply`, fall back to `patch -p1`. Return (rc, message)."""
+    project = Path(project_dir)
+
+    # Use stdin to feed the diff
+    try:
+        result = subprocess.run(
+            ["git", "apply", "--whitespace=fix", "-"],
+            input=diff_text,
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if result.returncode == 0:
+            return 0, "git apply succeeded"
+        git_err = result.stderr
+    except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+        git_err = str(e)
+
+    # Try patch as fallback
+    try:
+        result = subprocess.run(
+            ["patch", "-p1", "--forward"],
+            input=diff_text,
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if result.returncode == 0:
+            return 0, "patch succeeded"
+        return result.returncode, f"git apply: {git_err}; patch: {result.stderr}"
+    except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+        return 1, f"git apply: {git_err}; patch unavailable: {e}"

bugfixer/backends/base.py

@@ -0,0 +1,52 @@
+"""Backend interface contract."""
+
+import shutil
+import subprocess
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+
+@dataclass
+class RunResult:
+    returncode: int
+    stdout: str = ""
+    stderr: str = ""
+    timed_out: bool = False
+    skipped: bool = False
+    skip_reason: str = ""
+
+    @property
+    def ok(self) -> bool:
+        return self.returncode == 0 and not self.timed_out and not self.skipped
+
+
+class Backend(ABC):
+    """Abstract backend. Implementations wrap a CLI or API."""
+
+    name: str = "base"
+    display_name: str = "Base"
+    requires_binary: str = ""  # name of binary on PATH, empty = no requirement
+
+    def available(self) -> bool:
+        """Return True if backend can be used right now (binary present, key set, etc)."""
+        if self.requires_binary:
+            return shutil.which(self.requires_binary) is not None
+        return True
+
+    def version(self) -> str:
+        """Best-effort version string. Empty if unknown."""
+        if not self.requires_binary:
+            return ""
+        try:
+            out = subprocess.run(
+                [self.requires_binary, "--version"],
+                capture_output=True, text=True, timeout=5,
+            )
+            return (out.stdout or out.stderr).strip().splitlines()[0] if (out.stdout or out.stderr) else ""
+        except Exception:
+            return ""
+
+    @abstractmethod
+    def run(self, prompt: str, project_dir: str, timeout: int = 600) -> RunResult:
+        """Execute the backend against `prompt` inside `project_dir`. Return RunResult."""
+        raise NotImplementedError

bugfixer/backends/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI-based backends (subprocess wrappers around installed CLI tools)."""

bugfixer/backends/cli/aider.py

@@ -0,0 +1,25 @@
+"""Aider CLI backend."""
+
+from ..base import Backend, RunResult
+from .._subprocess import run_with_tee
+
+
+class AiderCLIBackend(Backend):
+    name = "aider"
+    display_name = "Aider"
+    requires_binary = "aider"
+
+    def run(self, prompt: str, project_dir: str, timeout: int = 600) -> RunResult:
+        # --yes-always: skip all confirmations.
+        # --no-auto-commits: bug fixer manages commits manually (user reviews).
+        # --map-tokens 1024: tighter repo map to save tokens.
+        # --no-stream: simpler stdout to capture.
+        cmd = [
+            "aider",
+            "--message", prompt,
+            "--yes-always",
+            "--no-auto-commits",
+            "--map-tokens", "1024",
+            "--no-stream",
+        ]
+        return run_with_tee(cmd, cwd=project_dir, timeout=timeout)

bugfixer/backends/cli/claude.py

@@ -0,0 +1,22 @@
+"""Claude Code CLI backend."""
+
+from ..base import Backend, RunResult
+from .._subprocess import run_with_tee
+
+
+class ClaudeCLIBackend(Backend):
+    name = "claude"
+    display_name = "Claude Code (Anthropic)"
+    requires_binary = "claude"
+
+    DEFAULT_ALLOWED_TOOLS = "Read,Edit,Write,Grep,Glob,Bash"
+
+    def run(self, prompt: str, project_dir: str, timeout: int = 600) -> RunResult:
+        cmd = [
+            "claude",
+            "--print",
+            prompt,
+            "--allowedTools",
+            self.DEFAULT_ALLOWED_TOOLS,
+        ]
+        return run_with_tee(cmd, cwd=project_dir, timeout=timeout)

bugfixer/backends/cli/codex.py

@@ -0,0 +1,20 @@
+"""OpenAI Codex CLI backend."""
+
+from ..base import Backend, RunResult
+from .._subprocess import run_with_tee
+
+
+class CodexCLIBackend(Backend):
+    name = "codex"
+    display_name = "Codex (OpenAI)"
+    requires_binary = "codex"
+
+    def run(self, prompt: str, project_dir: str, timeout: int = 600) -> RunResult:
+        # `codex exec` is the non-interactive mode; --full-auto auto-approves edits within sandbox.
+        cmd = [
+            "codex",
+            "exec",
+            "--full-auto",
+            prompt,
+        ]
+        return run_with_tee(cmd, cwd=project_dir, timeout=timeout)

bugfixer/backends/cli/cursor.py

@@ -0,0 +1,19 @@
+"""Cursor Agent CLI backend."""
+
+from ..base import Backend, RunResult
+from .._subprocess import run_with_tee
+
+
+class CursorAgentBackend(Backend):
+    name = "cursor"
+    display_name = "Cursor Agent"
+    requires_binary = "cursor-agent"
+
+    def run(self, prompt: str, project_dir: str, timeout: int = 600) -> RunResult:
+        # -p / --print prints output non-interactively.
+        cmd = [
+            "cursor-agent",
+            "-p",
+            prompt,
+        ]
+        return run_with_tee(cmd, cwd=project_dir, timeout=timeout)

bugfixer/backends/cli/gemini.py

@@ -0,0 +1,20 @@
+"""Google Gemini CLI backend."""
+
+from ..base import Backend, RunResult
+from .._subprocess import run_with_tee
+
+
+class GeminiCLIBackend(Backend):
+    name = "gemini"
+    display_name = "Gemini CLI (Google)"
+    requires_binary = "gemini"
+
+    def run(self, prompt: str, project_dir: str, timeout: int = 600) -> RunResult:
+        # --yolo auto-approves all tool calls.
+        cmd = [
+            "gemini",
+            "--yolo",
+            "-p",
+            prompt,
+        ]
+        return run_with_tee(cmd, cwd=project_dir, timeout=timeout)

bugfixer/backends/cli/qwen.py

@@ -0,0 +1,19 @@
+"""Qwen Code CLI backend (forked from Gemini CLI)."""
+
+from ..base import Backend, RunResult
+from .._subprocess import run_with_tee
+
+
+class QwenCLIBackend(Backend):
+    name = "qwen"
+    display_name = "Qwen Code (Alibaba)"
+    requires_binary = "qwen"
+
+    def run(self, prompt: str, project_dir: str, timeout: int = 600) -> RunResult:
+        cmd = [
+            "qwen",
+            "--yolo",
+            "-p",
+            prompt,
+        ]
+        return run_with_tee(cmd, cwd=project_dir, timeout=timeout)

bugfixer/backends/registry.py

@@ -0,0 +1,87 @@
+"""Backend registry — list, detect, instantiate."""
+
+from .api.openai_compat import OpenAICompatBackend
+from .base import Backend
+from .cli.aider import AiderCLIBackend
+from .cli.claude import ClaudeCLIBackend
+from .cli.codex import CodexCLIBackend
+from .cli.cursor import CursorAgentBackend
+from .cli.gemini import GeminiCLIBackend
+from .cli.qwen import QwenCLIBackend
+
+
+CLI_BACKENDS = [
+    ClaudeCLIBackend,
+    CodexCLIBackend,
+    GeminiCLIBackend,
+    CursorAgentBackend,
+    AiderCLIBackend,
+    QwenCLIBackend,
+]
+
+
+def list_cli_backends() -> list:
+    """Instantiate all CLI backend classes (regardless of availability)."""
+    return [cls() for cls in CLI_BACKENDS]
+
+
+def detect_available_clis() -> list:
+    """Return only CLI backends whose binary is on PATH."""
+    return [b for b in list_cli_backends() if b.available()]
+
+
+def detect_unavailable_clis() -> list:
+    """Return CLI backends whose binary is missing (for display)."""
+    return [b for b in list_cli_backends() if not b.available()]
+
+
+# ── Free-tier API presets ──────────────────────────────────────
+
+API_PRESETS = {
+    "groq": {
+        "label": "Groq (free, fast)",
+        "base_url": "https://api.groq.com/openai/v1",
+        "default_model": "llama-3.3-70b-versatile",
+        "key_url": "https://console.groq.com/keys",
+    },
+    "gemini": {
+        "label": "Google Gemini (free tier, big quota)",
+        "base_url": "https://generativelanguage.googleapis.com/v1beta/openai",
+        "default_model": "gemini-2.0-flash",
+        "key_url": "https://aistudio.google.com/apikey",
+    },
+    "openrouter": {
+        "label": "OpenRouter (free models available)",
+        "base_url": "https://openrouter.ai/api/v1",
+        "default_model": "deepseek/deepseek-chat-v3.1:free",
+        "key_url": "https://openrouter.ai/keys",
+    },
+    "cerebras": {
+        "label": "Cerebras (free tier, very fast)",
+        "base_url": "https://api.cerebras.ai/v1",
+        "default_model": "llama-3.3-70b",
+        "key_url": "https://cloud.cerebras.ai",
+    },
+    "ollama": {
+        "label": "Ollama (local, no key, free forever)",
+        "base_url": "http://localhost:11434/v1",
+        "default_model": "qwen2.5-coder:7b",
+        "key_url": "https://ollama.com",
+    },
+    "lmstudio": {
+        "label": "LM Studio (local, no key)",
+        "base_url": "http://localhost:1234/v1",
+        "default_model": "local-model",
+        "key_url": "https://lmstudio.ai",
+    },
+    "custom": {
+        "label": "Custom OpenAI-compatible endpoint",
+        "base_url": "",
+        "default_model": "",
+        "key_url": "",
+    },
+}
+
+
+def build_api_backend(base_url: str, api_key: str, model: str, **kwargs) -> Backend:
+    return OpenAICompatBackend(base_url=base_url, api_key=api_key, model=model, **kwargs)

bugfixer/budget.py

@@ -0,0 +1,119 @@
+"""Token budget — slim long sections, estimate cost, enforce caps.
+
+Estimation is heuristic (1 token ≈ 4 chars for English text). Good enough for
+warning users before they blow through a paid plan; not for billing accuracy.
+"""
+
+from dataclasses import dataclass
+
+
+# ── Section caps (chars) ───────────────────────────────────────
+
+DEFAULT_CAPS = {
+    "title": 300,
+    "description": 2500,
+    "steps": 1500,
+    "expected": 500,
+    "actual": 800,
+    "environment": 600,
+    "logs": 2000,
+    "notes": 800,
+    "raw_description": 4000,
+    "inline_file": 8000,  # inlined candidate file content
+}
+
+
+# ── Token cost rates (per backend, output:input ratio) ─────────
+
+# Multiplier estimates how many tokens get consumed per input token across the
+# whole agentic loop (reads, edits, retries). Pure-API backend = ~1.5; agentic
+# CLI = 3-4 because of tool-use round-trips.
+BACKEND_LOOP_MULTIPLIER = {
+    "claude": 4.0,
+    "codex": 4.0,
+    "gemini": 3.5,
+    "qwen": 3.5,
+    "cursor": 3.5,
+    "aider": 2.5,
+    "openai_compat": 1.5,  # diff-only, no loop
+}
+
+
+# ── Default budgets ────────────────────────────────────────────
+
+DEFAULT_BUDGETS = {
+    "session_max_tokens": 200_000,
+    "per_issue_max_tokens": 30_000,
+    "daily_max_tokens": 500_000,
+}
+
+
+# ── Public helpers ─────────────────────────────────────────────
+
+def slim(text: str, max_chars: int) -> str:
+    if not text:
+        return ""
+    if len(text) <= max_chars:
+        return text
+    cut = max_chars
+    return text[:cut].rstrip() + f"\n\n[...truncated {len(text) - cut} chars to save tokens...]"
+
+
+def estimate_tokens(text: str) -> int:
+    """Rough token count: 4 chars per token."""
+    if not text:
+        return 0
+    return max(1, len(text) // 4)
+
+
+def estimate_total_cost(prompt: str, backend_name: str) -> int:
+    """Estimate total tokens consumed for one issue on the given backend."""
+    base = estimate_tokens(prompt)
+    mult = BACKEND_LOOP_MULTIPLIER.get(backend_name, 3.0)
+    return int(base * mult)
+
+
+@dataclass
+class BudgetCheck:
+    allowed: bool
+    estimated: int
+    session_used: int
+    session_max: int
+    per_issue_max: int
+    daily_used: int
+    daily_max: int
+    reason: str = ""
+
+
+def check_budget(prompt: str, backend_name: str,
+                 session_used: int, daily_used: int,
+                 budgets: dict = None) -> BudgetCheck:
+    b = {**DEFAULT_BUDGETS, **(budgets or {})}
+    estimated = estimate_total_cost(prompt, backend_name)
+
+    reasons: list = []
+    if estimated > b["per_issue_max_tokens"]:
+        reasons.append(
+            f"per-issue cap exceeded ({estimated:,} > {b['per_issue_max_tokens']:,})"
+        )
+    if session_used + estimated > b["session_max_tokens"]:
+        reasons.append(
+            f"session cap would be exceeded "
+            f"({session_used + estimated:,} > {b['session_max_tokens']:,})"
+        )
+    if daily_used + estimated > b["daily_max_tokens"]:
+        reasons.append(
+            f"daily cap would be exceeded "
+            f"({daily_used + estimated:,} > {b['daily_max_tokens']:,})"
+        )
+
+    return BudgetCheck(
+        allowed=not reasons,
+        estimated=estimated,
+        session_used=session_used,
+        session_max=b["session_max_tokens"],
+        per_issue_max=b["per_issue_max_tokens"],
+        daily_used=daily_used,
+        daily_max=b["daily_max_tokens"],
+        reason="; ".join(reasons),
+    )