bugbee 0.1.0__py3-none-any.whl

bugbee/parser/error_parser.py

@@ -0,0 +1,106 @@
+"""Error‑parsing utilities for BugBee.
+
+The original script performed a handful of regex‑based operations to:
+
+1. Extract the file and line number from a stack‑trace.
+2. Sanitize an error string for stable hashing.
+3. Compute a SHA‑256 hash of the sanitized error.
+
+These helpers are now grouped in a dedicated module so they can be reused by the
+CLI and any future programmatic API.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+from pathlib import Path
+from typing import Optional, Tuple
+
+__all__ = [
+    "extract_location",
+    "sanitize_error",
+    "error_hash",
+]
+
+
+def extract_location(stderr: str, command: list[str]) -> Tuple[Optional[Path], Optional[int]]:
+    """Return the source file path and line number for the *first* stack entry.
+
+    The function mirrors the logic that existed in ``main.py`` for the supported
+    languages (Python, C, C++, Go, JavaScript, generic build tools).  It returns
+    ``(None, None)`` when no location can be determined.
+    """
+    file_under_execution = command[-1] if command else ""
+    line_number: Optional[int] = None
+    path: Optional[Path] = None
+
+    # Python stack trace
+    if file_under_execution.endswith(".py"):
+        match = re.search(r'File "([^\"]+)", line (\d+)', stderr)
+        if match:
+            path = Path(match.group(1))
+            line_number = int(match.group(2))
+
+    # C source (main.c)
+    elif file_under_execution.endswith(".c"):
+        match = re.search(r"main\.c:(\d+):\d+:", stderr)
+        if match:
+            path = Path(os.getcwd()) / file_under_execution
+            line_number = int(match.group(1))
+
+    # C++ source (main.cpp)
+    elif file_under_execution.endswith(".cpp"):
+        match = re.search(r"main\.cpp:(\d+):\d+:", stderr)
+        if match:
+            path = Path(os.getcwd()) / file_under_execution
+            line_number = int(match.group(1))
+
+    # Go source (main.go)
+    elif file_under_execution.endswith(".go"):
+        match = re.search(r"main\.go:(\d+):\d+:", stderr)
+        if match:
+            path = Path(os.getcwd()) / file_under_execution
+            line_number = int(match.group(1))
+
+    # JavaScript (Node) – try to pull the line from a V8 stack frame.
+    elif file_under_execution.endswith(".js"):
+        cwd = os.getcwd()
+        escaped = re.escape(cwd)
+        match = re.search(rf"at\s+.*?\({escaped}[\\/](.+?):(\d+):\d+\)", stderr)
+        if match:
+            path = Path(os.getcwd()) / file_under_execution
+            line_number = int(match.group(2))
+
+    # Generic build tool – attempts to find a "file:line" pattern.
+    elif file_under_execution.endswith("build"):
+        cwd = os.getcwd()
+        escaped = re.escape(cwd)
+        match = re.search(rf"(?:\()?({escaped}[\\/](.+?))[^\s]*?(\d+):\d+", stderr)
+        if match:
+            path = Path(match.group(1))
+            line_number = int(match.group(3))
+
+    return path, line_number
+
+
+def sanitize_error(stderr: str) -> str:
+    """Remove environment‑specific noise from *stderr*.
+
+    The transformations aim to produce a stable string that can be used for
+    hashing and cache lookup:
+
+    * Replace absolute paths with ``<PATH>``.
+    * Replace timestamps (HH:MM:SS) with ``<TIME>``.
+    * Replace numeric line identifiers with ``<NUM>``.
+    """
+    cleaned = re.sub(r"(/[\w\.-]+)+", "<PATH>", stderr)
+    cleaned = re.sub(r"\d{2}:\d{2}:\d{2}", "<TIME>", cleaned)
+    cleaned = re.sub(r"line \d+", "line <NUM>", cleaned)
+    return cleaned.strip()
+
+
+def error_hash(sanitized_error: str) -> str:
+    """Return the SHA‑256 hash of *sanitized_error* as a hex string."""
+    return hashlib.sha256(sanitized_error.encode("utf-8")).hexdigest()

bugbee/patcher/__init__.py

@@ -0,0 +1,61 @@
+"""Patch application utilities for BugBee.
+
+The historic ``auto_code_fix.auto_fix`` function performed a line‑level replace
+based on a *starting line* and a *search string* for the erroneous line.  The new
+implementation adds safety features:
+
+* Creates a timestamped backup before modifying the file.
+* Returns the path of the backup for possible rollback.
+* Raises ``FileNotFoundError`` if the target does not exist.
+"""
+
+from __future__ import annotations
+
+import shutil
+import time
+from pathlib import Path
+from typing import Optional
+
+__all__ = ["apply_patch"]
+
+
+def _backup_file(original: Path) -> Path:
+    """Create a backup ``<original>.bak.<timestamp>`` and return its path."""
+    timestamp = time.strftime("%Y%m%d%H%M%S")
+    backup_path = original.with_name(f"{original.name}.bak.{timestamp}")
+    shutil.copy2(original, backup_path)
+    return backup_path
+
+
+def apply_patch(
+    file_path: Path,
+    line_number: int,
+    error_line: str,
+    fixed_line: str,
+    *,
+    create_backup: bool = True,
+) -> bool:
+    """Replace *error_line* with *fixed_line* around *line_number* in *file_path*.
+
+    The function reads the file, searches backwards from ``line_number`` for a
+    line containing ``error_line`` (mirroring the original behaviour), replaces
+    that line, writes the file back, and optionally creates a backup before the
+    modification.
+
+    Returns ``True`` if a replacement was made, ``False`` otherwise.
+    """
+    if not file_path.is_file():
+        raise FileNotFoundError(str(file_path))
+
+    if create_backup:
+        _backup_file(file_path)
+
+    lines = file_path.read_text(encoding="utf-8").splitlines(keepends=True)
+    start_idx = max(0, line_number - 1)  # zero‑based index
+    # Search backwards up to 30 lines as in the original script.
+    for idx in range(start_idx, max(-1, start_idx - 31), -1):
+        if error_line in lines[idx]:
+            lines[idx] = fixed_line
+            file_path.write_text("".join(lines), encoding="utf-8")
+            return True
+    return False

bugbee/retrieval/__init__.py

@@ -0,0 +1,91 @@
+"""Retrieval layer for BugBee.
+
+Wraps the existing ChromaDB vector store used to fetch relevant documentation
+based on an error message.  The public function ``get_related_docs`` matches the
+signature of the original ``retrieval.get_related_docs`` but is now a method of
+the ``Retriever`` class for easier testing/mocking.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List, Tuple
+
+from ..lazy import lazy_import
+
+# Lazy imports for heavy dependencies
+Chroma = lazy_import('langchain_chroma').Chroma
+Document = lazy_import('langchain_core.documents').Document
+HuggingFaceEmbeddings = lazy_import('langchain_huggingface').HuggingFaceEmbeddings
+
+from bugbee.config.settings import settings
+
+__all__ = ["Retriever", "get_related_docs"]
+
+
+# Lazy singleton for Retriever to avoid repeated heavy initialisation.
+_retriever: Retriever | None = None
+
+
+def get_retriever() -> "Retriever":
+    """Return a cached ``Retriever`` instance, creating it on first call.
+
+    This function is used by ``get_related_docs`` and any external callers to
+    ensure that the heavy ``Chroma`` connection and embedding model are only
+   instantiated once per process.
+    """
+    global _retriever
+    if _retriever is None:
+        _retriever = Retriever()
+    return _retriever
+
+
+class Retriever:
+    """ChromaDB retriever configured from the global settings.
+
+    ``settings.chromadb_path`` determines where the persistent collection lives.
+    ``settings.retrieval_k`` defines how many results to return.
+    """
+
+    def __init__(self) -> None:
+        self.vector_store = Chroma(
+            persist_directory=str(settings.chromadb_path),
+            embedding_function=HuggingFaceEmbeddings(
+                model_name="sentence-transformers/all-MiniLM-L6-v2"
+            ),
+            collection_name="framework_docs",
+        )
+        self.k = settings.retrieval_k
+
+    def get_related_docs(self, query: str) -> Tuple[str, float, float]:
+        """Return formatted docs, top score and average score for *query*.
+
+        The return type mirrors the original implementation: ``(docs, top_score,
+        avg_score)`` where *docs* is a formatted string of source and content.
+        """
+        results = self.vector_store.similarity_search_with_score(query, k=self.k)
+        if not results:
+            return "No Relevant documentation found", 0.0, 0.0
+
+        docs: List[Document] = [doc for doc, _ in results]
+        scores = [score for _, score in results]
+        # Convert Chroma's distance (0..2) to a cosine‑like similarity.
+        cosine_scores = [1.0 - (s / 2.0) for s in scores]
+        top_score = cosine_scores[0]
+        avg_score = sum(cosine_scores) / len(cosine_scores)
+
+        formatted = ""
+        for doc in docs:
+            source = doc.metadata.get("source_file", "Unknown File")
+            formatted += f"--- Source: {source} ---\n{doc.page_content}\n\n"
+        return formatted, top_score, avg_score
+
+
+# Convenience function used throughout the code base.
+def get_related_docs(query: str) -> Tuple[str, float, float]:
+    """Convenience wrapper that uses a lazy singleton ``Retriever``.
+
+    This preserves the original public API while avoiding a new ``Retriever``
+    instance on every call.
+    """
+    return get_retriever().get_related_docs(query)

bugbee/ui.py

@@ -0,0 +1,239 @@
+"""bugbee.ui
+~~~~~~~~~~~~
+
+Centralised user-facing reporting for the BugBee CLI.
+
+Every ``log.info(...)`` / ``log.debug(...)`` / ``typer.echo(...)`` call that
+used to be scattered through ``bugbee.cli.main`` now lives here, behind a
+single ``UI`` class. This keeps two concerns cleanly separated:
+
+* ``bugbee.utils.logging`` – plain structured logging (file / stdout,
+  DEBUG / INFO / WARNING / ERROR) for diagnostics, CI logs, and bug
+  reports.
+* ``bugbee.ui`` (this module) – everything a *human* actually sees:
+  spinners while work happens, colored status lines, a syntax-friendly
+  panel for the AI's analysis, tables for config/doctor output, and a
+  confirmation prompt for applying fixes.
+
+``main.py`` only ever talks to the module-level ``ui`` singleton, e.g.::
+
+    from bugbee.ui import ui
+
+    ui.command_failed()
+    with ui.spinner("Consulting the model…"):
+        result = default_provider().generate(prompt)
+    ui.show_analysis(result)
+
+This makes the command pipeline read like a checklist of steps instead of
+being interleaved with logging boilerplate, and it makes the presentation
+layer trivial to swap out later (e.g. a ``--quiet`` or ``--json`` mode just
+means dropping in a different ``UI`` implementation).
+"""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import Any, Dict, Iterator, List, Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+from rich.rule import Rule
+from rich.status import Status
+from rich.table import Table
+from rich.theme import Theme
+
+from bugbee.utils.logging import get_logger
+
+_log = get_logger(__name__)
+
+_THEME = Theme(
+    {
+        "bugbee.brand": "bold magenta",
+        "bugbee.success": "bold green",
+        "bugbee.error": "bold red",
+        "bugbee.warning": "bold yellow",
+        "bugbee.info": "cyan",
+        "bugbee.muted": "dim",
+        "bugbee.path": "bold blue",
+    }
+)
+
+
+class UI:
+    """Single point of contact for everything printed to the terminal.
+
+    Every method here pairs a structured log call (for diagnostics) with a
+    short, friendly line of console output (for humans). Methods are named
+    after pipeline *events* rather than log levels, so call sites in
+    ``main.py`` read declaratively, e.g. ``ui.cache_hit()`` instead of
+    ``log.info("Cache hit – using previously generated response.")``.
+    """
+
+    def __init__(self, console: Optional[Console] = None) -> None:
+        self.console = console or Console(theme=_THEME, highlight=False)
+        self.err_console = Console(theme=_THEME, stderr=True, highlight=False)
+
+    # ------------------------------------------------------------------
+    # Generic helpers
+    # ------------------------------------------------------------------
+    def banner(self, version: str) -> None:
+        self.console.print(
+            Panel.fit(
+                f"[bugbee.brand]\U0001F41D  BugBee[/] [bugbee.muted]v{version}[/]\n"
+                "[bugbee.muted]AI-powered CLI debugger & auto-repair[/]",
+                border_style="magenta",
+            )
+        )
+
+    @contextmanager
+    def spinner(self, message: str) -> Iterator[Status]:
+        """Show a spinner + *message* for the duration of the ``with`` block."""
+        _log.debug(message)
+        with self.console.status(f"[bugbee.info]{message}[/]", spinner="dots") as status:
+            yield status
+
+    # ------------------------------------------------------------------
+    # Command execution
+    # ------------------------------------------------------------------
+    def running_command(self, command: List[str]) -> None:
+        cmd = " ".join(command)
+        _log.info(f"Running command: {cmd}")
+        self.console.print(Rule(f"[bugbee.muted]$ {cmd}[/]", style="dim"))
+
+    def command_succeeded(self) -> None:
+        _log.info("Command succeeded – no analysis needed.")
+        self.console.print("[bugbee.success]\u2713 Command succeeded — nothing to debug.[/]")
+
+    def command_failed(self) -> None:
+        _log.warning("Command failed – analyzing error.")
+        self.console.print(
+            "[bugbee.error]\u2717 Command failed.[/] [bugbee.muted]Analyzing the error…[/]"
+        )
+
+    # ------------------------------------------------------------------
+    # Error parsing / caching
+    # ------------------------------------------------------------------
+    def location_found(self, file_path: str, line_number: int) -> None:
+        _log.debug(f"Extracted location: {file_path}:{line_number}")
+        self.console.print(
+            f"[bugbee.info]\U0001F4CD Located error at[/] [bugbee.path]{file_path}:{line_number}[/]"
+        )
+
+    def location_not_found(self) -> None:
+        _log.debug("Could not determine source location from stderr.")
+        self.console.print("[bugbee.warning]\u26A0 Could not determine the source location.[/]")
+
+    def cache_hit(self) -> None:
+        _log.info("Cache hit – using previously generated response.")
+        self.console.print(
+            "[bugbee.info]\u26A1 Cache hit[/] [bugbee.muted]— reusing a previous analysis.[/]"
+        )
+
+    def cache_miss(self) -> None:
+        _log.info("Cache miss – invoking LLM.")
+        self.console.print("[bugbee.muted]No cached fix found — asking the model…[/]")
+
+    def cache_cleared(self) -> None:
+        _log.info("Cache cleared.")
+        self.console.print("[bugbee.success]\u2713 Cache cleared.[/]")
+
+    def retrieval_stats(self, top_score: float, avg_score: float) -> None:
+        _log.debug(f"Retrieval scores — top: {top_score}, avg: {avg_score}")
+
+    # ------------------------------------------------------------------
+    # LLM analysis
+    # ------------------------------------------------------------------
+    def show_analysis(self, content: str) -> None:
+        self.console.print(
+            Panel(content, title="\U0001F916 AI Analysis", border_style="cyan", expand=True)
+        )
+
+    # ------------------------------------------------------------------
+    # Patch / auto-fix
+    # ------------------------------------------------------------------
+    def confirm_fix(self, auto_yes: bool) -> bool:
+        if auto_yes:
+            return True
+        return Confirm.ask("[bold]Apply suggested fix?[/]", console=self.console, default=False)
+
+    def applying_patch(self, file_path: str, line_number: int) -> None:
+        _log.info(f"Applying patch to {file_path} at line {line_number}")
+        self.console.print(
+            f"[bugbee.info]\U0001F527 Applying patch to[/] [bugbee.path]{file_path}:{line_number}[/]…"
+        )
+
+    def patch_applied(self) -> None:
+        _log.info("Patch applied successfully.")
+        self.console.print("[bugbee.success]\u2713 Patch applied successfully.[/]")
+
+    def patch_not_applied(self) -> None:
+        _log.warning("Patch could not be applied – error line not found.")
+        self.console.print(
+            "[bugbee.warning]\u26A0 Patch could not be applied — error line not found.[/]"
+        )
+
+    def patch_error(self, exc: Exception) -> None:
+        _log.error(f"Patch application failed: {exc}")
+        self.console.print(f"[bugbee.error]\u2717 Patch application failed:[/] {exc}")
+
+    def auto_fix_declined(self) -> None:
+        _log.info("Auto-fix declined or no source file identified.")
+        self.console.print("[bugbee.muted]No changes were made.[/]")
+
+    # ------------------------------------------------------------------
+    # Validation
+    # ------------------------------------------------------------------
+    def validation_passed(self) -> None:
+        _log.info("Validation succeeded after patch.")
+        self.console.print("[bugbee.success]\u2713 Validation succeeded after patch.[/]")
+
+    def validation_failed(self) -> None:
+        _log.warning("Validation failed after applying the patch.")
+        self.console.print(
+            "[bugbee.warning]\u26A0 Validation failed after applying the patch.[/]"
+        )
+
+    # ------------------------------------------------------------------
+    # Misc commands
+    # ------------------------------------------------------------------
+    def config_table(self, values: Dict[str, Any]) -> None:
+        table = Table(title="BugBee Configuration", border_style="magenta")
+        table.add_column("Setting", style="bold")
+        table.add_column("Value", style="bugbee.muted")
+        for name, value in values.items():
+            table.add_row(name, str(value))
+        self.console.print(table)
+
+    def doctor_start(self) -> None:
+        self.console.print("[bugbee.info]Running BugBee doctor…[/]")
+
+    def doctor_result(self, missing: List[str]) -> None:
+        if missing:
+            _log.warning(f"Missing dependencies: {', '.join(missing)}")
+            self.console.print(
+                f"[bugbee.error]\u2717 Missing dependencies:[/] {', '.join(missing)}"
+            )
+        else:
+            _log.info("All dependencies present.")
+            self.console.print("[bugbee.success]\u2713 All good![/]")
+
+    def version(self, version: str) -> None:
+        self.console.print(f"[bugbee.brand]bugbee[/] [bugbee.muted]{version}[/]")
+
+    # ------------------------------------------------------------------
+    # Final summary
+    # ------------------------------------------------------------------
+    def summary(self, *, fix_applied: bool, returncode: int) -> None:
+        if fix_applied:
+            self.console.print(Rule(style="green"))
+            self.console.print("[bugbee.success]Done — fix applied.[/]")
+        else:
+            self.console.print(Rule(style="red"))
+            self.console.print(
+                f"[bugbee.error]Done — no fix applied (exit code {returncode}).[/]"
+            )
+
+
+# Module-level singleton so call sites can simply do ``ui.cache_hit()``.
+ui = UI()

bugbee/utils/logging.py

@@ -0,0 +1,90 @@
+"""Logging utilities for BugBee.
+
+The module configures a root logger the first time it is imported. By
+**default BugBee writes structured logs to a file only** — the terminal is
+owned entirely by ``bugbee.ui``, which renders a polished, human-readable
+line for the same events via ``rich``. Previously this handler wrote to
+``sys.stdout``, which meant every event printed *twice*: once as a plain
+``HH:MM:SS | INFO | ... | message`` line from this module, and once as the
+styled line from ``bugbee.ui``. Routing this logger to disk instead removes
+that duplication while keeping the full diagnostic trail available for bug
+reports.
+
+Verbosity (the file log level) is controlled via the global
+``bugbee.config.settings.Settings.log_level`` value. If you want the raw,
+timestamped log lines on the console too — e.g. while debugging a flaky LLM
+call — pass ``--verbose`` on the CLI, which calls
+:func:`enable_console_logging`.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from bugbee.config.settings import settings
+
+_LOG_FORMAT = "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s"
+_DATE_FORMAT = "%H:%M:%S"
+
+_DEFAULT_LOG_DIR = Path.home() / ".bugbee" / "logs"
+_DEFAULT_LOG_FILE = _DEFAULT_LOG_DIR / "bugbee.log"
+
+
+def _log_file_path() -> Path:
+    """Resolve the log file location, honouring ``settings.log_file`` if set."""
+    configured = getattr(settings, "log_file", None)
+    path = Path(configured) if configured else _DEFAULT_LOG_FILE
+    path.parent.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _configure_logging() -> None:
+    """Attach a file handler to the root logger according to current settings.
+
+    Deliberately does **not** attach a console handler by default: BugBee's
+    terminal output is owned by ``bugbee.ui`` so users see one clean, styled
+    line per event instead of a duplicate plain-text log line underneath it.
+    """
+    root = logging.getLogger()
+    if any(isinstance(h, logging.FileHandler) for h in root.handlers):
+        return  # already configured
+
+    level = getattr(logging, settings.log_level.upper(), logging.INFO)
+
+    handler = logging.FileHandler(_log_file_path(), encoding="utf-8")
+    handler.setFormatter(logging.Formatter(_LOG_FORMAT, datefmt=_DATE_FORMAT))
+    handler.setLevel(level)
+
+    root.setLevel(level)
+    root.addHandler(handler)
+
+
+def enable_console_logging(level: int = logging.DEBUG) -> None:
+    """Additionally stream raw log lines to the console (``--verbose`` mode).
+
+    Uses ``rich.logging.RichHandler`` instead of a plain ``StreamHandler`` so
+    the extra output stays visually consistent with the rest of the BugBee
+    UI instead of looking like a different, bolted-on tool.
+    """
+    from rich.logging import RichHandler
+
+    root = logging.getLogger()
+    if any(isinstance(h, RichHandler) for h in root.handlers):
+        return  # already enabled
+
+    handler = RichHandler(level=level, show_time=True, show_path=False, markup=True)
+    root.addHandler(handler)
+    if root.level > level:
+        root.setLevel(level)
+
+
+# Configure file logging on import – mirrors the behaviour of many libraries,
+# but writes to disk instead of the terminal so it never collides with the
+# rich-powered UI in ``bugbee.ui``.
+_configure_logging()
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Return a logger scoped to *name* (typically ``__name__``)."""
+    return logging.getLogger(name)

bugbee/validator/__init__.py

@@ -0,0 +1,30 @@
+"""Validation utilities for BugBee.
+
+After applying an automatic patch the original tool re‑ran the failing command to
+ensure the issue is resolved.  ``run_validation`` mirrors that behaviour: it
+executes the supplied command and returns ``True`` when the exit code is ``0``.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import List
+
+__all__ = ["run_validation"]
+
+
+def run_validation(command: List[str], cwd: Path | None = None) -> bool:
+    """Execute *command* and return ``True`` if it finishes with exit code ``0``.
+
+    ``cwd`` defaults to the current working directory.  Standard output and
+    error streams are captured but not displayed; callers can log them if they
+    wish.
+    """
+    result = subprocess.run(
+        command,
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+    )
+    return result.returncode == 0