lcode-cli 0.17.0__tar.gz → 0.19.0__tar.gz

{lcode_cli-0.17.0 → lcode_cli-0.19.0}/CHANGELOG.md

@@ -6,6 +6,37 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [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
+
+- `lcode -p "…" --output json` prints one result object (status, answer, tool calls, files
+  changed, token usage); `--output stream-json` prints an event per model step and tool result,
+  then the result. `--max-steps` and `--allowed-tools` limit a run, and the exit code says how it
+  ended. Without a person to ask, anything that needs permission is refused.
+- A Python API: `from lcode import Session`, with `run()`, `stream()` and an `approve` callback
+  for permission requests. See `examples/api/fix_tests.py`.
+- A GitHub Action for self-hosted runners (`uses: nasser1941/lcode@v0.18.0`). It answers `@lcode`
+  in issues and pull requests from the repository's owners, members and collaborators, proposes
+  changes as a pull request (or pushes them to the pull request's branch), and can review pull
+  requests. See [Automation](https://nasser1941.github.io/lcode/automation/).
+
 ## [0.17.0] - 2026-10-06
 
 ### Added
@@ -419,7 +450,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.17.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.19.0...HEAD
+[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
 [0.15.0]: https://github.com/nasser1941/lcode/compare/v0.14.0...v0.15.0

{lcode_cli-0.17.0 → lcode_cli-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.17.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,11 @@ 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.
 - **Bring your own model.** Eight curated open-weight models, all tested end to end, or any Ollama model
   with tool calling. Or use LM Studio, llama.cpp, vLLM or MLX instead of Ollama.
 - **MCP servers, ready to go.** Connect Jira and Confluence, GitHub, AWS, Google Drive, Grafana,
@@ -211,8 +216,7 @@ 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:
 
-- [Automation: JSON output, a Python API and a GitHub Action for self-hosted runners](https://github.com/nasser1941/lcode/issues/48)
-- [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.17.0 → lcode_cli-0.19.0}/README.md

@@ -68,6 +68,11 @@ 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.
 - **Bring your own model.** Eight curated open-weight models, all tested end to end, or any Ollama model
   with tool calling. Or use LM Studio, llama.cpp, vLLM or MLX instead of Ollama.
 - **MCP servers, ready to go.** Connect Jira and Confluence, GitHub, AWS, Google Drive, Grafana,
@@ -175,8 +180,7 @@ 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:
 
-- [Automation: JSON output, a Python API and a GitHub Action for self-hosted runners](https://github.com/nasser1941/lcode/issues/48)
-- [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.19.0/action.yml

@@ -0,0 +1,79 @@
+name: lcode
+description: Answer @lcode in issues and pull requests, propose changes and review pull requests, with an open-weight model on your own self-hosted runner.
+author: nasser1941
+branding:
+  icon: terminal
+  color: gray-dark
+
+inputs:
+  model:
+    description: The model to use (default, the runner's lcode configuration)
+    required: false
+    default: ""
+  trigger:
+    description: The word that calls lcode in a comment
+    required: false
+    default: "@lcode"
+  review:
+    description: Review pull requests when they're opened or updated ("true" or "false")
+    required: false
+    default: "false"
+  review-forks:
+    description: Also review pull requests from forks; their code runs through lcode's tools on your runner
+    required: false
+    default: "false"
+  author-associations:
+    description: Who can call lcode, by their association with the repository
+    required: false
+    default: "OWNER,MEMBER,COLLABORATOR"
+  permission-mode:
+    description: auto-edit (file changes, no shell commands except allow-commands) or yolo (anything; only on an isolated runner)
+    required: false
+    default: "auto-edit"
+  allow-commands:
+    description: Shell commands the model may run, one per line or comma-separated, with * wildcards (e.g. "pytest*, npm test")
+    required: false
+    default: ""
+  max-steps:
+    description: Model steps per request before lcode stops
+    required: false
+    default: "60"
+  lcode-version:
+    description: The lcode version to run (default, the one matching this action's tag)
+    required: false
+    default: ""
+  github-token:
+    description: Token for comments, pull requests and pushes
+    required: false
+    default: ${{ github.token }}
+
+runs:
+  using: composite
+  steps:
+    - name: Run lcode
+      shell: bash
+      env:
+        GITHUB_TOKEN: ${{ inputs.github-token }}
+        LCODE_MODEL: ${{ inputs.model }}
+        LCODE_TRIGGER: ${{ inputs.trigger }}
+        LCODE_REVIEW: ${{ inputs.review }}
+        LCODE_REVIEW_FORKS: ${{ inputs.review-forks }}
+        LCODE_ASSOCIATIONS: ${{ inputs.author-associations }}
+        LCODE_PERMISSION_MODE: ${{ inputs.permission-mode }}
+        LCODE_ALLOW_COMMANDS: ${{ inputs.allow-commands }}
+        LCODE_MAX_STEPS: ${{ inputs.max-steps }}
+        LCODE_VERSION: ${{ inputs.lcode-version }}
+        ACTION_REF: ${{ github.action_ref }}
+      run: |
+        version="${LCODE_VERSION:-${ACTION_REF#v}}"
+        spec="lcode-cli"
+        if [[ "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then spec="lcode-cli==$version"; fi
+        if command -v uvx > /dev/null; then
+          uvx --from "$spec" lcode action
+        elif command -v lcode > /dev/null; then
+          lcode action
+        else
+          python3 -m venv "$RUNNER_TEMP/lcode-venv"
+          "$RUNNER_TEMP/lcode-venv/bin/pip" install --quiet "$spec"
+          "$RUNNER_TEMP/lcode-venv/bin/lcode" action
+        fi

lcode_cli-0.19.0/docs/automation.md

@@ -0,0 +1,193 @@
+# Automation
+
+lcode can also run without a person at the keyboard:
+- **Scripts and CI** get structured results from `lcode -p`.
+- **Programs** use it from Python.
+- **A GitHub Action** answers `@lcode` in issues and pull requests on your own GPU machine.
+
+In all three, nothing waits for an answer: anything that would need your permission is refused,
+unless the permission mode, a [permission rule](hooks.md#permission-rules) or your program allows it.
+
+## Structured output
+
+```bash
+lcode -p "Fix the failing test in tests/test_parser.py" --auto-edit --output json
+lcode -p "Explain the retry logic" --output stream-json --max-steps 20
+```
+
+| Option | |
+|---|---|
+| `--output json` | One JSON object when the request is done |
+| `--output stream-json` | One JSON event per line as the request runs, ending with the same result object |
+| `--max-steps N` | Stop after N model steps (status `max_steps`) |
+| `--allowed-tools LIST` | Only these tools, e.g. `"read_file,grep,glob,bash"` |
+
+lcode's usual output goes to stderr, so stdout holds only the JSON. The exit code says how it
+went: `0` success, `1` an error, `3` stopped at `--max-steps`, `130` interrupted.
+
+### The result
+
+```json
+{
+  "type": "result",
+  "schema": 1,
+  "lcode": "0.18.0",
+  "status": "success",
+  "text": "Two bugs fixed in `calc.py`: …",
+  "session_id": "20261006-101503-7f3a",
+  "model": "lcode-qwen3.6-35b",
+  "tool_calls": [
+    {"id": "call_ab9fmzq1", "name": "read_file", "arguments": {"path": "calc.py"}, "error": false, "output": "…"},
+    {"id": "call_lhhyt2jn", "name": "bash", "arguments": {"command": "pytest -q"}, "error": true, "output": "This needs the user's permission, …"}
+  ],
+  "files_changed": [{"status": "M", "path": "calc.py"}],
+  "usage": {"requests": 6, "prompt_tokens": 35092, "output_tokens": 942},
+  "seconds": 30.67,
+  "error": ""
+}
+```
+
+| Field | |
+|---|---|
+| `status` | `success`, `error`, `max_steps` or `interrupted` |
+| `text` | The model's final answer |
+| `tool_calls` | Every tool call, with its arguments and output (the first 4,000 characters). `error` is true when the call failed or wasn't allowed |
+| `files_changed` | Files the request added (`A`), modified (`M`) or deleted (`D`), shell commands included |
+| `usage` | Model requests and tokens; `prompt_tokens` includes tokens served from the prompt cache |
+| `error` | What went wrong, when `status` is `error` |
+| `session_id` | Continue the conversation later with `lcode --resume <id>` |
+
+A failure before the request starts (no model server, an unknown model) prints
+`{"type": "result", "status": "error", "error": "…"}` and exits with `1`.
+
+### The events (stream-json)
+
+```json
+{"type": "start", "schema": 1, "lcode": "0.18.0", "session_id": "…", "model": "lcode-qwen3.6-35b", "cwd": "/src/app"}
+{"type": "assistant", "text": "", "tool_calls": [{"id": "call_1", "name": "read_file", "arguments": {"path": "calc.py"}}]}
+{"type": "tool_result", "id": "call_1", "name": "read_file", "error": false, "output": "…"}
+{"type": "assistant", "text": "The bug is in clamp(): …", "tool_calls": []}
+{"type": "result", "status": "success", …}
+```
+
+An `assistant` event comes after each model step; a `tool_result` follows each of its calls, with
+the same `id`.
+
+## Python
+
+```python
+from lcode import Session
+
+with Session("path/to/repo", permission_mode="auto-edit") as session:
+    result = session.run("Fix the failing test in tests/test_parser.py")
+    print(result.status, result.text)
+    for change in result.files_changed:
+        print(change["status"], change["path"])
+```
+
+- **A session is one conversation:** each `run` continues it.
+- **Events while it runs:** `session.stream(prompt)` yields the events above, ending with the result.
+- **Permissions:** pass `approve` to decide permission requests. It gets
+  `{"kind": "bash", "title": "…", "target": "pytest -q"}`; without it, every request is refused.
+- **Options:** `model`, `context`, `permission_mode`, `allowed_tools`, `max_steps`, `think`,
+  `web`, `memory`, `mcp` and `sandbox`. Leave one out to use your
+  [configuration](configuration.md).
+- **lcode's own output:** `verbose=True` shows it on stderr.
+- **When lcode can't start** (no model server, a missing model): `lcode.SetupError`.
+
+[`examples/api/fix_tests.py`](https://github.com/nasser1941/lcode/blob/main/examples/api/fix_tests.py)
+runs a repository's tests, lets the model fix what fails and approves only the test command:
+
+```text
+$ python examples/api/fix_tests.py ~/src/calc
+✓ read_file:      1	def average(values):
+✓ bash: ============================= test session starts ==============================
+✓ edit_file: Edited calc.py (1 replacement(s)). Result:
+✓ edit_file: Edited calc.py (1 replacement(s)). Result:
+✓ bash: ============================= test session starts ==============================
+
+success in 22s, 5 model requests
+  M calc.py
+```
+
+## GitHub Action
+
+The action runs lcode on a **self-hosted runner**, a machine of yours with a GPU and Ollama (or
+[another model server](servers.md)). The code and the model stay on that machine; only the
+replies and the commits go to GitHub.
+
+- **Someone comments `@lcode …`** on an issue or a pull request. lcode reacts with 👀, does what
+  they ask and replies.
+  - When it changed files on an **issue**, it commits them to a new branch and opens a pull
+    request that closes the issue.
+  - On a **pull request**, it pushes the commit to that pull request's branch.
+- **With `review: true`**, every new or updated pull request gets a review as a comment.
+
+```yaml
+# .github/workflows/lcode.yml
+name: lcode
+on:
+  issue_comment:
+    types: [created]
+  pull_request:
+    types: [opened, synchronize]
+
+permissions:
+  contents: write
+  issues: write
+  pull-requests: write
+
+jobs:
+  lcode:
+    if: github.event_name == 'pull_request' || contains(github.event.comment.body, '@lcode')
+    runs-on: [self-hosted, gpu]
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - uses: nasser1941/lcode@v0.18.0
+        with:
+          review: true
+          allow-commands: "pytest*, npm test"
+```
+
+| Input | Default | |
+|---|---|---|
+| `model` | the runner's config | The model to use |
+| `trigger` | `@lcode` | The word that calls lcode in a comment |
+| `review` | `false` | Review pull requests when they're opened or updated |
+| `review-forks` | `false` | Also review pull requests from forks |
+| `author-associations` | `OWNER,MEMBER,COLLABORATOR` | Who can call lcode |
+| `permission-mode` | `auto-edit` | `auto-edit`: file changes, and only the shell commands in `allow-commands`. `yolo`: anything |
+| `allow-commands` | | Shell commands the model may run, with `*` wildcards |
+| `max-steps` | `60` | Model steps per request |
+| `lcode-version` | the action's | The lcode version to run |
+
+### Setting up the runner
+
+1. [Add a self-hosted runner](https://docs.github.com/en/actions/hosting-your-own-runners/managing-self-hosted-runners/adding-self-hosted-runners)
+   to the repository, and give it a label such as `gpu`.
+2. On that machine, as the runner's user, install lcode and a model:
+   `curl -fsSL https://nasser1941.github.io/lcode/install.sh | bash`. The action runs lcode with
+   [uv](https://docs.astral.sh/uv/) when it's there, otherwise with the `lcode` it finds, otherwise
+   it installs lcode with pip.
+3. Settings and [permission rules](hooks.md#permission-rules) for the action go in that user's
+   `~/.config/lcode/config.toml`. A repository's own `.lcode/settings.toml` isn't used, because
+   nobody approved it on the runner.
+
+### Safety
+
+- **Who can trigger it.** Only people with an owner, member or collaborator association, and
+  never bots.
+- **Other people's text.** The issue's description and the code may have been written by anyone.
+  lcode tells the model to treat instructions in them as information, but a model can still be
+  talked into things. Keep `permission-mode: auto-edit` with a short `allow-commands` list,
+  unless the runner is isolated and disposable.
+- **Forks.** Pull requests from forks aren't reviewed unless you set `review-forks`: their code
+  would run through lcode's tools on your machine.
+- **Git.** lcode does the git steps itself: the model can't commit, push or switch branches, and
+  commits are made as `lcode`.
+- **Public repositories.** GitHub
+  [advises against](https://docs.github.com/en/actions/security-for-github-actions/security-guides/security-hardening-for-github-actions#hardening-for-self-hosted-runners)
+  self-hosted runners for public repositories, since anyone can open a pull request. Use the
+  action on private repositories, or on a runner you can afford to lose.

lcode_cli-0.19.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.17.0 → lcode_cli-0.19.0}/docs/quickstart.md

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

{lcode_cli-0.17.0 → lcode_cli-0.19.0}/docs/usage.md

@@ -10,11 +10,15 @@ 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 |
 |---|---|
 | `-p, --prompt TEXT` | Run one request non-interactively, print the result and exit |
+| `--output json\|stream-json` | With `-p`: print a JSON result, or a JSON event per line ([Automation](automation.md)) |
+| `--max-steps N` | Stop a request after N model steps |
+| `--allowed-tools LIST` | Only these tools, e.g. `"read_file,grep,glob,bash"` |
 | `-m, --model NAME` | Catalog key (see `lcode models`) or any installed Ollama model |
 | `--context SIZE` | Context window, e.g. `65536`, `128k`, `1m` |
 | `-r, --repo DIR` | Work in another directory |

{lcode_cli-0.17.0 → lcode_cli-0.19.0}/examples/README.md

@@ -7,6 +7,7 @@ them everywhere):
 |---|---|---|
 | [`commands/review.md`](commands/review.md) | `.lcode/commands/review.md` | `/review` or `/review the parser` |
 | [`skills/commit-message/`](skills/commit-message/) | `.lcode/skills/commit-message/` | ask for a commit message, or `/commit-message` |
+| [`api/fix_tests.py`](api/fix_tests.py) | anywhere | `python fix_tests.py path/to/repo`: lcode from Python ([Automation](https://nasser1941.github.io/lcode/automation/)) |
 
 ```bash
 mkdir -p .lcode/commands .lcode/skills

lcode_cli-0.19.0/examples/api/fix_tests.py

@@ -0,0 +1,37 @@
+"""Fix a repository's failing tests with lcode, from Python.
+
+    python fix_tests.py path/to/repo
+
+lcode may edit files, and run the test command only: every other shell command is refused,
+because nobody is there to ask.
+"""
+
+import sys
+
+from lcode import Session
+
+TEST_COMMANDS = ("pytest", "python -m pytest", "python3 -m pytest")
+
+
+def approve(request: dict) -> bool:
+    return request["kind"] == "bash" and request["target"].startswith(TEST_COMMANDS)
+
+
+def main() -> int:
+    repo = sys.argv[1] if len(sys.argv) > 1 else "."
+    with Session(repo, permission_mode="auto-edit", approve=approve, max_steps=40) as session:
+        for event in session.stream("Run the tests, fix the code until they pass, and run them again."):
+            if event["type"] == "tool_result":
+                mark = "✗" if event["error"] else "✓"
+                print(f"{mark} {event['name']}: {event['output'].splitlines()[0][:80] if event['output'] else ''}")
+            elif event["type"] == "result":
+                print(f"\n{event['status']} in {event['seconds']:.0f}s, {event['usage']['requests']} model requests")
+                for change in event["files_changed"]:
+                    print(f"  {change['status']} {change['path']}")
+                print(f"\n{event['text']}")
+                return 0 if event["status"] == "success" else 1
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{lcode_cli-0.17.0 → lcode_cli-0.19.0}/mkdocs.yml

@@ -96,6 +96,8 @@ nav:
       - Subagents: agents.md
       - 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.17.0 → lcode_cli-0.19.0}/pyproject.toml

@@ -85,6 +85,8 @@ ignore = [
 "src/lcode/bench_backend.py" = ["E501"]
 "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.19.0/src/lcode/__init__.py

@@ -0,0 +1,16 @@
+"""lcode — a local-first terminal coding agent powered by open-weight models via Ollama.
+
+From a program: `from lcode import Session` (see lcode.api).
+"""
+
+__version__ = "0.19.0"
+
+API = ("Session", "Result", "Options", "SetupError")
+
+
+def __getattr__(name: str):
+    if name in API:  # loaded on first use, so `import lcode` stays fast
+        from lcode import api
+
+        return getattr(api, name)
+    raise AttributeError(f"module 'lcode' has no attribute {name!r}")