lcode-cli 0.3.1__tar.gz → 0.4.0__tar.gz

{lcode_cli-0.3.1 → lcode_cli-0.4.0}/CHANGELOG.md

@@ -6,6 +6,31 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-10-01
+
+### Added
+
+- MCP (Model Context Protocol) servers: the model can use tools from Jira, GitHub, AWS, databases and
+  more, with your approval for every call.
+  - `lcode mcp add <name>` sets up a ready-made server and tests it: `atlassian`, `aws`,
+    `aws-knowledge`, `google-drive`, `grafana`, `gcp`, `github`, `playwright`, `context7`, `sentry`,
+    `postgres`, `kubernetes`, `linear` and `notion` (`lcode mcp catalog` lists them).
+  - Any other server works too, local (stdio) or remote (Streamable HTTP), configured in
+    `~/.config/lcode/mcp.json` in the standard `mcpServers` format, or per project in `.mcp.json`
+    (used only after you approve it).
+  - Browser sign-in (OAuth 2.1 with PKCE and dynamic client registration) with automatic token
+    refresh; `lcode mcp login/logout`.
+  - Speaks both the current MCP protocol (2026-07-28) and the earlier `initialize`-based versions.
+  - When the tool definitions would take more than 15% of the context window, the model finds tools
+    on demand instead (`mcp_tools` setting). `/mcp` shows servers, tools and their context cost;
+    `lcode --no-mcp` starts without them.
+
+### Fixed
+
+- `lcode bench`: stopping a run with Ctrl+C no longer leaves the running task's temporary folder
+  behind, and the summary marks the model as stopped.
+- `lcode bench` no longer lists the model it's about to benchmark as "already loaded".
+
 ## [0.3.1] - 2026-09-30
 
 ### Added
@@ -140,7 +165,8 @@ 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.3.1...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.4.0...HEAD
+[0.4.0]: https://github.com/nasser1941/lcode/compare/v0.3.1...v0.4.0
 [0.3.1]: https://github.com/nasser1941/lcode/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/nasser1941/lcode/compare/v0.2.2...v0.3.0
 [0.2.2]: https://github.com/nasser1941/lcode/compare/v0.2.1...v0.2.2

{lcode_cli-0.3.1 → lcode_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.3.1
+Version: 0.4.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/
@@ -81,6 +81,9 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   request's edits, new files and shell-command changes, without touching your git history.
 - **Bring your own model.** Eight curated open-weight models, all tested end to end, or any Ollama model
   with tool calling.
+- **MCP servers, ready to go.** Connect Jira and Confluence, GitHub, AWS, Google Drive, Grafana,
+  Google Cloud, Sentry, Linear, Notion, Postgres, Kubernetes and more with one command
+  (`lcode mcp add atlassian`), or any other MCP server. Browser sign-in (OAuth) is built in.
 - **Web search when needed.** Looks up the latest versions, docs and error messages with Ollama web
   search, Brave, Tavily or your own SearXNG, and reads pages as clean text.
 - **Private.** The model runs on your machine, lcode never uploads your files and has no telemetry.
@@ -128,6 +131,7 @@ lcode
 | `lcode models` / `lcode doctor` | what fits this machine / check the installation |
 | `lcode bench qwen3.6-35b qwen3.5-9b` | compare models on small coding tasks on this machine |
 | `/undo`, `/rewind` | take back the last request's file changes, or go back further |
+| `lcode mcp catalog` / `lcode mcp add github` | ready-made MCP servers / add one |
 | `/rename`, `/resume` | name the current session, resume a saved one |
 | `/model`, `/context`, `/compact`, `/help` | switch model, resize the context window (pick from a list), summarize, list commands |
 
@@ -172,7 +176,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:
 
-- [MCP tool servers](https://github.com/nasser1941/lcode/issues/6)
 - [Homebrew formula](https://github.com/nasser1941/lcode/issues/8) and an [optional sandbox for shell commands](https://github.com/nasser1941/lcode/issues/9)
 - 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.3.1 → lcode_cli-0.4.0}/README.md

@@ -48,6 +48,9 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   request's edits, new files and shell-command changes, without touching your git history.
 - **Bring your own model.** Eight curated open-weight models, all tested end to end, or any Ollama model
   with tool calling.
+- **MCP servers, ready to go.** Connect Jira and Confluence, GitHub, AWS, Google Drive, Grafana,
+  Google Cloud, Sentry, Linear, Notion, Postgres, Kubernetes and more with one command
+  (`lcode mcp add atlassian`), or any other MCP server. Browser sign-in (OAuth) is built in.
 - **Web search when needed.** Looks up the latest versions, docs and error messages with Ollama web
   search, Brave, Tavily or your own SearXNG, and reads pages as clean text.
 - **Private.** The model runs on your machine, lcode never uploads your files and has no telemetry.
@@ -95,6 +98,7 @@ lcode
 | `lcode models` / `lcode doctor` | what fits this machine / check the installation |
 | `lcode bench qwen3.6-35b qwen3.5-9b` | compare models on small coding tasks on this machine |
 | `/undo`, `/rewind` | take back the last request's file changes, or go back further |
+| `lcode mcp catalog` / `lcode mcp add github` | ready-made MCP servers / add one |
 | `/rename`, `/resume` | name the current session, resume a saved one |
 | `/model`, `/context`, `/compact`, `/help` | switch model, resize the context window (pick from a list), summarize, list commands |
 
@@ -139,7 +143,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:
 
-- [MCP tool servers](https://github.com/nasser1941/lcode/issues/6)
 - [Homebrew formula](https://github.com/nasser1941/lcode/issues/8) and an [optional sandbox for shell commands](https://github.com/nasser1941/lcode/issues/9)
 - 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.3.1 → lcode_cli-0.4.0}/SECURITY.md

@@ -36,6 +36,12 @@ user, in your working directory**. It is not a sandbox. Keep in mind:
   pages are downloaded from their websites. The model writes the queries, so they can contain names or
   snippets from your code. Use `web = ask` to approve each search, or `web = off` / `--no-web` to
   keep everything local.
+- MCP servers you add run as your user (local servers) or act on your accounts (remote servers).
+  Every MCP tool call needs your approval unless you're in `yolo` mode or listed the tool under
+  `allow`. A project's `.mcp.json` is only used after you approve it, and again after it changes.
+  MCP tool results can contain prompt injections, like web pages. Tokens you enter are stored in
+  `~/.config/lcode/mcp.json` and sign-in tokens in `~/.local/state/lcode/mcp-auth/`, both readable
+  only by you.
 - Sessions (including file contents the model read) are stored in `~/.local/state/lcode/sessions`.
   Checkpoints for `/undo` keep copies of your project's files (except ignored ones) in
   `~/.local/state/lcode/checkpoints` for 14 days; turn them off with `checkpoints = false`.

{lcode_cli-0.3.1 → lcode_cli-0.4.0}/docs/configuration.md

@@ -25,6 +25,7 @@ lcode config path                      # print the file location
 | `web` | `on` | Web search and page fetching: `on`, `ask` (before each search/website) or `off` |
 | `search_backend` | `auto` | `auto`, `ollama`, `brave`, `tavily` or `searxng`; `auto` uses the first one configured |
 | `searxng_url` | | Your SearXNG instance, e.g. `http://localhost:8888` |
+| `mcp_tools` | `auto` | How [MCP](mcp.md#context) tool definitions reach the model: `auto`, `direct` or `search` (on demand) |
 | `checkpoints` | `true` | Save a checkpoint before the model changes files, so [`/undo`](usage.md#undo-and-checkpoints) can restore them |
 
 Example file:
@@ -59,6 +60,9 @@ Environment variables override the file, which is useful for one-off runs and CI
 | `~/.config/lcode/config.toml` | Settings |
 | `~/.local/state/lcode/sessions/` | Saved conversations (for `lcode -c`) |
 | `~/.local/state/lcode/history` | Prompt history (++up++ in the prompt) |
+| `~/.config/lcode/mcp.json` | [MCP servers](mcp.md) (readable only by you; may contain tokens) |
+| `~/.local/state/lcode/mcp-auth/` | Sign-in tokens for remote MCP servers (readable only by you) |
+| `~/.local/state/lcode/mcp-logs/` | Error output of local MCP servers |
 | `~/.local/state/lcode/checkpoints/` | Checkpoints for `/undo` (copies of your project's files; deleted after 14 days) |
 | `~/.local/state/lcode/limits.json` | Context sizes that ran out of GPU memory on this machine (safe to delete) |
 

{lcode_cli-0.3.1 → lcode_cli-0.4.0}/docs/how-it-works.md

@@ -75,6 +75,7 @@ the Ollama server you configure, it only contacts the web when the model searche
 | `agent.py` | System prompt, streaming, tool loop, compaction, sessions |
 | `tools.py` | Tool schemas and implementations |
 | `permissions.py` | Approval prompts and the read-only allowlist |
+| `mcp/` | MCP client: stdio and HTTP transports, OAuth sign-in, server settings, the catalog, `lcode mcp` |
 | `bench.py` | `lcode bench`: the benchmark tasks, their checks and the reports |
 | `checkpoints.py` | Snapshots before the model changes files, for `/undo` and `/rewind` |
 | `catalog.py`, `models.toml` | Model catalog and memory estimates |

{lcode_cli-0.3.1 → lcode_cli-0.4.0}/docs/index.md

@@ -69,6 +69,13 @@ until the task is done, asking before it changes anything.
     Every edit is shown as a diff and every non-read-only command needs your approval, unless you
     choose otherwise. `/undo` takes back a request's file changes.
 
+-   :material-connection:{ .lg .middle } **MCP servers**
+
+    ---
+
+    Jira, GitHub, AWS, Google Drive, Grafana and more, one command each:
+    [`lcode mcp add atlassian`](mcp.md). Browser sign-in is built in.
+
 -   :material-swap-horizontal:{ .lg .middle } **Bring your own model**
 
     ---

lcode_cli-0.4.0/docs/mcp.md

@@ -0,0 +1,216 @@
+# MCP servers
+
+The [Model Context Protocol](https://modelcontextprotocol.io) (MCP) lets lcode use tools from other
+systems: your issue tracker, GitHub, cloud accounts, databases, dashboards, a browser. Each MCP server
+adds a set of tools that the model can call, just like reading files or running commands, and every
+call is shown to you for approval first.
+
+```bash
+lcode mcp catalog          # ready-made servers
+lcode mcp add atlassian    # add one (signs you in through the browser)
+lcode mcp list             # check that your servers work
+```
+
+Then start `lcode` as usual and ask, for example, *"Summarize the open bugs assigned to me in Jira
+and find the code for the top one."*
+
+## Ready-made servers
+
+`lcode mcp add <name>` sets these up, asks for anything they need and tests the connection:
+
+| Name | What it gives the model | You need |
+|---|---|---|
+| `atlassian` | Jira, Confluence, Jira Service Management, Compass, Bitbucket | an Atlassian account (browser sign-in) |
+| `aws` | AWS CLI commands on your account, read-only unless you change it | `uvx` and AWS credentials |
+| `aws-knowledge` | Current AWS documentation, code samples, regional availability | nothing |
+| `google-drive` | Search, read and create files in Google Drive | your own Google OAuth client ([below](#google-drive)) |
+| `grafana` | Dashboards, Prometheus and Loki queries, alerts, incidents | `uvx`, a Grafana service account token |
+| `gcp` | `gcloud` commands on your Google Cloud projects | `npx` and the `gcloud` CLI, signed in |
+| `github` | Repositories, issues, pull requests, Actions | a GitHub token (or the GitHub CLI) |
+| `playwright` | A real (headless) browser: open pages, click, fill forms | `npx` |
+| `context7` | Up-to-date docs and examples for thousands of libraries | nothing (an API key is optional) |
+| `sentry` | Errors, issues, traces and releases | a Sentry account (browser sign-in) |
+| `postgres` | Schemas, read-only queries, query performance | `uvx`, a connection URL |
+| `kubernetes` | Pods, deployments, logs and events, read-only | `npx` and a kubeconfig |
+| `linear` | Issues, projects and cycles | a Linear account (browser sign-in) |
+| `notion` | Pages and databases | a Notion account (browser sign-in) |
+
+`npx` comes with [Node.js](https://nodejs.org) (18 or newer) and `uvx` with
+[uv](https://docs.astral.sh/uv/getting-started/installation/). `lcode mcp catalog` shows what's missing
+on your machine.
+
+Servers that can change things start read-only where the server supports it (`aws`, `postgres`,
+`kubernetes`); the setup note tells you which setting to change to allow writes.
+
+### Signing in
+
+Atlassian, Sentry, Linear and Notion use OAuth: lcode opens your browser, you sign in and approve
+access, and the browser hands a code back to lcode on `localhost`. lcode stores the tokens in
+`~/.local/state/lcode/mcp-auth/` (readable only by you) and refreshes them automatically.
+
+```bash
+lcode mcp login atlassian     # sign in again, e.g. after revoking access
+lcode mcp logout atlassian    # forget the tokens
+```
+
+In a session, `/mcp login <name>` does the same. On a machine without a browser, lcode prints the
+sign-in URL; open it on any computer that can reach the machine's `localhost` (for example through an
+SSH tunnel), or sign in on your own machine and copy `~/.local/state/lcode/mcp-auth/`.
+
+Atlassian organizations can also allow API tokens instead; see
+[Atlassian's guide](https://developer.atlassian.com/cloud/rovo-mcp/guides/configuring-authentication-via-api-token/)
+and add the server [by hand](#adding-your-own-servers) with an `Authorization` header.
+
+### GitHub
+
+`lcode mcp add github` offers the GitHub CLI's token if you use `gh`; otherwise create a
+[fine-grained token](https://github.com/settings/personal-access-tokens/new) with access to the
+repositories you want. Only the `repos`, `issues`, `pull_requests` and `actions` toolsets are on, to
+keep the tool list short; change `X-MCP-Toolsets` in `mcp.json` for
+[others](https://github.com/github/github-mcp-server#available-toolsets).
+
+### Google Drive
+
+Google doesn't let apps register themselves, so the Drive server needs an OAuth client from your own
+Google Cloud project:
+
+1. In a Google Cloud project, enable the **Google Drive API** and the **Google Drive MCP API**.
+2. Configure the OAuth consent screen (while it's in testing, add yourself as a test user).
+3. Create an **OAuth client ID** of type **Desktop app**, and copy its ID and secret.
+4. Run `lcode mcp add google-drive` and paste them; lcode then signs you in through the browser.
+
+See [Google's guide](https://developers.google.com/workspace/guides/configure-mcp-servers) for
+details.
+
+## Adding your own servers
+
+Any MCP server works. For a remote server, give its URL; for a local one, the command that starts it:
+
+```bash
+lcode mcp add tracker --url https://mcp.example.com/mcp
+lcode mcp add tracker --url https://mcp.example.com/mcp --header "Authorization: Bearer \${TRACKER_TOKEN}"
+lcode mcp add notes -- npx -y @modelcontextprotocol/server-filesystem /home/me/notes
+lcode mcp add db --env DATABASE_URL=postgres://localhost/app -- uvx some-postgres-mcp
+```
+
+Servers are saved in `~/.config/lcode/mcp.json` in the `mcpServers` format that most MCP servers
+document, so you can also paste a server's example config into that file:
+
+```json
+{
+  "mcpServers": {
+    "tracker": {
+      "type": "http",
+      "url": "https://mcp.example.com/mcp",
+      "headers": { "Authorization": "Bearer ${TRACKER_TOKEN}" }
+    },
+    "notes": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/me/notes"],
+      "tools": ["read_file", "search_files"],
+      "allow": ["read_file"]
+    }
+  }
+}
+```
+
+| Key | Meaning |
+|---|---|
+| `command`, `args`, `env` | A local server, started by lcode and spoken to over stdin/stdout |
+| `type: "http"`, `url`, `headers` | A remote server (Streamable HTTP). Without an `Authorization` header, lcode signs in with OAuth when the server asks for it |
+| `tools` | Only offer these tools to the model (fewer tools save context and help smaller models) |
+| `allow` | Tools that run without asking; `["*"]` for all of the server's tools |
+| `timeout` | Seconds a tool call may take (default 300) |
+| `disabled` | `true` to turn the server off (`lcode mcp disable <name>`) |
+| `oauth` | For servers that need a pre-registered OAuth client: `client_id`, `client_secret`, `scopes`, `authorize_params` |
+
+Values can use environment variables: `${NAME}`, or `${NAME:-default}`. Keep tokens in environment
+variables if you prefer not to store them in the file; `mcp.json` is created readable only by you
+either way.
+
+Servers that only offer the old HTTP+SSE transport (URLs ending in `/sse`) aren't supported. Most of
+them also have a Streamable HTTP endpoint (often `/mcp`); otherwise bridge one with
+`npx -y mcp-remote <url>` as a local server.
+
+### Project servers
+
+A repository can share servers with everyone who works on it in a `.mcp.json` at its root, in the same
+format. Because those servers run programs or connect to services on your behalf, lcode asks before
+using them the first time, and again whenever the file changes.
+
+## In a session
+
+The banner lists your servers. They start in the background, and lcode waits for them (at most a
+couple of minutes, the first time `npx` or `uvx` downloads a server) before your first request.
+
+```text
+❯ /mcp
+MCP servers
+┏━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+┃ Server        ┃ Status ┃ Tools ┃ Details                                        ┃
+┡━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
+│ aws-knowledge │ ready  │     5 │ https://knowledge-mcp.global.api.aws           │
+│ everything    │ ready  │    13 │ npx -y @modelcontextprotocol/server-everything │
+│ context7      │ ready  │     2 │ https://mcp.context7.com/mcp                   │
+└───────────────┴────────┴───────┴────────────────────────────────────────────────┘
+           Tool definitions: ~6.2K tokens · all sent with every request
+```
+
+A server that can't start shows `failed` with the reason (for example, a missing environment
+variable), and one that needs you to sign in shows `needs sign-in`; the others work normally.
+
+| Command | |
+|---|---|
+| `/mcp` | Servers, their status and the context their tools take |
+| `/mcp tools <name>` | A server's tools |
+| `/mcp login <name>` | Sign in (or again) and reconnect |
+| `/mcp restart <name>` | Restart a server, e.g. after changing its settings |
+
+Start a session without MCP servers with `lcode --no-mcp`.
+
+### Approvals
+
+Every MCP tool call shows the server, the tool and its arguments, and waits for your answer, in the
+`ask` and `auto-edit` modes alike: answer ++y++ (once), ++a++ (always, for this tool, until you quit)
+or ++n++ with an optional reason. Only `yolo` mode, or the server's `allow` list, skips the question.
+
+### Context
+
+Every tool definition is sent to the model with every request. A few servers can add tens of
+thousands of tokens, which leaves less room for your code and makes smaller models pick the wrong
+tool. So when the definitions would take more than 15% of the context window, lcode doesn't send
+them: the model sees the tool names, looks up the ones it needs with `mcp_find_tools` and calls them
+with `mcp_call`. `/mcp` and `/context` show which way is used.
+
+| `mcp_tools` setting | |
+|---|---|
+| `auto` (default) | Send the definitions if they fit in 15% of the context, otherwise on demand |
+| `direct` | Always send them |
+| `search` | Always on demand |
+
+```bash
+lcode config set mcp_tools search
+```
+
+Limiting a server's `tools` in `mcp.json` is the best fix for a crowded tool list. Some servers are
+large: Grafana offers about 80 tools and Playwright about 25, while most have a handful.
+
+## Troubleshooting
+
+- `lcode mcp list` connects to every server and shows what's wrong.
+- A local server's error output is in `~/.local/state/lcode/mcp-logs/<name>.log`.
+- **A `uvx` server fails with a Python error:** some servers don't work on the newest Python yet;
+  the ready-made ones pin Python 3.12 with `--python 3.12`, which you can add to your own. A
+  `No module named 'mcp.server.fastmcp'` error means the server needs version 1 of the MCP Python
+  SDK: add `"--with", "mcp<2"` before the package name in its `args`.
+- **"needs sign-in":** run `lcode mcp login <name>`. If the sign-in page says the redirect URL isn't
+  allowed, the service needs a pre-registered client (see [Google Drive](#google-drive)).
+- **Very slow first start:** `npx -y` and `uvx` download the server the first time.
+
+## Protocol support
+
+lcode implements MCP tools over stdio and Streamable HTTP, for both the current protocol
+(`2026-07-28`, stateless) and the earlier `initialize`-based versions (`2025-11-25` and before), and
+the MCP authorization spec (OAuth 2.1 with PKCE, protected-resource discovery, dynamic client
+registration and refresh tokens). MCP resources, prompts, sampling and elicitation aren't supported
+yet.

{lcode_cli-0.3.1 → lcode_cli-0.4.0}/docs/quickstart.md

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

{lcode_cli-0.3.1 → lcode_cli-0.4.0}/docs/troubleshooting.md

@@ -62,6 +62,12 @@ of the text-only variant, run `lcode setup <key>` once to create the variant.
 - Some sites block automated downloads or need JavaScript; with `OLLAMA_API_KEY` set, lcode retries
   those through Ollama's fetch service.
 
+### An MCP server doesn't work
+
+Run `lcode mcp list`: it connects to every server and shows why one fails. A local server's error
+output is in `~/.local/state/lcode/mcp-logs/<name>.log`. Remote servers that say *needs sign-in*
+need `lcode mcp login <name>`. More in [MCP servers: Troubleshooting](mcp.md#troubleshooting).
+
 ### It's slow
 
 - The first request loads the model (10–45 s). lcode starts loading in the background as soon as it

{lcode_cli-0.3.1 → lcode_cli-0.4.0}/docs/usage.md

@@ -9,6 +9,7 @@ lcode models                 # the model catalog and what fits this machine
 lcode doctor                 # check the installation (include this in bug reports)
 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)
 ```
 
 | Option | Meaning |
@@ -23,6 +24,7 @@ lcode bench [models]         # score models on small coding tasks on this machin
 | `--yolo` | Never ask for permission |
 | `--no-think` | Turn off the model's reasoning: faster, less accurate |
 | `--no-web` | No web search or page fetching in this session |
+| `--no-mcp` | Don't start [MCP servers](mcp.md) in this session |
 | `--show-thinking` | Print the model's reasoning as it streams |
 | `-V, --version` | Print the version |
 
@@ -53,6 +55,7 @@ reasoning is on.
 | `/undo` | Undo the file changes of the last request ([details](#undo-and-checkpoints)) |
 | `/rewind [N]` | Go back to before request N: its files, and optionally the conversation |
 | `/checkpoints` | List the requests that changed files, and which files |
+| `/mcp [tools\|login\|restart NAME]` | [MCP servers](mcp.md), their status and tools |
 | `/compact [focus]` | Summarize the conversation to free context |
 | `/context [size]` | Show how full the context window is and change its size: pick from a list with memory estimates, or give a size like `/context 128k` (`/ctx` is a shortcut) |
 | `/model [name]`, `/models` | Switch model, list models |

{lcode_cli-0.3.1 → lcode_cli-0.4.0}/mkdocs.yml

@@ -94,6 +94,7 @@ nav:
       - Using lcode: usage.md
       - Models & context windows: models.md
       - Benchmarking models: bench.md
+      - MCP servers: mcp.md
       - Configuration: configuration.md
   - Reference:
       - How it works: how-it-works.md

{lcode_cli-0.3.1 → lcode_cli-0.4.0}/src/lcode/__init__.py

@@ -1,3 +1,3 @@
 """lcode — a local-first terminal coding agent powered by open-weight models via Ollama."""
 
-__version__ = "0.3.1"
+__version__ = "0.4.0"

{lcode_cli-0.3.1 → lcode_cli-0.4.0}/src/lcode/agent.py

@@ -15,12 +15,14 @@ from pathlib import Path
 
 from rich.console import Console
 from rich.markdown import Markdown
+from rich.markup import escape
 from rich.panel import Panel
 from rich.text import Text
 
 from lcode import catalog, limits, sessions, web
 from lcode.checkpoints import Checkpoints
 from lcode.config import format_tokens
+from lcode.mcp import McpManager
 from lcode.ollama import Ollama, OllamaError
 from lcode.permissions import Permissions
 from lcode.render import MarkdownStreamer
@@ -150,6 +152,8 @@ class Agent:
         self.tools = Toolbox(self)
         self.session_id = self.new_session_id()
         self.checkpoints = Checkpoints(self.console, settings.checkpoints)
+        self.mcp: McpManager | None = None  # set by the CLI when MCP servers are configured
+        self._mcp_prompt = ""  # the MCP part at the end of the system prompt
         self.session_name = ""
         self.session_title = ""
         self.ctx_used = 0
@@ -188,9 +192,32 @@ class Agent:
         return web.resolve_backend(self.settings.search_backend, self.settings.searxng_url)
 
     def tool_schemas(self) -> list[dict]:
-        if self.settings.web == "off":
-            return SCHEMAS
-        return [*SCHEMAS, *([WEB_SEARCH_SCHEMA] if self.search_backend() else []), WEB_FETCH_SCHEMA]
+        schemas = list(SCHEMAS)
+        if self.settings.web != "off":
+            schemas += [*([WEB_SEARCH_SCHEMA] if self.search_backend() else []), WEB_FETCH_SCHEMA]
+        if self.mcp:
+            schemas += self.mcp.schemas(self.settings.context)
+        return schemas
+
+    def prepare_mcp(self) -> None:
+        """Before a request: wait for MCP servers still starting and describe them in the system prompt."""
+        if not self.mcp:
+            return
+        if self.mcp.pending:
+            with self.console.status(f"Starting MCP servers: {', '.join(self.mcp.pending)}", spinner="dots"):
+                self.mcp.wait()
+            for state in self.mcp.servers.values():
+                if state.status in ("failed", "login") and not state.reported:
+                    state.reported = True
+                    self.console.print(f"[yellow]MCP server {state.name}: {escape(state.error)}[/] [dim](/mcp)[/]")
+        self.mcp.refresh_changed()
+        section = self.mcp.prompt_section(self.settings.context)
+        if section != self._mcp_prompt:
+            content = self.messages[0]["content"]
+            if self._mcp_prompt and content.endswith(self._mcp_prompt):
+                content = content[: -len(self._mcp_prompt)]
+            self.messages[0]["content"] = content + section
+            self._mcp_prompt = section
 
     def web_prompt(self) -> str:
         if self.settings.web == "off":
@@ -203,6 +230,7 @@ class Agent:
 
     def reset(self) -> None:
         self.messages = [{"role": "system", "content": self.system_prompt()}]
+        self._mcp_prompt = ""
         self.tools.read_mtimes.clear()
         self.ctx_used = len(self.messages[0]["content"]) // 3
 
@@ -254,6 +282,7 @@ class Agent:
             else:
                 note = f"The session's directory {saved_cwd} no longer exists; staying in {self.cwd}"
         self.messages = [{"role": "system", "content": self.system_prompt()}, *data.get("messages", [])[1:]]
+        self._mcp_prompt = ""
         self.session_id = info.id
         self.checkpoints.load(info.id, data.get("checkpoints") or [])
         self.session_name = data.get("name", "")
@@ -415,6 +444,15 @@ class Agent:
             return f"glob({args.get('pattern', '')})"
         if name == "list_dir":
             return f"list_dir({args.get('path', '.')})"
+        if self.mcp and self.mcp.owns(name):
+            if name == "mcp_find_tools":
+                return f"mcp_find_tools({args.get('query', '')!r})"
+            try:
+                state, tool, arguments = self.mcp.resolve(name, args)
+            except Exception:
+                return name
+            preview = json.dumps(arguments, ensure_ascii=False)
+            return f"{state.name} › {tool['name']}({preview if len(preview) <= 80 else preview[:79] + '…'})"
         return name
 
     def run_turn(self, user_text: str) -> None:
@@ -429,6 +467,7 @@ class Agent:
         self.checkpoints.before_change(self.cwd)
 
     def _run_turn(self, user_text: str) -> None:
+        self.prepare_mcp()
         self.messages.append({"role": "user", "content": self.expand_mentions(user_text)})
         malformed = 0
         for _ in range(MAX_STEPS_PER_TURN):

{lcode_cli-0.3.1 → lcode_cli-0.4.0}/src/lcode/bench.py

@@ -850,31 +850,33 @@ def run_task(
     ollama: Ollama, settings: Settings, task: Task, timeout: float, log: Console, keep: bool, usage: dict
 ) -> TaskResult:
     folder = Path(tempfile.mkdtemp(prefix=f"lcode-bench-{task.id}-"))
-    for rel, content in task.files.items():
-        (folder / rel).parent.mkdir(parents=True, exist_ok=True)
-        (folder / rel).write_text(content)
-    agent = Agent(ollama, settings, folder, console=log)
-    error = None
-    started = time.monotonic()
-    try:
-        with time_limit(timeout):
-            agent.run_turn(task.prompt)
-    except TaskTimeout:
-        error = f"timed out after {timeout:.0f}s"
-    except OllamaError as e:
-        error = str(e).splitlines()[0][:200]
-    seconds = time.monotonic() - started
-    for key, value in agent.usage.items():
-        usage[key] = usage.get(key, 0) + value
-    answer = next((m.get("content", "") for m in reversed(agent.messages) if m.get("role") == "assistant"), "")
     try:
-        check = task.check(folder, answer)
-    except Exception as e:  # a check must never crash the benchmark
-        check = Check(False, f"check failed: {type(e).__name__}: {e}")
-    if keep:
-        (folder / "lcode-bench.log").write_text(log.file.getvalue() if isinstance(log.file, io.StringIO) else "")
-    else:
-        shutil.rmtree(folder, ignore_errors=True)
+        for rel, content in task.files.items():
+            (folder / rel).parent.mkdir(parents=True, exist_ok=True)
+            (folder / rel).write_text(content)
+        agent = Agent(ollama, settings, folder, console=log)
+        error = None
+        started = time.monotonic()
+        try:
+            with time_limit(timeout):
+                agent.run_turn(task.prompt)
+        except TaskTimeout:
+            error = f"timed out after {timeout:.0f}s"
+        except OllamaError as e:
+            error = str(e).splitlines()[0][:200]
+        seconds = time.monotonic() - started
+        for key, value in agent.usage.items():
+            usage[key] = usage.get(key, 0) + value
+        answer = next((m.get("content", "") for m in reversed(agent.messages) if m.get("role") == "assistant"), "")
+        try:
+            check = task.check(folder, answer)
+        except Exception as e:  # a check must never crash the benchmark
+            check = Check(False, f"check failed: {type(e).__name__}: {e}")
+    finally:  # also when Ctrl+C stops the task
+        if keep:
+            (folder / "lcode-bench.log").write_text(log.file.getvalue() if isinstance(log.file, io.StringIO) else "")
+        else:
+            shutil.rmtree(folder, ignore_errors=True)
     return TaskResult(
         id=task.id,
         passed=check.passed and error is None,
@@ -1010,7 +1012,7 @@ def summary_rows(runs: list[ModelRun], tasks: list[Task]) -> list[tuple[str, lis
         return "—" if run.error else value
 
     rows += [
-        ("Passed", [cell(r, f"{r.passed}/{len(r.tasks)}") for r in runs]),
+        ("Passed", [cell(r, f"{r.passed}/{len(r.tasks)}" + (" (stopped)" if r.interrupted else "")) for r in runs]),
         ("Time", [cell(r, duration(r.seconds)) for r in runs]),
         ("Generation", [cell(r, f"{r.generation_tps:.1f} tok/s" if r.generation_tps else "?") for r in runs]),
         ("Prompt reading", [cell(r, f"{r.prompt_tps:,.0f} tok/s" if r.prompt_tps else "?") for r in runs]),