ErrorAI 0.9.0__tar.gz

errorai-0.9.0/ErrorAI.egg-info/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: ErrorAI
+Version: 0.9.0
+Summary: Python-only autonomous runtime that watches/analyzes errors with safe local auto-fix fallbacks.
+Author: Aswanth R
+License: MIT
+Project-URL: Homepage, https://github.com/NodeX-AR/ErrorAI
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: platformdirs>=3.0
+Requires-Dist: onnxruntime>=1.18.0
+Provides-Extra: watch
+Requires-Dist: watchdog>=4.0.0; extra == "watch"
+
+# ErrorAI v2
+
+`ErrorAI` is a Python-only autonomous runtime that starts on import, catches exceptions, and operates with safe-by-default watch/read/write behavior.
+
+## Quickstart
+
+```bash
+pip install ErrorAI
+```
+
+```python
+import errorai
+```
+
+That import initializes a singleton runtime, registers exception hooks, and starts background watch services when supported.
+
+## Optional setup commands
+
+
+```bash
+errorai init
+errorai doctor
+errorai install-model
+```
+
+- `init`: writes default `.errorai.toml`
+- `doctor`: reports environment/runtime/model readiness and fallback mode
+- `install-model`: retries local model bootstrap
+
+## Model bootstrap strategy
+
+- Core package does not bundle large model weights.
+- On import/first use, ErrorAI attempts to bootstrap a lightweight local coding model into user cache.
+- If bootstrap fails (offline/network/permissions), runtime continues in `rules-only` mode with clear status.
+
+## Safety defaults
+
+- Safe mode is enabled by default.
+- Writes are restricted to the project root.
+- Sensitive/common ignore patterns are blocked by default.
+- Dry-run mode is on by default to preview edits before writing.
+
+## Migration notes from v1 beta
+
+- `import errorai` now auto-starts the runtime; explicit `global_activate()` is optional.
+- `@watch` and `catch_errors` remain available for compatibility but are no longer required.

errorai-0.9.0/ErrorAI.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+README.md
+pyproject.toml
+ErrorAI.egg-info/PKG-INFO
+ErrorAI.egg-info/SOURCES.txt
+ErrorAI.egg-info/dependency_links.txt
+ErrorAI.egg-info/entry_points.txt
+ErrorAI.egg-info/requires.txt
+ErrorAI.egg-info/top_level.txt
+errorai/__init__.py
+errorai/__main__.py
+errorai/bootstrap.py
+errorai/cli.py
+errorai/compat.py
+errorai/config.py
+errorai/environment.py
+errorai/pipeline.py
+errorai/providers.py
+errorai/runtime.py
+errorai/universal.py
+tests/test_bootstrap.py
+tests/test_config.py
+tests/test_runtime.py
+tests/test_safety.py

errorai-0.9.0/ErrorAI.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

errorai-0.9.0/ErrorAI.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+errorai = errorai.cli:main

errorai-0.9.0/ErrorAI.egg-info/requires.txt

@@ -0,0 +1,5 @@
+platformdirs>=3.0
+onnxruntime>=1.18.0
+
+[watch]
+watchdog>=4.0.0

errorai-0.9.0/ErrorAI.egg-info/top_level.txt

@@ -0,0 +1 @@
+errorai

errorai-0.9.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: ErrorAI
+Version: 0.9.0
+Summary: Python-only autonomous runtime that watches/analyzes errors with safe local auto-fix fallbacks.
+Author: Aswanth R
+License: MIT
+Project-URL: Homepage, https://github.com/NodeX-AR/ErrorAI
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: platformdirs>=3.0
+Requires-Dist: onnxruntime>=1.18.0
+Provides-Extra: watch
+Requires-Dist: watchdog>=4.0.0; extra == "watch"
+
+# ErrorAI v2
+
+`ErrorAI` is a Python-only autonomous runtime that starts on import, catches exceptions, and operates with safe-by-default watch/read/write behavior.
+
+## Quickstart
+
+```bash
+pip install ErrorAI
+```
+
+```python
+import errorai
+```
+
+That import initializes a singleton runtime, registers exception hooks, and starts background watch services when supported.
+
+## Optional setup commands
+
+
+```bash
+errorai init
+errorai doctor
+errorai install-model
+```
+
+- `init`: writes default `.errorai.toml`
+- `doctor`: reports environment/runtime/model readiness and fallback mode
+- `install-model`: retries local model bootstrap
+
+## Model bootstrap strategy
+
+- Core package does not bundle large model weights.
+- On import/first use, ErrorAI attempts to bootstrap a lightweight local coding model into user cache.
+- If bootstrap fails (offline/network/permissions), runtime continues in `rules-only` mode with clear status.
+
+## Safety defaults
+
+- Safe mode is enabled by default.
+- Writes are restricted to the project root.
+- Sensitive/common ignore patterns are blocked by default.
+- Dry-run mode is on by default to preview edits before writing.
+
+## Migration notes from v1 beta
+
+- `import errorai` now auto-starts the runtime; explicit `global_activate()` is optional.
+- `@watch` and `catch_errors` remain available for compatibility but are no longer required.

errorai-0.9.0/README.md

@@ -0,0 +1,46 @@
+# ErrorAI v2
+
+`ErrorAI` is a Python-only autonomous runtime that starts on import, catches exceptions, and operates with safe-by-default watch/read/write behavior.
+
+## Quickstart
+
+```bash
+pip install ErrorAI
+```
+
+```python
+import errorai
+```
+
+That import initializes a singleton runtime, registers exception hooks, and starts background watch services when supported.
+
+## Optional setup commands
+
+
+```bash
+errorai init
+errorai doctor
+errorai install-model
+```
+
+- `init`: writes default `.errorai.toml`
+- `doctor`: reports environment/runtime/model readiness and fallback mode
+- `install-model`: retries local model bootstrap
+
+## Model bootstrap strategy
+
+- Core package does not bundle large model weights.
+- On import/first use, ErrorAI attempts to bootstrap a lightweight local coding model into user cache.
+- If bootstrap fails (offline/network/permissions), runtime continues in `rules-only` mode with clear status.
+
+## Safety defaults
+
+- Safe mode is enabled by default.
+- Writes are restricted to the project root.
+- Sensitive/common ignore patterns are blocked by default.
+- Dry-run mode is on by default to preview edits before writing.
+
+## Migration notes from v1 beta
+
+- `import errorai` now auto-starts the runtime; explicit `global_activate()` is optional.
+- `@watch` and `catch_errors` remain available for compatibility but are no longer required.

errorai-0.9.0/errorai/__init__.py

@@ -0,0 +1,9 @@
+from .compat import catch_errors, global_activate, watch
+from .runtime import configure, get_runtime
+
+__version__ = "2.0.0"
+__all__ = ["get_runtime", "configure", "watch", "catch_errors", "global_activate"]
+
+# Import-time auto-start for zero-decorator usage.
+runtime = get_runtime()
+runtime.initialize()

errorai-0.9.0/errorai/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

errorai-0.9.0/errorai/bootstrap.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import urllib.request
+
+from .config import ModelConfig
+
+
+@dataclass(frozen=True)
+class BootstrapStatus:
+    ready: bool
+    mode: str
+    detail: str
+    model_path: Path | None = None
+
+
+def model_path(config: ModelConfig) -> Path:
+    return config.cache_dir / "models" / f"{config.name}.gguf"
+
+
+def _download_model(url: str, destination: Path) -> None:
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    with urllib.request.urlopen(url, timeout=5) as response, destination.open("wb") as handle:
+        handle.write(response.read())
+
+
+def ensure_model(config: ModelConfig, explicit: bool = False) -> BootstrapStatus:
+    path = model_path(config)
+    if path.exists():
+        return BootstrapStatus(True, "model-ready", "Local model available.", path)
+
+    if not explicit and not config.auto_bootstrap:
+        return BootstrapStatus(False, "rules-only", "Auto-bootstrap is disabled.", None)
+
+    try:
+        _download_model(config.model_url, path)
+    except Exception as exc:
+        return BootstrapStatus(
+            False,
+            "rules-only",
+            f"Model bootstrap failed ({exc.__class__.__name__}); continuing without model.",
+            None,
+        )
+    return BootstrapStatus(True, "model-ready", "Model bootstrap completed.", path)
+
+
+def model_status(config: ModelConfig) -> BootstrapStatus:
+    path = model_path(config)
+    if path.exists():
+        return BootstrapStatus(True, "model-ready", "Model file exists.", path)
+    return BootstrapStatus(False, "rules-only", "Model file is not installed.", None)

errorai-0.9.0/errorai/cli.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from .bootstrap import ensure_model
+from .config import config_template, load_config
+from .runtime import get_runtime
+
+
+def cmd_init(args) -> int:
+    root = Path.cwd()
+    config_path = root / ".errorai.toml"
+    if not config_path.exists() or args.force:
+        config_path.write_text(config_template(), encoding="utf-8")
+        print(f"[errorai] Wrote {config_path}")
+    else:
+        print(f"[errorai] Config already exists: {config_path}")
+    return 0
+
+
+def cmd_doctor(_args) -> int:
+    runtime = get_runtime().initialize()
+    status = runtime.status_report()
+    print("ErrorAI Doctor")
+    for key in (
+        "environment",
+        "can_watch_fs",
+        "can_apply_patches",
+        "mode",
+        "model_ready",
+        "model_mode",
+        "model_detail",
+        "dry_run",
+        "project_root",
+    ):
+        print(f"- {key}: {status[key]}")
+    return 0
+
+
+def cmd_install_model(_args) -> int:
+    cfg = load_config()
+    status = ensure_model(cfg.model, explicit=True)
+    print(status.detail)
+    return 0 if status.ready else 1
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="errorai")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    init_parser = sub.add_parser("init", help="Create default .errorai.toml config.")
+    init_parser.add_argument("--force", action="store_true", help="Overwrite existing config.")
+    init_parser.set_defaults(func=cmd_init)
+
+    doctor_parser = sub.add_parser("doctor", help="Check runtime readiness and fallback state.")
+    doctor_parser.set_defaults(func=cmd_doctor)
+
+    install_parser = sub.add_parser("install-model", help="Install or retry local model bootstrap.")
+    install_parser.set_defaults(func=cmd_install_model)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return args.func(args)

errorai-0.9.0/errorai/compat.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import functools
+import sys
+
+from .runtime import get_runtime
+
+
+def watch(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception:
+            exc_type, exc_value, exc_tb = sys.exc_info()
+            get_runtime().process_exception(exc_type, exc_value, exc_tb)
+            raise
+
+    return wrapper
+
+
+class catch_errors:
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_tb):
+        if exc_type is None:
+            return False
+        get_runtime().process_exception(exc_type, exc_value, exc_tb)
+        return True
+
+
+def global_activate():
+    runtime = get_runtime()
+    runtime.initialize()
+    return runtime

errorai-0.9.0/errorai/config.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field, replace
+from pathlib import Path
+import os
+from typing import Any, Dict
+
+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=lambda: Path.cwd())
+    ignore_patterns: tuple[str, ...] = (
+        ".git",
+        "__pycache__",
+        ".env",
+        ".venv",
+        "venv",
+        "node_modules",
+        "*.lock",
+        ".errorai",
+    )
+
+
+@dataclass(frozen=True)
+class ModelConfig:
+    provider: str = "onnx"
+    name: str = "onnx-default-python-expert"
+    model_url: str = (
+        "https://huggingface.co/onnx-community/Qwen2.5-Coder-1.5B-Instruct-ONNX/resolve/main/"
+        "model.onnx"
+    )
+    context_window: int = 4096
+    temperature: float = 0.1
+    auto_bootstrap: bool = True
+    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", "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 "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-0.9.0/errorai/environment.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import os
+import sys
+
+
+@dataclass(frozen=True)
+class Capabilities:
+    environment: str
+    can_watch_fs: bool
+    can_apply_patches: bool
+    can_prompt_user: bool
+
+
+def detect_capabilities() -> Capabilities:
+    env = "generic"
+    interactive = bool(getattr(sys, "ps1", None) or sys.flags.interactive)
+    if "ipykernel" in sys.modules or "JPY_PARENT_PID" in os.environ:
+        env = "notebook"
+    elif "idlelib" in sys.modules:
+        env = "idle"
+    elif interactive:
+        env = "interactive"
+    elif sys.stdin and sys.stdin.isatty():
+        env = "terminal"
+    else:
+        env = "ide"
+
+    can_watch_fs = env not in {"notebook"}
+    can_apply_patches = env != "notebook"
+    can_prompt_user = env in {"terminal", "interactive", "idle", "ide"}
+    return Capabilities(
+        environment=env,
+        can_watch_fs=can_watch_fs,
+        can_apply_patches=can_apply_patches,
+        can_prompt_user=can_prompt_user,
+    )

errorai-0.9.0/errorai/pipeline.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+import fnmatch
+import json
+import threading
+from typing import Any
+
+from .config import RuntimeConfig
+from .environment import Capabilities
+from .providers import ModelProvider
+
+
+class Reporter:
+    def __init__(self, project_root: Path):
+        self.log_path = project_root / ".errorai" / "logs" / "operations.log"
+        self.log_path.parent.mkdir(parents=True, exist_ok=True)
+        self._lock = threading.Lock()
+
+    def log(self, event: str, payload: dict[str, Any]) -> None:
+        record = {
+            "time": datetime.now(timezone.utc).isoformat(),
+            "event": event,
+            "payload": payload,
+        }
+        with self._lock, self.log_path.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(record) + "\n")
+
+
+class Analyzer:
+    def analyze_exception(self, exc_type, exc_value, exc_tb) -> dict[str, Any]:
+        return {
+            "type": getattr(exc_type, "__name__", str(exc_type)),
+            "message": str(exc_value),
+        }
+
+
+class Planner:
+    def __init__(self, provider: ModelProvider):
+        self.provider = provider
+
+    def plan_line_fix(self, line: str, error_message: str) -> str | None:
+        return self.provider.suggest_patch(line, error_message)
+
+
+@dataclass
+class ApplyResult:
+    changed: bool
+    detail: str
+    preview: str | None = None
+
+
+class Applier:
+    def __init__(self, config: RuntimeConfig):
+        self.config = config
+        self.project_root = config.project_root.resolve()
+
+    def _is_ignored(self, path: Path) -> bool:
+        rel = str(path)
+        for pattern in self.config.ignore_patterns:
+            if fnmatch.fnmatch(path.name, pattern) or fnmatch.fnmatch(rel, pattern):
+                return True
+            if pattern in path.parts:
+                return True
+        return False
+
+    def _is_within_root(self, path: Path) -> bool:
+        try:
+            path.resolve().relative_to(self.project_root)
+        except ValueError:
+            return False
+        return True
+
+    def can_edit(self, file_path: Path) -> bool:
+        path = file_path.resolve()
+        return self._is_within_root(path) and not self._is_ignored(path)
+
+    def apply_line_change(self, file_path: Path, lineno: int, new_line: str) -> ApplyResult:
+        path = file_path.resolve()
+        if not self.can_edit(path):
+            return ApplyResult(False, "Blocked by safe mode restrictions.")
+
+        lines = path.read_text(encoding="utf-8").splitlines(keepends=True)
+        if lineno < 1 or lineno > len(lines):
+            return ApplyResult(False, "Line number out of range.")
+
+        old_line = lines[lineno - 1]
+        indentation = old_line[: len(old_line) - len(old_line.lstrip())]
+        candidate = f"{indentation}{new_line.strip()}\n"
+        preview = f"- {old_line.rstrip()}\n+ {candidate.rstrip()}"
+        if self.config.dry_run:
+            return ApplyResult(False, "Dry-run mode enabled; no write applied.", preview=preview)
+
+        lines[lineno - 1] = candidate
+        path.write_text("".join(lines), encoding="utf-8")
+        return ApplyResult(True, "Edit applied.", preview=preview)
+
+
+class Watcher:
+    def __init__(self, capabilities: Capabilities, reporter: Reporter):
+        self.capabilities = capabilities
+        self.reporter = reporter
+        self.started = False
+
+    def start(self) -> bool:
+        if not self.capabilities.can_watch_fs:
+            self.reporter.log("watcher.skipped", {"reason": "environment unsupported"})
+            return False
+        try:
+            from watchdog.observers import Observer  # type: ignore  # noqa: F401
+        except Exception:
+            self.reporter.log("watcher.skipped", {"reason": "watchdog unavailable"})
+            return False
+        self.started = True
+        self.reporter.log("watcher.started", {})
+        return True

errorai-0.9.0/errorai/providers.py

@@ -0,0 +1,57 @@
+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

errorai-0.9.0/errorai/runtime.py

@@ -0,0 +1,186 @@
+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 LlamaCppProvider, ModelProvider, RulesOnlyProvider
+
+
+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)
+
+    @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)
+            self.bootstrap_status = ensure_model(self.config.model, explicit=False)
+            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,
+                },
+            )
+            self._initialized = True
+        return self
+
+    def _select_provider(self, status: BootstrapStatus) -> ModelProvider:
+        if not status.ready or status.model_path is None or self.config is None:
+            return RulesOnlyProvider()
+        if self.config.model.provider != "llama_cpp":
+            return RulesOnlyProvider()
+        try:
+            return LlamaCppProvider(self.config.model, status.model_path)
+        except Exception:
+            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
+
+    def _sys_excepthook(self, exc_type, exc_value, exc_tb):
+        self.process_exception(exc_type, exc_value, exc_tb)
+        if self._orig_sys_hook:
+            self._orig_sys_hook(exc_type, exc_value, exc_tb)
+
+    def _thread_excepthook(self, args):
+        self.process_exception(args.exc_type, args.exc_value, args.exc_traceback)
+        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)
+        plan = self.planner.plan_line_fix(line or frame.line or "", analysis["message"])
+        if not plan or not filename or "<" in filename:
+            self.reporter.log("exception.analyzed", {"analysis": analysis, "fixed": False})
+            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,
+            },
+        )
+        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),
+        }
+
+    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._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-0.9.0/errorai/universal.py

@@ -0,0 +1,8 @@
+from .compat import catch_errors, global_activate, watch
+from .runtime import get_runtime
+
+
+class ErrorAI:
+    @staticmethod
+    def inspect_and_fix(exc_type, exc_value, exc_tb):
+        return get_runtime().process_exception(exc_type, exc_value, exc_tb)

errorai-0.9.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=61.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ErrorAI"
+version = "0.9.0"
+description = "Python-only autonomous runtime that watches/analyzes errors with safe local auto-fix fallbacks."
+readme = "README.md"
+authors = [
+    { name = "Aswanth R" }
+]
+license = { text = "MIT" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Quality Assurance",
+]
+requires-python = ">=3.9"
+dependencies = [
+    "platformdirs>=3.0",
+    "onnxruntime>=1.18.0",
+]
+
+[project.optional-dependencies]
+watch = ["watchdog>=4.0.0"]
+
+[project.scripts]
+errorai = "errorai.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/NodeX-AR/ErrorAI"

errorai-0.9.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

errorai-0.9.0/tests/test_bootstrap.py

@@ -0,0 +1,34 @@
+import os
+import tempfile
+from pathlib import Path
+import unittest
+
+os.environ["ERRORAI_AUTOSTART"] = "0"
+
+from errorai import bootstrap
+from errorai.config import ModelConfig
+
+
+class BootstrapTests(unittest.TestCase):
+    def test_bootstrap_fallback_to_rules_only_on_failure(self):
+        with tempfile.TemporaryDirectory() as td:
+            cfg = ModelConfig(cache_dir=Path(td))
+
+            original_download = bootstrap._download_model
+
+            def fail_download(url, destination):
+                raise OSError("offline")
+
+            bootstrap._download_model = fail_download
+            try:
+                status = bootstrap.ensure_model(cfg, explicit=True)
+            finally:
+                bootstrap._download_model = original_download
+
+            self.assertFalse(status.ready)
+            self.assertEqual(status.mode, "rules-only")
+            self.assertIn("failed", status.detail.lower())
+
+
+if __name__ == "__main__":
+    unittest.main()

errorai-0.9.0/tests/test_config.py

@@ -0,0 +1,31 @@
+import os
+import tempfile
+from pathlib import Path
+import unittest
+
+os.environ["ERRORAI_AUTOSTART"] = "0"
+
+from errorai.config import load_config
+
+
+class ConfigTests(unittest.TestCase):
+    def test_config_parsing_with_file_override(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            (root / "pyproject.toml").write_text(
+                "[tool.errorai.runtime]\nauto_watch = false\n\n[tool.errorai.model]\ncontext_window = 2048\n",
+                encoding="utf-8",
+            )
+            (root / ".errorai.toml").write_text(
+                "[runtime]\ndry_run = false\n\n[model]\ntemperature = 0.2\n",
+                encoding="utf-8",
+            )
+            config = load_config(root)
+            self.assertFalse(config.runtime.auto_watch)
+            self.assertFalse(config.runtime.dry_run)
+            self.assertEqual(config.model.context_window, 2048)
+            self.assertEqual(config.model.temperature, 0.2)
+
+
+if __name__ == "__main__":
+    unittest.main()

errorai-0.9.0/tests/test_runtime.py

@@ -0,0 +1,33 @@
+import os
+import sys
+import unittest
+
+os.environ["ERRORAI_AUTOSTART"] = "0"
+
+from errorai.runtime import _reset_for_tests, get_runtime
+
+
+class RuntimeTests(unittest.TestCase):
+    def setUp(self):
+        os.environ["ERRORAI_AUTOSTART"] = "1"
+        _reset_for_tests()
+        self._original_sys_hook = sys.excepthook
+
+    def tearDown(self):
+        _reset_for_tests()
+        os.environ.pop("ERRORAI_AUTOSTART", None)
+        sys.excepthook = self._original_sys_hook
+
+    def test_singleton_runtime_manager(self):
+        first = get_runtime()
+        second = get_runtime()
+        self.assertIs(first, second)
+
+    def test_hook_registration_on_initialize(self):
+        runtime = get_runtime().initialize()
+        self.assertIsNot(sys.excepthook, self._original_sys_hook)
+        self.assertTrue(runtime._initialized)
+
+
+if __name__ == "__main__":
+    unittest.main()

errorai-0.9.0/tests/test_safety.py

@@ -0,0 +1,36 @@
+import os
+import tempfile
+from pathlib import Path
+import unittest
+
+os.environ["ERRORAI_AUTOSTART"] = "0"
+
+from errorai.config import RuntimeConfig
+from errorai.pipeline import Applier
+
+
+class SafetyTests(unittest.TestCase):
+    def test_applier_restricts_writes_to_project_root(self):
+        with tempfile.TemporaryDirectory() as root_dir, tempfile.TemporaryDirectory() as outside_dir:
+            root = Path(root_dir)
+            outside = Path(outside_dir)
+            target = root / "main.py"
+            target.write_text("print('x')\n", encoding="utf-8")
+            outside_target = outside / "outside.py"
+            outside_target.write_text("print('y')\n", encoding="utf-8")
+
+            applier = Applier(RuntimeConfig(project_root=root, dry_run=False))
+            self.assertTrue(applier.can_edit(target))
+            self.assertFalse(applier.can_edit(outside_target))
+
+    def test_applier_respects_sensitive_ignore_defaults(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            sensitive = root / ".env"
+            sensitive.write_text("A=B\n", encoding="utf-8")
+            applier = Applier(RuntimeConfig(project_root=root))
+            self.assertFalse(applier.can_edit(sensitive))
+
+
+if __name__ == "__main__":
+    unittest.main()