pi-vim 0.9.0 → 0.10.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.10.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

@@ -34,10 +34,14 @@ 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);
 
@@ -47,7 +51,10 @@ function findLogicalLineBounds(line: string, cursorCol: number): { start: number
   };
 }
 
-function findCurrentLineBounds(text: string, cursorAbs: number): { startAbs: number; endAbs: number } {
+function findCurrentLineBounds(
+  text: string,
+  cursorAbs: number,
+): { startAbs: number; endAbs: number } {
   const cursor = clampCursorAbs(text, cursorAbs);
   const bounds = findLogicalLineBounds(text, cursor);
 
@@ -57,7 +64,10 @@ function findCurrentLineBounds(text: string, cursorAbs: number): { startAbs: num
   };
 }
 
-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);
@@ -68,7 +78,7 @@ function isWhitespace(ch: string | undefined): boolean {
 }
 
 export function normalizeDelimiterKey(key: string): DelimiterSpec | null {
-  if (key === "\"" || key === "'" || key === "`") {
+  if (key === '"' || key === "'" || key === "`") {
     return {
       type: "quote",
       open: key,
@@ -104,7 +114,8 @@ export function normalizeDelimiterKey(key: string): DelimiterSpec | 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--) {
@@ -140,7 +151,10 @@ export function resolveQuoteObjectRange(
 
     const closeIndex = index;
     if (openIndex <= cursor && cursor <= closeIndex) {
-      if (bestPair === null || closeIndex - openIndex < bestPair.close - bestPair.open) {
+      if (
+        bestPair === null ||
+        closeIndex - openIndex < bestPair.close - bestPair.open
+      ) {
         bestPair = { open: openIndex, close: closeIndex };
       }
     }
@@ -189,7 +203,10 @@ export function resolveBracketObjectRange(
     if (openIndex === undefined) continue;
 
     if (openIndex <= cursor && cursor <= index) {
-      if (bestPair === null || index - openIndex < bestPair.close - bestPair.open) {
+      if (
+        bestPair === null ||
+        index - openIndex < bestPair.close - bestPair.open
+      ) {
         bestPair = { open: openIndex, close: index };
       }
     }
@@ -224,7 +241,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 +267,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 +297,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 {