envfix 0.4.0__tar.gz → 0.5.0__tar.gz

{envfix-0.4.0 → envfix-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: envfix
-Version: 0.4.0
+Version: 0.5.0
 Summary: CLI tool that diagnoses and auto-fixes Python/ML environment errors using a local LLM.
 License: Business Source License 1.1
         
@@ -116,6 +116,9 @@ Requires-Dist: groq>=0.9.0
 Requires-Dist: google-genai>=0.1.0
 Requires-Dist: tomli>=2.0.1; python_version < "3.11"
 Requires-Dist: tomli-w>=1.0.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: semantic
+Requires-Dist: sentence-transformers>=3.0.0; extra == "semantic"
 Dynamic: license-file
 
 # envfix 🛠️

{envfix-0.4.0 → envfix-0.5.0}/envfix/__init__.py

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

{envfix-0.4.0 → envfix-0.5.0}/envfix/ai.py

@@ -1,6 +1,5 @@
-"""ai.py — Calls local or cloud AI models and parses their responses."""
+"""ai.py — Prompt building, response parsing, and provider dispatch for envfix."""
 
-import os
 import re
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Optional
@@ -8,21 +7,7 @@ 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
+from envfix.providers import get_provider
 
 
 PROMPT_TEMPLATE = (
@@ -125,68 +110,7 @@ def get_diagnosis(
     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}")
-
+    raw = get_provider(provider, model).diagnose(prompt)
     return _parse_response(raw)
 
 

{envfix-0.4.0 → envfix-0.5.0}/envfix/cache.py

@@ -7,6 +7,7 @@ from difflib import SequenceMatcher
 from typing import Optional
 
 from envfix.logger import get_log_file
+from envfix.embeddings import get_embedding, cosine_similarity
 
 # Minimum similarity ratio (0–1) to consider a log entry a match.
 # 0.92 is deliberately conservative: we only surface cache hits when
@@ -15,6 +16,10 @@ from envfix.logger import get_log_file
 # get matched to each other even when the missing package differs.
 SIMILARITY_THRESHOLD = 0.92
 
+# Threshold for semantic cosine similarity if sentence-transformers is installed.
+# 0.80 is empirically chosen to match identical errors with different variable names.
+SEMANTIC_THRESHOLD = 0.80
+
 
 @dataclass
 class CacheHit:
@@ -76,6 +81,8 @@ def find_cached_fix(
     # 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
+    
+    current_embedding = get_embedding(error_text)
 
     for entry in log_data:
         # ── Support both Phase 1 and Phase 2 schemas ─────────────────────
@@ -105,9 +112,19 @@ def find_cached_fix(
 
         if not stored_error or not fix:
             continue
+            
+        stored_embedding = entry.get("embedding")
+        is_semantic = False
+        
+        if current_embedding and stored_embedding:
+            score = cosine_similarity(current_embedding, stored_embedding)
+            is_semantic = True
+            hit_threshold = SEMANTIC_THRESHOLD
+        else:
+            score = SequenceMatcher(None, error_text, stored_error).ratio()
+            hit_threshold = SIMILARITY_THRESHOLD
 
-        score = SequenceMatcher(None, error_text, stored_error).ratio()
-        if score < threshold:
+        if score < hit_threshold:
             continue
 
         hit = CacheHit(

envfix-0.5.0/envfix/config.py

@@ -0,0 +1,66 @@
+import os
+import sys
+from pathlib import Path
+from typing import Dict, Any
+
+import typer
+import yaml
+from rich.console import Console
+
+console = Console()
+
+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:
+            global_config = tomllib.load(f)
+    except Exception:
+        global_config = {}
+
+    project_config = load_project_config()
+    
+    # Merge project config over global config
+    for k, v in project_config.items():
+        global_config[k] = v
+        
+    return global_config
+
+def load_project_config() -> Dict[str, Any]:
+    """Load the project-specific YAML configuration file."""
+    yaml_file = Path.cwd() / ".envfix.yaml"
+    if not yaml_file.exists():
+        return {}
+        
+    try:
+        with open(yaml_file, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+            return data if isinstance(data, dict) else {}
+    except yaml.YAMLError as e:
+        console.print(f"\n[bold red]✗ Failed to parse .envfix.yaml:[/bold red]\n{e}")
+        raise typer.Exit(code=1)
+    except OSError:
+        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-0.4.0 → envfix-0.5.0}/envfix/context.py

@@ -120,3 +120,91 @@ def _read_safe(filepath: str, lineno: int, root: Path) -> Optional[CodeContext]:
         )
     except (ValueError, OSError, UnicodeDecodeError):
         return None
+
+
+def is_external_path(path_str: str, root: Path) -> bool:
+    """Check if a path indicates a framework/stdlib or is outside the project root."""
+    path_str = path_str.replace("\\", "/")
+    if any(marker in path_str for marker in ["site-packages", "node_modules", "lib/python", "vendor/"]):
+        return True
+    
+    path_obj = Path(path_str)
+    if path_obj.is_absolute():
+        try:
+            path_obj.resolve().relative_to(root)
+        except (ValueError, OSError):
+            return True
+            
+    return False
+
+
+def trim_stack_trace(stderr: str, cwd: Optional[str] = None, ignore_patterns: Optional[list[str]] = None) -> str:
+    """
+    Trim external frames (site-packages, node_modules) from stack traces.
+    Strips any lines matching the provided regex patterns (ignore_patterns).
+    Caps the final text at ~12000 chars (approx 3000 tokens), keeping the bottom.
+    """
+    root = Path(cwd or os.getcwd()).resolve()
+    lines = stderr.splitlines()
+    
+    compiled_patterns = []
+    if ignore_patterns:
+        for p in ignore_patterns:
+            try:
+                compiled_patterns.append(re.compile(p))
+            except re.error:
+                pass
+    
+    out_lines = []
+    hidden_count = 0
+    skip_next = False
+    
+    for line in lines:
+        if compiled_patterns and any(p.search(line) for p in compiled_patterns):
+            continue
+            
+        if skip_next:
+            skip_next = False
+            # Python's code line under the frame is usually indented
+            if line.startswith("    ") or line.startswith("\t"):
+                continue
+        
+        # Check Python frame
+        py_match = re.search(r'File "([^"]+)",\s*line \d+', line)
+        if py_match:
+            path = py_match.group(1)
+            if is_external_path(path, root):
+                hidden_count += 1
+                skip_next = True
+                continue
+                
+        # Check Node frame
+        node_match = re.search(r'at\s+(?:[^\s(]+\s+\()?([^()]+?\.(?:js|ts|jsx|tsx|mjs|cjs)):(\d+)', line)
+        if node_match:
+            path = node_match.group(1)
+            if is_external_path(path, root):
+                hidden_count += 1
+                continue
+        
+        # Keep this line, flush hidden marker if needed
+        if hidden_count > 0:
+            out_lines.append(f"  [... {hidden_count} external frames hidden ...]")
+            hidden_count = 0
+            
+        out_lines.append(line)
+        
+    if hidden_count > 0:
+        out_lines.append(f"  [... {hidden_count} external frames hidden ...]")
+        
+    trimmed = "\n".join(out_lines)
+    
+    # Fallback if trimming removed everything useful
+    if not re.search(r'[a-zA-Z]', trimmed):
+        trimmed = stderr
+        
+    # Cap at ~12000 chars (keeping the bottom, which holds the actual error)
+    MAX_CHARS = 12000
+    if len(trimmed) > MAX_CHARS:
+        trimmed = "... [truncated] ...\n" + trimmed[-(MAX_CHARS - 25):]
+        
+    return trimmed

envfix-0.5.0/envfix/dependencies.py

@@ -0,0 +1,102 @@
+"""dependencies.py — Auto-append fixed packages to requirements files."""
+
+import os
+import re
+
+
+def extract_package_name(fix_command: str) -> str | None:
+    """
+    Extract the package name from a pip install command.
+    Example: 'python -m pip install -U torch' -> 'torch'
+    """
+    # Matches 'pip install', optional flags like '-U' or '--upgrade',
+    # and then captures the package name.
+    # Note: this is a heuristic and will grab the first package if multiple are specified.
+    match = re.search(r"pip\s+install\s+(?:-[a-zA-Z-]+\s+)*([a-zA-Z0-9_.-]+)", fix_command, re.IGNORECASE)
+    if match:
+        pkg = match.group(1).strip()
+        # Ignore common flags that might have been caught if regex missed them
+        if not pkg.startswith("-") and not pkg.endswith(".txt"):
+            return pkg
+    return None
+
+
+def update_requirements_txt(path: str, package: str) -> None:
+    """Append the package to requirements.txt, ensuring a trailing newline."""
+    if not os.path.exists(path):
+        return
+
+    with open(path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    # Avoid adding if it's already there
+    if re.search(rf"^{re.escape(package)}(?:[<>=!].*)?$", content, re.MULTILINE | re.IGNORECASE):
+        return
+
+    with open(path, "a", encoding="utf-8") as f:
+        if content and not content.endswith("\n"):
+            f.write("\n")
+        f.write(f"{package}\n")
+
+
+def update_pyproject_toml(path: str, package: str) -> None:
+    """
+    Insert the package into the [project] dependencies array in pyproject.toml.
+    Uses string manipulation to preserve comments and formatting.
+    """
+    if not os.path.exists(path):
+        return
+
+    with open(path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    # Avoid adding if it's already there (rudimentary check)
+    if f'"{package}"' in content or f"'{package}'" in content:
+        return
+
+    project_start = content.find("[project]")
+    if project_start == -1:
+        return
+
+    next_section = content.find("\n[", project_start + 1)
+    if next_section == -1:
+        next_section = len(content)
+
+    project_block = content[project_start:next_section]
+
+    # Find the dependencies array
+    match = re.search(r"(dependencies\s*=\s*\[)(.*?)(\])", project_block, flags=re.DOTALL)
+    if not match:
+        return
+
+    inner = match.group(2)
+    if "\n" in inner:
+        # Multi-line array: insert at the top to avoid trailing comma issues at the bottom
+        new_project_block = re.sub(
+            r"(dependencies\s*=\s*\[\s*\n)",
+            rf'\g<1>    "{package}",\n',
+            project_block,
+            count=1
+        )
+    else:
+        # Single-line array
+        inner_stripped = inner.strip()
+        if inner_stripped:
+            # Add at the beginning of the single line
+            new_inner = f'"{package}", ' + inner_stripped
+        else:
+            new_inner = f'"{package}"'
+            
+        new_project_block = re.sub(
+            r"(dependencies\s*=\s*\[).*?(\])",
+            rf'\g<1>{new_inner}\g<2>',
+            project_block,
+            count=1,
+            flags=re.DOTALL
+        )
+
+    # Reconstruct the file
+    new_content = content[:project_start] + new_project_block + content[next_section:]
+    
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(new_content)

envfix-0.5.0/envfix/embeddings.py

@@ -0,0 +1,43 @@
+"""embeddings.py — Semantic similarity using sentence-transformers."""
+
+from typing import Optional, List
+
+try:
+    from sentence_transformers import SentenceTransformer, util
+    _HAS_SENTENCE_TRANSFORMERS = True
+except ImportError:
+    _HAS_SENTENCE_TRANSFORMERS = False
+    SentenceTransformer = None
+    util = None
+
+
+_model = None
+
+
+def get_embedding(text: str) -> Optional[List[float]]:
+    """
+    Generate an embedding for the given text using all-MiniLM-L6-v2.
+    Returns None if sentence-transformers is not installed.
+    """
+    if not _HAS_SENTENCE_TRANSFORMERS:
+        return None
+
+    global _model
+    if _model is None:
+        _model = SentenceTransformer("all-MiniLM-L6-v2")
+
+    # Encode returns a numpy array or tensor, convert to standard Python floats for JSON serialization
+    embedding = _model.encode(text)
+    return embedding.tolist()
+
+
+def cosine_similarity(vec1: List[float], vec2: List[float]) -> float:
+    """
+    Compute cosine similarity between two embedding vectors.
+    Returns 0.0 if sentence-transformers is not installed.
+    """
+    if not _HAS_SENTENCE_TRANSFORMERS:
+        return 0.0
+
+    # util.cos_sim returns a 2D tensor (1x1), we extract the float item
+    return util.cos_sim(vec1, vec2).item()

envfix-0.5.0/envfix/git_utils.py

@@ -0,0 +1,63 @@
+"""git_utils.py — Git safety backup utilities."""
+
+import subprocess
+import time
+from typing import Optional
+
+
+def is_in_git_repo(cwd: Optional[str] = None) -> bool:
+    """Check if the current directory is inside a Git repository."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--is-inside-work-tree"],
+            cwd=cwd, capture_output=True, text=True, check=False
+        )
+        return result.returncode == 0 and result.stdout.strip() == "true"
+    except FileNotFoundError:
+        return False
+
+
+def has_uncommitted_changes(cwd: Optional[str] = None) -> bool:
+    """Check if there are any uncommitted changes in the repository."""
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=cwd, capture_output=True, text=True, check=False
+        )
+        return result.returncode == 0 and bool(result.stdout.strip())
+    except FileNotFoundError:
+        return False
+
+
+def create_safety_stash(cwd: Optional[str] = None) -> bool:
+    """
+    Create a non-destructive stash of the current working directory.
+    Uses 'git stash create' and 'git stash store' to avoid removing changes
+    from the working directory (unlike 'git stash push').
+    """
+    try:
+        # Create stash object
+        create_result = subprocess.run(
+            ["git", "stash", "create"],
+            cwd=cwd, capture_output=True, text=True, check=False
+        )
+        
+        if create_result.returncode != 0:
+            return False
+            
+        commit_hash = create_result.stdout.strip()
+        if not commit_hash:
+            return False  # Nothing to stash (e.g. only untracked files and no -u)
+            
+        # Store it
+        timestamp = int(time.time())
+        msg = f"envfix-auto-backup-{timestamp}"
+        
+        store_result = subprocess.run(
+            ["git", "stash", "store", "-m", msg, commit_hash],
+            cwd=cwd, capture_output=True, text=True, check=False
+        )
+        
+        return store_result.returncode == 0
+    except FileNotFoundError:
+        return False

{envfix-0.4.0 → envfix-0.5.0}/envfix/logger.py

@@ -7,6 +7,8 @@ import re
 from datetime import datetime, timezone
 from typing import Any, Optional
 
+from envfix.embeddings import get_embedding
+
 
 def get_log_file() -> str:
     """
@@ -85,6 +87,11 @@ def log_attempt(
         "context_included": context_included,
         "provider":         provider,
     }
+    
+    # Optionally compute and store a semantic embedding of the error text
+    embedding = get_embedding(error_text)
+    if embedding:
+        record["embedding"] = embedding
 
     log_data = _load_log(get_log_file())
     log_data.append(record)