virtuai-cli 1.0.6__tar.gz → 1.0.7__tar.gz

{virtuai_cli-1.0.6 → virtuai_cli-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtuai-cli
-Version: 1.0.6
+Version: 1.0.7
 Summary: Run VirtuAI deep agents on your local machine
 Author-email: uCloudStore <lmoreno@ucloudstore.com>
 License: Proprietary
@@ -20,9 +20,9 @@ Requires-Dist: keyring>=25.0
 Requires-Dist: typer>=0.12
 Requires-Dist: rich>=13.0
 Requires-Dist: textual>=0.86
+Requires-Dist: llmfit>=1.1.16
 Provides-Extra: local
 Requires-Dist: langchain-ollama>=0.3.4; extra == "local"
-Requires-Dist: llmfit>=1.1.16; extra == "local"
 Requires-Dist: langchain-openai>=0.3; extra == "local"
 Provides-Extra: browser
 Requires-Dist: browser-use>=0.1.40; extra == "browser"
@@ -63,6 +63,18 @@ virtuai pair <CODE>
 
 The pairing is one-time; the resulting token is stored in your system keychain.
 
+Pairing then sets up the **command check** (also on the first `virtuai chat`, or any time with `virtuai guard setup`). Before the agent runs a command on this machine, a small local model — `tev1:0.8b` (811 MB) on [Ollama](https://ollama.com) ≥ 0.35 — says what the command does:
+
+- reads, or runs the project's tests/build → it runs;
+- deletes, installs, writes, uses the network, reads secrets, needs root → you are shown the command and decide. If you don't authorize it, it is left in the input as `!command` for you to run yourself; its output goes back to the agent.
+
+Commands that only read (`ls`, `cat`, `git status`, `rg`…) run without the model; inline code (`python -c`, `bash -c`, `| sh`), `eval` and `sudo` are always asked. Setup uses [llmfit](https://pypi.org/project/llmfit/) to decide whether the model fits this machine, then offers to install or start Ollama and download the model. **If it does not fit, or you decline, there is no command check: what the agent runs is your responsibility**, you are asked to accept that, and the chat shows it.
+
+```bash
+virtuai guard status              # on, rules only, or off
+virtuai guard test "rm -rf dist"  # what it would do: run or ask
+```
+
 ### 2. Chat with an agent
 
 ```bash
@@ -71,13 +83,9 @@ virtuai chat
 
 Opens an interactive TUI. Pick an agent (skipped if your workspace has only one), type a message, watch the response stream in. The agent's tool calls — `bash`, file reads, file writes — execute on this machine, in the current directory.
 
-Every workspace includes a built-in **Plan** agent. Switch to it without leaving the TUI:
-
-```
-/plan
-```
+**Plan mode** (`Shift+Tab` or `/plan`): the same agent investigates and proposes a plan without changing anything — it may read and run commands that only look; writes, edits and tools that change something are refused by the server. When the plan is ready, choose to carry it out (plan mode turns off) or keep planning.
 
-`/agent Plan` does the same thing. List agents with `/agents`. Switching starts a **new** conversation with that agent (history does not carry over). You can also launch Plan directly: `virtuai chat --agent Plan`. Plan explores the repo and produces a design; it does not implement. Switch back with `/agent <name>` to execute.
+Every workspace also includes a built-in **Plan** agent, a separate agent with its own conversation: `/agent Plan` or `virtuai chat --agent Plan`. List agents with `/agents`.
 
 ### 3. Use it from a shell script
 
@@ -97,7 +105,7 @@ Agents can run inference on **your own machine** — with [Ollama](https://ollam
 
 ### Set up
 
-1. Install the CLI with the local extra (pulls `langchain-ollama`, `langchain-openai` for oMLX, and `llmfit`):
+1. Install the CLI with the local extra (pulls `langchain-ollama` and `langchain-openai` for oMLX; `llmfit` comes with the base install):
    ```bash
    pip install 'virtuai-cli[local]'
    ```
@@ -136,7 +144,7 @@ Each model call goes to the runner of the person the turn is for; if they have n
 
 ### What the runner tells the server
 
-At connect and then every minute: the models it has, the Ollama version, what is loaded and how much memory it really took. With `llmfit` installed it also estimates which pulled models fit this machine, so the server does not send a model to a runner that cannot hold it until it has actually run there. A model that spills to the CPU gets half the context on its next call on that machine (down to 4k).
+At connect and then every minute: the models it has, the Ollama version, what is loaded and how much memory it really took. With `llmfit` (part of the base install) it also estimates which pulled models fit this machine, so the server does not send a model to a runner that cannot hold it until it has actually run there. A model that spills to the CPU gets half the context on its next call on that machine (down to 4k).
 
 The context sent to Ollama is 16k by default (set on the server). A model that does not fit at that context — `qwen3:14b` on a 16 GB Mac spills 7% to the CPU — is capped at half on that machine after its first call, and the server is told in the same reply: from then on it sends prompts that fit, compacting the conversation when they would not, instead of letting Ollama cut the start of the prompt. `OLLAMA_NUM_CTX` sets a lower context on a machine with little memory. For qwen3 the runner turns Ollama's thinking mode off: left on, it reasoned for minutes before every tool call.
 

{virtuai_cli-1.0.6 → virtuai_cli-1.0.7}/README.md

@@ -34,6 +34,18 @@ virtuai pair <CODE>
 
 The pairing is one-time; the resulting token is stored in your system keychain.
 
+Pairing then sets up the **command check** (also on the first `virtuai chat`, or any time with `virtuai guard setup`). Before the agent runs a command on this machine, a small local model — `tev1:0.8b` (811 MB) on [Ollama](https://ollama.com) ≥ 0.35 — says what the command does:
+
+- reads, or runs the project's tests/build → it runs;
+- deletes, installs, writes, uses the network, reads secrets, needs root → you are shown the command and decide. If you don't authorize it, it is left in the input as `!command` for you to run yourself; its output goes back to the agent.
+
+Commands that only read (`ls`, `cat`, `git status`, `rg`…) run without the model; inline code (`python -c`, `bash -c`, `| sh`), `eval` and `sudo` are always asked. Setup uses [llmfit](https://pypi.org/project/llmfit/) to decide whether the model fits this machine, then offers to install or start Ollama and download the model. **If it does not fit, or you decline, there is no command check: what the agent runs is your responsibility**, you are asked to accept that, and the chat shows it.
+
+```bash
+virtuai guard status              # on, rules only, or off
+virtuai guard test "rm -rf dist"  # what it would do: run or ask
+```
+
 ### 2. Chat with an agent
 
 ```bash
@@ -42,13 +54,9 @@ virtuai chat
 
 Opens an interactive TUI. Pick an agent (skipped if your workspace has only one), type a message, watch the response stream in. The agent's tool calls — `bash`, file reads, file writes — execute on this machine, in the current directory.
 
-Every workspace includes a built-in **Plan** agent. Switch to it without leaving the TUI:
-
-```
-/plan
-```
+**Plan mode** (`Shift+Tab` or `/plan`): the same agent investigates and proposes a plan without changing anything — it may read and run commands that only look; writes, edits and tools that change something are refused by the server. When the plan is ready, choose to carry it out (plan mode turns off) or keep planning.
 
-`/agent Plan` does the same thing. List agents with `/agents`. Switching starts a **new** conversation with that agent (history does not carry over). You can also launch Plan directly: `virtuai chat --agent Plan`. Plan explores the repo and produces a design; it does not implement. Switch back with `/agent <name>` to execute.
+Every workspace also includes a built-in **Plan** agent, a separate agent with its own conversation: `/agent Plan` or `virtuai chat --agent Plan`. List agents with `/agents`.
 
 ### 3. Use it from a shell script
 
@@ -68,7 +76,7 @@ Agents can run inference on **your own machine** — with [Ollama](https://ollam
 
 ### Set up
 
-1. Install the CLI with the local extra (pulls `langchain-ollama`, `langchain-openai` for oMLX, and `llmfit`):
+1. Install the CLI with the local extra (pulls `langchain-ollama` and `langchain-openai` for oMLX; `llmfit` comes with the base install):
    ```bash
    pip install 'virtuai-cli[local]'
    ```
@@ -107,7 +115,7 @@ Each model call goes to the runner of the person the turn is for; if they have n
 
 ### What the runner tells the server
 
-At connect and then every minute: the models it has, the Ollama version, what is loaded and how much memory it really took. With `llmfit` installed it also estimates which pulled models fit this machine, so the server does not send a model to a runner that cannot hold it until it has actually run there. A model that spills to the CPU gets half the context on its next call on that machine (down to 4k).
+At connect and then every minute: the models it has, the Ollama version, what is loaded and how much memory it really took. With `llmfit` (part of the base install) it also estimates which pulled models fit this machine, so the server does not send a model to a runner that cannot hold it until it has actually run there. A model that spills to the CPU gets half the context on its next call on that machine (down to 4k).
 
 The context sent to Ollama is 16k by default (set on the server). A model that does not fit at that context — `qwen3:14b` on a 16 GB Mac spills 7% to the CPU — is capped at half on that machine after its first call, and the server is told in the same reply: from then on it sends prompts that fit, compacting the conversation when they would not, instead of letting Ollama cut the start of the prompt. `OLLAMA_NUM_CTX` sets a lower context on a machine with little memory. For qwen3 the runner turns Ollama's thinking mode off: left on, it reasoned for minutes before every tool call.
 

{virtuai_cli-1.0.6 → virtuai_cli-1.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "virtuai-cli"
-version = "1.0.6"
+version = "1.0.7"
 description = "Run VirtuAI deep agents on your local machine"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -28,6 +28,10 @@ dependencies = [
     "typer>=0.12",
     "rich>=13.0",
     "textual>=0.86",
+    # Whether the command classifier (tev1:0.8b) fits this machine, decided at
+    # setup (virtuai_cli/guard_setup.py); also which pulled models fit, for the
+    # server (ollama_state.py). Ships its own binary in the wheel.
+    "llmfit>=1.1.16",
 ]
 
 # Optional: local model inference. Pulls langchain-ollama (+ langchain-core) so
@@ -36,9 +40,6 @@ dependencies = [
 [project.optional-dependencies]
 local = [
     "langchain-ollama>=0.3.4",  # `reasoning` (think on/off)
-    # Which pulled models fit this machine, before they are first loaded
-    # (virtuai_cli/ollama_state.py). Ships its own binary in the wheel.
-    "llmfit>=1.1.16",
     # oMLX (MLX on Apple Silicon) speaks the OpenAI API (virtuai_cli/omlx_state.py).
     "langchain-openai>=0.3",
 ]

{virtuai_cli-1.0.6 → virtuai_cli-1.0.7}/src/virtuai_cli/__init__.py

@@ -1,2 +1,2 @@
 """VirtuAI local CLI."""
-__version__ = "1.0.6"
+__version__ = "1.0.7"

virtuai_cli-1.0.7/src/virtuai_cli/chat/clipboard.py

@@ -0,0 +1,123 @@
+"""The system clipboard, for the chat TUI: copy what is selected, paste
+files and images as attachments.
+
+Textual copies with OSC 52, which Terminal.app ignores and iTerm2 only
+honours when allowed; the native tools (pbcopy/pbpaste and osascript on
+macOS, wl-copy/wl-paste or xclip on Linux) work everywhere they exist, so
+they go first and OSC 52 is the fallback.
+"""
+
+from __future__ import annotations
+
+import re
+import shlex
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+_MAC = sys.platform == "darwin"
+
+
+def _run(cmd: list[str], data: Optional[bytes] = None, timeout: float = 3) -> Optional[bytes]:
+    if not shutil.which(cmd[0]):
+        return None
+    try:
+        p = subprocess.run(cmd, input=data, capture_output=True, timeout=timeout)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return p.stdout if p.returncode == 0 else None
+
+
+def copy_text(app: Any, text: str) -> bool:
+    """Put `text` on the clipboard. True when a native tool took it."""
+    data = text.encode("utf-8")
+    for cmd in (["pbcopy"],) if _MAC else (["wl-copy"], ["xclip", "-selection", "clipboard"]):
+        if _run(cmd, data) is not None:
+            return True
+    try:
+        app.copy_to_clipboard(text)  # OSC 52
+    except Exception:
+        pass
+    return False
+
+
+def read_text() -> str:
+    for cmd in (["pbpaste"],) if _MAC else (["wl-paste", "--no-newline"], ["xclip", "-selection", "clipboard", "-o"]):
+        out = _run(cmd)
+        if out is not None:
+            return out.decode("utf-8", "replace")
+    return ""
+
+
+def _paste_dir() -> Path:
+    d = Path(tempfile.gettempdir()) / "virtuai-paste"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def read_image() -> Optional[Path]:
+    """An image on the clipboard (a screenshot copied, an image copied from a
+    browser), saved as PNG; None when there is none."""
+    dest = _paste_dir() / f"pasted-{time.strftime('%Y%m%d-%H%M%S')}.png"
+    if _MAC:
+        script = (
+            f'set f to POSIX file "{dest}"\n'
+            'try\n  set d to the clipboard as «class PNGf»\non error\n  return "none"\nend try\n'
+            "set fh to open for access f with write permission\n"
+            "write d to fh\nclose access fh\nreturn \"ok\""
+        )
+        out = _run(["osascript", "-e", script])
+        return dest if out is not None and out.strip() == b"ok" and dest.exists() else None
+    for cmd in (["wl-paste", "--type", "image/png"], ["xclip", "-selection", "clipboard", "-t", "image/png", "-o"]):
+        out = _run(cmd)
+        if out and out[:8] == b"\x89PNG\r\n\x1a\n":
+            dest.write_bytes(out)
+            return dest
+    return None
+
+
+def read_copied_files() -> list[Path]:
+    """Files copied in Finder (macOS): their paths."""
+    if not _MAC:
+        return []
+    script = (
+        "try\n  set fs to the clipboard as «class furl»\non error\n  return \"\"\nend try\n"
+        "return POSIX path of fs"
+    )
+    out = _run(["osascript", "-e", script])
+    if not out:
+        return []
+    p = Path(out.decode("utf-8", "replace").strip())
+    return [p] if p.is_file() else []
+
+
+_URI = re.compile(r"^file://")
+
+
+def paths_in(text: str) -> list[Path]:
+    """Existing files named by pasted text — a path dragged into the terminal
+    (quoted or with escaped spaces), several of them, or file:// URIs. Empty
+    when the text is anything else, so ordinary text pastes as text."""
+    text = (text or "").strip()
+    if not text or len(text) > 4096:
+        return []
+    try:
+        parts = shlex.split(text)
+    except ValueError:
+        parts = text.splitlines()
+    out = []
+    for part in parts:
+        from urllib.parse import unquote
+
+        part = unquote(_URI.sub("", part.strip()))
+        if not part:
+            continue
+        p = Path(part).expanduser()
+        if not p.is_file():
+            return []
+        out.append(p)
+    return out

{virtuai_cli-1.0.6 → virtuai_cli-1.0.7}/src/virtuai_cli/chat/command.py

@@ -49,6 +49,7 @@ def run_chat(
     workdir: Optional[Path],
     server: Optional[str],
     agent: Optional[str],
+    continue_session: bool = False,
 ) -> None:
     """Launch the chat TUI. Called by the `chat` command in main.py."""
     server_url = (server or cfg.get_server_url()).rstrip("/")
@@ -77,7 +78,6 @@ def run_chat(
         workspace_name=info["workspace_name"],
         default_model_id=picked.get("default_model_id") or None,
         allowed_models=picked.get("allowed_models") or [],
+        continue_session=continue_session,
     )
-    saved_theme = cfg.get("theme", "textual-dark")
-    app.theme = saved_theme
     app.run()

virtuai_cli-1.0.7/src/virtuai_cli/chat/devtools.py

@@ -0,0 +1,214 @@
+"""The chat TUI as a programming tool: git, the shell, your editor, @files.
+
+- `git_status`: branch, ahead/behind and changed files, for the top bar.
+- `run_shell`: `!cmd` runs here, in the workdir, its output streamed.
+- `open_in_editor`: a file at a line in $VISUAL/$EDITOR (the TUI suspends
+  for a terminal editor), VS Code or Cursor, or the system's default app.
+- `notify`: a desktop notification when a long answer ends while you are
+  elsewhere.
+- `file_index` / `fuzzy`: the workdir's files for `@` mentions — git's own
+  list when it is a repository, else a walk that skips the usual noise.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Awaitable, Callable, Optional
+
+SKIP_DIRS = {".git", "node_modules", ".venv", "venv", "__pycache__", ".mypy_cache", ".pytest_cache",
+             "dist", "build", ".next", ".turbo", "target", ".idea", ".tox", ".cache"}
+
+
+# ── git ──────────────────────────────────────────────────────────────────────
+
+@dataclass
+class GitState:
+    branch: str
+    ahead: int = 0
+    behind: int = 0
+    changed: int = 0
+    untracked: int = 0
+
+
+async def _git(workdir: Path, *args: str, timeout: float = 5) -> Optional[str]:
+    if not shutil.which("git"):
+        return None
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "git", *args, cwd=str(workdir), stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.DEVNULL)
+        out, _ = await asyncio.wait_for(proc.communicate(), timeout)
+    except (OSError, asyncio.TimeoutError):
+        return None
+    return out.decode("utf-8", "replace") if proc.returncode == 0 else None
+
+
+async def git_status(workdir: Path) -> Optional[GitState]:
+    """None when the workdir is not in a git repository."""
+    out = await _git(workdir, "status", "--porcelain=v1", "--branch")
+    if out is None:
+        return None
+    lines = out.splitlines()
+    head = lines[0][3:] if lines and lines[0].startswith("## ") else ""
+    branch = head.split("...")[0].replace("No commits yet on ", "") or "?"
+    state = GitState(branch=branch)
+    if "[" in head:
+        info = head[head.index("[") + 1: head.rindex("]")]
+        for part in info.split(","):
+            part = part.strip()
+            if part.startswith("ahead "):
+                state.ahead = int(part[6:])
+            elif part.startswith("behind "):
+                state.behind = int(part[7:])
+    for line in lines[1:]:
+        if line.startswith("??"):
+            state.untracked += 1
+        elif line.strip():
+            state.changed += 1
+    return state
+
+
+async def git_diff(workdir: Path) -> str:
+    stat = await _git(workdir, "diff", "--stat", "HEAD") or ""
+    body = await _git(workdir, "diff", "HEAD", timeout=10) or ""
+    untracked = await _git(workdir, "ls-files", "--others", "--exclude-standard") or ""
+    extra = "".join(f"?? {p}\n" for p in untracked.splitlines()[:50])
+    return (stat + ("\n" + extra if extra else "") + "\n" + body).strip()
+
+
+# ── shell ────────────────────────────────────────────────────────────────────
+
+async def run_shell(cmd: str, workdir: Path, on_output: Callable[[str], Awaitable[None]],
+                    timeout: float = 600) -> tuple[int, str]:
+    """Run `cmd` in the user's shell, in the workdir; stream its output. (code, output)"""
+    shell = os.environ.get("SHELL") or "/bin/sh"
+    proc = await asyncio.create_subprocess_exec(
+        shell, "-lc", cmd, cwd=str(workdir),
+        stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.STDOUT,
+        env={**os.environ, "TERM": "dumb", "NO_COLOR": "1"})
+    chunks: list[str] = []
+
+    async def pump() -> None:
+        assert proc.stdout is not None
+        while True:
+            data = await proc.stdout.read(4096)
+            if not data:
+                break
+            text = data.decode("utf-8", "replace")
+            chunks.append(text)
+            await on_output(text)
+
+    try:
+        await asyncio.wait_for(pump(), timeout)
+        code = await proc.wait()
+    except asyncio.TimeoutError:
+        proc.kill()
+        code = 124
+    except asyncio.CancelledError:
+        proc.kill()
+        raise
+    return code, "".join(chunks)
+
+
+# ── editor ───────────────────────────────────────────────────────────────────
+
+_GUI = {"code": "-g", "cursor": "-g", "code-insiders": "-g", "subl": None, "zed": None}
+
+
+def open_in_editor(app: Any, path: Path, line: Optional[int] = None) -> str:
+    """Open `path` at `line`. Returns how it was opened."""
+    target = f"{path}:{line}" if line else str(path)
+    editor = os.environ.get("VISUAL") or os.environ.get("EDITOR") or ""
+    if editor:
+        parts = shlex.split(editor)
+        name = Path(parts[0]).name
+        if name in _GUI:
+            flag = _GUI[name]
+            subprocess.Popen(parts + ([flag, target] if flag else [target]),
+                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            return name
+        args = parts + ([f"+{line}"] if line and name in ("vim", "nvim", "vi", "nano", "emacs", "hx", "micro") else []) + [str(path)]
+        with app.suspend():
+            subprocess.call(args)
+        return name
+    for gui in ("code", "cursor"):
+        if shutil.which(gui):
+            subprocess.Popen([gui, "-g", target], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            return gui
+    opener = "open" if sys.platform == "darwin" else "xdg-open"
+    if shutil.which(opener):
+        subprocess.Popen([opener, str(path)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        return opener
+    return ""
+
+
+# ── notifications ────────────────────────────────────────────────────────────
+
+def notify(title: str, body: str) -> None:
+    try:
+        if sys.platform == "darwin" and shutil.which("osascript"):
+            esc = lambda s: s.replace("\\", "\\\\").replace('"', '\\"')  # noqa: E731
+            subprocess.Popen(["osascript", "-e", f'display notification "{esc(body)}" with title "{esc(title)}"'],
+                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        elif shutil.which("notify-send"):
+            subprocess.Popen(["notify-send", title, body], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except OSError:
+        pass
+
+
+# ── @files ───────────────────────────────────────────────────────────────────
+
+def file_index(workdir: Path, limit: int = 20000) -> list[str]:
+    """The workdir's files, relative: git's list in a repository, else a walk."""
+    if shutil.which("git"):
+        try:
+            out = subprocess.run(["git", "ls-files", "--cached", "--others", "--exclude-standard"],
+                                 cwd=str(workdir), capture_output=True, timeout=5)
+            if out.returncode == 0:
+                return out.stdout.decode("utf-8", "replace").splitlines()[:limit]
+        except (OSError, subprocess.SubprocessError):
+            pass
+    found: list[str] = []
+    for root, dirs, files in os.walk(workdir):
+        dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith(".")]
+        for name in files:
+            found.append(os.path.relpath(os.path.join(root, name), workdir))
+            if len(found) >= limit:
+                return found
+    return found
+
+
+def fuzzy(query: str, items: list[str], limit: int = 12) -> list[str]:
+    """Items whose letters follow the query's in order, best first: a match in
+    the file name beats one spread over the path, a tight one a loose one."""
+    q = query.lower()
+    if not q:
+        return items[:limit]
+    scored = []
+    for item in items:
+        low = item.lower()
+        name = low.rsplit("/", 1)[-1]
+        if q in name:
+            scored.append((0, name.index(q), len(item), item))
+            continue
+        if q in low:
+            scored.append((1, low.index(q), len(item), item))
+            continue
+        pos, gaps, ok = -1, 0, True
+        for ch in q:
+            nxt = low.find(ch, pos + 1)
+            if nxt < 0:
+                ok = False
+                break
+            gaps += nxt - pos - 1
+            pos = nxt
+        if ok:
+            scored.append((2, gaps, len(item), item))
+    scored.sort()
+    return [s[3] for s in scored[:limit]]

virtuai_cli-1.0.7/src/virtuai_cli/chat/highlight.py

@@ -0,0 +1,87 @@
+"""Code in the theme's colors, by language — web chat's code blocks in cells.
+
+One place for the colors of code: a file's diff (EditPreviewCard), markdown's
+code blocks (TextSegment) and the file viewer (panels.FilePreview). Dark
+themes use One Dark, light ones Pygments' default; diff lines keep their
+syntax colors over a green or red tint instead of turning all green.
+"""
+
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import Any, Optional
+
+from rich.style import Style
+from rich.syntax import Syntax
+from rich.text import Text
+
+DARK, LIGHT = "one-dark", "default"
+
+#: Diff tints: added and removed lines, dark and light.
+TINT = {
+    (True, "+"): "rgb(22,48,30)", (True, "-"): "rgb(60,24,26)",
+    (False, "+"): "rgb(230,255,236)", (False, "-"): "rgb(255,235,233)",
+}
+
+
+def is_dark(app: Any) -> bool:
+    theme = getattr(app, "current_theme", None)
+    return bool(getattr(theme, "dark", True))
+
+
+def code_theme(app: Any) -> str:
+    return DARK if is_dark(app) else LIGHT
+
+
+@lru_cache(maxsize=256)
+def _lexer(path: str, sample: str):
+    from pygments.lexers import guess_lexer_for_filename, get_lexer_for_filename
+    from pygments.util import ClassNotFound
+
+    try:
+        return get_lexer_for_filename(path, stripnl=False)
+    except ClassNotFound:
+        try:
+            return guess_lexer_for_filename(path, sample, stripnl=False)
+        except ClassNotFound:
+            return None
+
+
+def lexer_for(path: str, sample: str = ""):
+    """The Pygments lexer for a file, by name then content; None for plain text."""
+    return _lexer(path or "", (sample or "")[:2000])
+
+
+def highlight_line(line: str, lexer, theme: str) -> Text:
+    """One line in its language's colors, with no background of its own."""
+    if lexer is None:
+        return Text(line)
+    syntax_theme = Syntax.get_theme(theme)
+    out = Text()
+    for token, value in lexer.get_tokens(line):
+        value = value.rstrip("\n") if value.endswith("\n") else value
+        if not value:
+            continue
+        style = syntax_theme.get_style_for_token(token)
+        out.append(value, Style(color=style.color, bold=style.bold, italic=style.italic,
+                                underline=style.underline))
+    return out
+
+
+def diff_line(marker: str, line: str, lexer, app: Any) -> Text:
+    """A diff row: its marker, the code in its colors, the tint of the change."""
+    dark = is_dark(app)
+    if marker == " ":
+        body = highlight_line(line, lexer, code_theme(app))
+        body.stylize("dim")
+        return Text(" ") + body
+    sign = Text(marker, style="bold green" if marker == "+" else "bold red")
+    row = sign + highlight_line(line, lexer, code_theme(app))
+    row.stylize(f"on {TINT[(dark, marker)]}")
+    return row
+
+
+def file_syntax(path: str, content: str, app: Any, background: Optional[str] = None) -> Syntax:
+    lexer = lexer_for(path, content)
+    return Syntax(content, lexer if lexer is not None else "text", theme=code_theme(app),
+                  line_numbers=True, word_wrap=True, background_color=background)