localcode 0.4.0__py3-none-macosx_13_0_arm64.whl

localcode/tui/widgets/messages/__init__.py

@@ -0,0 +1,21 @@
+"""Per-message-kind renderers — agent `src/components/messages/` pattern.
+
+Each render method takes a ChatLog instance plus its kind-specific
+arguments and writes content to the log. ChatLog acts as the dispatcher
+(via `_dispatch_gap` for spacing + the per-kind method for content).
+
+Extracted modules so far:
+    diff.py          — file-edit diff with line-number gutter
+
+To extract (follow-up — each is its own self-contained PR):
+    user.py          — _render_user
+    assistant.py     — _render_assistant + the streaming partial-line path
+    thinking.py      — _render_thinking
+    tool.py          — _render_tool, _render_tool_done, _render_tool_result
+    info.py          — _render_info, _render_error, _render_approval
+    turn_summary.py  — _render_turn_summary
+
+Full extraction is a 1-day refactor — left for a quiet day. The diff
+extraction here proves the pattern works and gives the most-complex
+renderer its own testable home.
+"""

localcode/tui/widgets/messages/diff.py

@@ -0,0 +1,287 @@
+"""Diff renderer — two-column layout with line-number gutter.
+
+agent pattern from `src/components/StructuredDiff.tsx`:
+- Right-aligned gutter (line numbers) at fixed width per hunk.
+- Content column with `+`/`-` markers in green/red.
+- Context lines dim, hunks separated by `…` row.
+
+Extracted from `chat_log.ChatLog._render_diff` so the diff renderer
+can be tested in isolation and (later) reused by other surfaces
+(e.g. an inline diff preview during edit_file approval prompts).
+"""
+from __future__ import annotations
+
+import re
+import textwrap
+from typing import TYPE_CHECKING
+
+from rich.text import Text
+
+from ....theme import C
+
+if TYPE_CHECKING:
+    from ..chat_log import ChatLog
+
+
+def _available_content_width(log: "ChatLog", prefix_width: int) -> int:
+    """Chars of CONTENT that fit on one row given the diff prefix.
+
+    Terminal width minus: the diff prefix (gutter + separator + marker),
+    RichLog padding, and the vertical scrollbar. Floor at 20 so we
+    still wrap on tiny terminals rather than returning ≤0.
+    """
+    try:
+        term_w = log.app.size.width
+    except Exception:
+        term_w = 80
+    # Reserve: 1 for scrollbar, 2 for RichLog padding = 3. Prefix on
+    # the left is already accounted for separately.
+    return max(20, term_w - prefix_width - 3)
+
+
+def _emit_wrapped_line(
+    log: "ChatLog",
+    content: str,
+    build_first_prefix,      # callable() → Text for first visual row
+    build_cont_prefix,       # callable() → Text for every wrap-continuation row
+    content_style: str,
+    content_width: int,
+    highlighted=None,        # optional pre-syntax-highlighted Text for `content`
+) -> None:
+    """Write a styled diff line to `log`, wrapping long content cleanly.
+
+    Without this, diff lines longer than the terminal width fell through
+    to RichLog's default word-wrap, which rendered the wrapped remainder
+    flush to column 0 — text appeared to "extend to the left past the
+    margin" (image 110). The fix: pre-split the content on terminal
+    width, write the first piece with the real line-number + marker
+    prefix, and write each continuation piece with a blank prefix of
+    the same width so everything lines up under the `+`/`-` column.
+
+    When `highlighted` (a syntax-colored Text of `content`) is given AND the
+    line fits on one row, we render it directly to preserve token colors;
+    long lines fall back to plain-style wrapping so layout never breaks.
+    """
+    # Syntax-highlighted fast path: only when the whole line fits one row
+    # (avoids re-implementing style-preserving wrap). Otherwise fall through.
+    if highlighted is not None and content_width > 0 and len(content) <= content_width:
+        dl = build_first_prefix()
+        dl.append_text(highlighted)
+        log.write(dl)
+        log._track_lines()
+        return
+
+    if content_width <= 0:
+        # Degenerate terminal size — fall back to one write and let
+        # Rich wrap as best it can.
+        dl = build_first_prefix()
+        dl.append(content, style=content_style)
+        log.write(dl)
+        log._track_lines()
+        return
+
+    # textwrap preserves leading whitespace (important for indented code
+    # diffs) but `drop_whitespace=False` also keeps trailing spaces,
+    # which is what we want for code.
+    pieces = textwrap.wrap(
+        content if content else " ",
+        width=content_width,
+        drop_whitespace=False,
+        replace_whitespace=False,
+        break_long_words=True,
+        break_on_hyphens=False,
+        expand_tabs=False,
+    ) or [content]
+
+    dl = build_first_prefix()
+    dl.append(pieces[0], style=content_style)
+    log.write(dl)
+    log._track_lines()
+
+    for extra in pieces[1:]:
+        cont = build_cont_prefix()
+        cont.append(extra, style=content_style)
+        log.write(cont)
+        log._track_lines()
+
+
+_HUNK_HEADER_RE = re.compile(r'\+(\d+)(?:,(\d+))?')
+_HUNK_OLD_RE = re.compile(r'-(\d+)')
+
+# Extension → Pygments lexer name for syntax-highlighting diff content.
+_LEXER_BY_EXT = {
+    ".py": "python", ".pyi": "python", ".ts": "typescript", ".tsx": "tsx",
+    ".js": "javascript", ".jsx": "jsx", ".mjs": "javascript", ".go": "go",
+    ".rs": "rust", ".java": "java", ".kt": "kotlin", ".swift": "swift",
+    ".c": "c", ".h": "c", ".cpp": "cpp", ".cc": "cpp", ".hpp": "cpp",
+    ".cs": "csharp", ".rb": "ruby", ".php": "php", ".css": "css",
+    ".scss": "scss", ".html": "html", ".xml": "xml", ".json": "json",
+    ".yaml": "yaml", ".yml": "yaml", ".toml": "toml", ".sh": "bash",
+    ".bash": "bash", ".zsh": "bash", ".sql": "sql", ".md": "markdown",
+}
+
+
+def _lexer_for(file_path: str) -> str | None:
+    import os
+    return _LEXER_BY_EXT.get(os.path.splitext(file_path or "")[1].lower())
+
+
+def _highlight(content: str, lexer: str | None):
+    """Syntax-highlight one code line into a Rich Text, or None on failure.
+
+    Bounded to the few preview lines a diff card shows, so the Pygments cost
+    is negligible. Uses `background_color="default"` so it stays transparent
+    over the terminal palette (ansi_default theme). Any failure → None, and
+    the caller falls back to the flat green/red/dim styling.
+    """
+    if not lexer or not content.strip():
+        return None
+    try:
+        from rich.syntax import Syntax
+        txt = Syntax(
+            content, lexer, theme="ansi_dark",
+            background_color="default", word_wrap=False,
+        ).highlight(content)
+        txt.rstrip()  # drop the trailing newline Syntax appends
+        return txt
+    except Exception:
+        return None
+
+
+def render_diff(log: "ChatLog", diff_text: str, max_body_lines: int = 8) -> None:
+    """Write a unified-diff blob to `log` with the structured layout.
+
+    The header row shows file path + change counts (+N -M). The body
+    shows up to `max_body_lines` lines of actual diff content; the
+    rest is summarized as "… +X more lines".
+    """
+    lines = diff_text.strip().splitlines()
+    added = sum(1 for l in lines if l.startswith("+") and not l.startswith("+++"))
+    removed = sum(1 for l in lines if l.startswith("-") and not l.startswith("---"))
+
+    file_path = ""
+    max_line_no = 1
+    for l in lines:
+        if l.startswith("+++ "):
+            file_path = l[4:].split("\t", 1)[0]
+        elif l.startswith("@@"):
+            m = _HUNK_HEADER_RE.search(l)
+            if m:
+                start = int(m.group(1))
+                span = int(m.group(2) or 0)
+                max_line_no = max(max_line_no, start + span)
+    gutter_w = max(2, len(str(max_line_no)) + 1)
+    lexer = _lexer_for(file_path)
+
+    # Header row
+    header = Text()
+    header.append("    ⎿ ", style=f"dim {C.primary}")
+    if file_path:
+        header.append(f"{file_path}  ", style=f"dim {C.primary}")
+    parts = []
+    if added:
+        parts.append(f"+{added}")
+    if removed:
+        parts.append(f"-{removed}")
+    header.append(" ".join(parts) if parts else "no changes", style="dim")
+    log.write(header)
+    log._track_lines()
+
+    # Prefix width: 4 (left pad) + gutter_w + 1 (space) + 2 ("│ " or
+    # "│   ") + 2 ("+ " / "- " / "  "). For context lines the "│   "
+    # is wider (4 instead of 2) — we compute per-line below. The
+    # continuation indent for wrapped long diff lines is a blank
+    # string of the same visual width as the prefix, so wrapped text
+    # visually hangs under the "+ …" / "- …" column instead of
+    # flush-lefting (image 110 bug).
+    prefix_w_changed = 4 + gutter_w + 1 + 2 + 2  # "- "/"+ " variant
+    prefix_w_context = 4 + gutter_w + 1 + 4      # "│   " + no marker
+    cont_indent_changed = " " * prefix_w_changed
+    cont_indent_context = " " * prefix_w_context
+
+    width_changed = _available_content_width(log, prefix_w_changed)
+    width_context = _available_content_width(log, prefix_w_context)
+
+    old_line = 0
+    new_line = 0
+    shown = 0
+    skipped = 0
+    for line_text in lines:
+        if line_text.startswith("---") or line_text.startswith("+++"):
+            continue
+        if line_text.startswith("@@"):
+            m = _HUNK_OLD_RE.search(line_text)
+            if m:
+                old_line = int(m.group(1))
+            m2 = _HUNK_HEADER_RE.search(line_text)
+            if m2:
+                new_line = int(m2.group(1))
+            if shown > 0 and shown < max_body_lines:
+                sep = Text()
+                sep.append(" " * (6 + gutter_w) + "…", style="dim")
+                log.write(sep)
+                log._track_lines()
+                shown += 1
+            continue
+        if shown >= max_body_lines:
+            skipped += 1
+            continue
+
+        if line_text.startswith("-"):
+            def _first_minus(ol=old_line):
+                t = Text()
+                t.append(f"    {ol:>{gutter_w}} ", style=f"dim {C.error}")
+                t.append("│ ", style=f"dim {C.primary}")
+                t.append("- ", style=f"bold {C.error}")
+                return t
+            def _cont_minus():
+                return Text(cont_indent_changed)
+            _emit_wrapped_line(
+                log, line_text[1:], _first_minus, _cont_minus,
+                content_style=f"{C.error}", content_width=width_changed,
+            )
+            old_line += 1
+        elif line_text.startswith("+"):
+            def _first_plus(nl=new_line):
+                t = Text()
+                t.append(f"    {nl:>{gutter_w}} ", style=f"dim {C.success}")
+                t.append("│ ", style=f"dim {C.primary}")
+                t.append("+ ", style=f"bold {C.success}")
+                return t
+            def _cont_plus():
+                return Text(cont_indent_changed)
+            _emit_wrapped_line(
+                log, line_text[1:], _first_plus, _cont_plus,
+                content_style=f"{C.success}", content_width=width_changed,
+                highlighted=_highlight(line_text[1:], lexer),
+            )
+            new_line += 1
+        else:
+            content = line_text[1:] if line_text.startswith(" ") else line_text
+            if not content.strip():
+                old_line += 1
+                new_line += 1
+                continue
+            def _first_ctx(nl=new_line):
+                t = Text()
+                t.append(f"    {nl:>{gutter_w}} ", style="dim")
+                t.append("│   ", style=f"dim {C.primary}")
+                return t
+            def _cont_ctx():
+                return Text(cont_indent_context)
+            _emit_wrapped_line(
+                log, content, _first_ctx, _cont_ctx,
+                content_style="dim", content_width=width_context,
+                highlighted=_highlight(content, lexer),
+            )
+            old_line += 1
+            new_line += 1
+
+        shown += 1
+
+    if skipped > 0:
+        more = Text()
+        more.append(" " * (6 + gutter_w), style="")
+        more.append(f"… +{skipped} more lines", style="dim italic")
+        log.write(more)
+        log._track_lines()

localcode/tui/widgets/voice_visualizer.py

@@ -0,0 +1,122 @@
+"""Live audio volume indicator — a single tall narrow bar.
+
+Renders one short row containing a wide block character whose
+*fill level* changes with the mic's instantaneous volume, plus a
+small REC timer to the right. The bar's color cycles through a
+rainbow palette over time so even silence has a quiet pulse.
+
+Width is fixed (a few cells) — this isn't a waveform history strip,
+it's a single VU-meter-style bar. Pulls `peak` straight off the
+Recorder instance owned by the chat screen. Refreshes at ~30 FPS
+when active; hidden the rest of the time.
+"""
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from textual.widgets import Static
+
+
+# Vertical fill levels from empty to full. Each character occupies the
+# bottom Nth of a single text cell, so reading left-to-right these
+# look like a single bar growing from the bottom of the line up.
+_FILL = [" ", "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"]
+
+# Curated rainbow that reads well on both dark and light terminals.
+_PALETTE = [
+    "#ff5470", "#ff8a5b", "#ffd166", "#9bff8a", "#5bffc1",
+    "#5bd1ff", "#5b96ff", "#9b5bff", "#e75bff", "#ff5bd1",
+]
+
+# Bar is one cell wide — reads as a single thin pulsing bar at a glance.
+_BAR_WIDTH = 1
+
+
+class VoiceVisualizer(Static):
+    """A small VU-meter-style bar that breathes with mic input."""
+
+    DEFAULT_CSS = """
+    VoiceVisualizer {
+        height: 1;
+        width: 1;                /* exactly one cell — no phantom column */
+        background: ansi_default;
+        padding: 0;
+        margin: 0 0 0 1;         /* one space gap from input, nothing else */
+        display: none;          /* hidden when not recording */
+    }
+    VoiceVisualizer.active {
+        display: block;
+    }
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__("", *args, **kwargs)
+        self.recorder: Any = None
+        self._t0 = time.time()
+        self._timer = None
+        # Smoothed amplitude — EMA so the bar's height doesn't jitter
+        # every frame. New samples weighted at 0.6, prior at 0.4.
+        self._smoothed = 0.0
+
+    # ── lifecycle ─────────────────────────────────────────────────
+
+    def activate(self, recorder: Any) -> None:
+        """Start the 30-FPS render loop pointed at `recorder`."""
+        self.recorder = recorder
+        self._smoothed = 0.0
+        self._t0 = time.time()
+        self.add_class("active")
+        if self._timer is None:
+            self._timer = self.set_interval(1 / 30, self._tick)
+
+    def deactivate(self) -> None:
+        """Stop the timer and hide the widget."""
+        if self._timer is not None:
+            try:
+                self._timer.stop()
+            except Exception:
+                pass
+            self._timer = None
+        self.recorder = None
+        self.remove_class("active")
+        self.update("")
+
+    # ── render ────────────────────────────────────────────────────
+
+    def _tick(self) -> None:
+        if self.recorder is None:
+            return
+        try:
+            peak = float(getattr(self.recorder, "peak", 0.0) or 0.0)
+        except Exception:
+            peak = 0.0
+        target = min(1.0, peak * 8.0)
+        self._smoothed = 0.3 * self._smoothed + 0.7 * target
+
+        # ALWAYS render the full-block char (█). The cell is fully
+        # filled — no "bottom gray" because we don't use partial-height
+        # fill chars anymore (they left the unfilled portion as the
+        # terminal background). Amplitude is shown by COLOR INTENSITY:
+        # quiet = dim, loud = bright. Color also cycles through the
+        # rainbow palette over time.
+        t = time.time() - self._t0
+        # Cycle through palette; amplitude jumps phase forward.
+        phase = int(t * 3) + int(self._smoothed * 4)
+        base_color = _PALETTE[phase % len(_PALETTE)]
+
+        # Brightness modulation — at silence, mix toward dim grey; at
+        # peak, full saturation. Linear blend on RGB.
+        def _hex_to_rgb(h):
+            h = h.lstrip("#")
+            return int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)
+        r, g, b = _hex_to_rgb(base_color)
+        # Floor at 0.35 so silence still shows a visible glow (not pitch
+        # black, which would read as "off"). Loud peaks pull to 1.0.
+        intensity = 0.35 + 0.65 * self._smoothed
+        r = int(r * intensity)
+        g = int(g * intensity)
+        b = int(b * intensity)
+        color = f"#{r:02x}{g:02x}{b:02x}"
+
+        self.update(f"[{color}]█[/]")

localcode/turn_diff.py

@@ -0,0 +1,180 @@
+"""Turn-level diff aggregation — show what changed in one user turn.
+
+Instead of showing individual file operation diffs, aggregate all changes
+since the turn started into one unified view:
+
+    Turn summary:
+      +15 -3  auth.py (modified)
+      +42     models/user.py (created)
+      -1      old_config.py (deleted)
+    Total: 3 files, +57 -4
+
+This gives users a clear "what did the agent do" picture.
+"""
+from __future__ import annotations
+
+import difflib
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class FileChange:
+    """A single file's changes within a turn."""
+    path: str
+    action: str  # "created" | "modified" | "deleted"
+    lines_added: int = 0
+    lines_removed: int = 0
+    old_content: str = ""
+    new_content: str = ""
+
+
+@dataclass
+class TurnDiff:
+    """Aggregated changes for an entire turn."""
+    changes: list[FileChange] = field(default_factory=list)
+
+    @property
+    def total_added(self) -> int:
+        return sum(c.lines_added for c in self.changes)
+
+    @property
+    def total_removed(self) -> int:
+        return sum(c.lines_removed for c in self.changes)
+
+    @property
+    def files_changed(self) -> int:
+        return len(self.changes)
+
+    @property
+    def file_paths(self) -> list[str]:
+        return [c.path for c in self.changes]
+
+
+class TurnDiffTracker:
+    """Track file changes within a single user turn.
+
+    Usage:
+        tracker = TurnDiffTracker(repo_root)
+        tracker.start_turn()
+        # ... agent does work ...
+        diff = tracker.end_turn()
+        print(format_turn_diff(diff))
+    """
+
+    def __init__(self, repo_root: str | Path) -> None:
+        self.root = Path(repo_root)
+        self._baselines: dict[str, str | None] = {}  # path → content at turn start (None = didn't exist)
+        self._tracking = False
+
+    def start_turn(self, watched_files: list[str] | None = None) -> None:
+        """Snapshot current state of tracked files at turn start."""
+        self._baselines.clear()
+        self._tracking = True
+
+        if watched_files:
+            for rel_path in watched_files:
+                self._snapshot(rel_path)
+
+    def track_file(self, rel_path: str) -> None:
+        """Start tracking a file mid-turn (called when agent reads/writes a file)."""
+        if self._tracking and rel_path not in self._baselines:
+            self._snapshot(rel_path)
+
+    def end_turn(self) -> TurnDiff:
+        """Compute aggregated diff for the turn."""
+        self._tracking = False
+        changes = []
+
+        for rel_path, old_content in self._baselines.items():
+            full = self.root / rel_path
+            new_exists = full.is_file()
+
+            if old_content is None and new_exists:
+                # File was created
+                new_content = full.read_text(errors="replace")
+                added = len(new_content.splitlines())
+                changes.append(FileChange(
+                    path=rel_path, action="created",
+                    lines_added=added, lines_removed=0,
+                    old_content="", new_content=new_content,
+                ))
+
+            elif old_content is not None and not new_exists:
+                # File was deleted
+                removed = len(old_content.splitlines())
+                changes.append(FileChange(
+                    path=rel_path, action="deleted",
+                    lines_added=0, lines_removed=removed,
+                    old_content=old_content, new_content="",
+                ))
+
+            elif old_content is not None and new_exists:
+                # File was (potentially) modified
+                new_content = full.read_text(errors="replace")
+                if new_content != old_content:
+                    old_lines = old_content.splitlines()
+                    new_lines = new_content.splitlines()
+                    diff = list(difflib.unified_diff(old_lines, new_lines))
+                    added = sum(1 for l in diff if l.startswith("+") and not l.startswith("+++"))
+                    removed = sum(1 for l in diff if l.startswith("-") and not l.startswith("---"))
+                    changes.append(FileChange(
+                        path=rel_path, action="modified",
+                        lines_added=added, lines_removed=removed,
+                        old_content=old_content, new_content=new_content,
+                    ))
+
+        self._baselines.clear()
+        return TurnDiff(changes=changes)
+
+    def _snapshot(self, rel_path: str) -> None:
+        """Take a baseline snapshot of a file."""
+        full = self.root / rel_path
+        if full.is_file():
+            try:
+                self._baselines[rel_path] = full.read_text(errors="replace")
+            except Exception:
+                self._baselines[rel_path] = ""
+        else:
+            self._baselines[rel_path] = None  # doesn't exist yet
+
+
+# ── Display ─────────────────────────────────────────────────────────
+
+GREEN = "\033[92m"
+RED = "\033[91m"
+DIM = "\033[2m"
+BOLD = "\033[1m"
+RESET = "\033[0m"
+
+
+def format_turn_diff(diff: TurnDiff) -> str:
+    """Format a TurnDiff for terminal display."""
+    if not diff.changes:
+        return ""
+
+    lines = [f"\n{BOLD}  Turn summary:{RESET}"]
+
+    for change in diff.changes:
+        added = f"{GREEN}+{change.lines_added}{RESET}" if change.lines_added else ""
+        removed = f"{RED}-{change.lines_removed}{RESET}" if change.lines_removed else ""
+        stats = f"{added} {removed}".strip()
+        action = f"{DIM}({change.action}){RESET}"
+        lines.append(f"    {stats:>12}  {change.path} {action}")
+
+    # Total
+    lines.append(
+        f"  {DIM}Total: {diff.files_changed} file(s), "
+        f"{GREEN}+{diff.total_added}{RESET} {RED}-{diff.total_removed}{RESET}{DIM}{RESET}"
+    )
+
+    return "\n".join(lines)
+
+
+def print_turn_diff(diff: TurnDiff) -> None:
+    """Print turn diff to stdout."""
+    text = format_turn_diff(diff)
+    if text:
+        sys.stdout.write(text + "\n")
+        sys.stdout.flush()

localcode/ui/FORK_COMMIT

@@ -0,0 +1 @@
+e0ca52b8bae67723ff15097b80a5531b6a74860a

localcode/ui/__init__.py

@@ -0,0 +1,58 @@
+"""localcode's default interface: the localcode agent runtime (a fork of
+opencode, branded and stripped of cloud features) driven by a small Python
+supervisor that owns the bundled llama-server and serves the in-app model
+picker on a localhost control port.
+
+Layout:
+  launch.py      what `localcode` runs by default (see entrypoint.py)
+  supervisor.py  llama-server owner + control API (/catalog /quants /select ...)
+  server_cmd.py  the llama-server command line for THIS machine (RAM tier, KV, thinking)
+  ports.py       singleton guard + free port pair
+  plugin/        completion discipline loaded into the runtime as a plugin
+  FORK_COMMIT    the exact source commit the bundled binary was built from
+
+State lives under ~/.local/share/localcode-agent/run (logs, voice runtime),
+never inside the user's project.
+"""
+from __future__ import annotations
+
+import os
+import platform
+from pathlib import Path
+
+UI_BINARY_NAME = "localcode-ui"
+
+
+def run_dir() -> Path:
+    """Per-user scratch dir for the supervisor and launcher (logs, voice venv)."""
+    base = os.environ.get("LOCALCODE_AGENT_RUN_DIR")
+    path = Path(base) if base else Path.home() / ".local" / "share" / "localcode-agent" / "run"
+    return path
+
+
+def fork_commit() -> str:
+    try:
+        return (Path(__file__).parent / "FORK_COMMIT").read_text().strip()
+    except OSError:
+        return "unknown"
+
+
+def ui_binary_path() -> Path | None:
+    """The bundled UI binary, or None when this install has none.
+
+    LOCALCODE_UI_BIN overrides for development against a fresh fork build.
+    """
+    override = os.environ.get("LOCALCODE_UI_BIN")
+    if override:
+        p = Path(override).expanduser()
+        return p if p.is_file() else None
+    p = Path(__file__).resolve().parent.parent / "bin" / UI_BINARY_NAME
+    return p if p.is_file() else None
+
+
+def platform_supported() -> bool:
+    return platform.system() == "Darwin" and platform.machine().lower() == "arm64"
+
+
+def plugin_path() -> Path:
+    return Path(__file__).resolve().parent / "plugin" / "localcode.ts"