ErrorAI 0.9.0__tar.gz → 1.2.0__tar.gz

{errorai-0.9.0 → errorai-1.2.0}/ErrorAI.egg-info/PKG-INFO

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

{errorai-0.9.0 → errorai-1.2.0}/PKG-INFO

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

{errorai-0.9.0 → errorai-1.2.0}/errorai/__init__.py

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

errorai-1.2.0/errorai/cli.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+import argparse
+import ast
+import traceback
+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 _prompt_fix() -> bool:
+    answer = input("Should I fix it [Y/N]: ").strip().lower()
+    return answer in {"y", "yes"}
+
+
+def _attempt_simple_syntax_fix(content: str, err: SyntaxError) -> tuple[str, bool, str]:
+    if err.msg and "expected ':'" in err.msg and err.lineno:
+        lines = content.splitlines()
+        idx = err.lineno - 1
+        if 0 <= idx < len(lines):
+            line = lines[idx].rstrip()
+            if line and not line.endswith(":"):
+                lines[idx] = line + ":"
+                return "\n".join(lines) + ("\n" if content.endswith("\n") else ""), True, "Added missing ':'"
+    return content, False, "No safe automatic syntax fix available"
+
+
+def _attempt_simple_runtime_fix(content: str, exc: Exception) -> tuple[str, bool, str]:
+    if isinstance(exc, TypeError) and "unsupported operand type(s) for +:" in str(exc):
+        # Minimal safe stub: no automatic source mutation yet.
+        return content, False, "Detected TypeError (+ with incompatible types), but no safe auto-fix rule matched"
+    return content, False, "No safe automatic runtime fix available"
+
+
+def cmd_check(args) -> int:
+    file_path = Path(args.file_path).expanduser().resolve()
+    if not file_path.exists() or not file_path.is_file():
+        print(f"[errorai] File not found: {file_path}")
+        return 2
+
+    source = file_path.read_text(encoding="utf-8")
+
+    try:
+        ast.parse(source, filename=str(file_path))
+        print(f"[errorai] ✅ No syntax errors in {file_path}")
+        return 0
+    except SyntaxError as err:
+        print(f"[errorai] ❌ SyntaxError in {file_path}")
+        print(f"[errorai] Line {err.lineno}, Col {err.offset}: {err.msg}")
+        if err.text:
+            print(f"[errorai] >> {err.text.rstrip()}")
+
+        if not _prompt_fix():
+            return 1
+
+        fixed_source, changed, detail = _attempt_simple_syntax_fix(source, err)
+        print(f"[errorai] {detail}")
+
+        if changed:
+            file_path.write_text(fixed_source, encoding="utf-8")
+            print(f"[errorai] Applied fix to {file_path}")
+            try:
+                ast.parse(fixed_source, filename=str(file_path))
+                print("[errorai] ✅ Re-check passed")
+                return 0
+            except SyntaxError as second:
+                print(f"[errorai] Still invalid after fix: {second}")
+                return 1
+        return 1
+
+
+def cmd_run(args) -> int:
+    file_path = Path(args.file_path).expanduser().resolve()
+    if not file_path.exists() or not file_path.is_file():
+        print(f"[errorai] File not found: {file_path}")
+        return 2
+
+    # Run syntax check first
+    check_result = cmd_check(argparse.Namespace(file_path=str(file_path)))
+    if check_result != 0:
+        return check_result
+
+    source = file_path.read_text(encoding="utf-8")
+    globals_dict = {"__name__": "__main__", "__file__": str(file_path)}
+
+    try:
+        exec(compile(source, str(file_path), "exec"), globals_dict, globals_dict)
+        return 0
+    except Exception as exc:
+        print(f"[errorai] ❌ Runtime error: {type(exc).__name__}: {exc}")
+        if not _prompt_fix():
+            return 1
+        fixed_source, changed, detail = _attempt_simple_runtime_fix(source, exc)
+        print(f"[errorai] {detail}")
+        if changed:
+            file_path.write_text(fixed_source, encoding="utf-8")
+            print(f"[errorai] Applied runtime fix to {file_path}")
+            print("[errorai] Re-run with: errorai run <file path>")
+            return 0
+        print("[errorai] No fix applied")
+        traceback.print_exc()
+        return 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)
+
+    check_parser = sub.add_parser("check", help="Check a Python file for syntax errors and offer auto-fix.")
+    check_parser.add_argument("file_path", help="Path to .py file")
+    check_parser.set_defaults(func=cmd_check)
+
+    run_parser = sub.add_parser("run", help="Check then execute a Python file with runtime error interception.")
+    run_parser.add_argument("file_path", help="Path to .py file")
+    run_parser.set_defaults(func=cmd_run)
+
+    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-1.2.0}/errorai/compat.py

@@ -20,6 +20,9 @@ def watch(func):
 
 
 class catch_errors:
+    def __init__(self, func=None):
+        self.func = func
+
     def __enter__(self):
         return self
 
@@ -29,8 +32,23 @@ class catch_errors:
         get_runtime().process_exception(exc_type, exc_value, exc_tb)
         return True
 
+    def __call__(self, *args, **kwargs):
+        if callable(self.func):
+            @functools.wraps(self.func)
+            def inner(*wargs, **wkwargs):
+                try:
+                    return self.func(*wargs, **wkwargs)
+                except Exception as e:
+                    get_runtime().process_exception(type(e), e, e.__traceback__)
+                    raise
+            return inner(*args, **kwargs)
+
 
 def global_activate():
     runtime = get_runtime()
     runtime.initialize()
     return runtime
+
+
+# Automatically trigger global activation on import so zero-config works!
+global_activate()

{errorai-0.9.0 → errorai-1.2.0}/errorai/runtime.py

@@ -95,12 +95,18 @@ class RuntimeManager:
             threading.excepthook = self._thread_excepthook
 
     def _sys_excepthook(self, exc_type, exc_value, exc_tb):
-        self.process_exception(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):
-        self.process_exception(args.exc_type, args.exc_value, args.exc_traceback)
+        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)
 

{errorai-0.9.0 → errorai-1.2.0}/pyproject.toml

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

errorai-0.9.0/errorai/cli.py

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