lcode-cli 0.18.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

lcode/__init__.py

@@ -3,7 +3,7 @@
 From a program: `from lcode import Session` (see lcode.api).
 """
 
-__version__ = "0.18.0"
+__version__ = "0.19.0"
 
 API = ("Session", "Result", "Options", "SetupError")
 

lcode/acp.py

@@ -0,0 +1,635 @@
+"""`lcode acp`: lcode as the agent inside an editor, over the Agent Client Protocol (ACP, version 1).
+
+The editor starts `lcode acp` and talks JSON-RPC 2.0 over its stdin and stdout, one message per
+line. The editor shows what happens:
+- the model's answers and thinking stream as message chunks;
+- each tool call is a tool call with its kind, files and, for edits, a diff;
+- permission requests and plan approvals use the editor's own dialog;
+- the todo list becomes the editor's plan;
+- lcode's permission modes are the session's modes.
+
+Files are read from and written through the editor's buffers when it supports that, so the model
+sees unsaved changes and the editor tracks the edits. Everything else (tools, checkpoints, MCP
+servers, memory) works as in the terminal.
+
+Nothing but protocol messages may reach stdout: lcode's own output is discarded (or written to
+the file in LCODE_ACP_LOG), and stdin is the protocol channel only.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import os
+import sys
+import threading
+from pathlib import Path
+from typing import IO, TYPE_CHECKING, Any
+from urllib.parse import unquote, urlparse
+
+from rich.console import Console
+
+from lcode import __version__
+
+if TYPE_CHECKING:
+    from lcode.agent import Agent
+
+PROTOCOL_VERSION = 1
+MODES = [
+    ("ask", "Ask", "Ask before changing files or running commands"),
+    ("auto-edit", "Auto-edit", "Change files without asking; ask before commands"),
+    ("plan", "Plan", "Look around and plan; change nothing until you approve the plan"),
+    ("yolo", "Yolo", "Never ask"),
+]
+KINDS = {
+    "read_file": "read", "view_image": "read", "list_dir": "search", "glob": "search", "grep": "search",
+    "repo_map": "search", "search_code": "search", "lsp": "search", "edit_file": "edit", "write_file": "edit",
+    "bash": "execute", "web_search": "fetch", "web_fetch": "fetch", "agent": "think", "todo_write": "think",
+    "present_plan": "switch_mode",
+}  # fmt: skip
+STOP = {"success": "end_turn", "max_steps": "max_turn_requests", "interrupted": "cancelled"}
+MAX_INLINE = 200_000  # bytes of a file the editor attaches that go into the prompt
+METHOD_NOT_FOUND, INVALID_PARAMS, INTERNAL_ERROR, NOT_FOUND = -32601, -32602, -32603, -32002
+
+
+class RpcError(Exception):
+    def __init__(self, code: int, message: str):
+        super().__init__(message)
+        self.code = code
+
+
+# ----------------------------------------------------------------------------- JSON-RPC over stdio
+
+
+class Connection:
+    """Newline-delimited JSON-RPC 2.0, both ways: the editor's requests and lcode's own."""
+
+    def __init__(self, inp: IO[bytes], out: IO[bytes]):
+        self.inp, self.out = inp, out
+        self.lock = threading.Lock()
+        self.pending: dict[int, tuple[threading.Event, dict]] = {}
+        self.next_id = 0
+        self.closed = False
+
+    def send(self, message: dict) -> None:
+        data = (json.dumps({"jsonrpc": "2.0", **message}, ensure_ascii=False) + "\n").encode()
+        with self.lock:
+            self.out.write(data)
+            self.out.flush()
+
+    def notify(self, method: str, params: dict) -> None:
+        self.send({"method": method, "params": params})
+
+    def request(self, method: str, params: dict) -> dict:
+        """Ask the editor and wait for its answer."""
+        with self.lock:
+            self.next_id += 1
+            request_id = self.next_id
+            done, slot = threading.Event(), {}
+            self.pending[request_id] = (done, slot)
+        self.send({"id": request_id, "method": method, "params": params})
+        done.wait()
+        if "error" in slot:
+            error = slot["error"] or {}
+            raise RpcError(int(error.get("code", INTERNAL_ERROR)), str(error.get("message", "the editor failed")))
+        return slot.get("result") or {}
+
+    def serve(self, handle) -> None:
+        """Read messages until the editor closes stdin; requests are handled in threads of their own."""
+        for raw in self.inp:
+            line = raw.strip()
+            if not line:
+                continue
+            try:
+                message = json.loads(line)
+            except ValueError:
+                self.send({"id": None, "error": {"code": -32700, "message": "parse error"}})
+                continue
+            if "method" in message:
+                threading.Thread(target=self._dispatch, args=(handle, message), daemon=True).start()
+            elif message.get("id") in self.pending:
+                done, slot = self.pending.pop(message["id"])
+                slot.update({k: message[k] for k in ("result", "error") if k in message})
+                done.set()
+        self.closed = True
+        for done, slot in list(self.pending.values()):  # nobody will answer now
+            slot["error"] = {"code": INTERNAL_ERROR, "message": "the editor closed the connection"}
+            done.set()
+
+    def _dispatch(self, handle, message: dict) -> None:
+        request_id = message.get("id")
+        try:
+            result = handle(message["method"], message.get("params") or {})
+            if request_id is not None:
+                self.send({"id": request_id, "result": result if result is not None else {}})
+        except RpcError as e:
+            if request_id is not None:
+                self.send({"id": request_id, "error": {"code": e.code, "message": str(e)}})
+        except Exception as e:  # never leave the editor waiting
+            if request_id is not None:
+                self.send({"id": request_id, "error": {"code": INTERNAL_ERROR, "message": f"{type(e).__name__}: {e}"}})
+
+
+# ----------------------------------------------------------------------------- one editor session
+
+
+def file_path(uri: str) -> Path | None:
+    parsed = urlparse(uri)
+    if parsed.scheme in ("", "file"):
+        return Path(unquote(parsed.path)) if parsed.path else None
+    return None
+
+
+def call_title(agent: Agent, name: str, args: dict) -> str:
+    path = args.get("path")
+    rel = agent.tools.rel(agent.tools.resolve(path)) if isinstance(path, str) and path else ""
+    titles = {
+        "read_file": f"Read {rel}",
+        "list_dir": f"List {rel or '.'}",
+        "glob": f"Find {args.get('pattern', '')}",
+        "grep": f"Search for {args.get('pattern', '')}",
+        "edit_file": f"Edit {rel}",
+        "write_file": f"Write {rel}",
+        "bash": str(args.get("command", "")).strip()[:200],
+        "web_search": f"Search the web for {args.get('query', '')}",
+        "web_fetch": f"Fetch {args.get('url', '')}",
+        "todo_write": "Update the plan",
+        "present_plan": f"Plan: {args.get('title', '')}",
+        "agent": f"Subagent: {args.get('description') or args.get('type', '')}",
+    }
+    return titles.get(name) or agent.describe_call(name, args)
+
+
+class Session:
+    """An lcode agent wired to the editor: its output becomes session/update notifications."""
+
+    def __init__(self, server: Server, agent: Agent):
+        self.server, self.agent, self.id = server, agent, agent.session_id
+        self.conn = server.conn
+        self.before: dict[str, str | None] = {}  # file contents before an edit, by tool call id
+        self.mode = agent.perms.mode
+        agent.cancel = threading.Event()
+        agent.on_delta = self.delta
+        agent.on_event = self.event
+        agent.on_tool = self.started
+        agent.perms.approve = self.permission
+        agent.plan_review = self.review_plan
+        caps = server.client_caps.get("fs") or {}
+        if caps.get("readTextFile"):
+            agent.tools.reader = self.read_buffer
+        if caps.get("writeTextFile"):
+            agent.tools.writer = self.write_buffer
+
+    def update(self, update: dict) -> None:
+        self.conn.notify("session/update", {"sessionId": self.id, "update": update})
+
+    # -- the model's output
+    def delta(self, kind: str, text: str) -> None:
+        chunk = "agent_message_chunk" if kind == "text" else "agent_thought_chunk"
+        self.update({"sessionUpdate": chunk, "content": {"type": "text", "text": text}})
+
+    def call(self, call_id: str, name: str, args: dict, status: str) -> dict:
+        update: dict[str, Any] = {
+            "toolCallId": call_id,
+            "title": call_title(self.agent, name, args),
+            "kind": KINDS.get(name, "other"),
+            "status": status,
+            "rawInput": args,
+        }
+        path = args.get("path")
+        if isinstance(path, str) and path:
+            location: dict[str, Any] = {"path": str(self.agent.tools.resolve(path))}
+            if isinstance(args.get("offset"), int):
+                location["line"] = args["offset"]
+            update["locations"] = [location]
+        diff = self.proposed_diff(call_id, name, args)
+        if diff:
+            update["content"] = [diff]
+        return update
+
+    def proposed_diff(self, call_id: str, name: str, args: dict) -> dict | None:
+        """What an edit will change, as the editor's diff: the whole file before and after."""
+        if name not in ("edit_file", "write_file") or not isinstance(args.get("path"), str):
+            return None
+        path = self.agent.tools.resolve(args["path"])
+        try:
+            old = self.agent.tools.read_text(path) if path.is_file() else None
+        except OSError:
+            old = None
+        if name == "write_file":
+            new = str(args.get("content", ""))
+        else:
+            find, replace = str(args.get("old_string", "")), str(args.get("new_string", ""))
+            if old is None or not find or find not in old:
+                return {"type": "diff", "path": str(path), "oldText": find, "newText": replace}
+            new = old.replace(find, replace) if args.get("replace_all") else old.replace(find, replace, 1)
+        self.before[call_id] = old
+        return {"type": "diff", "path": str(path), "oldText": old, "newText": new}
+
+    def event(self, event: dict) -> None:
+        if event["type"] == "assistant":
+            for call in event["tool_calls"]:
+                self.update(
+                    {"sessionUpdate": "tool_call", **self.call(call["id"], call["name"], call["arguments"], "pending")}
+                )
+        elif event["type"] == "tool_result":
+            update: dict[str, Any] = {
+                "sessionUpdate": "tool_call_update",
+                "toolCallId": event["id"],
+                "status": "failed" if event["error"] else "completed",
+                "rawOutput": {"output": event["output"]},
+            }
+            content = [{"type": "content", "content": {"type": "text", "text": event["output"]}}]
+            if event["name"] in ("edit_file", "write_file") and not event["error"]:
+                path = next((c for c in self.pending_paths(event["id"])), None)
+                if path is not None:
+                    try:
+                        after = path.read_text(errors="replace")
+                        content = [{"type": "diff", "path": str(path), "oldText": self.before.pop(event["id"], None),
+                                    "newText": after}]  # fmt: skip
+                    except OSError:
+                        pass
+            update["content"] = content
+            self.update(update)
+            if event["name"] == "todo_write":
+                self.send_plan()
+            if self.agent.perms.mode != self.mode:  # an approved plan switched the mode
+                self.mode = self.agent.perms.mode
+                self.update({"sessionUpdate": "current_mode_update", "currentModeId": self.mode})
+
+    def pending_paths(self, call_id: str):
+        for message in reversed(self.agent.messages):
+            for call in message.get("tool_calls") or []:
+                if call.get("id") == call_id:
+                    args = call.get("function", {}).get("arguments") or {}
+                    if isinstance(args, dict) and isinstance(args.get("path"), str):
+                        yield self.agent.tools.resolve(args["path"])
+                    return
+
+    def started(self, name: str, args: dict) -> None:
+        self.update(
+            {"sessionUpdate": "tool_call_update", "toolCallId": self.agent.current_call, "status": "in_progress"}
+        )
+
+    def send_plan(self) -> None:
+        entries = [
+            {"content": str(t.get("content", "")), "priority": "medium",
+             "status": t.get("status") if t.get("status") in ("pending", "in_progress", "completed") else "pending"}
+            for t in self.agent.tools.todos
+        ]  # fmt: skip
+        self.update({"sessionUpdate": "plan", "entries": entries})
+
+    # -- asking the user, in the editor
+    def ask(self, tool_call: dict, options: list[dict]) -> str | None:
+        """The option the user picked, or None if the request was cancelled."""
+        try:
+            reply = self.conn.request(
+                "session/request_permission", {"sessionId": self.id, "toolCall": tool_call, "options": options}
+            )
+        except RpcError:
+            return None
+        outcome = reply.get("outcome") or {}
+        return outcome.get("optionId") if outcome.get("outcome") == "selected" else None
+
+    def permission(self, request: dict) -> bool | str:
+        call_id = self.agent.current_call
+        name = next(
+            (c.get("function", {}).get("name", "") for m in reversed(self.agent.messages)
+             for c in m.get("tool_calls") or [] if c.get("id") == call_id), "",
+        )  # fmt: skip
+        args = next(
+            (c.get("function", {}).get("arguments") or {} for m in reversed(self.agent.messages)
+             for c in m.get("tool_calls") or [] if c.get("id") == call_id), {},
+        )  # fmt: skip
+        tool_call = self.call(call_id, name, args if isinstance(args, dict) else {}, "pending") if name else {
+            "toolCallId": call_id or "permission", "title": request["title"], "kind": "other", "status": "pending"
+        }  # fmt: skip
+        tool_call["title"] = request["title"]
+        scope = "file edits" if request["kind"] == "edit" else request["key"].split(":", 1)[-1]
+        choice = self.ask(
+            tool_call,
+            [
+                {"optionId": "allow", "name": "Allow", "kind": "allow_once"},
+                {"optionId": "always", "name": f"Always allow {scope} in this session", "kind": "allow_always"},
+                {"optionId": "reject", "name": "Reject", "kind": "reject_once"},
+            ],
+        )
+        if choice == "always":
+            self.agent.perms.always.add("edit" if request["kind"] == "edit" else request["key"])
+        if choice in ("allow", "always"):
+            return True
+        if choice is None and self.agent.cancel is not None and self.agent.cancel.is_set():
+            return "The user denied this: they cancelled the request."
+        return "The user denied this in the editor. Ask how to proceed, or choose a different approach."
+
+    def review_plan(self, title: str, plan: str) -> str:
+        tool_call = {
+            "toolCallId": self.agent.current_call or "plan",
+            "title": f"Plan: {title}",
+            "kind": "switch_mode",
+            "status": "pending",
+            "content": [{"type": "content", "content": {"type": "text", "text": plan}}],
+        }
+        choice = self.ask(
+            tool_call,
+            [
+                {"optionId": "ask", "name": "Approve, and ask before changes", "kind": "allow_once"},
+                {"optionId": "auto-edit", "name": "Approve, and change files without asking", "kind": "allow_always"},
+                {"optionId": "keep", "name": "Keep planning", "kind": "reject_once"},
+            ],
+        )
+        if choice in ("ask", "auto-edit"):
+            return choice
+        return "The user wants to keep planning. Ask what they'd like to change in the plan; don't change anything yet."
+
+    # -- the editor's buffers
+    def read_buffer(self, path: Path) -> str | None:
+        try:
+            return self.conn.request("fs/read_text_file", {"sessionId": self.id, "path": str(path)}).get("content")
+        except RpcError:
+            return None  # not open in the editor, or not readable there: lcode reads the file itself
+
+    def write_buffer(self, path: Path, content: str) -> None:
+        try:
+            self.conn.request("fs/write_text_file", {"sessionId": self.id, "path": str(path), "content": content})
+        except RpcError:
+            pass  # lcode writes the file itself
+
+    # -- requests
+    def prompt(self, blocks: list[dict]) -> dict:
+        from lcode import api
+
+        text = self.render(blocks)
+        if not text.strip():
+            return {"stopReason": "end_turn"}
+        command = self.command(text)
+        if command == "":
+            return {"stopReason": "end_turn"}
+        if command is not None:
+            text = command
+        self.agent.cancel.clear()
+        result = api.run_request(self.agent, text)
+        self.update({"sessionUpdate": "usage_update", "used": self.agent.ctx_used, "size": self.agent.settings.context})
+        self.update({"sessionUpdate": "session_info_update", "title": self.agent.session_title or None})
+        if result.status == "error":
+            raise RpcError(INTERNAL_ERROR, result.error)
+        return {"stopReason": STOP.get(result.status, "end_turn")}
+
+    def command(self, text: str) -> str | None:
+        """A /command from the editor: the user's own commands, and /review."""
+        if not text.startswith("/"):
+            return None
+        name, _, arg = text[1:].partition(" ")
+        commands = self.agent.extensions().commands
+        if name in commands:
+            return commands[name].render(arg.strip())
+        if name == "review":
+            from lcode import gitflow
+
+            try:
+                prompt = gitflow.review_prompt(self.agent, arg.strip())
+            except gitflow.GitError as e:
+                self.delta("text", f"Nothing to review: {e}")
+                return ""
+            self.agent.no_changes = "This is a review, so nothing can be changed: report what should change instead."
+            return prompt
+        return None
+
+    def render(self, blocks: list[dict]) -> str:
+        """The editor's prompt (text, attached files, images) as one request for lcode."""
+        parts = []
+        for block in blocks:
+            kind = block.get("type")
+            if kind == "text":
+                parts.append(str(block.get("text", "")))
+            elif kind == "resource_link":
+                parts.append(self.attached(block.get("uri", ""), None))
+            elif kind == "resource":
+                resource = block.get("resource") or {}
+                parts.append(self.attached(resource.get("uri", ""), resource.get("text")))
+            elif kind == "image" and block.get("data"):
+                parts.append(self.image(block["data"], block.get("mimeType", "image/png")))
+        return "\n\n".join(p for p in parts if p)
+
+    def attached(self, uri: str, text: str | None) -> str:
+        path = file_path(uri)
+        where = self.agent.tools.rel(path) if path else uri
+        if text is None and path is not None and path.is_file() and path.stat().st_size <= MAX_INLINE:
+            text = self.agent.tools.read_text(path)
+        if text is None:
+            return f"[The user points at {where}]"
+        return f"[The user attached {where}]\n```\n{text[:MAX_INLINE].rstrip(chr(10))}\n```"
+
+    def image(self, data: str, mime: str) -> str:
+        from lcode import config
+
+        raw = base64.b64decode(data)
+        folder = config.STATE_DIR / "acp-images"
+        folder.mkdir(parents=True, exist_ok=True)
+        path = folder / f"{hashlib.sha256(raw).hexdigest()[:16]}.{mime.split('/')[-1].split('+')[0] or 'png'}"
+        path.write_bytes(raw)
+        return f"@{path}"
+
+    def replay(self) -> None:
+        """A loaded session's conversation, sent to the editor as it happened."""
+        results: dict[str, str] = {}
+        names: dict[str, str] = {}
+        for message in self.agent.messages[1:]:
+            role, content = message.get("role"), message.get("content") or ""
+            if role == "user" and content:
+                self.update({"sessionUpdate": "user_message_chunk", "content": {"type": "text", "text": content}})
+            elif role == "assistant":
+                if content:
+                    self.update({"sessionUpdate": "agent_message_chunk", "content": {"type": "text", "text": content}})
+                for i, call in enumerate(message.get("tool_calls") or []):
+                    call.setdefault("id", f"call_loaded_{len(names)}_{i}")
+                    fn = call.get("function", {})
+                    args = fn.get("arguments") if isinstance(fn.get("arguments"), dict) else {}
+                    names[call["id"]] = fn.get("name", "")
+                    update = {"sessionUpdate": "tool_call", "toolCallId": call["id"],
+                              "title": call_title(self.agent, fn.get("name", ""), args),
+                              "kind": KINDS.get(fn.get("name", ""), "other"), "status": "completed", "rawInput": args}  # fmt: skip
+                    self.update(update)
+            elif role == "tool":
+                call_id = message.get("tool_call_id") or next((i for i in reversed(names) if i not in results), "")
+                if call_id:
+                    results[call_id] = content
+                    self.update({"sessionUpdate": "tool_call_update", "toolCallId": call_id, "status": "completed",
+                                 "content": [{"type": "content", "content": {"type": "text", "text": content[:4000]}}]})  # fmt: skip
+
+
+# ----------------------------------------------------------------------------- the agent side
+
+
+class Server:
+    def __init__(self, conn: Connection, console: Console):
+        self.conn, self.console = conn, console
+        self.client_caps: dict = {}
+        self.sessions: dict[str, Session] = {}
+
+    def handle(self, method: str, params: dict) -> dict | None:
+        handlers = {
+            "initialize": self.initialize,
+            "authenticate": lambda p: {},
+            "session/new": self.new_session,
+            "session/load": self.load_session,
+            "session/prompt": self.prompt,
+            "session/cancel": self.cancel,
+            "session/set_mode": self.set_mode,
+        }
+        if method not in handlers:
+            raise RpcError(METHOD_NOT_FOUND, f"lcode doesn't support {method}")
+        return handlers[method](params)
+
+    def initialize(self, params: dict) -> dict:
+        self.client_caps = params.get("clientCapabilities") or {}
+        return {
+            "protocolVersion": PROTOCOL_VERSION,
+            "agentCapabilities": {
+                "loadSession": True,
+                "promptCapabilities": {"image": True, "audio": False, "embeddedContext": True},
+                "mcpCapabilities": {"http": True, "sse": False},
+            },
+            "agentInfo": {"name": "lcode", "title": "lcode", "version": __version__},
+            "authMethods": [],
+        }
+
+    def open(self, params: dict) -> Session:
+        from lcode import api
+
+        cwd = Path(str(params.get("cwd") or ""))
+        if not cwd.is_absolute():
+            raise RpcError(INVALID_PARAMS, "cwd must be an absolute path")
+        try:
+            agent = api.open_agent(cwd, api.Options(interactive=False), self.console)
+        except api.SetupError as e:
+            raise RpcError(INTERNAL_ERROR, str(e)) from e
+        agent.mcp = self.mcp(cwd, params.get("mcpServers") or [], agent)
+        session = Session(self, agent)
+        self.sessions[session.id] = session
+        return session
+
+    def mcp(self, cwd: Path, editor_servers: list[dict], agent: Agent):
+        """lcode's MCP servers, plus the ones the editor passes."""
+        from lcode import config
+        from lcode.mcp import config as mcp_config
+        from lcode.mcp.manager import McpManager
+
+        project = mcp_config.project_file(cwd)
+        servers, problems = mcp_config.load_all(cwd, include_project=bool(project and mcp_config.is_approved(project)))
+        names = {s.name for s in servers}
+        for entry in editor_servers:
+            name = str(entry.get("name") or "editor")
+            if name in names:
+                continue
+            if entry.get("url"):
+                raw = {
+                    "type": "http",
+                    "url": entry["url"],
+                    "headers": {h["name"]: h["value"] for h in entry.get("headers") or []},
+                }
+            else:
+                raw = {"command": entry.get("command", ""), "args": entry.get("args") or [],
+                       "env": {e["name"]: e["value"] for e in entry.get("env") or []}}  # fmt: skip
+            server = mcp_config.parse(name, raw, source="editor")
+            if server.error:
+                problems.append(f"{name}: {server.error}")
+            else:
+                servers.append(server)
+        for problem in problems:
+            self.console.print(f"MCP: {problem}")
+        if not servers:
+            return None
+        manager = McpManager(cwd, servers, config.load()["mcp_tools"])
+        manager.start()
+        return manager
+
+    def modes(self, session: Session) -> dict:
+        return {
+            "currentModeId": session.agent.perms.mode,
+            "availableModes": [{"id": i, "name": n, "description": d} for i, n, d in MODES],
+        }
+
+    def new_session(self, params: dict) -> dict:
+        session = self.open(params)
+        self.commands(session)
+        return {"sessionId": session.id, "modes": self.modes(session)}
+
+    def load_session(self, params: dict) -> dict:
+        from lcode import sessions
+
+        session = self.open(params)
+        wanted = str(params.get("sessionId", ""))
+        found = next((s for s in sessions.list_sessions(session.agent.cwd, limit=1000) if s.id == wanted), None)
+        if found is None:
+            self.sessions.pop(session.id, None)
+            raise RpcError(NOT_FOUND, f"no saved lcode session {wanted} in {session.agent.cwd}")
+        self.sessions.pop(session.id, None)
+        session.agent.load(found)
+        session.id = session.agent.session_id
+        self.sessions[session.id] = session
+        session.replay()
+        self.commands(session)
+        return {"modes": self.modes(session)}
+
+    def commands(self, session: Session) -> None:
+        available = [{"name": "review", "description": "Review the uncommitted changes, or the branch against a base",
+                      "input": {"hint": "base branch (optional)"}}]  # fmt: skip
+        for name, command in session.agent.extensions().commands.items():
+            if name != "review":
+                entry: dict = {"name": name, "description": command.description}
+                if command.argument_hint:
+                    entry["input"] = {"hint": command.argument_hint}
+                available.append(entry)
+        session.update({"sessionUpdate": "available_commands_update", "availableCommands": available})
+
+    def session(self, params: dict) -> Session:
+        session = self.sessions.get(str(params.get("sessionId", "")))
+        if session is None:
+            raise RpcError(NOT_FOUND, f"no session {params.get('sessionId')}")
+        return session
+
+    def prompt(self, params: dict) -> dict:
+        session = self.session(params)
+        try:
+            return session.prompt(params.get("prompt") or [])
+        finally:
+            session.agent.no_changes = ""
+
+    def cancel(self, params: dict) -> None:
+        session = self.sessions.get(str(params.get("sessionId", "")))
+        if session is not None and session.agent.cancel is not None:
+            session.agent.cancel.set()
+            from lcode import subagents
+
+            if session.agent.response is not None:
+                subagents.abort(session.agent.response)  # stop the model's answer now
+        return None
+
+    def set_mode(self, params: dict) -> dict:
+        session = self.session(params)
+        mode = str(params.get("modeId", ""))
+        if mode not in {m[0] for m in MODES}:
+            raise RpcError(INVALID_PARAMS, f"unknown mode {mode}")
+        session.agent.perms.mode = session.mode = mode
+        return {}
+
+
+def main() -> int:
+    """Serve one editor over stdin and stdout until it disconnects."""
+    inp, out = sys.stdin.buffer, sys.stdout.buffer
+    sys.stdout = sys.stderr  # a stray print must not corrupt the protocol
+    # Open for the life of the process:
+    sys.stdin = open(os.devnull)  # noqa: SIM115  # nothing may wait for typed input: stdin is the protocol
+    log = os.environ.get("LCODE_ACP_LOG")
+    output = open(log, "a") if log else open(os.devnull, "w")  # noqa: SIM115  # lcode's own output
+    console = Console(file=output, width=120, force_terminal=False)
+    conn = Connection(inp, out)
+    server = Server(conn, console)
+    conn.serve(server.handle)
+    for session in server.sessions.values():
+        from lcode import api
+
+        api.close_agent(session.agent)
+    return 0

lcode/agent.py

@@ -257,6 +257,10 @@ class Agent:
         self.cancel: threading.Event | None = None  # set from another thread to stop
         self.on_tool = None  # called with (name, arguments) before each tool runs
         self.on_event: Callable[[dict], None] | None = None  # each step and tool result, for --output stream-json
+        self.on_delta: Callable[[str, str], None] | None = None  # ("text" or "thinking", piece) as it streams
+        self.current_call = ""  # id of the tool call that's running, so a permission request can name it
+        # Decides on a presented plan instead of asking in the terminal: "ask", "auto-edit", or why not.
+        self.plan_review: Callable[[str, str], str] | None = None
         self.max_steps = MAX_STEPS_PER_TURN
         self.turn_status = ""  # how the last request ended: success, max_steps
         self.response = None  # the streaming response, so another thread can abort it
@@ -649,6 +653,8 @@ class Agent:
                 msg = chunk.get("message", {})
                 if msg.get("thinking"):
                     thinking += msg["thinking"]
+                    if self.on_delta:
+                        self.on_delta("thinking", msg["thinking"])
                     progress.update("Thinking", msg["thinking"])
                     if self.settings.show_thinking:
                         stop_spinner()  # raw text is printed as it streams
@@ -659,6 +665,8 @@ class Agent:
                         self.console.print("\n")
                         printed_thinking = False
                     content += msg["content"]
+                    if self.on_delta:
+                        self.on_delta("text", msg["content"])
                     progress.update("Writing", msg["content"])
                     # Finished markdown blocks print above the spinner, which keeps running meanwhile.
                     start_spinner()
@@ -667,6 +675,8 @@ class Agent:
                     tool_calls.extend(msg["tool_calls"])
                 if chunk.get("done"):
                     final = chunk
+            if self.cancel is not None and self.cancel.is_set():
+                raise KeyboardInterrupt  # cancelled while the answer streamed: its end never came
         except KeyboardInterrupt:
             stop_spinner()
             md.flush()
@@ -833,6 +843,7 @@ class Agent:
                     raise
             for i, call in enumerate(calls):
                 name, args = call.get("function", {}).get("name", ""), call_arguments(call)
+                self.current_call = call.get("id", "")
                 if self.on_tool:
                     self.on_tool(name, args)
                 if name not in ("bash", "todo_write", "web_search", "web_fetch", "agent"):  # those print their own

lcode/cli.py

@@ -774,6 +774,11 @@ def build_subparsers() -> dict[str, argparse.ArgumentParser]:
     from lcode.mcp.commands import build_parser as mcp_parser
 
     subs["mcp"] = mcp_parser()
+    subs["acp"] = argparse.ArgumentParser(
+        prog="lcode acp",
+        description="Run as the agent inside an editor, over the Agent Client Protocol on stdin and stdout "
+        "(Zed and other ACP editors start it for you; see the docs).",
+    )
     subs["action"] = argparse.ArgumentParser(
         prog="lcode action",
         description="Run as a GitHub Action on a self-hosted runner: answer @lcode in issues and pull requests, "
@@ -782,6 +787,12 @@ def build_subparsers() -> dict[str, argparse.ArgumentParser]:
     return subs
 
 
+def cmd_acp(args) -> None:
+    from lcode import acp
+
+    sys.exit(acp.main())
+
+
 def cmd_action(args) -> None:
     from lcode import action
 
@@ -851,6 +862,7 @@ COMMANDS = {
     "mcp": cmd_mcp,
     "index": cmd_index,
     "action": cmd_action,
+    "acp": cmd_acp,
 }
 
 

lcode/permissions.py

@@ -76,7 +76,8 @@ class Permissions:
         self.always: set[str] = set()
         self.rules = Rules()  # allow and deny lists from the settings (lcode.hooks)
         self.on_prompt = None  # called with the title before lcode asks the user (notification hooks)
-        self.approve: Callable[[dict], bool] | None = None  # decides instead of asking (see lcode.api)
+        # Decides instead of asking (lcode.api, lcode acp): True, False, or a message saying why not.
+        self.approve: Callable[[dict], bool | str] | None = None
 
     def rule(self, kind: str, target: str) -> tuple[bool, str] | None:
         """A rule's verdict on an action: (allowed, message for the model), or None when no rule matches."""
@@ -109,9 +110,10 @@ class Permissions:
             target = target or key.split(":", 1)[-1]
             if kind == "bash":
                 target = LEADING_CD.sub("", target)  # the command itself, without `cd <folder> &&`
-            if self.approve({"kind": kind, "title": title, "target": target}):
+            verdict = self.approve({"kind": kind, "title": title, "target": target, "key": key})
+            if verdict is True:
                 return True, ""
-            return False, NOT_ASKED
+            return False, verdict if isinstance(verdict, str) and verdict else NOT_ASKED
         if self.on_prompt:
             self.on_prompt(title)
         self.console.print(Panel(body, title=title, title_align="left", border_style="yellow"))

lcode/planning.py

@@ -92,6 +92,11 @@ def present(agent: Agent, title: str, plan: str) -> str:
     plan = plan.strip()
     if not plan:
         return "Error: the plan is empty. Write the steps, the files, the risks and how you'll verify the work."
+    if agent.plan_review is not None:  # an editor shows the plan (lcode acp)
+        choice = agent.plan_review(title, plan)
+        if choice in ("ask", "auto-edit"):
+            return approve(agent, title, plan, choice, False)
+        return choice or "The user didn't approve the plan. Ask them what they'd like to change."
     edited = False
     while True:
         c.print(Panel(Markdown(plan), title=f"Plan: {escape(title)}", title_align="left", border_style="cyan"))

lcode/tools.py

@@ -15,6 +15,7 @@ import signal
 import subprocess
 import threading
 import time
+from collections.abc import Callable
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -366,6 +367,9 @@ class Toolbox:
         self.agent = agent
         self.read_mtimes: dict[str, float] = {}
         self.todos: list[dict] = []
+        # An editor's buffers (lcode acp): read unsaved changes and write through the editor.
+        self.reader: Callable[[Path], str | None] | None = None
+        self.writer: Callable[[Path, str], None] | None = None
 
     @property
     def console(self):
@@ -611,7 +615,7 @@ class Toolbox:
             raise ToolError(f"{path} is an image; look at it with view_image")
         if is_binary(p):
             raise ToolError(f"{path} is a binary file ({p.stat().st_size} bytes)")
-        lines = p.read_text(errors="replace").splitlines()
+        lines = self.read_text(p).splitlines()
         offset, limit = max(1, int(offset or 1)), max(1, int(limit or 2000))
         chunk = lines[offset - 1 : offset - 1 + limit]
         self.read_mtimes[str(p)] = p.stat().st_mtime
@@ -704,9 +708,20 @@ class Toolbox:
             diff = diff[:12_000] + "\n... (diff truncated for display)\n"
         return Syntax(diff or "(no changes)", "diff", theme="monokai", word_wrap=True)
 
+    def read_text(self, p: Path) -> str:
+        """A file's text: the editor's buffer when lcode runs inside one, else the file on disk."""
+        if self.reader is not None:
+            text = self.reader(p)
+            if text is not None:
+                return text
+        return p.read_text(errors="replace")
+
     def _write(self, p: Path, content: str) -> None:
         p.parent.mkdir(parents=True, exist_ok=True)
-        p.write_text(content)
+        if self.writer is not None:
+            self.writer(p, content)  # the editor updates its buffer (and the file)
+        if not p.exists() or p.read_text(errors="replace") != content:
+            p.write_text(content)  # the file on disk must match, for checkpoints and the tools
         self.read_mtimes[str(p)] = p.stat().st_mtime
 
     def t_write_file(self, path: str, content: str) -> str:
@@ -716,7 +731,7 @@ class Toolbox:
             if p.is_dir():
                 raise ToolError(f"{path} is a directory")
             self._check_fresh(p)
-            body = self._diff(p, p.read_text(errors="replace"), content)
+            body = self._diff(p, self.read_text(p), content)
         else:
             lines = content.splitlines()
             preview = "\n".join(lines[:60]) + (f"\n... ({len(lines) - 60} more lines)" if len(lines) > 60 else "")
@@ -725,7 +740,7 @@ class Toolbox:
         ok, feedback = self.agent.perms.request("edit", "edit", f"{verb} {self.rel(p)}", body, self.project_rel(p))
         if not ok:
             return feedback
-        before = p.read_text(errors="replace") if exists else None
+        before = self.read_text(p) if exists else None
         self.agent.checkpoint()
         self._write(p, content)
         n = len(content.splitlines())
@@ -741,7 +756,7 @@ class Toolbox:
             raise ToolError("old_string and new_string are identical")
         if not old_string:
             raise ToolError("old_string is empty; use write_file to create or overwrite files")
-        text = p.read_text(errors="replace")
+        text = self.read_text(p)
         count = text.count(old_string)
         if count == 0:
             new_text = fuzzy_replace(text, old_string, new_string)

{lcode_cli-0.18.0.dist-info → lcode_cli-0.19.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.18.0
+Version: 0.19.0
 Summary: A local-first terminal coding agent powered by open-weight models on your own GPU or Mac, via Ollama.
 Project-URL: Homepage, https://nasser1941.github.io/lcode/
 Project-URL: Documentation, https://nasser1941.github.io/lcode/
@@ -104,6 +104,8 @@ through [Ollama](https://ollama.com), and when it needs current information it c
 - **Git workflow.** `/commit` writes messages in your repository's style, `/review` checks the
   changes with `file:line` findings, `/pr` opens the pull request, each after you approve it, and
   `lcode --worktree` runs parallel sessions on one repository.
+- **In your editor.** Zed, JetBrains IDEs, Neovim and other editors that speak the Agent Client
+  Protocol run lcode with `lcode acp`, with diffs and approvals in the editor.
 - **Automation.** `lcode -p --output json` for scripts and CI, a Python API (`from lcode import
   Session`), and a GitHub Action that answers `@lcode` in issues and pull requests on your own
   self-hosted runner.
@@ -214,7 +216,6 @@ fills up. Details: [How it works](https://nasser1941.github.io/lcode/how-it-work
 
 See the pinned [Roadmap issue](https://github.com/nasser1941/lcode/issues/10). Next up:
 
-- [Editor integration through the Agent Client Protocol](https://github.com/nasser1941/lcode/issues/49)
 - [Long-running work: finish notifications and background commands](https://github.com/nasser1941/lcode/issues/51)
 - More models in the catalog, and test reports from your hardware ([report one](https://github.com/nasser1941/lcode/issues/new?template=model_request.yml))
 

{lcode_cli-0.18.0.dist-info → lcode_cli-0.19.0.dist-info}/RECORD

@@ -1,14 +1,15 @@
-lcode/__init__.py,sha256=WtOJl9ZuDxmhgQBhqCaBR_KVw2PffYBBxhlQXcCzw7I,473
+lcode/__init__.py,sha256=7yjbvkgWF_Vh6y72kETMa3SVkh4RP81rLJzvo11gIV8,473
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
+lcode/acp.py,sha256=M_CdTVqRSmLn33QD56Le4238Vz1ZxffnHCfjmajSv34,28940
 lcode/action.py,sha256=1r3abjheYFYQ-EUArvotls8pLmE3YjNMGHAy_iF0Z70,16198
-lcode/agent.py,sha256=MmXL2CZJzGaxqM8fpA0fEnnDgiBqrYSuUIhAtVIYcYY,48852
+lcode/agent.py,sha256=pB7rDZIbWiRrc8Ye4rA_LzHVqJ36yoTUN6nFsUeg428,49664
 lcode/api.py,sha256=kXlzXhGwkNdW9sWpxgOvL9h5pPzhzKRLXKrL1-eN3XY,15110
 lcode/backends.py,sha256=dtJHrC6ys73bRDg64z0tQz1PavmeAkiODZu1fOO9ExQ,20635
 lcode/bench.py,sha256=XVdk0hDxmRcjgROOCgwwOsExcUhIxgh0B2vnxtGnA3o,40742
 lcode/bench_backend.py,sha256=X2fo-zRX92Xp3KMxSsFlWioc2vRupBTtowj5kLME8mw,14287
 lcode/catalog.py,sha256=pZ1azX9OH2r4JE2c6E5OfwywpgS39-W2oXzoCHJhmtM,4141
 lcode/checkpoints.py,sha256=eqPtmPe44-aweWqc2H21ROogwzIt3NpvcUobsaCHoGY,18354
-lcode/cli.py,sha256=3p9NX6sVa8us7DDh5oFQh29aOdFIsOnFAa5DOL4OQec,39115
+lcode/cli.py,sha256=zo2QTHrdxVaJwIjCEOsfR99byPqeCkKHE5p_Xh8kfb8,39471
 lcode/codesearch.py,sha256=Io8leN1nb_Y-Dvlm9xaGtwUWYXX-ooswuznJV6dGU1s,10766
 lcode/config.py,sha256=nFljzjHTFaCTTbagycagbh2X_PpLtsUs-yRODiy4QcU,10065
 lcode/context.py,sha256=qJymLE3eYeaF6qVOzlUwDURqlky__8cskl_6vXeU3AA,10701
@@ -22,15 +23,15 @@ lcode/lsp.py,sha256=NtSW7xapv7fg2HAQLuYK1nwIqT7nG0LK1hiTpOmla_4,26086
 lcode/memory.py,sha256=WZEHTp-lVxAwS-yyLQR2xB3TMZ9sejmX2Ivg7T-tl3w,21949
 lcode/models.toml,sha256=lt2G64zzo_Ryxv2ISRSNZoVD_JqCqYqsM01n8WoXGs8,4098
 lcode/ollama.py,sha256=u5tnvL28cfaFS4GhmiEsHhTQe6w3Ng_Tej05UUzLQTQ,7715
-lcode/permissions.py,sha256=Ce5_rE7VsOyFPtgzfDrIq1n19ofvtbf9g4-Jfh0TFSQ,6181
-lcode/planning.py,sha256=hZjVka7i9TswJrXLbjbZJ0PBc6zHpmO64JqMiaFYnMQ,6110
+lcode/permissions.py,sha256=i04YLtqYCxwApgawomPp4d35uk9HAJtpKY__gfw8j9s,6347
+lcode/planning.py,sha256=mGXMU-khHyGHE8IHxxrsQc-FFOzbdRa4MWHMU19UR7o,6439
 lcode/render.py,sha256=gMvf4W3qkLUJ4Vot3az_hP_zRDAItJC9pP-68dHFkfA,1375
 lcode/repl.py,sha256=zJ2hj1c-tx35Sms8V-1W4XsyfFZ9omu9bZgGpEgBYi8,47655
 lcode/repomap.py,sha256=1GRJgEUjBl9XHSXsF7tSGXBCEgsY-3CzwMohaTudZ_M,13969
 lcode/sandbox.py,sha256=u_pkrVRXhCGhh-wFDPwuZ3jGG7UeXxXRAeBNsm37ZvE,8608
 lcode/sessions.py,sha256=wOR-J0EHgJxLSPboKPHnvBcp5VTUYTj3tZWgpsa6-K4,4013
 lcode/subagents.py,sha256=S_ZBpqnKFxRKhe-lE-I8SHc3yMOhe0zW-SD2K-Gwn28,28832
-lcode/tools.py,sha256=zpFFY3dK8-g9So_MmUoj7qU8Stmx5b6PQrpcNba-s6E,42360
+lcode/tools.py,sha256=Y4XmQsoLIA32S255DnCwOwebGPgQay1k7H_A9R5DINA,43145
 lcode/vision.py,sha256=w33QPmdGwP33wM4mvmAH4amFDZ1xzeXhEsSLJ-STSHY,4243
 lcode/web.py,sha256=vyxKbSRJTl1Lj3hj7Yd_NwTgbv0Xi6dup2YfUXjqp-Y,14579
 lcode/mcp/__init__.py,sha256=XujtAmRoXW9S0uq1XPf_CAeCkHh_UvA8FCmoAKP9j1Y,171
@@ -48,8 +49,8 @@ lcode/mcp/stdio.py,sha256=kC6KHwzMMDjBr-yCZLmyVKS7PZXU299WpZdYRoX5eRQ,6292
 lcode/servers/__init__.py,sha256=qrIhxEodEB8cjKEQ4Cicc0GsQhE2OH-9qlVHzr3-tq8,77
 lcode/servers/encord.py,sha256=WSauawL1UKYZCUAG1oalcKL_An3DVof-JM6xIgFyQSE,12769
 lcode/servers/valohai.py,sha256=e5xZGIoa4cja4f5i85q1GpL9c7cglUjV8jN2co1CFMY,14430
-lcode_cli-0.18.0.dist-info/METADATA,sha256=sgLqPzqqVoC9Q2253XGc2GPJK-Ktet1UKof6Sds0Vkw,12571
-lcode_cli-0.18.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.18.0.dist-info/entry_points.txt,sha256=pMz2Byj2QRyt-ZZQYZvmWUtmKPCeE7f8iCvu-sjZPIo,133
-lcode_cli-0.18.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.18.0.dist-info/RECORD,,
+lcode_cli-0.19.0.dist-info/METADATA,sha256=cUJGqerCzNU65yzxUbn48STtIOP3fjvVbItArdo1vJ4,12642
+lcode_cli-0.19.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.19.0.dist-info/entry_points.txt,sha256=pMz2Byj2QRyt-ZZQYZvmWUtmKPCeE7f8iCvu-sjZPIo,133
+lcode_cli-0.19.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.19.0.dist-info/RECORD,,