decorated-pi 0.7.2 → 0.8.0

package/tools/patch/encoding.ts

@@ -0,0 +1,172 @@
+/**
+ * Encoding detection and conversion for patch.
+ *
+ * - chardet analyses raw bytes (BOM + histogram heuristics) → encoding name.
+ * - iconv-lite decodes/encodes between Buffer and string.
+ *
+ * For UTF-8 (the overwhelmingly common case) we bypass iconv-lite and use
+ * Node's native string<->Buffer conversion — zero behaviour change vs the
+ * pre-encoding-aware tool, and no iconv runtime cost for ASCII/UTF-8 files.
+ */
+
+import * as fs from "node:fs";
+import chardet, { type Match } from "chardet";
+import * as iconv from "iconv-lite";
+
+export interface FileEncoding {
+  /** iconv-lite-compatible encoding name (e.g. "utf-8", "gb18030", "utf-16le"). */
+  encoding: string;
+  /** True when the file starts with a BOM that should be preserved on write. */
+  hasBOM: boolean;
+  /** True when the file is UTF-8 (with or without BOM). Native path is used. */
+  isUtf8: boolean;
+}
+
+// chardet emits "UTF-8" for plain UTF-8. iconv-lite accepts any case.
+const UTF8_ALIASES = new Set(["utf-8", "utf8", "ascii"]);
+const UTF8_BOM = Buffer.from([0xef, 0xbb, 0xbf]);
+const UTF16LE_BOM = Buffer.from([0xff, 0xfe]);
+const UTF16BE_BOM = Buffer.from([0xfe, 0xff]);
+
+/** Returns true if `buf` is valid UTF-8 (every byte parses, no U+FFFD
+ *  replacement). Pure-ASCII and any well-formed UTF-8 qualify. */
+function isValidUtf8(buf: Buffer): boolean {
+  // Writing then reading back would corrupt invalid sequences into U+FFFD;
+  // detect that by comparing round-trip byte lengths. The cheap, correct
+  // check is Node's built-in: toString('utf8') replaces bad sequences with
+  // U+FFFD, so we scan the decoded string for it.
+  if (buf.length === 0) return true;
+  const s = buf.toString("utf8");
+  return !s.includes("\uFFFD");
+}
+
+function looksLikeUtf8Bom(buf: Buffer): boolean {
+  return buf.length >= 3 && buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf;
+}
+
+function looksLikeUtf16LeBom(buf: Buffer): boolean {
+  return buf.length >= 2 && buf[0] === 0xff && buf[1] === 0xfe;
+}
+
+function looksLikeUtf16BeBom(buf: Buffer): boolean {
+  return buf.length >= 2 && buf[0] === 0xfe && buf[1] === 0xff;
+}
+
+/**
+ * Detect a file's encoding by reading its bytes.
+ * Falls back to UTF-8 if detection fails or the detected encoding is not
+ * supported by iconv-lite.
+ */
+export function detectFileEncoding(filePath: string): FileEncoding {
+  const buf = fs.readFileSync(filePath);
+
+  // BOM takes precedence for the UTF-16/UTF-32 family (endianness matters).
+  if (looksLikeUtf8Bom(buf)) {
+    return { encoding: "utf-8", hasBOM: true, isUtf8: true };
+  }
+  if (looksLikeUtf16LeBom(buf)) {
+    return { encoding: "utf-16le", hasBOM: true, isUtf8: false };
+  }
+  if (looksLikeUtf16BeBom(buf)) {
+    return { encoding: "utf-16be", hasBOM: true, isUtf8: false };
+  }
+
+  // Any well-formed UTF-8 (including pure ASCII) is UTF-8. This short-circuits
+  // chardet's tendency to mis-classify short or ASCII-only buffers as exotic
+  // encodings (e.g. 2-byte "x\n" as utf-32le).
+  if (isValidUtf8(buf)) {
+    return { encoding: "utf-8", hasBOM: false, isUtf8: true };
+  }
+
+  // Not valid UTF-8 — trust chardet's heuristic for the legacy encoding.
+  // chardet mis-classifies short or mixed CJK samples (it often ties GBK,
+  // Big5, Shift_JIS, EUC-JP, EUC-KR at the same low confidence). Use the
+  // full ranked list and prefer Chinese encodings — GB18030 is a superset
+  // of GBK/GB2312 and the most common non-UTF-8 encoding for Chinese text,
+  // which is the primary use case for this tool.
+  const candidates = chardet.analyse(buf);
+  let encoding = pickLegacyEncoding(candidates);
+  let hasBOM = false;
+
+  // Verify iconv-lite actually ships a codec for this label; otherwise fall
+  // back to UTF-8 (the previous behaviour) instead of throwing mid-edit.
+  if (!iconv.encodingExists(encoding)) {
+    encoding = "utf-8";
+    hasBOM = false;
+  }
+
+  // Last-resort safety net: if the chosen encoding still produces U+FFFD
+  // replacement chars on decode, the file is not actually in that encoding
+  // and we would corrupt it on write-back. Fall back to ISO-8859-1 (Latin1),
+  // which is a lossless 1:1 byte<->code-point mapping for 0x00–0xFF and can
+  // never introduce U+FFFD — round-tripping is byte-identical.
+  if (!UTF8_ALIASES.has(encoding) && iconv.decode(buf, encoding).includes("\uFFFD")) {
+    encoding = "iso-8859-1";
+    hasBOM = false;
+  }
+
+  return {
+    encoding,
+    hasBOM,
+    isUtf8: UTF8_ALIASES.has(encoding),
+  };
+}
+
+/** Preference order for breaking chardet ties. Chinese first (GB18030 is a
+ *  superset of GBK/GB2312), then other CJK, then everything else. */
+const ENCODING_PRIORITY: string[] = [
+  "gb18030", "gbk", "gb2312",  // Chinese (mainland)
+  "big5",                       // Chinese (traditional)
+  "shift_jis", "euc-jp",        // Japanese
+  "euc-kr", "windows-949",      // Korean
+  "windows-1252", "iso-8859-1", // Western (rarely reached: isValidUtf8 short-circuits)
+];
+
+function pickLegacyEncoding(candidates: Match[]): string {
+  if (candidates.length === 0) return "iso-8859-1";
+  const top = candidates[0]!.confidence;
+  // Keep only candidates tied with the top confidence (±5 tolerance —
+  // chardet's scores are coarse).
+  const tied = candidates.filter((c) => Math.abs(c.confidence - top) <= 5);
+  for (const pref of ENCODING_PRIORITY) {
+    const hit = tied.find((c) => c.name.toLowerCase() === pref);
+    if (hit) return pref;
+  }
+  // We only reach here when isValidUtf8 already failed (there are high
+  // bytes), so "ascii" / "UTF-8" from chardet are wrong. ISO-8859-1 is the
+  // safe single-byte fallback — lossless for 0x00–0xFF, no U+FFFD.
+  return "iso-8859-1";
+}
+
+/** Read a file as a string, decoding via the detected encoding. */
+export function readFileDecoded(filePath: string, enc: FileEncoding): string {
+  const buf = fs.readFileSync(filePath);
+  if (enc.isUtf8) {
+    // Native path: identical to the old fs.readFileSync(p, "utf8").
+    // For UTF-8 with BOM, slice off the BOM so it does not leak into content
+    // matching (it would prefix the first line and break old_str lookups).
+    const slice = enc.hasBOM ? buf.subarray(3) : buf;
+    return slice.toString("utf8");
+  }
+  return iconv.decode(buf, enc.encoding, { stripBOM: true });
+}
+
+/** Write a string back to a file, encoding via the detected encoding. */
+export function writeFileEncoded(
+  filePath: string,
+  content: string,
+  enc: FileEncoding,
+): void {
+  if (enc.isUtf8) {
+    if (enc.hasBOM) {
+      const body = Buffer.from(content, "utf8");
+      const out = Buffer.concat([UTF8_BOM, body]);
+      fs.writeFileSync(filePath, out);
+      return;
+    }
+    fs.writeFileSync(filePath, content, "utf8");
+    return;
+  }
+  const buf = iconv.encode(content, enc.encoding, { addBOM: enc.hasBOM });
+  fs.writeFileSync(filePath, buf);
+}

package/tsconfig.json

@@ -19,6 +19,7 @@
     "commands/**/*.ts",
     "providers/**/*.ts",
     "ui/**/*.ts",
+    "utils/**/*.ts",
     "test/**/*.ts"
   ],
   "exclude": ["node_modules", "dist"]

package/ui/ask.ts

@@ -28,10 +28,6 @@ export interface AskQuestion {
   question: string;
   options?: string[];
   default?: string;
-  /** When true on single/multi, an "Other" row is appended after the
-   *  regular options. Picking it switches the row into an inline text
-   *  input — lets the user type a custom answer not in the preset list. */
-  allowCustom?: boolean;
 }
 
 export interface AskAnswer {
@@ -41,7 +37,7 @@ export interface AskAnswer {
 
 interface QuestionState {
   value: string | string[];
-  cursor: number; // option cursor; for allowCustom, opts.length = "Other" row
+  cursor: number; // option cursor; opts.length maps to the "Other" row
   /** Typed text when the cursor sits on the "Other" row (single or multi). */
   customText: string;
   /** Multi only: whether "Other" is currently toggled into the selection. */
@@ -62,10 +58,39 @@ function parseDefault(type: AskQuestionType, options: string[] | undefined, defa
   return { value: selected, cursor: 0, customText: "", customSelected: false };
 }
 
-/** For single/multi with allowCustom, returns the effective option count
+/** Returns true for single/multi choice questions, which always get an
+ *  "Other" row for entering a custom answer not in the preset list. */
+function hasOtherRow(q: AskQuestion): boolean {
+  return q.type === "single" || q.type === "multi";
+}
+
+/** For single/multi questions, returns the effective option count
  *  (regular options plus the "Other" row). */
 function effectiveOptionCount(q: AskQuestion): number {
-  return (q.options?.length ?? 0) + (q.allowCustom ? 1 : 0);
+  return (q.options?.length ?? 0) + (hasOtherRow(q) ? 1 : 0);
+}
+
+const BRACKETED_PASTE_START = "\x1b[200~";
+const BRACKETED_PASTE_END = "\x1b[201~";
+
+/** Extract content from a bracketed-paste sequence. Returns undefined if the
+ *  data is not a complete paste. Any trailing input after the end marker is
+ *  returned as `remaining` so it can be processed recursively. */
+function extractBracketedPaste(data: string): { content: string; remaining: string } | undefined {
+  if (!data.startsWith(BRACKETED_PASTE_START)) return undefined;
+  const afterStart = data.slice(BRACKETED_PASTE_START.length);
+  const endIndex = afterStart.indexOf(BRACKETED_PASTE_END);
+  if (endIndex === -1) return undefined;
+  return {
+    content: afterStart.slice(0, endIndex),
+    remaining: afterStart.slice(endIndex + BRACKETED_PASTE_END.length),
+  };
+}
+
+/** Normalize pasted text for a single-line input: strip line breaks and
+ *  expand tabs to spaces (matches pi-tui's built-in Input behavior). */
+function cleanPastedText(text: string): string {
+  return text.replace(/\r\n/g, "").replace(/\r/g, "").replace(/\n/g, "").replace(/\t/g, "    ");
 }
 
 class DynamicBorder implements Component {
@@ -133,31 +158,31 @@ export class AskComponent extends Container {
     const state = this.currentState();
     if (q.type === "text") return (state.value as string).trim() !== "";
     if (q.type === "single") {
-      if (q.allowCustom && state.cursor === (q.options?.length ?? 0)) {
+      if (state.cursor === (q.options?.length ?? 0)) {
         return state.customText.trim() !== "";
       }
       return (state.value as string) !== "";
     }
     // multi: valid if any regular option is selected, or "Other" is
     // toggled AND has non-empty custom text.
-    if (q.allowCustom && state.customSelected) {
+    if (state.customSelected) {
       return state.customText.trim() !== "" || (state.value as string[]).length > 0;
     }
     return (state.value as string[]).length > 0;
   }
 
   /** The answer that will actually be submitted for this question. Differs
-   *  from state.value when allowCustom is in play and "Other" is chosen. */
+   *  from state.value when the cursor is on the "Other" row. */
   private committedValue(q: AskQuestion, state: QuestionState): string | string[] {
     if (q.type === "single") {
-      if (q.allowCustom && state.cursor === (q.options?.length ?? 0)) {
+      if (state.cursor === (q.options?.length ?? 0)) {
         return state.customText.trim();
       }
       return state.value as string;
     }
     if (q.type === "multi") {
       const base = state.value as string[];
-      if (q.allowCustom && state.customSelected && state.customText.trim() !== "") {
+      if (state.customSelected && state.customText.trim() !== "") {
         return [...base, state.customText.trim()];
       }
       return base;
@@ -209,6 +234,35 @@ export class AskComponent extends Container {
   handleInput(data: string): void {
     const kb = getKeybindings();
 
+    // ── Bracketed paste ─────────────────────────────────────────────
+    // Terminals that support bracketed paste mode wrap pasted content in
+    // \x1b[200~ ... \x1b[201~. Without handling this, the leading ESC is
+    // rejected as a control character and nothing is inserted.
+    const paste = extractBracketedPaste(data);
+    if (paste) {
+      if (!this.summaryMode) {
+        const text = cleanPastedText(paste.content);
+        const q = this.currentQuestion();
+        const state = this.currentState();
+        if (q.type === "text") {
+          state.value = (state.value as string) + text;
+        } else if (hasOtherRow(q)) {
+          const opts = q.options ?? [];
+          if (state.cursor === opts.length) {
+            state.customText += text;
+            if (q.type === "multi") {
+              state.customSelected = true;
+            }
+          }
+        }
+        this.renderView();
+      }
+      if (paste.remaining) {
+        this.handleInput(paste.remaining);
+      }
+      return;
+    }
+
     // ── Summary mode ────────────────────────────────────────────────
     if (this.summaryMode) {
       if (data === "\r" || data === "\n" || kb.matches(data, "tui.select.confirm")) {
@@ -264,7 +318,7 @@ export class AskComponent extends Container {
     } else if (q.type === "single" && q.options) {
       const opts = q.options;
       const totalLen = effectiveOptionCount(q);
-      const onCustomRow = q.allowCustom === true && state.cursor === opts.length;
+      const onCustomRow = state.cursor === opts.length;
 
       if (kb.matches(data, "tui.select.up")) {
         const next = (state.cursor - 1 + totalLen) % totalLen;
@@ -290,7 +344,7 @@ export class AskComponent extends Container {
     } else if (q.type === "multi" && q.options) {
       const opts = q.options;
       const totalLen = effectiveOptionCount(q);
-      const onCustomRow = q.allowCustom === true && state.cursor === opts.length;
+      const onCustomRow = state.cursor === opts.length;
 
       if (kb.matches(data, "tui.select.up")) {
         state.cursor = (state.cursor - 1 + totalLen) % totalLen;
@@ -367,7 +421,7 @@ export class AskComponent extends Container {
       const opts = q.options;
       const totalLen = effectiveOptionCount(q);
       for (let j = 0; j < totalLen; j++) {
-        const isCustomRow = q.allowCustom === true && j === opts.length;
+        const isCustomRow = j === opts.length;
         const optLabel = isCustomRow ? "Other" : opts[j];
         const selected = isCustomRow ? false : optLabel === state.value;
         const atCursor = j === state.cursor;
@@ -389,7 +443,7 @@ export class AskComponent extends Container {
       const opts = q.options;
       const totalLen = effectiveOptionCount(q);
       for (let j = 0; j < totalLen; j++) {
-        const isCustomRow = q.allowCustom === true && j === opts.length;
+        const isCustomRow = j === opts.length;
         const optLabel = isCustomRow ? "Other" : opts[j];
         const inValue = !isCustomRow && (state.value as string[]).includes(optLabel);
         const customOn = isCustomRow && state.customSelected;
@@ -413,13 +467,9 @@ export class AskComponent extends Container {
     if (q.type === "text") {
       hint = "Enter next · Esc cancel";
     } else if (q.type === "single") {
-      hint = q.allowCustom
-        ? "↑↓ move · Enter next · Esc cancel"
-        : "↑↓ move · Enter next · Esc cancel";
+      hint = "↑↓ move · Enter next · Esc cancel";
     } else {
-      hint = q.allowCustom
-        ? "↑↓ move · Space toggle · Enter next · Esc cancel"
-        : "↑↓ move · Space toggle · Enter next · Esc cancel";
+      hint = "↑↓ move · Space toggle · Enter next · Esc cancel";
     }
     this.hintComponent.setText(this.theme.fg("dim", "  " + hint));
   }

package/ui/module-settings.ts

@@ -6,9 +6,11 @@
  * category so the user can toggle each one.
  */
 
-import type { Theme as PiTheme } from "@earendil-works/pi-coding-agent";
+import type { Theme as PiTheme, ExtensionUIContext } from "@earendil-works/pi-coding-agent";
 import { Container, SettingsList, type TUI, type SettingsListTheme, type SettingItem, type Component } from "@earendil-works/pi-tui";
-import { getAllModuleSettings, setModuleEnabled, type ModuleSettings } from "../settings.js";
+import { getAllModuleSettings, setModuleEnabled, type ModuleSettings, getDependencyPath, setDependencyPath, isDontBother, setDontBother, getDependencyView, listDependencyViewNames } from "../settings.js";
+import { listLspBinaryNames } from "../tools/lsp/servers.js";
+import { listMcpBinaryNames } from "../tools/mcp/config.js";
 
 type ModuleName =
   | "patchOverrideEdit"
@@ -48,7 +50,7 @@ const MODULE_DESCS: Record<ModuleName, string> = {
   usage: "/usage command for token stats",
 };
 
-type CategoryId = "tools" | "hooks" | "commands";
+type CategoryId = "commands" | "hooks" | "tools";
 
 interface CategoryDef {
   label: string;
@@ -57,23 +59,27 @@ interface CategoryDef {
 }
 
 const CATEGORIES: Record<CategoryId, CategoryDef> = {
-  tools: {
-    label: "Tools",
-    description: "LLM-callable tools",
-    modules: ["patchOverrideEdit", "ask", "lsp", "mcp"],
+  commands: {
+    label: "Commands",
+    description: "Slash commands",
+    modules: ["atOverride", "retry", "usage"],
   },
   hooks: {
     label: "Hooks",
     description: "Agent-loop event handlers",
-    modules: ["secretRedaction", "rtk", "wakatime"],
+    modules: ["rtk", "secretRedaction", "wakatime"],
   },
-  commands: {
-    label: "Commands",
-    description: "Slash commands",
-    modules: ["atOverride", "retry", "usage"],
+  tools: {
+    label: "Tools",
+    description: "LLM-callable tools",
+    modules: ["ask", "lsp", "mcp", "patchOverrideEdit"],
   },
 };
 
+// Hard-coded display order, alphabetized by visible label. Dependencies is
+// inserted between Commands and Hooks in ModuleSettingsComponent below.
+const CATEGORY_ORDER: CategoryId[] = ["commands", "hooks", "tools"];
+
 class DynamicBorder implements Component {
   private colorFn: (str: string) => string;
   constructor(theme: PiTheme) { this.colorFn = (str: string) => theme.fg("border", str); }
@@ -135,8 +141,6 @@ class CategorySubmenu extends Container {
       (id: string, newValue: string) => {
         setModuleEnabled(id, newValue === "on");
         this.list.updateValue(id, newValue);
-        // Stay open so the user can toggle multiple items; the parent
-        // summary updates when the submenu is closed with Esc.
       },
       () => done(summaryFor(getAllModuleSettings(), category.modules)),
     );
@@ -152,14 +156,132 @@ class CategorySubmenu extends Container {
   }
 }
 
+/** Submenu for configuring binary path overrides. Each row is a binary
+ *  that decorated-pi looks up at startup; Enter opens an input dialog
+ *  where the user can type an absolute path (or clear it). */
+function dependencyDisplayValue(name: string): string {
+  const view = getDependencyView(name);
+  if (view.path) return view.path;
+  if (view.resolvedPath) return view.resolvedPath;
+  if (view.resolvedState === undefined) return view.dontBother ? "(not checked, silenced)" : "(not checked)";
+  return view.dontBother ? "(not found, silenced)" : "(not found)";
+}
+
+class DependencyBinarySubmenu extends Container {
+  private list: SettingsList;
+  private name: string;
+  private ui: ExtensionUIContext;
+
+  constructor(name: string, theme: PiTheme, ui: ExtensionUIContext, done: (summary?: string) => void) {
+    super();
+    this.name = name;
+    this.ui = ui;
+
+    const items: SettingItem[] = [
+      {
+        id: "path",
+        label: "Path override",
+        description: "Enter to edit; empty to clear override",
+        currentValue: dependencyDisplayValue(name),
+        values: ["edit"],
+      },
+      {
+        id: "dontBother",
+        label: "dontBother",
+        description: "Silence missing-dependency notification for this binary",
+        currentValue: isDontBother(name) ? "on" : "off",
+        values: ["off", "on"],
+      },
+    ];
+
+    this.list = new SettingsList(
+      items,
+      10,
+      getSettingsListTheme(theme),
+      (id: string, newValue: string) => {
+        if (id === "dontBother") {
+          setDontBother(this.name, newValue === "on");
+          this.list.updateValue("dontBother", newValue);
+          this.list.updateValue("path", dependencyDisplayValue(this.name));
+          return;
+        }
+        this.list.updateValue("path", dependencyDisplayValue(this.name));
+        void this.promptForPath();
+      },
+      () => done(dependencyDisplayValue(this.name)),
+    );
+    this.addChild(this.list);
+  }
+
+  handleInput(data: string) {
+    this.list.handleInput(data);
+  }
+
+  private async promptForPath(): Promise<void> {
+    const current = getDependencyPath(this.name) ?? "";
+    const input = await this.ui.input(
+      `Path for ${this.name} (empty to clear)`,
+      current || `/absolute/path/to/${this.name}`,
+    );
+    if (input === undefined) return;
+    setDependencyPath(this.name, input.trim() === "" ? null : input.trim());
+    this.list.updateValue("path", dependencyDisplayValue(this.name));
+  }
+
+  render(width: number): string[] {
+    return this.list.render(width);
+  }
+}
+
+class DependenciesSubmenu extends Container {
+  private list: SettingsList;
+  private binaryNames: string[];
+
+  constructor(theme: PiTheme, ui: ExtensionUIContext, done: (summary?: string) => void) {
+    super();
+    // Builtins we know about plus entries already present in config/shadow.
+    this.binaryNames = listDependencyViewNames([
+      "rtk",
+      "wakatime-cli",
+      ...listLspBinaryNames(),
+      ...listMcpBinaryNames(),
+    ]);
+
+    const items: SettingItem[] = this.binaryNames.map((name) => ({
+      id: name,
+      label: name,
+      description: "Enter to configure path override and dontBother",
+      currentValue: dependencyDisplayValue(name),
+      submenu: (_currentValue, submenuDone) => new DependencyBinarySubmenu(name, theme, ui, submenuDone),
+    }));
+
+    this.list = new SettingsList(
+      items,
+      10,
+      getSettingsListTheme(theme),
+      () => {},
+      () => done(summaryForDependencies()),
+    );
+    this.addChild(this.list);
+  }
+
+  handleInput(data: string) {
+    this.list.handleInput(data);
+  }
+
+  render(width: number): string[] {
+    return this.list.render(width);
+  }
+}
+
 export class ModuleSettingsComponent extends Container {
   private settingsList: SettingsList;
 
-  constructor(tui: TUI, theme: PiTheme, onDone: () => void) {
+  constructor(tui: TUI, theme: PiTheme, ui: ExtensionUIContext, onDone: () => void) {
     super();
     const modules = getAllModuleSettings();
 
-    const categoryItems: SettingItem[] = (Object.keys(CATEGORIES) as CategoryId[]).map((id) => ({
+    const categoryItems: SettingItem[] = CATEGORY_ORDER.map((id) => ({
       id,
       label: CATEGORIES[id].label,
       description: CATEGORIES[id].description,
@@ -167,6 +289,17 @@ export class ModuleSettingsComponent extends Container {
       submenu: (_currentValue, done) => new CategorySubmenu(id, theme, done),
     }));
 
+    // Dependencies is a separate top-level category — it doesn't fit
+    // ModuleSettings' on/off toggle model. Insert it alphabetically between
+    // Commands and Hooks.
+    categoryItems.splice(1, 0, {
+      id: "dependencies",
+      label: "Dependencies",
+      description: "Override binary paths (rtk, wakatime-cli, LSP/MCP servers)",
+      currentValue: summaryForDependencies(),
+      submenu: (_currentValue, done) => new DependenciesSubmenu(theme, ui, done),
+    });
+
     this.addChild(new DynamicBorder(theme));
 
     this.settingsList = new SettingsList(
@@ -186,3 +319,20 @@ export class ModuleSettingsComponent extends Container {
     this.settingsList.handleInput(data);
   }
 }
+
+/** Count how many binaries have an explicit override. */
+function summaryForDependencies(): string {
+  // Builtins we know about: rtk, wakatime-cli, LSP servers, MCP servers.
+  const known = listDependencyViewNames([
+    "rtk",
+    "wakatime-cli",
+    ...listLspBinaryNames(),
+    ...listMcpBinaryNames(),
+  ]);
+  const overridden = known.filter((n) => getDependencyPath(n) !== null).length;
+  const silenced = known.filter((n) => isDontBother(n)).length;
+  const parts: string[] = [];
+  if (overridden) parts.push(`${overridden} overridden`);
+  if (silenced) parts.push(`${silenced} silenced`);
+  return parts.length ? parts.join(", ") : "default";
+}