decorated-pi 0.7.2 → 0.7.3

package/tools/lsp/servers.ts

@@ -2,9 +2,9 @@
  * LSP Server Config — language detection, server commands, workspace roots.
  */
 import { existsSync, readdirSync, type Dirent } from "node:fs";
-import { spawnSync } from "node:child_process";
 import { dirname, extname, isAbsolute, join, resolve } from "node:path";
 import type { DependencyStatus } from "../../hooks/skeleton.js";
+import { getDependencyPath, resolveDependency } from "../../settings.js";
 
 // ─── File extension → language mapping ────────────────────────────────────
 
@@ -97,6 +97,16 @@ export function listSupportedLanguages(): string[] {
   return Object.keys(LANGUAGE_SERVERS).sort();
 }
 
+/** Unique binary names used by builtin LSP servers. Used by the
+ *  /dp-settings Dependencies UI to know which binaries are configurable. */
+export function listLspBinaryNames(): string[] {
+  const seen = new Set<string>();
+  for (const lang of Object.keys(LANGUAGE_SERVERS)) {
+    seen.add(LANGUAGE_SERVERS[lang].command);
+  }
+  return [...seen].sort();
+}
+
 export function getServerConfig(
   language: string,
   cwd = process.cwd(),
@@ -104,6 +114,12 @@ export function getServerConfig(
   const base = LANGUAGE_SERVERS[language];
   if (!base) return undefined;
 
+  const override = getDependencyPath(base.command);
+  if (override) {
+    const resolvedOverride = resolveDependency(base.command, { extendPath: [] });
+    return { ...base, command: resolvedOverride ?? override, is_project_local: false };
+  }
+
   const resolved = resolveLocalBinary(base.command, cwd);
   return { ...base, command: resolved.command, is_project_local: resolved.is_project_local };
 }
@@ -147,14 +163,16 @@ export function collectLspDependencyStatuses(cwd: string): DependencyStatus[] {
   const statuses: DependencyStatus[] = [];
   const seen = new Set<string>();
   for (const language of listSupportedLanguages()) {
-    const cfg = getServerConfig(language, cwd);
-    if (!cfg || seen.has(cfg.command)) continue;
-    seen.add(cfg.command);
+    const base = LANGUAGE_SERVERS[language];
+    if (!base || seen.has(base.command)) continue;
+    seen.add(base.command);
+    const path = resolveLspBinary(base.command, cwd);
     statuses.push({
       module: "lsp",
-      label: cfg.command,
-      state: commandExists(cfg.command) ? "ok" : "missing",
-      detail: cfg.install_hint,
+      label: base.command,
+      state: path ? "ok" : "missing",
+      detail: base.install_hint,
+      path: path ?? undefined,
     });
   }
   return statuses;
@@ -174,14 +192,12 @@ export function findWorkspaceRoot(
 
 // ─── Internal helpers ─────────────────────────────────────────────────────
 
-function commandExists(command: string): boolean {
-  if (isAbsolute(command) || command.includes("/") || command.includes("\\")) {
-    return existsSync(command);
-  }
-  const result = process.platform === "win32"
-    ? spawnSync("where", [command], { encoding: "utf-8" })
-    : spawnSync(process.env.SHELL || "sh", ["-lc", `command -v '${command.replace(/'/g, `'"'"'`)}'`], { encoding: "utf-8" });
-  return result.status === 0;
+export function lspDependencyExtendPath(cwd = process.cwd()): string[] {
+  return [...ancestorDirs(cwd)].map((dir) => join(dir, "node_modules", ".bin"));
+}
+
+export function resolveLspBinary(command: string, cwd = process.cwd()): string | null {
+  return resolveDependency(command, { extendPath: lspDependencyExtendPath(cwd) });
 }
 
 function resolveLocalBinary(

package/tools/mcp/config.ts

@@ -15,11 +15,11 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { spawnSync } from "node:child_process";
-import { isModuleEnabled } from "../../settings.js";
+import { isModuleEnabled, resolveDependency } from "../../settings.js";
 import type { DependencyStatus } from "../../hooks/skeleton.js";
 import { BUILTIN_MCP_SERVERS } from "./builtin/index.js";
 
+
 export { BUILTIN_MCP_SERVERS } from "./builtin/index.js";
 
 export interface McpServerConfig {
@@ -33,6 +33,8 @@ export interface McpServerConfig {
   source: "builtin" | "global" | "project";
   /** Optional predicate: return false if this server cannot be used in the given project. */
   canUseInProject?: (cwd: string) => boolean;
+  /** Binary/config key before dependency path resolution. */
+  dependencyName?: string;
 }
 
 function globalMcpJsonPath(): string {
@@ -217,33 +219,50 @@ export function resolveMcpConfigs(cwd: string): McpServerConfig[] {
     }
   }
 
-  return [...byName.values()].filter((s) => s.url || s.command);
+  return [...byName.values()]
+    .filter((s) => s.url || s.command)
+    .map((s) => {
+      // Apply user-configured binary path override (dependencies[cmd].path)
+      // last, so it wins over builtin/global/project configs. Only applies
+      // to servers that use a command (not URL-based servers).
+      if (!s.command) return s;
+      const dependencyName = s.command;
+      const resolved = resolveMcpBinary(dependencyName);
+      return { ...s, dependencyName, command: resolved ?? s.command };
+    });
+}
+
+/** Unique binary names used by builtin MCP servers that have a `command`
+ *  (URL-based servers are excluded — they don't need a binary). */
+export function listMcpBinaryNames(): string[] {
+  const seen = new Set<string>();
+  for (const s of BUILTIN_MCP_SERVERS) {
+    if (s.command) seen.add(s.command);
+  }
+  return [...seen].sort();
 }
 
 export function collectMcpDependencyStatuses(cwd: string): DependencyStatus[] {
   const seen = new Set<string>();
   const statuses: DependencyStatus[] = [];
   for (const cfg of resolveMcpConfigs(cwd)) {
-    if (!cfg.enabled || !cfg.command || seen.has(cfg.command)) continue;
-    seen.add(cfg.command);
+    const depName = cfg.dependencyName ?? cfg.command;
+    if (!cfg.enabled || !cfg.command || !depName || seen.has(depName)) continue;
+    seen.add(depName);
+    const resolved = resolveMcpBinary(depName);
     statuses.push({
       module: `mcp:${cfg.name}`,
-      label: cfg.command,
-      state: commandExists(cfg.command) ? "ok" : "missing",
+      label: depName,
+      state: resolved ? "ok" : "missing",
       detail: `Install the MCP server command for \"${cfg.name}\" or update its config.`,
+      path: resolved ?? undefined,
     });
   }
   return statuses;
 }
 
-function commandExists(command: string): boolean {
-  if (path.isAbsolute(command) || command.includes("/") || command.includes("\\")) {
-    return fs.existsSync(command);
-  }
-  const result = process.platform === "win32"
-    ? spawnSync("where", [command], { encoding: "utf-8" })
-    : spawnSync(process.env.SHELL || "sh", ["-lc", `command -v '${command.replace(/'/g, `'"'"'`)}'`], { encoding: "utf-8" });
-  return result.status === 0;
+export function resolveMcpBinary(command: string): string | null {
+  return resolveDependency(command);
 }
 
 function readMcpJsonSafe(filePath: string): Record<string, any> | null {

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";
+}