pfix 0.1.1__py3-none-any.whl

pfix/__init__.py

@@ -0,0 +1,21 @@
+"""
+pfix — Self-healing Python for development.
+
+Catches runtime errors and fixes source code + dependencies via LLM + MCP.
+
+    from pfix import pfix
+
+    @pfix
+    def my_function():
+        ...
+
+    # Configure
+    from pfix import configure
+    configure(auto_apply=True, llm_model="openrouter/anthropic/claude-sonnet-4")
+"""
+
+from .config import PfixConfig, configure, get_config
+from .decorator import apfix, pfix
+
+__version__ = "0.1.1"
+__all__ = ["pfix", "apfix", "configure", "get_config", "PfixConfig"]

pfix/analyzer.py

@@ -0,0 +1,223 @@
+"""
+pfix.analyzer — Extract structured error context for LLM analysis.
+
+Gathers: traceback, source, local vars, imports, project deps,
+pipreqs scan results, and decorator hints.
+"""
+
+from __future__ import annotations
+
+import ast
+import inspect
+import sys
+import traceback
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+
+@dataclass
+class ErrorContext:
+    """Structured error report for LLM consumption."""
+
+    # Error
+    exception_type: str = ""
+    exception_message: str = ""
+    traceback_text: str = ""
+
+    # Source
+    source_file: str = ""
+    source_code: str = ""
+    function_name: str = ""
+    function_source: str = ""
+    line_number: int = 0
+    failing_line: str = ""
+
+    # Environment
+    local_vars: dict[str, str] = field(default_factory=dict)
+    imports: list[str] = field(default_factory=list)
+    python_version: str = ""
+
+    # Project context
+    project_deps: list[str] = field(default_factory=list)
+    missing_deps: list[str] = field(default_factory=list)
+
+    # Decorator metadata
+    hints: dict[str, Any] = field(default_factory=dict)
+
+    def to_prompt(self) -> str:
+        parts = [
+            "## Error Report",
+            f"**Exception**: `{self.exception_type}: {self.exception_message}`",
+            f"**File**: `{self.source_file}` line {self.line_number}",
+            f"**Function**: `{self.function_name}`",
+            "",
+            "### Traceback",
+            f"```\n{self.traceback_text}\n```",
+        ]
+
+        if self.source_code:
+            parts += ["", "### Full Source File", f"```python\n{self.source_code}\n```"]
+
+        if self.function_source:
+            parts += ["", "### Function Source", f"```python\n{self.function_source}\n```"]
+
+        if self.local_vars:
+            parts.append("\n### Local Variables")
+            for k, v in list(self.local_vars.items())[:30]:
+                parts.append(f"- `{k}` = `{v}`")
+
+        if self.imports:
+            parts.append("\n### File Imports")
+            for imp in self.imports:
+                parts.append(f"- `{imp}`")
+
+        if self.missing_deps:
+            parts.append("\n### Missing Dependencies (pipreqs scan)")
+            for dep in self.missing_deps:
+                parts.append(f"- `{dep}`")
+
+        if self.hints:
+            parts.append("\n### Developer Hints (@pfix decorator)")
+            for k, v in self.hints.items():
+                parts.append(f"- **{k}**: {v}")
+
+        parts.append(f"\n### Python {self.python_version}")
+        return "\n".join(parts)
+
+
+def analyze_exception(
+    exc: BaseException,
+    func: Optional[Any] = None,
+    local_vars: Optional[dict] = None,
+    hints: Optional[dict] = None,
+) -> ErrorContext:
+    """Build ErrorContext from a caught exception."""
+    ctx = ErrorContext()
+    ctx.exception_type = type(exc).__name__
+    ctx.exception_message = str(exc)
+    ctx.traceback_text = "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
+    ctx.python_version = sys.version.split()[0]
+
+    # Walk traceback to innermost user-code frame
+    tb = exc.__traceback__
+    if tb is not None:
+        while tb.tb_next is not None:
+            tb = tb.tb_next
+        frame = tb.tb_frame
+        ctx.line_number = tb.tb_lineno
+        ctx.source_file = frame.f_code.co_filename
+        if local_vars is None:
+            local_vars = frame.f_locals
+        ctx.local_vars = {
+            k: _safe_repr(v) for k, v in (local_vars or {}).items()
+            if not k.startswith("__")
+        }
+
+    # Function source
+    if func is not None:
+        try:
+            ctx.function_source = inspect.getsource(func)
+            ctx.function_name = func.__qualname__
+            ctx.source_file = inspect.getfile(func)
+        except (OSError, TypeError):
+            ctx.function_name = getattr(func, "__name__", "<unknown>")
+
+    # Full file source
+    if ctx.source_file and Path(ctx.source_file).is_file():
+        try:
+            ctx.source_code = Path(ctx.source_file).read_text(encoding="utf-8")
+            lines = ctx.source_code.splitlines()
+            if 0 < ctx.line_number <= len(lines):
+                ctx.failing_line = lines[ctx.line_number - 1]
+        except Exception:
+            pass
+
+    # Extract imports
+    if ctx.source_code:
+        ctx.imports = _extract_imports(ctx.source_code)
+
+    # Scan for missing deps via pipreqs
+    if ctx.source_file:
+        ctx.missing_deps = scan_missing_deps(Path(ctx.source_file).parent)
+
+    ctx.hints = hints or {}
+    return ctx
+
+
+def classify_error(ctx: ErrorContext) -> str:
+    """Classify error to guide fix strategy."""
+    exc = ctx.exception_type
+    msg = ctx.exception_message.lower()
+
+    if exc in ("ModuleNotFoundError", "ImportError"):
+        return "missing_dependency"
+    if exc == "NameError" and "is not defined" in msg:
+        return "missing_import"
+    if exc == "TypeError":
+        return "type_error"
+    if exc == "AttributeError":
+        return "attribute_error"
+    if exc == "SyntaxError":
+        return "syntax_error"
+    if exc == "IndexError":
+        return "index_error"
+    if exc == "KeyError":
+        return "key_error"
+    if exc == "ValueError":
+        return "value_error"
+    if exc == "FileNotFoundError":
+        return "file_not_found"
+    if exc == "PermissionError":
+        return "permission_error"
+    return "other"
+
+
+def scan_missing_deps(project_dir: Path) -> list[str]:
+    """Use pipreqs to detect imports that aren't installed."""
+    try:
+        from pipreqs import pipreqs
+        imports = pipreqs.get_all_imports(str(project_dir))
+        pkg_info = pipreqs.get_pkg_names(imports)
+        # Compare with installed
+        installed = {pkg.key for pkg in __import__("importlib.metadata").metadata.distributions()}
+    except Exception:
+        installed = set()
+
+    missing = []
+    try:
+        from pipreqs import pipreqs
+        all_imports = pipreqs.get_all_imports(str(project_dir))
+        for imp in all_imports:
+            top = imp.split(".")[0].lower()
+            if top not in installed and top not in sys.stdlib_module_names:
+                missing.append(imp)
+    except Exception:
+        pass
+
+    return missing
+
+
+def _extract_imports(source: str) -> list[str]:
+    imports = []
+    try:
+        tree = ast.parse(source)
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    imports.append(f"import {alias.name}")
+            elif isinstance(node, ast.ImportFrom):
+                module = node.module or ""
+                names = ", ".join(a.name for a in node.names)
+                imports.append(f"from {module} import {names}")
+    except SyntaxError:
+        pass
+    return imports
+
+
+def _safe_repr(obj: Any, max_len: int = 200) -> str:
+    try:
+        r = repr(obj)
+        return r[:max_len] + "..." if len(r) > max_len else r
+    except Exception:
+        return f"<{type(obj).__name__}: repr failed>"

pfix/cli.py

@@ -0,0 +1,220 @@
+"""
+pfix.cli — Command-line interface.
+
+    pfix run script.py          # Run with global exception hook
+    pfix run script.py --auto   # Auto-apply fixes
+    pfix check                  # Validate config
+    pfix deps scan              # Scan for missing deps (pipreqs)
+    pfix deps install           # Install missing deps
+    pfix deps generate          # Generate requirements.txt
+    pfix server                 # Start MCP server (stdio)
+    pfix server --http 3001     # Start MCP server (HTTP)
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import sys
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="pfix", description="Self-healing Python — fix code & deps via LLM + MCP")
+    sub = parser.add_subparsers(dest="command")
+
+    # run
+    run_p = sub.add_parser("run", help="Run a script with pfix active")
+    run_p.add_argument("script", help="Python script path")
+    run_p.add_argument("args", nargs="*")
+    run_p.add_argument("--auto", action="store_true", help="Auto-apply fixes")
+    run_p.add_argument("--dry-run", action="store_true")
+    run_p.add_argument("--restart", action="store_true", help="Restart process after fix")
+
+    # check
+    sub.add_parser("check", help="Validate config")
+
+    # deps
+    deps_p = sub.add_parser("deps", help="Dependency management")
+    deps_sub = deps_p.add_subparsers(dest="deps_command")
+    deps_sub.add_parser("scan", help="Scan for missing deps (pipreqs)")
+    deps_sub.add_parser("install", help="Install missing deps")
+    deps_sub.add_parser("generate", help="Generate requirements.txt")
+
+    # server
+    srv_p = sub.add_parser("server", help="Start MCP server")
+    srv_p.add_argument("--http", type=int, default=None, metavar="PORT", help="HTTP port (default: stdio)")
+    srv_p.add_argument("--host", default="127.0.0.1")
+
+    # version
+    sub.add_parser("version", help="Show version")
+
+    args = parser.parse_args(argv)
+
+    if args.command == "run":
+        return cmd_run(args)
+    elif args.command == "check":
+        return cmd_check()
+    elif args.command == "deps":
+        return cmd_deps(args)
+    elif args.command == "server":
+        return cmd_server(args)
+    elif args.command == "version":
+        from pfix import __version__
+        console.print(f"pfix {__version__}")
+        return 0
+    else:
+        parser.print_help()
+        return 0
+
+
+def cmd_run(args) -> int:
+    from pfix import configure
+
+    script = Path(args.script).resolve()
+    if not script.is_file():
+        console.print(f"[red]✗ Not found: {script}[/]")
+        return 1
+
+    configure(
+        auto_apply=args.auto,
+        dry_run=args.dry_run,
+        auto_restart=args.restart,
+        project_root=script.parent,
+    )
+    _install_excepthook()
+
+    sys.argv = [str(script)] + (args.args or [])
+    spec = importlib.util.spec_from_file_location("__main__", str(script))
+    if spec is None or spec.loader is None:
+        console.print(f"[red]✗ Cannot load: {script}[/]")
+        return 1
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules["__main__"] = module
+    try:
+        spec.loader.exec_module(module)
+    except SystemExit as e:
+        return e.code if isinstance(e.code, int) else 0
+    except Exception as e:
+        console.print(f"[red]💥 Unhandled: {type(e).__name__}: {e}[/]")
+        return 1
+    return 0
+
+
+def cmd_check() -> int:
+    from pfix.config import get_config
+
+    config = get_config()
+    warnings = config.validate()
+
+    table = Table(title="pfix Configuration")
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value")
+
+    rows = [
+        ("Model", config.llm_model),
+        ("API Key", "✓ set" if config.llm_api_key else "[red]✗ missing[/]"),
+        ("API Base", config.llm_api_base),
+        ("Pkg Manager", config.pkg_manager),
+        ("Auto Apply", str(config.auto_apply)),
+        ("Auto Install Deps", str(config.auto_install_deps)),
+        ("Auto Restart", str(config.auto_restart)),
+        ("Max Retries", str(config.max_retries)),
+        ("Dry Run", str(config.dry_run)),
+        ("Enabled", str(config.enabled)),
+        ("MCP Enabled", str(config.mcp_enabled)),
+        ("MCP Transport", config.mcp_transport),
+        ("Git Auto-Commit", str(config.git_auto_commit)),
+        ("Project Root", str(config.project_root)),
+    ]
+    for k, v in rows:
+        table.add_row(k, v)
+
+    console.print(table)
+
+    if warnings:
+        console.print()
+        for w in warnings:
+            console.print(f"[yellow]⚠ {w}[/]")
+        return 1
+
+    console.print("\n[green]✓ Configuration valid[/]")
+    return 0
+
+
+def cmd_deps(args) -> int:
+    if not hasattr(args, "deps_command") or args.deps_command is None:
+        console.print("Usage: pfix deps [scan|install|generate]")
+        return 1
+
+    from pfix.dependency import scan_project_deps, install_packages, generate_requirements
+
+    if args.deps_command == "generate":
+        generate_requirements()
+        return 0
+
+    result = scan_project_deps()
+
+    if not result["missing"]:
+        console.print(f"[green]✓ All dependencies satisfied ({len(result['installed'])} packages)[/]")
+        return 0
+
+    table = Table(title=f"Missing Dependencies ({len(result['missing'])})")
+    table.add_column("Package", style="yellow")
+    for pkg in result["missing"]:
+        table.add_row(pkg)
+    console.print(table)
+
+    if args.deps_command == "install":
+        install_packages(result["missing"])
+
+    return 0
+
+
+def cmd_server(args) -> int:
+    try:
+        from pfix.mcp_server import start_server
+
+        if args.http:
+            start_server(transport="http", host=args.host, port=args.http)
+        else:
+            start_server(transport="stdio")
+        return 0
+    except ImportError as e:
+        console.print(f"[red]MCP server requires: pip install pfix[mcp][/]\n{e}")
+        return 1
+
+
+def _install_excepthook():
+    from pfix.analyzer import analyze_exception
+    from pfix.llm import request_fix
+    from pfix.fixer import apply_fix
+
+    original = sys.excepthook
+
+    def hook(exc_type, exc_value, exc_tb):
+        if exc_type in (KeyboardInterrupt, SystemExit):
+            original(exc_type, exc_value, exc_tb)
+            return
+
+        console.print(f"\n[red]💥 pfix hook: {exc_type.__name__}: {exc_value}[/]")
+        exc_value.__traceback__ = exc_tb
+        ctx = analyze_exception(exc_value)
+        proposal = request_fix(ctx)
+
+        if proposal.confidence > 0.1:
+            apply_fix(ctx, proposal, confirm=True)
+
+        original(exc_type, exc_value, exc_tb)
+
+    sys.excepthook = hook
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pfix/config.py

@@ -0,0 +1,151 @@
+"""
+pfix.config — Configuration management.
+
+Loads from .env → environment → pyproject.toml [tool.pfix].
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+from dotenv import load_dotenv
+
+
+@dataclass
+class PfixConfig:
+    """Central configuration."""
+
+    # LLM
+    llm_model: str = "openrouter/anthropic/claude-sonnet-4"
+    llm_api_key: str = ""
+    llm_api_base: str = "https://openrouter.ai/api/v1"
+    llm_temperature: float = 0.2
+    llm_max_tokens: int = 4096
+
+    # Behavior
+    auto_apply: bool = False
+    auto_install_deps: bool = True
+    auto_restart: bool = False          # os.execv restart after fix
+    max_retries: int = 3
+    enabled: bool = True
+    dry_run: bool = False
+
+    # Dependency manager: "pip" | "uv" (auto-detected)
+    pkg_manager: str = "pip"
+
+    # MCP
+    mcp_enabled: bool = False
+    mcp_server_url: str = "http://localhost:3001"
+    mcp_transport: str = "stdio"        # "stdio" | "http"
+
+    # Git integration
+    git_auto_commit: bool = False
+    git_commit_prefix: str = "pfix: "
+
+    # Paths
+    project_root: Path = field(default_factory=lambda: Path.cwd())
+    log_file: Optional[str] = None
+
+    # Extra context for LLM
+    extra_context: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_env(cls, dotenv_path: Optional[str] = None) -> "PfixConfig":
+        """Load config from .env + environment + pyproject.toml."""
+        # Find and load .env
+        if dotenv_path:
+            load_dotenv(dotenv_path)
+        else:
+            for parent in [Path.cwd(), *Path.cwd().parents]:
+                env_file = parent / ".env"
+                if env_file.exists():
+                    load_dotenv(env_file)
+                    break
+
+        # Detect uv
+        pkg_manager = "uv" if shutil.which("uv") else "pip"
+
+        cfg = cls(
+            llm_model=os.getenv("PFIX_MODEL", os.getenv("LIBFIX_MODEL", cls.llm_model)),
+            llm_api_key=os.getenv("OPENROUTER_API_KEY", os.getenv("PFIX_API_KEY", "")),
+            llm_api_base=os.getenv("PFIX_API_BASE", cls.llm_api_base),
+            llm_temperature=float(os.getenv("PFIX_TEMPERATURE", str(cls.llm_temperature))),
+            llm_max_tokens=int(os.getenv("PFIX_MAX_TOKENS", str(cls.llm_max_tokens))),
+            auto_apply=os.getenv("PFIX_AUTO_APPLY", "false").lower() in ("true", "1", "yes"),
+            auto_install_deps=os.getenv("PFIX_AUTO_INSTALL_DEPS", "true").lower() in ("true", "1", "yes"),
+            auto_restart=os.getenv("PFIX_AUTO_RESTART", "false").lower() in ("true", "1", "yes"),
+            max_retries=int(os.getenv("PFIX_MAX_RETRIES", "3")),
+            enabled=os.getenv("PFIX_ENABLED", "true").lower() in ("true", "1", "yes"),
+            dry_run=os.getenv("PFIX_DRY_RUN", "false").lower() in ("true", "1", "yes"),
+            pkg_manager=os.getenv("PFIX_PKG_MANAGER", pkg_manager),
+            mcp_enabled=os.getenv("PFIX_MCP_ENABLED", "false").lower() in ("true", "1", "yes"),
+            mcp_server_url=os.getenv("PFIX_MCP_SERVER_URL", cls.mcp_server_url),
+            mcp_transport=os.getenv("PFIX_MCP_TRANSPORT", cls.mcp_transport),
+            git_auto_commit=os.getenv("PFIX_GIT_COMMIT", "false").lower() in ("true", "1", "yes"),
+            git_commit_prefix=os.getenv("PFIX_GIT_PREFIX", cls.git_commit_prefix),
+            project_root=Path(os.getenv("PFIX_PROJECT_ROOT", str(Path.cwd()))),
+            log_file=os.getenv("PFIX_LOG_FILE"),
+        )
+
+        # Merge pyproject.toml [tool.pfix]
+        pyproject = cls._read_pyproject(cfg.project_root / "pyproject.toml")
+        for key, val in pyproject.items():
+            if hasattr(cfg, key) and not os.getenv(f"PFIX_{key.upper()}"):
+                setattr(cfg, key, val)
+
+        return cfg
+
+    @staticmethod
+    def _read_pyproject(path: Path) -> dict:
+        if not path.exists():
+            return {}
+        try:
+            import tomllib
+        except ImportError:
+            try:
+                import tomli as tomllib  # type: ignore
+            except ImportError:
+                return {}
+        with open(path, "rb") as f:
+            data = tomllib.load(f)
+        return data.get("tool", {}).get("pfix", {})
+
+    def validate(self) -> list[str]:
+        warnings = []
+        if not self.llm_api_key:
+            warnings.append("No API key. Set OPENROUTER_API_KEY in .env")
+        return warnings
+
+
+# ── Global singleton ────────────────────────────────────────────────
+
+_config: Optional[PfixConfig] = None
+
+
+def get_config() -> PfixConfig:
+    global _config
+    if _config is None:
+        _config = PfixConfig.from_env()
+    return _config
+
+
+def configure(**kwargs) -> PfixConfig:
+    """Override global config programmatically."""
+    global _config
+    _config = PfixConfig.from_env()
+    for k, v in kwargs.items():
+        if hasattr(_config, k):
+            setattr(_config, k, v)
+        else:
+            _config.extra_context[k] = v
+    return _config
+
+
+def reset_config():
+    """Reset global config (useful in tests)."""
+    global _config
+    _config = None