lcode-cli 0.29.0__py3-none-any.whl → 0.31.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.31.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

@@ -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/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/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/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/repl.py

@@ -63,6 +63,7 @@ COMMANDS = {
     "/mode": "Permission mode: ask | plan | auto-edit | yolo (Shift+Tab cycles)",
     "/cd": "Change the working directory",
     "/todos": "Show the current todo list",
+    "/status": "The task sheet: your requests, the plan and notes, files changed, the last check",
     "/jobs": "Background commands the model started: /jobs, /jobs stop <id>",
     "/commit": "Commit the changes with a message in the repository's style, after you approve it",
     "/review": "Review the uncommitted changes, or the branch against a base: /review [base]",
@@ -109,6 +110,31 @@ def mention(path: Path) -> str:
     return f'@"{shown}"' if " " in shown else f"@{shown}"
 
 
+def status_command(agent: Agent) -> None:
+    """What the session is doing, as lcode keeps it for the model (the task sheet)."""
+    c = agent.console
+    requests = context_tools.user_requests(agent.messages)
+    if not requests and not agent.tools.todos and not agent.tools.changed:
+        c.print("Nothing yet: no requests in this session.")
+        return
+    if requests:
+        latest = requests[-3:]
+        lines = [f"[dim]{len(requests) - len(latest) + i + 1}.[/] {escape(r[:300])}" for i, r in enumerate(latest)]
+        c.print(Panel("\n".join(lines), title="Requests (latest)", title_align="left", border_style="cyan"))
+    if agent.tools.todos or agent.tools.notes:
+        agent.tools.show_todos()
+    if agent.tools.changed:
+        c.print(f"[bold]Files changed:[/] {escape(', '.join(agent.tools.changed))}")
+    if agent.check_results:
+        last = agent.check_results[-1]
+        code = last.get("exit_code")
+        state = (
+            "[green]passed[/]" if code == 0 else "didn't run" if code is None else f"[red]failed[/] (exit code {code})"
+        )
+        c.print(f"[bold]Last check:[/] {escape(str(last.get('command')))} {state}")
+    c.print("[dim]The model keeps this too, even when old messages are removed or summarized.[/]")
+
+
 def build_session(agent: Agent) -> PromptSession:
     kb = KeyBindings()
 
@@ -978,6 +1004,8 @@ def handle_command(agent: Agent, line: str, hardware: Hardware) -> bool:
             c.print(f"Working directory: {p}")
         else:
             c.print(f"[red]Not a directory: {p}[/]")
+    elif cmd == "/status":
+        status_command(agent)
     elif cmd == "/todos":
         agent.tools.show_todos()
     elif cmd == "/jobs":

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

@@ -24,11 +24,12 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from rich.console import Group
+from rich.markup import escape
 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
@@ -45,6 +46,7 @@ NO_NETWORK = re.compile(
 )
 MAX_TOOL_OUTPUT = 30_000  # characters returned to the model per tool call
 PENDING_LINES = 5000  # output lines waiting to be read, at most
+MAX_NOTES, MAX_NOTE = 12, 300  # the model's task notes: how many, how long each
 LEFTOVER_GRACE = 0.5  # seconds to wait for output after a command ends, before stopping what it left running
 IGNORE_DIRS = {
     ".git", "node_modules", "__pycache__", ".venv", "venv", "env", ".mypy_cache", ".pytest_cache",
@@ -96,6 +98,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).",
@@ -152,7 +163,8 @@ SCHEMAS = [
     _fn(
         "todo_write",
         "Create or update your task list for multi-step work. Pass the full list every time. Keep exactly one "
-        "item in_progress while working.",
+        "item in_progress while working. In `notes`, keep what you must not forget: decisions and why, findings, "
+        "open questions. The list and the notes stay with you even when old messages are removed.",
         {
             "todos": {
                 "type": "array",
@@ -164,7 +176,12 @@ SCHEMAS = [
                     },
                     "required": ["content", "status"],
                 },
-            }
+            },
+            "notes": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Short notes, the full list each time (omit to keep the current ones)",
+            },
         },
         ["todos"],
     ),
@@ -375,22 +392,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 = []
@@ -445,6 +446,8 @@ class Toolbox:
         self.agent = agent
         self.read_mtimes: dict[str, float] = {}
         self.formats: dict[str, TextFormat] = {}  # encoding and line endings of the files read
+        self.notes: list[str] = []  # the model's notes on the task (todo_write): decisions, findings, questions
+        self.changed: dict[str, None] = {}  # files lcode wrote in this session, in order
         self.todos: list[dict] = []
         # An editor's buffers (lcode acp): read unsaved changes and write through the editor.
         self.reader: Callable[[Path], str | None] | None = None
@@ -703,9 +706,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 +740,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 +755,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 +765,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 +777,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 +808,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:
@@ -833,6 +875,7 @@ class Toolbox:
         if not p.exists() or p.read_bytes() != data:
             p.write_bytes(data)  # the file on disk must match, for checkpoints and the tools
         self.read_mtimes[str(p)] = p.stat().st_mtime
+        self.changed[self.rel(p)] = None
 
     def t_write_file(self, path: str, content: str) -> str:
         p = self.path(path)
@@ -873,6 +916,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 +984,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 +1007,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:
@@ -1160,12 +1259,29 @@ class Toolbox:
         return f"[{describe(job)}]" + (f"\nIts last output:\n{last}" if last else "")
 
     # -- planning
-    def t_todo_write(self, todos: list | str) -> str:
+    def t_todo_write(self, todos: list | str, notes: list | str | None = None) -> str:
         if isinstance(todos, str):
             todos = json.loads(todos)
         self.todos = list(todos)
+        # Small models often put a note inside an item instead of in `notes`: keep it either way.
+        attached = [
+            str(todo.get(key)).strip()
+            for todo in self.todos
+            if isinstance(todo, dict)
+            for key in ("notes", "note", "details")
+            if str(todo.get(key) or "").strip()
+        ]
+        if attached:
+            notes = [*([] if notes is None else ([notes] if isinstance(notes, str) else list(notes))), *attached]
+        if notes is not None:
+            if isinstance(notes, str):
+                try:
+                    notes = json.loads(notes)
+                except ValueError:
+                    notes = [notes]
+            self.notes = [str(n).strip()[:MAX_NOTE] for n in notes if str(n).strip()][:MAX_NOTES]
         self.show_todos()
-        return "Todo list updated."
+        return "Todo list updated." + (f" {len(self.notes)} note(s) kept." if notes is not None else "")
 
     def show_todos(self) -> None:
         icons = {"completed": "[green]✔[/]", "in_progress": "[yellow]◐[/]", "pending": "[dim]○[/]"}
@@ -1177,4 +1293,6 @@ class Toolbox:
             elif status == "in_progress":
                 text = f"[bold]{text}[/]"
             rows.append(f"{icons.get(status, '○')} {text}")
+        if self.notes:
+            rows += ["", *(f"[dim]•[/] {escape(note)}" for note in self.notes)]
         self.console.print(Panel("\n".join(rows) or "(empty)", title="Todos", title_align="left", border_style="blue"))

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

@@ -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.dist-info → lcode_cli-0.31.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-lcode/__init__.py,sha256=MDtHYmkvKuvQap8m7LmA2apEsX16ubVEWst8qW4l_kQ,473
+lcode/__init__.py,sha256=gXBLoiYa3VhO8oR-eyFbfplfXuE6GNMT6g92TwUc_2g,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=OkGViWlZd8g-MFZpaCnbRIpmrFXnKajbIeEMKV1e7-o,70275
 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
@@ -15,7 +15,7 @@ lcode/cli.py,sha256=svnW6pfLtqiMXbA3wMlYESKGgGe6Xb9wlWkqg6Cz0O0,41081
 lcode/clipboard.py,sha256=nTSdJyCXPdtjH947RjvB3QvRqnL5HZsS9KB8EkC42cc,5138
 lcode/codesearch.py,sha256=Io8leN1nb_Y-Dvlm9xaGtwUWYXX-ooswuznJV6dGU1s,10766
 lcode/config.py,sha256=KSjSBvxA9nmd4h4QYk3xp8BQ7C04pjTULsSn0jcQwBc,11301
-lcode/context.py,sha256=WSMiitscDh2Juy4Hx0x9EPNWrn804IbOWRZly1-DU38,17022
+lcode/context.py,sha256=0YYLrC7gI164HqDjW_jrgHSnfrAilrRUoTLhvw54VI8,19082
 lcode/extensions.py,sha256=W0HFDl0BvROzr7i_qtabHdIbacBgP5o5qIJLzoM2oNE,16806
 lcode/frontmatter.py,sha256=Bx0n4vLPhp7ZCWx-g7xqzqNy5VoKBxyeeikh5UFB_gA,2441
 lcode/gitflow.py,sha256=6j_nnCBZXkX1qhTI7K4CyZ5D0NAZLpH96weFEo64AkQ,27913
@@ -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/repl.py,sha256=ayrKySMbbRbax_WMjqYBN4fkcDpzuHniefJC3DZ4-2Y,50687
+lcode/repeats.py,sha256=-vcbj363nFcIyso7yFJgsbHz9C6VOu2EOg3Svs4eFyE,4091
+lcode/repl.py,sha256=0f3nojURlQE8Pm_JkXvh9y7nEg1CHG3xanZIs0osPxw,52107
 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=PofQ77Y7TvsUcFcvrUDP4GirpgkQKhhC_NL_1K_8_Jo,61182
 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.31.0.dist-info/METADATA,sha256=kGzeEZoj0ZAZxYBHC30JRJAKERgqAq4h9XObVzJYPms,12620
+lcode_cli-0.31.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.31.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
+lcode_cli-0.31.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.31.0.dist-info/RECORD,,