lcode-cli 0.29.0__tar.gz → 0.31.0__tar.gz

{lcode_cli-0.29.0 → lcode_cli-0.31.0}/CHANGELOG.md

@@ -6,6 +6,35 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.31.0] - 2026-10-14
+
+### Added
+
+- A task sheet that survives long sessions. The plan (the todo list), the model's notes (decisions,
+  findings, open questions, kept in `todo_write`'s new `notes`, or inside a todo item, where small
+  models tend to put them), the files changed and the last check are pinned next to the summary and
+  next to your request when old output is removed. It's saved with the session, so `lcode -c`
+  brings it back (the todo list used to be lost), and `/status` shows it. See
+  [Context management](https://nasser1941.github.io/lcode/how-it-works/#context-management).
+
+## [0.30.0] - 2026-10-13
+
+### Added
+
+- Edits that the model copied imperfectly land where they belong instead of failing: line numbers
+  copied from `read_file`, stray escapes, a block at the wrong indentation or spaces for tabs (the new
+  text is re-indented), dropped blank lines, and very close matches. A close match changes only the
+  lines the model meant to change, so an earlier edit its copy doesn't show survives. Ambiguous or
+  weak matches are refused, and the model is shown the closest lines with their numbers. See
+  [Imperfect edits](https://nasser1941.github.io/lcode/usage/#imperfect-edits).
+- `apply_patch`: the model can apply a unified diff to several files at once. Hunks are found by
+  their text, so wrong `@@` line numbers don't matter, and a file changes only if every hunk fits.
+- Common tool slips get a useful answer instead of an error: a `grep` pattern that isn't a valid regex
+  (`def add(`) is searched as plain text, a path that doesn't exist comes back with the closest
+  existing ones (`Did you mean: src/pkg/math_utils.py?`), `read_file` on a folder lists it, and
+  `list_dir` on a file says to read it.
+- `lcode bench --json` breaks failed tool calls down by tool (`errors_by_tool`).
+
 ## [0.29.0] - 2026-10-13
 
 ### Added
@@ -650,7 +679,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.29.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.31.0...HEAD
+[0.31.0]: https://github.com/nasser1941/lcode/compare/v0.30.0...v0.31.0
+[0.30.0]: https://github.com/nasser1941/lcode/compare/v0.29.0...v0.30.0
 [0.29.0]: https://github.com/nasser1941/lcode/compare/v0.28.1...v0.29.0
 [0.28.1]: https://github.com/nasser1941/lcode/compare/v0.28.0...v0.28.1
 [0.28.0]: https://github.com/nasser1941/lcode/compare/v0.27.0...v0.28.0

{lcode_cli-0.29.0 → lcode_cli-0.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.29.0
+Version: 0.31.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/

{lcode_cli-0.29.0 → lcode_cli-0.31.0}/docs/how-it-works.md

@@ -97,6 +97,16 @@ context is old tool output, so:
    findings, files changed, next steps) and continues from it. Your latest requests (up to eight)
    are kept word for word under the summary, so the goal isn't lost in the retelling.
 
+**The task sheet.** Next to the summary, and next to your request when old tool output is removed,
+lcode pins a short sheet, so the state of the work survives:
+
+- the plan (the model's todo list);
+- the notes the model keeps with it (decisions and why, findings, open questions);
+- the files changed in the session;
+- the last check.
+
+It's saved with the session, so `lcode -c` brings it back, and `/status` shows it to you.
+
 `lcode config set compact_at 128k` moves the ceiling, and `0` turns it off, leaving only the 85%
 rule. `/context` shows where the current session makes room.
 

{lcode_cli-0.29.0 → lcode_cli-0.31.0}/docs/quickstart.md

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

{lcode_cli-0.29.0 → lcode_cli-0.31.0}/docs/usage.md

@@ -80,6 +80,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 |
+| `/status` | The task sheet: your latest requests, the plan and the model's notes, files changed, the last check |
 | `/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 |
@@ -92,13 +93,14 @@ reasoning is on.
 |---|---|
 | `read_file` | Read a file with line numbers (paged for large files) |
 | `write_file` | Create or overwrite a file (shows a preview or diff) |
-| `edit_file` | Replace an exact snippet in a file (shows a diff); tolerates trailing-whitespace differences |
+| `edit_file` | Replace a snippet in a file (shows a diff); [forgiving](#imperfect-edits) when the model copies it imperfectly |
+| `apply_patch` | Apply a unified diff (as `git diff` writes it) to one or more files; hunks are found by their text |
 | `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; 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 |
+| `todo_write` | Keep a visible task list for multi-step work, with notes (decisions, findings) that survive when old messages are removed; `/status` shows them |
 | `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 |
 | `view_image` | Look at an image: a model that can see describes it ([Images](#images)) |
@@ -113,6 +115,34 @@ 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.
 
+### Imperfect edits
+
+Small models copy text imperfectly, and an edit that doesn't match exactly used to fail, often again
+and again. When the text isn't in the file exactly, lcode tries, in order:
+
+- **Copying slips:** removing the line numbers `read_file` shows, and undoing stray escapes such
+  as `\"`.
+- **Looser line matches:** comparing lines without trailing spaces, then without indentation (a block
+  at the wrong level, or spaces where the file has tabs). The new text is re-indented to fit.
+- **Blank lines:** ignoring blank lines the model dropped or added.
+- **A very close match:** at least 90% alike, and clearly better than any other place. Only the lines
+  the model meant to change are changed, so an earlier edit that the model's copy doesn't show is
+  kept. If a changed line differs in the file by more than a typo, the edit is refused.
+
+The result says how it matched (`Edited config.py (1 replacement(s), ignoring indentation)`), and the
+diff shows the change as usual. A match that's ambiguous or too weak is never applied. Instead, the
+model gets the closest lines with their numbers, so it can copy them exactly. `apply_patch` places
+each hunk the same way, so wrong `@@` line numbers don't matter, and it changes a file only if every
+hunk fits.
+
+Other common slips get a useful answer instead of a bare error:
+
+- **A pattern that isn't a valid regex** (`grep "def add("`) is searched as plain text, and the result
+  says so.
+- **A path that doesn't exist** comes back with the closest existing ones: the same file name
+  elsewhere in the project, or a near name in the folder (`Did you mean: src/pkg/math_utils.py?`).
+- **`read_file` on a folder** lists it, and **`list_dir` on a file** says to read it.
+
 ## Checks before done
 
 Small models like to call work done after a syntax check. So after a request that changed files, lcode

{lcode_cli-0.29.0 → lcode_cli-0.31.0}/pyproject.toml

@@ -82,7 +82,8 @@ ignore = [
 "src/lcode/context.py" = ["E501"]
 "src/lcode/lsp.py" = ["E501"]
 "src/lcode/repomap.py" = ["E501"]
-"src/lcode/bench_runtime.py" = ["E501"] # the task's files and hidden test
+"src/lcode/bench_runtime.py" = ["E501"]
+"tests/test_matching.py" = ["E501"] # file contents as test data # the task's files and hidden test
 "src/lcode/codesearch.py" = ["E501"]
 "src/lcode/bench_backend.py" = ["E501"]
 "src/lcode/backends.py" = ["E501"]

{lcode_cli-0.29.0 → lcode_cli-0.31.0}/src/lcode/__init__.py

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

{lcode_cli-0.29.0 → lcode_cli-0.31.0}/src/lcode/acp.py

@@ -44,7 +44,7 @@ MODES = [
 ]
 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",
+    "repo_map": "search", "search_code": "search", "lsp": "search", "edit_file": "edit", "write_file": "edit", "apply_patch": "edit",
     "bash": "execute", "web_search": "fetch", "web_fetch": "fetch", "agent": "think", "todo_write": "think",
     "present_plan": "switch_mode", "bash_output": "read", "bash_stop": "execute",
 }  # fmt: skip

{lcode_cli-0.29.0 → lcode_cli-0.31.0}/src/lcode/agent.py

@@ -112,7 +112,7 @@ SYSTEM_PROMPT = """You are lcode, an autonomous software-engineering agent runni
 - To understand a repository: look at the layout, README/docs, entry points and config, then grep and read the relevant files. Cite code as `path:line`.
 - Read a file before editing it. Use edit_file for targeted changes and write_file for new files or full rewrites. old_string must be copied exactly from the file (without the line-number prefixes).
 - Match the existing code style, naming and structure. Don't add unrequested features.
-- For multi-step tasks, plan with todo_write and keep it updated.
+- For multi-step tasks, plan with todo_write and keep it updated; put decisions and findings you must not lose in its notes.
 - Work autonomously until the task is done. Only stop to ask the user when you are genuinely blocked or the decision is theirs.
 - Don't run destructive or irreversible commands (rm -rf, git reset --hard, git push --force, dropping data) unless the user explicitly asked.
 - If the user denies a tool call, don't retry the same thing; adjust or ask.
@@ -613,6 +613,9 @@ class Agent:
             "title": self.session_title,
             "messages": self.messages,
             "checkpoints": self.checkpoints.to_json(),
+            "todos": self.tools.todos,
+            "notes": self.tools.notes,
+            "changed": list(self.tools.changed),
         }
         # Written next to it and then renamed: a crash halfway leaves the previous version, not a broken file.
         partial = f.with_name(f".{f.name}.partial")
@@ -626,6 +629,8 @@ class Agent:
         self.session_name = ""
         self.session_title = ""
         self.checkpoints.reset(self.session_id)
+        self.tools.todos, self.tools.notes, self.tools.changed = [], [], {}
+        self.check_results = []
 
     def rename(self, name: str) -> None:
         self.session_name = " ".join(name.split())
@@ -652,6 +657,9 @@ class Agent:
         self.session_name = data.get("name", "")
         self.session_title = data.get("title") or sessions.title_from(self.messages)
         self.tools.read_mtimes.clear()  # files may have changed since; the model must read them again
+        self.tools.todos = list(data.get("todos") or [])
+        self.tools.notes = [str(n) for n in data.get("notes") or []]
+        self.tools.changed = dict.fromkeys(str(f) for f in data.get("changed") or [])
         self.reflected = len(self.messages)  # checked for notes to remember when that session ended
         self.ctx_used = sum(len(json.dumps(m)) for m in self.messages) // 3
         self.counted_chars = None
@@ -1134,7 +1142,7 @@ class Agent:
                     )
                     if verdict.stop:
                         looping = self.describe_call(name, args)
-                if name in ("edit_file", "write_file") and not result.startswith(REFUSED):
+                if name in ("edit_file", "write_file", "apply_patch") and not result.startswith(REFUSED):
                     changed, verified = True, False
                 elif name == "bash" and changed and self.model_ran_checks(str(args.get("command", "")), result):
                     verified = True  # the model ran the checks itself, after its last change
@@ -1289,6 +1297,8 @@ class Agent:
                     self.messages, keep=1, removed=removed
                 )  # not enough: before the last request
             context_tools.note_removed(self.messages, removed)
+            if saved:
+                context_tools.pin(self.messages, context_tools.task_sheet(self))
             if saved:
                 self.sent_chars = 0  # the conversation changed: the model reads it again
                 self.pruned += 1
@@ -1333,7 +1343,9 @@ class Agent:
             {"role": "system", "content": self.system_prompt()},
             {
                 "role": "user",
-                "content": f"{sessions.SUMMARY_PREFIX}\n\n{summary}" + context_tools.requests_block(requests),
+                "content": f"{sessions.SUMMARY_PREFIX}\n\n{summary}"
+                + context_tools.requests_block(requests)
+                + (f"\n\n{sheet}" if (sheet := context_tools.task_sheet(self)) else ""),
             },
             {"role": "assistant", "content": "Got it — I have the context from the summary and will continue."},
         ]

{lcode_cli-0.29.0 → lcode_cli-0.31.0}/src/lcode/bench.py

@@ -789,6 +789,7 @@ class TaskResult:
     steps: int = 0  # model responses
     tool_errors: int = 0  # failed tool calls, including malformed ones
     error: str | None = None  # why the run stopped early: a timeout or an Ollama error
+    errors_by_tool: dict[str, int] = field(default_factory=dict)  # which tools failed, "malformed" for unreadable calls
 
 
 @dataclass
@@ -861,14 +862,20 @@ class Elapsed:
         return Text(f"{self.label}  {time.monotonic() - self.start:.0f}s", style="dim")
 
 
+def errors_by_tool(messages: list[dict]) -> dict[str, int]:
+    """Failed tool calls by tool, and "malformed" for calls the model wrote unreadably."""
+    counts: dict[str, int] = {}
+    for m in messages:
+        if m.get("role") == "tool" and m.get("content", "").startswith("Error:"):
+            name = m.get("tool_name") or "?"
+            counts[name] = counts.get(name, 0) + 1
+        elif m.get("role") == "user" and m.get("content", "").startswith("[lcode] Your last tool call"):
+            counts["malformed"] = counts.get("malformed", 0) + 1
+    return counts
+
+
 def count_tool_errors(messages: list[dict]) -> int:
-    failed = sum(1 for m in messages if m.get("role") == "tool" and m.get("content", "").startswith("Error:"))
-    malformed = sum(
-        1
-        for m in messages
-        if m.get("role") == "user" and m.get("content", "").startswith("[lcode] Your last tool call")
-    )
-    return failed + malformed
+    return sum(errors_by_tool(messages).values())
 
 
 def run_task(
@@ -933,6 +940,7 @@ def run_task(
         detail=error or check.detail,
         steps=agent.usage["requests"] - before.get("requests", 0),
         tool_errors=count_tool_errors(agent.messages[first:] if len(agent.messages) > first else agent.messages),
+        errors_by_tool=errors_by_tool(agent.messages[first:] if len(agent.messages) > first else agent.messages),
         error=error,
     )
 

{lcode_cli-0.29.0 → lcode_cli-0.31.0}/src/lcode/context.py

@@ -49,7 +49,9 @@ REQUESTS_HEADER = "[The user's requests in this conversation, word for word, old
 MAX_REQUESTS = 8  # the most recent ones are kept through a summary
 MAX_REQUEST_CHARS = 1500
 # What lcode appends to the user's words: attached files, images and folders, and its own notes.
-ATTACHED = re.compile(r"\n\n(?:<file path=|<image path=|<directory path=|\[lcode[:\]] |\[The user wants the )")
+ATTACHED = re.compile(
+    r"\n\n(?:<file path=|<image path=|<directory path=|\[lcode[:\]] |\[The user wants the )"
+)  # also the sheet
 
 
 def request_text(content: str) -> str:
@@ -187,6 +189,51 @@ def prune(messages: list[dict], keep: int = KEEP_RECENT_REQUESTS, removed: list[
     return saved
 
 
+SHEET_HEADER = "[lcode] Task sheet: the plan, notes and changes so far, kept when old messages are removed"
+MAX_SHEET = 3000  # characters
+
+
+def task_sheet(agent: Agent) -> str:
+    """The state of the work, from lcode's own records: the todo list and the model's notes (todo_write), the
+    files changed in the session and the last check. Pinned where old messages go: in summaries and next to the
+    request when tool output is removed."""
+    tools = agent.tools
+    parts = []
+    if tools.todos:
+        marks = {"completed": "[x]", "in_progress": "[>]", "pending": "[ ]"}
+        plan = "\n".join(f"{marks.get(t.get('status', ''), '[ ]')} {t.get('content', '')}" for t in tools.todos)
+        parts.append(f"Plan:\n{plan}")
+    if tools.notes:
+        parts.append("Notes:\n" + "\n".join(f"- {note}" for note in tools.notes))
+    if tools.changed:
+        files = list(tools.changed)
+        more = f" and {len(files) - 30} more" if len(files) > 30 else ""
+        parts.append("Files changed in this session: " + ", ".join(files[-30:]) + more)
+    if agent.check_results:
+        last = agent.check_results[-1]
+        code = last.get("exit_code")
+        state = "passed" if code == 0 else "didn't run" if code is None else f"failed (exit code {code})"
+        parts.append(f"Last check: `{last.get('command')}` {state}")
+    if not parts:
+        return ""
+    sheet = "\n\n".join(parts)
+    if len(sheet) > MAX_SHEET:
+        sheet = sheet[: MAX_SHEET - 20] + "\n[…cut]"
+    return f"{SHEET_HEADER}\n{sheet}"
+
+
+def pin(messages: list[dict], text: str) -> None:
+    """Put a note next to the request the model is working on, replacing an earlier sheet there."""
+    if not text:
+        return
+    for message in reversed(messages):
+        content = str(message.get("content", ""))
+        if message.get("role") == "user" and not content.startswith(("[lcode]", SUMMARY_PREFIX)):
+            content = content.split("\n\n" + SHEET_HEADER, 1)[0]
+            message["content"] = f"{content}\n\n{text}"
+            return
+
+
 def note_removed(messages: list[dict], removed: list[str]) -> None:
     """Tell the model, next to the request it's working on, which files it no longer has: a stub deep in the
     conversation is easy to overlook, and models then answer from memory instead of reading again."""

lcode_cli-0.31.0/src/lcode/matching.py

@@ -0,0 +1,287 @@
+"""Find where an edit goes when the model's text doesn't match the file exactly.
+
+Small models copy text imperfectly: with the line numbers `read_file` shows, with spaces where the file has
+tabs, a block at the wrong indentation, quotes still escaped, a blank line dropped, a letter wrong. An exact
+match fails and the model often repeats the same failing edit. So when the exact text isn't there, lcode tries,
+in order: removing line-number prefixes and stray escapes; comparing lines without trailing whitespace, without
+indentation (and re-indenting the new text to fit), without blank lines; and, last, a very close match. It
+only ever applies a match that is unique; anything ambiguous or weak is refused, with the closest lines and
+their numbers, so the model can copy them exactly.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from difflib import SequenceMatcher
+
+LINE_NUMBER = re.compile(r"^\s*\d+(?:\t|→| \| |: )")  # how read_file and other tools number lines
+CLOSE_ENOUGH = 0.9  # similarity a loose match needs
+CLEAR_LEAD = 0.05  # how much better than the next one it must be
+MAX_SIMILARITY_LINES = 20_000  # bigger files: no similarity search
+HINT_FLOOR = 0.5  # weaker candidates aren't worth showing
+
+
+@dataclass
+class Found:
+    text: str  # the file with the edit applied
+    how: str  # how the match was found, for the model ("ignoring indentation"); "" for an exact match
+    start_line: int  # first matched line, 1-based
+
+
+@dataclass
+class Miss:
+    reason: str  # "not found" or "ambiguous"
+    hint: str  # the closest lines, numbered, or ""
+
+
+def numbered(lines: list[str], start: int) -> str:
+    return "\n".join(f"{start + i:6}\t{line.rstrip(chr(10))}" for i, line in enumerate(lines))
+
+
+def strip_line_numbers(text: str) -> str | None:
+    lines = text.split("\n")
+    content = [line for line in lines if line.strip()]
+    if not content or not all(LINE_NUMBER.match(line) for line in content):
+        return None
+    return "\n".join(LINE_NUMBER.sub("", line, count=1) if line.strip() else line for line in lines)
+
+
+def unescape(text: str, file_text: str) -> str | None:
+    """`\\"`, `\\n` and `\\t` written literally, when the file doesn't contain them literally."""
+    changed = text
+    for literal, real in (('\\"', '"'), ("\\'", "'"), ("\\t", "\t")):
+        if literal in changed and literal not in file_text:
+            changed = changed.replace(literal, real)
+    if "\\n" in changed and "\n" not in changed and "\\n" not in file_text:
+        changed = changed.replace("\\n", "\n")
+    return changed if changed != text else None
+
+
+def indent_of(line: str) -> str:
+    return line[: len(line) - len(line.lstrip(" \t"))]
+
+
+def width(indent: str) -> int:
+    return len(indent.expandtabs(4))
+
+
+def reindent(new: str, old_lines: list[str], file_lines: list[str]) -> str:
+    """Move `new` from the old text's indentation to the file's, keeping its relative structure."""
+    old_first = next((line for line in old_lines if line.strip()), "")
+    file_first = next((line for line in file_lines if line.strip()), "")
+    new_first = next((line for line in new.split("\n") if line.strip()), "")
+    base_old, base_file = width(indent_of(old_first)), indent_of(file_first)
+    same_kind = ("\t" in base_file) == ("\t" in indent_of(new_first))
+    if base_old != width(base_file) and width(indent_of(new_first)) == width(base_file) and same_kind:
+        return new  # the model got the old text's indentation wrong but wrote the new text in the file's
+    old_steps = sorted({width(indent_of(line)) - base_old for line in old_lines if line.strip()} - {0})
+    step_old = next((s for s in old_steps if s > 0), 4)
+    tabs = "\t" in base_file or any(indent_of(line).startswith("\t") for line in file_lines if line.strip())
+    file_steps = sorted({width(indent_of(line)) - width(base_file) for line in file_lines if line.strip()} - {0})
+    unit = "\t" if tabs else " " * next((s for s in file_steps if s > 0), step_old)
+    out = []
+    for line in new.split("\n"):
+        if not line.strip():
+            out.append(line)
+            continue
+        levels = round((width(indent_of(line)) - base_old) / step_old)
+        lead = base_file + unit * levels if levels >= 0 else base_file[: max(0, len(base_file) + levels * len(unit))]
+        out.append(lead + line.lstrip(" \t"))
+    return "\n".join(out)
+
+
+def splice(lines: list[str], start: int, end: int, new: str) -> str:
+    """Replace lines[start:end] with `new`, keeping the line break the region ended with."""
+    ending = "\n" if lines[end - 1].endswith("\n") else ""
+    body = new.rstrip("\n")
+    return "".join(lines[:start]) + (body + ending if body else "") + "".join(lines[end:])
+
+
+def line_matches(file_lines: list[str], old_lines: list[str], key) -> list[int]:
+    n = len(old_lines)
+    wanted = [key(line) for line in old_lines]
+    return [i for i in range(len(file_lines) - n + 1) if [key(line) for line in file_lines[i : i + n]] == wanted]
+
+
+def locate(text: str, old: str, new: str) -> Found | Miss:
+    """Where `old` goes in `text`, when it isn't there exactly; with `new` in its place."""
+    # 1. Copying mistakes that leave the text itself right.
+    for fix, how in ((strip_line_numbers, "without the line numbers"), (unescape, "with the escapes undone")):
+        fixed = fix(old) if fix is strip_line_numbers else unescape(old, text)
+        if fixed is None:
+            continue
+        fixed_new = (fix(new) if fix is strip_line_numbers else unescape(new, text)) or new
+        if text.count(fixed) == 1:
+            start = text.index(fixed)
+            return Found(text.replace(fixed, fixed_new, 1), how, text.count("\n", 0, start) + 1)
+        old, new = fixed, fixed_new  # the looser steps below work on the fixed text
+    file_lines = text.splitlines(keepends=True)
+    old_lines = old.strip("\n").split("\n")
+    if not old_lines or not any(line.strip() for line in old_lines):
+        return Miss("not found", "")
+    plain = [line.rstrip("\r\n") for line in file_lines]
+    # 2. Line by line, looser each time.
+    for key, how, indent in (
+        (lambda s: s.rstrip(), "ignoring trailing spaces", False),
+        (lambda s: s.strip(), "ignoring indentation", True),
+    ):
+        hits = line_matches(plain, old_lines, key)
+        if len(hits) == 1:
+            i = hits[0]
+            region = plain[i : i + len(old_lines)]
+            body = reindent(new.strip("\n"), old_lines, region) if indent else new.strip("\n")
+            return Found(splice(file_lines, i, i + len(old_lines), body), how, i + 1)
+        if len(hits) > 1:
+            return Miss("ambiguous", "\n\n".join(numbered(plain[i : i + len(old_lines)], i + 1) for i in hits[:3]))
+    # Without blank lines: map the non-blank lines back to the file.
+    solid = [line for line in old_lines if line.strip()]
+    content = [(i, line) for i, line in enumerate(plain) if line.strip()]
+    keys = [line.strip() for _, line in content]
+    wanted = [line.strip() for line in solid]
+    hits = [j for j in range(len(keys) - len(wanted) + 1) if keys[j : j + len(wanted)] == wanted]
+    first, last = (content[hits[0]][0], content[hits[0] + len(wanted) - 1][0]) if len(hits) == 1 else (0, -1)
+    if len(hits) == 1 and last - first + 1 != len(old_lines):
+        body = reindent(new.strip("\n"), old_lines, plain[first : last + 1])
+        return Found(splice(file_lines, first, last + 1, body), "ignoring blank lines", first + 1)
+    # 3. A very close match of the same number of lines, clearly better than any other. Only the lines the model
+    #    changed change: the rest stays as the file has it now, so an earlier edit the model's copy doesn't show
+    #    survives. Where a changed line differs in the file by more than a typo, the edit is refused.
+    if len(plain) > MAX_SIMILARITY_LINES:
+        return Miss("not found", "")
+    n = len(old_lines)
+    target = "\n".join(line.strip() for line in old_lines)
+    scores = []
+    for j in range(len(plain) - n + 1):
+        if (old_lines[0].strip() and not plain[j].strip()) or (old_lines[-1].strip() and not plain[j + n - 1].strip()):
+            continue  # a window that starts or ends on a blank line where the model's text doesn't
+        window = "\n".join(line.strip() for line in plain[j : j + n])
+        matcher = SequenceMatcher(None, target, window, autojunk=False)
+        if matcher.real_quick_ratio() < HINT_FLOOR or matcher.quick_ratio() < HINT_FLOOR:
+            continue
+        scores.append((matcher.ratio(), j))
+    scores.sort(reverse=True)
+    if not scores or scores[0][0] < HINT_FLOOR:
+        return Miss("not found", "")
+    best, j = scores[0]
+    runner_up = scores[1][0] if len(scores) > 1 else 0.0
+    if best >= CLOSE_ENOUGH and best - runner_up >= CLEAR_LEAD:
+        merged = merge(old_lines, new.strip("\n").split("\n"), plain[j : j + n])
+        if merged is not None:
+            body = "\n".join(merged)
+            return Found(splice(file_lines, j, j + n, body), f"at a close match ({best:.0%} alike)", j + 1)
+    # To show the model where to look, compare line by line: one long line doesn't outweigh the rest.
+    hint = max(scores[:20], key=lambda score: line_by_line(old_lines, plain[score[1] : score[1] + n]))[1]
+    return Miss("not found", numbered(plain[hint : hint + n], hint + 1))
+
+
+def line_by_line(old: list[str], region: list[str]) -> float:
+    pairs = list(zip(old, region, strict=False))  # the region may end early, at the end of the file
+    return sum(SequenceMatcher(None, a.strip(), b.strip(), autojunk=False).ratio() for a, b in pairs) / len(pairs)
+
+
+def merge(old: list[str], new: list[str], region: list[str]) -> list[str] | None:
+    """Apply the model's change (old -> new) to the file's lines (`region`, aligned with `old`). None when a line
+    it changes differs in the file by more than a typo: the model's copy is out of date there."""
+    new = reindent("\n".join(new), old, region).split("\n")
+    out: list[str] = []
+    ops = SequenceMatcher(None, [line.strip() for line in old], [line.strip() for line in new], autojunk=False)
+    for tag, i1, i2, j1, j2 in ops.get_opcodes():
+        if tag == "equal":
+            out += region[i1:i2]  # as the file has them
+            continue
+        for k in range(i1, i2):
+            alike = SequenceMatcher(None, old[k].strip(), region[k].strip(), autojunk=False).ratio()
+            if old[k].strip() != region[k].strip() and alike < CLOSE_ENOUGH:
+                return None
+        out += new[j1:j2]
+    return out
+
+
+# ----------------------------------------------------------------------------- unified diffs
+
+
+@dataclass
+class Hunk:
+    header: str  # the @@ line, for messages
+    old: str  # its context and removed lines
+    new: str  # its context and added lines
+
+
+@dataclass
+class FilePatch:
+    path: str  # without a/ and b/
+    hunks: list[Hunk]
+    new_file: bool = False
+    deleted: bool = False
+
+
+def strip_prefix(path: str) -> str:
+    path = path.strip().split("\t")[0]
+    return path[2:] if path[:2] in ("a/", "b/") else path
+
+
+def parse_patch(patch: str) -> list[FilePatch]:
+    """A unified diff (as git diff writes it) as files and hunks. The @@ line numbers aren't trusted: hunks are
+    found by their text. Raises ValueError when it isn't a diff."""
+    files: list[FilePatch] = []
+    hunk: list[str] | None = None
+    current: FilePatch | None = None
+
+    def close() -> None:
+        nonlocal hunk
+        if hunk is not None and current is not None:
+            old = [line[1:] for line in hunk[1:] if line[:1] in (" ", "-")]
+            new = [line[1:] for line in hunk[1:] if line[:1] in (" ", "+")]
+            current.hunks.append(Hunk(hunk[0], "\n".join(old), "\n".join(new)))
+        hunk = None
+
+    lines = patch.replace("\r\n", "\n").split("\n")
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+        if line.startswith("--- ") and i + 1 < len(lines) and lines[i + 1].startswith("+++ "):
+            close()
+            old_path, new_path = line[4:], lines[i + 1][4:]
+            gone, born = old_path.strip() == "/dev/null", new_path.strip() == "/dev/null"
+            current = FilePatch(strip_prefix(old_path if born else new_path), [], new_file=gone, deleted=born)
+            files.append(current)
+            i += 2
+            continue
+        if line.startswith("@@") and current is not None:
+            close()
+            hunk = [line]
+        elif hunk is not None:
+            if line.startswith(("\\ No newline", "diff --git", "index ")):
+                pass
+            elif line == "" and i == len(lines) - 1:
+                pass  # the patch's own final newline
+            else:
+                hunk.append(line if line[:1] in (" ", "-", "+") else " " + line)  # a context line that lost its space
+        i += 1
+    close()
+    if not files or not any(f.hunks for f in files):
+        raise ValueError("no ---/+++ file headers with @@ hunks: write a unified diff, as git diff does")
+    return files
+
+
+def apply_hunks(text: str, hunks: list[Hunk]) -> tuple[str, list[str]]:
+    """Apply hunks one after another; returns the text and how each loose match was made. Raises ValueError
+    naming the hunk that can't be placed."""
+    notes = []
+    for n, hunk in enumerate(hunks, 1):
+        if not hunk.old.strip():
+            raise ValueError(f"hunk {n} ({hunk.header}) has no context lines to place it by")
+        count = text.count(hunk.old)
+        if count == 1:
+            text = text.replace(hunk.old, hunk.new, 1)
+            continue
+        if count > 1:
+            raise ValueError(f"hunk {n} ({hunk.header}) matches {count} places: add more context lines")
+        found = locate(text, hunk.old, hunk.new)
+        if isinstance(found, Miss):
+            where = f" The closest text is:\n{found.hint}" if found.hint else ""
+            raise ValueError(f"hunk {n} ({hunk.header}) doesn't match the file.{where}")
+        text = found.text
+        notes.append(f"hunk {n} {found.how}")
+    return text, notes

{lcode_cli-0.29.0 → lcode_cli-0.31.0}/src/lcode/repeats.py

@@ -82,7 +82,7 @@ class Repeats:
             )
         hint = (
             "If it's an edit, read the file again and copy the text exactly. "
-            if failed and name in ("edit_file", "write_file")
+            if failed and name in ("edit_file", "write_file", "apply_patch")
             else ""
         )
         return Verdict(
@@ -97,7 +97,7 @@ def changes_things(name: str, args: dict, result: str) -> bool:
     """Whether the call may have changed files (or anything else a later call could see)."""
     if name in UNCHANGING:
         return False
-    if name in ("edit_file", "write_file"):
+    if name in ("edit_file", "write_file", "apply_patch"):
         return not result.startswith(FAILED)
     if name == "bash":
         return not is_read_only(str(args.get("command", "")))