logwise-cli 0.2.0__py3-none-any.whl

logwise/ai.py

@@ -0,0 +1,190 @@
+"""AI error analysis over any OpenAI-compatible chat API.
+
+Single HTTP code path (stdlib ``urllib`` only — no vendor SDKs) for all
+providers in :mod:`logwise.providers`. Gemini works through its
+``.../v1beta/openai`` endpoint; Ollama/LM Studio work against localhost.
+"""
+
+import json
+import urllib.error
+import urllib.request
+
+from .providers import (
+    PROVIDERS,
+    key_hint,
+    resolve_api_key,
+    resolve_base_url,
+    resolve_model,
+    resolve_provider,
+)
+
+TIMEOUT_S = 30
+
+_PROMPT_TEMPLATE = """Analyze this command error:
+Command: {command}
+Exit code: {exit_code}
+Stderr: {stderr}
+
+Reply in exactly this format, under 200 words:
+Reason: <one or two plain-language sentences>
+Fixes:
+1. <first step>
+2. <second step>
+"""
+
+
+def _extract_sse_content(body: str) -> str:
+    """Assemble assistant text from a Server-Sent Events stream.
+
+    Some OpenAI-compatible servers stream even when asked not to.
+    Collects ``choices[0].delta.content`` from each ``data:`` chunk,
+    ignoring reasoning fields and the ``[DONE]`` terminator.
+    """
+    parts = []
+    for line in body.splitlines():
+        line = line.strip()
+        if not line.startswith("data:"):
+            continue
+        data = line[5:].strip()
+        if not data or data == "[DONE]":
+            continue
+        try:
+            chunk = json.loads(data)
+        except ValueError:
+            continue
+        try:
+            delta = chunk["choices"][0].get("delta", {})
+        except (KeyError, IndexError, AttributeError):
+            continue
+        content = delta.get("content")
+        if content:
+            parts.append(content)
+    return "".join(parts).strip()
+
+
+def _post_chat_completions(base_url: str, api_key: str | None, model: str, prompt: str) -> str:
+    """POST one chat-completions request, return the assistant text."""
+    body = {
+        "model": model,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.7,
+        "max_tokens": 700,
+        "stream": False,
+    }
+    req = urllib.request.Request(
+        f"{base_url}/chat/completions",
+        data=json.dumps(body).encode("utf-8"),
+        headers={"Content-Type": "application/json"},
+    )
+    if api_key:
+        req.add_header("Authorization", f"Bearer {api_key}")
+    try:
+        with urllib.request.urlopen(req, timeout=TIMEOUT_S) as resp:
+            raw = resp.read().decode("utf-8", "replace")
+            content_type = resp.headers.get("Content-Type", "")
+    except urllib.error.HTTPError as e:
+        detail = e.read().decode("utf-8", "replace")[:300]
+        raise RuntimeError(f"HTTP {e.code} from {base_url}: {detail}")
+    except urllib.error.URLError as e:
+        raise RuntimeError(f"Cannot reach {base_url}: {e.reason}")
+
+    if "text/event-stream" in content_type:
+        text = _extract_sse_content(raw)
+        if not text:
+            raise RuntimeError(f"Empty SSE stream from {base_url}. Preview: {raw[:300]}")
+        return text
+    try:
+        payload = json.loads(raw)
+    except ValueError:
+        raise RuntimeError(
+            f"Non-JSON response from {base_url} "
+            f"(content-type: {content_type or 'unknown'}). "
+            f"Preview: {raw[:300]}"
+        )
+    try:
+        return payload["choices"][0]["message"]["content"].strip()
+    except (KeyError, IndexError, AttributeError):
+        raise RuntimeError(f"Unexpected API response shape: {str(payload)[:300]}")
+
+
+#: Line markers (case-insensitive, markdown-bold tolerant) that start
+#: the fixes section of a model response.
+_FIXES_MARKERS = (
+    "step-by-step",
+    "steps to fix",
+    "fix steps",
+    "how to fix",
+    "fixes:",
+    "solution:",
+    "resolution:",
+)
+
+
+def _split_reason_fixes(analysis: str) -> tuple[str, str]:
+    """Split model output into (reason, fixes).
+
+    Finds the first line starting with a known fixes marker; everything
+    before it is the reason (minus a leading ``Reason:`` label), everything
+    from it onward is the fixes (minus a bare header line like
+    ``**Fix Steps:**``). Falls back to whole-text-as-reason.
+    """
+    lines = analysis.splitlines()
+    for i, line in enumerate(lines):
+        clean = line.strip().strip("*").strip().lower()
+        if not any(clean.startswith(m) for m in _FIXES_MARKERS):
+            continue
+        reason = "\n".join(lines[:i])
+        for label in ("a simple human-readable reason for the error:", "reason:"):
+            bare = reason.lstrip().lstrip("*")
+            if bare.lower().startswith(label):
+                reason = bare[len(label) :].lstrip("*").strip()
+                break
+        fix_lines = lines[i:]
+        if fix_lines[0].strip().strip("*").strip().endswith(":"):
+            fix_lines = fix_lines[1:]  # bare header line, drop it
+        fixes = "\n".join(fix_lines).strip()
+        return reason.strip(), fixes or "No fixes suggested."
+    return analysis.strip(), "No fixes suggested."
+
+
+def ai_analyze_err(
+    command: str, stderr: str, exit_code: int, provider: str | None = None, model: str | None = None
+) -> dict:
+    """
+    Analyze an error with the selected provider (default: gemini).
+
+    Returns {"reason", "fixes", "provider", "model"} or {"error": ...}.
+    Resolves provider → LOGWISE_PROVIDER env → "gemini";
+    model → LOGWISE_MODEL env → provider default;
+    key → LOGWISE_API_KEY env → provider key env.
+    """
+    try:
+        canonical, config = resolve_provider(provider)
+    except ValueError as e:
+        return {"error": str(e)}
+    use_model = resolve_model(config, model)
+    base_url = resolve_base_url(config)
+    api_key = resolve_api_key(canonical, config)
+
+    keyless_local = "localhost" in base_url or "127.0.0.1" in base_url
+    if config["key_env"] is not None and not api_key and not keyless_local:
+        return {"error": f"No API key for provider '{canonical}'. {key_hint(canonical, config)}."}
+
+    prompt = _PROMPT_TEMPLATE.format(command=command, exit_code=exit_code, stderr=stderr)
+    try:
+        analysis = _post_chat_completions(base_url, api_key, use_model, prompt)
+    except Exception as e:
+        return {"error": f"AI analysis failed ({canonical}/{use_model}): {e}"}
+
+    reason, fixes = _split_reason_fixes(analysis)
+    return {
+        "reason": reason,
+        "fixes": fixes,
+        "provider": canonical,
+        "model": use_model,
+    }
+
+
+def list_providers() -> list:
+    """Provider names for CLI help / validation."""
+    return sorted(PROVIDERS)

logwise/analyze.py

@@ -0,0 +1,122 @@
+import json
+import os
+
+from .paths import get_log_dir
+from .rules import apply_rules
+
+
+def analyze_log_in_memory(
+    log: dict, use_ai: bool = False, provider: str | None = None, model: str | None = None
+) -> dict:
+    """
+    Analyze log dict directly.
+    If use_ai=True → AI-only analysis (rules skipped)
+    """
+    result = {"log": log}
+
+    # --- AI MODE (explicit override) ---
+    if use_ai:
+        from .ai import ai_analyze_err  # lazy: no network imports unless needed
+
+        ai_result = ai_analyze_err(
+            log["command"],
+            log["stderr"],
+            log["exit_code"],
+            provider=provider,
+            model=model,
+        )
+        if "error" in ai_result:
+            result["summary"] = f"AI analysis failed: {ai_result['error']}"
+        else:
+            result["summary"] = "AI-based analysis requested."
+            result["ai_analysis"] = ai_result
+        return result
+
+    # --- DEFAULT MODE (rules first, AI fallback) ---
+    issues = apply_rules(log)
+    result["issues"] = issues
+
+    if issues:
+        result["summary"] = f"Found {len(issues)} rule-based issue(s)."
+        return result
+
+    from .ai import ai_analyze_err  # lazy: no network imports unless needed
+
+    ai_result = ai_analyze_err(
+        log["command"],
+        log["stderr"],
+        log["exit_code"],
+        provider=provider,
+        model=model,
+    )
+    if "error" in ai_result:
+        result["summary"] = f"No rule-based issues. AI fallback failed: {ai_result['error']}"
+    else:
+        result["summary"] = "No rule-based issues. AI fallback used."
+        result["ai_analysis"] = ai_result
+
+    return result
+
+
+def analyze_log(
+    log_file: str, use_ai: bool = False, provider: str | None = None, model: str | None = None
+) -> dict:
+    full_path = os.path.join(get_log_dir(), log_file)
+    if not os.path.exists(full_path):
+        return {"error": "Log file not found."}
+
+    with open(full_path) as f:
+        log = json.load(f)
+
+    return analyze_log_in_memory(log, use_ai=use_ai, provider=provider, model=model)
+
+
+def list_logs() -> list:
+    log_dir = get_log_dir()
+    if not os.path.isdir(log_dir):
+        return []
+    return [f for f in os.listdir(log_dir) if f.endswith(".json")]
+
+
+def prune_logs(
+    keep: int | None = None, older_than_days: float | None = None, dry_run: bool = False
+) -> dict:
+    """Delete saved logs by age/count.
+
+    Returns {"deleted": [...], "kept": n}; with `dry_run=True` nothing is
+    removed and the doomed files are reported under "doomed" instead.
+
+    - `older_than_days` set: only files older than that are eligible.
+    - `keep` set: the newest `keep` eligible files are exempt.
+    - Both None: nothing is deleted.
+    Files are ordered by mtime (oldest first). Unreadable/deleted files
+    are skipped, never fatal.
+    """
+    if keep is None and older_than_days is None:
+        return {"deleted": [], "doomed": [], "kept": len(list_logs())}
+    log_dir = get_log_dir()
+    entries = []
+    for name in list_logs():
+        try:
+            entries.append((os.path.getmtime(os.path.join(log_dir, name)), name))
+        except OSError:
+            continue
+    entries.sort()  # oldest first
+    if older_than_days is not None:
+        import time
+
+        cutoff = time.time() - older_than_days * 86400
+        entries = [(mtime, name) for mtime, name in entries if mtime < cutoff]
+    doomed = [name for _, name in entries]
+    if keep is not None and keep >= 0:
+        doomed = doomed[: max(0, len(doomed) - keep)]
+    if dry_run:
+        return {"deleted": [], "doomed": doomed, "kept": len(list_logs())}
+    deleted = []
+    for name in doomed:
+        try:
+            os.remove(os.path.join(log_dir, name))
+            deleted.append(name)
+        except OSError:
+            continue
+    return {"deleted": deleted, "doomed": [], "kept": len(list_logs())}

logwise/capture.py

@@ -0,0 +1,64 @@
+import datetime
+import json
+import os
+import subprocess
+from contextlib import nullcontext as _nullcontext
+
+from . import display
+from .analyze import analyze_log_in_memory
+from .paths import get_log_dir
+
+
+def capture_and_run(
+    command: str,
+    use_ai: bool = False,
+    provider: str | None = None,
+    model: str | None = None,
+    no_color: bool = False,
+) -> str | None:
+    """
+    Run command, print output if no error else analyze the error.
+    Returns the saved log filename on failure, None on success.
+    """
+    start_time = datetime.datetime.now().isoformat()
+    try:
+        result = subprocess.run(command, shell=True, capture_output=True, text=True)
+        log_entry = {
+            "command": command,
+            "start_time": start_time,
+            "end_time": datetime.datetime.now().isoformat(),
+            "stdout": result.stdout.strip(),
+            "stderr": result.stderr.strip(),
+            "exit_code": result.returncode,
+        }
+        if result.returncode == 0 and not result.stderr:
+            print(result.stdout)
+            return None
+        else:
+            log_dir = get_log_dir()
+            os.makedirs(log_dir, exist_ok=True)
+            log_name = f"log_{start_time.replace(':', '-')}.json"
+            log_file = os.path.join(log_dir, log_name)
+            with open(log_file, "w") as f:
+                json.dump(log_entry, f, indent=4)
+            # Analyze in memory
+            console = display.get_console(no_color=no_color)
+            plain = not display.use_rich(console)
+            with display.ai_progress(console, provider, model, plain) if use_ai else _nullcontext():
+                analysis = analyze_log_in_memory(
+                    log_entry, use_ai=use_ai, provider=provider, model=model
+                )
+            display.error_header(console, result.returncode, plain)
+            display.stderr_block(console, result.stderr, plain)
+            display.analysis(
+                console,
+                analysis["summary"],
+                analysis.get("issues", []),
+                analysis.get("ai_analysis"),
+                plain,
+            )
+            return log_name
+
+    except Exception as e:
+        print("Execution failed: " + str(e))
+        return None

logwise/display.py

@@ -0,0 +1,221 @@
+"""Terminal rendering for LogWise (the only module that knows about color).
+
+All failure/analysis output goes through here so `run` and `analyze`
+never drift apart. Two modes:
+
+- Rich (terminal): red error header, stderr panel, colored issue rows,
+  Markdown AI panel, table-backed `list`.
+- Plain (piped/redirected, `NO_COLOR`/`LOGWISE_NO_COLOR`, or `--no-color`):
+  the exact legacy `print()` text, byte-for-byte, so scripts keep working.
+
+Success-path stdout never touches this module — it stays a plain print.
+"""
+
+import os
+import sys
+from contextlib import nullcontext
+
+import typer
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.markup import escape
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+#: Accent color per AI provider (AI panel, spinner). Unknown → magenta.
+PROVIDER_THEMES = {
+    "gemini": "blue",
+    "openai": "green",
+    "deepseek": "violet",
+    "groq": "orange1",
+    "openrouter": "cyan",
+    "ollama": "grey62",
+}
+
+
+def provider_color(name: str | None) -> str:
+    """Accent color for a provider name (case-insensitive)."""
+    return PROVIDER_THEMES.get((name or "").strip().lower(), "magenta")
+
+
+def get_console(no_color: bool = False) -> Console:
+    """Build a Console honoring `--no-color` / `LOGWISE_NO_COLOR` / `NO_COLOR`."""
+    return Console(
+        no_color=no_color or bool(os.getenv("LOGWISE_NO_COLOR")),
+    )
+
+
+def use_rich(console: Console) -> bool:
+    """Rich only when attached to a real terminal with color enabled."""
+    return bool(console.is_terminal) and not console.no_color
+
+
+def interactive(console: Console) -> bool:
+    """True when safe to prompt: terminal output AND tty stdin."""
+    try:
+        stdin_tty = sys.stdin.isatty()
+    except Exception:
+        stdin_tty = False
+    return bool(console.is_terminal) and stdin_tty
+
+
+def ai_progress(console: Console, provider: str | None, model: str | None, plain: bool):
+    """Spinner shown while waiting on an AI provider (no-op when plain).
+
+    Usage: `with ai_progress(console, provider, model, plain): ...`
+    """
+    if plain:
+        return nullcontext()
+    accent = provider_color(provider)
+    label = escape(f"{provider or 'ai'} / {model or '?'}")
+    return console.status(f"[{accent}]Consulting {label}…[/]", spinner="dots")
+
+
+def prompt_retry(console: Console) -> bool:
+    """Ask whether to re-run the failed command (False when non-interactive)."""
+    if not interactive(console):
+        return False
+    try:
+        return typer.confirm("Retry command?", default=False)
+    except Exception:
+        return False
+
+
+def prompt_ai(console: Console) -> bool:
+    """Offer AI analysis after a non-AI failure (False when non-interactive)."""
+    if not interactive(console):
+        return False
+    try:
+        return typer.confirm("Analyze with AI?", default=False)
+    except Exception:
+        return False
+
+
+def prompt_rerun(console: Console) -> bool:
+    """Offer to re-run a logged command from `analyze`."""
+    if not interactive(console):
+        return False
+    try:
+        return typer.confirm("Re-run the logged command?", default=False)
+    except Exception:
+        return False
+
+
+def prompt_edit_command(console: Console, current: str) -> str | None:
+    """Let the user edit a command before re-running it.
+
+    Returns the (possibly unchanged) command, or None if the user aborts
+    or prompts are unavailable. Enter keeps `current` (typer default).
+    """
+    if not interactive(console):
+        return None
+    try:
+        return typer.prompt("Edit command", default=current)
+    except KeyboardInterrupt:
+        return None
+    except Exception:
+        return None
+
+
+def error_header(console: Console, exit_code: int, plain: bool) -> None:
+    """`Error occurred (exit code: N)` — loud in rich, legacy text in plain."""
+    if plain:
+        typer.echo(f"Error occurred (exit code: {exit_code})")
+    else:
+        console.print(f"[bold red]:x: Error occurred[/] [red](exit code: {exit_code})[/]")
+
+
+def stderr_block(console: Console, stderr: str, plain: bool) -> None:
+    """Captured stderr — red panel in rich, labeled text in plain."""
+    if plain:
+        typer.echo("Stderr captured:")
+        typer.echo(stderr)
+    else:
+        console.print(
+            Panel(
+                Text(stderr or "(empty)", overflow="fold"),
+                title="[red]stderr[/]",
+                border_style="red",
+            )
+        )
+
+
+def analysis(
+    console: Console,
+    summary: str,
+    issues: list,
+    ai_analysis: dict | None,
+    plain: bool,
+    *,
+    show_summary: bool = True,
+    ai_label: str = "AI Enhanced Analysis:",
+) -> None:
+    """Summary line + rule issues + optional AI panel.
+
+    `show_summary=False` skips the summary (for callers that already
+    printed it, e.g. `analyze` under its "Log Summary:" label). `ai_label`
+    keeps each command's legacy plain-text header byte-identical.
+    """
+    if plain:
+        if show_summary:
+            typer.echo("\nAnalysis:")
+            typer.echo(summary)
+        for issue in issues:
+            typer.echo(f"- Reason: {issue['description']} ({issue['root_cause']})")
+            typer.echo(f"  Steps to fix: {issue['fixes']}")
+        if ai_analysis:
+            typer.echo(f"\n{ai_label}")
+            typer.echo(f"Reason: {ai_analysis['reason']}")
+            typer.echo(f"Steps to fix: {ai_analysis['fixes']}")
+        return
+
+    console.print(f"[bold]{escape(summary)}[/]")
+    for n, issue in enumerate(issues, 1):
+        console.print(
+            f"[yellow]:warning: {n}. {escape(issue['description'])}[/]"
+            f" [dim]({escape(issue['root_cause'])})[/]"
+            f" [dim][{escape(str(issue.get('rule_id', '?')))}][/]"
+        )
+        console.print(f"   [green]->[/] {escape(issue['fixes'])}")
+    if ai_analysis:
+        provider = escape(str(ai_analysis.get("provider", "?")))
+        model = escape(str(ai_analysis.get("model", "?")))
+        accent = provider_color(ai_analysis.get("provider"))
+        console.print(
+            Panel(
+                Markdown(f"{ai_analysis['reason']}\n\n{ai_analysis['fixes']}"),
+                title=f"[bold {accent}]:sparkles: AI analysis[/]",
+                subtitle=f"[dim]{provider} / {model}[/]",
+                border_style=accent,
+            )
+        )
+
+
+def log_table(console: Console, entries: list, plain: bool) -> None:
+    """Saved-logs listing — table in rich, one-per-line in plain.
+
+    `entries` is a list of {"file", "command", "exit_code"} dicts; any of
+    the latter two may be None for unreadable files.
+    """
+    if plain:
+        if not entries:
+            typer.echo("No logs found.")
+        for entry in entries:
+            typer.echo(entry["file"])
+        return
+
+    if not entries:
+        console.print("[dim]No logs found.[/]")
+        return
+    table = Table(title="Captured logs")
+    table.add_column("File", style="cyan")
+    table.add_column("Command", overflow="fold")
+    table.add_column("Exit", justify="right", style="red")
+    for entry in entries:
+        table.add_row(
+            escape(entry["file"]),
+            escape(entry.get("command")) if entry.get("command") else "[dim](unreadable)[/]",
+            str(entry["exit_code"]) if entry.get("exit_code") is not None else "?",
+        )
+    console.print(table)

logwise/env.py

@@ -0,0 +1,98 @@
+"""Minimal `.env` file support (stdlib only, no python-dotenv dependency).
+
+Loaded once at CLI startup (see ``main.py``). Rules:
+
+- Discovery: ``LOGWISE_ENV_FILE`` if set, else the first ``.env`` found
+  walking from the current working directory up to the filesystem root.
+  (Cwd-based, not package-dir-based, so it works for a pip-installed
+  ``logwise`` run from any project directory.)
+- Precedence: real process environment always wins — file values are
+  applied with ``os.environ.setdefault`` and never override exports.
+- Format (common subset): ``KEY=VALUE`` lines, optional ``export ``
+  prefix, ``#`` comments, single/double-quote stripping. Single-line
+  values only; no variable interpolation or multiline values.
+
+A missing file is silently ignored, except an explicitly-set but
+missing ``LOGWISE_ENV_FILE``, which warns on stderr.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+ENV_FILENAME = ".env"
+ENV_FILE_OVERRIDE_VAR = "LOGWISE_ENV_FILE"
+
+
+def find_dotenv(start: Path | None = None) -> Path | None:
+    """Return the nearest `.env` from `start` upward, or None."""
+    current = (start or Path.cwd()).resolve()
+    root = current.anchor
+    while True:
+        candidate = current / ENV_FILENAME
+        if candidate.is_file():
+            return candidate
+        if str(current) == root:
+            return None
+        current = current.parent
+
+
+def parse_dotenv_text(text: str) -> dict:
+    """Parse `.env` content into a dict (no env interaction)."""
+    values: dict = {}
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if line.lower().startswith("export "):
+            line = line[7:].lstrip()
+        key, sep, value = line.partition("=")
+        if not sep:
+            continue
+        key = key.strip()
+        if not key or key[0].isdigit() or not key.replace("_", "").isalnum():
+            continue
+        value = value.strip()
+        if len(value) >= 2 and value[0] == value[-1] and value[0] in ("'", '"'):
+            value = value[1:-1]
+        elif "#" in value:
+            # Strip trailing inline comments only for unquoted values.
+            value = value.split("#", 1)[0].rstrip()
+        values[key] = value
+    return values
+
+
+def load_dotenv(path: Path | str | None = None) -> Path | None:
+    """Load environment variables from a `.env` file.
+
+    Returns the path loaded, or None if no file was found. Existing
+    process environment variables are never overridden.
+    """
+    if path is None:
+        override = os.getenv(ENV_FILE_OVERRIDE_VAR)
+        if override:
+            explicit = Path(override).expanduser()
+            if not explicit.is_file():
+                print(
+                    f"logwise: {ENV_FILE_OVERRIDE_VAR}={override} not found, skipping.",
+                    file=sys.stderr,
+                )
+                return None
+            path = explicit
+        else:
+            found = find_dotenv()
+            if found is None:
+                return None
+            path = found
+    else:
+        path = Path(path).expanduser()
+        if not path.is_file():
+            return None
+
+    try:
+        text = path.read_text(encoding="utf-8")
+    except OSError:
+        return None
+    for key, value in parse_dotenv_text(text).items():
+        os.environ.setdefault(key, value)
+    return path