envfix 0.4.0__py3-none-any.whl

envfix/__init__.py

@@ -0,0 +1,3 @@
+"""envfix — Automatic Python/ML environment error fixer."""
+
+__version__ = "0.4.0"

envfix/ai.py

@@ -0,0 +1,261 @@
+"""ai.py — Calls local or cloud AI models and parses their responses."""
+
+import os
+import re
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from envfix.context import CodeContext
+
+
+try:
+    import ollama
+except ImportError:  # pragma: no cover
+    ollama = None  # type: ignore[assignment]
+
+try:
+    import groq
+except ImportError:
+    groq = None
+
+try:
+    from google import genai
+except ImportError:
+    genai = None
+
+
+PROMPT_TEMPLATE = (
+    "You are diagnosing a development environment error on a Windows machine. "
+    "The user has specified this error is related to the '{category}' ecosystem "
+    "(it could be Python, Node.js, package managers, build tools, permissions, or general shell errors).\n"
+    "Here is the error output:\n{stderr}\n\n"
+    "Give a short diagnosis (1-2 sentences) of the root cause, "
+    "then give exactly ONE shell command that would likely fix it. "
+    "Respond in this exact format:\n"
+    "DIAGNOSIS: <text>\n"
+    "FIX: <command>\n\n"
+    "IMPORTANT rules for the FIX command:\n"
+    "- If it's a Python pip error, use 'python -m pip install ...' instead of 'pip install ...'\n"
+    "- NO backticks, NO markdown formatting, NO surrounding quotes around the command\n"
+    "- Give a single runnable shell command only\n"
+    "Example correct format:\n"
+    "DIAGNOSIS: The torch package is not installed.\n"
+    "FIX: python -m pip install torch"
+)
+
+# Used when a code snippet from the failing file is available.
+# Gives the model much richer context than the raw error text alone.
+PROMPT_TEMPLATE_WITH_CONTEXT = (
+    "You are diagnosing a development environment error on a Windows machine. "
+    "The user has specified this error is related to the '{category}' ecosystem.\n\n"
+    "Here is the error output:\n{stderr}\n\n"
+    "Here is the relevant code from {filepath}, lines {start}-{end}:\n"
+    "```\n{snippet}\n```\n\n"
+    "Using both the error and the code above, give a precise diagnosis (1-2 sentences) "
+    "that references the actual code where possible, "
+    "then give exactly ONE shell command that would likely fix it. "
+    "Respond in this exact format:\n"
+    "DIAGNOSIS: <text>\n"
+    "FIX: <command>\n\n"
+    "IMPORTANT rules for the FIX command:\n"
+    "- If it's a Python pip error, use 'python -m pip install ...' instead of 'pip install ...'\n"
+    "- NO backticks, NO markdown formatting, NO surrounding quotes around the command\n"
+    "- Give a single runnable shell command only\n"
+    "Example correct format:\n"
+    "DIAGNOSIS: Line 42 calls `train()` before the model is loaded.\n"
+    "FIX: python -m pip install torch"
+)
+
+DEFAULT_MODEL = "llama3.1:8b"
+
+
+def get_actual_model(model: str, provider: str) -> str:
+    """Resolve the actual model string if the user left it as the Ollama default."""
+    if model != DEFAULT_MODEL:
+        return model
+    
+    if provider == "groq":
+        return "llama-3.3-70b-versatile"
+    elif provider == "gemini":
+        return "gemini-3.5-flash"
+    
+    return DEFAULT_MODEL
+
+
+@dataclass
+class DiagnosisResult:
+    """Structured result from the AI model."""
+
+    diagnosis: str
+    fix: str
+    raw_response: str
+    parsed_ok: bool
+
+
+def get_diagnosis(
+    stderr: str,
+    model: str = DEFAULT_MODEL,
+    category: str = "general",
+    code_context: "Optional[CodeContext]" = None,
+    provider: str = "ollama",
+) -> DiagnosisResult:
+    """
+    Send stderr (and optional code context) to the chosen AI provider.
+
+    Args:
+        stderr:       The captured error text from the failed command.
+        model:        Model tag to use (default: llama3.1:8b for ollama).
+        category:     The ecosystem category.
+        code_context: Optional in-project code snippet extracted from the traceback.
+        provider:     Which AI service to use ("ollama", "groq", or "gemini").
+
+    Returns:
+        A DiagnosisResult with diagnosis, fix, raw_response, and parsed_ok.
+    """
+    if code_context is not None:
+        prompt = PROMPT_TEMPLATE_WITH_CONTEXT.format(
+            stderr=stderr,
+            category=category,
+            filepath=code_context.filepath,
+            start=code_context.start_line,
+            end=code_context.end_line,
+            snippet=code_context.snippet,
+        )
+    else:
+        prompt = PROMPT_TEMPLATE.format(stderr=stderr, category=category)
+
+    if provider == "ollama":
+        if ollama is None:
+            raise RuntimeError(
+                "The 'ollama' Python package is not installed. "
+                "Run: pip install ollama"
+            )
+        try:
+            response = ollama.chat(
+                model=model,
+                messages=[{"role": "user", "content": prompt}],
+            )
+            raw = response["message"]["content"].strip()
+        except Exception as exc:
+            raise RuntimeError(
+                f"Ollama request failed: {exc}\n"
+                "Make sure the Ollama service is running (`ollama serve`) "
+                f"and the model '{model}' is pulled (`ollama pull {model}`)."
+            ) from exc
+
+    elif provider == "groq":
+        if groq is None:
+            raise RuntimeError("The 'groq' Python package is not installed.")
+        api_key = os.getenv("GROQ_API_KEY")
+        if not api_key:
+            raise RuntimeError(
+                "GROQ_API_KEY environment variable is not set. "
+                "Please set it to your Groq API key."
+            )
+        try:
+            client = groq.Groq(api_key=api_key)
+            actual_model = get_actual_model(model, provider)
+            chat_completion = client.chat.completions.create(
+                messages=[{"role": "user", "content": prompt}],
+                model=actual_model,
+            )
+            raw = chat_completion.choices[0].message.content.strip()
+        except Exception as exc:
+            raise RuntimeError(f"Groq request failed: {exc}") from exc
+
+    elif provider == "gemini":
+        if genai is None:
+            raise RuntimeError("The 'google-genai' Python package is not installed.")
+        api_key = os.getenv("GEMINI_API_KEY")
+        if not api_key:
+            raise RuntimeError(
+                "GEMINI_API_KEY environment variable is not set. "
+                "Please set it to your Gemini API key."
+            )
+        try:
+            client = genai.Client(api_key=api_key)
+            actual_model = get_actual_model(model, provider)
+            response = client.models.generate_content(
+                model=actual_model, 
+                contents=prompt
+            )
+            raw = response.text.strip()
+        except Exception as exc:
+            raise RuntimeError(f"Gemini API call failed: {exc}") from exc
+
+    else:
+        raise ValueError(f"Unknown provider: {provider}")
+
+    return _parse_response(raw)
+
+
+def _parse_response(raw: str) -> DiagnosisResult:
+    """
+    Extract DIAGNOSIS and FIX from the model's raw text.
+
+    Tries a strict regex first, then falls back to a lenient line scan.
+    If neither works, marks parsed_ok=False and stuffs the raw text into
+    both fields so the UI can still display something useful.
+    """
+    # --- Strict parse: both keys on their own lines (case-insensitive) ---
+    strict = re.search(
+        r"DIAGNOSIS\s*:\s*(.+?)\s*FIX\s*:\s*(.+)",
+        raw,
+        re.IGNORECASE | re.DOTALL,
+    )
+    if strict:
+        diagnosis = strict.group(1).strip()
+        fix = _clean_fix(strict.group(2).strip().splitlines()[0].strip())
+        return DiagnosisResult(
+            diagnosis=diagnosis, fix=fix, raw_response=raw, parsed_ok=True
+        )
+
+    # --- Lenient parse: scan line-by-line ---
+    diagnosis: Optional[str] = None
+    fix: Optional[str] = None
+    for line in raw.splitlines():
+        stripped = line.strip()
+        if diagnosis is None and re.match(r"DIAGNOSIS\s*:", stripped, re.IGNORECASE):
+            diagnosis = re.sub(r"^DIAGNOSIS\s*:\s*", "", stripped, flags=re.IGNORECASE)
+        elif fix is None and re.match(r"FIX\s*:", stripped, re.IGNORECASE):
+            fix = re.sub(r"^FIX\s*:\s*", "", stripped, flags=re.IGNORECASE)
+
+    if diagnosis and fix:
+        return DiagnosisResult(
+            diagnosis=diagnosis, fix=_clean_fix(fix), raw_response=raw, parsed_ok=True
+        )
+
+    # --- Fallback: show raw output, don't crash ---
+    return DiagnosisResult(
+        diagnosis=raw,
+        fix="(could not parse a fix command — see diagnosis above)",
+        raw_response=raw,
+        parsed_ok=False,
+    )
+
+
+def _clean_fix(fix: str) -> str:
+    """
+    Strip markdown/shell formatting artefacts from the fix command and
+    normalise Windows-incompatible patterns.
+
+    LLMs often wrap commands in backticks (`` `cmd` ``) or fenced code blocks.
+    Running `` `pip install torch` `` on Windows will fail because the backtick
+    is not a valid shell character there.
+
+    Also replaces bare 'pip install' with 'python -m pip install' because pip
+    is often not on the Windows PATH even when python is.
+    """
+    # Strip surrounding backticks: `cmd` → cmd  or ```cmd``` → cmd
+    fix = fix.strip()
+    fix = re.sub(r'^`+|`+$', '', fix).strip()
+    # Strip surrounding single or double quotes added by the model
+    if (fix.startswith('"') and fix.endswith('"')) or \
+       (fix.startswith("'") and fix.endswith("'")):
+        fix = fix[1:-1].strip()
+    # Strip markdown emphasis like *cmd* or **cmd**
+    fix = re.sub(r'^\*+|\*+$', '', fix).strip()
+    # Replace bare 'pip' with 'python -m pip' so it works when pip is not on PATH
+    fix = re.sub(r'^pip\b', 'python -m pip', fix)
+    return fix

envfix/cache.py

@@ -0,0 +1,134 @@
+"""cache.py — Known-fix cache: fuzzy-match current errors against past verified fixes."""
+
+import json
+import os
+from dataclasses import dataclass
+from difflib import SequenceMatcher
+from typing import Optional
+
+from envfix.logger import get_log_file
+
+# Minimum similarity ratio (0–1) to consider a log entry a match.
+# 0.92 is deliberately conservative: we only surface cache hits when
+# the error text is nearly identical (same module name, same error type).
+# Too low and structurally-similar errors (e.g. two different ModuleNotFoundErrors)
+# get matched to each other even when the missing package differs.
+SIMILARITY_THRESHOLD = 0.92
+
+
+@dataclass
+class CacheHit:
+    """A previously verified fix that closely matches the current error."""
+
+    fix: str
+    diagnosis: str
+    score: float            # 0.0 – 1.0 similarity ratio
+    original_command: str   # the command that originally triggered the error
+    previously_worked: bool # True if fix_worked=True in the log entry
+    category: str           # The ecosystem category of the error
+
+
+def find_cached_fix(
+    error_text: str,
+    log_file: str = "",           # empty string → resolved at call-time
+    threshold: float = SIMILARITY_THRESHOLD,
+    category: str = "general",
+) -> Optional[CacheHit]:
+    """
+    Search the user's log for a previously attempted fix for a similar error.
+
+    log_file defaults to the current user's personal log file if not supplied.
+    Passing an explicit path is still supported (used in tests).
+
+    Two tiers:
+    - Prefers entries where the fix is CONFIRMED to have worked (fix_worked=True).
+    - Falls back to entries where the user APPROVED the fix (user_approved=True)
+      even if fix_worked=False/None — this surfaces "we've already tried this"
+      so Ollama is not called again for the same problem.
+
+    Uses difflib.SequenceMatcher for lightweight fuzzy string similarity.
+    Supports both Phase 1 (worked/fix/stderr) and Phase 2 schemas transparently.
+
+    Args:
+        error_text: The current stderr text to match against.
+        log_file:   Path to the JSON log file (defaults to cwd).
+        threshold:  Minimum SequenceMatcher ratio to accept as a hit.
+        category:   The ecosystem category. Only matches logs with the same category.
+
+    Returns:
+        A CacheHit with the best-matching fix, or None if no good match found.
+    """
+    if not log_file:
+        log_file = get_log_file()
+
+    if not os.path.exists(log_file):
+        return None
+
+    try:
+        with open(log_file, "r", encoding="utf-8") as f:
+            log_data = json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return None
+
+    if not isinstance(log_data, list) or not log_data:
+        return None
+
+    # We keep two best candidates: one that worked, one that was merely approved.
+    best_worked:   Optional[tuple[float, CacheHit]] = None
+    best_approved: Optional[tuple[float, CacheHit]] = None
+
+    for entry in log_data:
+        # ── Support both Phase 1 and Phase 2 schemas ─────────────────────
+        fix_worked = (
+            entry.get("fix_worked")
+            if "fix_worked" in entry
+            else entry.get("worked")
+        )
+        user_approved = (
+            entry.get("user_approved")
+            if "user_approved" in entry
+            else entry.get("approved", False)
+        )
+
+        # Only use entries the user actually approved (ignore "n" declines)
+        if not user_approved:
+            continue
+
+        entry_category = entry.get("category", "general")
+        if entry_category != category:
+            continue
+
+        stored_error: str = entry.get("error_text") or entry.get("stderr", "")
+        fix: str          = entry.get("fix_command") or entry.get("fix", "")
+        diagnosis: str    = entry.get("diagnosis", "")
+        original_cmd: str = entry.get("original_command") or entry.get("command", "")
+
+        if not stored_error or not fix:
+            continue
+
+        score = SequenceMatcher(None, error_text, stored_error).ratio()
+        if score < threshold:
+            continue
+
+        hit = CacheHit(
+            fix=fix,
+            diagnosis=diagnosis,
+            score=score,
+            original_command=original_cmd,
+            previously_worked=bool(fix_worked),
+            category=entry_category,
+        )
+
+        if fix_worked:
+            if best_worked is None or score > best_worked[0]:
+                best_worked = (score, hit)
+        else:
+            if best_approved is None or score > best_approved[0]:
+                best_approved = (score, hit)
+
+    # Prefer a confirmed-working hit over a merely-approved one
+    if best_worked:
+        return best_worked[1]
+    if best_approved:
+        return best_approved[1]
+    return None

envfix/config.py

@@ -0,0 +1,36 @@
+import os
+import sys
+from pathlib import Path
+from typing import Dict, Any
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib
+
+import tomli_w
+
+CONFIG_DIR = Path.home() / ".envfix"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+
+def load_config() -> Dict[str, Any]:
+    """Load the persistent TOML configuration file."""
+    if not CONFIG_FILE.exists():
+        return {}
+    
+    try:
+        with open(CONFIG_FILE, "rb") as f:
+            return tomllib.load(f)
+    except Exception:
+        return {}
+
+def save_config(data: Dict[str, Any]) -> None:
+    """Save the configuration dict to TOML."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(CONFIG_FILE, "wb") as f:
+        tomli_w.dump(data, f)
+
+def reset_config() -> None:
+    """Delete the configuration file."""
+    if CONFIG_FILE.exists():
+        CONFIG_FILE.unlink()

envfix/context.py

@@ -0,0 +1,122 @@
+"""context.py — Extract code snippets from stack traces for richer Ollama prompts."""
+
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+# Lines to include above and below the failing line
+CONTEXT_WINDOW = 10
+
+# ── Stack-trace patterns ──────────────────────────────────────────────────────
+
+# Python:  File "main.py", line 42
+_PYTHON_RE = re.compile(r'File "([^"]+)",\s*line (\d+)')
+
+# Node.js: at Object.<anonymous> (main.js:42:10)  OR  at main.js:42:10
+_NODE_RE = re.compile(
+    r'at\s+(?:[^\s(]+\s+\()?([^()]+?\.(?:js|ts|jsx|tsx|mjs|cjs)):(\d+)'
+)
+
+
+@dataclass
+class CodeContext:
+    """A code snippet extracted from the failing file."""
+
+    filepath: str      # path relative to cwd — safe to show the user
+    line_number: int   # the line the stack trace pointed at
+    start_line: int    # first line of the snippet (1-indexed, clamped)
+    end_line: int      # last line of the snippet  (1-indexed, clamped)
+    snippet: str       # numbered source lines ready to embed in a prompt
+
+
+def extract_context(stderr: str, cwd: Optional[str] = None) -> Optional[CodeContext]:
+    """
+    Parse *stderr* for file paths and line numbers in common stack trace formats.
+
+    Only files that live inside *cwd* (or its subdirectories) are read.
+    System paths, site-packages, and anything outside the project root are
+    silently skipped.
+
+    For Python tracebacks the *last* in-project file is used (that's where
+    the user's own code triggered the error).  For Node.js the first match
+    is used (the top of the call stack).
+
+    Args:
+        stderr: The captured error output from the failed command.
+        cwd:    Project root to restrict file access to. Defaults to os.getcwd().
+
+    Returns:
+        A CodeContext if a safe, readable file is found; None otherwise.
+    """
+    root = Path(cwd or os.getcwd()).resolve()
+
+    python_hits: list[tuple[str, int]] = [
+        (m.group(1), int(m.group(2))) for m in _PYTHON_RE.finditer(stderr)
+    ]
+    node_hits: list[tuple[str, int]] = [
+        (m.group(1), int(m.group(2))) for m in _NODE_RE.finditer(stderr)
+    ]
+
+    # Python: try last in-project file first (closest to the actual error)
+    for filepath, lineno in reversed(python_hits):
+        ctx = _read_safe(filepath, lineno, root)
+        if ctx:
+            return ctx
+
+    # Node.js: try first match first (top of call stack = user's code)
+    for filepath, lineno in node_hits:
+        ctx = _read_safe(filepath, lineno, root)
+        if ctx:
+            return ctx
+
+    return None
+
+
+def _read_safe(filepath: str, lineno: int, root: Path) -> Optional[CodeContext]:
+    """
+    Read a ±CONTEXT_WINDOW line snippet from *filepath* around *lineno*.
+
+    Returns None if:
+    - the path resolves outside *root*  (safety boundary)
+    - the file doesn't exist or can't be read
+    - the line number is out of range
+    """
+    try:
+        if os.path.isabs(filepath):
+            resolved = Path(filepath).resolve()
+        else:
+            resolved = (root / filepath).resolve()
+
+        # ── Safety check: must be inside the project root ─────────────────
+        resolved.relative_to(root)   # raises ValueError if outside
+
+        if not resolved.is_file():
+            return None
+
+        lines = resolved.read_text(encoding="utf-8", errors="replace").splitlines()
+        total = len(lines)
+
+        if lineno < 1 or lineno > total:
+            return None
+
+        # Clamp snippet window to file bounds (1-indexed)
+        start = max(1, lineno - CONTEXT_WINDOW)
+        end   = min(total, lineno + CONTEXT_WINDOW)
+
+        # Build a numbered snippet so the model can reference line numbers
+        snippet = "\n".join(
+            f"{start + i:4d} | {line}"
+            for i, line in enumerate(lines[start - 1 : end])
+        )
+
+        return CodeContext(
+            filepath=str(resolved.relative_to(root)),
+            line_number=lineno,
+            start_line=start,
+            end_line=end,
+            snippet=snippet,
+        )
+    except (ValueError, OSError, UnicodeDecodeError):
+        return None