lcode-cli 0.28.1__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.28.1"
+__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

@@ -27,6 +27,7 @@ from rich.text import Text
 
 from lcode import (
     catalog,
+    checks,
     codesearch,
     extensions,
     limits,
@@ -81,7 +82,13 @@ EVENT_OUTPUT = 4000  # characters of a tool's output in an event
 REFUSED = ("Error:", "A deny rule", "The user denied", "This needs the user's permission")
 MAX_MALFORMED_CALL_RETRIES = 2  # Ollama rejects tool calls whose arguments aren't valid JSON
 # How Ollama reports a tool call it couldn't parse (Qwen3.6's calls are XML)
-MALFORMED_CALL = ("error parsing tool call", "XML syntax error")
+MALFORMED_CALL = (
+    "error parsing tool call",
+    # Go's XML decoder, for models that write calls as XML (Qwen3.6): a cut-off or misordered call
+    "XML syntax error",
+    "expected element type",
+    "closed by </",
+)
 RESULT_SHARE = 0.25  # of the context window, at most, for one tool result
 MIN_RESULT_CHARS = 8000
 READING_NOTE_TOKENS = 4000  # new input this large gets "Reading … new tokens" in the status line
@@ -114,7 +121,7 @@ SYSTEM_PROMPT = """You are lcode, an autonomous software-engineering agent runni
 - A syntax check or an import only shows that code loads. Run what you changed the way it will be used (the script, the tests, the app) and fix what fails.
 - To fix a bug, first reproduce each problem the user reports with a test, a command or a short script, then run the same checks to show they're gone.
 - For what you can't see, like a GUI, a web page or a layout, check it without a screen where you can: `QT_QPA_PLATFORM=offscreen` for Qt, a headless browser, or a script that prints sizes and positions or renders to an image{look}. Measure instead of assuming.
-- Never claim something works, mark a todo done, or call it tested unless you ran it. If you couldn't check something, say so and tell the user exactly what to look for. If something fails, say so and show the relevant error.
+- Never claim something works, mark a todo done, or call it tested unless you ran it. If you couldn't check something, say so and tell the user exactly what to look for. If something fails, say so and show the relevant error.{checks}
 
 # Communication
 - Be concise and direct; no filler. Use GitHub-flavored markdown.
@@ -268,6 +275,7 @@ class Settings:
     secret_check: bool = True  # scan what git commit and git push would add (lcode.secretscan)
     compact_at: int = 0  # tokens: make room at this size even when the window is larger (0: only at 85%)
     repeat_limit: int = 3  # identical calls with identical results before the model is told (lcode.repeats)
+    checks: str = "off"  # the project's checks after a change (lcode.checks): auto, off or a command
 
 
 class Agent:
@@ -324,6 +332,8 @@ class Agent:
         self.made_room_for = ""  # why the model was unloaded (the vision model, an MCP tool), for the reload line
         self.load_state = ""  # "loading" while the model loads in the background at startup (lcode.repl)
         self.autosave = False  # save the session after every step (sessions people resume; not the bench's)
+        self._check: tuple[Path, checks.Check | None] | None = None
+        self.check_results: list[dict] = []  # the checks of the last request: command, exit code, who ran them
         self.sent_chars = 0  # characters of the conversation the model had already read
         self.counted_chars: int | None = None  # characters that ctx_used covers (None: all of them)
         self.turn_status = ""  # how the last request ended: success, max_steps, loop
@@ -363,6 +373,7 @@ class Agent:
             code=self.code_prompt(),
             map=self.map_prompt(),
             look=" you look at with view_image" if self.vision_model() else "",
+            checks=self.checks_prompt(),
         )
 
     def repo_map(self) -> repomap.RepoMap | None:
@@ -812,6 +823,64 @@ class Agent:
             self.last_speed = final.get("eval_count", 0) / seconds if seconds else 0.0
         return message
 
+    def checks_prompt(self) -> str:
+        check = self.project_check()
+        if check is None:
+            return ""
+        return (
+            f"\n- When you've changed files, lcode runs the project's checks (`{check.command}`) before your answer "
+            "is final, and gives you the failures to fix. Run them yourself while you work, too."
+        )
+
+    def project_check(self) -> checks.Check | None:
+        """The project's check command, for the main agent outside plan mode and reviews (None otherwise)."""
+        if self.allowed_tools is not None or self.planning() or self.no_changes or self.settings.checks == "off":
+            return None
+        root = project_root_or_cwd(self.cwd)
+        if self._check is None or self._check[0] != root or self._check[1] is None:  # tests may appear meanwhile
+            self._check = (root, checks.find(root, self.settings.checks, self.settings.trust_project))
+        return self._check[1]
+
+    def model_ran_checks(self, command: str, result: str) -> bool:
+        """Whether a command the model ran was the project's checks, and they passed."""
+        check = self.project_check()
+        if check is None or not checks.covers(check, command) or checks.exit_code(result) != 0:
+            return False
+        self.check_results.append({"command": check.command, "exit_code": 0, "by": "model"})
+        return True
+
+    def run_check(self, check: checks.Check, round_: int) -> str | None:
+        """Run the checks after a change. Returns what to tell the model when they fail, else None."""
+        self.say(f"Checking the work: {check.command} (from {check.source})")
+        result = self.tools.run("bash", {"command": check.command, "timeout": checks.TIMEOUT})
+        code = checks.exit_code(result)
+        self.check_results.append({"command": check.command, "exit_code": code, "by": "lcode"})
+        if code is None:
+            self.say(f"The checks didn't run: {result.splitlines()[0][:200]}", warning=True)
+            return None
+        if code == 0:
+            self.say(f"Checks pass: {check.command}")
+            return None
+        if checks.no_tests(check, result):
+            self.say(f"The checks found no tests to run ({check.command}).")
+            return None
+        if checks.missing(check, result):
+            self.say(
+                f"The checks couldn't run ({check.command}): {result.splitlines()[0][:160]}. Install what they need, "
+                'or set the command: lcode config set checks "…" (or checks off).',
+                warning=True,
+            )
+            return None
+        if round_ >= checks.MAX_ROUNDS:
+            self.say(
+                f"Checks still fail ({check.command}, exit code {code}): the model will say what's left.", warning=True
+            )
+        else:
+            self.say(
+                f"Checks fail ({check.command}, exit code {code}): the model gets the output to fix it.", warning=True
+            )
+        return checks.failure_note(check, result, round_)
+
     def before_request(self, progress: Progress) -> residency.LoadWatch | None:
         """Set the status line for what comes before the first token: loading the model if it isn't in memory
         (watched until it is), then reading the prompt. Returns the watch while the model loads."""
@@ -948,6 +1017,9 @@ class Agent:
         note = planning.NOTE if self.planning() and self.allowed_tools is None else ""
         self.messages.append({"role": "user", "content": self.expand_mentions(user_text) + note})
         self.repeats.reset()
+        self.check_results = []
+        changed = verified = False  # files changed in this request; the checks passed since
+        check_rounds = 0
         malformed = 0
         looping = ""  # the call the model kept repeating, when lcode stopped the request for it
         for step in range(self.max_steps):
@@ -983,6 +1055,8 @@ class Agent:
                     reason = str(e).rsplit("err=", 1)[-1].strip()
                 elif "XML syntax error" in str(e):
                     reason = str(e).split("XML syntax error", 1)[1].strip(" :") or "invalid XML"
+                elif "expected element type" in str(e) or "closed by </" in str(e):
+                    reason = str(e).split("Ollama error:", 1)[-1].strip() or "invalid XML"
                 else:
                     reason = "invalid JSON"
                 self.console.print("[yellow]The model wrote a malformed tool call; asking it to try again.[/]")
@@ -996,6 +1070,15 @@ class Agent:
                 )
                 continue
             if not calls:
+                check = self.project_check() if changed and not verified else None
+                if check is not None and check_rounds < checks.MAX_ROUNDS:
+                    check_rounds += 1
+                    feedback = self.run_check(check, check_rounds)
+                    if feedback:
+                        self.messages.append({"role": "user", "content": feedback})
+                        changed = False  # run them again only if the model changes something more
+                        continue
+                    verified = True
                 break
             done: dict[int, str] = {}  # results of subagents that ran together
             together = [
@@ -1051,6 +1134,10 @@ class Agent:
                     )
                     if verdict.stop:
                         looping = self.describe_call(name, args)
+                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
                 tool_msg = {"role": "tool", "tool_name": name, "content": result}
                 if call.get("id"):
                     tool_msg["tool_call_id"] = call["id"]

lcode/api.py

@@ -76,6 +76,7 @@ class Result:
     tool_calls: list[dict] = field(default_factory=list)  # {"id", "name", "arguments", "error", "output"}
     files_changed: list[dict] = field(default_factory=list)  # {"status": "A" | "M" | "D", "path"}
     usage: dict = field(default_factory=dict)  # requests, prompt_tokens, output_tokens
+    checks: list[dict] = field(default_factory=list)  # {"command", "exit_code", "by": "lcode" | "model"}
     seconds: float = 0.0
     error: str = ""
 
@@ -196,6 +197,7 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         notify_after=cfg["notify_after"],
         secret_check=cfg["secret_check"],
         repeat_limit=cfg["repeat_limit"],
+        checks=cfg["checks"],
         compact_at=cfg["compact_at"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
@@ -303,6 +305,7 @@ def run_request(agent: Agent, prompt: str) -> Result:
         tool_calls=list(calls.values()),
         files_changed=files,
         usage=usage,
+        checks=list(agent.check_results),
         seconds=round(time.monotonic() - started, 2),
         error=error,
     )

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

@@ -0,0 +1,160 @@
+"""Run the project's checks before calling work done.
+
+Small models call work done after a syntax check, and telling them to verify isn't enough. So after a request
+that changed files, lcode runs the project's check command itself (its tests, or a linter) before the answer
+counts as final. When it fails, the output goes back to the model, which keeps working, at most `MAX_ROUNDS`
+times; then the answer says plainly that the checks still fail.
+
+The command is, in order: the repository's `.lcode/settings.toml` (`[checks] command = "…"`, used once the
+repository is trusted, like its hooks), the user's `checks` setting, or what the project looks like: pytest,
+unittest, npm test, cargo test, go test, make test. `checks = "off"` turns it off.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+MAX_ROUNDS = 2  # times the model gets failing checks back before lcode stops asking
+TIMEOUT = 600  # seconds a check may run
+OUTPUT_TAIL = 6000  # characters of a failing check's output the model gets back
+EXIT = re.compile(r"\[exit code: (-?\d+)\]\s*$")
+
+
+@dataclass
+class Check:
+    command: str
+    source: str  # where it comes from, for the user: "pyproject.toml", "your configuration"…
+
+
+def find(root: Path, setting: str, trusted: bool) -> Check | None:
+    """The project's check command, or None when there's none or checks are off."""
+    setting = (setting or "auto").strip()
+    if setting == "off":
+        return None
+    if trusted:
+        from lcode.hooks import HookError, read_toml
+
+        try:
+            data = read_toml(root / ".lcode" / "settings.toml")
+        except HookError:
+            data = {}
+        command = str((data.get("checks") or {}).get("command") or "").strip()
+        if command:
+            return Check(command, ".lcode/settings.toml")
+    if setting != "auto":
+        return Check(setting, "your configuration (checks)")
+    return detect(root)
+
+
+def python() -> str:
+    return "python" if shutil.which("python") else "python3"
+
+
+def text(path: Path) -> str:
+    try:
+        return path.read_text(errors="replace") if path.is_file() else ""
+    except OSError:
+        return ""
+
+
+def python_tests(root: Path) -> bool:
+    """Whether the project has Python test files (a few levels deep, outside environments and caches)."""
+    from lcode.tools import IGNORE_DIRS
+
+    def walk(folder: Path, depth: int) -> bool:
+        try:
+            entries = list(folder.iterdir())
+        except OSError:
+            return False
+        if any(e.is_file() and re.fullmatch(r"test_.*\.py|.*_test\.py", e.name) for e in entries):
+            return True
+        return depth > 0 and any(
+            walk(e, depth - 1)
+            for e in entries
+            if e.is_dir() and e.name not in IGNORE_DIRS and not e.name.startswith(".")
+        )
+
+    return walk(root, 3)
+
+
+def detect(root: Path) -> Check | None:
+    """A check command from what the project looks like. Python checks need test files: pytest configured in a
+    project without tests "fails" with nothing to run."""
+    if python_tests(root):
+        configs = text(root / "pyproject.toml") + text(root / "setup.cfg") + text(root / "tox.ini")
+        if "pytest" in configs or any((root / name).is_file() for name in ("pytest.ini", "conftest.py")):
+            runner = "uv run pytest -q" if (root / "uv.lock").is_file() else f"{python()} -m pytest -q"
+            return Check(runner, "pytest in the project's configuration")
+        if list(root.glob("test_*.py")) or list(root.glob("*_test.py")):
+            return Check(f"{python()} -m unittest", "test files")
+        if (root / "tests").is_dir():
+            return Check(f"{python()} -m unittest discover -s tests -t .", "tests/")
+    package = text(root / "package.json")
+    if package:
+        try:
+            test = (json.loads(package).get("scripts") or {}).get("test") or ""
+        except ValueError:
+            test = ""
+        if test and "no test specified" not in test:
+            for lock, tool in (("pnpm-lock.yaml", "pnpm"), ("yarn.lock", "yarn"), ("bun.lockb", "bun")):
+                if (root / lock).is_file():
+                    return Check(f"{tool} test", "package.json")
+            return Check("npm test", "package.json")
+    if (root / "Cargo.toml").is_file():
+        return Check("cargo test", "Cargo.toml")
+    if (root / "go.mod").is_file():
+        return Check("go test ./...", "go.mod")
+    if re.search(r"^test:", text(root / "Makefile"), re.M):
+        return Check("make test", "Makefile")
+    return None
+
+
+NO_TESTS = 5  # pytest's and unittest's exit code when no test ran: not a failure
+
+
+def no_tests(check: Check, result: str) -> bool:
+    return exit_code(result) == NO_TESTS and bool(re.search(r"pytest|unittest", check.command))
+
+
+def exit_code(result: str) -> int | None:
+    """The exit code at the end of a bash tool result (None: it didn't run, e.g. not allowed)."""
+    found = EXIT.search(result)
+    return int(found.group(1)) if found else None
+
+
+def covers(check: Check, command: str) -> bool:
+    """Whether a command the model ran is this check (`cd x && uv run pytest -q 2>&1 | tail` counts)."""
+    return " ".join(check.command.split()) in " ".join(command.split())
+
+
+def failure_note(check: Check, result: str, round_: int) -> str:
+    output = result if len(result) <= OUTPUT_TAIL else "…" + result[-OUTPUT_TAIL:]
+    last = round_ >= MAX_ROUNDS
+    return (
+        f"[lcode] Your changes are done, but the project's checks fail: `{check.command}` "
+        f"(exit code {exit_code(result)}).\n\n{output}\n\n"
+        + (
+            "This was the last check lcode runs for this request. Don't change anything more: tell the user what "
+            "still fails and why."
+            if last
+            else "Fix what your changes broke, then finish. If a failure isn't caused by your changes (it failed "
+            "before), don't chase it: say so in your answer."
+        )
+    )
+
+
+# The check command itself is missing (not the code under test): nothing the model can fix.
+MISSING = re.compile(r"No module named '?pytest'?\s*$|command not found|^\S+: not found$", re.I | re.M)
+
+
+def missing(check: Check, result: str) -> bool:
+    """Whether the check couldn't run at all: its program isn't installed."""
+    code = exit_code(result)
+    if code == 127:
+        return True
+    head = result.splitlines()[:5]  # a missing program says so first; test failures look different
+    return code not in (0, None) and any(MISSING.search(line) for line in head)

lcode/cli.py

@@ -580,6 +580,7 @@ def cmd_bench(args) -> None:
             checkpoints=False,
             prune=not args.no_prune,
             compact_at=cfg["compact_at"] if args.compact_at is None else args.compact_at,
+            checks=cfg["checks"] if args.checks is None else args.checks,
             repo_map=args.repo_map,
             embed_model=cfg["embed_model"] if args.code_search else "off",
         )
@@ -774,6 +775,11 @@ def build_subparsers() -> dict[str, argparse.ArgumentParser]:
     p.add_argument("--repo-map", action="store_true", help="give the model the repository map (off by default)")
     p.add_argument("--code-search", action="store_true", help="index each task's folder and offer semantic code search")
     p.add_argument("--no-prune", action="store_true", help="don't remove old tool output (to compare, with --session)")
+    p.add_argument(
+        "--checks",
+        metavar="auto|off|COMMAND",
+        help="run each task's checks before it counts as done (default: the checks setting)",
+    )
     p.add_argument(
         "--compact-at",
         type=compact_tokens,

lcode/config.py

@@ -59,6 +59,7 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "subagents": (True, bool, "let the model hand tasks to subagents that have their own context"),
     "notify": (True, bool, "desktop notification when a long request is done or waits for you"),
     "notify_after": (30, int, "seconds a request runs before it notifies (with notify on)"),
+    "checks": ("auto", str, "run the project's checks before calling work done: auto | off | a command"),
     "repeat_limit": (3, int, "identical tool calls with identical results before lcode steps in (0: never)"),
     "secret_check": (True, bool, "before git commit and git push, look for passwords, keys and tokens they'd add"),
     "compact_at": (65536, int, "summarize at this many tokens even when the window is larger (0: only at 85%)"),

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.28.1.dist-info → lcode_cli-0.30.0.dist-info}/METADATA

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

@@ -1,19 +1,20 @@
-lcode/__init__.py,sha256=USdcfUSBcDvzY7_LoT19i6HbdafE2NIPUyufHNoj9Vo,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=ws5i476DOsaEIv5YkYQ_qfmRV5fPitd6QltLDU9QhpE,64804
-lcode/api.py,sha256=Ul_2H_6LzkufaXHaG0Dz1vDIEmOAZ31VHO2qsjVdtE8,15506
+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
 lcode/checkpoints.py,sha256=eqPtmPe44-aweWqc2H21ROogwzIt3NpvcUobsaCHoGY,18354
-lcode/cli.py,sha256=M6Mjd5BROSGlZj4J6TrSZMJqI-OVfUEWPoC0TQyOQ28,40831
+lcode/checks.py,sha256=FOD8DOxPWXY1RMtrL9ONJsOxsV10BLgzPvzIJMK5NrU,6582
+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=q1zGzH3p5U23ai6O9Jai3dS-s30CuQ9gc5cWX0_yxWE,11195
+lcode/config.py,sha256=KSjSBvxA9nmd4h4QYk3xp8BQ7C04pjTULsSn0jcQwBc,11301
 lcode/context.py,sha256=WSMiitscDh2Juy4Hx0x9EPNWrn804IbOWRZly1-DU38,17022
 lcode/extensions.py,sha256=W0HFDl0BvROzr7i_qtabHdIbacBgP5o5qIJLzoM2oNE,16806
 lcode/frontmatter.py,sha256=Bx0n4vLPhp7ZCWx-g7xqzqNy5VoKBxyeeikh5UFB_gA,2441
@@ -23,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
@@ -30,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
@@ -58,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.28.1.dist-info/METADATA,sha256=96ojptFvjK6CP51H1expKcg1ZtjKmxSQce4hOk052XI,12620
-lcode_cli-0.28.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.28.1.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
-lcode_cli-0.28.1.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.28.1.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,,