ErrorAI 1.5.0__tar.gz → 1.6.0__tar.gz

{errorai-1.5.0 → errorai-1.6.0}/ErrorAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ErrorAI
-Version: 1.5.0
+Version: 1.6.0
 Summary: Python-only autonomous runtime that watches/analyzes errors with safe local auto-fix fallbacks.
 Author: Aswanth R
 License: MIT

{errorai-1.5.0 → errorai-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ErrorAI
-Version: 1.5.0
+Version: 1.6.0
 Summary: Python-only autonomous runtime that watches/analyzes errors with safe local auto-fix fallbacks.
 Author: Aswanth R
 License: MIT

errorai-1.6.0/errorai/config.py

@@ -0,0 +1,311 @@
+from __future__ import annotations
+
+from dataclasses import replace
+from pathlib import Path
+import linecache
+import sys
+import threading
+import traceback
+from types import TracebackType
+from typing import Any
+
+from .bootstrap import BootstrapStatus, ensure_model, model_status
+from .config import ErrorAIConfig, autostart_enabled, load_config
+from .environment import Capabilities, detect_capabilities
+from .pipeline import Analyzer, Applier, Planner, Reporter, Watcher
+from .providers import ModelProvider, RulesOnlyProvider, HttpApiProvider
+
+try:
+    from .providers import LlamaCppProvider
+except ImportError:  # pragma: no cover - optional dependency
+    LlamaCppProvider = None  # type: ignore[assignment,misc]
+
+try:
+    from .providers import OnnxProvider
+except ImportError:  # pragma: no cover - optional dependency
+    OnnxProvider = None  # type: ignore[assignment,misc]
+
+
+class RuntimeManager:
+    _instance: "RuntimeManager | None" = None
+    _instance_lock = threading.Lock()
+
+    def __init__(self) -> None:
+        self._init_lock = threading.Lock()
+        self._initialized = False
+        self.config: ErrorAIConfig | None = None
+        self.capabilities: Capabilities | None = None
+        self.reporter: Reporter | None = None
+        self.analyzer: Analyzer | None = None
+        self.planner: Planner | None = None
+        self.applier: Applier | None = None
+        self.watcher: Watcher | None = None
+        self.provider: ModelProvider = RulesOnlyProvider()
+        self.bootstrap_status = BootstrapStatus(False, "rules-only", "Not initialized.", None)
+        self.mode = "rules-only"
+        self._orig_sys_hook = sys.excepthook
+        self._orig_thread_hook = getattr(threading, "excepthook", None)
+        self._orig_idle_print_exception = None
+        self._idle_hook_installed = False
+
+    @classmethod
+    def get_instance(cls) -> "RuntimeManager":
+        with cls._instance_lock:
+            if cls._instance is None:
+                cls._instance = cls()
+            return cls._instance
+
+    def initialize(self, config_override: ErrorAIConfig | None = None) -> "RuntimeManager":
+        if not autostart_enabled():
+            return self
+        with self._init_lock:
+            if self._initialized:
+                return self
+
+            self.config = config_override or load_config()
+            self.capabilities = detect_capabilities()
+            self.reporter = Reporter(self.config.runtime.project_root)
+            self.analyzer = Analyzer()
+            self.applier = Applier(self.config.runtime)
+            if self.config.model.provider in ("onnx", "llama_cpp"):
+                self.bootstrap_status = ensure_model(self.config.model, explicit=False)
+            else:
+                self.bootstrap_status = BootstrapStatus(
+                    True, "remote", "Using remote HTTP API provider; no local model needed.", None
+                )
+            self.provider = self._select_provider(self.bootstrap_status)
+            self.planner = Planner(self.provider)
+            self.watcher = Watcher(self.capabilities, self.reporter)
+            self._register_hooks()
+            watch_started = False
+            if self.config.runtime.auto_watch:
+                watch_started = self.watcher.start()
+            self.mode = "full" if self.bootstrap_status.ready and watch_started else "analyze-only"
+            if not self.bootstrap_status.ready:
+                self.mode = "rules-only"
+            self.reporter.log(
+                "runtime.initialized",
+                {
+                    "environment": self.capabilities.environment,
+                    "mode": self.mode,
+                    "model_mode": self.bootstrap_status.mode,
+                    "idle_hook_installed": self._idle_hook_installed,
+                },
+            )
+            self._initialized = True
+        return self
+
+    def _select_provider(self, status: BootstrapStatus) -> ModelProvider:
+        if self.config is None:
+            return RulesOnlyProvider()
+
+        provider_name = self.config.model.provider
+
+        if provider_name == "http_api":
+            return HttpApiProvider(self.config.model)
+
+        if not status.ready or status.model_path is None:
+            return RulesOnlyProvider()
+
+        if provider_name == "onnx":
+            if OnnxProvider is None:
+                return RulesOnlyProvider()
+            try:
+                return OnnxProvider(self.config.model, status.model_path)
+            except Exception:
+                return RulesOnlyProvider()
+
+        if provider_name == "llama_cpp":
+            if LlamaCppProvider is None:
+                return RulesOnlyProvider()
+            try:
+                return LlamaCppProvider(self.config.model, status.model_path)
+            except Exception:
+                return RulesOnlyProvider()
+
+        return RulesOnlyProvider()
+
+    def _register_hooks(self) -> None:
+        self._orig_sys_hook = sys.excepthook
+        sys.excepthook = self._sys_excepthook
+        if hasattr(threading, "excepthook"):
+            self._orig_thread_hook = threading.excepthook
+            threading.excepthook = self._thread_excepthook
+
+        if self.capabilities and self.capabilities.environment == "idle":
+            self._install_idle_hook()
+
+    def _install_idle_hook(self) -> None:
+        """IDLE runs user code inside idlelib.run's own exec/except loop and
+        prints tracebacks itself via idlelib.run.print_exception, so the
+        exception never reaches sys.excepthook. Patch that function directly.
+        """
+        try:
+            import idlelib.run as idle_run
+        except ImportError:  # pragma: no cover - not actually running under IDLE
+            return
+
+        if self._idle_hook_installed:
+            return
+
+        self._orig_idle_print_exception = idle_run.print_exception
+
+        def patched_print_exception() -> None:
+            exc_type, exc_value, exc_tb = sys.exc_info()
+            handled = False
+            if exc_type is not None:
+                handled = self.process_exception(exc_type, exc_value, exc_tb)
+            if handled:
+                print("[errorai] exception intercepted")
+                return
+            if self._orig_idle_print_exception is not None:
+                self._orig_idle_print_exception()
+
+        idle_run.print_exception = patched_print_exception
+        self._idle_hook_installed = True
+
+    def _uninstall_idle_hook(self) -> None:
+        if not self._idle_hook_installed:
+            return
+        try:
+            import idlelib.run as idle_run
+        except ImportError:  # pragma: no cover
+            self._idle_hook_installed = False
+            return
+        if self._orig_idle_print_exception is not None:
+            idle_run.print_exception = self._orig_idle_print_exception
+        self._idle_hook_installed = False
+
+    def _sys_excepthook(self, exc_type, exc_value, exc_tb):
+        handled = self.process_exception(exc_type, exc_value, exc_tb)
+        if handled:
+            print("[errorai] exception intercepted")
+            return
+        if self._orig_sys_hook:
+            self._orig_sys_hook(exc_type, exc_value, exc_tb)
+
+    def _thread_excepthook(self, args):
+        handled = self.process_exception(args.exc_type, args.exc_value, args.exc_traceback)
+        if handled:
+            print("[errorai] thread exception intercepted")
+            return
+        if self._orig_thread_hook:
+            self._orig_thread_hook(args)
+
+    def process_exception(self, exc_type, exc_value, exc_tb: TracebackType | None) -> bool:
+        if not exc_tb or not self.analyzer or not self.planner or not self.applier or not self.reporter:
+            return False
+        tb_list = traceback.extract_tb(exc_tb)
+        if not tb_list:
+            return False
+        frame = tb_list[-1]
+        filename = frame.filename
+        line = linecache.getline(filename, frame.lineno).strip() if filename else ""
+        analysis = self.analyzer.analyze_exception(exc_type, exc_value, exc_tb)
+        try:
+            plan = self.planner.plan_line_fix(line or frame.line or "", analysis["message"])
+        except Exception as provider_exc:
+            # Never let a broken/missing model provider raise out of an
+            # exception hook -- that can crash the interpreter (or IDLE's
+            # subprocess) while it's in the middle of handling an exception.
+            self.reporter.log(
+                "provider.error",
+                {"analysis": analysis, "error": f"{type(provider_exc).__name__}: {provider_exc}"},
+            )
+            print(f"[errorai] Model provider failed ({type(provider_exc).__name__}: {provider_exc})")
+            return False
+
+        if not plan or not filename or "<" in filename:
+            self.reporter.log("exception.analyzed", {"analysis": analysis, "fixed": False})
+            print(f"[errorai] Caught {analysis['type']}: {analysis['message']}")
+            print("[errorai] No automatic fix rule matched this error.")
+            return False
+
+        print(f"[errorai] Caught {analysis['type']}: {analysis['message']}")
+        print(f"[errorai] Suggested fix -> {plan}")
+
+        if self.capabilities and self.capabilities.can_prompt_user:
+            try:
+                answer = input("[errorai] Should I fix it [Y/N]: ").strip().lower()
+            except (EOFError, OSError):
+                answer = "n"
+            if answer not in {"y", "yes"}:
+                self.reporter.log("exception.declined", {"analysis": analysis})
+                print("[errorai] Skipped.")
+                return False
+
+        result = self.applier.apply_line_change(Path(filename), frame.lineno, plan)
+        self.reporter.log(
+            "exception.handled",
+            {
+                "analysis": analysis,
+                "changed": result.changed,
+                "detail": result.detail,
+                "preview": result.preview,
+            },
+        )
+        if result.preview and not result.changed:
+            print("[errorai] suggested fix (dry-run, not applied):")
+            print(result.preview)
+            print("[errorai] set dry_run = false in .errorai.toml to auto-apply")
+        elif result.changed:
+            print(f"[errorai] Applied fix to {filename}:{frame.lineno}")
+        return result.changed
+
+    def status_report(self) -> dict[str, Any]:
+        cfg = self.config or load_config()
+        caps = self.capabilities or detect_capabilities()
+        model = model_status(cfg.model)
+        return {
+            "environment": caps.environment,
+            "can_watch_fs": caps.can_watch_fs,
+            "can_apply_patches": caps.can_apply_patches,
+            "mode": self.mode,
+            "model_ready": model.ready,
+            "model_mode": self.bootstrap_status.mode,
+            "model_detail": self.bootstrap_status.detail,
+            "dry_run": cfg.runtime.dry_run,
+            "project_root": str(cfg.runtime.project_root),
+            "idle_hook_installed": self._idle_hook_installed,
+        }
+
+    def install_model(self) -> BootstrapStatus:
+        if self.config is None:
+            self.config = load_config()
+        self.bootstrap_status = ensure_model(self.config.model, explicit=True)
+        return self.bootstrap_status
+
+    def configure(self, **overrides) -> None:
+        if self.config is None:
+            self.config = load_config()
+        runtime_values = overrides.get("runtime", {})
+        model_values = overrides.get("model", {})
+        self.config = ErrorAIConfig(
+            runtime=replace(self.config.runtime, **runtime_values),
+            model=replace(self.config.model, **model_values),
+        )
+
+    def shutdown(self) -> None:
+        sys.excepthook = self._orig_sys_hook
+        if hasattr(threading, "excepthook") and self._orig_thread_hook is not None:
+            threading.excepthook = self._orig_thread_hook
+        self._uninstall_idle_hook()
+        self._initialized = False
+
+
+def get_runtime() -> RuntimeManager:
+    return RuntimeManager.get_instance()
+
+
+def configure(**overrides) -> RuntimeManager:
+    runtime = get_runtime()
+    runtime.configure(**overrides)
+    return runtime
+
+
+def _reset_for_tests() -> None:
+    runtime = RuntimeManager._instance
+    if runtime is not None:
+        runtime.shutdown()
+    RuntimeManager._instance = None
+    

errorai-1.6.0/errorai/providers.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+import json
+import re
+import urllib.error
+import urllib.request
+from .config import ModelConfig
+
+
+class ModelProvider(ABC):
+    @abstractmethod
+    def suggest_patch(self, snippet: str, error_message: str) -> str | None:
+        raise NotImplementedError
+
+
+class RulesOnlyProvider(ModelProvider):
+    def suggest_patch(self, snippet: str, error_message: str) -> str | None:
+        lowered = error_message.lower()
+        if "expected ':'" in lowered and not snippet.rstrip().endswith(":"):
+            return f"{snippet.rstrip()}:"
+        return None
+
+
+@dataclass
+class LlamaCppProvider(ModelProvider):
+    config: ModelConfig
+    model_path: Path
+    _llm: object | None = None
+
+    def _get_llm(self):
+        if self._llm is not None:
+            return self._llm
+        from llama_cpp import Llama  # type: ignore
+
+        self._llm = Llama(
+            model_path=str(self.model_path),
+            n_ctx=self.config.context_window,
+            verbose=False,
+        )
+        return self._llm
+
+    def suggest_patch(self, snippet: str, error_message: str) -> str | None:
+        llm = self._get_llm()
+        prompt = (
+            "You are fixing Python code. Return only the fixed single line.\n"
+            f"Error: {error_message}\n"
+            f"Code: {snippet}\n"
+            "Fix:"
+        )
+        response = llm(
+            prompt=prompt,
+            temperature=self.config.temperature,
+            max_tokens=128,
+            stop=["\n\n"],
+        )
+        text = response["choices"][0]["text"].strip()
+        return text or None
+
+
+@dataclass
+class OnnxProvider(ModelProvider):
+    config: ModelConfig
+    model_path: Path
+    _model: object | None = None
+    _tokenizer: object | None = None
+
+    def _get_model(self):
+        if self._model is not None and self._tokenizer is not None:
+            return self._model, self._tokenizer
+
+        # optimum wraps onnxruntime with a HF-style generate() API, so we
+        # don't have to hand-roll KV-cache decoding against a raw .onnx graph.
+        from optimum.onnxruntime import ORTModelForCausalLM  # type: ignore
+        from transformers import AutoTokenizer  # type: ignore
+
+        model_dir = self.model_path if self.model_path.is_dir() else self.model_path.parent
+
+        self._tokenizer = AutoTokenizer.from_pretrained(model_dir)
+        self._model = ORTModelForCausalLM.from_pretrained(
+            model_dir,
+            subfolder="onnx",
+            file_name="model_int8.onnx",
+            use_cache=True,
+        )
+        return self._model, self._tokenizer
+
+    def suggest_patch(self, snippet: str, error_message: str) -> str | None:
+        model, tokenizer = self._get_model()
+
+        prompt = (
+            "You are fixing Python code. Return only the fixed single line.\n"
+            f"Error: {error_message}\n"
+            f"Code: {snippet}\n"
+            "Fix:"
+        )
+        inputs = tokenizer(prompt, return_tensors="pt")
+        max_new_tokens = 64
+        eos_token_id = tokenizer.eos_token_id
+
+        try:
+            output_ids = model.generate(
+                **inputs,
+                max_new_tokens=max_new_tokens,
+                do_sample=self.config.temperature > 0,
+                temperature=max(self.config.temperature, 1e-4),
+                eos_token_id=eos_token_id,
+                pad_token_id=eos_token_id,
+            )
+        except Exception:
+            return None
+
+        generated = output_ids[0][inputs["input_ids"].shape[-1]:]
+        text = tokenizer.decode(generated, skip_special_tokens=True).strip()
+        # Model can wander onto a second line/explanation; keep only the fix.
+        text = text.splitlines()[0].strip() if text else ""
+        return text or None
+
+
+_PROSE_PREFIXES = (
+    "here", "here's", "sure", "the fix", "this fixes", "note:", "note that",
+    "explanation", "you should", "to fix", "i ", "i'd", "the corrected",
+    "certainly", "of course", "this line", "this code", "in python",
+)
+
+
+def _clean_line_response(text: str | None, original_line: str) -> str | None:
+    """Reduce a chat-model reply down to a single bare code line.
+
+    Models asked for "just the fix" routinely still wrap it in a markdown
+    fence, prepend "Here's the fix:", or tack on an explanatory comment.
+    None of that should ever reach Applier.apply_line_change, since the user
+    is agreeing to apply exactly one corrected line, not a paragraph.
+    """
+    if not text:
+        return None
+    text = text.strip()
+    if text.startswith("```"):
+        text = re.sub(r"^```[a-zA-Z0-9]*\n?", "", text)
+        text = re.sub(r"\n?```$", "", text).strip()
+
+    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
+    lines = [ln for ln in lines if not ln.startswith("```")]
+    if not lines:
+        return None
+
+    candidate = lines[0]
+    lowered = candidate.lower()
+    if any(lowered.startswith(p) for p in _PROSE_PREFIXES):
+        # Try the next non-prose line instead of giving up outright.
+        remaining = [ln for ln in lines[1:] if not any(ln.lower().startswith(p) for p in _PROSE_PREFIXES)]
+        if not remaining:
+            return None
+        candidate = remaining[0]
+
+    # Strip a trailing comment the model added that wasn't in the original --
+    # that's commentary, not part of the fix.
+    if "#" not in original_line and "#" in candidate:
+        candidate = candidate.split("#", 1)[0].rstrip()
+
+    return candidate or None
+
+
+@dataclass
+class HttpApiProvider(ModelProvider):
+    """Uses a free, keyless, hosted chat-completions API instead of a local model.
+
+    Default target is OVHcloud AI Endpoints' anonymous tier (no signup, no
+    API key, ~2 req/min per IP): https://endpoints.ai.cloud.ovh.net
+    Trade-off vs the local ONNX provider: the error line + message leave the
+    machine over the network. Only use this provider if that's acceptable.
+    """
+
+    config: ModelConfig
+
+    def suggest_patch(self, snippet: str, error_message: str) -> str | None:
+        prompt = (
+            "Fix this single line of Python code so it no longer raises the "
+            "error below. Reply with ONLY the corrected line of code and "
+            "nothing else -- no explanation, no markdown fences, no comments, "
+            "no extra lines.\n\n"
+            f"Error: {error_message}\n"
+            f"Line: {snippet}\n"
+            "Fixed line:"
+        )
+        payload = json.dumps(
+            {
+                "model": self.config.http_api_model,
+                "messages": [
+                    {"role": "system", "content": "You output only corrected code, never prose."},
+                    {"role": "user", "content": prompt},
+                ],
+                "max_tokens": 100,
+                "temperature": 0.0,
+            }
+        ).encode("utf-8")
+
+        request = urllib.request.Request(
+            self.config.http_api_base_url,
+            data=payload,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=self.config.http_api_timeout) as response:
+                body = json.loads(response.read().decode("utf-8"))
+            text = body["choices"][0]["message"]["content"]
+        except (urllib.error.URLError, TimeoutError, KeyError, IndexError, ValueError, OSError):
+            return None
+
+        return _clean_line_response(text, snippet)

{errorai-1.5.0 → errorai-1.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ErrorAI"
-version = "1.5.0"
+version = "1.6.0"
 description = "Python-only autonomous runtime that watches/analyzes errors with safe local auto-fix fallbacks."
 readme = "README.md"
 authors = [

errorai-1.5.0/errorai/config.py

@@ -1,155 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field, replace
-from pathlib import Path
-import os
-import sys
-from typing import Any, Dict
-
-
-def _default_project_root() -> Path:
-    """Prefer the directory of the script actually being run.
-
-    Path.cwd() is wrong in IDLE (and many IDEs): "Run Module" does not chdir
-    into the script's folder, it just sets sys.argv[0] to the script path.
-    Falling back to cwd() there means the running file is almost never
-    considered "inside" project_root, and every fix silently gets blocked by
-    Applier.can_edit().
-    """
-    try:
-        candidate = sys.argv[0]
-        if candidate and Path(candidate).is_file():
-            return Path(candidate).resolve().parent
-    except Exception:
-        pass
-    return Path.cwd()
-
-try:
-    import tomllib
-except ModuleNotFoundError:  # pragma: no cover - py<3.11 fallback
-    import tomli as tomllib
-
-
-def _default_cache_dir() -> Path:
-    try:
-        from platformdirs import user_cache_dir
-
-        return Path(user_cache_dir("errorai", "ErrorAI"))
-    except Exception:
-        return Path.home() / ".cache" / "errorai"
-
-
-@dataclass(frozen=True)
-class RuntimeConfig:
-    auto_watch: bool = True
-    safe_mode: bool = True
-    dry_run: bool = True
-    project_root: Path = field(default_factory=_default_project_root)
-    ignore_patterns: tuple[str, ...] = (
-        ".git",
-        "__pycache__",
-        ".env",
-        ".venv",
-        "venv",
-        "node_modules",
-        "*.lock",
-        ".errorai",
-    )
-
-
-@dataclass(frozen=True)
-class ModelConfig:
-    provider: str = "onnx"
-    name: str = "onnx-qwen2.5-coder-0.5b"
-    repo_id: str = "onnx-community/Qwen2.5-Coder-0.5B-Instruct"
-    model_url: str = (
-        "https://huggingface.co/onnx-community/Qwen2.5-Coder-0.5B-Instruct/resolve/main/"
-        "onnx/model.onnx"
-    )
-    context_window: int = 4096
-    temperature: float = 0.1
-    auto_bootstrap: bool = True
-    download_timeout: int = 600
-    cache_dir: Path = field(default_factory=_default_cache_dir)
-
-
-@dataclass(frozen=True)
-class ErrorAIConfig:
-    runtime: RuntimeConfig = field(default_factory=RuntimeConfig)
-    model: ModelConfig = field(default_factory=ModelConfig)
-
-
-def _read_toml(path: Path) -> Dict[str, Any]:
-    if not path.exists():
-        return {}
-    with path.open("rb") as handle:
-        return tomllib.load(handle)
-
-
-def _coerce_runtime(base: RuntimeConfig, values: Dict[str, Any]) -> RuntimeConfig:
-    data = {}
-    for key in ("auto_watch", "safe_mode", "dry_run"):
-        if key in values:
-            data[key] = bool(values[key])
-    if "ignore_patterns" in values:
-        data["ignore_patterns"] = tuple(str(v) for v in values["ignore_patterns"])
-    if "project_root" in values:
-        data["project_root"] = Path(values["project_root"]).resolve()
-    return replace(base, **data)
-
-
-def _coerce_model(base: ModelConfig, values: Dict[str, Any]) -> ModelConfig:
-    data = {}
-    for key in ("provider", "name", "repo_id", "model_url"):
-        if key in values:
-            data[key] = str(values[key])
-    if "context_window" in values:
-        data["context_window"] = int(values["context_window"])
-    if "temperature" in values:
-        data["temperature"] = float(values["temperature"])
-    if "auto_bootstrap" in values:
-        data["auto_bootstrap"] = bool(values["auto_bootstrap"])
-    if "download_timeout" in values:
-        data["download_timeout"] = int(values["download_timeout"])
-    if "cache_dir" in values:
-        data["cache_dir"] = Path(values["cache_dir"]).expanduser().resolve()
-    return replace(base, **data)
-
-
-def load_config(project_root: Path | None = None) -> ErrorAIConfig:
-    root = (project_root or Path.cwd()).resolve()
-    config = ErrorAIConfig(runtime=RuntimeConfig(project_root=root))
-    pyproject = _read_toml(root / "pyproject.toml")
-    pyproject_settings = pyproject.get("tool", {}).get("errorai", {})
-    local_settings = _read_toml(root / ".errorai.toml")
-
-    runtime_values = {}
-    model_values = {}
-    for source in (pyproject_settings, local_settings):
-        runtime_values.update(source.get("runtime", {}))
-        model_values.update(source.get("model", {}))
-
-    return ErrorAIConfig(
-        runtime=_coerce_runtime(config.runtime, runtime_values),
-        model=_coerce_model(config.model, model_values),
-    )
-
-
-def config_template() -> str:
-    return """[runtime]
-auto_watch = true
-safe_mode = true
-dry_run = true
-ignore_patterns = [".git", "__pycache__", ".env", ".venv", "venv", "node_modules", "*.lock", ".errorai"]
-
-[model]
-provider = "onnx"
-name = "onnx-default-python-expert"
-context_window = 4096
-temperature = 0.1
-auto_bootstrap = true
-"""
-
-
-def autostart_enabled() -> bool:
-    return os.environ.get("ERRORAI_AUTOSTART", "1") != "0"

errorai-1.5.0/errorai/providers.py

@@ -1,112 +0,0 @@
-from __future__ import annotations
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from pathlib import Path
-from .config import ModelConfig
-
-
-class ModelProvider(ABC):
-    @abstractmethod
-    def suggest_patch(self, snippet: str, error_message: str) -> str | None:
-        raise NotImplementedError
-
-
-class RulesOnlyProvider(ModelProvider):
-    def suggest_patch(self, snippet: str, error_message: str) -> str | None:
-        lowered = error_message.lower()
-        if "expected ':'" in lowered and not snippet.rstrip().endswith(":"):
-            return f"{snippet.rstrip()}:"
-        return None
-
-
-@dataclass
-class LlamaCppProvider(ModelProvider):
-    config: ModelConfig
-    model_path: Path
-    _llm: object | None = None
-
-    def _get_llm(self):
-        if self._llm is not None:
-            return self._llm
-        from llama_cpp import Llama  # type: ignore
-
-        self._llm = Llama(
-            model_path=str(self.model_path),
-            n_ctx=self.config.context_window,
-            verbose=False,
-        )
-        return self._llm
-
-    def suggest_patch(self, snippet: str, error_message: str) -> str | None:
-        llm = self._get_llm()
-        prompt = (
-            "You are fixing Python code. Return only the fixed single line.\n"
-            f"Error: {error_message}\n"
-            f"Code: {snippet}\n"
-            "Fix:"
-        )
-        response = llm(
-            prompt=prompt,
-            temperature=self.config.temperature,
-            max_tokens=128,
-            stop=["\n\n"],
-        )
-        text = response["choices"][0]["text"].strip()
-        return text or None
-
-
-@dataclass
-class OnnxProvider(ModelProvider):
-    config: ModelConfig
-    model_path: Path
-    _model: object | None = None
-    _tokenizer: object | None = None
-
-    def _get_model(self):
-        if self._model is not None and self._tokenizer is not None:
-            return self._model, self._tokenizer
-
-        # optimum wraps onnxruntime with a HF-style generate() API, so we
-        # don't have to hand-roll KV-cache decoding against a raw .onnx graph.
-        from optimum.onnxruntime import ORTModelForCausalLM  # type: ignore
-        from transformers import AutoTokenizer  # type: ignore
-
-        model_dir = self.model_path if self.model_path.is_dir() else self.model_path.parent
-
-        self._tokenizer = AutoTokenizer.from_pretrained(model_dir)
-        self._model = ORTModelForCausalLM.from_pretrained(
-            model_dir,
-            use_cache=True,
-        )
-        return self._model, self._tokenizer
-
-    def suggest_patch(self, snippet: str, error_message: str) -> str | None:
-        model, tokenizer = self._get_model()
-
-        prompt = (
-            "You are fixing Python code. Return only the fixed single line.\n"
-            f"Error: {error_message}\n"
-            f"Code: {snippet}\n"
-            "Fix:"
-        )
-        inputs = tokenizer(prompt, return_tensors="pt")
-        max_new_tokens = 64
-        eos_token_id = tokenizer.eos_token_id
-
-        try:
-            output_ids = model.generate(
-                **inputs,
-                max_new_tokens=max_new_tokens,
-                do_sample=self.config.temperature > 0,
-                temperature=max(self.config.temperature, 1e-4),
-                eos_token_id=eos_token_id,
-                pad_token_id=eos_token_id,
-            )
-        except Exception:
-            return None
-
-        generated = output_ids[0][inputs["input_ids"].shape[-1]:]
-        text = tokenizer.decode(generated, skip_special_tokens=True).strip()
-        # Model can wander onto a second line/explanation; keep only the fix.
-        text = text.splitlines()[0].strip() if text else ""
-        return text or None