ErrorAI 2.0.0__py3-none-any.whl

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/__main__.py

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

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/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/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/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 = "llama_cpp"
+    name: str = "qwen2.5-coder-1.5b-instruct-q4_k_m"
+    model_url: str = (
+        "https://huggingface.co/Qwen/Qwen2.5-Coder-1.5B-Instruct-GGUF/resolve/main/"
+        "qwen2.5-coder-1.5b-instruct-q4_k_m.gguf"
+    )
+    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 = "llama_cpp"
+name = "qwen2.5-coder-1.5b-instruct-q4_k_m"
+context_window = 4096
+temperature = 0.1
+auto_bootstrap = true
+"""
+
+
+def autostart_enabled() -> bool:
+    return os.environ.get("ERRORAI_AUTOSTART", "1") != "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/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/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/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/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-2.0.0.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: ErrorAI
+Version: 2.0.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
+Provides-Extra: local-model
+Requires-Dist: llama-cpp-python>=0.2.90; extra == "local-model"
+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-2.0.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+errorai/__init__.py,sha256=J67kAHQlrBPKaMsN-yC8u_bQLc-JVmW0QzouUjfEhbA,304
+errorai/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+errorai/bootstrap.py,sha256=26IxxdYNnbOh-3CdPZ4qhYqqK8uOX4Chje3Yj3lbc8M,1649
+errorai/cli.py,sha256=bPSrHHAr-z5f316neiGz5hdTZrJalAI63RxyCNx4PxI,1989
+errorai/compat.py,sha256=UKnd-1DLbHUjUSskK2CLOIZkr4eRoYQ7O4-zYjyAu7E,787
+errorai/config.py,sha256=jpDaQuChuT_FRjFx3Z-FDK58lavr6VMROEaZQ_ONiKM,3969
+errorai/environment.py,sha256=rN4eLD0xkaLYb-Zu63HGk9mG4B3gL-3ZcW2g1LEIhyI,1008
+errorai/pipeline.py,sha256=vglfYQQ0JGEqopMTf3ybmNACaB-rK_CW1ciYFRy6ilc,3960
+errorai/providers.py,sha256=jVEb33MvFX8Xdwl3p7i2xaZVOOgAfg1p5ZuK6g0Qbho,1625
+errorai/runtime.py,sha256=uITKabXhzRPgy9NGyarXEG31SScVdw3bu6ZaElW30WQ,7353
+errorai/universal.py,sha256=zcu7oH_EjxmUzGIQ_EAwOq3FJOisDKvdQvB6uKXKhIk,255
+errorai-2.0.0.dist-info/METADATA,sha256=w8KMb3A58XXzm8wifIl_IFpedu1nnBELk37C0rTi2OI,2077
+errorai-2.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+errorai-2.0.0.dist-info/entry_points.txt,sha256=5F4SLE2xjnAcrxsaJdFm2n1klc9o2zhaRwJktPrxB2E,45
+errorai-2.0.0.dist-info/top_level.txt,sha256=RcAm9aPNk9gmal-or7wKBjGOOrnXp7H-JfroHu1HJqo,8
+errorai-2.0.0.dist-info/RECORD,,

errorai-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

errorai-2.0.0.dist-info/entry_points.txt

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

errorai-2.0.0.dist-info/top_level.txt

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