pi-vim 0.9.0 → 0.11.0

package/motions.ts

@@ -49,7 +49,10 @@ export function isBlankLine(line: string | undefined): boolean {
 /**
  * Paragraph start: non-blank line at BOF or after a blank line.
  */
-export function isParagraphStart(lines: readonly string[], lineIndex: number): boolean {
+export function isParagraphStart(
+  lines: readonly string[],
+  lineIndex: number,
+): boolean {
   if (!Number.isInteger(lineIndex)) return false;
   if (lineIndex < 0 || lineIndex >= lines.length) return false;
   if (isBlankLine(lines[lineIndex])) return false;
@@ -60,7 +63,10 @@ export function isParagraphStart(lines: readonly string[], lineIndex: number): b
 /**
  * One step of } motion from current line index.
  */
-export function findNextParagraphStart(lines: readonly string[], fromLine: number): number {
+export function findNextParagraphStart(
+  lines: readonly string[],
+  fromLine: number,
+): number {
   if (lines.length === 0) return 0;
 
   const start = clampLineIndex(lines, fromLine) + 1;
@@ -74,7 +80,10 @@ export function findNextParagraphStart(lines: readonly string[], fromLine: numbe
 /**
  * One step of { motion from current line index.
  */
-export function findPrevParagraphStart(lines: readonly string[], fromLine: number): number {
+export function findPrevParagraphStart(
+  lines: readonly string[],
+  fromLine: number,
+): number {
   if (lines.length === 0) return 0;
 
   const start = clampLineIndex(lines, fromLine) - 1;
@@ -125,16 +134,21 @@ export function reverseCharMotion(motion: CharMotion): CharMotion {
   return reverseMap[motion];
 }
 
-const GRAPHEME_SEGMENTER = typeof Intl !== "undefined"
-  && typeof Intl.Segmenter === "function"
-  ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
-  : null;
+const GRAPHEME_SEGMENTER =
+  typeof Intl !== "undefined" && typeof Intl.Segmenter === "function"
+    ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
+    : null;
 
-export function getLineGraphemes(line: string): Array<{ start: number; end: number }> {
+export function getLineGraphemes(
+  line: string,
+): Array<{ start: number; end: number }> {
   const segments: Array<{ start: number; end: number }> = [];
   if (GRAPHEME_SEGMENTER) {
     for (const part of GRAPHEME_SEGMENTER.segment(line)) {
-      segments.push({ start: part.index, end: part.index + part.segment.length });
+      segments.push({
+        start: part.index,
+        end: part.index + part.segment.length,
+      });
     }
     return segments;
   }
@@ -163,7 +177,7 @@ export function findCharMotionTarget(
   const steps = Number.isFinite(count) && count > 0 ? Math.floor(count) : 1;
 
   const graphemes = getLineGraphemes(line);
-  let currentIndex = graphemes.findIndex(g => col < g.end);
+  let currentIndex = graphemes.findIndex((g) => col < g.end);
   if (currentIndex === -1) currentIndex = graphemes.length;
 
   for (let i = 0; i < steps; i++) {
@@ -179,7 +193,10 @@ export function findCharMotionTarget(
         if (!g) continue;
         // Use startsWith to allow matching base chars if targetChar lacks combining marks,
         // or just exact match since targetChar is typically a full grapheme.
-        if (line.slice(g.start, g.end) === targetChar || line.slice(g.start, g.end).startsWith(targetChar)) {
+        if (
+          line.slice(g.start, g.end) === targetChar ||
+          line.slice(g.start, g.end).startsWith(targetChar)
+        ) {
           found = j;
           break;
         }
@@ -199,7 +216,10 @@ export function findCharMotionTarget(
       for (let j = nextIndex; j >= 0; j--) {
         const g = graphemes[j];
         if (!g) continue;
-        if (line.slice(g.start, g.end) === targetChar || line.slice(g.start, g.end).startsWith(targetChar)) {
+        if (
+          line.slice(g.start, g.end) === targetChar ||
+          line.slice(g.start, g.end).startsWith(targetChar)
+        ) {
           found = j;
           break;
         }
@@ -243,11 +263,13 @@ export function findWordMotionTarget(
 
       // Skip current word/punct block
       if (startType !== CharType.Space) {
-        while (i < len && getCharType(line[i], semanticClass) === startType) i++;
+        while (i < len && getCharType(line[i], semanticClass) === startType)
+          i++;
       }
 
       // Skip whitespace
-      while (i < len && getCharType(line[i], semanticClass) === CharType.Space) i++;
+      while (i < len && getCharType(line[i], semanticClass) === CharType.Space)
+        i++;
 
       return i;
     }
@@ -256,7 +278,8 @@ export function findWordMotionTarget(
     if (i < len - 1) i++;
 
     // Skip whitespace forward
-    while (i < len && getCharType(line[i], semanticClass) === CharType.Space) i++;
+    while (i < len && getCharType(line[i], semanticClass) === CharType.Space)
+      i++;
 
     // Now at start of next word (or end of line). Find end.
     if (i >= len) return len;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-vim",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Vim-style modal editing for Pi's TUI editor",
   "type": "module",
   "keywords": [
@@ -22,8 +22,8 @@
   ],
   "scripts": {
     "build": "echo 'nothing to build'",
-    "format": "biome format --write .",
-    "lint": "biome lint . && eslint .",
+    "format": "biome check --write .",
+    "lint": "biome check . && eslint .",
     "typecheck": "tsc --noEmit",
     "test": "node --import tsx/esm --test 'test/**/*.test.ts'",
     "check": "npm run lint && npm run typecheck && npm run test",

package/settings.ts

@@ -0,0 +1,92 @@
+import { SettingsManager } from "@mariozechner/pi-coding-agent";
+
+export type ModeColorSettings = {
+  insert?: string;
+  normal?: string;
+  ex?: string;
+};
+
+export type PiVimSettings = {
+  clipboardMirror?: unknown;
+  modeColors?: ModeColorSettings;
+  syncBorderColorWithMode?: boolean;
+};
+
+const M = Symbol(),
+  C = ["insert", "normal", "ex"] as const,
+  T = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+const rec = (v: unknown): v is Record<string, unknown> =>
+  typeof v === "object" && v !== null && !Array.isArray(v);
+
+function get(s: unknown, k: keyof PiVimSettings): unknown {
+  if (!rec(s) || !Object.hasOwn(s, "piVim")) return M;
+  const p = s.piVim;
+  if (!rec(p)) return p;
+  return Object.hasOwn(p, k) ? p[k] : M;
+}
+
+function colors(v: unknown) {
+  if (!rec(v)) return;
+  const r: ModeColorSettings = {};
+  for (const k of C) {
+    const x = v[k],
+      t = typeof x === "string" ? x.trim() : "";
+    if (T.test(t)) r[k] = t;
+  }
+  return Object.keys(r)[0] ? r : undefined;
+}
+
+export function readPiVimClipboardMirrorSetting(g: unknown, p: unknown) {
+  let v = get(p, "clipboardMirror");
+  if (v !== M) return v;
+  v = get(g, "clipboardMirror");
+  return v === M ? undefined : v;
+}
+
+export function readPiVimModeColors(g: unknown, p: unknown) {
+  const v = get(p, "modeColors");
+  // Project settings are a whole-setting override. If a project checks in an
+  // invalid modeColors value, fall back to pi-vim defaults instead of leaking a
+  // developer's global colors into that project.
+  if (v !== M) return colors(v);
+  const w = get(g, "modeColors");
+  return colors(w);
+}
+
+export function readPiVimBooleanSetting(
+  g: unknown,
+  p: unknown,
+  k: "syncBorderColorWithMode",
+) {
+  const v = get(p, k);
+  if (v !== M) return typeof v === "boolean" ? v : undefined;
+  const w = get(g, k);
+  return typeof w === "boolean" ? w : undefined;
+}
+
+function disk(cwd: string): PiVimSettings {
+  const s = SettingsManager.create(cwd),
+    g = s.getGlobalSettings(),
+    p = s.getProjectSettings();
+  return {
+    clipboardMirror: readPiVimClipboardMirrorSetting(g, p),
+    modeColors: readPiVimModeColors(g, p),
+    syncBorderColorWithMode: readPiVimBooleanSetting(
+      g,
+      p,
+      "syncBorderColorWithMode",
+    ),
+  };
+}
+
+let reader = disk;
+export function readPiVimSettings(cwd: string) {
+  return reader(cwd);
+}
+export function setPiVimSettingsReaderForTests(next: typeof disk) {
+  const prev = reader;
+  reader = next;
+  return () => {
+    reader = prev;
+  };
+}

package/text-objects.ts

@@ -13,6 +13,15 @@ export type DelimiterSpec = {
   close: string;
 };
 
+export type MatchingPairKind = "()" | "[]" | "{}";
+
+export type MatchingPairMotionTarget = {
+  pair: MatchingPairKind;
+  sourceAbs: number;
+  targetAbs: number;
+  rangeAnchorAbs: number;
+};
+
 function normalizeCount(count: number): number {
   if (!Number.isFinite(count) || count < 1) return 1;
   return Math.floor(count);
@@ -34,30 +43,24 @@ function clampCursorAbs(text: string, cursorAbs: number): number {
   return Math.max(0, Math.min(normalized, text.length - 1));
 }
 
-function findLogicalLineBounds(line: string, cursorCol: number): { start: number; end: number } {
+function findLogicalLineBounds(
+  line: string,
+  cursorCol: number,
+): { start: number; end: number } {
   if (line.length === 0) return { start: 0, end: 0 };
 
-  const previousSearchStart = line[cursorCol] === "\n" ? cursorCol - 1 : cursorCol;
+  const previousSearchStart =
+    line[cursorCol] === "\n" ? cursorCol - 1 : cursorCol;
   const start = line.lastIndexOf("\n", previousSearchStart) + 1;
   const nextNewline = line.indexOf("\n", cursorCol);
 
-  return {
-    start,
-    end: nextNewline === -1 ? line.length : nextNewline,
-  };
+  return { start, end: nextNewline === -1 ? line.length : nextNewline };
 }
 
-function findCurrentLineBounds(text: string, cursorAbs: number): { startAbs: number; endAbs: number } {
-  const cursor = clampCursorAbs(text, cursorAbs);
-  const bounds = findLogicalLineBounds(text, cursor);
-
-  return {
-    startAbs: bounds.start,
-    endAbs: bounds.end,
-  };
-}
-
-function isWordTextObjectChar(ch: string | undefined, semanticClass: WordTextObjectClass): boolean {
+function isWordTextObjectChar(
+  ch: string | undefined,
+  semanticClass: WordTextObjectClass,
+): boolean {
   if (ch === undefined) return false;
   if (semanticClass === "WORD") return !/\s/.test(ch);
   return /\w/.test(ch);
@@ -67,44 +70,52 @@ function isWhitespace(ch: string | undefined): boolean {
   return ch !== undefined && /\s/.test(ch);
 }
 
-export function normalizeDelimiterKey(key: string): DelimiterSpec | null {
-  if (key === "\"" || key === "'" || key === "`") {
-    return {
-      type: "quote",
-      open: key,
-      close: key,
-    };
-  }
-
-  if (key === "(" || key === ")" || key === "b") {
-    return {
-      type: "bracket",
-      open: "(",
-      close: ")",
-    };
-  }
-
-  if (key === "[" || key === "]") {
-    return {
-      type: "bracket",
-      open: "[",
-      close: "]",
-    };
-  }
+function pairKind(ch?: string): MatchingPairKind | null {
+  return ch === "(" || ch === ")"
+    ? "()"
+    : ch === "[" || ch === "]"
+      ? "[]"
+      : ch === "{" || ch === "}"
+        ? "{}"
+        : null;
+}
 
-  if (key === "{" || key === "}" || key === "B") {
-    return {
-      type: "bracket",
-      open: "{",
-      close: "}",
-    };
+function scanSameDelimiterPairs(
+  text: string,
+  open: string,
+  close: string,
+  onPair: (openAbs: number, closeAbs: number) => number | null,
+): number | null {
+  const stack: number[] = [];
+  for (let index = 0; index < text.length; index++) {
+    if (text[index] === open) stack.push(index);
+    else if (text[index] === close) {
+      const openAbs = stack.pop();
+      if (openAbs === undefined) continue;
+      const targetAbs = onPair(openAbs, index);
+      if (targetAbs !== null) return targetAbs;
+    }
   }
-
   return null;
 }
 
+export function normalizeDelimiterKey(key: string): DelimiterSpec | null {
+  if (key === '"' || key === "'" || key === "`")
+    return { type: "quote", open: key, close: key };
+  const pair =
+    key === "(" || key === ")" || key === "b"
+      ? "()"
+      : key === "[" || key === "]"
+        ? "[]"
+        : key === "{" || key === "}" || key === "B"
+          ? "{}"
+          : null;
+  return pair ? { type: "bracket", open: pair[0], close: pair[1] } : null;
+}
+
 export function isEscapedDelimiter(text: string, index: number): boolean {
-  if (!Number.isInteger(index) || index <= 0 || index >= text.length) return false;
+  if (!Number.isInteger(index) || index <= 0 || index >= text.length)
+    return false;
 
   let backslashCount = 0;
   for (let i = index - 1; i >= 0 && text[i] === "\\"; i--) {
@@ -124,13 +135,13 @@ export function resolveQuoteObjectRange(
   if (spec?.type !== "quote") return null;
 
   const cursor = clampCursorAbs(text, cursorAbs);
-  const bounds = findCurrentLineBounds(text, cursor);
-  if (bounds.startAbs >= bounds.endAbs) return null;
+  const bounds = findLogicalLineBounds(text, cursor);
+  if (bounds.start >= bounds.end) return null;
 
   let openIndex: number | null = null;
   let bestPair: { open: number; close: number } | null = null;
 
-  for (let index = bounds.startAbs; index < bounds.endAbs; index++) {
+  for (let index = bounds.start; index < bounds.end; index++) {
     if (text[index] !== quote || isEscapedDelimiter(text, index)) continue;
 
     if (openIndex === null) {
@@ -138,10 +149,12 @@ export function resolveQuoteObjectRange(
       continue;
     }
 
-    const closeIndex = index;
-    if (openIndex <= cursor && cursor <= closeIndex) {
-      if (bestPair === null || closeIndex - openIndex < bestPair.close - bestPair.open) {
-        bestPair = { open: openIndex, close: closeIndex };
+    if (openIndex <= cursor && cursor <= index) {
+      if (
+        bestPair === null ||
+        index - openIndex < bestPair.close - bestPair.open
+      ) {
+        bestPair = { open: openIndex, close: index };
       }
     }
     openIndex = null;
@@ -172,28 +185,19 @@ export function resolveBracketObjectRange(
   if (open.length !== 1 || close.length !== 1 || open === close) return null;
 
   const cursor = clampCursorAbs(text, cursorAbs);
-  const openStack: number[] = [];
-  let bestPair: { open: number; close: number } | null = null;
-
-  for (let index = 0; index < text.length; index++) {
-    const ch = text[index];
-
-    if (ch === open) {
-      openStack.push(index);
-      continue;
-    }
+  let bestPair = null as { open: number; close: number } | null;
 
-    if (ch !== close) continue;
-
-    const openIndex = openStack.pop();
-    if (openIndex === undefined) continue;
-
-    if (openIndex <= cursor && cursor <= index) {
-      if (bestPair === null || index - openIndex < bestPair.close - bestPair.open) {
-        bestPair = { open: openIndex, close: index };
+  scanSameDelimiterPairs(text, open, close, (openIndex, closeIndex) => {
+    if (openIndex <= cursor && cursor <= closeIndex) {
+      if (
+        bestPair === null ||
+        closeIndex - openIndex < bestPair.close - bestPair.open
+      ) {
+        bestPair = { open: openIndex, close: closeIndex };
       }
     }
-  }
+    return null;
+  });
 
   if (bestPair === null) return null;
 
@@ -210,6 +214,44 @@ export function resolveBracketObjectRange(
   };
 }
 
+export function resolveMatchingPairMotionTarget(
+  text: string,
+  cursorAbs: number,
+  currentLineStartAbs: number,
+  currentLineEndAbs: number,
+): MatchingPairMotionTarget | null {
+  const start = currentLineStartAbs,
+    end = currentLineEndAbs;
+  if (!text.length || start >= end) return null;
+  const visibleEol = cursorAbs >= end;
+  let sourceAbs = visibleEol ? end - 1 : Math.max(cursorAbs, start);
+  const rangeAnchorAbs = visibleEol ? sourceAbs : cursorAbs;
+  let pair = pairKind(text[sourceAbs]);
+  for (
+    let index = sourceAbs + 1;
+    !visibleEol && !pair && index < end;
+    index++
+  ) {
+    pair = pairKind(text[index]);
+    if (pair) sourceAbs = index;
+  }
+  if (!pair) return null;
+  const targetAbs = scanSameDelimiterPairs(
+    text,
+    pair[0],
+    pair[1],
+    (openAbs, closeAbs) =>
+      openAbs === sourceAbs
+        ? closeAbs
+        : closeAbs === sourceAbs
+          ? openAbs
+          : null,
+  );
+  if (targetAbs !== null) return { pair, sourceAbs, targetAbs, rangeAnchorAbs };
+
+  return null;
+}
+
 export function resolveDelimitedTextObjectRange(
   text: string,
   cursorAbs: number,
@@ -224,7 +266,13 @@ export function resolveDelimitedTextObjectRange(
   }
 
   if (spec.type === "bracket") {
-    return resolveBracketObjectRange(text, cursorAbs, kind, spec.open, spec.close);
+    return resolveBracketObjectRange(
+      text,
+      cursorAbs,
+      kind,
+      spec.open,
+      spec.close,
+    );
   }
 
   return null;
@@ -244,11 +292,10 @@ export function resolveWordTextObjectRange(
   const bounds = findLogicalLineBounds(line, cursor);
   if (bounds.start >= bounds.end) return null;
 
-  const hasWordChar = (idx: number) => (
-    idx >= bounds.start
-    && idx < bounds.end
-    && isWordTextObjectChar(line[idx], semanticClass)
-  );
+  const hasWordChar = (idx: number) =>
+    idx >= bounds.start &&
+    idx < bounds.end &&
+    isWordTextObjectChar(line[idx], semanticClass);
 
   let col = Math.max(bounds.start, Math.min(cursor, bounds.end - 1));
 
@@ -275,7 +322,8 @@ export function resolveWordTextObjectRange(
   let remaining = normalizeCount(count) - 1;
   while (remaining > 0) {
     let nextWordStart = end;
-    while (nextWordStart < bounds.end && !hasWordChar(nextWordStart)) nextWordStart++;
+    while (nextWordStart < bounds.end && !hasWordChar(nextWordStart))
+      nextWordStart++;
     if (nextWordStart >= bounds.end) break;
 
     let nextWordEnd = nextWordStart + 1;

package/word-boundary-cache.ts

@@ -52,7 +52,7 @@ function buildWordBoundaryData(
     charTypes[i] = getCharType(line[i], semanticClass);
   }
 
-  for (let runStart = 0; runStart < len;) {
+  for (let runStart = 0; runStart < len; ) {
     const runType = charTypes[runStart] ?? CharType.Space;
     let runEnd = runStart;
     while (runEnd + 1 < len && charTypes[runEnd + 1] === runType) {
@@ -153,9 +153,10 @@ export class WordBoundaryCache {
   private readonly maxEntries: number;
 
   constructor(maxEntries: number = DEFAULT_MAX_CACHE_ENTRIES) {
-    this.maxEntries = Number.isInteger(maxEntries) && maxEntries > 0
-      ? maxEntries
-      : DEFAULT_MAX_CACHE_ENTRIES;
+    this.maxEntries =
+      Number.isInteger(maxEntries) && maxEntries > 0
+        ? maxEntries
+        : DEFAULT_MAX_CACHE_ENTRIES;
   }
 
   private makeCacheKey(line: string, semanticClass: WordMotionClass): string {