lcode-cli 0.32.0__py3-none-any.whl → 0.33.1__py3-none-any.whl

lcode/__init__.py

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

lcode/agent.py

@@ -52,6 +52,7 @@ from lcode.permissions import Permissions
 from lcode.render import MarkdownStreamer
 from lcode.repeats import Repeats
 from lcode.sandbox import Sandbox, SandboxError, project_root
+from lcode.steer import NOTE_INTRO, Steering
 from lcode.tools import (
     LSP_SCHEMA,
     MEMORY_SCHEMA,
@@ -224,10 +225,12 @@ class Progress:
     arrives, for example while the model writes a long file into a tool call.
     """
 
-    def __init__(self, phase: str = "Thinking") -> None:
+    def __init__(self, phase: str = "Thinking", steering: Steering | None = None, tokens: bool = True) -> None:
         self.started = self.last_chunk = time.time()
         self.phase = phase
         self.chars = 0
+        self.steering = steering  # the note being typed and the notes waiting, shown on a second line
+        self.tokens = tokens  # False for a command running: no tokens to count
 
     def update(self, phase: str, text: str) -> None:
         self.phase, self.chars, self.last_chunk = phase, self.chars + len(text), time.time()
@@ -240,9 +243,11 @@ class Progress:
         now = time.time()
         streaming = self.phase in ("Thinking", "Writing")  # loading and reading say what they are throughout
         phase = self.phase if now - self.last_chunk < 3 or not streaming else "Working"
-        return Text.from_markup(
-            f"[cyan]{phase}…[/] [dim]({self.chars // 4} tokens, {now - self.started:.0f}s · Ctrl+C to stop)[/]"
-        )
+        tokens = f"{self.chars // 4} tokens, " if self.tokens else ""
+        keys = "Ctrl+C to stop" if self.steering is None else "type a note · Esc pauses · Ctrl+C stops"
+        line = Text.from_markup(f"[cyan]{phase}…[/] [dim]({tokens}{now - self.started:.0f}s · {keys})[/]")
+        below = self.steering.status() if self.steering is not None else None
+        return line if below is None else Text("\n").join([line, below])
 
 
 @dataclass
@@ -321,6 +326,9 @@ class Agent:
         self.read_only = False  # only read-only shell commands
         self.no_changes = ""  # set during a review: why nothing may change (read-only tools only)
         self.cancel: threading.Event | None = None  # set from another thread to stop
+        self.steering: Steering | None = None  # notes typed and pauses asked for during a request (lcode.repl)
+        self.turn_requests: list[str] = []  # the request, then the notes added to it while it ran
+        self.unsent = ""  # typed during the last request but never sent to the model: back in the prompt (lcode.repl)
         self.on_tool = None  # called with (name, arguments) before each tool runs
         self.jobs = Jobs()  # background commands (shared with subagents)
         self.turn_started = 0.0  # when the running request started (time.monotonic)
@@ -749,7 +757,7 @@ class Agent:
         """Stream one model response, rendering thinking/content live. Returns the assistant message."""
         content, thinking, tool_calls, final = "", "", [], {}
         md = MarkdownStreamer(self.console)
-        progress = Progress()
+        progress = Progress(steering=self.steering)
         watch = self.before_request(progress)
         status = None
         printed_thinking = False
@@ -845,15 +853,10 @@ class Agent:
         diff, changed = review.diff_of(self.tools.before, self.current_text, budget)
         if changed < review.MIN_CHANGED_LINES:
             return []
-        request = next(
-            (
-                context_tools.request_text(str(m.get("content", "")))
-                for m in reversed(self.messages)
-                if m.get("role") == "user"
-                and not str(m.get("content", "")).startswith(("[lcode]", sessions.SUMMARY_PREFIX))
-            ),
-            "",
-        )
+        request = self.turn_requests[0] if self.turn_requests else ""
+        if len(self.turn_requests) > 1:
+            added = "\n".join(f"- {note}" for note in self.turn_requests[1:])
+            request += f"\n\nWhat the user added while you worked:\n{added}"
         try:
             with self.console.status("Reviewing the change against your request…", spinner="dots"):
                 problems = review.run(self, request, answer, diff)
@@ -1069,6 +1072,7 @@ class Agent:
         self.turn_status = "running"
         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.turn_requests = [user_text.strip()]
         self.repeats.reset()
         self.check_results = []
         self.review_results = None
@@ -1081,6 +1085,8 @@ class Agent:
         for step in range(self.max_steps):
             if self.cancel is not None and self.cancel.is_set():
                 raise KeyboardInterrupt
+            if step and self.steering is not None:
+                self.steer()
             if step and self.autosave:
                 self.save()  # a crash or a closed terminal loses at most this step
             self.maybe_compact()
@@ -1126,6 +1132,8 @@ class Agent:
                 )
                 continue
             if not calls:
+                if self.steering is not None and self.steering.waiting():
+                    continue  # the user added a note while the model wrote its answer: it reads the note first
                 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
@@ -1241,6 +1249,34 @@ class Agent:
         self.turn_status = "success"
         self.print_stats()
 
+    def steer(self) -> None:
+        """Between two steps: pause if the user pressed Esc, then hand the model the notes typed meanwhile."""
+        steering = self.steering
+        if steering is None:
+            return
+        if steering.take_pause():
+            self.console.print(
+                Text(
+                    "⏸ Paused. Press Enter to go on, type a note to go on with it, or press Ctrl+C to stop the request.",
+                    style="yellow",
+                )
+            )
+            note = steering.ask("  ⏸ ").strip()
+            if note:
+                steering.add(note)
+        notes = steering.take()
+        if not notes:
+            return
+        self.turn_requests += notes
+        self.messages.append({"role": "user", "content": "\n\n".join(notes) + "\n\n" + NOTE_INTRO})
+        for note in notes:
+            shown = note if len(note) <= 200 else note[:200] + "…"
+            self.console.print(Text(f"✎ Note for the model: {shown}", style="cyan"))
+
+    def activity(self, phase: str):
+        """A spinner with the elapsed time while something runs (a command), with the note being typed under it."""
+        return self.console.status(Progress(phase, self.steering, tokens=False), spinner="dots")
+
     def print_stats(self) -> None:
         pct = 100 * self.ctx_used / self.settings.context
         self.console.print(

lcode/permissions.py

@@ -198,6 +198,7 @@ class Permissions:
         self.always: set[str] = set()
         self.rules = Rules()  # allow and deny lists from the settings (lcode.hooks)
         self.on_prompt = None  # called with the title before lcode asks the user (notification hooks)
+        self.read_line: Callable[[str], str] | None = None  # asks instead of input() (lcode.steer, during a request)
         # Decides instead of asking (lcode.api, lcode acp): True, False, or a message saying why not.
         self.approve: Callable[[dict], bool | str] | None = None
 
@@ -243,7 +244,8 @@ class Permissions:
         if kind == "mcp":
             scope = scope.replace(":", " › ", 1)
         try:
-            answer = input(f"  Allow? [y]es / [a]lways for '{scope}' this session / [n]o (+ optional reason): ")
+            question = f"  Allow? [y]es / [a]lways for '{scope}' this session / [n]o (+ optional reason): "
+            answer = (self.read_line or input)(question)
         except EOFError:
             return False, "The user denied this action (no input available)."
         answer = answer.strip()

lcode/repl.py

@@ -36,6 +36,7 @@ from lcode.checkpoints import Checkpoint, CheckpointError, Restore
 from lcode.config import PERMISSION_MODES, STATE_DIR, ConfigError, format_tokens, parse_context
 from lcode.hardware import Hardware
 from lcode.ollama import OllamaError
+from lcode.steer import KeyReader, Steering
 from lcode.tools import IGNORE_DIRS
 
 COMMANDS = {
@@ -874,6 +875,7 @@ def git_command(agent: Agent, cmd: str, arg: str) -> None:
 
 def run_safely(agent: Agent, text: str) -> None:
     started = time.monotonic()
+    reader = start_steering(agent) if agent.interactive else None
     try:
         agent.run_turn(text)
     except KeyboardInterrupt:
@@ -881,10 +883,33 @@ def run_safely(agent: Agent, text: str) -> None:
     except OllamaError as e:
         agent.console.print(f"[red]{e}[/]")
     finally:
+        if reader is not None:
+            stop_steering(agent, reader)
         agent.save()
         agent.finished(text, time.monotonic() - started)
 
 
+def start_steering(agent: Agent) -> KeyReader | None:
+    """Read the keyboard while the request runs: a typed line becomes a note for the model, Esc pauses."""
+    steering = Steering()
+    reader = KeyReader(steering)
+    if not reader.start():
+        return None  # not a terminal lcode can read keys from (or Windows): the request runs as before
+    agent.steering = steering
+    agent.perms.read_line = steering.ask  # questions take the keyboard back meanwhile
+    return reader
+
+
+def stop_steering(agent: Agent, reader: KeyReader) -> None:
+    reader.stop()
+    agent.steering = None
+    agent.perms.read_line = None
+    unsent = reader.steering.leftover()
+    if unsent:
+        agent.unsent = unsent
+        agent.console.print(Text("✎ What you typed didn't reach the model; it's in the prompt below.", style="cyan"))
+
+
 def session_start(agent: Agent) -> None:
     """session_start hooks: their output is shown, and with feedback = true also given to the model."""
     for outcome in agent.hooks.run("session_start", {"cwd": str(agent.cwd), "session": agent.session_id}, agent.cwd):
@@ -1115,13 +1140,13 @@ def resume_session(agent: Agent, info: sessions.SessionInfo) -> None:
 
 def print_recap(agent: Agent) -> None:
     """Show the last request and the start of the last answer, so it's clear where things left off."""
-    last_user = next((m for m in reversed(agent.messages) if m.get("role") == "user"), None)
+    requests = context_tools.user_requests(agent.messages)  # the user's own words, not lcode's notes to the model
     last_answer = next(
         (m for m in reversed(agent.messages) if m.get("role") == "assistant" and m.get("content", "").strip()), None
     )
-    if not last_user:
+    if not requests:
         return
-    lines = [f"[bold]You:[/] {escape(sessions.title_from([last_user]))}"]
+    lines = [f"[bold]You:[/] {escape(sessions.title_from([{'role': 'user', 'content': requests[-1]}]))}"]
     if last_answer:
         answer = " ".join(last_answer["content"].split())
         answer = answer if len(answer) <= 300 else answer[:299].rstrip() + "…"
@@ -1153,7 +1178,8 @@ def repl(agent: Agent, prompt: str | None, hardware: Hardware, cont: bool = Fals
     while True:
         try:
             agent.console.print()
-            line = session.prompt(HTML("<ansicyan><b>❯ </b></ansicyan>")).strip()
+            unsent, agent.unsent = agent.unsent, ""
+            line = session.prompt(HTML("<ansicyan><b>❯ </b></ansicyan>"), default=unsent).strip()
         except KeyboardInterrupt:
             continue
         except EOFError:

lcode/sessions.py

@@ -45,7 +45,9 @@ def title_from(messages: list[dict]) -> str:
         if content.startswith(SUMMARY_PREFIX):
             compacted = True
             continue
-        text = re.split(r"\n\n<(?:file|directory) path=", content, maxsplit=1)[0]
+        if content.startswith("[lcode]"):
+            continue  # lcode's own message to the model (a failed check, a review), not the user's words
+        text = re.split(r"\n\n(?:<(?:file|directory|image) path=|\[lcode[:\]] )", content, maxsplit=1)[0]
         text = " ".join(text.split())
         if text:
             return text if len(text) <= TITLE_LENGTH else text[: TITLE_LENGTH - 1].rstrip() + "…"

lcode/steer.py

@@ -0,0 +1,287 @@
+"""Steer a request while it runs: type a note for the model, or press Esc to pause after the step.
+
+With a local model a request can take minutes. Ctrl+C throws away the step in progress; a note doesn't
+interrupt anything: a line typed while lcode works is kept and handed to the model before its next step, and the
+spinner line shows what's being typed and what's waiting. Esc asks lcode to stop after the current step, so you
+can look at what it did and then go on, with or without a note.
+
+`Steering` holds the state and turns keystrokes into notes; it knows nothing about terminals, so it's easy to
+test. `KeyReader` reads the keys from the terminal in the background, without echoing them (that would garble
+the output), and hands the keyboard back whenever lcode asks a question (`Steering.ask`).
+"""
+
+from __future__ import annotations
+
+import codecs
+import contextlib
+import os
+import select
+import sys
+import threading
+import time
+from collections.abc import Callable, Iterator
+
+from rich.text import Text
+
+try:
+    import termios
+except ImportError:  # Windows: no steering, everything else works
+    termios = None  # type: ignore[assignment]
+
+MAX_NOTE = 4000  # characters in one note
+SHOWN = 45  # characters of the line being typed shown under the spinner (the line fits 80 columns)
+ESC_WAIT = 0.03  # an Esc followed by more bytes this soon is an arrow or function key, not the Esc key
+TOO_QUICK = 0.4  # an Enter this soon after a question appears was meant for the note being typed
+NOTE_INTRO = (
+    "[lcode] The user wrote this while you were working. Take it into account from here on; it doesn't mean "
+    "starting over unless it says so."
+)
+
+
+class Steering:
+    """Notes typed during a request, the line being typed, and whether to pause after the step."""
+
+    def __init__(self) -> None:
+        self.lock = threading.Lock()
+        self.typed = ""  # the line being typed
+        self.notes: list[str] = []  # finished lines, waiting for the model's next step
+        self.pause = False  # stop after the current step
+        self.reader: KeyReader | None = None
+        self.read_line: Callable[[str], str] | None = None  # input() when None (looked up when asking)
+
+    # Input ------------------------------------------------------------------------------------------------
+
+    def feed(self, keys: str) -> None:
+        """Keystrokes as text: printable characters, Enter, Backspace, Ctrl+U/Ctrl+W, Esc and escape sequences.
+
+        A lone "\\x1b" is the Esc key (KeyReader waits a moment for the rest of a sequence before it hands one
+        over). Everything else that starts with it is skipped: the sequences arrow and function keys send,
+        Alt+key, and a terminal's answers to queries (cursor position, colours).
+        """
+        with self.lock:
+            i = 0
+            while i < len(keys):
+                ch = keys[i]
+                i += 1
+                if ch == "\x1b":
+                    after = keys[i] if i < len(keys) else ""
+                    if after == "[":  # CSI: parameters, then a final byte in @..~
+                        i += 1
+                        while i < len(keys) and not ("@" <= keys[i] <= "~"):
+                            i += 1
+                        i += 1
+                    elif after == "O":  # SS3: one more character (F1-F4, keypad)
+                        i += 2
+                    elif after in ("]", "P", "_", "^"):  # a string (OSC, DCS…), ended by BEL or ESC \
+                        end = min(
+                            (j for j in (keys.find("\x07", i), keys.find("\x1b\\", i)) if j >= 0), default=len(keys)
+                        )
+                        i = end + (2 if keys.startswith("\x1b\\", end) else 1)
+                    elif after in ("", "\x1b"):  # the Esc key (twice in a row: two presses)
+                        self.pause = not self.pause
+                    else:
+                        i += 1  # Alt+key
+                elif ch in "\r\n":
+                    note = self.typed.strip()
+                    self.typed = ""
+                    if note:
+                        self.notes.append(note[:MAX_NOTE])
+                elif ch in "\x7f\x08":
+                    self.typed = self.typed[:-1]
+                elif ch == "\x15":  # Ctrl+U: clear the line
+                    self.typed = ""
+                elif ch == "\x17":  # Ctrl+W: delete the last word
+                    self.typed = self.typed.rstrip()
+                    self.typed = self.typed[: self.typed.rfind(" ") + 1] if " " in self.typed else ""
+                elif ch == "\t":
+                    self.typed += " "
+                elif ch >= " " and len(self.typed) < MAX_NOTE:
+                    self.typed += ch
+
+    # For the agent ----------------------------------------------------------------------------------------
+
+    def add(self, note: str) -> None:
+        with self.lock:
+            self.notes.append(note[:MAX_NOTE])
+
+    def waiting(self) -> bool:
+        with self.lock:
+            return bool(self.notes)
+
+    def take(self) -> list[str]:
+        """The notes waiting for the model (and forget them)."""
+        with self.lock:
+            notes, self.notes = self.notes, []
+            return notes
+
+    def take_pause(self) -> bool:
+        """Whether a pause was asked for (and clear the request)."""
+        with self.lock:
+            asked, self.pause = self.pause, False
+            return asked
+
+    def leftover(self) -> str:
+        """What never reached the model: notes still waiting and the unfinished line, for the next prompt."""
+        with self.lock:
+            text = "\n".join([*self.notes, self.typed.strip()]).strip()
+            self.notes, self.typed = [], ""
+            return text
+
+    def ask(self, question: str) -> str:
+        """Ask the user a question while the keyboard is being read for notes (permission prompts, the pause).
+
+        Keys typed before the question appeared are dropped, and an Enter pressed right as it appeared asks
+        once more: it was meant to finish a note, not to answer (an empty answer often means yes).
+        """
+        hold = self.reader.suspended() if self.reader is not None else contextlib.nullcontext()
+        with hold:
+            asked = time.monotonic()
+            answer = (self.read_line or input)(question)
+            if not answer.strip() and time.monotonic() - asked < TOO_QUICK:
+                answer = (self.read_line or input)(question)
+            return answer
+
+    def status(self) -> Text | None:
+        """The line under the spinner: what's being typed, notes waiting, a pause coming."""
+        with self.lock:
+            typed, waiting, pause = self.typed, len(self.notes), self.pause
+        parts: list[Text] = []
+        if typed:
+            shown = typed if len(typed) <= SHOWN else "…" + typed[-SHOWN:]
+            parts.append(Text.assemble(("✎ ", "cyan"), shown, ("▏", "cyan"), ("  Enter adds it as a note", "dim")))
+        if waiting:
+            what = "a note" if waiting == 1 else f"{waiting} notes"
+            parts.append(Text(f"✎ {what} waiting for the model's next step", style="cyan"))
+        if pause:
+            parts.append(Text("⏸ Pausing after this step (Esc again to go on without pausing)", style="yellow"))
+        if not parts:
+            return None
+        return Text("\n").join(parts)
+
+
+class KeyReader:
+    """Reads the keyboard in the background while a request runs, and gives the keys to a Steering.
+
+    The terminal stays in "cbreak" mode meanwhile: keys arrive one by one and aren't echoed, while Ctrl+C still
+    interrupts. `suspended()` hands the keyboard back, in its usual mode, for a question.
+    """
+
+    def __init__(self, steering: Steering, fd: int | None = None) -> None:
+        self.steering = steering
+        self.fd = fd  # stdin when None
+        self.saved: list | None = None
+        self.thread: threading.Thread | None = None
+        self.stopping = threading.Event()
+        self.hold = threading.Event()  # asked to stop reading for a while
+        self.held = threading.Event()  # ...and the thread has stopped
+        self.resume = threading.Event()
+        self.decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
+
+    def start(self) -> bool:
+        """Start reading; False when this isn't a terminal lcode can read keys from."""
+        if termios is None:
+            return False
+        try:
+            if self.fd is None:
+                self.fd = sys.stdin.fileno()
+            if not os.isatty(self.fd):
+                return False
+        except (OSError, ValueError):  # no real stdin (tests, some IDE consoles)
+            return False
+        try:
+            self.saved = termios.tcgetattr(self.fd)
+            self._cbreak()
+        except termios.error:
+            self.saved = None
+            return False
+        self.steering.reader = self
+        self.thread = threading.Thread(target=self._run, name="lcode-keys", daemon=True)
+        self.thread.start()
+        return True
+
+    def stop(self) -> None:
+        self.stopping.set()
+        self.resume.set()
+        if self.thread is not None:
+            self.thread.join(timeout=1)
+        self._restore()
+        self.steering.reader = None
+
+    def __enter__(self) -> KeyReader:
+        self.start()
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.stop()
+
+    @contextlib.contextmanager
+    def suspended(self) -> Iterator[None]:
+        """The keyboard back in its usual mode (echo, line editing) for a question, with typed-ahead keys dropped."""
+        if self.thread is None or not self.thread.is_alive():
+            yield
+            return
+        self.resume.clear()
+        self.hold.set()
+        self.held.wait(timeout=1)
+        self._restore()
+        with contextlib.suppress(termios.error):
+            termios.tcflush(self.fd, termios.TCIFLUSH)
+        try:
+            yield
+        finally:
+            with contextlib.suppress(termios.error):
+                self._cbreak()
+            self.hold.clear()
+            self.held.clear()
+            self.resume.set()
+
+    def _cbreak(self) -> None:
+        mode = termios.tcgetattr(self.fd)
+        mode[3] &= ~(termios.ECHO | termios.ICANON)  # lflags; ISIG stays, so Ctrl+C still interrupts
+        mode[6][termios.VMIN] = 1
+        mode[6][termios.VTIME] = 0
+        termios.tcsetattr(self.fd, termios.TCSANOW, mode)
+
+    def _restore(self) -> None:
+        if self.saved is not None:
+            with contextlib.suppress(termios.error):
+                termios.tcsetattr(self.fd, termios.TCSANOW, self.saved)
+
+    def _run(self) -> None:
+        while not self.stopping.is_set():
+            if self.hold.is_set():
+                self.held.set()
+                self.resume.wait()
+                continue
+            try:
+                ready, _, _ = select.select([self.fd], [], [], 0.1)
+                if not ready or self.hold.is_set():
+                    continue
+                data = os.read(self.fd, 1024)
+                if not data:
+                    return  # the terminal is gone
+                while incomplete_escape(data):
+                    more, _, _ = select.select([self.fd], [], [], ESC_WAIT)  # the rest of an escape sequence?
+                    if not more:
+                        break  # a lone "\x1b" is then the Esc key
+                    data += os.read(self.fd, 1024)
+            except (OSError, ValueError):
+                return
+            self.steering.feed(self.decoder.decode(data))
+
+
+def incomplete_escape(data: bytes) -> bool:
+    """Whether the bytes end in the middle of an escape sequence (or with a "\\x1b" that may start one)."""
+    start = data.rfind(b"\x1b")
+    if start < 0:
+        return False
+    tail = data[start:]
+    if tail == b"\x1b":
+        return True
+    if tail.startswith(b"\x1b["):
+        return not any(0x40 <= b <= 0x7E for b in tail[2:])
+    if tail.startswith(b"\x1bO"):
+        return len(tail) < 3
+    if tail[1:2] in (b"]", b"P", b"_", b"^"):
+        return b"\x07" not in tail  # (one ended by ESC \ has its last ESC there: complete)
+    return False

lcode/tools.py

@@ -1121,6 +1121,8 @@ class Toolbox:
         deadline = time.time() + int(timeout or 180)
         finished = 0.0  # when the command itself ended (its marker arrived)
         held_open = False  # something it started still holds the output open
+        spinner = self.agent.activity("Running the command")  # the elapsed time, and a note being typed
+        spinner.start()
         try:
             while True:
                 if self.agent.cancel is not None and self.agent.cancel.is_set():
@@ -1154,6 +1156,8 @@ class Toolbox:
             reading.clear()
             stop()
             raise
+        finally:
+            spinner.stop()
         reading.clear()
         code = proc.wait()
         if held_open and sandbox and token:

{lcode_cli-0.32.0.dist-info → lcode_cli-0.33.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.32.0
+Version: 0.33.1
 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/
@@ -35,11 +35,12 @@ Requires-Dist: encord>=0.1.200; extra == 'encord'
 Description-Content-Type: text/markdown
 
 <p align="center">
-  <img src="docs/assets/logo.svg" width="96" alt="lcode logo">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nasser1941/lcode/main/docs/assets/logo-dark.png">
+    <img src="https://raw.githubusercontent.com/nasser1941/lcode/main/docs/assets/logo.png" width="360" alt="lcode">
+  </picture>
 </p>
 
-<h1 align="center">lcode</h1>
-
 <p align="center">
   <b>A coding agent that runs entirely on your own machine.</b><br>
   Open-weight models · up to 256K tokens of context · your NVIDIA GPU or Apple Silicon Mac · your code stays local
@@ -49,7 +50,7 @@ Description-Content-Type: text/markdown
   <a href="https://github.com/nasser1941/lcode/actions/workflows/ci.yml"><img src="https://github.com/nasser1941/lcode/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
   <a href="https://nasser1941.github.io/lcode/"><img src="https://github.com/nasser1941/lcode/actions/workflows/docs.yml/badge.svg" alt="Docs"></a>
   <a href="https://pypi.org/project/lcode-cli/"><img src="https://img.shields.io/pypi/v/lcode-cli.svg" alt="PyPI"></a>
-  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT License"></a>
+  <a href="https://github.com/nasser1941/lcode/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT License"></a>
   <img src="https://img.shields.io/badge/python-3.10%2B-blue.svg" alt="Python 3.10+">
   <img src="https://img.shields.io/badge/platform-Linux%20%7C%20macOS%20(Apple%20Silicon)-lightgrey.svg" alt="Linux and macOS">
 </p>
@@ -58,11 +59,11 @@ Description-Content-Type: text/markdown
   <a href="https://nasser1941.github.io/lcode/"><b>Documentation</b></a> ·
   <a href="https://nasser1941.github.io/lcode/installation/">Install</a> ·
   <a href="https://nasser1941.github.io/lcode/models/">Models</a> ·
-  <a href="CONTRIBUTING.md">Contributing</a>
+  <a href="https://github.com/nasser1941/lcode/blob/main/CONTRIBUTING.md">Contributing</a>
 </p>
 
 <p align="center">
-  <img src="docs/assets/demo.svg" alt="lcode finding and fixing a bug, then running the tests" width="820">
+  <img src="https://raw.githubusercontent.com/nasser1941/lcode/main/docs/assets/demo.svg" alt="lcode finding and fixing a bug, then running the tests" width="820">
 </p>
 
 Point lcode at a repository and talk to it in your terminal. It explores the code, answers
@@ -222,8 +223,8 @@ See the pinned [Roadmap issue](https://github.com/nasser1941/lcode/issues/10). N
 ## Contributing
 
 Contributions are welcome: bug reports, model test results, docs and code. See
-[CONTRIBUTING.md](CONTRIBUTING.md). Please follow the [code of conduct](CODE_OF_CONDUCT.md), and
-report security issues privately as described in [SECURITY.md](SECURITY.md).
+[CONTRIBUTING.md](https://github.com/nasser1941/lcode/blob/main/CONTRIBUTING.md). Please follow the [code of conduct](https://github.com/nasser1941/lcode/blob/main/CODE_OF_CONDUCT.md), and
+report security issues privately as described in [SECURITY.md](https://github.com/nasser1941/lcode/blob/main/SECURITY.md).
 
 ## Acknowledgements
 
@@ -234,4 +235,4 @@ the open-weight models from Qwen, Poolside, NVIDIA and OpenAI,
 
 ## License
 
-[MIT](LICENSE) © 2026 Naser Derakhshan
+[MIT](https://github.com/nasser1941/lcode/blob/main/LICENSE) © 2026 Naser Derakhshan

{lcode_cli-0.32.0.dist-info → lcode_cli-0.33.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
-lcode/__init__.py,sha256=WYtKNLgt5PjAq5IrasutTzXxW9RCwY4T0ZQs0OxnnLs,473
+lcode/__init__.py,sha256=n_tK4I5-3-ii3F5D31XFOFGkqv0EUglLYce81_yaD-Q,473
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
 lcode/acp.py,sha256=d97VV3sbqXdWKhPQQNbYRaDTm8WrUk0mGbDLiOyX7jE,29058
 lcode/action.py,sha256=wuT5F9EJCdEligPeytzmEi8FpahWBhXer528tpuTj_k,16711
-lcode/agent.py,sha256=ztjxSzYkvUvwuHVEI9piFnuOV8glHBe9ULNIk7x2HKQ,72682
+lcode/agent.py,sha256=fs40oIivqNV6R_Y2Yp8jHbQUywK55czn3wRHrdViyQ0,75086
 lcode/api.py,sha256=YTfXVMSYSp1EC3tNI_fW-JcNBgrdFTN7V57HNIzB7Kc,15861
 lcode/backends.py,sha256=dtJHrC6ys73bRDg64z0tQz1PavmeAkiODZu1fOO9ExQ,20635
 lcode/bench.py,sha256=KDgPnkceZOS3gDDEl5j6-k8Ser2es4-IuV_S8p_46Zo,41517
@@ -29,19 +29,20 @@ lcode/memory.py,sha256=WZEHTp-lVxAwS-yyLQR2xB3TMZ9sejmX2Ivg7T-tl3w,21949
 lcode/models.toml,sha256=lt2G64zzo_Ryxv2ISRSNZoVD_JqCqYqsM01n8WoXGs8,4098
 lcode/notify.py,sha256=uieDeXe7XwuVHjOk4tqVyZEW_85XWkoWQmFOWEf77oc,1538
 lcode/ollama.py,sha256=u5tnvL28cfaFS4GhmiEsHhTQe6w3Ng_Tej05UUzLQTQ,7715
-lcode/permissions.py,sha256=3OPVVth6uTE5kcAWMZ8X_vUnFRbf6STEHAJimZX0Yu4,12118
+lcode/permissions.py,sha256=q7CjDsc_Xrblw7t3_BbxA5LUjxFSswGs1RiJmtMi0po,12288
 lcode/planning.py,sha256=Q2upaoZPnXDMQT2F-ETxX1lk_wDntTzhSKNVYIQSoQA,6540
 lcode/render.py,sha256=gMvf4W3qkLUJ4Vot3az_hP_zRDAItJC9pP-68dHFkfA,1375
 lcode/repeats.py,sha256=-vcbj363nFcIyso7yFJgsbHz9C6VOu2EOg3Svs4eFyE,4091
-lcode/repl.py,sha256=0f3nojURlQE8Pm_JkXvh9y7nEg1CHG3xanZIs0osPxw,52107
+lcode/repl.py,sha256=_krcqKqHKsGUKo4JfQS9KQNBxA47qE1k__TAkDTusRc,53242
 lcode/repomap.py,sha256=1GRJgEUjBl9XHSXsF7tSGXBCEgsY-3CzwMohaTudZ_M,13969
 lcode/residency.py,sha256=bDB2J0SZULDOz6wYuMCnkjacYk7pWi5f75iY83ycAXQ,6912
 lcode/review.py,sha256=0QBIS-R1B2b3zqx5TcC1qZptpKBbrDhYvMKSNCaDAUo,4686
 lcode/sandbox.py,sha256=u_pkrVRXhCGhh-wFDPwuZ3jGG7UeXxXRAeBNsm37ZvE,8608
 lcode/secretscan.py,sha256=6Euvfk2gCtK7lZbuQD84zgWuSECi6OnSw8V5rFu1tfU,13575
-lcode/sessions.py,sha256=wOR-J0EHgJxLSPboKPHnvBcp5VTUYTj3tZWgpsa6-K4,4013
+lcode/sessions.py,sha256=ojkpP453JyIll8_iFeJgW4BG4Zz2FKMRsLiij6spiTo,4185
+lcode/steer.py,sha256=0vaqLxgRKgC0yGp8xoQfV1f9VEOzH3U4rCIb74eFnZ8,12127
 lcode/subagents.py,sha256=GGn2E7QUwEsShJEHXaMhG53leyGFUZwJku_n33gJguU,29157
-lcode/tools.py,sha256=5qaQISmPqkQiM7i1b1_3lDxbokugGRyGNOmSHOBAFDQ,61426
+lcode/tools.py,sha256=Af4CYJUB7hCmsrNWAn5dIfI11YZFBTLclYaoEZ4Tsm4,61599
 lcode/update.py,sha256=i92bnW252VneYh0vD6djxmXsDOa5MXP20bjlLZUue_c,25236
 lcode/vision.py,sha256=w33QPmdGwP33wM4mvmAH4amFDZ1xzeXhEsSLJ-STSHY,4243
 lcode/web.py,sha256=vyxKbSRJTl1Lj3hj7Yd_NwTgbv0Xi6dup2YfUXjqp-Y,14579
@@ -61,8 +62,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.32.0.dist-info/METADATA,sha256=QWfst181FXU5mfBDoHdf_9FpIj_SJvVAkbSdvNNv5lo,12620
-lcode_cli-0.32.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.32.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
-lcode_cli-0.32.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.32.0.dist-info/RECORD,,
+lcode_cli-0.33.1.dist-info/METADATA,sha256=LlI-m-ksKjOELjiauEwss3yyFgw_1TX0uvyF-ZwhqVk,13141
+lcode_cli-0.33.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.33.1.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
+lcode_cli-0.33.1.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.33.1.dist-info/RECORD,,