krnl-code 1.0.4__py3-none-any.whl

krnl_agent/server.py

@@ -0,0 +1,302 @@
+"""FastAPI server: WebSocket (streaming + approvals) and a REST fallback.
+
+Cloud-ready: optional bearer-token auth (`--token` / $KRNL_AGENT_TOKEN), bind to
+any host, dynamic port, cancel/undo, auto-approve, and cross-restart persistence.
+
+WebSocket protocol (JSON both directions)
+-----------------------------------------
+Client -> server:
+  {"type":"init","workspace_path":"...","provider":"krnl"?,"model":"..."?,
+   "api_key":"..."?,"base_url":"..."?,"auto_approve":bool?,"persist":bool?,"token":"..."?}
+  {"type":"run","task":"..."}
+  {"type":"approval","id":"...","approved":bool,"feedback":"..."?}
+  {"type":"cancel"}            # stop the running task
+  {"type":"undo"}              # revert the last turn's file changes
+  {"type":"ping"}
+
+Server -> client: see krnl_agent.events.
+"""
+from __future__ import annotations
+
+import asyncio
+import os
+import secrets
+from typing import Optional
+
+from fastapi import FastAPI, Header, HTTPException, WebSocket, WebSocketDisconnect
+from pydantic import BaseModel
+
+from . import events as ev
+from .config import Config, load_config
+from .events import AgentIO, ApprovalDecision
+from .loop import AgentSession
+
+app = FastAPI(title="Krnl Agent", version="1.4.0")
+app.state.token = None  # set by serve(); None disables auth (local dev/tests)
+
+
+def _auth_ok(provided: Optional[str]) -> bool:
+    expected = app.state.token
+    return expected is None or (provided is not None and secrets.compare_digest(provided, expected))
+
+
+# --------------------------------------------------------------------------- #
+# WebSocket IO
+# --------------------------------------------------------------------------- #
+class WebSocketIO(AgentIO):
+    def __init__(self, ws: WebSocket, loop: asyncio.AbstractEventLoop):
+        self.ws = ws
+        self.loop = loop
+        self.pending: dict[str, asyncio.Future] = {}
+
+    def emit_sync(self, event: dict) -> None:
+        asyncio.run_coroutine_threadsafe(self._safe_send(event), self.loop)
+
+    async def _safe_send(self, event: dict) -> None:
+        try:
+            await self.ws.send_json(event)
+        except Exception:
+            pass
+
+    async def emit(self, event: dict) -> None:
+        await self._safe_send(event)
+
+    async def request_approval(self, request: dict) -> ApprovalDecision:
+        fut: asyncio.Future = self.loop.create_future()
+        self.pending[request["id"]] = fut
+        await self.ws.send_json(request)
+        return await fut
+
+    def resolve_approval(self, data: dict) -> None:
+        fut = self.pending.pop(data.get("id"), None)
+        if fut and not fut.done():
+            fut.set_result(
+                ApprovalDecision(
+                    bool(data.get("approved", False)),
+                    data.get("feedback"),
+                    always=bool(data.get("always", False)),
+                )
+            )
+
+
+def _config_for(data: dict) -> Config:
+    return load_config(
+        provider=data.get("provider"),
+        model=data.get("model"),
+        api_key=data.get("api_key"),
+        base_url=data.get("base_url"),
+    )
+
+
+@app.websocket("/ws")
+async def ws_endpoint(ws: WebSocket):
+    await ws.accept()
+    loop = asyncio.get_running_loop()
+    io = WebSocketIO(ws, loop)
+    session: Optional[AgentSession] = None
+    running: Optional[asyncio.Task] = None
+
+    try:
+        while True:
+            data = await ws.receive_json()
+            kind = data.get("type")
+
+            if kind == "init":
+                if not _auth_ok(data.get("token")):
+                    await ws.send_json(ev.error("Unauthorized: bad or missing token."))
+                    await ws.close()
+                    return
+                cfg = _config_for(data)
+                if data.get("auto_approve"):
+                    cfg.agent.auto_approve_writes = True
+                    cfg.agent.auto_approve_commands = True
+                effort = data.get("reasoning_effort")
+                if effort:
+                    cfg.agent.reasoning_effort = effort
+                    cfg.agent.thinking = effort == "high"
+                session = AgentSession(
+                    data["workspace_path"],
+                    cfg,
+                    io,
+                    persist=bool(data.get("persist")),
+                    plan_mode=bool(data.get("plan_mode")),
+                    session_id=data.get("session_id"),
+                    dangerous=bool(data.get("dangerous")),
+                )
+                await ws.send_json(
+                    ev.status(f"ready · {cfg.provider.name} · {cfg.provider.model}")
+                )
+                if cfg.agent.auto_onboard and not data.get("no_onboard"):
+                    from . import scaffold
+                    from .skills import load_skills
+
+                    if scaffold.needs_scaffold(data["workspace_path"]):
+                        created = scaffold.scaffold(data["workspace_path"])
+                        if created:
+                            session.skills = load_skills(data["workspace_path"])
+                            await ws.send_json(ev.info(
+                                f"Onboarded this project — created {len(created)} files "
+                                "under .krnl/ (memory, project doc, a skill)."))
+
+            elif kind == "onboard":
+                if session:
+                    from . import scaffold
+                    from .skills import load_skills
+
+                    created = scaffold.scaffold(session.workspace)
+                    session.skills = load_skills(session.workspace)
+                    await ws.send_json(ev.info(
+                        "Onboarded: " + (", ".join(created) if created else "already set up")))
+
+            elif kind == "run":
+                if session is None:
+                    await ws.send_json(ev.error("Send an 'init' message first."))
+                    continue
+                if running and not running.done():
+                    await ws.send_json(ev.error("A task is already running."))
+                    continue
+                running = asyncio.create_task(session.run(data["task"], data.get("images")))
+
+            elif kind == "approval":
+                io.resolve_approval(data)
+
+            elif kind == "cancel":
+                if session:
+                    session.cancel()
+
+            elif kind == "undo":
+                if session:
+                    reverted = session.undo()
+                    await ws.send_json(
+                        ev.info(
+                            f"reverted {len(reverted)} file(s): {', '.join(reverted)}"
+                            if reverted
+                            else "nothing to undo"
+                        )
+                    )
+
+            elif kind == "ping":
+                await ws.send_json({"type": "pong"})
+
+            else:
+                await ws.send_json(ev.error(f"Unknown message type: {kind}"))
+
+    except WebSocketDisconnect:
+        if running and not running.done():
+            if session:
+                session.cancel()
+            running.cancel()
+
+
+# --------------------------------------------------------------------------- #
+# REST fallback (one-shot, non-interactive)
+# --------------------------------------------------------------------------- #
+class BufferIO(AgentIO):
+    def __init__(self, auto_approve: bool):
+        self.events: list[dict] = []
+        self.auto_approve = auto_approve
+
+    def emit_sync(self, event: dict) -> None:
+        self.events.append(event)
+
+    async def emit(self, event: dict) -> None:
+        self.events.append(event)
+
+    async def request_approval(self, request: dict) -> ApprovalDecision:
+        self.events.append(request)
+        return ApprovalDecision(approved=self.auto_approve, feedback=None)
+
+
+class RunRequest(BaseModel):
+    task: str
+    workspace_path: str
+    provider: Optional[str] = None
+    model: Optional[str] = None
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+    auto_approve: bool = False
+
+
+@app.post("/agent/run")
+async def agent_run(req: RunRequest, authorization: Optional[str] = Header(default=None)):
+    token = authorization.replace("Bearer ", "") if authorization else None
+    if not _auth_ok(token):
+        raise HTTPException(status_code=401, detail="Unauthorized")
+    cfg = load_config(
+        provider=req.provider, model=req.model, api_key=req.api_key, base_url=req.base_url
+    )
+    if req.auto_approve:
+        cfg.agent.auto_approve_writes = True
+        cfg.agent.auto_approve_commands = True
+    io = BufferIO(auto_approve=req.auto_approve)
+    session = AgentSession(req.workspace_path, cfg, io)
+    await session.run(req.task)
+    final = next(
+        (e["text"] for e in reversed(io.events) if e["type"] == "assistant_message"), ""
+    )
+    return {
+        "status": "ok",
+        "provider": cfg.provider.name,
+        "model": cfg.provider.model,
+        "final": final,
+        "session_tokens": session.session_tokens,
+        "events": io.events,
+    }
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok"}
+
+
+@app.get("/providers")
+async def providers():
+    cfg = load_config()
+    return {
+        "active": cfg.provider.name,
+        "providers": {
+            name: {"type": p.type, "model": p.model, "base_url": p.base_url}
+            for name, p in cfg.all_providers.items()
+        },
+    }
+
+
+# --------------------------------------------------------------------------- #
+# Server entry
+# --------------------------------------------------------------------------- #
+def _free_port(host: str) -> int:
+    import socket
+
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.bind((host if host != "0.0.0.0" else "", 0))
+    port = s.getsockname()[1]
+    s.close()
+    return port
+
+
+def serve(
+    host: str = "127.0.0.1",
+    port: int = 8000,
+    reload: bool = False,
+    token: Optional[str] = None,
+    auth: bool = True,
+) -> None:
+    import uvicorn
+
+    if port == 0:
+        port = _free_port(host)
+
+    # Resolve the auth token: explicit > env > generated (unless auth disabled).
+    resolved = token or os.getenv("KRNL_AGENT_TOKEN")
+    if auth and not resolved:
+        resolved = secrets.token_urlsafe(24)
+    app.state.token = resolved if auth else None
+
+    # Announce port (and token) on stdout so a parent process can discover them.
+    print(f"KRNL_AGENT_LISTENING http://{host}:{port}", flush=True)
+    if app.state.token:
+        print(f"KRNL_AGENT_TOKEN {app.state.token}", flush=True)
+
+    uvicorn.run(
+        "krnl_agent.server:app" if reload else app, host=host, port=port, reload=reload
+    )

krnl_agent/sessions.py

@@ -0,0 +1,258 @@
+"""Named, resumable sessions with a dashboard + transcript search.
+
+Each session is a JSON file under ``~/.krnl-agent/sessions/<id>.json`` with
+metadata (workspace, created/updated timestamps, title) and the full message
+list. Supports listing (dashboard), resuming by id or "latest for this
+workspace", and full-text search across past conversations.
+
+Phase 3 additions:
+- Structured per-session memory with types: fact, decision, error, solution
+- Memory retrieval with staleness checking against the code knowledge graph
+- Per-session only (no cross-session persistence).
+"""
+from __future__ import annotations
+
+import json
+import time
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+
+from .settings import SETTINGS_DIR
+
+if TYPE_CHECKING:
+    from .graph import GraphManager
+
+SESSIONS_DIR = SETTINGS_DIR / "sessions"
+
+
+# --------------------------------------------------------------------------- #
+# Phase 3: Per-Session Memory
+# --------------------------------------------------------------------------- #
+@dataclass
+class MemoryEntry:
+    """A single memory entry in a session."""
+    type: str  # fact, decision, error, solution
+    content: str
+    created_at: float
+    related_files: list[str] = field(default_factory=list)
+    stale: bool = False
+
+
+@dataclass
+class SessionMemory:
+    """Per-session structured memory."""
+    entries: list[MemoryEntry] = field(default_factory=list)
+
+    def add(self, memory_type: str, content: str, related_files: Optional[list[str]] = None) -> None:
+        """Add a memory entry."""
+        if memory_type not in ("fact", "decision", "error", "solution"):
+            raise ValueError(f"Invalid memory type: {memory_type}")
+        entry = MemoryEntry(
+            type=memory_type,
+            content=content,
+            created_at=time.time(),
+            related_files=related_files or [],
+        )
+        self.entries.append(entry)
+
+    def retrieve(
+        self,
+        context_files: Optional[list[str]] = None,
+        graph_manager: Optional["GraphManager"] = None,
+        limit: int = 10,
+    ) -> list[MemoryEntry]:
+        """Retrieve memory entries, filtering by context and staleness.
+
+        Args:
+            context_files: Files currently in context (for relevance matching)
+            graph_manager: GraphManager for staleness checking
+            limit: Max number of entries to return
+
+        Returns:
+            List of non-stale, relevant memory entries ordered by recency.
+        """
+        # Filter stale entries using graph
+        if graph_manager:
+            self._check_staleness(graph_manager)
+
+        # Filter by context relevance
+        relevant = []
+        for entry in self.entries:
+            if entry.stale:
+                continue
+            if context_files and entry.related_files:
+                # Check if any related file is in current context
+                if not any(f in context_files for f in entry.related_files):
+                    continue
+            relevant.append(entry)
+
+        # Sort by recency and limit
+        relevant.sort(key=lambda e: e.created_at, reverse=True)
+        return relevant[:limit]
+
+    def _check_staleness(self, graph_manager: "GraphManager") -> None:
+        """Mark entries stale if their referenced files/functions changed.
+
+        Precedence rule: if a memory entry references a file/function that the
+        Phase 1 graph shows has since changed or been deleted, mark that memory
+        entry stale and exclude it from retrieval.
+        """
+        for entry in self.entries:
+            if not entry.related_files:
+                continue
+
+            # Check if any related file has changed or been deleted
+            for file_path in entry.related_files:
+                # Try both relative and absolute path
+                nodes = graph_manager.graph.get_nodes_by_file(file_path)
+                if not nodes:
+                    # Try resolving as relative to workspace
+                    from pathlib import Path
+                    abs_path = str(Path(graph_manager.workspace) / file_path)
+                    nodes = graph_manager.graph.get_nodes_by_file(abs_path)
+
+                if not nodes:
+                    # File deleted from graph
+                    entry.stale = True
+                    break
+
+                # Check if nodes still exist (they might have been invalidated)
+                # In a real implementation, we'd track node versions/timestamps
+                # For v1, we assume if the file exists in the graph, it's not stale
+                # This is a simplification per the spec's "explicitly deferred" scope
+
+
+
+def new_id() -> str:
+    return uuid.uuid4().hex[:12]
+
+
+def _file(session_id: str) -> Path:
+    return SESSIONS_DIR / f"{session_id}.json"
+
+
+def _title(messages: list[dict]) -> str:
+    for m in messages:
+        if m.get("role") == "user":
+            c = m.get("content")
+            text = c if isinstance(c, str) else (
+                next((b.get("text", "") for b in c if isinstance(b, dict) and b.get("type") == "text"), "")
+                if isinstance(c, list) else ""
+            )
+            text = text.strip().replace("\n", " ")
+            if text:
+                return text[:60]
+    return "(empty session)"
+
+
+def save(session_id: str, workspace: str, messages: list[dict], memory: Optional[SessionMemory] = None) -> None:
+    try:
+        SESSIONS_DIR.mkdir(parents=True, exist_ok=True)
+        f = _file(session_id)
+        created = time.time()
+        if f.exists():
+            try:
+                created = json.loads(f.read_text(encoding="utf-8")).get("created", created)
+            except Exception:
+                pass
+
+        # Serialize memory entries
+        memory_data = None
+        if memory:
+            memory_data = [
+                {
+                    "type": e.type,
+                    "content": e.content,
+                    "created_at": e.created_at,
+                    "related_files": e.related_files,
+                    "stale": e.stale,
+                }
+                for e in memory.entries
+            ]
+
+        f.write_text(json.dumps({
+            "id": session_id,
+            "workspace": str(Path(workspace).resolve()),
+            "created": created,
+            "updated": time.time(),
+            "title": _title(messages),
+            "messages": messages,
+            "memory": memory_data,
+        }), encoding="utf-8")
+    except Exception:
+        pass
+
+
+def load(session_id: str) -> tuple[list[dict], Optional[SessionMemory]]:
+    """Load messages and memory from a session."""
+    try:
+        data = json.loads(_file(session_id).read_text(encoding="utf-8"))
+        messages = data.get("messages", [])
+
+        # Deserialize memory entries
+        memory_data = data.get("memory")
+        memory = None
+        if memory_data:
+            memory = SessionMemory()
+            for entry_data in memory_data:
+                entry = MemoryEntry(
+                    type=entry_data["type"],
+                    content=entry_data["content"],
+                    created_at=entry_data["created_at"],
+                    related_files=entry_data.get("related_files", []),
+                    stale=entry_data.get("stale", False),
+                )
+                memory.entries.append(entry)
+
+        return messages, memory
+    except Exception:
+        return [], None
+
+
+def _meta(path: Path) -> dict | None:
+    try:
+        d = json.loads(path.read_text(encoding="utf-8"))
+        return {k: d.get(k) for k in ("id", "workspace", "created", "updated", "title")}
+    except Exception:
+        return None
+
+
+def list_sessions(workspace: str | None = None) -> list[dict]:
+    if not SESSIONS_DIR.is_dir():
+        return []
+    ws = str(Path(workspace).resolve()) if workspace else None
+    out = []
+    for p in SESSIONS_DIR.glob("*.json"):
+        m = _meta(p)
+        if m and (ws is None or m.get("workspace") == ws):
+            out.append(m)
+    return sorted(out, key=lambda m: m.get("updated") or 0, reverse=True)
+
+
+def latest_id(workspace: str) -> str | None:
+    rows = list_sessions(workspace)
+    return rows[0]["id"] if rows else None
+
+
+def search(query: str, workspace: str | None = None) -> list[dict]:
+    q = query.lower()
+    hits = []
+    for meta in list_sessions(workspace):
+        messages, _ = load(meta["id"])
+        for m in messages:
+            c = m.get("content")
+            if isinstance(c, str) and q in c.lower():
+                idx = c.lower().find(q)
+                hits.append({"id": meta["id"], "title": meta["title"],
+                             "snippet": c[max(0, idx - 30): idx + 50].replace("\n", " ")})
+                break
+    return hits
+
+
+def delete(session_id: str) -> None:
+    try:
+        _file(session_id).unlink()
+    except Exception:
+        pass

krnl_agent/settings.py

@@ -0,0 +1,59 @@
+"""Persistent user settings for the CLI (Claude-CLI-style).
+
+Stored at ``~/.krnl-agent/config.json`` so the CLI remembers your provider,
+model, and API keys between sessions. Keys live here in plaintext (user-only
+file permissions on POSIX); for shared machines prefer environment variables.
+
+Shape:
+    {
+      "provider": "openai",
+      "providers": {
+        "openai": {"api_key": "sk-...", "model": "gpt-4o-mini", "base_url": null}
+      }
+    }
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+SETTINGS_DIR = Path.home() / ".krnl-agent"
+SETTINGS_FILE = SETTINGS_DIR / "config.json"
+
+
+def load() -> dict:
+    try:
+        return json.loads(SETTINGS_FILE.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def save(data: dict) -> None:
+    SETTINGS_DIR.mkdir(parents=True, exist_ok=True)
+    SETTINGS_FILE.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    try:
+        os.chmod(SETTINGS_FILE, 0o600)  # best-effort; no-op on some platforms
+    except Exception:
+        pass
+
+
+def set_active_provider(name: str) -> None:
+    d = load()
+    d["provider"] = name
+    save(d)
+
+
+def set_provider_field(provider: str, field: str, value) -> None:
+    d = load()
+    provs = d.setdefault("providers", {})
+    p = provs.setdefault(provider, {})
+    if value in (None, ""):
+        p.pop(field, None)
+    else:
+        p[field] = value
+    save(d)
+
+
+def provider_overrides(provider: str) -> dict:
+    return (load().get("providers") or {}).get(provider, {})

krnl_agent/skills.py

@@ -0,0 +1,73 @@
+"""Skills — packaged, reusable capabilities loaded on demand (Claude-Code-style).
+
+A skill is a folder with a `SKILL.md` file:
+    .krnl/skills/<name>/SKILL.md      (project)
+    ~/.krnl-agent/skills/<name>/SKILL.md   (global)
+
+`SKILL.md` may start with YAML-ish frontmatter:
+    ---
+    description: One line shown to the model so it knows when to use this skill.
+    ---
+    <the full instructions / playbook>
+
+Progressive disclosure: only the name + description go into the system prompt; the
+model calls `use_skill(name)` to pull the full body when it actually needs it.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from .settings import SETTINGS_DIR
+
+
+def _dirs(workspace: str) -> list[Path]:
+    from . import plugins
+
+    return [SETTINGS_DIR / "skills", *plugins.plugin_skill_dirs(),
+            Path(workspace) / ".krnl" / "skills"]
+
+
+def _parse(text: str) -> tuple[str, str]:
+    """Return (description, body)."""
+    description = ""
+    body = text
+    if text.startswith("---"):
+        end = text.find("---", 3)
+        if end != -1:
+            front = text[3:end]
+            body = text[end + 3:].lstrip("\n")
+            for line in front.splitlines():
+                if line.lower().strip().startswith("description:"):
+                    description = line.split(":", 1)[1].strip()
+    if not description:
+        for line in body.splitlines():
+            s = line.strip().lstrip("#").strip()
+            if s:
+                description = s
+                break
+    return description, body
+
+
+def load_skills(workspace: str) -> dict[str, dict]:
+    skills: dict[str, dict] = {}
+    for d in _dirs(workspace):
+        if not d.is_dir():
+            continue
+        for sub in sorted(d.iterdir()):
+            skill_md = sub / "SKILL.md"
+            if skill_md.is_file():
+                try:
+                    desc, body = _parse(skill_md.read_text(encoding="utf-8"))
+                except Exception:
+                    continue
+                skills[sub.name] = {"description": desc, "body": body, "path": str(sub)}
+    return skills
+
+
+def skills_summary(skills: dict[str, dict]) -> str:
+    if not skills:
+        return ""
+    lines = ["You have these SKILLS available — call `use_skill(name)` to load one when relevant:"]
+    for name, s in skills.items():
+        lines.append(f"- {name}: {s['description']}")
+    return "\n".join(lines)