bugbee 0.1.0__py3-none-any.whl

bugbee/__init__.py

@@ -0,0 +1,13 @@
+"""Top level package for BugBee.
+
+Provides version information and exposes the public API.
+"""
+
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version(__name__)
+except PackageNotFoundError:  # pragma: no cover – during development the package may not be installed yet
+    __version__ = "0.1.0"
+
+__all__ = ["__version__"]

bugbee/cache/__init__.py

@@ -0,0 +1,76 @@
+"""Cache handling for BugBee.
+
+Provides a thin wrapper around a JSON file (default ``bugbee.json``) used to
+store LLM responses keyed by a deterministic error hash.  The API mirrors the
+original script's ``check_cache`` and ``save_to_cache`` functions.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from bugbee.config.settings import settings
+
+__all__ = ["Cache", "cache"]
+
+
+class Cache:
+    """Simple JSON‑file cache.
+
+    The cache file is created on first use and persisted between runs.  Loading
+    and writing are performed lazily to avoid disk I/O during CLI start‑up.
+    """
+
+    def __init__(self, path: Optional[Path] = None) -> None:
+        self.path = path or settings.cache_file
+        self._data: Dict[str, Any] = {}
+        self._loaded = False
+
+    def _load(self) -> None:
+        if self._loaded:
+            return
+        if self.path.is_file():
+            try:
+                self._data = json.load(self.path.open())
+            except json.JSONDecodeError:
+                self._data = {}
+        else:
+            self._data = {}
+        self._loaded = True
+
+    def _save(self) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(json.dumps(self._data, indent=2))
+
+    def get(self, key: str) -> Optional[Any]:
+        self._load()
+        return self._data.get(key)
+
+    def set(self, key: str, value: Any) -> None:
+        self._load()
+        self._data[key] = value
+        self._save()
+
+    def clear(self) -> None:
+        self._data.clear()
+        self._loaded = True
+        if self.path.is_file():
+            self.path.unlink()
+
+# Export a lazy accessor for the cache. The cache object is instantiated
+# only when first needed, avoiding file I/O during CLI start‑up.
+
+def get_cache() -> Cache:
+    """Return a shared ``Cache`` instance, creating it on first call.
+
+    This mirrors the previous ``cache`` singleton but defers the actual object
+    construction (and the associated disk read) until the cache is accessed.
+    """
+    global _cache_instance
+    try:
+        return _cache_instance
+    except NameError:
+        _cache_instance = Cache()
+        return _cache_instance

bugbee/cli/main.py

@@ -0,0 +1,258 @@
+"""CLI entry point for the BugBee package.
+
+The original monolithic implementation lived in ``cli-wrapper/src/cli_wrapper/main.py``.
+This version keeps the ``run`` command as a clean pipeline built on top of:
+
+* ``bugbee.parser.error_parser`` – stack‑trace extraction, sanitisation, hashing
+* ``bugbee.cache`` – JSON cache wrapper
+* ``bugbee.retrieval`` – ChromaDB document retrieval
+* ``bugbee.llm`` – LLM provider abstraction
+* ``bugbee.patcher`` – safe patch application with backup
+* ``bugbee.validator`` – post‑patch validation runner
+* ``bugbee.metrics`` – metrics collection and JSONL persistence
+* ``bugbee.ui`` – ALL logging and terminal presentation (spinners, colored
+  status lines, panels, tables, confirmation prompts) lives here. This file
+  contains no direct ``log.*`` or ``typer.echo`` calls — every user-facing
+  message is routed through the ``ui`` singleton so the pipeline below reads
+  as pure business logic.
+
+The command line mimics the historic behaviour while being fully testable,
+type‑safe, and pleasant to actually use.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+from typing import List, Tuple
+
+import typer
+
+from bugbee import __version__
+from bugbee.config.settings import settings
+from bugbee.parser.error_parser import (
+    extract_location,
+    sanitize_error,
+    error_hash,
+)
+from bugbee.cache import get_cache
+from bugbee.lazy import lazy_import
+from bugbee.ui import ui
+from bugbee.utils.logging import enable_console_logging
+# Heavy imports are lazy‑loaded inside the command handlers.
+# from bugbee.retrieval import get_related_docs
+# from bugbee.llm import default_provider
+# from bugbee.metrics import MetricsCollector
+# from bugbee.patcher import apply_patch
+# from bugbee.validator import run_validation
+
+app = typer.Typer(
+    help="BugBee – AI‑powered CLI debugger and auto‑repair tool",
+    rich_markup_mode="rich",
+)
+
+
+@app.callback()
+def main(
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        help="Also print raw, timestamped log lines to the console (in addition to the normal UI).",
+    ),
+) -> None:
+    """BugBee – AI‑powered CLI debugger and auto‑repair tool."""
+    if verbose:
+        enable_console_logging()
+
+
+def _run_subprocess(command: List[str]) -> Tuple[int, str, str]:
+    """Execute *command* and return ``(returncode, stdout, stderr)``.
+
+    The function deliberately forwards stdout directly to the console (as the
+    original tool did) and captures stderr for analysis.
+    """
+    import subprocess
+
+    ui.running_command(command)
+    proc = subprocess.Popen(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+    out, err = proc.communicate()
+    # Echo stdout to the console to preserve original behaviour.
+    if out:
+        sys.stdout.write(out)
+    return proc.returncode, out, err
+
+
+def _parse_llm_output(output: str) -> Tuple[str, str, str]:
+    """Extract ``error_line`` and ``fix`` from the LLM ``output``.
+
+    The original script expected XML‑like tags <ERROR_LINE> and <FIX>.  We keep
+    that contract for backward compatibility.
+    """
+    error_line_match = re.search(r"<ERROR_LINE>(.*?)</ERROR_LINE>", output, re.DOTALL)
+    fix_match = re.search(r"<FIX>(.*?)</FIX>", output, re.DOTALL)
+    error_line = error_line_match.group(1).strip() if error_line_match else ""
+    fix = fix_match.group(1).strip() if fix_match else ""
+    # The full content without the tags is also useful for reporting.
+    content = output.strip()
+    return content, error_line, fix
+
+
+@app.command()
+def run(
+    command: List[str] = typer.Argument(..., help="Command to execute and debug"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Auto‑accept fix without prompting"),
+) -> None:
+    """Execute *command*, analyse failures and optionally apply an auto‑fix."""
+    # Lazy imports of heavy modules – they are only loaded when this command runs.
+    MetricsCollector = lazy_import('bugbee.metrics').MetricsCollector
+    get_related_docs = lazy_import('bugbee.retrieval').get_related_docs
+    default_provider = lazy_import('bugbee.llm').default_provider
+    apply_patch = lazy_import('bugbee.patcher').apply_patch
+    run_validation = lazy_import('bugbee.validator').run_validation
+
+    metrics = MetricsCollector()
+    metrics.update("command", " ".join(command))
+
+    returncode, _, stderr = _run_subprocess(command)
+    if returncode == 0:
+        ui.command_succeeded()
+        metrics.write()
+        raise typer.Exit(code=0)
+
+    ui.command_failed()
+
+    # 1️⃣ Extract location info (file + line) – may be ``None``.
+    file_path, line_number = extract_location(stderr, command)
+    if file_path and line_number:
+        ui.location_found(file_path, line_number)
+    else:
+        ui.location_not_found()
+
+    # 2️⃣ Sanitize error and compute hash for caching.
+    cleaned = sanitize_error(stderr)
+    err_hash = error_hash(cleaned)
+    cache_obj = get_cache()
+    cached = cache_obj.get(err_hash)
+    if cached:
+        ui.cache_hit()
+        llm_content, error_line, fix = cached
+    else:
+        ui.cache_miss()
+        # Retrieve relevant docs.
+        with ui.spinner("Retrieving relevant documentation…"):
+            docs, top_score, avg_score = get_related_docs(stderr)
+        metrics.update("retrieval.top_score", top_score)
+        metrics.update("retrieval.avg_score", avg_score)
+        ui.retrieval_stats(top_score, avg_score)
+
+        # Very simple prompt composition.
+        prompt = (
+            f"Error message:\n{stderr}\n\n"
+            f"Relevant documentation:\n{docs}\n\n"
+            "Provide an XML-like response containing <ERROR_LINE> and <FIX>."
+        )
+        with ui.spinner("Consulting the model for a fix…"):
+            llm_resp = default_provider().generate(prompt)
+
+        llm_content, error_line, fix = _parse_llm_output(llm_resp)
+        cache_obj.set(err_hash, (llm_content, error_line, fix))
+
+    # Show the LLM analysis to the user.
+    ui.show_analysis(llm_content)
+
+    # Auto‑fix handling.
+    performed = False
+    accept = ui.confirm_fix(yes)
+    if accept and file_path:
+        ui.applying_patch(file_path, line_number)
+        try:
+            success = apply_patch(file_path, line_number, error_line, fix + "\n", create_backup=True)
+            if success:
+                performed = True
+                metrics.update("autofix.patch_applied", True)
+                metrics.update("autofix.files_modified", 1)
+                ui.patch_applied()
+                # Run validation to ensure fix works.
+                with ui.spinner("Validating the fix…"):
+                    validation_ok = run_validation(command, cwd=Path.cwd())
+                if validation_ok:
+                    metrics.update("validation.passed", True)
+                    ui.validation_passed()
+                else:
+                    ui.validation_failed()
+            else:
+                ui.patch_not_applied()
+        except Exception as exc:
+            ui.patch_error(exc)
+    else:
+        ui.auto_fix_declined()
+
+    # Record final metrics.
+    metrics.update("diagnosis.error_line_found", bool(error_line))
+    metrics.update("diagnosis.fix_generated", bool(fix))
+    metrics.write()
+
+    ui.summary(fix_applied=performed, returncode=returncode)
+
+    # Exit with the original return code if no successful fix was applied.
+    if performed:
+        raise typer.Exit(code=0)
+    else:
+        raise typer.Exit(code=returncode)
+
+
+@app.command()
+def analyze(
+    command: List[str] = typer.Argument(..., help="Command to analyze without applying a fix"),
+) -> None:
+    """Run *command* and display LLM analysis but do not prompt for auto‑fix."""
+    # Reuse ``run`` logic but force ``yes=False`` and skip patch step.
+    run(command=command, yes=False)
+
+
+@app.command()
+def version() -> None:
+    """Print the installed BugBee version."""
+    ui.version(__version__)
+
+
+@app.command()
+def cache_clear() -> None:
+    """Remove the local cache file (``bugbee.json``)."""
+    get_cache().clear()
+    ui.cache_cleared()
+
+
+@app.command()
+def config_show() -> None:
+    """Display the effective configuration (environment variables, .env, defaults)."""
+    ui.config_table(settings.dict())
+
+
+@app.command()
+def doctor() -> None:
+    """Run a quick health‑check of required dependencies and connectivity."""
+    ui.doctor_start()
+    missing = []
+    try:
+        import chromadb  # noqa: F401
+    except Exception:
+        missing.append("chromadb")
+    try:
+        import langchain  # noqa: F401
+    except Exception:
+        missing.append("langchain")
+    ui.doctor_result(missing)
+    if missing:
+        raise typer.Exit(code=1)
+
+
+if __name__ == "__main__":
+    app()

bugbee/config/settings.py

@@ -0,0 +1,116 @@
+"""Configuration handling for BugBee.
+
+BugBee loads configuration from:
+
+1. Environment variables
+2. .env file
+3. Optional YAML configuration
+
+Environment variables always take precedence.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Mapping
+
+import yaml
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from platformdirs import user_cache_dir, user_data_dir
+
+
+class Settings(BaseSettings):
+    """Global configuration for BugBee."""
+
+    # ------------------------------------------------------------------
+    # Pydantic Settings Configuration
+    # ------------------------------------------------------------------
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",  # Ignore unknown environment variables
+    )
+
+    # ------------------------------------------------------------------
+    # General
+    # ------------------------------------------------------------------
+
+    log_level: str = "INFO"
+
+    temperature: float = 0.1
+
+    retrieval_k: int = 3
+
+    # ------------------------------------------------------------------
+    # Paths
+    # ------------------------------------------------------------------
+
+    cache_file: Path = Field(
+        default_factory=lambda: Path(user_cache_dir("bugbee")) / "cache.json"
+    )
+
+    chromadb_path: Path = Field(
+        default_factory=lambda: Path(user_data_dir("bugbee")) / "chromadb"
+    )
+
+    # ------------------------------------------------------------------
+    # LLM Configuration
+    # ------------------------------------------------------------------
+
+    llm_endpoint: str = (
+        "https://api-inference.huggingface.co/models/deepseek-ai/DeepSeek-R1"
+    )
+
+    # ------------------------------------------------------------------
+    # API Keys
+    # ------------------------------------------------------------------
+
+    openai_api_key: str | None = Field(
+        default=None,
+        alias="OPENAI_API_KEY",
+    )
+
+    anthropic_api_key: str | None = Field(
+        default=None,
+        alias="ANTHROPIC_API_KEY",
+    )
+
+    google_api_key: str | None = Field(
+        default=None,
+        alias="GOOGLE_API_KEY",
+    )
+
+    openrouter_api_key: str | None = Field(
+        default=None,
+        alias="OPENROUTER_API_KEY",
+    )
+
+    huggingface_api_key: str | None = Field(
+        default=None,
+        validation_alias="HF_TOKEN",
+    )
+
+
+    # ------------------------------------------------------------------
+    # Optional YAML Loader
+    # ------------------------------------------------------------------
+
+    @classmethod
+    def from_yaml(cls, yaml_path: Path) -> "Settings":
+        """Load configuration from a YAML file."""
+
+        if not yaml_path.exists():
+            return cls()
+
+        data: Mapping[str, Any] = yaml.safe_load(
+            yaml_path.read_text(encoding="utf-8")
+        ) or {}
+
+        return cls(**data)
+
+
+# Singleton instance used across the project.
+settings = Settings()

bugbee/lazy.py

@@ -0,0 +1,42 @@
+"""Utility helpers for lazy importing heavy dependencies.
+
+This module provides a simple ``lazy_import`` function that defers the actual
+``import`` until the first attribute access.  It is used throughout the codebase
+to keep the CLI start‑up path lightweight.
+"""
+
+from __future__ import annotations
+
+import importlib
+import sys
+import types
+from typing import Any
+
+
+def lazy_import(module_name: str) -> types.ModuleType:
+    """Return a proxy module that imports ``module_name`` on first attribute use.
+
+    The returned object behaves like the real module but delays the import until
+    an attribute or ``__getattr__`` is accessed.  Subsequent accesses reuse the
+    already-loaded module.
+    """
+
+    class _LazyModule(types.ModuleType):
+        __dict__: dict[str, Any]
+        _module: types.ModuleType | None = None
+
+        def _load(self) -> types.ModuleType:
+            if self._module is None:
+                self._module = importlib.import_module(module_name)
+                # Insert the loaded module into ``sys.modules`` so other imports
+                # resolve to the same object.
+                sys.modules[module_name] = self._module
+            return self._module
+
+        def __getattr__(self, name: str) -> Any:  # pragma: no cover – exercised at runtime
+            return getattr(self._load(), name)
+
+        def __dir__(self) -> list[str]:  # pragma: no cover
+            return dir(self._load())
+
+    return _LazyModule(module_name)

bugbee/legacy.py

@@ -0,0 +1,31 @@
+"""Legacy shim for backward compatibility.
+
+The original project exposed a ``main`` function in ``cli-wrapper/src/cli_wrapper/main.py``.
+We import that function and expose it here so existing ``import bugbee.legacy``
+or ``python -m bugbee.legacy`` continues to work.
+"""
+
+import sys
+from pathlib import Path
+
+# Ensure the original source directory is on ``sys.path``.
+_PROJECT_ROOT = Path(__file__).resolve().parents[2]  # points to repository root
+_SRC_DIR = _PROJECT_ROOT / "cli-wrapper" / "src" / "cli_wrapper"
+if str(_SRC_DIR) not in sys.path:
+    sys.path.insert(0, str(_SRC_DIR))
+
+# Import the historic ``main`` function.
+try:
+    from main import main as _original_main  # type: ignore
+except Exception as exc:  # pragma: no cover – during early development the module may not be importable yet
+    raise ImportError("Unable to import legacy main function") from exc
+
+
+def main() -> None:
+    """Entry point that forwards to the original implementation.
+
+    This wrapper exists so that external scripts that called the old ``main``
+    continue to operate.  All behaviour (including interactive prompts) is
+    unchanged.
+    """
+    _original_main()

bugbee/llm/__init__.py

@@ -0,0 +1,59 @@
+"""
+LLM provider for BugBee.
+
+Currently BugBee uses DeepSeek-R1 through the Hugging Face Inference API.
+
+Future versions can add OpenAI, Anthropic, Gemini, Ollama, etc.
+"""
+
+from __future__ import annotations
+
+from functools import lru_cache
+
+from bugbee.config.settings import settings
+from bugbee.lazy import lazy_import
+
+# Lazy imports (only loaded when the provider is created)
+ChatHuggingFace = lazy_import("langchain_huggingface").ChatHuggingFace
+HuggingFaceEndpoint = lazy_import("langchain_huggingface").HuggingFaceEndpoint
+HumanMessage = lazy_import("langchain_core.messages").HumanMessage
+
+
+class DeepSeekProvider:
+    """DeepSeek provider backed by Hugging Face Inference API."""
+
+    def __init__(self) -> None:
+
+        self.endpoint = HuggingFaceEndpoint(
+            repo_id="deepseek-ai/DeepSeek-R1",
+            task="text-generation",
+            huggingfacehub_api_token=settings.huggingface_api_key,
+            temperature=settings.temperature,
+        )
+
+        self.model = ChatHuggingFace(
+            llm=self.endpoint,
+        )
+
+    def generate(self, prompt: str) -> str:
+        """Generate a response from DeepSeek."""
+
+        response = self.model.invoke(
+            [
+                HumanMessage(
+                    content=prompt
+                )
+            ]
+        )
+
+        return response.content
+
+
+@lru_cache(maxsize=1)
+def default_provider() -> DeepSeekProvider:
+    """
+    Singleton provider.
+
+    Prevents recreating the model every request.
+    """
+    return DeepSeekProvider()

bugbee/metrics/__init__.py

@@ -0,0 +1,58 @@
+"""Metrics collection for BugBee.
+
+The original script accumulated a dictionary ``metrics_obj`` and appended JSON
+lines to ``metrics.jsonl``.  ``MetricsCollector`` provides a thin wrapper around
+that behaviour, exposing methods to update sections and write a record.  All
+timestamps are ISO‑8601 strings.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict
+
+from bugbee.config.settings import settings
+
+__all__ = ["MetricsCollector"]
+
+
+class MetricsCollector:
+    """Collect and persist metrics for a single run.
+
+    Usage example::
+
+        collector = MetricsCollector()
+        collector.update("command", "python myscript.py")
+        collector.update("retrieval", {"top_score": 0.9})
+        collector.write()
+    """
+
+    def __init__(self, file_path: Path | None = None) -> None:
+        self.file_path = file_path or Path.cwd() / "metrics.jsonl"
+        self.metrics: Dict[str, Any] = {
+            "timestamp": datetime.utcnow().isoformat(),
+            "command": "",
+            "exceptionType": "NA",
+            "retrieval": {"top_score": 0.0, "avg_score": 0.0, "latency_ms": 0.0},
+            "llm": {"input_tokens": 0, "output_tokens": 0, "latency_ms": 0.0},
+            "diagnosis": {"error_line_found": False, "fix_generated": False},
+            "autofix": {"patch_applied": False, "files_modified": 0},
+            "validation": {"passed": False},
+        }
+
+    def update(self, key: str, value: Any) -> None:
+        """Set *key* to *value* – creates nested dicts as needed."""
+        parts = key.split(".")
+        target = self.metrics
+        for part in parts[:-1]:
+            target = target.setdefault(part, {})
+        target[parts[-1]] = value
+
+    def write(self) -> None:
+        """Append the current metrics as a JSON line to ``metrics.jsonl``."""
+        self.file_path.parent.mkdir(parents=True, exist_ok=True)
+        with self.file_path.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(self.metrics) + "\n")