lcode-cli 0.2.1__tar.gz → 0.2.2__tar.gz

{lcode_cli-0.2.1 → lcode_cli-0.2.2}/CHANGELOG.md

@@ -6,6 +6,15 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.2.2] - 2026-09-30
+
+### Added
+
+- `/context` now lets you change the context window mid-session: it lists the sizes the model
+  supports with the memory each needs and whether it fits on the GPU, and you pick one (or type
+  `/context 128k`). If the conversation is too long for a smaller size, lcode summarizes it first.
+  `/ctx` is a shortcut for the same command.
+
 ## [0.2.1] - 2026-09-29
 
 ### Fixed
@@ -107,7 +116,8 @@ First public release.
 - `AGENTS.md` project instructions and `/init` to generate them.
 - One-line installer for Linux and macOS.
 
-[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.2.1...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.2.2...HEAD
+[0.2.2]: https://github.com/nasser1941/lcode/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/nasser1941/lcode/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/nasser1941/lcode/compare/v0.1.2...v0.2.0
 [0.1.2]: https://github.com/nasser1941/lcode/compare/v0.1.1...v0.1.2

{lcode_cli-0.2.1 → lcode_cli-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.2.1
+Version: 0.2.2
 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/
@@ -124,7 +124,7 @@ lcode
 | `lcode --model qwen3.5-9b --context 128k` | pick a model and context window for this session |
 | `lcode models` / `lcode doctor` | what fits this machine / check the installation |
 | `/rename`, `/resume` | name the current session, resume a saved one |
-| `/model`, `/ctx 128k`, `/compact`, `/help` | switch model, resize context, summarize, list commands |
+| `/model`, `/context`, `/compact`, `/help` | switch model, resize the context window (pick from a list), summarize, list commands |
 
 ## Models
 

{lcode_cli-0.2.1 → lcode_cli-0.2.2}/README.md

@@ -91,7 +91,7 @@ lcode
 | `lcode --model qwen3.5-9b --context 128k` | pick a model and context window for this session |
 | `lcode models` / `lcode doctor` | what fits this machine / check the installation |
 | `/rename`, `/resume` | name the current session, resume a saved one |
-| `/model`, `/ctx 128k`, `/compact`, `/help` | switch model, resize context, summarize, list commands |
+| `/model`, `/context`, `/compact`, `/help` | switch model, resize the context window (pick from a list), summarize, list commands |
 
 ## Models
 

{lcode_cli-0.2.1 → lcode_cli-0.2.2}/SECURITY.md

@@ -6,7 +6,7 @@ lcode is young; security fixes go into the latest release on `main`.
 
 | Version | Supported |
 |---|---|
-| 0.1.x (latest) | ✅ |
+| 0.2.x (latest) | ✅ |
 | older | ❌ |
 
 ## Reporting a vulnerability

{lcode_cli-0.2.1 → lcode_cli-0.2.2}/docs/models.md

@@ -91,9 +91,20 @@ lcode --context 64k                      # this session only
 lcode config set context 128k            # change the saved default
 ```
 
+Inside a session, `/context` lists the sizes the model supports, with the memory each needs and
+whether it fits on the GPU, and lets you pick one (or type `/context 128k` directly). The model
+reloads with the new size on your next message; if the conversation is too long for a smaller size,
+lcode summarizes it first.
+
 ```text
-❯ /ctx 128k      # inside a session (the model reloads on the next request)
-❯ /ctx           # show the current window and the model maximum
+❯ /context
+Context window for lcode-qwen3.6-35b
+ #  Size  Memory · fit
+ 1   16K  ~22 GB · GPU + RAM
+ 2   32K  ~23 GB · GPU + RAM
+ …
+ 5  256K  ~28 GB · GPU + RAM   current, recommended
+  Choose a number, a size like 96k, or press Enter to keep 256K: 2
 ```
 
 Sizes accept `k` and `m` suffixes (`128k` = 131,072 tokens, `1m` = 1,048,576). When the window is

{lcode_cli-0.2.1 → lcode_cli-0.2.2}/docs/quickstart.md

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

{lcode_cli-0.2.1 → lcode_cli-0.2.2}/docs/usage.md

@@ -50,8 +50,7 @@ reasoning is on.
 | `/rename NAME` | Name the current session so it's easy to find later |
 | `/resume [SESSION]` | Resume a saved session: pick from a list, or give its number or name; `/resume all` lists every folder |
 | `/compact [focus]` | Summarize the conversation to free context |
-| `/context` | Show how full the context window is |
-| `/ctx [size]` | Show or change the context window |
+| `/context [size]` | Show how full the context window is and change its size: pick from a list with memory estimates, or give a size like `/context 128k` (`/ctx` is a shortcut) |
 | `/model [name]`, `/models` | Switch model, list models |
 | `/think [on\|off]` | Toggle reasoning |
 | `/verbose` | Toggle showing the reasoning text |

{lcode_cli-0.2.1 → lcode_cli-0.2.2}/src/lcode/__init__.py

@@ -1,3 +1,3 @@
 """lcode — a local-first terminal coding agent powered by open-weight models via Ollama."""
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"

{lcode_cli-0.2.1 → lcode_cli-0.2.2}/src/lcode/repl.py

@@ -21,7 +21,7 @@ from rich.table import Table
 from rich.text import Text
 
 from lcode import __version__, catalog, limits, sessions, web
-from lcode.agent import INIT_PROMPT, Agent
+from lcode.agent import AUTO_COMPACT_RATIO, INIT_PROMPT, Agent
 from lcode.catalog import MIN_USEFUL_CONTEXT
 from lcode.config import PERMISSION_MODES, STATE_DIR, ConfigError, format_tokens, parse_context
 from lcode.hardware import Hardware
@@ -35,8 +35,8 @@ COMMANDS = {
     "/rename": "Name this session so you can find it later, e.g. /rename auth refactor",
     "/resume": "Resume a saved session: pick from a list, or /resume <number|name> (/resume all: every folder)",
     "/compact": "Summarize the conversation to free context (optional: what to focus on)",
-    "/context": "Show context-window usage",
-    "/ctx": "Show or change the context window, e.g. /ctx 128k",
+    "/context": "Show context usage and change the window size: pick from a list, or /context 128k",
+    "/ctx": "Shortcut for /context",
     "/model": "Show or switch model, e.g. /model qwen3.5-9b",
     "/models": "List models and how they fit this machine",
     "/think": "Toggle model reasoning on/off",
@@ -145,6 +145,114 @@ def banner(agent: Agent) -> None:
     )
 
 
+CONTEXT_CHOICES = (16384, 32768, 65536, 131072, 262144, 524288, 1048576)
+
+
+def context_options(agent: Agent, hardware: Hardware) -> list[dict]:
+    """The context sizes this model supports, with how each one fits this machine."""
+    s = agent.settings
+    spec = catalog.find(s.model)
+    try:
+        max_ctx = agent.ollama.max_context(s.model) or (spec.max_context if spec else None)
+    except OllamaError:
+        max_ctx = spec.max_context if spec else None
+    sizes = {c for c in CONTEXT_CHOICES if not max_ctx or c <= max_ctx} | {s.context}
+    if max_ctx:
+        sizes.add(max_ctx)
+    learned = limits.get(s.model)
+    recommended = limits.cap(s.model, spec.fit(hardware)[0]) if spec and spec.fit(hardware)[0] else None
+    options = []
+    for size in sorted(sizes):
+        if spec:
+            memory = spec.memory_gib(size)
+            if hardware.unified:
+                fit = "fits" if memory <= hardware.budget_gib - catalog.HEADROOM_GIB else "too large"
+            elif hardware.gpu and memory <= hardware.vram_gib:
+                fit = "on GPU"
+            elif memory <= hardware.budget_gib - catalog.HEADROOM_GIB:
+                fit = "GPU + RAM" if spec.moe else "GPU + RAM, slow"
+            else:
+                fit = "too large"
+            note = f"~{memory:.0f} GB · {fit}"
+        else:
+            note = "no memory estimate for this model"
+        if learned and size > learned:
+            note += " · ran out of memory here before"
+        options.append({"size": size, "note": note, "current": size == s.context, "recommended": size == recommended})
+    return options
+
+
+def context_command(agent: Agent, arg: str, hardware: Hardware) -> None:
+    """Show context usage and change the window size, from a list or directly (/context 128k)."""
+    c, s = agent.console, agent.settings
+    c.print(
+        f"In use: {format_tokens(agent.ctx_used)} of {format_tokens(s.context)} tokens "
+        f"({100 * agent.ctx_used / s.context:.0f}%) in {len(agent.messages)} message"
+        f"{'' if len(agent.messages) == 1 else 's'}; auto-compacts at 85%."
+    )
+    if arg:
+        try:
+            apply_context(agent, parse_context(arg), hardware)
+        except ConfigError as e:
+            c.print(f"[red]{e}[/]")
+        return
+    options = context_options(agent, hardware)
+    table = Table(title=f"Context window for {s.model}", title_justify="left", header_style="bold")
+    table.add_column("#", justify="right", style="cyan")
+    table.add_column("Size", justify="right")
+    table.add_column("Memory · fit")
+    table.add_column("")
+    for i, option in enumerate(options, 1):
+        marks = []
+        if option["current"]:
+            marks.append("[bold]current[/]")
+        if option["recommended"]:
+            marks.append("[cyan]recommended[/]")
+        table.add_row(str(i), format_tokens(option["size"]), option["note"], ", ".join(marks))
+    c.print(table)
+    try:
+        answer = input(f"  Choose a number, a size like 96k, or press Enter to keep {format_tokens(s.context)}: ")
+    except EOFError:
+        return
+    answer = answer.strip()
+    if not answer:
+        c.print(f"Keeping {format_tokens(s.context)}.")
+        return
+    if answer.isdigit() and 1 <= int(answer) <= len(options):
+        size = options[int(answer) - 1]["size"]
+    else:
+        try:
+            size = parse_context(answer)
+        except ConfigError as e:
+            c.print(f"[red]{e}[/]")
+            return
+    apply_context(agent, size, hardware)
+
+
+def apply_context(agent: Agent, size: int, hardware: Hardware) -> None:
+    c, s = agent.console, agent.settings
+    if size == s.context:
+        c.print(f"The context window is already {format_tokens(size)}.")
+        return
+    if agent.has_conversation() and agent.ctx_used > AUTO_COMPACT_RATIO * size:
+        c.print(
+            f"This conversation uses {format_tokens(agent.ctx_used)} tokens, too much for {format_tokens(size)}; "
+            "summarizing it first."
+        )
+        try:
+            agent.compact()
+        except OllamaError as e:
+            c.print(f"[red]Couldn't summarize the conversation, so the context stays the same: {e}[/]")
+            return
+    c.print(agent.set_context(size))
+    spec = catalog.find(s.model)
+    if spec and spec.memory_gib(s.context) > hardware.budget_gib:
+        c.print(
+            f"[yellow]~{spec.memory_gib(s.context):.0f} GB needed but ~{hardware.budget_gib:.0f} GB available; "
+            "this may run out of memory, in which case lcode falls back to a smaller size.[/]"
+        )
+
+
 def web_status(agent: Agent) -> str:
     if agent.settings.web == "off":
         return "off"
@@ -196,28 +304,8 @@ def handle_command(agent: Agent, line: str, hardware: Hardware) -> bool:
             resume_session(agent, info)
     elif cmd == "/compact":
         agent.compact(arg)
-    elif cmd == "/context":
-        c.print(
-            f"Context: {format_tokens(agent.ctx_used)} of {format_tokens(s.context)} tokens "
-            f"({100 * agent.ctx_used / s.context:.1f}%) in {len(agent.messages)} messages; "
-            "auto-compacts at 85%."
-        )
-    elif cmd == "/ctx":
-        if not arg:
-            spec = catalog.find(s.model)
-            extra = f" · model maximum {format_tokens(spec.max_context)}" if spec else ""
-            c.print(f"Context window: {format_tokens(s.context)} tokens{extra}. Change it with /ctx 128k")
-        else:
-            try:
-                c.print(agent.set_context(parse_context(arg)))
-            except ConfigError as e:
-                c.print(f"[red]{e}[/]")
-            spec = catalog.find(s.model)
-            if spec and spec.memory_gib(s.context) > hardware.budget_gib:
-                c.print(
-                    f"[yellow]~{spec.memory_gib(s.context):.0f} GB needed but ~{hardware.budget_gib:.0f} GB "
-                    "available; this may run out of memory.[/]"
-                )
+    elif cmd in ("/context", "/ctx"):
+        context_command(agent, arg, hardware)
     elif cmd == "/models":
         print_models(agent.ollama, hardware, s.model)
     elif cmd == "/model":

lcode_cli-0.2.2/tests/test_context_picker.py

@@ -0,0 +1,73 @@
+import pytest
+
+from conftest import output, reply
+from lcode import limits
+from lcode.hardware import Hardware
+from lcode.repl import context_options, handle_command
+
+LAPTOP = Hardware("linux", "x", 31, "RTX 4080 Laptop", 12)
+
+
+def answer(monkeypatch, text):
+    monkeypatch.setattr("builtins.input", lambda _: text)
+
+
+def test_options_show_fit_current_and_recommended(agent):
+    options = {o["size"]: o for o in context_options(agent, LAPTOP)}
+    assert sorted(options) == [16384, 32768, 65536, 131072, 262144]  # capped at the model's 256K
+    assert options[65536]["current"] and options[262144]["recommended"]
+    assert options[262144]["note"] == "~28 GB · GPU + RAM"
+
+
+def test_options_warn_about_sizes_that_ran_out_of_memory(agent):
+    limits.record(agent.settings.model, 131072)
+    options = {o["size"]: o for o in context_options(agent, LAPTOP)}
+    assert "ran out of memory here before" in options[262144]["note"]
+    assert "ran out of memory" not in options[131072]["note"]
+    assert options[131072]["recommended"]
+
+
+def test_options_for_models_outside_the_catalog(make_agent):
+    agent = make_agent(model="custom:7b", context=8192)
+    options = context_options(agent, LAPTOP)
+    assert options[0]["size"] == 8192 and options[0]["current"]
+    assert options[0]["note"] == "no memory estimate for this model"
+
+
+def test_pick_by_number(agent, monkeypatch):
+    answer(monkeypatch, "4")  # 16K, 32K, 64K, 128K, ...
+    handle_command(agent, "/context", LAPTOP)
+    assert agent.settings.context == 131072
+    assert "Context window set to 128K" in output(agent)
+
+
+def test_pick_by_size_and_keep(agent, monkeypatch):
+    answer(monkeypatch, "96k")
+    handle_command(agent, "/context", LAPTOP)
+    assert agent.settings.context == 98304
+    answer(monkeypatch, "")
+    handle_command(agent, "/ctx", LAPTOP)
+    assert agent.settings.context == 98304 and "Keeping 96K" in output(agent)
+
+
+def test_bad_answer_changes_nothing(agent, monkeypatch):
+    answer(monkeypatch, "lots")
+    handle_command(agent, "/context", LAPTOP)
+    assert agent.settings.context == 65536 and "invalid context size" in output(agent)
+
+
+def test_direct_size_skips_the_list(agent, monkeypatch):
+    monkeypatch.setattr("builtins.input", lambda _: pytest.fail("should not ask"))
+    handle_command(agent, "/context 32k", LAPTOP)
+    assert agent.settings.context == 32768
+
+
+def test_shrinking_below_the_conversation_summarizes_first(make_agent, monkeypatch):
+    agent = make_agent([reply("first answer"), reply("SUMMARY of the work")])
+    agent.run_turn("a long task")
+    agent.ctx_used = 60000  # more than 85% of 32K
+    monkeypatch.setattr("builtins.input", lambda _: pytest.fail("should not ask"))
+    handle_command(agent, "/context 32k", LAPTOP)
+    assert agent.settings.context == 32768
+    assert "SUMMARY of the work" in agent.messages[1]["content"]
+    assert "summarizing it first" in output(agent)