krnl-code 1.0.4__py3-none-any.whl

krnl_agent/doctor.py

@@ -0,0 +1,106 @@
+"""`krnl-agent doctor` — environment self-check.
+
+Checks the things that commonly break a setup (Python version, package version, a
+configured provider + reachable key, optional tools like git/ripgrep/gh, and the
+writable user-data dir) and prints a clear PASS/WARN/FAIL report with a fix hint
+for anything wrong. Read-only and safe to run anytime.
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+from pathlib import Path
+
+from . import __version__
+from .config import Config
+
+
+class Check:
+    def __init__(self, name: str, status: str, detail: str = "", hint: str = ""):
+        self.name = name
+        self.status = status  # "pass" | "warn" | "fail"
+        self.detail = detail
+        self.hint = hint
+
+
+def run_checks(config: Config | None = None, workspace: str = ".") -> list[Check]:
+    checks: list[Check] = []
+
+    # Python version
+    v = sys.version_info
+    if v >= (3, 9):
+        checks.append(Check("Python", "pass", f"{v.major}.{v.minor}.{v.micro}"))
+    else:
+        checks.append(Check("Python", "fail", f"{v.major}.{v.minor}",
+                            "Python 3.9+ is required."))
+
+    checks.append(Check("krnl-coding-agent", "pass", f"v{__version__}"))
+
+    # Provider + key
+    if config is not None:
+        p = config.provider
+        checks.append(Check("Active provider", "pass", f"{p.name} ({p.model})"))
+        needs_key = bool(p.api_key_env)  # local providers (ollama/lmstudio) need none
+        if not needs_key:
+            checks.append(Check("API key", "pass", "not required (local provider)"))
+        elif p.api_key:
+            checks.append(Check("API key", "pass", f"set via {p.api_key_env}"))
+        else:
+            checks.append(Check("API key", "warn", f"{p.api_key_env} not set",
+                                f"export {p.api_key_env}=… or run `/key` in chat."))
+        if p.base_url:
+            checks.append(Check("Base URL", "pass", p.base_url))
+
+    # Optional external tools
+    for exe, why in [
+        ("git", "version control + git tools"),
+        ("rg", "fast search (ripgrep)"),
+        ("gh", "open pull requests"),
+        ("pip-audit", "Python dependency audit"),
+    ]:
+        if shutil.which(exe):
+            checks.append(Check(f"tool: {exe}", "pass", "found"))
+        else:
+            checks.append(Check(f"tool: {exe}", "warn", "not found",
+                                f"optional — install for {why}."))
+
+    # Writable user-data dir
+    data_dir = Path(os.path.expanduser("~")) / ".krnl-agent"
+    try:
+        data_dir.mkdir(parents=True, exist_ok=True)
+        probe = data_dir / ".doctor_probe"
+        probe.write_text("ok", encoding="utf-8")
+        probe.unlink()
+        checks.append(Check("User data dir", "pass", str(data_dir)))
+    except Exception as e:  # noqa: BLE001
+        checks.append(Check("User data dir", "fail", str(e),
+                            "Check permissions on your home directory."))
+
+    # Workspace writability
+    ws = Path(workspace)
+    checks.append(Check("Workspace", "pass" if os.access(ws, os.W_OK) else "warn",
+                        str(ws.resolve()),
+                        "" if os.access(ws, os.W_OK) else "workspace is not writable."))
+    return checks
+
+
+def format_report(checks: list[Check]) -> str:
+    icon = {"pass": "✔", "warn": "⚠", "fail": "✗"}
+    lines = ["Krnl Agent — environment check", ""]
+    for c in checks:
+        mark = icon.get(c.status, "?")
+        line = f"  {mark} {c.name}: {c.detail}".rstrip()
+        lines.append(line)
+        if c.hint and c.status != "pass":
+            lines.append(f"      ↳ {c.hint}")
+    fails = sum(1 for c in checks if c.status == "fail")
+    warns = sum(1 for c in checks if c.status == "warn")
+    lines.append("")
+    if fails:
+        lines.append(f"Result: {fails} failure(s), {warns} warning(s) — fix failures above.")
+    elif warns:
+        lines.append(f"Result: all critical checks passed, {warns} optional warning(s).")
+    else:
+        lines.append("Result: all checks passed. You're good to go.")
+    return "\n".join(lines)

krnl_agent/events.py

@@ -0,0 +1,141 @@
+"""Event protocol and the AgentIO interface.
+
+The agent loop is transport-agnostic: it talks to the outside world only
+through an `AgentIO` implementation. The CLI implements it with the terminal;
+the FastAPI server implements it over a WebSocket. Both speak the same set of
+event dicts so the VS Code webview and the CLI render identical information.
+"""
+from __future__ import annotations
+
+import abc
+from dataclasses import dataclass
+from typing import Optional
+
+
+# --------------------------------------------------------------------------- #
+# Event constructors (plain dicts so they serialize straight to JSON)
+# --------------------------------------------------------------------------- #
+def status(message: str) -> dict:
+    return {"type": "status", "message": message}
+
+
+def token(text: str) -> dict:
+    """A streamed chunk of assistant text."""
+    return {"type": "token", "text": text}
+
+
+def assistant_message(text: str) -> dict:
+    """A complete assistant message (sent once a turn finishes)."""
+    return {"type": "assistant_message", "text": text}
+
+
+def tool_start(call_id: str, name: str, args: dict) -> dict:
+    return {"type": "tool_start", "id": call_id, "name": name, "args": args}
+
+
+def tool_result(call_id: str, name: str, ok: bool, output: str) -> dict:
+    return {"type": "tool_result", "id": call_id, "name": name, "ok": ok, "output": output}
+
+
+def diff(path: str, patch: str, is_new: bool = False) -> dict:
+    return {"type": "diff", "path": path, "patch": patch, "is_new": is_new}
+
+
+def approval_request(call_id: str, name: str, args: dict, preview: Optional[str]) -> dict:
+    return {
+        "type": "approval_request",
+        "id": call_id,
+        "name": name,
+        "args": args,
+        "preview": preview,
+    }
+
+
+def done(summary: str = "") -> dict:
+    return {"type": "done", "summary": summary}
+
+
+def error(message: str) -> dict:
+    return {"type": "error", "message": message}
+
+
+def command_output(call_id: str, text: str) -> dict:
+    """A streamed chunk of stdout/stderr from a running command."""
+    return {"type": "command_output", "id": call_id, "text": text}
+
+
+def usage(prompt: int, completion: int, total_session: int, cost: float = 0.0) -> dict:
+    return {
+        "type": "usage",
+        "prompt_tokens": prompt,
+        "completion_tokens": completion,
+        "session_tokens": total_session,
+        "session_cost": round(cost, 4),
+    }
+
+
+def cancelled() -> dict:
+    return {"type": "cancelled"}
+
+
+def info(message: str) -> dict:
+    """A neutral notice (compaction, checkpoint, undo, …)."""
+    return {"type": "info", "message": message}
+
+
+def thinking(text: str) -> dict:
+    """A streamed chunk of the model's reasoning."""
+    return {"type": "thinking", "text": text}
+
+
+def plan(text: str) -> dict:
+    """A proposed plan emitted in plan mode, awaiting approval."""
+    return {"type": "plan", "text": text}
+
+
+def todos(items: list) -> dict:
+    """The agent's current task checklist."""
+    return {"type": "todos", "items": items}
+
+
+def subagent_start(call_id: str, description: str) -> dict:
+    return {"type": "subagent_start", "id": call_id, "description": description}
+
+
+def subagent_end(call_id: str, summary: str) -> dict:
+    return {"type": "subagent_end", "id": call_id, "summary": summary}
+
+
+# --------------------------------------------------------------------------- #
+# Approval decision + IO interface
+# --------------------------------------------------------------------------- #
+@dataclass
+class ApprovalDecision:
+    approved: bool
+    feedback: Optional[str] = None  # optional user note fed back to the model
+    always: bool = False  # "always allow" — persist an allow rule for this tool
+
+
+class AgentIO(abc.ABC):
+    """How the agent loop emits output and requests human approval."""
+
+    @abc.abstractmethod
+    def emit_sync(self, event: dict) -> None:
+        """Emit an event from anywhere — including a worker thread. Used for
+        streamed `token` and `command_output`. Implementations must be
+        thread-safe / non-blocking."""
+
+    @abc.abstractmethod
+    async def emit(self, event: dict) -> None:
+        """Emit a structured event (always from the event loop)."""
+
+    @abc.abstractmethod
+    async def request_approval(self, request: dict) -> ApprovalDecision:
+        """Ask the human to approve a gated action and block until answered."""
+
+    # Back-compat convenience used by the LLM stream callback.
+    def on_token(self, text: str, is_thinking: bool = False) -> None:
+        if is_thinking:
+            self.emit_sync({"type": "thinking_token", "text": text})
+        else:
+            self.emit_sync(token(text))

krnl_agent/gitignore.py

@@ -0,0 +1,47 @@
+"""Best-effort .gitignore → ignore-glob conversion.
+
+This is intentionally lightweight (no `pathspec` dependency). It converts the
+common .gitignore patterns into the fnmatch-style globs that ``ToolContext``
+already understands. Negations (`!pattern`) are skipped — we only ever *add*
+ignores, never un-ignore, which is the safe direction for an agent.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def load_gitignore_patterns(root: Path) -> list[str]:
+    gi = root / ".gitignore"
+    if not gi.is_file():
+        return []
+    patterns: list[str] = []
+    try:
+        lines = gi.read_text(encoding="utf-8", errors="ignore").splitlines()
+    except Exception:
+        return []
+    for raw in lines:
+        line = raw.strip()
+        if not line or line.startswith("#") or line.startswith("!"):
+            continue
+        # strip a leading slash (anchored to root); we match on relative paths
+        line = line.lstrip("/")
+        # a trailing slash means "a directory"
+        is_dir = line.endswith("/")
+        line = line.rstrip("/")
+        if not line:
+            continue
+        patterns.append(line)
+        # match contents of a directory too
+        patterns.append(f"{line}/**")
+        if not is_dir and "/" not in line and "*" not in line:
+            # a bare name like "node_modules" should match at any depth
+            patterns.append(f"**/{line}")
+            patterns.append(f"**/{line}/**")
+    # de-dup, preserve order
+    seen: set[str] = set()
+    out: list[str] = []
+    for p in patterns:
+        if p not in seen:
+            seen.add(p)
+            out.append(p)
+    return out