lcode-cli 0.29.0__py3-none-any.whl → 0.30.0__py3-none-any.whl

lcode/__init__.py

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

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/agent.py

@@ -1134,7 +1134,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

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/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/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", "")))

lcode/subagents.py

@@ -69,7 +69,7 @@ READ_ONLY_TOOLS = frozenset(
         "search_code",
     }
 )
-EDIT_TOOLS = frozenset({"write_file", "edit_file"})
+EDIT_TOOLS = frozenset({"write_file", "edit_file", "apply_patch"})
 NOT_FOR_SUBAGENTS = frozenset({"agent", "memory"})  # no agents inside agents; only the main session remembers
 MAX_STEPS = 200
 MAX_UNTRACKED_BYTES = 10 * 1024 * 1024  # larger untracked files aren't copied into a worker's worktree

lcode/tools.py

@@ -28,7 +28,7 @@ from rich.panel import Panel
 from rich.syntax import Syntax
 from rich.text import Text
 
-from lcode import secretscan, web
+from lcode import matching, secretscan, web
 from lcode.context import OutputSpool, shorten
 from lcode.jobs import JobError, describe, stop_leftovers
 from lcode.permissions import bash_key, is_read_only
@@ -96,6 +96,15 @@ SCHEMAS = [
         },
         ["path", "old_string", "new_string"],
     ),
+    _fn(
+        "apply_patch",
+        "Apply a unified diff to one or more files, as `git diff` writes it: `--- a/path` and `+++ b/path` "
+        "headers, then `@@` hunks of context lines (starting with a space), removed lines (-) and added lines (+). "
+        "Hunks are found by their text, so the @@ line numbers may be off; include 2-3 context lines around each "
+        "change. Use `--- /dev/null` for a new file. For a single change, edit_file is simpler.",
+        {"patch": {"type": "string", "description": "The unified diff"}},
+        ["patch"],
+    ),
     _fn(
         "list_dir",
         "Show a directory tree (skips .git, node_modules, virtualenvs and caches).",
@@ -375,22 +384,6 @@ def tree(base: Path, depth: int = 2, limit: int = 400) -> str:
     return "\n".join(lines)
 
 
-def fuzzy_replace(text: str, old: str, new: str) -> str | None:
-    """Replace `old` with `new` matching lines while ignoring trailing whitespace. None unless exactly one match."""
-    t_lines = text.splitlines(keepends=True)
-    o_lines = [line.rstrip() for line in old.strip("\n").splitlines()]
-    if not o_lines:
-        return None
-    n = len(o_lines)
-    matches = [i for i in range(len(t_lines) - n + 1) if [ln.rstrip() for ln in t_lines[i : i + n]] == o_lines]
-    if len(matches) != 1:
-        return None
-    i = matches[0]
-    tail = "\n" if t_lines[i + n - 1].endswith("\n") else ""
-    replacement = new.strip("\n") + tail if new.strip("\n") else ""
-    return "".join(t_lines[:i]) + replacement + "".join(t_lines[i + n :])
-
-
 def parse_text_tool_calls(content: str) -> list[dict]:
     """Recover tool calls that a model printed as text instead of emitting structured calls."""
     calls = []
@@ -703,9 +696,10 @@ class Toolbox:
     def t_read_file(self, path: str, offset: int = 1, limit: int = 2000) -> str:
         p = self.path(path, read=True)
         if not p.exists():
-            raise ToolError(f"{path} does not exist")
+            raise ToolError(f"{path} does not exist.{self._did_you_mean(path)}")
         if p.is_dir():
-            raise ToolError(f"{path} is a directory; use list_dir")
+            listing = tree(p, depth=1)
+            return f"{self.rel(p)} is a directory, so here's what's in it (read a file with read_file):\n{listing}"
         if is_image(p):
             raise ToolError(f"{path} is an image; look at it with view_image")
         if is_binary(p):
@@ -736,8 +730,10 @@ class Toolbox:
 
     def t_list_dir(self, path: str = ".", depth: int = 2) -> str:
         p = self.path(path, read=True)
+        if p.is_file():
+            return f"{self.rel(p)} is a file, not a directory: read it with read_file."
         if not p.is_dir():
-            raise ToolError(f"{path} is not a directory")
+            raise ToolError(f"{path} does not exist.{self._did_you_mean(path)}")
         return tree(p, depth=max(1, min(int(depth or 2), 6)))
 
     def t_glob(self, pattern: str, path: str = ".") -> str:
@@ -749,6 +745,8 @@ class Toolbox:
         ]
         hits.sort(key=lambda p: p.stat().st_mtime, reverse=True)
         if not hits:
+            if not base.is_dir():
+                return f"No files found: {path} does not exist.{self._did_you_mean(path)}"
             return "No files found."
         more = f"\n... and {len(hits) - 200} more" if len(hits) > 200 else ""
         return "\n".join(self.rel(p) for p in hits[:200]) + more
@@ -757,6 +755,7 @@ class Toolbox:
         self, pattern: str, path: str = ".", glob: str | None = None, ignore_case: bool = False, context: int = 0
     ) -> str:
         p = self.path(path)
+        literal = False  # the pattern wasn't a valid regex, so it was searched as plain text
         if shutil.which("rg"):
             cmd = ["rg", "--line-number", "--no-heading", "--with-filename", "--hidden", "--color", "never"]
             cmd += ["--max-columns", "400"]
@@ -768,16 +767,24 @@ class Toolbox:
                 cmd += ["-g", glob]
             for d in IGNORE_DIRS:
                 cmd += ["-g", f"!{d}/"]
-            cmd += ["-e", pattern, str(p)]
-            r = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+            if not p.exists():
+                raise ToolError(f"{path} does not exist.{self._did_you_mean(path)}")
+            r = subprocess.run([*cmd, "-e", pattern, str(p)], capture_output=True, text=True, timeout=60)
+            if r.returncode == 2 and "regex parse error" in r.stderr:
+                # "def add(" is meant literally: search for the text instead of failing
+                r = subprocess.run([*cmd, "-F", "-e", pattern, str(p)], capture_output=True, text=True, timeout=60)
+                literal = True
             if r.returncode == 2:
                 raise ToolError(r.stderr.strip())
             out = r.stdout
         else:
+            if not p.exists():
+                raise ToolError(f"{path} does not exist.{self._did_you_mean(path)}")
             try:
                 rx = re.compile(pattern, re.I if ignore_case else 0)
-            except re.error as e:
-                raise ToolError(f"invalid regex: {e}") from e
+            except re.error:
+                rx = re.compile(re.escape(pattern), re.I if ignore_case else 0)  # meant literally
+                literal = True
             results = []
             for f in [p] if p.is_file() else walk_files(p):
                 if (glob and not fnmatch.fnmatch(f.name, glob)) or is_binary(f):
@@ -791,13 +798,38 @@ class Toolbox:
             out = "\n".join(results)
         out = out.replace(str(self.agent.cwd) + os.sep, "")
         lines = out.splitlines()
+        note = "[The pattern isn't a valid regular expression, so it was searched as plain text.]\n" if literal else ""
         if not lines:
-            return "No matches."
+            return note + "No matches."
         if len(lines) > 400:
-            return "\n".join(lines[:400]) + f"\n... [{len(lines) - 400} more lines; narrow the search]"
-        return out
+            return note + "\n".join(lines[:400]) + f"\n... [{len(lines) - 400} more lines; narrow the search]"
+        return note + out
 
     # -- file changes
+    def _did_you_mean(self, path: str) -> str:
+        """Existing paths close to one that doesn't exist: the same name elsewhere in the project, or a near name
+        in the nearest folder that exists. Saves the model a search, or a guess."""
+        wanted = self.resolve(path)
+        found: list[Path] = []
+        from lcode.checkpoints import work_tree_for
+
+        for i, candidate in enumerate(walk_files(work_tree_for(self.agent.cwd))):
+            if i > 20_000 or len(found) >= 3:
+                break
+            if candidate.name == wanted.name:
+                found.append(candidate)
+        folder = wanted.parent
+        while not folder.is_dir() and folder != folder.parent:
+            folder = folder.parent
+        try:
+            names = [e.name + ("/" if e.is_dir() else "") for e in folder.iterdir() if e.name not in IGNORE_DIRS]
+        except OSError:
+            names = []
+        for name in difflib.get_close_matches(wanted.name, names, n=3, cutoff=0.6):
+            found.append(folder / name.rstrip("/"))
+        shown = list(dict.fromkeys(self.rel(p) + ("/" if p.is_dir() else "") for p in found))[:3]
+        return f" Did you mean: {', '.join(shown)}?" if shown else ""
+
     def _check_fresh(self, p: Path) -> None:
         key = str(p)
         if key not in self.read_mtimes:
@@ -873,6 +905,63 @@ class Toolbox:
             "on its current content."
         )
 
+    def t_apply_patch(self, patch: str) -> str:
+        try:
+            files = matching.parse_patch(patch)
+        except ValueError as e:
+            raise ToolError(str(e)) from e
+        planned: list[tuple[Path, str | None, str, list[str]]] = []  # path, before, after, notes
+        for fp in files:
+            p = self.path(fp.path)
+            if fp.deleted:
+                raise ToolError(f"{fp.path}: deleting files isn't something apply_patch does; use bash (rm)")
+            if fp.new_file:
+                if p.exists():
+                    raise ToolError(f"{fp.path} already exists; the patch creates it from /dev/null")
+                planned.append((p, None, "\n".join(h.new for h in fp.hunks) + "\n", []))
+                continue
+            if not p.is_file():
+                raise ToolError(f"{fp.path} does not exist (use --- /dev/null to create it)")
+            self._check_fresh(p)
+            before = self.read_text(p)
+            try:
+                after, notes = matching.apply_hunks(before, fp.hunks)
+            except ValueError as e:
+                raise ToolError(f"{fp.path}: {e}") from e
+            planned.append((p, before, after, notes))
+        done = []
+        for p, before, after, notes in planned:
+            body = self._diff(p, before or "", after)
+            verb = "Create" if before is None else "Patch"
+            ok, feedback = self.agent.perms.request("edit", "edit", f"{verb} {self.rel(p)}", body, self.project_rel(p))
+            if not ok:
+                return feedback + (f" (already patched: {', '.join(done)})" if done else "")
+            if (self.read_text(p) if p.exists() else None) != before:
+                return self._changed_meanwhile(p)
+            self.agent.checkpoint()
+            self._write(p, after)
+            self.console.print(f"  [green]✓[/] {'Created' if before is None else 'Patched'} {self.rel(p)}")
+            done.append(self.rel(p) + (f" ({'; '.join(notes)})" if notes else ""))
+            problems = self._check(p, before, after)
+            if problems:
+                done[-1] += problems
+        return "Patched " + ", ".join(done) + "."
+
+    def _edit_miss(self, p: Path, miss: matching.Miss) -> str:
+        """Why an edit can't be placed, with the closest lines so the model can copy them exactly."""
+        if miss.reason == "ambiguous":
+            return (
+                f"old_string isn't in {self.rel(p)} exactly, and it's close to more than one place:\n{miss.hint}\n"
+                "Add surrounding lines to old_string so it matches only one, copied exactly."
+            )
+        message = f"old_string not found in {self.rel(p)}. It must match the file exactly, including indentation."
+        if miss.hint:
+            return (
+                message
+                + f" The closest text is:\n{miss.hint}\nCopy what you mean from it exactly (without the line numbers)."
+            )
+        return message + " Re-read the file and copy the text precisely (without line-number prefixes)."
+
     def t_edit_file(self, path: str, old_string: str, new_string: str, replace_all: bool = False) -> str:
         p = self.path(path)
         if not p.exists():
@@ -884,14 +973,12 @@ class Toolbox:
             raise ToolError("old_string is empty; use write_file to create or overwrite files")
         text = self.read_text(p)
         count = text.count(old_string)
+        how, start_line = "", 0
         if count == 0:
-            new_text = fuzzy_replace(text, old_string, new_string)
-            if new_text is None:
-                raise ToolError(
-                    f"old_string not found in {self.rel(p)}. It must match exactly, including indentation. "
-                    "Re-read the file and copy the text precisely (without line-number prefixes)."
-                )
-            count = 1
+            found = matching.locate(text, old_string, new_string)
+            if isinstance(found, matching.Miss):
+                raise ToolError(self._edit_miss(p, found))
+            new_text, how, start_line, count = found.text, found.how, found.start_line, 1
         elif count > 1 and not replace_all:
             raise ToolError(
                 f"old_string occurs {count} times in {self.rel(p)}. Add surrounding lines to make it unique, "
@@ -909,15 +996,16 @@ class Toolbox:
         self._write(p, new_text)
         self.console.print(f"  [green]✓[/] Edited {self.rel(p)}")
         problems = self._check(p, text, new_text)
-        idx = new_text.find(new_string) if new_string else -1
-        if idx < 0:
-            return f"Edited {self.rel(p)} ({count} replacement(s))." + problems
+        done = f"Edited {self.rel(p)} ({count} replacement(s)" + (f", {how}" if how else "") + ")."
+        idx = new_text.find(new_string) if new_string and not how else -1
+        if idx < 0 and not start_line:
+            return done + problems
         # Show the model the edited region so it can verify the result.
-        start = new_text.count("\n", 0, idx) + 1
+        start = new_text.count("\n", 0, idx) + 1 if idx >= 0 else start_line
         lines = new_text.splitlines()
         lo, hi = max(1, start - 3), min(len(lines), start + new_string.count("\n") + 3)
         snippet = "\n".join(f"{i:6}\t{lines[i - 1]}" for i in range(lo, hi + 1))
-        return f"Edited {self.rel(p)} ({count} replacement(s)). Result:\n{snippet}" + problems
+        return f"{done} Result:\n{snippet}" + problems
 
     # -- shell
     def t_bash(self, command: str, timeout: int = 180, background: bool = False) -> str:

{lcode_cli-0.29.0.dist-info → lcode_cli-0.30.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.29.0
+Version: 0.30.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.dist-info → lcode_cli-0.30.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-lcode/__init__.py,sha256=MDtHYmkvKuvQap8m7LmA2apEsX16ubVEWst8qW4l_kQ,473
+lcode/__init__.py,sha256=_ncPdkojpmAnL6Af19KuRAd4o_TixpnzWrgz3usKy0A,473
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
-lcode/acp.py,sha256=Tpc8lsvffZSYbTRI4t7X4E2chahqZIPcKeYIcL5bV3Y,29035
+lcode/acp.py,sha256=d97VV3sbqXdWKhPQQNbYRaDTm8WrUk0mGbDLiOyX7jE,29058
 lcode/action.py,sha256=wuT5F9EJCdEligPeytzmEi8FpahWBhXer528tpuTj_k,16711
-lcode/agent.py,sha256=mYGtftFoEzgI-KvpDpXTOLmtKPrB3ZVjfP__1B872r8,69547
+lcode/agent.py,sha256=CVOyaV_KJQor1zlW2zou3iQXzf9UPV-3emTmuqJ5JVE,69562
 lcode/api.py,sha256=PhG8PZReM7DXSxG6wf7mEjAKx_TAsgj3xHApacrXGCM,15684
 lcode/backends.py,sha256=dtJHrC6ys73bRDg64z0tQz1PavmeAkiODZu1fOO9ExQ,20635
-lcode/bench.py,sha256=7ICipu_2GXW6vE519XeZucc2GSWA44votT8JvqcNv1k,40964
+lcode/bench.py,sha256=KDgPnkceZOS3gDDEl5j6-k8Ser2es4-IuV_S8p_46Zo,41517
 lcode/bench_backend.py,sha256=X2fo-zRX92Xp3KMxSsFlWioc2vRupBTtowj5kLME8mw,14287
 lcode/bench_runtime.py,sha256=EjzNgIvUkdbT8cbSy1TpmlyeIk6e-ipjlDFpM7Dnqx0,6835
 lcode/catalog.py,sha256=pZ1azX9OH2r4JE2c6E5OfwywpgS39-W2oXzoCHJhmtM,4141
@@ -24,6 +24,7 @@ lcode/hooks.py,sha256=K0itOiAuH4rxndJ9gne_uCrqby6oWAzFPRrfB3tCq-E,9324
 lcode/jobs.py,sha256=P1P3FqI6EqL4LgdMX9YGZwCW0Bh5BRXFA_FnQxpHNjE,5618
 lcode/limits.py,sha256=oJzVQoMyTZ0_Fkpu5t3qxrf9v7Hv9S8U8BRQR5M1aKA,1237
 lcode/lsp.py,sha256=NtSW7xapv7fg2HAQLuYK1nwIqT7nG0LK1hiTpOmla_4,26086
+lcode/matching.py,sha256=2N3_qwKJ5gd8el2m_y_egKkFM9rsF1eUhYJcRCVIp98,14015
 lcode/memory.py,sha256=WZEHTp-lVxAwS-yyLQR2xB3TMZ9sejmX2Ivg7T-tl3w,21949
 lcode/models.toml,sha256=lt2G64zzo_Ryxv2ISRSNZoVD_JqCqYqsM01n8WoXGs8,4098
 lcode/notify.py,sha256=uieDeXe7XwuVHjOk4tqVyZEW_85XWkoWQmFOWEf77oc,1538
@@ -31,15 +32,15 @@ lcode/ollama.py,sha256=u5tnvL28cfaFS4GhmiEsHhTQe6w3Ng_Tej05UUzLQTQ,7715
 lcode/permissions.py,sha256=3OPVVth6uTE5kcAWMZ8X_vUnFRbf6STEHAJimZX0Yu4,12118
 lcode/planning.py,sha256=Q2upaoZPnXDMQT2F-ETxX1lk_wDntTzhSKNVYIQSoQA,6540
 lcode/render.py,sha256=gMvf4W3qkLUJ4Vot3az_hP_zRDAItJC9pP-68dHFkfA,1375
-lcode/repeats.py,sha256=uzyAewX03nJf5dKwYFH4y9ZDnh0Lvy2k0qC2vdntM5Y,4061
+lcode/repeats.py,sha256=-vcbj363nFcIyso7yFJgsbHz9C6VOu2EOg3Svs4eFyE,4091
 lcode/repl.py,sha256=ayrKySMbbRbax_WMjqYBN4fkcDpzuHniefJC3DZ4-2Y,50687
 lcode/repomap.py,sha256=1GRJgEUjBl9XHSXsF7tSGXBCEgsY-3CzwMohaTudZ_M,13969
 lcode/residency.py,sha256=bDB2J0SZULDOz6wYuMCnkjacYk7pWi5f75iY83ycAXQ,6912
 lcode/sandbox.py,sha256=u_pkrVRXhCGhh-wFDPwuZ3jGG7UeXxXRAeBNsm37ZvE,8608
 lcode/secretscan.py,sha256=6Euvfk2gCtK7lZbuQD84zgWuSECi6OnSw8V5rFu1tfU,13575
 lcode/sessions.py,sha256=wOR-J0EHgJxLSPboKPHnvBcp5VTUYTj3tZWgpsa6-K4,4013
-lcode/subagents.py,sha256=Z2RHp7an16dhOGReucVIEOAnXjxM8jx7sHvWd_Fp2V4,29142
-lcode/tools.py,sha256=h7C6r27_cBoCkW8tZ4BLmxdgRByYa2cUKh8AWfmEucI,54193
+lcode/subagents.py,sha256=GGn2E7QUwEsShJEHXaMhG53leyGFUZwJku_n33gJguU,29157
+lcode/tools.py,sha256=1zH4hkEyHQz4byV348J4zfe0VzwvjmlH1MOqiobznbA,59446
 lcode/update.py,sha256=i92bnW252VneYh0vD6djxmXsDOa5MXP20bjlLZUue_c,25236
 lcode/vision.py,sha256=w33QPmdGwP33wM4mvmAH4amFDZ1xzeXhEsSLJ-STSHY,4243
 lcode/web.py,sha256=vyxKbSRJTl1Lj3hj7Yd_NwTgbv0Xi6dup2YfUXjqp-Y,14579
@@ -59,8 +60,8 @@ lcode/servers/__init__.py,sha256=qrIhxEodEB8cjKEQ4Cicc0GsQhE2OH-9qlVHzr3-tq8,77
 lcode/servers/encord.py,sha256=WSauawL1UKYZCUAG1oalcKL_An3DVof-JM6xIgFyQSE,12769
 lcode/servers/valohai.py,sha256=e5xZGIoa4cja4f5i85q1GpL9c7cglUjV8jN2co1CFMY,14430
 lcode/servers/xai.py,sha256=h2emAvHSnkuB9WmJInlynsDhvxJwNVD2AHFX7vqMXNc,13627
-lcode_cli-0.29.0.dist-info/METADATA,sha256=IYMbafynIQ-eNxr7iOJkmc5vXhfry3Q5FIeyMXmeEgE,12620
-lcode_cli-0.29.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.29.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
-lcode_cli-0.29.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.29.0.dist-info/RECORD,,
+lcode_cli-0.30.0.dist-info/METADATA,sha256=s6dAfe3HCeh9LIPNLLoYY3VGXfGT6b8ZW0pZbERa6X0,12620
+lcode_cli-0.30.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.30.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
+lcode_cli-0.30.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.30.0.dist-info/RECORD,,