pi-hashline-edit-pro 4.3.2 → 4.3.4

package/src/config-ui.ts

@@ -2,7 +2,7 @@ import { Key, matchesKey, visibleWidth } 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" | "anchorGrepEnabled" | "requirePath" | "strictInput" | "boundaryDedupMode" | "diffContextLines";
+export type ConfigToggleKey = "autoRead" | "autoReadAll" | "autoReadAllIgnore" | "anchorGrepEnabled" | "requirePath" | "strictInput" | "boundaryDedupMode" | "diffContextLines";
 
 export interface ConfigRow {
   key: ConfigToggleKey;
@@ -12,6 +12,7 @@ export interface ConfigRow {
   mode?: string;
   cycle?: string[];
   value?: number;
+  folders?: string[];
   disabled?: boolean;
 }
 
@@ -19,6 +20,7 @@ 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, folders: 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: "requirePath", label: "Require path", hint: "replace + insert need path (RPC visibility)", enabled: config.requirePath === true },
@@ -42,12 +44,22 @@ function numberBox(theme: Theme, value: number, disabled?: boolean): string {
   if (disabled) return theme.fg("dim", `[${value}]`);
   return theme.fg("accent", `[${value}]`);
 }
+function ignoreBox(theme: Theme, folders: string[]): string {
+  return theme.fg("accent", `[${folders.length}]`);
+}
+function formatIgnoreFolders(folders: string[]): string {
+  if (folders.length === 0) return "(empty)";
+  const joined = folders.join(", ");
+  return joined.length > 40 ? `${joined.slice(0, 37)}...` : joined;
+}
 
 export class HashlineConfigOverlay {
   private rows: ConfigRow[];
   private selected = 0;
+  private editingIgnore = false;
+  private editBuffer = "";
 
-  constructor(private readonly opts: { tui: { requestRender(force?: boolean): void }; theme: Theme; done: () => void; onToggle: (key: ConfigToggleKey, delta?: number) => Promise<void> }) {
+  constructor(private readonly opts: { tui: { requestRender(force?: boolean): void }; theme: Theme; done: () => void; onToggle: (key: ConfigToggleKey, delta?: number, value?: string) => Promise<void> }) {
     this.rows = [];
   }
 
@@ -55,19 +67,43 @@ export class HashlineConfigOverlay {
     this.rows = configRows(await readConfig());
   }
 
-  private runToggle(row: ConfigRow, delta?: number): void {
+  private runToggle(row: ConfigRow, delta?: number, value?: string): void {
     this.opts.tui.requestRender(true);
-    void this.opts.onToggle(row.key, delta).then(async () => {
+    void this.opts.onToggle(row.key, delta, value).then(async () => {
       this.rows = configRows(await readConfig());
+      this.editingIgnore = false;
       this.opts.tui.requestRender(true);
     }).catch((error: unknown) => {
       console.error("Failed to toggle hashline setting:", error);
     });
   }
+  private startIgnoreEdit(row: ConfigRow): void {
+    this.editingIgnore = true;
+    this.editBuffer = (row.folders ?? []).join(", ");
+    this.opts.tui.requestRender(true);
+  }
+  private commitIgnoreEdit(): void {
+    const row = this.rows[this.selected];
+    if (!row || row.key !== "autoReadAllIgnore") {
+      this.editingIgnore = false;
+      return;
+    }
+    const value = this.editBuffer;
+    this.editingIgnore = false;
+    this.runToggle(row, undefined, value);
+  }
+  private cancelIgnoreEdit(): void {
+    this.editingIgnore = false;
+    this.opts.tui.requestRender(true);
+  }
 
   private toggleSelected(): void {
     const row = this.rows[this.selected];
     if (!row || row.disabled) return;
+    if (row.key === "autoReadAllIgnore") {
+      this.startIgnoreEdit(row);
+      return;
+    }
     if (row.value !== undefined) {
       row.value += 1;
       this.runToggle(row, 1);
@@ -92,6 +128,32 @@ export class HashlineConfigOverlay {
   }
 
   handleInput(data: string): void {
+    if (this.editingIgnore) {
+      if (matchesKey(data, Key.escape) || data === "\x1b") {
+        this.cancelIgnoreEdit();
+        return;
+      }
+      if (matchesKey(data, Key.enter) || data === "\r" || data === "\n") {
+        this.commitIgnoreEdit();
+        return;
+      }
+      if (data === "\x7f" || data === "\b" || data === "\x08") {
+        this.editBuffer = this.editBuffer.slice(0, -1);
+        this.opts.tui.requestRender(true);
+        return;
+      }
+      if (data === "\x15") {
+        this.editBuffer = "";
+        this.opts.tui.requestRender(true);
+        return;
+      }
+      if (data.length >= 1 && [...data].every((ch) => ch.charCodeAt(0) >= 32 && ch !== "\x7f")) {
+        this.editBuffer += data;
+        this.opts.tui.requestRender(true);
+        return;
+      }
+      return;
+    }
     if (matchesKey(data, Key.up) || data === "k") {
       this.selected = (this.selected + this.rows.length - 1) % this.rows.length;
       return;
@@ -112,6 +174,11 @@ export class HashlineConfigOverlay {
       this.toggleSelected();
       return;
     }
+    const row = this.rows[this.selected];
+    if ((data === "e" || data === "E") && row && row.key === "autoReadAllIgnore" && !row.disabled) {
+      this.startIgnoreEdit(row);
+      return;
+    }
     if (matchesKey(data, Key.escape) || data === "q") {
       this.opts.done();
     }
@@ -129,12 +196,17 @@ export class HashlineConfigOverlay {
     lines.push(theme.fg("border", `├${"─".repeat(innerWidth)}┤`));
     this.rows.forEach((row, index) => {
       const cursor = index === this.selected ? theme.fg("accent", "> ") : "  ";
-      const box = 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 box = row.folders !== undefined ? ignoreBox(theme, row.folders) : 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;
-      lines.push(padRow(theme, innerWidth, `${cursor}${box} ${label} ${theme.fg("dim", `— ${row.hint}`)}`));
+      const suffix = row.folders !== undefined ? ` — ${row.hint}: ${formatIgnoreFolders(row.folders)}` : ` — ${row.hint}`;
+      lines.push(padRow(theme, innerWidth, `${cursor}${box} ${label} ${theme.fg("dim", suffix)}`));
+      if (row.key === "autoReadAllIgnore" && index === this.selected && this.editingIgnore) {
+        lines.push(padRow(theme, innerWidth, `  ${theme.fg("accent", "edit:")} ${this.editBuffer}█ ${theme.fg("dim", "(Enter save · Esc cancel · Ctrl-U clear)")}`));
+      }
     });
     lines.push(theme.fg("border", `├${"─".repeat(innerWidth)}┤`));
-    lines.push(padRow(theme, innerWidth, theme.fg("dim", " ↑↓ navigate · space toggle · ←/→ or -/+ adjust · q close")));
+    const footer = this.editingIgnore ? " 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;
   }

package/src/config.ts

@@ -15,6 +15,7 @@ export interface Config {
   autoRead: boolean;
   anchorGrepEnabled: boolean;
   autoReadAll?: AutoReadAllMode;
+  autoReadAllIgnore?: string[];
   requirePath?: boolean;
   strictInput?: boolean;
   boundaryDedupMode?: BoundaryDedupMode;
@@ -25,6 +26,7 @@ const DEFAULT_CONFIG: Config = {
   autoRead: true,
   anchorGrepEnabled: true,
   autoReadAll: "off",
+  autoReadAllIgnore: [],
   requirePath: false,
   strictInput: false,
   boundaryDedupMode: "on",
@@ -47,6 +49,26 @@ function parseAutoReadAllMode(value: unknown): AutoReadAllMode {
   return DEFAULT_CONFIG.autoReadAll ?? "off";
 }
 
+export function normalizeAutoReadAllIgnoreEntry(entry: string): string {
+  return entry.trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "").replace(/\/{2,}/g, "/");
+}
+
+export function parseAutoReadAllIgnore(value: unknown): string[] {
+  const raw = typeof value === "string" ? value.split(",") : Array.isArray(value) ? value : [];
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const item of raw) {
+    if (typeof item !== "string") continue;
+    const cleaned = normalizeAutoReadAllIgnoreEntry(item);
+    if (cleaned.length === 0) continue;
+    const lower = cleaned.toLowerCase();
+    if (seen.has(lower)) continue;
+    seen.add(lower);
+    out.push(cleaned);
+  }
+  return out;
+}
+
 export function normalizeDiffContextLines(value: unknown): number {
   if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_DIFF_CONTEXT_LINES;
   const floored = Math.floor(value);
@@ -68,6 +90,7 @@ function parseConfig(content: string): Config {
   const boundaryDedupMode = parsed.boundaryDedupMode;
   const legacyBoundaryDedup = parsed.boundaryDedupEnabled;
   const diffContextLines = parsed.diffContextLines;
+  const autoReadAllIgnore = parsed.autoReadAllIgnore;
   return {
     autoRead: typeof autoRead === "boolean" ? autoRead : DEFAULT_CONFIG.autoRead,
     anchorGrepEnabled: typeof anchorGrepEnabled === "boolean" ? anchorGrepEnabled : DEFAULT_CONFIG.anchorGrepEnabled,
@@ -76,6 +99,7 @@ function parseConfig(content: string): Config {
     strictInput: typeof strictInput === "boolean" ? strictInput : DEFAULT_CONFIG.strictInput,
     boundaryDedupMode: parseBoundaryDedupMode(boundaryDedupMode, legacyBoundaryDedup),
     diffContextLines: normalizeDiffContextLines(diffContextLines),
+    autoReadAllIgnore: parseAutoReadAllIgnore(autoReadAllIgnore),
   };
 }
 
@@ -222,3 +246,14 @@ export async function adjustDiffContextLines(delta: number): Promise<number> {
   });
   return next;
 }
+export async function setAutoReadAllIgnore(dirs: string[]): Promise<string[]> {
+  let next: string[] = [];
+  await updateConfig((c) => {
+    next = parseAutoReadAllIgnore(dirs);
+    c.autoReadAllIgnore = next;
+  });
+  return next;
+}
+export async function setAutoReadAllIgnoreFromText(text: string): Promise<string[]> {
+  return setAutoReadAllIgnore(text.split(","));
+}

package/src/edit-common.ts

@@ -13,13 +13,15 @@ export interface EditToolFlags {
   strictInput: boolean;
   boundaryDedupMode: BoundaryDedupMode;
   autoRead: boolean;
+  autoReadAllActive: boolean;
 }
 
 export const DEFAULT_EDIT_FLAGS: EditToolFlags = {
   requirePath: false,
   strictInput: false,
   boundaryDedupMode: "on",
-  autoRead: true
+  autoRead: true,
+  autoReadAllActive: false
 };
 
 export async function currentEditFlags(): Promise<EditToolFlags> {
@@ -28,7 +30,8 @@ export async function currentEditFlags(): Promise<EditToolFlags> {
     requirePath: config.requirePath === true,
     strictInput: config.strictInput === true,
     boundaryDedupMode: config.boundaryDedupMode ?? "on",
-    autoRead: config.autoRead !== false
+    autoRead: config.autoRead !== false,
+    autoReadAllActive: (config.autoReadAll ?? "off") !== "off"
   };
 }
 
@@ -38,7 +41,8 @@ export function withReplacePrompts(base: { description: string; snippet: string;
   let guidelines = [...base.guidelines];
   if (!flags.autoRead) {
     description = description.replace(" Anchor follow-up edits on the `+anchor│` and ` anchor│` rows of the post-edit diff instead of re-reading.", "");
-    guidelines = guidelines.map((guideline) => guideline.includes("post-edit diff") ? "`replace`: one batch per file per turn; verify each result before the next edit on that file." : guideline);
+    guidelines = guidelines.filter((guideline) => !guideline.includes("post-edit diff"));
+    description = description.replace("and the last call shows the combined diff,", "and the last call shows the combined result,");
   }
   const descriptionParts = [description];
   if (flags.requirePath) {
@@ -64,13 +68,21 @@ export function withReplacePrompts(base: { description: string; snippet: string;
 }
 
 export function withReadPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
-  if (flags.autoRead) return { description: base.description, snippet: base.snippet, guidelines: [...base.guidelines] };
-  const guidelines = base.guidelines.map((guideline) => guideline.startsWith("`read`: call again after an edit") ? "`read`: call again after an edit when you need anchors you lack." : guideline);
-  return { description: base.description, snippet: base.snippet, guidelines };
+  if (flags.autoReadAllActive) {
+    const rewritten = base.guidelines
+      .filter((guideline) => !guideline.includes("call again after an edit"))
+    return { description: base.description, snippet: base.snippet, guidelines: [...rewritten] };
+  }
+  const withoutAutoReadAll = base.guidelines.filter((guideline) => !guideline.includes("E_AUTO_READ_ALL"))
+  if (flags.autoRead) return { description: base.description, snippet: base.snippet, guidelines: [...withoutAutoReadAll] };
+  const guidelines = [...withoutAutoReadAll];
+  const mapped = guidelines.map((guideline) => guideline.startsWith("`read`: call again after an edit") ? "`read`: call again after an edit when you need anchors you lack." : guideline);
+  return { description: base.description, snippet: base.snippet, guidelines: mapped };
 }
 
 export function withInsertPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
-  const descriptionParts = [base.description];
+  const baseDescription = flags.autoRead ? base.description : base.description.replace("and the last call shows the combined diff,", "and the last call shows the combined result,");
+  const descriptionParts = [baseDescription];
   const snippetParts = [base.snippet];
   const guidelines = [...base.guidelines];
   if (flags.requirePath) {
@@ -87,6 +99,12 @@ export function withInsertPrompts(base: { description: string; snippet: string;
   }
   return { description: descriptionParts.join(" "), snippet: snippetParts.join(""), guidelines };
 }
+
+export function withUndoPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
+  if (flags.autoRead) return { description: base.description, snippet: base.snippet, guidelines: [...base.guidelines] };
+  const guidelines = base.guidelines.map((guideline) => guideline.includes("bad diff") ? "`undo_last_change`: only the last `replace`/`insert` per file is undoable; a `write` clears it, so undo right after a bad edit — review what you're restoring." : guideline);
+  return { description: base.description, snippet: base.snippet, guidelines };
+}
 export function resolveEditTarget(removeFrom: string, removeTo?: string): string {
   const refs = [removeFrom, removeTo].filter((value): value is string => typeof value === "string");
   const owners = refs.map((ref) => ownerOf(parseHashRef(stripAnchorRow(ref.trim(), "anchor entry")).hash));

package/src/file-reader.ts

@@ -1,10 +1,9 @@
 import { constants } from "node:fs";
 import { stat } from "node:fs/promises";
-import { relative } from "node:path";
 import { lineHashes } from "./hashline";
 import { loadFileKindAndText, type LFile } from "./file-kind";
 import { resolveTarget, type FileIdentity } from "./fs-write";
-import { toCwd } from "./paths";
+import { toCwd, toDisplayPath } from "./paths";
 import { detectEnding, toLF, stripBOM, type LineEnding } from "./normalize";
 import { abortIf, errCode, assertLineLimit } from "./utils";
 import { ANCHOR_POOL_EXHAUSTED_PREFIX } from "./constants";
@@ -119,7 +118,7 @@ export async function tryReadNormFile(
   options?: ReadNormOptions,
 ): Promise<NormFile | undefined> {
   try {
-    const displayPath = relative(cwd, absPath).replace(/\\/g, "/") || absPath;
+    const displayPath = toDisplayPath(cwd, absPath);
     const file = await loadFileKindAndText(absPath, { maxLines: options?.maxLines, displayPath });
     if (file.kind !== "text") return undefined;
     return await readNormFile(absPath, cwd, { ...options, preloadedFile: file });

package/src/glob.ts

@@ -0,0 +1,186 @@
+function bracketEnd(source: string, start: number): number {
+  let j = start + 1;
+  if (j < source.length && (source[j] === "!" || source[j] === "^")) j++;
+  if (j < source.length && source[j] === "]") j++;
+  let esc = false;
+  while (j < source.length) {
+    const c = source[j]!;
+    if (esc) {
+      esc = false;
+      j++;
+      continue;
+    }
+    if (c === "\\") {
+      esc = true;
+      j++;
+      continue;
+    }
+    if (c === "]") return j;
+    j++;
+  }
+  return -1;
+}
+function globPartToSource(glob: string): string {
+  let source = "";
+  let i = 0;
+  while (i < glob.length) {
+    const ch = glob[i]!;
+    if (ch === "\\" && i + 1 < glob.length) {
+      const next = glob[i + 1]!;
+      source += next.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      i += 2;
+      continue;
+    }
+    if (ch === "*") {
+      if (glob[i + 1] === "*") {
+        i += 2;
+        if (glob[i] === "/") {
+          i += 1;
+          source += "(?:.*\\/)?";
+        } else {
+          source += ".*";
+        }
+        continue;
+      }
+      source += ".*";
+      i += 1;
+      continue;
+    }
+    if (ch === "?") {
+      source += "[^/]";
+      i += 1;
+      continue;
+    }
+    if (ch === "{") {
+      let depth = 1;
+      let j = i + 1;
+      let esc = false;
+      while (j < glob.length && depth > 0) {
+        const c = glob[j]!;
+        if (esc) {
+          esc = false;
+          j++;
+          continue;
+        }
+        if (c === "\\") {
+          esc = true;
+          j++;
+          continue;
+        }
+        if (c === "[") {
+          const e = bracketEnd(glob, j);
+          if (e >= 0) {
+            j = e + 1;
+            continue;
+          }
+          j++;
+          continue;
+        }
+        if (c === "{") depth++;
+        else if (c === "}") depth--;
+        if (depth === 0) break;
+        j++;
+      }
+      if (depth !== 0) {
+        source += "\\{";
+        i++;
+        continue;
+      }
+      const inner = glob.slice(i + 1, j);
+      const parts: string[] = [];
+      let cur = "";
+      let d2 = 0;
+      let esc2 = false;
+      for (let k = 0; k < inner.length; k++) {
+        const c = inner[k]!;
+        if (esc2) {
+          cur += c;
+          esc2 = false;
+          continue;
+        }
+        if (c === "\\") {
+          esc2 = true;
+          cur += c;
+          continue;
+        }
+        if (c === "[") {
+          const e = bracketEnd(inner, k);
+          if (e >= 0) {
+            cur += inner.slice(k, e + 1);
+            k = e;
+            continue;
+          }
+          cur += c;
+          continue;
+        }
+        if (c === "{") {
+          d2++;
+          cur += c;
+          continue;
+        }
+        if (c === "}") {
+          d2--;
+          cur += c;
+          continue;
+        }
+        if (c === "," && d2 === 0) {
+          parts.push(cur);
+          cur = "";
+          continue;
+        }
+        cur += c;
+      }
+      parts.push(cur);
+      if (parts.length <= 1) {
+        source += "\\{" + globPartToSource(inner) + "\\}";
+      } else {
+        source += "(?:" + parts.map((p) => globPartToSource(p)).join("|") + ")";
+      }
+      i = j + 1;
+      continue;
+    }
+    if (ch === "[") {
+      let j = i + 1;
+      if (j < glob.length && (glob[j] === "!" || glob[j] === "^")) j++;
+      if (j < glob.length && glob[j] === "]") j++;
+      let esc3 = false;
+      while (j < glob.length) {
+        const c = glob[j]!;
+        if (esc3) {
+          esc3 = false;
+          j++;
+          continue;
+        }
+        if (c === "\\") {
+          esc3 = true;
+          j++;
+          continue;
+        }
+        if (c === "]") break;
+        j++;
+      }
+      if (j >= glob.length) {
+        source += "\\[";
+        i++;
+        continue;
+      }
+      let content = glob.slice(i + 1, j);
+      if (content.startsWith("!")) content = "^" + content.slice(1);
+      if (content.startsWith("]") || content.startsWith("^]")) {
+        if (content.startsWith("^]")) content = "^\\]" + content.slice(2);
+        else content = "\\]" + content.slice(1);
+      }
+      if (content.startsWith("^") && !content.includes("/")) content = "^/" + content.slice(1);
+      source += "[" + content + "]";
+      i = j + 1;
+      continue;
+    }
+    source += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    i++;
+  }
+  return source;
+}
+export function globToRegex(glob: string): RegExp {
+  if (glob.startsWith("/")) glob = glob.slice(1);
+  return new RegExp(`^${globPartToSource(glob)}$`);
+}

package/src/grep.ts

@@ -2,16 +2,17 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { formatSize, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, type TruncationResult } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { stat } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, win32 } from "node:path";
+import { dirname, isAbsolute, join, win32 } from "node:path";
 import { spawn, spawnSync } from "node:child_process";
 import { createInterface } from "node:readline";
 import { tryReadNormFile } from "./file-reader";
+import { globToRegex } from "./glob";
 import { MAX_HASH_LINES, fmtRow, HASH_LEN, HASH_SEP } from "./hashline";
 import { ANCHOR_POOL_EXHAUSTED_PREFIX, MAX_GREP_LINE_BYTES } from "./constants";
-import { toCwd } from "./paths";
+import { toCwd, toDisplayPath } from "./paths";
 import { loadP, loadGuide } from "./prompts";
 import { normReq } from "./payload-contract";
-import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines } from "./utils";
+import { abortIf, errCode, gutterWidth, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines } from "./utils";
 import { withAnchorSession } from "./anchor-registry";
 import { serveRows } from "./served";
 import { Text } from "@earendil-works/pi-tui";
@@ -152,34 +153,6 @@ function assertSafeRegex(pattern: string): void {
   }
 }
 
-function globToRegex(glob: string): RegExp {
-  if (glob.startsWith("/")) glob = glob.slice(1);
-  let source = "";
-  let i = 0;
-  while (i < glob.length) {
-    const ch = glob[i]!;
-    if (ch === "*") {
-      if (glob[i + 1] === "*") {
-        i += 2;
-        if (glob[i] === "/") {
-          i += 1;
-          source += "(?:.*\\/)?";
-        } else {
-          source += ".*";
-        }
-        continue;
-      }
-      source += ".*";
-    } else if (ch === "?") {
-      source += "[^/]";
-    } else {
-      source += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-    }
-    i += 1;
-  }
-  return new RegExp(`^${source}$`);
-}
-
 interface FileHit {
   path: string;
   displayPath: string;
@@ -401,14 +374,11 @@ async function collectRgMatches(
   });
 }
 
-function gutterWidthFor(numbers: number[]): number {
-  let max = 0;
-  for (const n of numbers) if (n > max) max = n;
-  return String(max || 1).length;
-}
 
 function displayRowsForHit(hit: FileHit): string[] {
-  const width = gutterWidthFor(hit.lineNumbers);
+  let max = 0;
+  for (const n of hit.lineNumbers) if (n > max) max = n;
+  const width = gutterWidth(max, 1);
   return hit.rows.map((row, i) => {
     const n = hit.lineNumbers[i]!;
     const padded = String(n).padStart(width, " ");
@@ -571,8 +541,8 @@ export function regGrep(pi: ExtensionAPI): void {
         const globRegex = req.glob === undefined ? undefined : globToRegex(req.glob);
         const matchesGlob = (absPath: string): boolean => {
           if (globRegex === undefined) return true;
-          const displayPath = relative(ctx.cwd, absPath).replace(/\\/g, "/");
-          const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
+          const displayPath = toDisplayPath(ctx.cwd, absPath);
+          const globPath = toDisplayPath(globRoot, absPath);
           return globRegex.test(globPath) || globRegex.test(displayPath);
         };
         const validatedRegex = buildRegex(req.pattern, req.literal === true, req.ignoreCase === true);
@@ -613,7 +583,7 @@ export function regGrep(pi: ExtensionAPI): void {
             if (!matchesGlob(absPath)) continue;
             const norm = await readGrepFileShadow(absPath);
             if (!norm) continue;
-            const hit = makeHitFromIndices(norm, relative(ctx.cwd, absPath).replace(/\\/g, "/"), indices, context, validatedRegex, totalForFile, indices.length);
+            const hit = makeHitFromIndices(norm, toDisplayPath(ctx.cwd, absPath), indices, context, validatedRegex, totalForFile, indices.length);
             const display = displayRowsForHit(hit);
             totalRows += display.length;
             for (const r of display) totalBytes += Buffer.byteLength(r, "utf-8") + 1;
@@ -635,7 +605,7 @@ export function regGrep(pi: ExtensionAPI): void {
           if (!matchesGlob(absPath)) continue;
           const norm = await readGrepFile(absPath);
           if (!norm) continue;
-          const hit = makeHitFromIndices(norm, relative(ctx.cwd, absPath).replace(/\\/g, "/"), indices, context, validatedRegex, totalForFile, Math.min(totalForFile, remaining));
+          const hit = makeHitFromIndices(norm, toDisplayPath(ctx.cwd, absPath), indices, context, validatedRegex, totalForFile, Math.min(totalForFile, remaining));
           const display = displayRowsForHit(hit);
           const keptRows: string[] = [];
           const keptHashes: string[] = [];