lcode-cli 0.18.0__tar.gz → 0.20.0__tar.gz

{lcode_cli-0.18.0 → lcode_cli-0.20.0}/CHANGELOG.md

@@ -6,6 +6,39 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.20.0] - 2026-10-06
+
+### Added
+
+- Background commands: the model starts a dev server, a watcher or another process that keeps
+  running with `bash` and `background: true`, reads its new output with `bash_output` and stops it
+  with `bash_stop`. `/jobs` lists them, and they all stop when the session ends.
+- Desktop notifications (`notify-send` on Linux, `osascript` on macOS, else the terminal bell)
+  when a request that ran longer than 30 seconds is done, or lcode waits for your answer during
+  one. Settings: `notify` and `notify_after`.
+
+### Fixed
+
+- A command that starts something with `&` no longer hangs until its timeout while that process
+  holds the output open. What it left running is stopped when it ends, and the model is told to
+  use a background command instead.
+
+## [0.19.0] - 2026-10-06
+
+### Added
+
+- `lcode acp`: lcode inside editors that speak the Agent Client Protocol (Zed, JetBrains IDEs,
+  Neovim, Emacs and others). The editor shows the answers and thinking as they stream, each tool
+  call with the files it touches and a diff for edits, and asks permission questions and plan
+  approvals in its own dialog. lcode's permission modes are the session's modes, the todo list is
+  the editor's plan, and saved sessions reopen with their conversation. The model reads the
+  editor's buffers (unsaved changes included) and edits through them, and MCP servers the editor
+  passes join lcode's own. See [Editors](https://nasser1941.github.io/lcode/editors/) for setup.
+
+### Fixed
+
+- Cancelling a request whose answer was cut off mid-stream no longer ends it as if it were done.
+
 ## [0.18.0] - 2026-10-06
 
 ### Added
@@ -434,7 +467,9 @@ First public release.
 - `AGENTS.md` project instructions and `/init` to generate them.
 - One-line installer for Linux and macOS.
 
-[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.18.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.20.0...HEAD
+[0.20.0]: https://github.com/nasser1941/lcode/compare/v0.19.0...v0.20.0
+[0.19.0]: https://github.com/nasser1941/lcode/compare/v0.18.0...v0.19.0
 [0.18.0]: https://github.com/nasser1941/lcode/compare/v0.17.0...v0.18.0
 [0.17.0]: https://github.com/nasser1941/lcode/compare/v0.16.0...v0.17.0
 [0.16.0]: https://github.com/nasser1941/lcode/compare/v0.15.0...v0.16.0

{lcode_cli-0.18.0 → lcode_cli-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.18.0
+Version: 0.20.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,8 +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))
 
 ## Contributing

{lcode_cli-0.18.0 → lcode_cli-0.20.0}/README.md

@@ -68,6 +68,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.
@@ -178,8 +180,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))
 
 ## Contributing

{lcode_cli-0.18.0 → lcode_cli-0.20.0}/docs/configuration.md

@@ -40,6 +40,8 @@ lcode config path                      # print the file location
 | `prune` | `true` | When the context is 85% full, first remove old tool output, and summarize the conversation only if that's not enough ([how](how-it-works.md#context-management)) |
 | `subagents` | `true` | Let the model hand tasks to [subagents](agents.md) with their own context |
 | `max_parallel_agents` | `1` | Subagents that run at the same time; more needs `OLLAMA_NUM_PARALLEL` on the Ollama server ([details](agents.md#several-at-once)) |
+| `notify` | `true` | A desktop [notification](usage.md#notifications) when a long request is done or waits for your answer |
+| `notify_after` | `30` | Seconds a request runs before it notifies |
 | `checkpoints` | `true` | Save a checkpoint before the model changes files, so [`/undo`](usage.md#undo-and-checkpoints) can restore them |
 
 Besides these settings, `config.toml` can hold [hooks](hooks.md) (`[[hooks]]`) and

lcode_cli-0.20.0/docs/editors.md

@@ -0,0 +1,85 @@
+# Editors
+
+lcode also works inside editors that support the
+[Agent Client Protocol](https://agentclientprotocol.com) (ACP), such as Zed, JetBrains IDEs,
+Neovim and Emacs. The editor starts `lcode acp` and shows lcode's work in its own UI: answers,
+tool calls, a diff for each edit, and permission questions.
+
+## Zed
+
+Add lcode to Zed's `settings.json`:
+
+```json
+{
+  "agent_servers": {
+    "lcode": {
+      "type": "custom",
+      "command": "lcode",
+      "args": ["acp"],
+      "env": {}
+    }
+  }
+}
+```
+
+Then open the Agent Panel and start a new thread with **lcode** from the new-thread menu.
+
+- **Zed can't start lcode:** use the full path in `command`, from `which lcode` (usually
+  `~/.local/bin/lcode`). An editor started from the desktop may not see your shell's `PATH`.
+- **Something goes wrong:** run **dev: open acp logs** in Zed's command palette to see the
+  messages lcode and Zed exchange.
+
+## JetBrains IDEs
+
+Add lcode to `~/.jetbrains/acp.json`, with the full path from `which lcode`:
+
+```json
+{
+  "agent_servers": {
+    "lcode": {
+      "command": "/home/you/.local/bin/lcode",
+      "args": ["acp"]
+    }
+  }
+}
+```
+
+Then pick lcode in the AI Chat tool window.
+
+## Other editors
+
+Any [ACP client](https://agentclientprotocol.com/overview/clients) works the same way: tell it
+to run `lcode acp`. That includes Neovim (CodeCompanion, avante.nvim), Emacs (agent-shell),
+VS Code extensions and more.
+
+## What the editor shows
+
+| In the editor | From lcode |
+|---|---|
+| The conversation | lcode's answers and its thinking, as they stream |
+| Tool calls | Each tool call, with its kind (read, search, edit, run, fetch) and the files it touches |
+| Edits | A diff of the whole file for each edit |
+| Open files | Edits go through the editor, so open files update right away. The model reads what's in the editor, unsaved changes included |
+| Permission questions | **Allow**, **Always allow** (for this session) or **Reject**, in the editor's own dialog |
+| Modes | lcode's [permission modes](usage.md#permissions): Ask, Auto-edit, Plan and Yolo |
+| Plans | In Plan mode, the plan is approved in the editor, which then switches to Ask or Auto-edit |
+| The plan list | The model's todo list |
+| Context | How much of the context window is in use |
+| Commands | `/review` and [your own commands](commands.md) |
+| Past threads | lcode's saved sessions: an editor that reopens a thread gets its conversation back |
+
+[Checkpoints](usage.md#undo-and-checkpoints), [hooks and permission rules](hooks.md),
+[memory](memory.md), [subagents](agents.md) and [MCP servers](mcp.md) work as in the terminal.
+MCP servers the editor passes to its agents are added to lcode's own.
+
+## Settings
+
+lcode uses your [configuration](configuration.md): the model, the context window, the
+[model server](servers.md) and the default permission mode. To use different settings in an
+editor, set them in the agent's `env`, for example `"env": {"LCODE_MODEL": "qwen3.5-9b"}`.
+
+A repository's own commands, skills, agents and hooks are used only after you
+[approve them](commands.md#approving-a-repositorys-commands-skills-and-agents). An editor can't
+ask, so run `lcode` in the repository once and approve them there.
+
+To see lcode's own output while it runs in an editor, set `LCODE_ACP_LOG` to a file in `env`.

{lcode_cli-0.18.0 → lcode_cli-0.20.0}/docs/hooks.md

@@ -46,7 +46,7 @@ command = "ruff format {path} && ruff check --fix {path}"
 | `after_tool` | After a tool call | Its output goes to the model when it exits with an error, or always with `feedback = true` |
 | `after_request` | When a request is done | Its output is shown to you |
 | `session_start` | When a session starts | Its output is shown, and with `feedback = true` given to the model |
-| `notification` | When lcode waits for your answer, and when a request that took over 30 seconds is done | Show a desktop notification, ring a bell |
+| `notification` | When lcode waits for your answer, and when a request that ran longer than `notify_after` seconds (30) is done | Send a message, play a sound (lcode shows [desktop notifications](usage.md#notifications) itself) |
 
 | Key | |
 |---|---|

{lcode_cli-0.18.0 → lcode_cli-0.20.0}/docs/quickstart.md

@@ -12,7 +12,7 @@ lcode
 
 ```text
 ╭──────────────────────────────────────────────╮
-│ lcode v0.18.0 — local coding agent           │
+│ lcode v0.20.0 — local coding agent           │
 │                                              │
 │ model    lcode-qwen3.6-35b                   │
 │ context  256K tokens                         │

{lcode_cli-0.18.0 → lcode_cli-0.20.0}/docs/usage.md

@@ -10,6 +10,7 @@ lcode doctor                 # check the installation (include this in bug repor
 lcode config [set|unset]     # show or change settings
 lcode bench [models]         # score models on small coding tasks on this machine
 lcode mcp [catalog|add|list] # connect MCP servers: Jira, GitHub, AWS, databases… (see MCP servers)
+lcode acp                    # run inside an editor over the Agent Client Protocol (see Editors)
 ```
 
 | Option | Meaning |
@@ -78,6 +79,7 @@ reasoning is on.
 | `/mode [ask\|plan\|auto-edit\|yolo]` | Set the permission mode |
 | `/cd DIR` | Change the working directory |
 | `/todos` | Show the model's task list |
+| `/jobs [stop ID]` | The [background commands](#background-commands) the model started; stop one |
 | `/commit [notes]` | [Commit](git.md#commit) the changes with a message in the repository's style, once you approve it |
 | `/review [base]` | [Review](git.md#review) the uncommitted changes, or the branch against a base |
 | `/pr [base] [notes]` | Push the branch and open a GitHub [pull request](git.md#pr), once you approve it |
@@ -93,7 +95,8 @@ reasoning is on.
 | `list_dir` | Directory tree, skipping `.git`, `node_modules`, virtualenvs and caches |
 | `glob` | Find files by pattern, newest first |
 | `grep` | Regex search with ripgrep (falls back to Python if ripgrep is missing) |
-| `bash` | Run a shell command with live output, a timeout and a persistent working directory |
+| `bash` | Run a shell command with live output, a timeout and a persistent working directory; with `background`, keep it running ([details](#background-commands)) |
+| `bash_output`, `bash_stop` | Read what a background command printed since last time; stop it |
 | `todo_write` | Keep a visible task list for multi-step work |
 | `web_search` | Search the web for current information (needs a [search provider](#web-search)) |
 | `web_fetch` | Read a web page or text file by URL as clean text |
@@ -109,6 +112,38 @@ reasoning is on.
 lcode refuses to edit a file the model hasn't read in the session, or one that changed on disk since
 it was read, so the model always edits the current version.
 
+## Background commands
+
+Some commands keep running: a dev server, a test watcher, a build in watch mode. The model starts
+one with `bash` and `background: true` and carries on working. It reads what the command printed
+since last time with `bash_output`, and stops it with `bash_stop`.
+
+```text
+  $ npm run dev  (in the background)
+    > vite
+    VITE v6.0.0  ready in 312 ms
+  ⎿ background job 1, /jobs to see it
+```
+
+- `/jobs` lists the background commands; `/jobs stop 1` stops one.
+- They all stop when the session ends.
+- Anything else a command starts with `&` is stopped when that command ends. Only background
+  commands keep running, so no process outlives the session unnoticed.
+- Background commands ask for permission like any other command, and run in the
+  [sandbox](sandbox.md) when it's on.
+
+## Notifications
+
+Local models take a while, so you'll often switch to something else during a request. lcode shows
+a desktop notification:
+- when a request that ran longer than 30 seconds is done;
+- when, during such a request, lcode waits for your answer (a permission question or a plan).
+
+It uses `notify-send` on Linux and `osascript` on macOS, and rings the terminal bell where neither
+works. Change the time with `lcode config set notify_after 60`, or turn notifications off with
+`lcode config set notify false`. For something else, such as a sound or a phone message, use a
+[notification hook](hooks.md#hooks).
+
 ## Images
 
 lcode can look at screenshots, mockups, diagrams and photos:

{lcode_cli-0.18.0 → lcode_cli-0.20.0}/mkdocs.yml

@@ -97,6 +97,7 @@ nav:
       - Commands and skills: commands.md
       - Git workflow: git.md
       - Automation: automation.md
+      - Editors: editors.md
       - Code intelligence: lsp.md
       - Repository map and code search: search.md
       - Models & context windows: models.md

{lcode_cli-0.18.0 → lcode_cli-0.20.0}/pyproject.toml

@@ -86,6 +86,7 @@ ignore = [
 "src/lcode/backends.py" = ["E501"]
 "src/lcode/gitflow.py" = ["E501"]
 "src/lcode/action.py" = ["E501"]
+"src/lcode/acp.py" = ["E501"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{lcode_cli-0.18.0 → lcode_cli-0.20.0}/src/lcode/__init__.py

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