localcode 0.3.17__tar.gz → 0.3.18__tar.gz

{localcode-0.3.17/src/localcode.egg-info → localcode-0.3.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.17
+Version: 0.3.18
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.3.17 → localcode-0.3.18}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.3.17"
+version = "0.3.18"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
 requires-python = ">=3.10"

{localcode-0.3.17 → localcode-0.3.18}/src/localcode/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.3.17"
+__version__ = "0.3.18"

{localcode-0.3.17 → localcode-0.3.18}/src/localcode/agent/loop.py

@@ -361,6 +361,31 @@ def run_agent_loop(
     if not messages or messages[-1].get("content") != user_text:
         messages.append({"role": "user", "content": user_text})
 
+    # Attach any images pasted in the TUI to THIS turn's user message.
+    # app.ask()/compose_messages is text-only, so the base64 images ride
+    # on the app object (stashed by the chat screen). We rebuild the
+    # matching user message here — where the loop owns the message list —
+    # via the composer's OpenAI-compatible image_url parts. Cleared after
+    # so images send exactly once, and only when the model can see them.
+    _pending_imgs = getattr(app, "_pending_images", None)
+    if _pending_imgs:
+        app._pending_images = []
+        _profile = getattr(app, "profile", None)
+        if _profile is not None and getattr(_profile, "supports_vision", False):
+            try:
+                from ..composer import _build_user_message
+                _provider = getattr(getattr(app, "config", None).runtime, "provider", "llama_cpp")
+                for _i in range(len(messages) - 1, -1, -1):
+                    if (messages[_i].get("role") == "user"
+                            and messages[_i].get("content") == user_text):
+                        messages[_i] = _build_user_message(
+                            user_text, list(_pending_imgs), _profile, _provider
+                        )
+                        break
+            except Exception:
+                # Never let image plumbing break a normal text turn.
+                pass
+
     full_response: list[str] = []
     start_time = time.time()
     tools_called: list[str] = []
@@ -1301,7 +1326,7 @@ def run_agent_loop(
                 try:
                     from ..tools.project_check import run_project_check
                     out.print_info("Verifying — running the project's typecheck…")
-                    _proj_errors = run_project_check(str(app.repo_root))
+                    _proj_errors = run_project_check(str(app.repo_root), ctx_tokens=_ctx_tokens_turn)
                 except Exception:
                     _proj_errors = None
                 try:

{localcode-0.3.17 → localcode-0.3.18}/src/localcode/config.py

@@ -45,6 +45,7 @@ llama_cpp_lookup_cache = false
 kv_cache_type_k = "q8_0"
 kv_cache_type_v = "turbo4"
 llama_cpp_binary = ""
+vision_enabled = false
 temperature = 1.0
 max_context_chars = 200000
 request_timeout_seconds = 600
@@ -116,6 +117,11 @@ class RuntimeConfig:
     diffusion_cli_binary: str = ""         # llama-diffusion-cli path (DiffusionGemma runner; built on demand)
     cohere_server_binary: str = ""         # llama-server with cohere2moe (North-Mini-Code; built on demand from PR #24260)
     model_dir: str = ""                    # directory where GGUFs download to (blank → ~/.local/share/localcode/models)
+    # Vision toggle. Tracks whether the multimodal projector should be
+    # loaded (--mmproj) alongside the text decoder. Persisted so turning
+    # vision OFF just relaunches WITHOUT --mmproj (frees RAM) while KEEPING
+    # the projector file on disk — re-enabling is instant, no re-download.
+    vision_enabled: bool = False
     temperature: float = 1.0  # Unsloth's official Gemma 4 recommendation — prevents IQ3_S mode-collapse loops
     max_context_chars: int = 200000
     request_timeout_seconds: int = 600
@@ -241,6 +247,7 @@ def save_config(config: AppConfig) -> Path:
         f'diffusion_cli_binary = "{config.runtime.diffusion_cli_binary}"\n'
         f'cohere_server_binary = "{config.runtime.cohere_server_binary}"\n'
         f'model_dir = "{config.runtime.model_dir}"\n'
+        f"vision_enabled = {'true' if config.runtime.vision_enabled else 'false'}\n"
         f"temperature = {config.runtime.temperature}\n"
         f"max_context_chars = {config.runtime.max_context_chars}\n"
         f"request_timeout_seconds = {config.runtime.request_timeout_seconds}\n"
@@ -321,6 +328,7 @@ def load_config() -> AppConfig:
         diffusion_cli_binary=os.environ.get("LOCALCODE_DIFFUSION_CLI_BINARY", runtime_data.get("diffusion_cli_binary", "")),
         cohere_server_binary=os.environ.get("LOCALCODE_COHERE_SERVER_BINARY", runtime_data.get("cohere_server_binary", "")),
         model_dir=os.environ.get("LOCALCODE_MODEL_DIR", runtime_data.get("model_dir", "")),
+        vision_enabled=str(os.environ.get("LOCALCODE_VISION_ENABLED", runtime_data.get("vision_enabled", False))).lower() in {"1", "true", "yes", "on"},
         # `llama_cpp_spec_type` migration (2026-04-26): old configs
         # auto-saved "ngram-mod" or "ngram-simple" from a benchmark
         # preset. N-gram speculative decoding looks up matching

{localcode-0.3.17 → localcode-0.3.18}/src/localcode/runtime.py

@@ -410,17 +410,21 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
             "--threads", str(threads),
             "--flash-attn", "on" if flash_attn_on else "off",
         ]
-        # Multimodal projector — if the currently-selected catalog entry
-        # has an mmproj sidecar AND the sidecar is on disk, pass --mmproj
-        # so llama-server loads the vision encoder alongside the text
-        # decoder. We don't auto-download here; the chat layer prompts
-        # the user on first vision use (see voice.py / vision flow).
+        # Multimodal projector — pass --mmproj only when vision is
+        # ENABLED (config flag) AND the currently-selected catalog entry
+        # has an mmproj sidecar present on disk. Gating on the flag (not
+        # file presence alone) is what lets /vision OFF free the encoder
+        # RAM by relaunching without --mmproj while KEEPING the projector
+        # file on disk — so re-enabling never re-downloads. We don't
+        # auto-download here; the chat layer prompts the user on first
+        # vision use (see voice.py / vision flow).
         try:
-            from .models_catalog import by_filename
-            from pathlib import Path as _P
-            choice = by_filename(_P(model_path).name)
-            if choice is not None and choice.mmproj_path and choice.mmproj_path.is_file():
-                cmd.extend(["--mmproj", str(choice.mmproj_path)])
+            if getattr(self.config, "vision_enabled", False):
+                from .models_catalog import by_filename
+                from pathlib import Path as _P
+                choice = by_filename(_P(model_path).name)
+                if choice is not None and choice.mmproj_path and choice.mmproj_path.is_file():
+                    cmd.extend(["--mmproj", str(choice.mmproj_path)])
         except Exception:
             # Never block server launch on mmproj lookup
             pass

{localcode-0.3.17 → localcode-0.3.18}/src/localcode/tools/project_check.py

@@ -23,13 +23,22 @@ import shutil
 import subprocess
 
 _TIMEOUT = 60.0
-_MAX_ERR_CHARS = 2500
+_MAX_ERR_CHARS = 2500  # floor; scaled up to the real context window at call time
 _ANSI = re.compile(r"\x1b\[[0-9;]*m")
 
 
-def run_project_check(repo_root: str) -> str | None:
+def run_project_check(repo_root: str, ctx_tokens: int = 0) -> str | None:
     """Run the first available typecheck/lint for the project; return a bounded
-    error summary, or None if clean / nothing to run."""
+    error summary, or None if clean / nothing to run.
+
+    `ctx_tokens` (the model's real context window) scales the error-text cap so a
+    big-window model can see more of a wall of tsc/build errors it has room for,
+    instead of a fixed 2500-char slice; floored at 2500 so small machines are
+    unchanged.
+    """
+    max_err_chars = _MAX_ERR_CHARS
+    if ctx_tokens:
+        max_err_chars = max(_MAX_ERR_CHARS, int(ctx_tokens * 3.5 * 0.04))
     env = {**os.environ, "NO_COLOR": "1", "FORCE_COLOR": "0"}
     for label, argv, cwd in _detect_commands(repo_root):
         try:
@@ -42,10 +51,12 @@ def run_project_check(repo_root: str) -> str | None:
         if r.returncode != 0:
             out = _ANSI.sub("", ((r.stdout or "") + "\n" + (r.stderr or "")).strip())
             # Keep only the most useful lines, capped, so we don't flood a
-            # small model's context with a wall of output.
-            lines = [l for l in out.splitlines() if l.strip()][:40]
+            # small model's context with a wall of output. The line cap also
+            # scales with the window (40 on a small machine → more on a big one).
+            max_lines = 40 if not ctx_tokens else max(40, int(ctx_tokens / 4000))
+            lines = [l for l in out.splitlines() if l.strip()][:max_lines]
             if lines:
-                return f"[{label}] reported errors:\n" + "\n".join(lines)[:_MAX_ERR_CHARS]
+                return f"[{label}] reported errors:\n" + "\n".join(lines)[:max_err_chars]
     return None
 
 

localcode-0.3.18/src/localcode/tui/clipboard_image.py

@@ -0,0 +1,131 @@
+"""Read an image off the OS clipboard as PNG bytes.
+
+Terminals never hand an application image data through a Cmd+V / Ctrl+V
+paste — the OS only pastes text, so an image paste arrives as an EMPTY
+paste event. When that happens the TUI calls :func:`read_clipboard_png`
+to pull the image directly out of the OS clipboard and attach it.
+
+macOS-only. On every other platform this returns ``None`` (no
+dependency, no crash) so callers can attempt it unconditionally.
+
+Implementation notes
+--------------------
+We shell out to ``osascript`` (always present on macOS, no new Python
+dependency). Two cases are handled:
+
+1. Raw image data on the clipboard (e.g. a screenshot from Cmd+Shift+4
+   or "Copy Image" in a browser). We coerce the clipboard to
+   ``«class PNGf»`` and write the bytes to a temp file, then read them
+   back in Python.
+2. A copied image FILE (e.g. Finder "Copy" on a .png). The clipboard
+   exposes a file URL (``«class furl»``); if it points at a common
+   image extension we read that file directly.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+_IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".gif", ".webp"}
+_PNG_MAGIC = b"\x89PNG\r\n\x1a\n"
+
+
+def read_clipboard_png() -> bytes | None:
+    """Return image bytes from the OS clipboard, or ``None``.
+
+    Prefers a PNG coercion of raw clipboard image data; falls back to a
+    copied image file. Returns ``None`` on non-macOS platforms and
+    whenever the clipboard holds no image.
+    """
+    if sys.platform != "darwin":
+        return None
+    data = _read_png_via_osascript()
+    if data:
+        return data
+    return _read_image_from_file_url()
+
+
+def _read_png_via_osascript() -> bytes | None:
+    """Coerce raw clipboard image data to PNG and read the bytes."""
+    fd, tmp_path = tempfile.mkstemp(suffix=".png")
+    os.close(fd)
+    try:
+        # AppleScript: try to grab the clipboard as PNG; bail with a
+        # sentinel if there's no image. Write to a temp file we can read
+        # back. `«class PNGf»` is the PNG pasteboard type; `«class furl»`
+        # (used below) is a file URL.
+        script = (
+            "try\n"
+            "\tset pngData to (the clipboard as «class PNGf»)\n"
+            "on error\n"
+            "\treturn \"NO_IMAGE\"\n"
+            "end try\n"
+            f"set outFile to (POSIX file \"{tmp_path}\")\n"
+            "try\n"
+            "\tset fh to open for access outFile with write permission\n"
+            "\tset eof fh to 0\n"
+            "\twrite pngData to fh\n"
+            "\tclose access fh\n"
+            "on error\n"
+            "\ttry\n"
+            "\t\tclose access fh\n"
+            "\tend try\n"
+            "\treturn \"WRITE_ERROR\"\n"
+            "end try\n"
+            "return \"OK\"\n"
+        )
+        result = subprocess.run(
+            ["osascript", "-e", script],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        if (result.stdout or "").strip() != "OK":
+            return None
+        data = Path(tmp_path).read_bytes()
+        return data if _looks_like_png(data) else None
+    except Exception:
+        return None
+    finally:
+        try:
+            os.unlink(tmp_path)
+        except Exception:
+            pass
+
+
+def _read_image_from_file_url() -> bytes | None:
+    """Read a copied image FILE (Finder copy) from its clipboard URL."""
+    script = (
+        "try\n"
+        "\treturn POSIX path of (the clipboard as «class furl»)\n"
+        "on error\n"
+        "\treturn \"\"\n"
+        "end try\n"
+    )
+    try:
+        result = subprocess.run(
+            ["osascript", "-e", script],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except Exception:
+        return None
+    path_str = (result.stdout or "").strip()
+    if not path_str:
+        return None
+    p = Path(path_str)
+    if p.suffix.lower() not in _IMAGE_EXTS or not p.is_file():
+        return None
+    try:
+        return p.read_bytes()
+    except Exception:
+        return None
+
+
+def _looks_like_png(data: bytes) -> bool:
+    return bool(data) and data[:8] == _PNG_MAGIC

{localcode-0.3.17 → localcode-0.3.18}/src/localcode/tui/screens/chat.py

@@ -570,6 +570,16 @@ class _ChatTextArea(TextArea):
         # row in a live terminal.
         text = getattr(event, "text", "") or ""
         if not text:
+            # A terminal pastes ONLY text; an image copied to the OS
+            # clipboard arrives here as an EMPTY paste. This is exactly
+            # where we hook image capture: read the clipboard for a PNG
+            # and, if present, attach it to the next message.
+            try:
+                handler = getattr(self.screen, "_attach_clipboard_image", None)
+                if callable(handler) and handler():
+                    event.stop()
+            except Exception:
+                pass
             return
         joined = text.replace("\r\n", "\n").replace("\r", "\n")
         prevent_default = getattr(event, "prevent_default", None)
@@ -984,6 +994,9 @@ class ChatScreen(Screen):
         # App.notify exactly once per finished/failed download.
         self._dl_notified: set[str] = set()
         self._pending_messages: list[str] = []
+        # Base64-encoded images captured from an empty (image) clipboard
+        # paste, attached to the FIRST user message of the next turn.
+        self._pending_images: list[str] = []
         self._stream_buf: list[str] = []
         self._last_assistant_text: str = ""
         self._turn_start: float = 0
@@ -2230,7 +2243,9 @@ class ChatScreen(Screen):
         # Resolve the catalog entry behind the configured model path.
         choice = current_choice(config)
         model_disp = choice.name if choice is not None else _P(config.runtime.model or "—").name
-        mmproj_on = "yes" if (choice and choice.mmproj_path and choice.mmproj_path.is_file()) else "no"
+        _vision_on = bool(getattr(config.runtime, "vision_enabled", False))
+        _mmproj_cached = bool(choice and choice.mmproj_path and choice.mmproj_path.is_file())
+        mmproj_on = "yes" if (_vision_on and _mmproj_cached) else ("off (cached)" if _mmproj_cached else "no")
 
         # Voice state (lazy)
         vs = getattr(self.tui, "voice_state", None)
@@ -2679,6 +2694,16 @@ class ChatScreen(Screen):
                 "Type [bold]/vision[/] again to retry — partial download is preserved."
             )
             return
+        # Persist the enabled flag now that the projector is on disk, so
+        # the runtime relaunches WITH --mmproj and future toggles never
+        # re-download (the file stays put; OFF just drops --mmproj).
+        try:
+            cfg = self.tui.config
+            cfg.runtime.vision_enabled = True
+            from ...config import save_config
+            save_config(cfg)
+        except Exception:
+            pass
         log.append_info("Vision projector ready — restarting server to activate...")
         self._restart_for_vision_change(reason="Vision ON")
 
@@ -2752,6 +2777,69 @@ class ChatScreen(Screen):
 
         self.run_worker(_worker, thread=True, exclusive=False)
 
+    def _attach_clipboard_image(self) -> bool:
+        """Empty paste → maybe an image sits on the OS clipboard.
+
+        Reads it as PNG, base64-encodes it into `_pending_images` (sent
+        with the next message), shows a visible indicator, and auto-enables
+        vision when the model supports it. Returns True if an image was
+        attached (so the caller can `event.stop()` and avoid a terminal
+        beep). macOS-only under the hood; a no-op elsewhere.
+        """
+        try:
+            from ..clipboard_image import read_clipboard_png
+        except Exception:
+            return False
+        try:
+            png = read_clipboard_png()
+        except Exception:
+            png = None
+        if not png:
+            return False
+        import base64
+        b64 = base64.b64encode(png).decode("ascii")
+        if getattr(self, "_pending_images", None) is None:
+            self._pending_images = []
+        self._pending_images.append(b64)
+        n = len(self._pending_images)
+        try:
+            log = self.query_one("#chat-log", ChatLog)
+            log.append_info(
+                f"📎 image attached ({n}) — it will be sent with your next message"
+            )
+        except Exception:
+            pass
+        try:
+            self._maybe_enable_vision_for_image()
+        except Exception:
+            pass
+        return True
+
+    def _maybe_enable_vision_for_image(self) -> None:
+        """After attaching a pasted image, make sure the model can see it.
+
+        If the current model supports vision but vision is OFF, enable it
+        (which only downloads the projector when genuinely missing). If the
+        model can't do vision at all, tell the user to switch models.
+        """
+        try:
+            from ...models_catalog import current as current_choice
+            config = self.tui.config
+            choice = current_choice(config)
+            log = self.query_one("#chat-log", ChatLog)
+        except Exception:
+            return
+        if choice is None or not getattr(choice, "supports_vision", False):
+            log.append_info(
+                "Note: the current model can't see images — switch to a vision "
+                "model with /model to use this attachment."
+            )
+            return
+        if getattr(config.runtime, "vision_enabled", False):
+            return  # already on
+        log.append_info("Enabling vision so the model can see this image…")
+        self._handle_vision_command("/vision")
+
     def _handle_vision_command(self, text: str) -> None:
         """`/vision` toggles vision on/off for the current model.
 
@@ -2781,25 +2869,32 @@ class ChatScreen(Screen):
         except Exception:
             pass
         mmproj = choice.mmproj_path
-        has = bool(mmproj and mmproj.is_file())
+        # `file_on_disk` = projector already downloaded; `enabled` = the
+        # persistent config flag that decides whether the server loads it.
+        # ON/OFF is driven by the FLAG, not file presence — turning OFF
+        # keeps the file so re-enabling never re-downloads.
+        file_on_disk = bool(mmproj and mmproj.is_file())
+        enabled = bool(getattr(config.runtime, "vision_enabled", False))
 
         parts = text.strip().split()
         sub = parts[1] if len(parts) >= 2 else None
 
-        # ── bare /vision → toggle ─────────────────────────────────
-        if sub is None:
-            if has:
-                # Currently "on" → remove projector + restart server so
-                # it relaunches without --mmproj. Frees RAM immediately.
-                try:
-                    mmproj.unlink()
-                except Exception as e:
-                    log.append_error(f"Couldn't remove projector: {e}")
-                    return
-                log.append_info("Vision OFF — restarting server to release projector memory…")
-                self._restart_for_vision_change(reason="Vision OFF")
-                return
-            # Currently "off" → download + activate (async — keeps UI live)
+        def _set_flag(value: bool) -> None:
+            config.runtime.vision_enabled = value
+            try:
+                from ...config import save_config
+                save_config(config)
+            except Exception:
+                pass
+
+        def _turn_on_with_existing_file() -> None:
+            # Projector already on disk → just flip the flag + restart so
+            # the runtime relaunches WITH --mmproj. No download.
+            _set_flag(True)
+            log.append_info("Vision ON — restarting server to load the projector…")
+            self._restart_for_vision_change(reason="Vision ON")
+
+        def _download_then_enable() -> None:
             if getattr(self, "_vision_download_in_flight", False):
                 log.append_info("Vision projector is already downloading — please wait.")
                 return
@@ -2827,13 +2922,32 @@ class ChatScreen(Screen):
 
             import threading as _t
             _t.Thread(target=_worker, daemon=True).start()
+
+        # ── bare /vision → toggle ─────────────────────────────────
+        if sub is None:
+            if enabled:
+                # Currently ON → flip flag off + restart so the server
+                # relaunches WITHOUT --mmproj. Frees the encoder RAM but
+                # KEEPS the projector file on disk (instant re-enable).
+                _set_flag(False)
+                log.append_info("Vision OFF — restarting server to release projector memory…")
+                self._restart_for_vision_change(reason="Vision OFF")
+                return
+            # Currently OFF → enable. If the projector is already on disk,
+            # just flip + restart; only download when genuinely missing.
+            if file_on_disk:
+                _turn_on_with_existing_file()
+            else:
+                _download_then_enable()
             return
 
         # ── power-user subcommands ───────────────────────────────
         if sub == "status":
-            if has:
+            if enabled and file_on_disk:
                 mb = mmproj.stat().st_size // (1024 * 1024)
                 log.append_info(f"Vision: on · {mmproj.name} · {mb} MB")
+            elif file_on_disk:
+                log.append_info("Vision: off (projector cached on disk) · type /vision to enable instantly")
             else:
                 log.append_info(
                     f"Vision: off · type /vision to enable "
@@ -2842,15 +2956,20 @@ class ChatScreen(Screen):
             return
 
         if sub in ("on", "download", "setup"):
-            if has:
+            if enabled:
                 log.append_info("Vision already on.")
                 return
-            self._handle_vision_command("/vision")
+            if file_on_disk:
+                _turn_on_with_existing_file()
+            else:
+                _download_then_enable()
             return
 
         if sub == "off":
-            if has:
-                self._handle_vision_command("/vision")
+            if enabled:
+                _set_flag(False)
+                log.append_info("Vision OFF — restarting server to release projector memory…")
+                self._restart_for_vision_change(reason="Vision OFF")
             else:
                 log.append_info("Vision already off.")
             return
@@ -3585,6 +3704,18 @@ class ChatScreen(Screen):
         log.reset_steps()
         self._show_thinking()
         self._update_status()
+        # Hand any images pasted from the clipboard to the engine so the
+        # agent loop can attach them to THIS turn's first user message.
+        # app.ask() composes text-only messages, so the images ride on the
+        # engine object (which the loop already receives) rather than a
+        # new param. Cleared after handoff so they send exactly once.
+        _imgs = getattr(self, "_pending_images", None)
+        if _imgs:
+            try:
+                self.tui.engine._pending_images = list(_imgs)
+            except Exception:
+                pass
+            self._pending_images = []
         self.run_agent_turn(text)
 
     @work(exclusive=True, thread=True)

{localcode-0.3.17 → localcode-0.3.18/src/localcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.17
+Version: 0.3.18
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.3.17 → localcode-0.3.18}/src/localcode.egg-info/SOURCES.txt

@@ -893,6 +893,7 @@ src/localcode/tools/write_file.py
 src/localcode/tui/__init__.py
 src/localcode/tui/app.py
 src/localcode/tui/bridge.py
+src/localcode/tui/clipboard_image.py
 src/localcode/tui/screens/__init__.py
 src/localcode/tui/screens/chat.py
 src/localcode/tui/screens/mode_picker.py
@@ -911,6 +912,7 @@ tests/test_architecture.py
 tests/test_bootstrap.py
 tests/test_checkpoint.py
 tests/test_churn_detection.py
+tests/test_clipboard_image.py
 tests/test_compaction.py
 tests/test_comprehensive_agent.py
 tests/test_comprehensive_bg_download.py