patchi 0.7.5__py3-none-any.whl

patchi/cli/commands/model_cmd.py

@@ -0,0 +1,207 @@
+"""
+`p model` — Manage Patchi's local Ollama model integration.
+
+Subcommands:
+  p model set <model_name>   — Set the local model Patchi uses
+  p model list               — List available models from Ollama
+  p model status             — Show current model + Ollama connection health
+
+Ollama API base: http://localhost:11434
+All network calls time out in 5s — they are informational checks, not blockers.
+"""
+
+from __future__ import annotations
+
+# ── Subcommand runners ─────────────────────────────────────────────────────────
+import logging
+import time
+from pathlib import Path
+
+from rich.table import Table
+
+from patchi.cli.console import con
+from patchi.core.config import require_project_root
+from patchi.core.constants import OLLAMA_BASE_URL
+
+_log = logging.getLogger("patchi.cli.model_cmd")
+
+
+def run_set(model_name: str, root: Path | None = None) -> None:
+    """Set the local model Patchi will use."""
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    from patchi.core import config as cfg
+
+    cfg.set_value("ai.local_model_name", model_name, r)
+    con.print()
+    con.print(f"[#4ADE80]✓[/#4ADE80] Local model set to [bold]{model_name}[/bold]")
+    con.print()
+
+    # Quick availability check
+    ok, note = _model_available(model_name)
+    if ok:
+        con.print(f"  [dim]✓ {note}[/dim]")
+    else:
+        con.print(f"  [#FACC15]⚠ {note}[/#FACC15]")
+    con.print()
+
+
+def run_list(root: Path | None = None) -> None:
+    """List models available from local Ollama instance."""
+    con.print()
+    con.print("[bold #C8621A]Local Models[/bold #C8621A]  [dim]from Ollama (localhost:11434)[/dim]")
+    con.print()
+
+    try:
+        r = root or require_project_root()
+        from patchi.core import config as cfg
+
+        current_model = cfg.load(r).get("ai", {}).get("local_model_name", "")
+    except Exception as e:
+        _log.warning("run_list failed: %s", e)
+        current_model = ""
+
+    models = _fetch_models()
+
+    if models is None:
+        con.print("[#FACC15]⚠  Ollama is not running.[/#FACC15]")
+        con.print("[dim]Start it with: ollama serve[/dim]")
+        con.print()
+        return
+
+    if not models:
+        con.print("[dim]No models pulled yet.[/dim]")
+        con.print("[dim]Try: ollama pull llama3.2[/dim]")
+        con.print()
+        return
+
+    table = Table(show_header=True, header_style="bold #C8621A", box=None, pad_edge=False)
+    table.add_column("Model", style="bold #F2EDD6", width=32)
+    table.add_column("Size", justify="right", width=10)
+    table.add_column("Modified", width=22)
+    table.add_column("Active", width=8)
+
+    for m in sorted(models, key=lambda x: x.get("name", "")):
+        name = m.get("name", "?")
+        size = _fmt_size(m.get("size", 0))
+        mod = m.get("modified_at", "")[:19].replace("T", " ")
+        active = (
+            "[#4ADE80]●[/#4ADE80]"
+            if name.split(":")[0] == (current_model or "").split(":")[0]
+            else ""
+        )
+        table.add_row(name, size, mod, active)
+
+    con.print(table)
+    con.print()
+
+
+def run_status(root: Path | None = None) -> None:
+    """Show Ollama connection health and current model."""
+    con.print()
+    con.print("[bold #C8621A]Model Status[/bold #C8621A]")
+    con.print()
+
+    try:
+        r = root or require_project_root()
+        from patchi.core import config as cfg
+
+        config = cfg.load(r)
+        local_model = config.get("ai", {}).get("local_model_name")
+    except RuntimeError:
+        local_model = None
+
+    # ── Ollama health ─────────────────────────────────────────────────────────
+    ollama_ok, ollama_note = _check_ollama()
+    marker = "[#4ADE80]●[/#4ADE80]" if ollama_ok else "[#FF4D6D]●[/#FF4D6D]"
+    con.print(f"  {marker} Ollama   [dim]{ollama_note}[/dim]")
+
+    # ── Configured model ──────────────────────────────────────────────────────
+    if local_model:
+        avail_ok, avail_note = _model_available(local_model)
+        marker2 = "[#4ADE80]●[/#4ADE80]" if avail_ok else "[#FACC15]●[/#FACC15]"
+        con.print(f"  {marker2} Model    [bold]{local_model}[/bold]  [dim]{avail_note}[/dim]")
+
+        # Benchmark ping if available
+        if ollama_ok:
+            ms = _ping_model(local_model)
+            if ms is not None:
+                con.print(f"  [dim]         Response time: {ms}ms[/dim]")
+    else:
+        con.print("  [dim]—  No local model configured. Run: p model set <name>[/dim]")
+
+    con.print()
+
+
+# ── Ollama API helpers ─────────────────────────────────────────────────────────
+
+
+def _fetch_models() -> list[dict] | None:
+    """Return list of pulled model objects, or None if Ollama is unreachable."""
+    try:
+        import httpx
+
+        resp = httpx.get(f"{OLLAMA_BASE_URL}/api/tags", timeout=4.0)
+        if resp.status_code == 200:
+            return resp.json().get("models", [])
+        return []
+    except Exception as e:
+        _log.warning("_fetch_models failed: %s", e)
+        return None
+
+
+def _check_ollama() -> tuple[bool, str]:
+    try:
+        import httpx
+
+        t0 = time.monotonic()
+        resp = httpx.get(f"{OLLAMA_BASE_URL}/", timeout=4.0)
+        ms = int((time.monotonic() - t0) * 1000)
+        if resp.status_code in (200, 404):
+            return True, f"Running — localhost:11434 ({ms}ms)"
+        return False, f"HTTP {resp.status_code}"
+    except Exception as e:
+        _log.debug("_check_ollama failed: %s", e)
+        return False, "Not running — start with: ollama serve"
+
+
+def _model_available(model_name: str) -> tuple[bool, str]:
+    models = _fetch_models()
+    if models is None:
+        return False, "Ollama not running"
+    stem = model_name.split(":")[0]
+    if any(m.get("name", "").split(":")[0] == stem for m in models):
+        return True, "Model is available locally"
+    return False, f"Not pulled — run: ollama pull {model_name}"
+
+
+def _ping_model(model_name: str) -> int | None:
+    """Send a minimal generation request to measure first-token latency."""
+    try:
+        import httpx
+
+        t0 = time.monotonic()
+        resp = httpx.post(
+            f"{OLLAMA_BASE_URL}/api/generate",
+            json={"model": model_name, "prompt": "hi", "stream": False, "max_tokens": 1},
+            timeout=15.0,
+        )
+        ms = int((time.monotonic() - t0) * 1000)
+        if resp.status_code == 200:
+            return ms
+        return None
+    except Exception as e:
+        _log.debug("_ping_model failed: %s", e)
+        return None
+
+
+def _fmt_size(size_bytes: int) -> str:
+    if size_bytes >= 1_073_741_824:
+        return f"{size_bytes / 1_073_741_824:.1f} GB"
+    if size_bytes >= 1_048_576:
+        return f"{size_bytes / 1_048_576:.0f} MB"
+    return f"{size_bytes} B"

patchi/cli/commands/notify_cmd.py

@@ -0,0 +1,213 @@
+"""
+`p notify` — manage notification channels.
+list | add <type> | remove <name> | test [name] | ack <id> | flush | pending
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+
+import patchi.core.config as config
+from patchi.cli.commands.notify_prompts import CHANNEL_SETUP_FIELDS, SEVERITY_CHOICES
+from patchi.core.notifications.channels import ChannelType, from_config
+from patchi.core.notifications.notifier import Notifier
+
+console = Console()
+
+
+def run_notify(args) -> None:
+    sub = getattr(args, "notify_cmd", None)
+
+    if sub == "list" or sub is None:
+        _cmd_list(args)
+    elif sub == "add":
+        _cmd_add(args)
+    elif sub == "remove":
+        _cmd_remove(args)
+    elif sub == "test":
+        _cmd_test(args)
+    elif sub == "ack":
+        _cmd_ack(args)
+    elif sub == "flush":
+        _cmd_flush(args)
+    elif sub == "pending":
+        _cmd_pending(args)
+
+
+def _cmd_list(args) -> None:
+    root = _require_root()
+    cfg = config.load(root)
+    channels = cfg.get("notifications", [])
+
+    if not channels:
+        console.print("[dim]No notification channels configured.[/dim]")
+        console.print("Add one with: [bold]p notify add slack[/bold]")
+        return
+
+    table = Table(show_header=True, header_style="bold", box=None, pad_edge=False)
+    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("Type", style="white")
+    table.add_column("Min Severity", style="yellow")
+    table.add_column("Digest", style="dim")
+
+    for ch in channels:
+        table.add_row(
+            ch.get("name", "—"),
+            ch.get("type", "—"),
+            ch.get("min_severity", "medium"),
+            "yes" if ch.get("in_digest") else "no",
+        )
+
+    console.print(table)
+    quiet = cfg.get("quiet_hours", {})
+    if quiet.get("enabled"):
+        console.print(
+            f"\n[dim]Quiet hours: {quiet['start']} → {quiet['end']} ({quiet.get('timezone', 'UTC')})[/dim]"
+        )
+    console.print(f"[dim]Digest frequency: {cfg.get('digest_frequency', 'daily')}[/dim]")
+
+
+def _prompt_credentials(channel_type: str) -> dict[str, str]:
+    """Prompt for channel-specific credentials. Returns a dict of field→value."""
+    credentials: dict[str, str] = {}
+    for field_key, prompt in CHANNEL_SETUP_FIELDS.get(channel_type, []):
+        value = console.input(f"[cyan]{prompt}: [/cyan]").strip()
+        if value:
+            credentials[field_key] = value
+    return credentials
+
+
+def _cmd_add(args) -> None:
+    root = _require_root()
+    channel_type = getattr(args, "channel_type", None)
+
+    valid_types = [t.value for t in ChannelType]
+    if not channel_type or channel_type not in valid_types:
+        console.print(f"[red]Specify a channel type:[/red] {', '.join(valid_types)}")
+        return
+
+    console.print(f"\n[bold]Adding {channel_type} channel[/bold]")
+    name = console.input("[cyan]Channel name (e.g. my-slack): [/cyan]").strip()
+    if not name:
+        console.print("[red]Name cannot be empty.[/red]")
+        return
+
+    credentials: dict[str, str] = _prompt_credentials(channel_type)
+
+    min_severity = (
+        console.input(
+            f"[cyan]Minimum severity [{'/'.join(SEVERITY_CHOICES)}] (default: medium): [/cyan]"
+        ).strip()
+        or "medium"
+    )
+    if min_severity not in SEVERITY_CHOICES:
+        min_severity = "medium"
+
+    in_digest_raw = (
+        console.input("[cyan]Batch into digest? (y/n, default: n): [/cyan]").strip().lower()
+    )
+    in_digest = in_digest_raw == "y"
+
+    raw = {
+        "name": name,
+        "type": channel_type,
+        "min_severity": min_severity,
+        "in_digest": in_digest,
+        **credentials,
+    }
+
+    # Validate before saving
+    try:
+        from_config(raw)
+    except ValueError as exc:
+        console.print(f"[red]Invalid config:[/red] {exc}")
+        return
+
+    cfg = config.load(root)
+    cfg.setdefault("notifications", [])
+
+    if any(ch["name"] == name for ch in cfg["notifications"]):
+        console.print(f"[red]A channel named '{name}' already exists.[/red]")
+        return
+
+    cfg["notifications"].append(raw)
+    config.save(cfg, root)
+    console.print(f"[green]✓ Channel '{name}' added.[/green]")
+    console.print("Run [bold]p notify test[/bold] to verify it works.")
+
+
+def _cmd_remove(args) -> None:
+    root = _require_root()
+    name = getattr(args, "channel_name", None)
+    if not name:
+        console.print("[red]Specify a channel name to remove.[/red]")
+        return
+
+    cfg = config.load(root)
+    before = len(cfg.get("notifications", []))
+    cfg["notifications"] = [ch for ch in cfg.get("notifications", []) if ch.get("name") != name]
+
+    if len(cfg["notifications"]) == before:
+        console.print(f"[red]No channel named '{name}' found.[/red]")
+        return
+
+    config.save(cfg, root)
+    console.print(f"[green]✓ Channel '{name}' removed.[/green]")
+
+
+def _cmd_test(args) -> None:
+    root = _require_root()
+    target = getattr(args, "channel_name", None)
+    if not config.load(root).get("notifications"):
+        console.print("[dim]No channels configured. Add one with p notify add.[/dim]")
+        return
+    for ch_name, ok in _notifier(root).test(target):
+        console.print(f"  {ch_name}: {'[green]✓ sent[/green]' if ok else '[red]✗ failed[/red]'}")
+
+
+def _cmd_ack(args) -> None:
+    aid = getattr(args, "alert_id", None)
+    if not aid:
+        console.print("[red]Provide an alert ID to acknowledge.[/red]")
+        return
+    ok = _notifier(_require_root()).acknowledge(aid)
+    msg = (
+        f"[green]✓ Alert {aid} acknowledged.[/green]"
+        if ok
+        else f"[red]Alert ID '{aid}' not found.[/red]"
+    )
+    console.print(msg)
+
+
+def _cmd_flush(args) -> None:
+    sent = _notifier(_require_root()).flush_digest()
+    console.print(
+        f"[green]✓ Digest flushed to {sent} channel(s).[/green]"
+        if sent
+        else "[dim]Nothing to flush.[/dim]"
+    )
+
+
+def _cmd_pending(args) -> None:
+    pending = _notifier(_require_root()).pending_escalations()
+    if not pending:
+        console.print("[dim]No pending escalations.[/dim]")
+        return
+    for alert in pending:
+        console.print(f"  [red]{alert['id']}[/red]  {alert['severity'].upper()}  {alert['title']}")
+    console.print("\nAck with: [bold]p notify ack <id>[/bold]")
+
+
+def _notifier(root: Path) -> Notifier:
+    return Notifier(root, config.load(root))
+
+
+def _require_root() -> Path:
+    try:
+        return config.require_project_root()
+    except RuntimeError as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise SystemExit(1) from exc

patchi/cli/commands/notify_prompts.py

@@ -0,0 +1,29 @@
+"""
+Prompt field definitions for `p notify add` interactive setup.
+Kept separate so notify_cmd.py stays under 200 lines.
+"""
+
+CHANNEL_SETUP_FIELDS: dict[str, list[tuple[str, str]]] = {
+    "email": [
+        ("user", "SMTP username (your email address)"),
+        ("password", "SMTP password or app password"),
+        ("host", "SMTP host (e.g. smtp.gmail.com)"),
+        ("port", "SMTP port [leave blank for default]"),
+        ("to", "Recipient address [blank = same as username]"),
+    ],
+    "slack": [
+        ("webhook_url", "Slack incoming webhook URL"),
+    ],
+    "discord": [
+        ("webhook_url", "Discord webhook URL"),
+    ],
+    "webhook": [
+        ("url", "Webhook URL (https://...)"),
+    ],
+    "telegram": [
+        ("bot_token", "Telegram bot token"),
+        ("chat_id", "Chat ID (your chat or channel ID)"),
+    ],
+}
+
+SEVERITY_CHOICES: list[str] = ["critical", "high", "medium", "low", "info"]

patchi/cli/commands/patch_cmd.py

@@ -0,0 +1,231 @@
+"""
+`p patch` — Manage individual patches by ID.
+
+Subcommands:
+  p patch list          — list all patches (all states)
+  p patch show <id>     — show full diff + metadata for one patch
+  p patch apply <id>    — apply a pending patch
+  p patch reject <id>   — reject a pending patch
+"""
+
+from __future__ import annotations
+
+from datetime import UTC
+from pathlib import Path
+
+from rich.syntax import Syntax
+from rich.table import Table
+from rich.text import Text
+
+from patchi.cli.console import con
+from patchi.core import memory as mem
+from patchi.core.config import require_project_root
+from patchi.core.fix.patch import Patch, PatchState
+
+_STATE_COLORS = {
+    "proposed": "#B8A898",
+    "pending": "#FACC15",
+    "auto_applied": "#4ADE80",
+    "applying": "#C8621A",
+    "applied": "#4ADE80",
+    "failed": "#FF4D6D",
+    "rolled_back": "#FF8C42",
+    "rejected": "dim",
+    "undone": "dim",
+}
+
+
+def run_list(root: Path | None = None, json_output: bool = False) -> None:
+    """p patch list"""
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    patches_raw = mem.list_patches(r)
+    if json_output:
+        import json as _json
+
+        con.print(_json.dumps({"patches": patches_raw or []}, indent=2, default=str))
+        return
+
+    if not patches_raw:
+        con.print("[dim]No patches yet. Run [bold]p fix[/bold] to generate some.[/dim]")
+        return
+
+    con.print()
+    table = Table(show_header=True, header_style="bold #C8621A", box=None, pad_edge=False)
+    table.add_column("ID", style="bold #F2EDD6", width=10)
+    table.add_column("State", width=12)
+    table.add_column("Agent", style="dim", width=18)
+    table.add_column("Risk", width=8)
+    table.add_column("Files", justify="right", width=6)
+    table.add_column("Description", width=44)
+
+    risk_colors = {"low": "#4ADE80", "medium": "#FACC15", "high": "#FF4D6D"}
+
+    for p in reversed(patches_raw):  # newest first
+        risk_score = p.get("risk_score", 0)
+        risk_level = p.get("risk_level", "low")
+        state = p.get("state", "proposed")
+        table.add_row(
+            p.get("id", "?"),
+            Text(state, style=_STATE_COLORS.get(state, "white")),
+            p.get("agent", "?"),
+            Text(f"{risk_score}", style=risk_colors.get(risk_level, "white")),
+            str(p.get("file_count", 0)),
+            p.get("description", "?")[:44],
+        )
+
+    con.print(table)
+    con.print()
+    con.print("[dim]p patch show <id>  ·  p patch apply <id>  ·  p patch reject <id>[/dim]")
+    con.print()
+
+
+def run_show(patch_id: str, root: Path | None = None, json_output: bool = False) -> None:
+    """p patch show <id>"""
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    patch_dict = mem.get_patch(patch_id, r)
+    if not patch_dict:
+        if json_output:
+            import json as _json
+
+            con.print(_json.dumps({"error": f"Patch {patch_id!r} not found"}, indent=2))
+        else:
+            con.print(f"[red]Patch {patch_id!r} not found.[/red]")
+        return
+
+    if json_output:
+        import json as _json
+
+        con.print(_json.dumps(patch_dict, indent=2, default=str))
+        return
+
+    patch = Patch.from_dict(patch_dict)
+    state = patch.state.value
+    state_color = _STATE_COLORS.get(state, "white")
+    risk_colors = {"low": "#4ADE80", "medium": "#FACC15", "high": "#FF4D6D"}
+    risk_color = risk_colors.get(patch.risk_level, "white")
+
+    con.print()
+    con.print(
+        f"[bold #F2EDD6]Patch {patch.id}[/bold #F2EDD6]  [{state_color}]{state}[/{state_color}]"
+    )
+    con.print(
+        f"[dim]Agent: {patch.agent}  ·  Type: {patch.patch_type.value}  ·  "
+        f"Proposed: {patch.proposed_at[:19]}[/dim]"
+    )
+    con.print()
+    con.print(f"  {patch.description}")
+    if patch.ai_explanation:
+        con.print(f"  [dim italic]{patch.ai_explanation[:120]}[/dim italic]")
+    con.print()
+    con.print(
+        f"  [bold {risk_color}]Risk: {patch.risk_score}/100 ({patch.risk_level})[/bold {risk_color}]"
+        f"   [dim]Confidence: {patch.confidence}%"
+        f"   Blast radius: {patch.blast_radius}[/dim]"
+    )
+    con.print()
+
+    for change in patch.changes:
+        if not change.diff.strip():
+            continue
+        con.print(
+            f"[bold #B8A898]{change.path}[/bold #B8A898]  "
+            f"[dim]+{change.lines_added} -{change.lines_removed}[/dim]"
+        )
+        con.print(Syntax(change.diff, "diff", theme="monokai", padding=1))
+
+    if patch.test_result:
+        passed = patch.test_result.get("passed")
+        if passed is True:
+            con.print("[#4ADE80]Tests passed.[/#4ADE80]")
+        elif passed is False:
+            con.print("[red]Tests failed — patch rolled back.[/red]")
+            out = patch.test_result.get("output", "")
+            if out:
+                con.print(f"[dim]{out[:500]}[/dim]")
+
+    con.print()
+
+
+def run_apply(patch_id: str, root: Path | None = None) -> None:
+    """p patch apply <id>"""
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    patch_dict = mem.get_patch(patch_id, r)
+    if not patch_dict:
+        con.print(f"[red]Patch {patch_id!r} not found.[/red]")
+        return
+
+    if patch_dict.get("state") not in ("pending", "proposed"):
+        con.print(f"[yellow]Patch {patch_id} is already {patch_dict['state']}.[/yellow]")
+        return
+
+    from patchi.core.fix.applier import PatchApplier
+    from patchi.core.fix.risk_gate import RiskGate
+
+    patch = Patch.from_dict(patch_dict)
+    gate = RiskGate(r)
+    gate_result = gate.evaluate(patch)
+
+    if gate_result.is_blocked:
+        con.print(f"[red]Blocked:[/red] {gate_result.blocks[0]}")
+        return
+
+    con.print(f"Applying patch [bold]{patch_id}[/bold]…")
+    result = PatchApplier(r).apply(patch)
+
+    if result.success:
+        con.print(
+            f"[#4ADE80]✓ Applied.[/#4ADE80]  "
+            f"[dim]Tests: {'passed' if result.test_passed else 'skipped'}  "
+            f"Snapshot: {result.snapshot_id}[/dim]"
+        )
+    else:
+        con.print(f"[red]✗ Failed.[/red]  [dim]{result.error}[/dim]")
+        if result.rolled_back:
+            con.print("[dim]Rolled back to original state.[/dim]")
+
+
+def run_reject(patch_id: str, root: Path | None = None) -> None:
+    """p patch reject <id>"""
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    patch_dict = mem.get_patch(patch_id, r)
+    if not patch_dict:
+        con.print(f"[red]Patch {patch_id!r} not found.[/red]")
+        return
+
+    try:
+        import json
+        from datetime import datetime
+
+        from patchi.core.constants import MEMORY_FILES, MemoryCategory
+
+        patches = mem.list_patches(r)
+        for p in patches:
+            if p.get("id") == patch_id:
+                p["state"] = PatchState.REJECTED.value
+                p["rejected_at"] = datetime.now(UTC).isoformat()
+                break
+        mem_path = r / MEMORY_FILES[MemoryCategory.PATCHES]
+        mem_path.write_text(json.dumps(patches, indent=2), encoding="utf-8")
+        con.print(f"[dim]Patch {patch_id} rejected.[/dim]")
+    except Exception as e:
+        con.print(f"[red]Error: {e}[/red]")