envfix 0.4.0__py3-none-any.whl

envfix/logger.py

@@ -0,0 +1,147 @@
+"""logger.py — Structured JSON logging + history reader for envfix."""
+
+import getpass
+import json
+import os
+import re
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+
+def get_log_file() -> str:
+    """
+    Return the path to this user's envfix log file.
+
+    The filename is derived from the OS username so that multiple
+    users on a shared machine each get their own separate history.
+
+    Examples:
+        alice   -> envfix_log_alice.json
+        bob     -> envfix_log_bob.json
+    """
+    # Sanitise the username so it's always safe to use in a filename
+    raw = getpass.getuser()
+    safe = re.sub(r"[^A-Za-z0-9_-]", "_", raw)
+    return f"envfix_log_{safe}.json"
+
+
+# Legacy constant kept for backward compat (tests, cache.py default arg)
+LOG_FILE = get_log_file()
+
+
+def log_attempt(
+    original_command: str,
+    error_text: str,
+    diagnosis: str,
+    fix_command: str,
+    user_approved: bool,
+    fix_worked: Optional[bool],
+    source: str = "ollama",
+    category: str = "general",
+    context_included: bool = False,
+    provider: str = "ollama",
+) -> None:
+    """
+    Append one attempt record to the user's personal log file.
+
+    Phase 4 schema
+    ──────────────
+    {
+      "timestamp":        ISO-8601 UTC string,
+      "original_command": the shell command that failed,
+      "error_text":       captured stderr (or stdout) from that command,
+      "diagnosis":        AI-generated or cache-sourced diagnosis,
+      "fix_command":      the suggested fix command,
+      "user_approved":    whether the user said y to apply it,
+      "fix_worked":       True/False after retry, None if not approved,
+      "source":           "ollama" | "cache",
+      "category":         ecosystem category (e.g. "python", "node", "general"),
+      "context_included": whether a code snippet was injected into the prompt,
+      "provider":         the AI provider used (e.g., "ollama", "groq", "gemini")
+    }
+
+    Args:
+        original_command: The failing shell command.
+        error_text:       Captured stderr/stdout of the failure.
+        diagnosis:        Diagnosis text (from model or cache).
+        fix_command:      Suggested fix command.
+        user_approved:    True if the user approved running the fix.
+        fix_worked:       True/False after re-run, None if not applied.
+        source:           Where the fix came from: "ollama" or "cache".
+        category:         The ecosystem category.
+        context_included: Whether a code snippet was included in the prompt.
+        provider:         The AI provider used.
+    """
+    record: dict[str, Any] = {
+        "timestamp":        datetime.now(timezone.utc).isoformat(),
+        "original_command": original_command,
+        "error_text":       error_text,
+        "diagnosis":        diagnosis,
+        "fix_command":      fix_command,
+        "user_approved":    user_approved,
+        "fix_worked":       fix_worked,
+        "source":           source,
+        "category":         category,
+        "context_included": context_included,
+        "provider":         provider,
+    }
+
+    log_data = _load_log(get_log_file())
+    log_data.append(record)
+    _save_log(log_data, get_log_file())
+
+
+def get_history(log_file: str = LOG_FILE) -> list[dict[str, Any]]:
+    """
+    Load and return all log entries, newest-first.
+
+    Transparently reads both Phase 1 (legacy) and Phase 2 schemas.
+    Each returned dict is guaranteed to have these keys:
+        timestamp, original_command, error_text, diagnosis,
+        fix_command, user_approved, fix_worked, source, category
+    """
+    raw = _load_log(log_file)
+    normalised = []
+    for entry in raw:
+        normalised.append(_normalise_entry(entry))
+    return list(reversed(normalised))  # newest first
+
+
+# ── Private helpers ───────────────────────────────────────────────────────────
+
+def _load_log(log_file: str = LOG_FILE) -> list[dict[str, Any]]:
+    """Load JSON log; return empty list on any error."""
+    if not os.path.exists(log_file):
+        return []
+    try:
+        with open(log_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return data if isinstance(data, list) else []
+    except (json.JSONDecodeError, OSError):
+        return []
+
+
+def _save_log(log_data: list[dict[str, Any]], log_file: str = LOG_FILE) -> None:
+    """Write the log list to disk as pretty-printed JSON."""
+    with open(log_file, "w", encoding="utf-8") as f:
+        json.dump(log_data, f, indent=2, ensure_ascii=False)
+
+
+def _normalise_entry(entry: dict[str, Any]) -> dict[str, Any]:
+    """
+    Convert a Phase 1 log entry into the Phase 2 schema.
+    Phase 2 entries pass through unchanged.
+    """
+    return {
+        "timestamp":        entry.get("timestamp", ""),
+        "original_command": entry.get("original_command") or entry.get("command", ""),
+        "error_text":       entry.get("error_text") or entry.get("stderr", ""),
+        "diagnosis":        entry.get("diagnosis", ""),
+        "fix_command":      entry.get("fix_command") or entry.get("fix", ""),
+        "user_approved":    entry.get("user_approved") if "user_approved" in entry else entry.get("approved", False),
+        "fix_worked":       entry.get("fix_worked") if "fix_worked" in entry else entry.get("worked"),
+        "source":           entry.get("source", "ollama"),
+        "category":         entry.get("category", "general"),
+        "context_included": bool(entry.get("context_included", False)),
+        "provider":         entry.get("provider", "ollama"),
+    }

envfix/main.py

@@ -0,0 +1,485 @@
+"""main.py — Typer CLI entry point for envfix (Phase 2)."""
+
+import sys
+from datetime import datetime, timezone
+from typing import List, Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+from rich.text import Text
+
+from envfix.ai import _clean_fix, get_actual_model, get_diagnosis
+from envfix.cache import find_cached_fix
+from envfix.config import load_config, save_config, reset_config
+from envfix.context import extract_context
+from envfix.logger import LOG_FILE, get_history, get_log_file, log_attempt
+from envfix.preview import get_fix_preview, is_destructive
+from envfix.runner import run_command
+
+app = typer.Typer(
+    name="envfix",
+    help="Diagnose and auto-fix Python/ML environment errors using a local LLM.",
+    add_completion=False,
+)
+
+console = Console()
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _quote_join(tokens: List[str]) -> str:
+    """
+    Join command tokens back into a shell string, re-quoting any token
+    that contains spaces with double quotes.
+
+    PowerShell strips quotes when it passes arguments, so:
+        envfix run python -c "import torch"
+    arrives as tokens: ["python", "-c", "import torch"]
+
+    Without re-quoting we'd produce: python -c import torch  (SyntaxError).
+    With re-quoting we produce:      python -c "import torch"  (correct).
+    """
+    if len(tokens) == 1:
+        return tokens[0]
+
+    parts = []
+    for tok in tokens:
+        if " " in tok:
+            tok = '"' + tok.replace('"', '\\"') + '"'
+        parts.append(tok)
+    return " ".join(parts)
+
+
+def _show_fix_panel(
+    diagnosis: str,
+    fix: str,
+    source: str,
+    cache_score: Optional[float] = None,
+) -> None:
+    """Render the DIAGNOSIS + FIX suggestion panel."""
+    source_tag = (
+        f"[dim] (from cache — {cache_score:.0%} match)[/dim]"
+        if source == "cache" and cache_score is not None
+        else ""
+    )
+    console.print(
+        Panel(
+            Text.assemble(
+                ("DIAGNOSIS\n", "bold magenta"),
+                (diagnosis + "\n\n", "white"),
+                ("FIX\n", "bold cyan"),
+                (fix, "bold white"),
+            ),
+            title=f"[bold]envfix Suggestion[/bold]{source_tag}",
+            border_style="cyan",
+            expand=False,
+        )
+    )
+
+
+# ── Commands ──────────────────────────────────────────────────────────────────
+
+@app.command("config")
+def config_cmd(
+    show: bool = typer.Option(False, "--show", help="Show current configuration."),
+    reset: bool = typer.Option(False, "--reset", help="Reset configuration to defaults."),
+) -> None:
+    """Manage envfix global configuration interactively."""
+    if reset:
+        reset_config()
+        console.print("[green]Configuration reset to defaults.[/green]")
+        return
+        
+    if show:
+        config = load_config()
+        if not config:
+            console.print("[yellow]No configuration found. Using hardcoded defaults.[/yellow]")
+            return
+            
+        table = Table(title="Global Configuration")
+        table.add_column("Key", style="cyan")
+        table.add_column("Value", style="magenta")
+        
+        for k, v in config.items():
+            table.add_row(k, str(v))
+            
+        console.print(table)
+        return
+
+    console.print("[bold cyan]envfix Configuration Setup[/bold cyan]\n")
+    
+    while True:
+        provider = typer.prompt("Default provider [ollama/groq/gemini]", default="ollama")
+        if provider in ["ollama", "groq", "gemini"]:
+            break
+        console.print("[red]Invalid choice. Must be ollama, groq, or gemini.[/red]")
+        
+    while True:
+        category = typer.prompt("Default category [general/python/node/docker]", default="general")
+        if category in ["general", "python", "node", "docker"]:
+            break
+        console.print("[red]Invalid choice. Must be general, python, node, or docker.[/red]")
+    
+    save_config({
+        "default_provider": provider,
+        "default_category": category,
+    })
+    
+    console.print("\n[bold green]Configuration saved successfully![/bold green]")
+
+
+@app.command(
+    context_settings={"ignore_unknown_options": True, "allow_extra_args": True},
+)
+def run(
+    ctx: typer.Context,
+    model: str = typer.Option(
+        "llama3.1:8b",
+        "--model",
+        help="Ollama model tag to use for diagnosis.",
+        show_default=True,
+    ),
+    category: Optional[str] = typer.Option(
+        None,
+        "--category",
+        help="Ecosystem category (e.g. python, node, docker) to tailor the diagnosis. [default: general (or config)]",
+    ),
+    provider: Optional[str] = typer.Option(
+        None,
+        "--provider",
+        help="AI provider to use (ollama, groq, gemini). [default: ollama (or config)]",
+    ),
+    no_cache: bool = typer.Option(
+        False,
+        "--no-cache",
+        help="Bypass the local cache and force a new AI diagnosis.",
+    ),
+) -> None:
+    """
+    Run COMMAND. If it fails, diagnose the error with a local LLM (or cache),
+    propose a fix, and (with your approval) apply it and retry.
+
+    Everything after [OPTIONS] is treated as the command to run:
+
+    \b
+        envfix run python -m non_existent_module_xyz
+        envfix run python -c "import torch"
+        envfix run python train.py --gpu 0
+        envfix run --model qwen2.5:3b python train.py
+    """
+    # ── Parse args (strip Typer 0.27 subcommand-name leak) ───────────────
+    args = list(ctx.args)
+    if args and args[0] == "run":
+        args.pop(0)
+    cmd = _quote_join(args)
+
+    if not cmd.strip():
+        console.print(
+            "[bold red]Error:[/bold red] No command provided.\n"
+            "Usage:  [bold]envfix run[/bold] [OPTIONS] COMMAND...\n"
+            "Example:[bold] envfix run python -m non_existent_module_xyz[/bold]"
+        )
+        raise typer.Exit(code=1)
+        
+    # Resolve defaults from config if omitted
+    config = load_config()
+    if not provider:
+        provider = config.get("default_provider", "ollama")
+    if not category:
+        category = config.get("default_category", "general")
+
+    # ── Step 1: Run the original command ─────────────────────────────────
+    console.print(f"\n[bold cyan]▶ Running:[/bold cyan] {cmd}\n")
+    stdout, stderr, returncode = run_command(cmd)
+
+    if stdout:
+        console.print(stdout, end="")
+
+    if returncode == 0:
+        console.print("\n[bold green]✓ Command succeeded — nothing to fix![/bold green]")
+        return
+
+    # ── Step 2: Command failed — show the error ───────────────────────────
+    error_text = stderr.strip() or stdout.strip() or "(no output captured)"
+    console.print(
+        Panel(
+            error_text,
+            title="[bold red]✗ Command Failed[/bold red]",
+            border_style="red",
+            expand=False,
+        )
+    )
+
+    # ── Step 3: Extract code context from the stack trace ─────────────────
+    code_context = extract_context(error_text)
+    if code_context:
+        console.print(
+            f"[dim]📎 Context found: {code_context.filepath} "
+            f"(lines {code_context.start_line}–{code_context.end_line})[/dim]"
+        )
+
+    # ── Step 4: Check known-fix cache before calling the model ───────────
+    if not no_cache:
+        cache_hit = find_cached_fix(error_text, category=category)
+    else:
+        cache_hit = None
+    
+    source = provider
+
+    if cache_hit:
+        if cache_hit.previously_worked:
+            banner = (
+                f"⚡ Found a previously [bold green]verified[/bold green] fix "
+                f"for a similar error ({cache_hit.score:.0%} match) — skipping model call."
+            )
+        else:
+            banner = (
+                f"⚡ Found a previously [bold yellow]attempted[/bold yellow] fix "
+                f"for a similar error ({cache_hit.score:.0%} match) — "
+                "skipping model call. [dim](fix didn't fully resolve it last time)[/dim]"
+            )
+        console.print(f"\n{banner}")
+        diagnosis = cache_hit.diagnosis
+        # Normalise cached fix commands — old log entries may have bare 'pip install'
+        # which doesn't work on Windows. _clean_fix() converts it to 'python -m pip'.
+        fix = _clean_fix(cache_hit.fix)
+        source = "cache"
+        _show_fix_panel(diagnosis, fix, source, cache_hit.score)
+    else:
+        # ── Step 4a: Ask the LLM ─────────────────────────────────────────
+        provider_name = provider.capitalize()
+        display_model = get_actual_model(model, provider)
+        console.print(
+            f"\n[bold yellow]🤖 Asking {provider_name} ({display_model}) for a diagnosis…[/bold yellow]"
+        )
+        try:
+            result = get_diagnosis(
+                stderr=error_text,
+                model=model,
+                category=category,
+                code_context=code_context,
+                provider=provider,
+            )
+        except RuntimeError as exc:
+            console.print(f"\n[bold red]Error reaching {provider_name}:[/bold red] {exc}")
+            raise typer.Exit(code=1)
+
+        if not result.parsed_ok:
+            console.print(
+                "\n[bold yellow]⚠ Could not parse a structured response. "
+                "Showing raw model output:[/bold yellow]"
+            )
+            console.print(
+                Panel(result.raw_response, border_style="yellow", expand=False)
+            )
+            log_attempt(
+                original_command=cmd,
+                error_text=error_text,
+                diagnosis=result.diagnosis,
+                fix_command=result.fix,
+                user_approved=False,
+                fix_worked=None,
+                source=provider,
+                category=category,
+                context_included=code_context is not None,
+                provider=provider,
+            )
+            raise typer.Exit(code=1)
+
+        diagnosis = result.diagnosis
+        fix = result.fix
+        _show_fix_panel(diagnosis, fix, source)
+
+    # ── Step 4b: Dry-run preview ──────────────────────────────────────────
+    preview = get_fix_preview(fix)
+    if preview:
+        console.print(
+            f"\n[bold yellow]📋 What this will do:[/bold yellow] {preview}"
+        )
+
+    # ── Step 5: Ask for approval ──────────────────────────────────────────
+    if is_destructive(fix):
+        console.print(
+            "\n[bold red]⚠️ DANGEROUS COMMAND DETECTED[/bold red]\n"
+            "[yellow]This command may delete files, change permissions, or execute remote code.[/yellow]"
+        )
+        response = Prompt.ask("[bold]Type 'yes' to run this fix[/bold]", default="no")
+        approved = (response.strip().lower() == "yes")
+    else:
+        approved = Confirm.ask("\n[bold]Run this fix?[/bold]", default=False)
+
+    if not approved:
+        console.print("[dim]Exiting without changes.[/dim]")
+        log_attempt(
+            original_command=cmd,
+            error_text=error_text,
+            diagnosis=diagnosis,
+            fix_command=fix,
+            user_approved=False,
+            fix_worked=None,
+            source=source,
+            category=category,
+            context_included=code_context is not None,
+            provider=provider,
+        )
+        raise typer.Exit(code=0)
+
+    # ── Step 6: Run the fix, then re-run the original command ─────────────
+    console.print(f"\n[bold cyan]⚙ Applying fix:[/bold cyan] {fix}\n")
+    fix_stdout, fix_stderr, fix_rc = run_command(fix)
+
+    if fix_stdout:
+        console.print(fix_stdout, end="")
+    if fix_stderr:
+        console.print(fix_stderr, end="")
+
+    if fix_rc != 0:
+        console.print(
+            "[bold red]✗ Fix command itself failed "
+            f"(exit code {fix_rc}). Aborting retry.[/bold red]"
+        )
+        log_attempt(
+            original_command=cmd,
+            error_text=error_text,
+            diagnosis=diagnosis,
+            fix_command=fix,
+            user_approved=True,
+            fix_worked=False,
+            source=source,
+            category=category,
+            context_included=code_context is not None,
+            provider=provider,
+        )
+        raise typer.Exit(code=1)
+
+    console.print(
+        f"\n[bold cyan]🔄 Re-running original command:[/bold cyan] {cmd}\n"
+    )
+    retry_stdout, retry_stderr, retry_rc = run_command(cmd)
+
+    if retry_stdout:
+        console.print(retry_stdout, end="")
+    if retry_stderr:
+        console.print(retry_stderr, end="")
+
+    # ── Step 7: Report result ─────────────────────────────────────────────
+    worked = retry_rc == 0
+    if worked:
+        console.print(
+            "\n[bold green]✓ Success! The fix resolved the issue.[/bold green]"
+        )
+    else:
+        console.print(
+            "\n[bold red]✗ Original command still failed after the fix "
+            f"(exit code {retry_rc}). "
+            "You may need to try a different approach.[/bold red]"
+        )
+
+    # ── Step 8: Log everything ────────────────────────────────────────────
+    log_attempt(
+        original_command=cmd,
+        error_text=error_text,
+        diagnosis=diagnosis,
+        fix_command=fix,
+        user_approved=True,
+        fix_worked=worked,
+        source=source,
+        category=category,
+        context_included=code_context is not None,
+        provider=provider,
+    )
+    console.print(f"\n[dim]📝 Attempt logged to {get_log_file()}[/dim]")
+    raise typer.Exit(code=0 if worked else 1)
+
+
+@app.command()
+def history(
+    last: int = typer.Option(20, "--last", "-n", help="Show the last N attempts."),
+) -> None:
+    """
+    Print a readable summary of past envfix attempts from the current user's log file.
+
+    \b
+        envfix history          # show last 20
+        envfix history --last 5 # show last 5
+    """
+    entries = get_history()
+
+    if not entries:
+        console.print(
+            "[yellow]No history found.[/yellow] "
+            f"Run [bold]envfix run[/bold] on a failing command first.\n"
+            f"(Looking for [dim]{get_log_file()}[/dim] in the current directory)"
+        )
+        return
+
+    shown = entries[:last]
+    total = len(entries)
+
+    table = Table(
+        title=f"envfix History  (showing {len(shown)} of {total} attempts)",
+        border_style="cyan",
+        show_lines=True,
+        expand=False,
+    )
+    table.add_column("#",    no_wrap=True)
+    table.add_column("When",        style="white",        width=16, no_wrap=True)
+    table.add_column("Command",     style="bold white",   width=30)
+    table.add_column("Fix",         style="cyan",         width=30)
+    table.add_column("Category",    style="magenta",      width=10, no_wrap=True)
+    table.add_column("Approved",    style="white",        width=8,  no_wrap=True)
+    table.add_column("Worked",      style="white",        width=8,  no_wrap=True)
+    table.add_column("Source",      style="dim",          width=7,  no_wrap=True)
+
+    for idx, entry in enumerate(shown, start=1):
+        # Format timestamp nicely
+        ts = entry.get("timestamp", "")
+        try:
+            dt = datetime.fromisoformat(ts)
+            when = dt.strftime("%b %d  %H:%M")
+        except (ValueError, TypeError):
+            when = ts[:16]
+
+        orig_cmd = entry.get("original_command", "—")
+        fix_cmd  = entry.get("fix_command", "—")
+
+        approved_val = entry.get("user_approved")
+        worked_val   = entry.get("fix_worked")
+
+        approved_str = "[green]y[/green]" if approved_val else "[red]n[/red]"
+
+        if worked_val is True:
+            worked_str = "[green]✓ yes[/green]"
+        elif worked_val is False:
+            worked_str = "[red]✗ no[/red]"
+        else:
+            worked_str = "[dim]—[/dim]"
+
+        source_str = entry.get("source", "ollama")
+        cat_str = entry.get("category", "general")
+
+        table.add_row(
+            str(idx),
+            when,
+            orig_cmd,
+            fix_cmd,
+            cat_str,
+            approved_str,
+            worked_str,
+            source_str,
+        )
+
+    console.print()
+    console.print(table)
+    console.print()
+
+
+def main() -> None:  # pragma: no cover
+    app()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()