pi-hashline-edit-pro 6.1.1 → 6.2.0

package/src/config-ui.ts

@@ -1,14 +1,18 @@
-import { Key, matchesKey, visibleWidth } from "@earendil-works/pi-tui";
+import { Key, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { readConfig, type Config } from "./config";
 
-export type ConfigToggleKey = "autoRead" | "autoReadAll" | "autoReadAllIgnore" | "anchorGrepEnabled" | "copyMoveEnabled" | "replaceMatchEnabled" | "requirePath" | "strictInput" | "diffContextLines" | "disableOnModels" | "disableReadOnModels";
+export type ConfigToggleKey = "autoRead" | "autoReadAll" | "autoReadAllRequireGit" | "autoReadAllIgnore" | "anchorGrepEnabled" | "copyMoveEnabled" | "replaceMatchEnabled" | "requirePath" | "strictInput" | "diffContextLines" | "disableOnModels" | "readOnDisabledModels";
 
 export interface ConfigRow {
   key: ConfigToggleKey;
   label: string;
   hint: string;
+  group: string;
+  depth: number;
   enabled: boolean;
+  dependsOn?: ConfigToggleKey;
+  gated?: boolean;
   mode?: string;
   cycle?: string[];
   value?: number;
@@ -16,53 +20,79 @@ export interface ConfigRow {
   disabled?: boolean;
 }
 
+function rowActive(row: ConfigRow): boolean {
+  if (row.entries !== undefined) return row.entries.length > 0;
+  if (row.mode !== undefined) return row.mode !== "off";
+  return row.enabled;
+}
+
 export function configRows(config: Config): ConfigRow[] {
-  return [
-    { key: "autoRead", label: "Auto-read", hint: "Anchors after write + post-edit diffs", enabled: config.autoRead !== false },
-    { key: "autoReadAll", label: "Auto-read all", hint: "Attach files on the first turn: off, on, git (git repos only)", enabled: (config.autoReadAll ?? "off") !== "off", mode: config.autoReadAll ?? "off", cycle: ["off", "on", "git"] },
-    { key: "autoReadAllIgnore", label: "Ignore folders/files", hint: "Extra folders, files, or globs skipped by auto-read all (comma-separated)", enabled: (config.autoReadAllIgnore ?? []).length > 0, entries: config.autoReadAllIgnore ?? [] },
-    { key: "diffContextLines", label: "Diff context", hint: "Surrounding lines in post-edit diffs (needs Auto-read)", enabled: config.autoRead !== false, value: config.diffContextLines ?? 1, disabled: config.autoRead === false },
-    { key: "anchorGrepEnabled", label: "Anchor grep", hint: "anchor_grep tool (builtin grep off while on)", enabled: config.anchorGrepEnabled === true },
-    { key: "copyMoveEnabled", label: "Copy/move", hint: "copy and move tools (both off while disabled)", enabled: config.copyMoveEnabled !== false },
-    { key: "requirePath", label: "Require path", hint: "replace, insert, copy, move need path (RPC visibility)", enabled: config.requirePath === true },
-    { key: "strictInput", label: "Strict input", hint: "Reject auto-fixable slips instead of warnings", enabled: config.strictInput === true },
-    { key: "replaceMatchEnabled", label: "Replace match", hint: "replace_match tool (off while disabled)", enabled: config.replaceMatchEnabled !== false },
-    { key: "disableOnModels", label: "Disable on models", hint: "Model globs (provider/id, model id, or api) that turn off the anchored edit tools (comma-separated)", enabled: (config.disableOnModels ?? []).length > 0, entries: config.disableOnModels ?? [] },
-    { key: "disableReadOnModels", label: "Disable read on models", hint: "Also turn off read for models matched by Disable on models (off keeps read active)", enabled: config.disableReadOnModels !== false },
+  const rows: ConfigRow[] = [
+    { key: "autoRead", group: "Auto-read", depth: 0, label: "Auto-read", hint: "Show fresh anchors after write and post-edit diffs", enabled: config.autoRead !== false },
+    { key: "diffContextLines", group: "Auto-read", depth: 1, dependsOn: "autoRead", gated: true, label: "Diff context", hint: "Context lines around each change in post-edit diffs", enabled: config.autoRead !== false, value: config.diffContextLines ?? 1 },
+    { key: "autoReadAll", group: "Auto-read all", depth: 0, label: "Auto-read all", hint: "Attach project files when a session starts", enabled: (config.autoReadAll ?? "off") !== "off", mode: config.autoReadAll ?? "off", cycle: ["off", "outline", "full"] },
+    { key: "autoReadAllRequireGit", group: "Auto-read all", depth: 1, dependsOn: "autoReadAll", gated: true, label: "Git repos only", hint: "Attach only inside a git repository", enabled: config.autoReadAllRequireGit !== false },
+    { key: "autoReadAllIgnore", group: "Auto-read all", depth: 1, dependsOn: "autoReadAll", label: "Ignore folders/files", hint: "Folders, files, or globs that auto-read all skips (comma-separated)", enabled: (config.autoReadAllIgnore ?? []).length > 0, entries: config.autoReadAllIgnore ?? [] },
+    { key: "anchorGrepEnabled", group: "Tools", depth: 0, label: "Anchor grep", hint: "Use anchor_grep instead of the built-in grep", enabled: config.anchorGrepEnabled === true },
+    { key: "copyMoveEnabled", group: "Tools", depth: 0, label: "Copy/move", hint: "Enable the copy and move tools", enabled: config.copyMoveEnabled !== false },
+    { key: "replaceMatchEnabled", group: "Tools", depth: 0, label: "Replace match", hint: "Enable the replace_match tool", enabled: config.replaceMatchEnabled !== false },
+    { key: "requirePath", group: "Edit behavior", depth: 0, label: "Require path", hint: "Edit tools must also send a matching path", enabled: config.requirePath === true },
+    { key: "strictInput", group: "Edit behavior", depth: 0, label: "Strict input", hint: "Reject auto-fixable slips instead of warnings", enabled: config.strictInput === true },
+    { key: "disableOnModels", group: "Model gating", depth: 0, label: "Disable on models", hint: "Model globs that turn off anchored tools (comma-separated)", enabled: (config.disableOnModels ?? []).length > 0, entries: config.disableOnModels ?? [] },
+    { key: "readOnDisabledModels", group: "Model gating", depth: 1, dependsOn: "disableOnModels", gated: true, label: "Read on disabled models", hint: "Keep read available for models disabled above", enabled: (config.readOnDisabledModels ?? "vanilla") !== "remove", mode: config.readOnDisabledModels ?? "vanilla", cycle: ["remove", "vanilla"] },
   ];
+  for (const row of rows) {
+    if (row.gated !== true || row.dependsOn === undefined) continue;
+    const parent = rows.find((candidate) => candidate.key === row.dependsOn);
+    row.disabled = parent !== undefined && !rowActive(parent);
+  }
+  return rows;
 }
 
 function padRow(theme: Theme, innerWidth: number, content: string): string {
-  const padded = content + " ".repeat(Math.max(0, innerWidth - visibleWidth(content)));
+  const clipped = visibleWidth(content) > innerWidth ? truncateToWidth(content, innerWidth) : content;
+  const padded = clipped + " ".repeat(Math.max(0, innerWidth - visibleWidth(clipped)));
   return theme.fg("border", "│") + padded + theme.fg("border", "│");
 }
 
-function modeBox(theme: Theme, mode: string): string {
-  if (mode === "off") return theme.fg("dim", `[${mode}]`);
+function modeBox(theme: Theme, mode: string, disabled?: boolean): string {
+  if (disabled === true || mode === "off") return theme.fg("dim", `[${mode}]`);
   if (mode === "strict") return theme.fg("accent", `[${mode}]`);
   return theme.fg("success", `[${mode}]`);
 }
 
 function numberBox(theme: Theme, value: number, disabled?: boolean): string {
-  if (disabled) return theme.fg("dim", `[${value}]`);
+  if (disabled === true) return theme.fg("dim", `[${value}]`);
   return theme.fg("accent", `[${value}]`);
 }
-function listBox(theme: Theme, entries: string[]): string {
+
+function listBox(theme: Theme, entries: string[], disabled?: boolean): string {
+  if (disabled === true) return theme.fg("dim", `[${entries.length}]`);
   return theme.fg("accent", `[${entries.length}]`);
 }
-function formatList(entries: string[]): string {
-  if (entries.length === 0) return "(empty)";
-  const joined = entries.join(", ");
-  return joined.length > 40 ? `${joined.slice(0, 37)}...` : joined;
+
+function rowBox(theme: Theme, row: ConfigRow): string {
+  if (row.entries !== undefined) return listBox(theme, row.entries, row.disabled);
+  if (row.value !== undefined) return numberBox(theme, row.value, row.disabled);
+  if (row.mode !== undefined) return modeBox(theme, row.mode, row.disabled);
+  if (row.disabled === true) return theme.fg("dim", row.enabled ? "[x]" : "[ ]");
+  return row.enabled ? theme.fg("success", "[x]") : theme.fg("dim", "[ ]");
+}
+
+function rowDetail(row: ConfigRow): string {
+  if (row.entries === undefined) return row.hint;
+  const joined = row.entries.length > 0 ? row.entries.join(", ") : "(empty)";
+  return `${row.hint}: ${joined}`;
 }
 
 export class HashlineConfigOverlay {
   private rows: ConfigRow[];
   private selected = 0;
+  private scrollTop = 0;
   private editingList = false;
   private editBuffer = "";
 
-  constructor(private readonly opts: { tui: { requestRender(force?: boolean): void }; theme: Theme; done: () => void; onToggle: (key: ConfigToggleKey, delta?: number, value?: string) => Promise<void> }) {
+  constructor(private readonly opts: { tui: { requestRender(force?: boolean): void }; theme: Theme; done: () => void; maxHeight?: () => number | undefined; onToggle: (key: ConfigToggleKey, delta?: number, value?: string) => Promise<void> }) {
     this.rows = [];
   }
 
@@ -100,6 +130,16 @@ export class HashlineConfigOverlay {
     this.opts.tui.requestRender(true);
   }
 
+  private applyCycle(row: ConfigRow, step: number): void {
+    if (row.cycle === undefined || row.mode === undefined) return;
+    const index = row.cycle.indexOf(row.mode);
+    const next = row.cycle[(index + step + row.cycle.length) % row.cycle.length];
+    if (next === undefined) return;
+    row.mode = next;
+    row.enabled = next !== "off";
+    this.runToggle(row, step);
+  }
+
   private toggleSelected(): void {
     const row = this.rows[this.selected];
     if (!row || row.disabled) return;
@@ -112,22 +152,31 @@ export class HashlineConfigOverlay {
       this.runToggle(row, 1);
       return;
     }
-    if (row.cycle && row.mode !== undefined) {
-      const next = row.cycle[(row.cycle.indexOf(row.mode) + 1) % row.cycle.length] ?? row.cycle[0];
-      if (next === undefined) return;
-      row.mode = next;
-      row.enabled = next !== "off";
-    } else {
-      row.enabled = !row.enabled;
+    if (row.cycle !== undefined && row.mode !== undefined) {
+      this.applyCycle(row, 1);
+      return;
     }
+    row.enabled = !row.enabled;
     this.runToggle(row);
   }
 
   private adjustSelected(delta: number): void {
     const row = this.rows[this.selected];
-    if (!row || row.disabled || row.value === undefined) return;
-    row.value += delta;
-    this.runToggle(row, delta);
+    if (!row || row.disabled) return;
+    if (row.value !== undefined) {
+      row.value += delta;
+      this.runToggle(row, delta);
+      return;
+    }
+    if (row.cycle !== undefined && row.mode !== undefined) {
+      this.applyCycle(row, delta > 0 ? 1 : -1);
+      return;
+    }
+    if (row.entries !== undefined) return;
+    const wanted = delta > 0;
+    if (row.enabled === wanted) return;
+    row.enabled = wanted;
+    this.runToggle(row);
   }
 
   handleInput(data: string): void {
@@ -177,11 +226,6 @@ export class HashlineConfigOverlay {
       this.toggleSelected();
       return;
     }
-    const row = this.rows[this.selected];
-    if ((data === "e" || data === "E") && row && row.entries !== undefined && !row.disabled) {
-      this.startListEdit(row);
-      return;
-    }
     if (matchesKey(data, Key.escape) || data === "q") {
       this.opts.done();
     }
@@ -193,24 +237,60 @@ export class HashlineConfigOverlay {
   render(width: number): string[] {
     const theme = this.opts.theme;
     const innerWidth = width - 2;
-    const lines: string[] = [];
-    lines.push(theme.fg("border", `╭${"─".repeat(innerWidth)}╮`));
-    lines.push(padRow(theme, innerWidth, ` ${theme.fg("accent", theme.bold("Hashline Config"))}`));
-    lines.push(theme.fg("border", `├${"─".repeat(innerWidth)}┤`));
+    const body: string[] = [];
+    const spans: Array<{ start: number; end: number }> = [];
+    let group = "";
     this.rows.forEach((row, index) => {
-      const cursor = index === this.selected ? theme.fg("accent", "> ") : "  ";
-      const box = row.entries !== undefined ? listBox(theme, row.entries) : row.value !== undefined ? numberBox(theme, row.value, row.disabled) : row.mode !== undefined ? modeBox(theme, row.mode) : row.enabled ? theme.fg("success", "[x]") : theme.fg("dim", "[ ]");
-      const label = row.disabled ? theme.fg("dim", row.label) : index === this.selected ? theme.fg("accent", theme.bold(row.label)) : row.label;
-      const suffix = row.entries !== undefined ? ` — ${row.hint}: ${formatList(row.entries)}` : ` — ${row.hint}`;
-      lines.push(padRow(theme, innerWidth, `${cursor}${box} ${label} ${theme.fg("dim", suffix)}`));
-      if (row.entries !== undefined && index === this.selected && this.editingList) {
-        lines.push(padRow(theme, innerWidth, `  ${theme.fg("accent", "edit:")} ${this.editBuffer}█ ${theme.fg("dim", "(Enter save · Esc cancel · Ctrl-U clear)")}`));
+      if (row.group !== group) {
+        group = row.group;
+        body.push(padRow(theme, innerWidth, theme.fg("dim", theme.bold(` ${group}`))));
       }
+      const start = body.length;
+      const selected = index === this.selected;
+      const indent = "  ".repeat(row.depth);
+      const cursor = selected ? theme.fg("accent", "> ") : "  ";
+      const box = rowBox(theme, row);
+      const label = row.disabled === true ? theme.fg("dim", row.label) : selected ? theme.fg("accent", theme.bold(row.label)) : row.label;
+      const headWidth = 2 + indent.length + visibleWidth(box) + 1;
+      const contentWidth = Math.max(1, innerWidth - headWidth);
+      wrapTextWithAnsi(label, contentWidth).forEach((segment, part) => {
+        body.push(padRow(theme, innerWidth, (part === 0 ? `${cursor}${indent}${box} ` : " ".repeat(headWidth)) + segment));
+      });
+      for (const segment of wrapTextWithAnsi(theme.fg("dim", rowDetail(row)), contentWidth)) {
+        body.push(padRow(theme, innerWidth, " ".repeat(headWidth) + segment));
+      }
+      if (row.entries !== undefined && selected && this.editingList) {
+        const edit = `${theme.fg("accent", "edit:")} ${this.editBuffer}█ ${theme.fg("dim", "(Enter save · Esc cancel · Ctrl-U clear)")}`;
+        for (const segment of wrapTextWithAnsi(edit, Math.max(1, innerWidth - 2))) {
+          body.push(padRow(theme, innerWidth, `  ${segment}`));
+        }
+      }
+      spans.push({ start, end: body.length - 1 });
     });
-    lines.push(theme.fg("border", `├${"─".repeat(innerWidth)}┤`));
-    const footer = this.editingList ? " type to edit · Enter save · Esc cancel" : " ↑↓ navigate · space toggle · ←/→ or -/+ adjust · e edit list · q close";
-    lines.push(padRow(theme, innerWidth, theme.fg("dim", footer)));
-    lines.push(theme.fg("border", `╰${"─".repeat(innerWidth)}╯`));
-    return lines;
+    const head = [
+      theme.fg("border", `╭${"─".repeat(innerWidth)}╮`),
+      padRow(theme, innerWidth, ` ${theme.fg("accent", theme.bold("Hashline Config"))}`),
+      theme.fg("border", `├${"─".repeat(innerWidth)}┤`),
+    ];
+    const footer = this.editingList ? " type to edit · Enter save · Esc cancel" : " ↑↓ navigate · space toggle/edit · ←/→ or -/+ adjust · q close";
+    const tail = [
+      theme.fg("border", `├${"─".repeat(innerWidth)}┤`),
+      padRow(theme, innerWidth, theme.fg("dim", footer)),
+      theme.fg("border", `╰${"─".repeat(innerWidth)}╯`),
+    ];
+    const limit = this.opts.maxHeight?.();
+    if (limit === undefined || body.length + head.length + tail.length <= limit) {
+      this.scrollTop = 0;
+      return [...head, ...body, ...tail];
+    }
+    const viewport = Math.max(1, limit - head.length - tail.length);
+    const span = spans[this.selected] ?? { start: 0, end: 0 };
+    let top = this.scrollTop;
+    if (span.end - span.start + 1 > viewport) top = span.start;
+    else if (span.start < top) top = span.start;
+    else if (span.end >= top + viewport) top = span.end - viewport + 1;
+    top = Math.max(0, Math.min(top, Math.max(0, body.length - viewport)));
+    this.scrollTop = top;
+    return [...head, ...body.slice(top, top + viewport), ...tail];
   }
 }

package/src/config.ts

@@ -3,8 +3,11 @@ import { dirname } from "node:path";
 import { configPath } from "./paths";
 import { errCode, isRec } from "./utils";
 import { writeAtomic } from "./fs-write";
-export type AutoReadAllMode = "off" | "on" | "git";
-const AUTO_READ_ALL_MODES: AutoReadAllMode[] = ["off", "on", "git"];
+export type AutoReadAllMode = "off" | "outline" | "full";
+const AUTO_READ_ALL_MODES: AutoReadAllMode[] = ["off", "outline", "full"];
+
+export type ReadOnDisabledModels = "remove" | "vanilla";
+const READ_ON_DISABLED_MODELS: ReadOnDisabledModels[] = ["remove", "vanilla"];
 
 export const DEFAULT_DIFF_CONTEXT_LINES = 1;
 export const MIN_DIFF_CONTEXT_LINES = 0;
@@ -16,12 +19,13 @@ export interface Config {
   copyMoveEnabled?: boolean;
   replaceMatchEnabled?: boolean;
   autoReadAll?: AutoReadAllMode;
+  autoReadAllRequireGit?: boolean;
   autoReadAllIgnore?: string[];
   requirePath?: boolean;
   strictInput?: boolean;
   diffContextLines?: number;
   disableOnModels?: string[];
-  disableReadOnModels?: boolean;
+  readOnDisabledModels?: ReadOnDisabledModels;
 }
 
 const DEFAULT_CONFIG: Config = {
@@ -30,21 +34,37 @@ const DEFAULT_CONFIG: Config = {
   copyMoveEnabled: true,
   replaceMatchEnabled: true,
   autoReadAll: "off",
+  autoReadAllRequireGit: true,
   autoReadAllIgnore: [],
   requirePath: false,
   strictInput: false,
   diffContextLines: DEFAULT_DIFF_CONTEXT_LINES,
   disableOnModels: [],
-  disableReadOnModels: true,
+  readOnDisabledModels: "vanilla",
 };
 
 function parseAutoReadAllMode(value: unknown): AutoReadAllMode {
-  if (value === "off" || value === "on" || value === "git") return value;
-  if (value === true) return "on";
+  if (value === "off" || value === "outline" || value === "full") return value;
+  if (value === "outline(git)") return "outline";
+  if (value === "git") return "full";
+  if (value === "on" || value === true) return "full";
   if (value === false) return "off";
   return DEFAULT_CONFIG.autoReadAll ?? "off";
 }
 
+function parseAutoReadAllRequireGit(value: unknown, legacyMode: unknown): boolean {
+  if (typeof value === "boolean") return value;
+  if (legacyMode === "git" || legacyMode === "outline(git)") return true;
+  if (legacyMode === "full" || legacyMode === "outline" || legacyMode === "on" || legacyMode === true) return false;
+  return DEFAULT_CONFIG.autoReadAllRequireGit ?? true;
+}
+
+function parseReadOnDisabledModels(value: unknown, legacy: unknown): ReadOnDisabledModels {
+  if (value === "remove" || value === "vanilla") return value;
+  if (typeof legacy === "boolean") return legacy ? "remove" : "vanilla";
+  return DEFAULT_CONFIG.readOnDisabledModels ?? "vanilla";
+}
+
 export function normalizeAutoReadAllIgnoreEntry(entry: string): string {
   return entry.trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "").replace(/\/{2,}/g, "/");
 }
@@ -91,24 +111,27 @@ function parseConfig(content: string): Config {
   const copyMoveEnabled = parsed.copyMoveEnabled;
   const replaceMatchEnabled = parsed.replaceMatchEnabled;
   const autoReadAll = parsed.autoReadAll;
+  const autoReadAllRequireGit = parsed.autoReadAllRequireGit;
   const requirePath = parsed.requirePath;
   const strictInput = parsed.strictInput;
   const diffContextLines = parsed.diffContextLines;
   const autoReadAllIgnore = parsed.autoReadAllIgnore;
   const disableOnModels = parsed.disableOnModels;
-  const disableReadOnModels = parsed.disableReadOnModels;
+  const readOnDisabledModels = parsed.readOnDisabledModels;
+  const legacyDisableReadOnModels = parsed.disableReadOnModels;
   return {
     autoRead: typeof autoRead === "boolean" ? autoRead : DEFAULT_CONFIG.autoRead,
     anchorGrepEnabled: typeof anchorGrepEnabled === "boolean" ? anchorGrepEnabled : DEFAULT_CONFIG.anchorGrepEnabled,
     copyMoveEnabled: typeof copyMoveEnabled === "boolean" ? copyMoveEnabled : DEFAULT_CONFIG.copyMoveEnabled,
     replaceMatchEnabled: typeof replaceMatchEnabled === "boolean" ? replaceMatchEnabled : DEFAULT_CONFIG.replaceMatchEnabled,
     autoReadAll: parseAutoReadAllMode(autoReadAll),
+    autoReadAllRequireGit: parseAutoReadAllRequireGit(autoReadAllRequireGit, autoReadAll),
     requirePath: typeof requirePath === "boolean" ? requirePath : DEFAULT_CONFIG.requirePath,
     strictInput: typeof strictInput === "boolean" ? strictInput : DEFAULT_CONFIG.strictInput,
     diffContextLines: normalizeDiffContextLines(diffContextLines),
     autoReadAllIgnore: parseAutoReadAllIgnore(autoReadAllIgnore),
     disableOnModels: parseDisableOnModels(disableOnModels),
-    disableReadOnModels: typeof disableReadOnModels === "boolean" ? disableReadOnModels : DEFAULT_CONFIG.disableReadOnModels,
+    readOnDisabledModels: parseReadOnDisabledModels(readOnDisabledModels, legacyDisableReadOnModels),
   };
 }
 
@@ -216,22 +239,35 @@ export async function writeConfig(config: Config): Promise<void> {
 }
 
 
-type ToggleKey = "autoRead" | "anchorGrepEnabled" | "copyMoveEnabled" | "replaceMatchEnabled" | "requirePath" | "strictInput" | "disableReadOnModels";
+type ToggleKey = "autoRead" | "autoReadAllRequireGit" | "anchorGrepEnabled" | "copyMoveEnabled" | "replaceMatchEnabled" | "requirePath" | "strictInput";
 
 async function toggleFlag(key: ToggleKey): Promise<boolean> {
   const config = await updateConfig((c) => { c[key] = !(c[key] === true); });
   return config[key] === true;
 }
 export const toggleAutoRead = (): Promise<boolean> => toggleFlag("autoRead");
+export const toggleAutoReadAllRequireGit = (): Promise<boolean> => toggleFlag("autoReadAllRequireGit");
 export const toggleAnchorGrep = (): Promise<boolean> => toggleFlag("anchorGrepEnabled");
 export const toggleCopyMove = (): Promise<boolean> => toggleFlag("copyMoveEnabled");
 export const toggleReplaceMatch = (): Promise<boolean> => toggleFlag("replaceMatchEnabled");
-export const toggleDisableReadOnModels = (): Promise<boolean> => toggleFlag("disableReadOnModels");
-export async function cycleAutoReadAllMode(): Promise<AutoReadAllMode> {
+function steppedIndex(length: number, index: number, delta: number): number {
+  return ((index + delta) % length + length) % length;
+}
+
+export async function cycleReadOnDisabledModels(delta = 1): Promise<ReadOnDisabledModels> {
+  let next: ReadOnDisabledModels = "vanilla";
+  await updateConfig((c) => {
+    const current = c.readOnDisabledModels ?? "vanilla";
+    next = READ_ON_DISABLED_MODELS[steppedIndex(READ_ON_DISABLED_MODELS.length, READ_ON_DISABLED_MODELS.indexOf(current), delta)] ?? "remove";
+    c.readOnDisabledModels = next;
+  });
+  return next;
+}
+export async function cycleAutoReadAllMode(delta = 1): Promise<AutoReadAllMode> {
   let next: AutoReadAllMode = "off";
   await updateConfig((c) => {
     const current = c.autoReadAll ?? "off";
-    next = AUTO_READ_ALL_MODES[(AUTO_READ_ALL_MODES.indexOf(current) + 1) % AUTO_READ_ALL_MODES.length] ?? "off";
+    next = AUTO_READ_ALL_MODES[steppedIndex(AUTO_READ_ALL_MODES.length, AUTO_READ_ALL_MODES.indexOf(current), delta)] ?? "off";
     c.autoReadAll = next;
   });
   return next;

package/src/copy-move.ts

@@ -900,11 +900,11 @@ type TransferToolDef = ToolDefinition<any, ReplaceDetails, RRState> & { renderSh
 export function buildTransferToolDef(kind: TransferKind, flags: EditToolFlags = DEFAULT_EDIT_FLAGS): TransferToolDef {
   const prompted = withTransferPrompts(
     {
-      description: loadP(`../prompts/${kind}.md`),
-      snippet: loadP(`../prompts/${kind}-snippet.md`),
+      description: loadP(`../tool-prompts/${kind}.md`),
+      snippet: loadP(`../tool-prompts/${kind}-snippet.md`),
       guidelines: [
-        ...loadGuide(`../prompts/${kind}-guidelines.md`),
-        ...loadGuide("../prompts/transfer-guidelines.md"),
+        ...loadGuide(`../tool-prompts/${kind}-guidelines.md`),
+        ...loadGuide("../tool-prompts/transfer-guidelines.md"),
       ],
     },
     flags,

package/src/grep.ts

@@ -535,9 +535,9 @@ export function renderGrepResult(result: { content?: Array<{ type: string; text?
 }
 export function regGrep(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FLAGS): void {
   const prompted = withGrepPrompts({
-    description: loadP("../prompts/grep.md"),
-    snippet: loadP("../prompts/grep-snippet.md"),
-    guidelines: loadGuide("../prompts/grep-guidelines.md"),
+    description: loadP("../tool-prompts/grep.md"),
+    snippet: loadP("../tool-prompts/grep-snippet.md"),
+    guidelines: loadGuide("../tool-prompts/grep-guidelines.md"),
   }, flags);
   pi.registerTool({
     name: "anchor_grep",

package/src/insert.ts

@@ -159,9 +159,9 @@ type InsertToolDef = ToolDefinition<any, ReplaceDetails, RRState> & { renderShel
 
 export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): InsertToolDef {
   const prompted = withInsertPrompts({
-    description: loadP("../prompts/insert.md"),
-    snippet: loadP("../prompts/insert-snippet.md"),
-    guidelines: loadGuide("../prompts/insert-guidelines.md"),
+    description: loadP("../tool-prompts/insert.md"),
+    snippet: loadP("../tool-prompts/insert-snippet.md"),
+    guidelines: loadGuide("../tool-prompts/insert-guidelines.md"),
   }, flags);
   return {
     name: "insert",

package/src/outline/index.ts

@@ -0,0 +1,45 @@
+import { visLines } from "../utils";
+import { loadOutlineParser } from "./parsers";
+import { renderPreviewOutline, renderSymbolOutline, type OutlineRender } from "./render";
+
+export interface FileOutlineInput {
+	displayPath: string;
+	content: string;
+	hashes: string[];
+	maxRows?: number;
+	maxDepth?: number;
+	maxBytes?: number;
+	previewHeadLines?: number;
+	previewTailLines?: number;
+}
+
+export async function buildFileOutline(input: FileOutlineInput): Promise<OutlineRender> {
+	const lines = visLines(input.content);
+	const parser = await loadOutlineParser();
+	const parsed = parser === undefined ? undefined : await parser.parse(input.displayPath, input.content);
+	if (parsed !== undefined && parsed.symbols.length > 0) {
+		return renderSymbolOutline({
+			displayPath: input.displayPath,
+			languageName: parsed.languageName,
+			totalLines: lines.length,
+			hashes: input.hashes,
+			symbols: parsed.symbols,
+			...(input.maxRows !== undefined ? { maxRows: input.maxRows } : {}),
+			...(input.maxDepth !== undefined ? { maxDepth: input.maxDepth } : {}),
+			...(input.maxBytes !== undefined ? { maxBytes: input.maxBytes } : {}),
+		});
+	}
+	return renderPreviewOutline({
+		displayPath: input.displayPath,
+		lines,
+		hashes: input.hashes,
+		...(input.previewHeadLines !== undefined ? { headLines: input.previewHeadLines } : {}),
+		...(input.previewTailLines !== undefined ? { tailLines: input.previewTailLines } : {}),
+		...(input.maxBytes !== undefined ? { maxBytes: input.maxBytes } : {}),
+	});
+}
+
+export { loadOutlineParser } from "./parsers";
+export { renderPreviewOutline, renderSymbolOutline } from "./render";
+export type { OutlineParse, OutlineParser, OutlineSymbol } from "./parsers";
+export type { OutlineRender, OutlineRow } from "./render";

package/src/outline/parsers.ts

@@ -0,0 +1,42 @@
+export interface OutlineSymbol {
+	name: string;
+	type: string;
+	startLine: number;
+	endLine: number;
+	children?: OutlineSymbol[];
+	detail?: string;
+}
+
+export interface OutlineParse {
+	symbols: OutlineSymbol[];
+	languageName: string;
+}
+
+export interface OutlineParser {
+	languageFor(path: string): string | null;
+	parse(path: string, content: string): Promise<OutlineParse | undefined>;
+}
+
+async function load(): Promise<OutlineParser | undefined> {
+	try {
+		const parsers = await import("./vendor/parsers/index.js");
+		return {
+			languageFor: (path) => parsers.detectLanguage(path),
+			parse: async (path, content) => {
+				if (parsers.detectLanguage(path) === null) return undefined;
+				const parsed = await parsers.parseSourceFile(path, content);
+				return { symbols: parsed.symbols, languageName: parsed.languageName };
+			},
+		};
+	} catch (error) {
+		console.error("Failed to load the vendored outline parsers:", error);
+		return undefined;
+	}
+}
+
+let parserPromise: Promise<OutlineParser | undefined> | undefined;
+
+export function loadOutlineParser(): Promise<OutlineParser | undefined> {
+	parserPromise ??= load();
+	return parserPromise;
+}