lcode-cli 0.1.1__py3-none-any.whl

lcode/models.toml

@@ -0,0 +1,128 @@
+# The model catalog: open-weight models lcode knows how to size and set up.
+#
+# Want another model? Open a "Model request" issue or a pull request that adds an entry here
+# (see CONTRIBUTING.md). Any other Ollama model with tool calling also works with
+# `lcode --model <ollama-tag>`; lcode just can't estimate its memory needs.
+#
+# Fields
+#   key               short name used on the command line (`lcode --model <key>`)
+#   tag               Ollama model tag that `lcode setup` pulls
+#   size_gb           download size (GB, 10^9 bytes)
+#   max_context       largest context window the model supports (tokens)
+#   kv_kib_per_token  KV-cache memory per token of context at f16 (KiB), computed from the GGUF
+#                     metadata: attention layers x KV heads x (key_length + value_length) x 2 bytes
+#   kv_estimated      true when the attention layout had to be assumed rather than read
+#   moe               Mixture-of-Experts: runs well even when part of it sits in system RAM
+#   num_batch         prompt batch size lcode uses by default (omit for Ollama's default of 512)
+#   tested            verified end to end with lcode's tools by the maintainers
+#
+# The order matters: `lcode setup` recommends the first *tested* model that fits the machine, and
+# otherwise the first model in this order that fits with a useful context, so keep stronger models first.
+
+[[model]]
+key = "qwen3.6-35b"
+tag = "qwen3.6:35b-a3b-coding"
+name = "Qwen3.6 35B-A3B Coding"
+publisher = "Qwen (Alibaba)"
+params = "35B MoE · 3B active"
+moe = true
+size_gb = 22.6
+max_context = 262144
+kv_kib_per_token = 22
+num_batch = 1024
+swe_bench_verified = 73.4
+tested = true
+notes = "Default. Strongest tool calling among local MoE coders; fast even with experts in RAM."
+
+[[model]]
+key = "qwen3.8-27b"
+tag = "qwen3.8:27b"
+name = "Qwen3.8 27B"
+publisher = "Qwen (Alibaba)"
+params = "27B dense"
+moe = false
+size_gb = 17.7
+max_context = 262144
+kv_kib_per_token = 68
+tested = false
+notes = "Newest Qwen. Dense: excellent when it fits entirely in GPU/unified memory, slow when split."
+
+[[model]]
+key = "qwen3.6-27b"
+tag = "qwen3.6:27b-coding"
+name = "Qwen3.6 27B Coding"
+publisher = "Qwen (Alibaba)"
+params = "27B dense"
+moe = false
+size_gb = 17.8
+max_context = 262144
+kv_kib_per_token = 68
+tested = false
+notes = "Dense coding model. Best on 24 GB+ GPUs or Macs with 48 GB+ unified memory."
+
+[[model]]
+key = "laguna-xs-2.1"
+tag = "laguna-xs-2.1"
+name = "Laguna XS 2.1"
+publisher = "Poolside"
+params = "33B MoE · 3B active"
+moe = true
+size_gb = 20.3
+max_context = 262144
+kv_kib_per_token = 40
+kv_estimated = true
+swe_bench_verified = 70.9
+tested = false
+notes = "Agentic-coding MoE built for local machines; slightly smaller than Qwen3.6 35B."
+
+[[model]]
+key = "nemotron-3.5-lightning"
+tag = "nemotron-3.5-lightning:30b"
+name = "Nemotron 3.5 Lightning"
+publisher = "NVIDIA"
+params = "30B MoE · 3B active"
+moe = true
+size_gb = 25.4
+max_context = 1048576
+kv_kib_per_token = 7
+tested = false
+notes = "Hybrid Mamba-Transformer: tiny KV cache, up to 1M tokens of context."
+
+[[model]]
+key = "gpt-oss-20b"
+tag = "gpt-oss:20b"
+name = "gpt-oss 20B"
+publisher = "OpenAI"
+params = "21B MoE · 3.6B active"
+moe = true
+size_gb = 13.8
+max_context = 131072
+kv_kib_per_token = 24
+tested = false
+notes = "Compact MoE with 128K context; fits 16 GB GPUs and 24 GB Macs."
+
+[[model]]
+key = "qwen3.5-9b"
+tag = "qwen3.5:9b"
+name = "Qwen3.5 9B"
+publisher = "Qwen (Alibaba)"
+params = "9B dense"
+moe = false
+size_gb = 6.6
+max_context = 262144
+kv_kib_per_token = 32
+tested = true
+notes = "Small and capable: 64 tok/s fully on a 12 GB GPU at 128K context. For 8-12 GB GPUs and 16-24 GB Macs."
+
+[[model]]
+key = "qwen3.5-4b"
+tag = "qwen3.5:4b"
+name = "Qwen3.5 4B"
+publisher = "Qwen (Alibaba)"
+params = "4B dense"
+moe = false
+size_gb = 3.4
+max_context = 262144
+kv_kib_per_token = 32
+tested = true
+notes = "Smallest option: ~95 tok/s on a 12 GB GPU. Makes more mistakes but fixes them when commands fail."

lcode/ollama.py

@@ -0,0 +1,163 @@
+"""A small client for the Ollama HTTP API (works with native, Docker and remote servers)."""
+
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Callable, Iterator
+from urllib.parse import urlsplit, urlunsplit
+
+import requests
+
+MIN_VERSION = (0, 30, 0)  # first release that runs the Qwen3.5/3.6 hybrid-attention architecture
+
+
+class OllamaError(RuntimeError):
+    pass
+
+
+def redact(url: str) -> str:
+    """Hide credentials embedded in a URL (http://user:pass@host) before printing it."""
+    parts = urlsplit(url)
+    if parts.username or parts.password:
+        host = parts.hostname or ""
+        if parts.port:
+            host += f":{parts.port}"
+        return urlunsplit((parts.scheme, f"***@{host}", parts.path, parts.query, parts.fragment))
+    return url
+
+
+def version_tuple(version: str) -> tuple[int, ...]:
+    return tuple(int(x) for x in re.findall(r"\d+", version)[:3])
+
+
+class Ollama:
+    def __init__(self, host: str):
+        self.host = host.rstrip("/")
+
+    def _url(self, path: str) -> str:
+        return f"{self.host}{path}"
+
+    def _post(self, path: str, payload: dict, timeout: float | None = 30) -> dict:
+        try:
+            r = requests.post(self._url(path), json=payload, timeout=timeout)
+        except requests.RequestException as e:
+            raise OllamaError(f"cannot reach Ollama at {redact(self.host)}: {e}") from e
+        if r.status_code != 200:
+            raise OllamaError(f"Ollama {path} failed ({r.status_code}): {r.text[:300]}")
+        return r.json()
+
+    # -- info
+    def version(self) -> str:
+        try:
+            return requests.get(self._url("/api/version"), timeout=5).json()["version"]
+        except (requests.RequestException, ValueError, KeyError) as e:
+            raise OllamaError(f"cannot reach Ollama at {redact(self.host)}: {e}") from e
+
+    def list_models(self) -> list[dict]:
+        try:
+            return requests.get(self._url("/api/tags"), timeout=10).json().get("models", [])
+        except (requests.RequestException, ValueError) as e:
+            raise OllamaError(f"cannot reach Ollama at {redact(self.host)}: {e}") from e
+
+    def installed_names(self) -> set[str]:
+        names = set()
+        for m in self.list_models():
+            names.add(m["name"])
+            if m["name"].endswith(":latest"):
+                names.add(m["name"][: -len(":latest")])
+        return names
+
+    def show(self, model: str) -> dict:
+        return self._post("/api/show", {"model": model})
+
+    def max_context(self, model: str) -> int | None:
+        info = self.show(model).get("model_info", {})
+        return next((int(v) for k, v in info.items() if k.endswith(".context_length")), None)
+
+    def running(self) -> list[dict]:
+        try:
+            return requests.get(self._url("/api/ps"), timeout=5).json().get("models", [])
+        except (requests.RequestException, ValueError):
+            return []
+
+    # -- management
+    def pull(self, model: str, on_progress: Callable[[dict], None]) -> None:
+        try:
+            with requests.post(
+                self._url("/api/pull"), json={"model": model, "stream": True}, stream=True, timeout=(10, None)
+            ) as r:
+                if r.status_code != 200:
+                    raise OllamaError(f"pull failed ({r.status_code}): {r.text[:300]}")
+                for line in r.iter_lines():
+                    if line:
+                        event = json.loads(line)
+                        if "error" in event:
+                            raise OllamaError(f"pull failed: {event['error']}")
+                        on_progress(event)
+        except requests.RequestException as e:
+            raise OllamaError(f"pull failed: {e}") from e
+
+    def create_text_only(self, name: str, base: str) -> bool:
+        """Create `name` from `base` without its vision projector. Returns False if `base` has none.
+
+        Only the language-model weights are referenced (no copy, no extra disk). Dropping the
+        projector saves ~1 GB of VRAM, which Ollama under-counts on small GPUs.
+        """
+        show = self.show(base)
+        modelfile = show.get("modelfile", "")
+        blobs = re.findall(r"^FROM .*?sha256[-:]([0-9a-f]{64})", modelfile, re.M)
+        if len(blobs) < 2 and "projector_info" not in show:
+            return False
+        if not blobs:
+            raise OllamaError(f"could not find the weights of {base}")
+        params: dict[str, list[str]] = {}
+        for line in show.get("parameters", "").splitlines():
+            key, _, value = line.strip().partition(" ")
+            if key:
+                params.setdefault(key, []).append(value.strip().strip('"'))
+        payload: dict = {
+            "model": name,
+            "files": {"model.gguf": f"sha256:{blobs[0]}"},
+            "template": show.get("template", ""),
+            "parameters": {k: (v if k == "stop" else _number(v[-1])) for k, v in params.items()},
+            "stream": False,
+        }
+        for key in ("renderer", "parser"):
+            m = re.search(rf"^{key.upper()} (\S+)", modelfile, re.M)
+            if m:
+                payload[key] = m.group(1)
+        if self._post("/api/create", payload, timeout=600).get("status") != "success":
+            raise OllamaError(f"creating {name} failed")
+        return True
+
+    # -- inference
+    def chat_stream(self, payload: dict) -> Iterator[dict]:
+        try:
+            r = requests.post(self._url("/api/chat"), json={**payload, "stream": True}, stream=True, timeout=(10, None))
+        except requests.RequestException as e:
+            raise OllamaError(f"cannot reach Ollama at {redact(self.host)}: {e}") from e
+        with r:
+            if r.status_code != 200:
+                raise OllamaError(f"Ollama error {r.status_code}: {r.text[:500]}")
+            for line in r.iter_lines():
+                if line:
+                    chunk = json.loads(line)
+                    if "error" in chunk:
+                        raise OllamaError(f"Ollama error: {chunk['error']}")
+                    yield chunk
+
+    def load(self, model: str, options: dict, keep_alive: str) -> None:
+        """Load a model into memory without generating anything."""
+        self._post(
+            "/api/chat", {"model": model, "messages": [], "keep_alive": keep_alive, "options": options}, timeout=900
+        )
+
+
+def _number(value: str) -> int | float | str:
+    for cast in (int, float):
+        try:
+            return cast(value)
+        except ValueError:
+            pass
+    return value

lcode/permissions.py

@@ -0,0 +1,90 @@
+"""Permission prompts for file edits and shell commands."""
+
+from __future__ import annotations
+
+import re
+import shlex
+
+from rich.console import Console, RenderableType
+from rich.panel import Panel
+
+from lcode.config import PERMISSION_MODES
+
+# Commands that only read state run without asking (when used without redirection or chaining).
+SAFE_COMMANDS = {
+    "ls", "cat", "head", "tail", "wc", "pwd", "grep", "rg", "find", "tree", "file", "stat", "du", "df",
+    "echo", "which", "whoami", "uname", "date", "sort", "uniq", "cut", "nl", "diff", "basename", "dirname",
+    "realpath", "readlink", "nvidia-smi", "sw_vers",
+}  # fmt: skip
+SAFE_GIT = {"status", "log", "diff", "show", "branch", "ls-files", "rev-parse", "remote", "blame", "shortlog"}
+# For these, "always allow" is remembered per subcommand (e.g. `git commit`, not all of `git`).
+MULTI_WORD = {"git", "npm", "pnpm", "yarn", "pip", "uv", "docker", "cargo", "go", "kubectl", "python", "python3", "brew"}  # fmt: skip  # noqa: E501
+
+
+def bash_key(command: str) -> str:
+    """The key "always allow" remembers: the program (plus subcommand for tools like git), ignoring `cd dir &&`."""
+    command = re.sub(r"^\s*(cd\s+\S+\s*&&\s*)+", "", command)
+    try:
+        words = shlex.split(command)
+    except ValueError:
+        words = command.split()
+    if not words:
+        return "bash:"
+    if words[0] in MULTI_WORD and len(words) > 1:
+        if words[1] in ("-m", "-c") and len(words) > 2:  # python -m <module>
+            return f"bash:{' '.join(words[:3])}"
+        return f"bash:{words[0]} {words[1]}"
+    return f"bash:{words[0]}"
+
+
+def is_read_only(command: str) -> bool:
+    if any(tok in command for tok in (";", "&", ">", "`", "$(", "<(")) or "\n" in command:
+        return False
+    if re.search(r"-exec|-delete|-ok\b|-fprint", command):
+        return False
+    for segment in command.split("|"):
+        try:
+            words = shlex.split(segment)
+        except ValueError:
+            return False
+        if not words:
+            return False
+        if words[0] == "git":
+            if len(words) < 2 or words[1] not in SAFE_GIT:
+                return False
+        elif words[0] not in SAFE_COMMANDS:
+            return False
+    return True
+
+
+class Permissions:
+    def __init__(self, console: Console, mode: str = "ask"):
+        self.console = console
+        self.mode = mode
+        self.always: set[str] = set()
+
+    def cycle(self) -> None:
+        self.mode = PERMISSION_MODES[(PERMISSION_MODES.index(self.mode) + 1) % len(PERMISSION_MODES)]
+
+    def request(self, key: str, kind: str, title: str, body: RenderableType) -> tuple[bool, str]:
+        """Ask the user. kind is 'edit' or 'bash'. Returns (allowed, message for the model)."""
+        if self.mode == "yolo" or key in self.always or (kind == "edit" and self.mode == "auto-edit"):
+            return True, ""
+        self.console.print(Panel(body, title=title, title_align="left", border_style="yellow"))
+        scope = key.split(":", 1)[1] if kind == "bash" else "file edits"
+        try:
+            answer = input(f"  Allow? [y]es / [a]lways for '{scope}' this session / [n]o (+ optional reason): ")
+        except EOFError:
+            return False, "The user denied this action (no input available)."
+        answer = answer.strip()
+        if answer.lower() in ("y", "yes", ""):
+            return True, ""
+        if answer.lower() in ("a", "always"):
+            self.always.add(key if kind == "bash" else "edit")
+            return True, ""
+        # "n", "no", "n <reason>" or any other text, which is taken as the reason.
+        reason = re.sub(r"^(no|n)\b[\s,:-]*", "", answer, flags=re.I).strip()
+        message = "The user denied this action."
+        if reason:
+            return False, f"{message} User says: {reason}"
+        return False, f"{message} Ask the user how to proceed or choose a different approach."

lcode/render.py

@@ -0,0 +1,43 @@
+"""Terminal rendering helpers."""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.markdown import Markdown
+
+
+class MarkdownStreamer:
+    """Render streamed markdown block by block, at blank lines outside code fences.
+
+    Rendering whole blocks (instead of re-rendering a live region) keeps scrollback clean and
+    works in every terminal.
+    """
+
+    def __init__(self, console: Console):
+        self.console = console
+        self.buf = ""
+
+    def feed(self, text: str) -> None:
+        self.buf += text
+        cut, offset, in_fence = 0, 0, False
+        for line in self.buf.split("\n")[:-1]:  # the last line may still be incomplete
+            stripped = line.strip()
+            if stripped.startswith(("```", "~~~")):
+                in_fence = not in_fence
+                if not in_fence:
+                    cut = offset + len(line) + 1
+            elif not in_fence and stripped == "":
+                cut = offset + len(line) + 1
+            offset += len(line) + 1
+        if cut:
+            self._render(self.buf[:cut])
+            self.buf = self.buf[cut:]
+
+    def flush(self) -> None:
+        self._render(self.buf)
+        self.buf = ""
+
+    def _render(self, text: str) -> None:
+        if text.strip():
+            self.console.print(Markdown(text.strip("\n"), code_theme="monokai"))
+            self.console.print()