fixfleet 0.4.0__tar.gz → 0.4.2__tar.gz

{fixfleet-0.4.0/fixfleet.egg-info → fixfleet-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixfleet
-Version: 0.4.0
+Version: 0.4.2
 Summary: Auto-fix bugs from GitHub, GitLab, Jira, Linear, Bitbucket, or Azure DevOps with AI agents — bring your own CLI or free API.
 Author: Yash Koladiya
 License-Expression: GPL-3.0-or-later
@@ -405,12 +405,23 @@ No. FixFleet runs **100% locally** on your machine. No FixFleet servers, no Azur
 
 </details>
 
+<details>
+<summary><b>Does FixFleet collect any data?</b></summary>
+
+Only anonymous usage analytics (via Google Analytics): event names and coarse metadata like provider key, backend name, and success/failure — **never your code, tokens, project URLs, or issue content**. Used purely to find bugs and see which trackers/backends need attention.
+
+Opt out anytime:
+- CLI: `fixfleet --config-set telemetry.enabled=false` (or set `DO_NOT_TRACK=1`)
+- VSCode: uncheck `fixfleet.telemetry` in settings (the global VS Code telemetry setting is respected too)
+
+</details>
+
 <details>
 <summary><b>What's the difference between the VSCode extension and the CLI?</b></summary>
 
 Same engine, two interfaces:
-- **CLI** (`pip install fixfleet`) — interactive terminal flow, beautiful styled output
-- **VSCode extension** — premium UI sidebar + click-to-fix workflow, calls the CLI under the hood
+- **CLI** (`pip install fixfleet`) — interactive terminal flow, beautiful styled output. The guided interactive mode currently supports GitLab; for the other trackers use the JSON flags (`fixfleet --list-bugs-json --provider github ...`) or the extension.
+- **VSCode extension** — premium UI sidebar + click-to-fix workflow for all 6 trackers, calls the CLI under the hood
 
 Install both if you want flexibility. Extension auto-installs the CLI on first run if missing.
 

{fixfleet-0.4.0 → fixfleet-0.4.2}/README.md

@@ -377,12 +377,23 @@ No. FixFleet runs **100% locally** on your machine. No FixFleet servers, no Azur
 
 </details>
 
+<details>
+<summary><b>Does FixFleet collect any data?</b></summary>
+
+Only anonymous usage analytics (via Google Analytics): event names and coarse metadata like provider key, backend name, and success/failure — **never your code, tokens, project URLs, or issue content**. Used purely to find bugs and see which trackers/backends need attention.
+
+Opt out anytime:
+- CLI: `fixfleet --config-set telemetry.enabled=false` (or set `DO_NOT_TRACK=1`)
+- VSCode: uncheck `fixfleet.telemetry` in settings (the global VS Code telemetry setting is respected too)
+
+</details>
+
 <details>
 <summary><b>What's the difference between the VSCode extension and the CLI?</b></summary>
 
 Same engine, two interfaces:
-- **CLI** (`pip install fixfleet`) — interactive terminal flow, beautiful styled output
-- **VSCode extension** — premium UI sidebar + click-to-fix workflow, calls the CLI under the hood
+- **CLI** (`pip install fixfleet`) — interactive terminal flow, beautiful styled output. The guided interactive mode currently supports GitLab; for the other trackers use the JSON flags (`fixfleet --list-bugs-json --provider github ...`) or the extension.
+- **VSCode extension** — premium UI sidebar + click-to-fix workflow for all 6 trackers, calls the CLI under the hood
 
 Install both if you want flexibility. Extension auto-installs the CLI on first run if missing.
 

{fixfleet-0.4.0 → fixfleet-0.4.2}/bugfixer/__init__.py

@@ -1,6 +1,6 @@
 """FixFleet — Fleet of AI agents fixing bugs across any issue tracker."""
 
-__version__ = "0.4.0"
+__version__ = "0.4.2"
 __name_pretty__ = "FixFleet"
 __tagline__ = "Fleet of AI agents fixing bugs across any tracker"
 __author__ = "Yash Koladiya"

{fixfleet-0.4.0 → fixfleet-0.4.2}/bugfixer/backends/_subprocess.py

@@ -1,6 +1,7 @@
 """Shared subprocess runner with stdout tee (live print + capture)."""
 
 import os
+import signal
 import subprocess
 import sys
 import threading
@@ -9,6 +10,30 @@ from typing import List
 
 from .base import RunResult
 
+_IS_POSIX = os.name == "posix"
+
+
+def _kill_tree(proc: subprocess.Popen):
+    """Kill the child and (on POSIX) its whole process group, then reap it.
+
+    Agentic CLIs fork grandchildren (shell tools, git, sandbox workers); killing
+    only the direct child leaves those running and still mutating the repo.
+    """
+    try:
+        if _IS_POSIX:
+            os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+        else:
+            proc.kill()
+    except (ProcessLookupError, PermissionError, OSError):
+        try:
+            proc.kill()
+        except OSError:
+            pass
+    try:
+        proc.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        pass
+
 
 def run_with_tee(cmd: List[str], cwd: str, timeout: int = 600,
                  stdin_data: str = None, env: dict = None) -> RunResult:
@@ -25,18 +50,25 @@ def run_with_tee(cmd: List[str], cwd: str, timeout: int = 600,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
             text=True,
+            encoding="utf-8",
+            errors="replace",
             bufsize=1,
             env={**os.environ, **(env or {})},
+            start_new_session=_IS_POSIX,  # own process group so timeout can kill the whole tree
         )
     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
+        # Write on a thread — a large payload can fill the pipe buffer and
+        # deadlock against the child's stdout otherwise.
+        def writer():
+            try:
+                proc.stdin.write(stdin_data)
+                proc.stdin.close()
+            except (BrokenPipeError, OSError):
+                pass
+        threading.Thread(target=writer, daemon=True).start()
 
     def reader(stream, sink_list, dest):
         try:
@@ -61,7 +93,7 @@ def run_with_tee(cmd: List[str], cwd: str, timeout: int = 600,
         if rc is not None:
             break
         if time.time() > deadline:
-            proc.kill()
+            _kill_tree(proc)
             t_out.join(timeout=2)
             t_err.join(timeout=2)
             return RunResult(

{fixfleet-0.4.0 → fixfleet-0.4.2}/bugfixer/backends/api/openai_compat.py

@@ -10,11 +10,11 @@ No agentic tool-use loop — keeps token usage minimal.
 
 import json
 import re
+import socket
 import subprocess
 import sys
 import urllib.error
 import urllib.request
-from pathlib import Path
 
 from ..base import Backend, RunResult
 
@@ -66,15 +66,12 @@ class OpenAICompatBackend(Backend):
             "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",
-        )
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            # Omit the header entirely when no key (Ollama/LM Studio) — some
+            # strict gateways reject an empty Authorization value.
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        req = urllib.request.Request(url, data=data, headers=headers, method="POST")
         with urllib.request.urlopen(req, timeout=timeout) as resp:
             return json.loads(resp.read().decode())
 
@@ -90,13 +87,19 @@ class OpenAICompatBackend(Backend):
             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:
+            if isinstance(getattr(e, "reason", None), socket.timeout):
+                return RunResult(returncode=2, stderr=f"Request timed out after {timeout}s", timed_out=True)
             return RunResult(returncode=2, stderr=f"Network error: {e.reason}")
+        except socket.timeout:
+            return RunResult(returncode=2, stderr=f"Request timed out after {timeout}s", timed_out=True)
         except Exception as e:
             return RunResult(returncode=3, stderr=f"Unexpected error: {e}")
 
         try:
             content = response["choices"][0]["message"]["content"] or ""
-        except (KeyError, IndexError):
+        except (KeyError, IndexError, TypeError):
+            # TypeError covers "choices": null — some proxies return error
+            # payloads with HTTP 200.
             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.
@@ -138,18 +141,22 @@ 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:
+        if ("---" in m and "+++" in m and "@@" in m) or m.lstrip().startswith("diff --git"):
             return m.strip() + "\n"
     # Fallback: maybe model emitted raw diff without fences
-    if text.lstrip().startswith("---") and "+++" in text:
+    stripped = text.lstrip()
+    if stripped.startswith("diff --git") or (stripped.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)
+    """Try `git apply`, fall back to `patch -p1`. Return (rc, message).
 
+    Both paths are atomic: git apply is all-or-nothing by design, and the
+    patch fallback dry-runs first so a failing hunk never leaves the repo
+    half-patched.
+    """
     # Use stdin to feed the diff
     try:
         result = subprocess.run(
@@ -166,8 +173,18 @@ def _apply_diff(diff_text: str, project_dir: str) -> tuple:
     except (FileNotFoundError, subprocess.TimeoutExpired) as e:
         git_err = str(e)
 
-    # Try patch as fallback
+    # Try patch as fallback — dry-run first to keep it all-or-nothing.
     try:
+        dry = subprocess.run(
+            ["patch", "-p1", "--forward", "--dry-run"],
+            input=diff_text,
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if dry.returncode != 0:
+            return dry.returncode, f"git apply: {git_err}; patch (dry-run): {dry.stderr or dry.stdout}"
         result = subprocess.run(
             ["patch", "-p1", "--forward"],
             input=diff_text,

{fixfleet-0.4.0 → fixfleet-0.4.2}/bugfixer/backends/cli/claude.py

@@ -12,6 +12,9 @@ class ClaudeCLIBackend(Backend):
     DEFAULT_ALLOWED_TOOLS = "Read,Edit,Write,Grep,Glob,Bash"
 
     def run(self, prompt: str, project_dir: str, timeout: int = 600) -> RunResult:
+        if prompt.startswith("-"):
+            # Positional argv token — a leading dash would parse as a flag.
+            prompt = " " + prompt
         cmd = [
             "claude",
             "--print",

{fixfleet-0.4.0 → fixfleet-0.4.2}/bugfixer/backends/cli/codex.py

@@ -10,6 +10,9 @@ class CodexCLIBackend(Backend):
     requires_binary = "codex"
 
     def run(self, prompt: str, project_dir: str, timeout: int = 600) -> RunResult:
+        if prompt.startswith("-"):
+            # Positional argv token — a leading dash would parse as a flag.
+            prompt = " " + prompt
         # `codex exec` is the non-interactive mode; --full-auto auto-approves edits within sandbox.
         cmd = [
             "codex",

{fixfleet-0.4.0 → fixfleet-0.4.2}/bugfixer/budget.py

@@ -85,10 +85,20 @@ class BudgetCheck:
     reason: str = ""
 
 
+def _to_int(value, fallback: int) -> int:
+    """Coerce config values that may have been stored as strings."""
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return fallback
+
+
 def check_budget(prompt: str, backend_name: str,
                  session_used: int, daily_used: int,
                  budgets: dict = None) -> BudgetCheck:
     b = {**DEFAULT_BUDGETS, **(budgets or {})}
+    for key, default in DEFAULT_BUDGETS.items():
+        b[key] = _to_int(b.get(key), default)
     estimated = estimate_total_cost(prompt, backend_name)
 
     reasons: list = []

{fixfleet-0.4.0 → fixfleet-0.4.2}/bugfixer/cli.py

@@ -5,7 +5,7 @@ import sys
 from datetime import datetime
 from pathlib import Path
 
-from . import budget, config, state, ui
+from . import budget, config, state, telemetry, ui
 from .backends.base import Backend, RunResult
 from .backends.registry import (
     API_PRESETS,
@@ -569,6 +569,7 @@ def _fix_issues(selected: list, project_dir: str, project_id: str,
                 failed += 1
                 continue
 
+        telemetry.track("fix_started", {"provider": "gitlab", "backend": backend.name})
         result: RunResult = backend.run(prompt, project_dir)
         consumed = check.estimated  # use estimate as proxy
 
@@ -590,6 +591,15 @@ def _fix_issues(selected: list, project_dir: str, project_id: str,
         if conf.final_score < 0.20 and not conf.files_changed:
             success = False
 
+        telemetry.track("fix_completed", {
+            "provider": "gitlab",
+            "backend": backend.name,
+            "success": success,
+            "timed_out": result.timed_out,
+            "confidence": conf.label(),
+            "files_changed": len(conf.files_changed),
+        })
+
         session_tokens += consumed
         state.record_usage(
             backend_name=backend.name,
@@ -636,20 +646,24 @@ def main():
     try:
         issues = fetch_bug_issues(token, project_id, date_filter, host=host)
     except GitLabAuthError as e:
+        telemetry.track("provider_error", {"provider": "gitlab", "code": e.code})
         ui.print_error(e.message)
         ui.print_info("Open https://gitlab.com/-/user_settings/personal_access_tokens to create a new token.")
         ui.print_end()
         sys.exit(1)
     except GitLabNotFoundError as e:
+        telemetry.track("provider_error", {"provider": "gitlab", "code": e.code})
         ui.print_error(e.message)
         ui.print_end()
         sys.exit(1)
     except GitLabNetworkError as e:
+        telemetry.track("provider_error", {"provider": "gitlab", "code": e.code})
         ui.print_error(e.message)
         ui.print_info("Check your internet connection and try again.")
         ui.print_end()
         sys.exit(1)
     except GitLabError as e:
+        telemetry.track("provider_error", {"provider": "gitlab", "code": e.code})
         ui.print_error(e.message)
         ui.print_end()
         sys.exit(1)

{fixfleet-0.4.0 → fixfleet-0.4.2}/bugfixer/config.py

@@ -26,6 +26,9 @@ DEFAULT_CONFIG = {
         "inline_max_lines": 250,
     },
     "skip_already_fixed": True,
+    "telemetry": {
+        "enabled": True,  # anonymous usage events only; see bugfixer/telemetry.py
+    },
 }
 
 

{fixfleet-0.4.0 → fixfleet-0.4.2}/bugfixer/json_api.py

@@ -11,7 +11,7 @@ import json
 import sys
 from pathlib import Path
 
-from . import __version__, budget, config, state
+from . import __version__, budget, config, state, telemetry
 from .backends.base import RunResult
 from .backends.registry import (
     API_PRESETS,
@@ -139,12 +139,21 @@ def cmd_list_bugs_json(args):
             date_to=getattr(args, "date_to", None),
         )
     except ProviderNotImplementedError as e:
+        telemetry.track("provider_error", {"provider": provider.key, "code": e.code})
         _err_from_gitlab(e)
     except ProviderError as e:
+        telemetry.track("provider_error", {"provider": provider.key, "code": e.code})
         _err_from_gitlab(e)
     except Exception as e:
+        telemetry.track("unexpected_error", {"where": "list_bugs", "type": type(e).__name__})
         _err(f"unexpected error: {e}", error_code="unexpected")
 
+    telemetry.track("bugs_listed", {
+        "provider": provider.key,
+        "count": len(issues),
+        "date_filter": bool(args.date or getattr(args, "date_from", None) or getattr(args, "date_to", None)),
+    })
+
     payload_issues = []
     for i in issues:
         parsed = parse_issue(i)
@@ -238,8 +247,10 @@ def cmd_fix_issue(args):
     try:
         issues = provider.fetch_bugs(token=token, project_id=project_id, host=host)
     except ProviderNotImplementedError as e:
+        telemetry.track("provider_error", {"provider": provider.key, "code": e.code})
         _err_from_gitlab(e)
     except ProviderError as e:
+        telemetry.track("provider_error", {"provider": provider.key, "code": e.code})
         _err_from_gitlab(e)
     target = next(
         (i for i in issues if str(i.get("iid")) == str(issue_iid)),
@@ -252,14 +263,31 @@ def cmd_fix_issue(args):
     loc = locate(parsed, project_dir)
     prompt = build_prompt(parsed, locator=loc)
 
-    # Budget check
+    # Budget check — enforced unless --force is passed.
+    cfg_budgets = (config.load().get("budgets") or {})
     daily_used = state.get_daily_usage(backend.name)
     check = budget.check_budget(
         prompt, backend.name,
         session_used=0, daily_used=daily_used,
+        budgets=cfg_budgets,
     )
+    if not check.allowed and not getattr(args, "force", False):
+        telemetry.track("budget_blocked", {"backend": backend.name})
+        _emit({
+            "ok": False,
+            "code": "budget_exceeded",
+            "error": f"Budget would be exceeded: {check.reason}. Pass --force to run anyway.",
+            "budget": {
+                "estimated": check.estimated,
+                "per_issue_max": check.per_issue_max,
+                "daily_used": check.daily_used,
+                "daily_max": check.daily_max,
+            },
+        })
+        sys.exit(1)
 
     # Run backend
+    telemetry.track("fix_started", {"provider": provider.key, "backend": backend.name})
     result: RunResult = backend.run(prompt, project_dir)
     conf = evaluate_confidence(
         result.stdout, project_dir,
@@ -268,6 +296,14 @@ def cmd_fix_issue(args):
     )
 
     success = result.ok and (conf.final_score >= 0.20 or conf.files_changed)
+    telemetry.track("fix_completed", {
+        "provider": provider.key,
+        "backend": backend.name,
+        "success": success,
+        "timed_out": result.timed_out,
+        "confidence": conf.label(),
+        "files_changed": len(conf.files_changed),
+    })
     state.record_usage(
         backend_name=backend.name,
         tokens=check.estimated,
@@ -341,12 +377,18 @@ def cmd_config_set(args):
         if "=" not in pair:
             _err(f"invalid --config-set entry: {pair}")
         key, value = pair.split("=", 1)
+        # Coerce to native JSON types (int, float, bool, null) so numeric
+        # settings like budgets don't get stored as strings.
+        try:
+            parsed_value = json.loads(value)
+        except (json.JSONDecodeError, ValueError):
+            parsed_value = value
         # Support nested keys via dot notation: api.base_url=...
         parts = key.split(".")
         target = cfg
         for p in parts[:-1]:
             target = target.setdefault(p, {})
-        target[parts[-1]] = value
+        target[parts[-1]] = parsed_value
 
     config.save(cfg)
     _emit({"ok": True, "saved": list(args.config_set)})
@@ -376,9 +418,12 @@ def build_parser() -> argparse.ArgumentParser:
     p.add_argument("--token", help="Issue-tracker token (or set BUGFIXER_TOKEN env var)")
     p.add_argument("--project-url", help="Project URL or ID")
     p.add_argument("--project-dir", help="Local project directory")
-    p.add_argument("--provider", default="gitlab",
-                   help="Issue-tracker provider: gitlab (default), github, jira, linear")
+    p.add_argument("--provider", default=None,
+                   help="Issue-tracker provider: gitlab, github, jira, linear, bitbucket, azure "
+                        "(default: auto-detect from --project-url, falling back to gitlab)")
     p.add_argument("--backend", help="AI backend name: claude, codex, gemini, cursor, aider, qwen, openai_compat")
+    p.add_argument("--force", action="store_true",
+                   help="Run --fix-issue even when the token budget would be exceeded")
     p.add_argument("--date", help="Filter bugs created on YYYY-MM-DD (single day)")
     p.add_argument("--date-from", dest="date_from", help="Filter bugs created on/after YYYY-MM-DD")
     p.add_argument("--date-to", dest="date_to", help="Filter bugs created on/before YYYY-MM-DD")
@@ -398,25 +443,31 @@ def main():
     args.backend = args.backend or os.environ.get("BUGFIXER_BACKEND", "")
 
     if args.backends_json:
+        telemetry.track("cli_start", {"mode": "backends_json"})
         cmd_backends_json()
         return
     if args.providers_json:
         cmd_providers_json()
         return
     if args.list_bugs_json:
+        telemetry.track("cli_start", {"mode": "list_bugs_json"})
         cmd_list_bugs_json(args)
         return
     if args.fix_issue is not None:
+        telemetry.track("cli_start", {"mode": "fix_issue"})
         cmd_fix_issue(args)
         return
     if args.config_get:
         cmd_config_get()
         return
     if args.config_set:
+        telemetry.track("config_set", {"keys": ",".join(p.split("=")[0] for p in args.config_set)})
         cmd_config_set(args)
         return
 
     # No JSON flag → fall through to interactive CLI
+    telemetry.maybe_show_notice()
+    telemetry.track("cli_start", {"mode": "interactive"})
     from .cli import main as interactive_main
     interactive_main()
 

{fixfleet-0.4.0 → fixfleet-0.4.2}/bugfixer/providers/azure.py

@@ -12,6 +12,7 @@ import json
 import urllib.error
 import urllib.parse
 import urllib.request
+from datetime import datetime, timedelta
 from typing import Optional
 
 from .base import (
@@ -28,6 +29,15 @@ API_HOST = "dev.azure.com"
 MAX_IDS_PER_REQUEST = 200
 
 
+def _next_day(date_str: str) -> str:
+    """YYYY-MM-DD → next day, for exclusive upper bounds."""
+    try:
+        d = datetime.strptime(date_str, "%Y-%m-%d")
+    except ValueError:
+        return date_str
+    return (d + timedelta(days=1)).strftime("%Y-%m-%d")
+
+
 class AzureDevOpsProvider(Provider):
     key = "azure"
     display_name = "Azure DevOps"
@@ -103,14 +113,21 @@ class AzureDevOpsProvider(Provider):
         ]
         if date_from:
             wiql_parts.append(f"  AND [System.CreatedDate] >= '{date_from}T00:00:00Z'")
+            if date_to:
+                wiql_parts.append(f"  AND [System.CreatedDate] < '{_next_day(date_to)}T00:00:00Z'")
         elif date_str:
+            # Single-day window, matching GitLab's --date semantics.
             wiql_parts.append(f"  AND [System.CreatedDate] >= '{date_str}T00:00:00Z'")
-        if date_to:
-            wiql_parts.append(f"  AND [System.CreatedDate] <= '{date_to}T23:59:59Z'")
+            wiql_parts.append(f"  AND [System.CreatedDate] < '{_next_day(date_str)}T00:00:00Z'")
+        elif date_to:
+            wiql_parts.append(f"  AND [System.CreatedDate] < '{_next_day(date_to)}T00:00:00Z'")
         wiql_parts.append("ORDER BY [System.CreatedDate] DESC")
         wiql = " ".join(wiql_parts)
 
-        wiql_url = f"https://{host}/{org}/{project}/_apis/wit/wiql?api-version={API_VERSION}"
+        # Re-encode path segments — project names commonly contain spaces.
+        org_q = urllib.parse.quote(org, safe="")
+        project_q = urllib.parse.quote(project, safe="")
+        wiql_url = f"https://{host}/{org_q}/{project_q}/_apis/wit/wiql?api-version={API_VERSION}"
         wiql_req = urllib.request.Request(
             wiql_url,
             data=json.dumps({"query": wiql}).encode(),
@@ -156,7 +173,7 @@ class AzureDevOpsProvider(Provider):
             chunk = ids[i:i + MAX_IDS_PER_REQUEST]
             ids_str = ",".join(str(x) for x in chunk)
             details_url = (
-                f"https://{host}/{org}/_apis/wit/workitems"
+                f"https://{host}/{org_q}/_apis/wit/workitems"
                 f"?ids={ids_str}&$expand=none&api-version={API_VERSION}"
             )
             req = urllib.request.Request(details_url, headers=headers)
@@ -164,8 +181,20 @@ class AzureDevOpsProvider(Provider):
                 with urllib.request.urlopen(req, timeout=30) as resp:
                     details = json.loads(resp.read().decode())
             except urllib.error.HTTPError as e:
-                # Skip chunk on error — partial results better than none
-                continue
+                if e.code in (401, 403):
+                    raise ProviderAuthError(
+                        code="token_invalid", status=e.code,
+                        message="Azure DevOps PAT rejected while fetching work item details.",
+                    )
+                raise ProviderError(
+                    code=f"http_{e.code}", status=e.code,
+                    message=f"Azure DevOps work-item fetch returned {e.code} {e.reason}",
+                )
+            except urllib.error.URLError as e:
+                raise ProviderNetworkError(
+                    code="network_error",
+                    message=f"Couldn't reach https://{host} — {e.reason}",
+                )
             for wi in details.get("value", []):
                 results.append(self._normalize(wi, host, org, project))
 
@@ -197,11 +226,13 @@ class AzureDevOpsProvider(Provider):
             tags.append(priority_label)
 
         created_by = fields.get("System.CreatedBy") or {}
-        author_name = (
-            created_by.get("displayName")
-            or created_by.get("uniqueName")
-            or (created_by if isinstance(created_by, str) else "")
-        )
+        if isinstance(created_by, str):
+            # Older api-versions return a plain "Name <email>" string.
+            author_name = created_by
+        elif isinstance(created_by, dict):
+            author_name = created_by.get("displayName") or created_by.get("uniqueName") or ""
+        else:
+            author_name = ""
 
         return {
             "iid": wi_id,

{fixfleet-0.4.0 → fixfleet-0.4.2}/bugfixer/providers/base.py

@@ -79,11 +79,26 @@ class Provider(ABC):
 
     @classmethod
     def matches_url(cls, url: str) -> bool:
-        """Heuristic: does this provider own this URL?"""
+        """Heuristic: does this provider own this URL? Matches host part only,
+        so a repo path like github.com/acme/gitlab.integration can't misroute."""
         if not url:
             return False
-        lower = url.lower()
-        return any(p in lower for p in cls.host_patterns)
+        lower = url.lower().strip()
+        # Extract host from URL / ssh / scheme-less forms
+        host = lower
+        if "://" in host:
+            host = host.split("://", 1)[1]
+        if host.startswith("git@"):
+            host = host[4:].split(":", 1)[0]
+        host = host.split("/", 1)[0].split("@")[-1].split(":", 1)[0]
+        for p in cls.host_patterns:
+            if p.endswith("."):
+                # Prefix pattern, e.g. "gitlab." matches gitlab.com / gitlab.example.com
+                if host.startswith(p):
+                    return True
+            elif host == p or host.endswith("." + p):
+                return True
+        return False
 
     @abstractmethod
     def parse_url(self, raw: str) -> tuple: