pi-vim 0.3.2 → 0.9.0

package/motions.ts

@@ -175,7 +175,8 @@ export function findCharMotionTarget(
       const nextIndex = currentIndex + 1 + tillRepeatOffset;
       let found = -1;
       for (let j = nextIndex; j < graphemes.length; j++) {
-        const g = graphemes[j]!;
+        const g = graphemes[j];
+        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)) {
@@ -184,13 +185,20 @@ export function findCharMotionTarget(
         }
       }
       if (found === -1) return null;
-      if (isFinal) return isTill ? graphemes[found - 1]!.start : graphemes[found]!.start;
+      if (isFinal) {
+        const targetGrapheme = graphemes[found];
+        if (!targetGrapheme) return null;
+        if (!isTill) return targetGrapheme.start;
+        const previousGrapheme = graphemes[found - 1];
+        return previousGrapheme ? previousGrapheme.start : null;
+      }
       currentIndex = found;
     } else {
       const nextIndex = currentIndex - 1 - tillRepeatOffset;
       let found = -1;
       for (let j = nextIndex; j >= 0; j--) {
-        const g = graphemes[j]!;
+        const g = graphemes[j];
+        if (!g) continue;
         if (line.slice(g.start, g.end) === targetChar || line.slice(g.start, g.end).startsWith(targetChar)) {
           found = j;
           break;
@@ -198,7 +206,9 @@ export function findCharMotionTarget(
       }
       if (found === -1) return null;
       if (isFinal) {
-        if (!isTill) return graphemes[found]!.start;
+        const targetGrapheme = graphemes[found];
+        if (!targetGrapheme) return null;
+        if (!isTill) return targetGrapheme.start;
         const afterTarget = graphemes[found + 1];
         return afterTarget ? afterTarget.start : line.length;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-vim",
-  "version": "0.3.2",
+  "version": "0.9.0",
   "description": "Vim-style modal editing for Pi's TUI editor",
   "type": "module",
   "keywords": [
@@ -22,11 +22,13 @@
   ],
   "scripts": {
     "build": "echo 'nothing to build'",
-    "lint": "eslint .",
+    "format": "biome format --write .",
+    "lint": "biome lint . && eslint .",
     "typecheck": "tsc --noEmit",
     "test": "node --import tsx/esm --test 'test/**/*.test.ts'",
     "check": "npm run lint && npm run typecheck && npm run test",
     "pack:check": "node --import tsx/esm script/pack-check.ts",
+    "hooks:install": "lefthook install",
     "prepublishOnly": "npm run lint && npm run typecheck && npm run pack:check && npm test"
   },
   "pi": {
@@ -35,15 +37,17 @@
     ]
   },
   "devDependencies": {
+    "@biomejs/biome": "2.4.8",
     "@eslint/js": "^9.25.1",
     "@types/node": "^24.7.2",
     "eslint": "^9.25.1",
+    "lefthook": "^2.1.4",
     "tsx": "^4.19.3",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.31.1"
   },
   "peerDependencies": {
     "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-tui": "*"
+    "@mariozechner/pi-tui": ">=0.47.0"
   }
 }

package/text-objects.ts

@@ -0,0 +1,303 @@
+export type TextObjectKind = "i" | "a";
+
+export type TextObjectRange = {
+  startAbs: number;
+  endAbs: number;
+};
+
+export type WordTextObjectClass = "word" | "WORD";
+
+export type DelimiterSpec = {
+  type: "quote" | "bracket";
+  open: string;
+  close: string;
+};
+
+function normalizeCount(count: number): number {
+  if (!Number.isFinite(count) || count < 1) return 1;
+  return Math.floor(count);
+}
+
+function clampCursorCol(line: string, cursorCol: number): number {
+  if (line.length === 0) return 0;
+  if (!Number.isFinite(cursorCol)) return 0;
+
+  const normalized = Math.trunc(cursorCol);
+  return Math.max(0, Math.min(normalized, line.length - 1));
+}
+
+function clampCursorAbs(text: string, cursorAbs: number): number {
+  if (text.length === 0) return 0;
+  if (!Number.isFinite(cursorAbs)) return 0;
+
+  const normalized = Math.trunc(cursorAbs);
+  return Math.max(0, Math.min(normalized, text.length - 1));
+}
+
+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 start = line.lastIndexOf("\n", previousSearchStart) + 1;
+  const nextNewline = line.indexOf("\n", cursorCol);
+
+  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 {
+  if (ch === undefined) return false;
+  if (semanticClass === "WORD") return !/\s/.test(ch);
+  return /\w/.test(ch);
+}
+
+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: "]",
+    };
+  }
+
+  if (key === "{" || key === "}" || key === "B") {
+    return {
+      type: "bracket",
+      open: "{",
+      close: "}",
+    };
+  }
+
+  return null;
+}
+
+export function isEscapedDelimiter(text: string, index: number): boolean {
+  if (!Number.isInteger(index) || index <= 0 || index >= text.length) return false;
+
+  let backslashCount = 0;
+  for (let i = index - 1; i >= 0 && text[i] === "\\"; i--) {
+    backslashCount++;
+  }
+
+  return backslashCount % 2 === 1;
+}
+
+export function resolveQuoteObjectRange(
+  text: string,
+  cursorAbs: number,
+  kind: TextObjectKind,
+  quote: string,
+): TextObjectRange | null {
+  const spec = normalizeDelimiterKey(quote);
+  if (spec?.type !== "quote") return null;
+
+  const cursor = clampCursorAbs(text, cursorAbs);
+  const bounds = findCurrentLineBounds(text, cursor);
+  if (bounds.startAbs >= bounds.endAbs) return null;
+
+  let openIndex: number | null = null;
+  let bestPair: { open: number; close: number } | null = null;
+
+  for (let index = bounds.startAbs; index < bounds.endAbs; index++) {
+    if (text[index] !== quote || isEscapedDelimiter(text, index)) continue;
+
+    if (openIndex === null) {
+      openIndex = index;
+      continue;
+    }
+
+    const closeIndex = index;
+    if (openIndex <= cursor && cursor <= closeIndex) {
+      if (bestPair === null || closeIndex - openIndex < bestPair.close - bestPair.open) {
+        bestPair = { open: openIndex, close: closeIndex };
+      }
+    }
+    openIndex = null;
+  }
+
+  if (bestPair === null) return null;
+
+  if (kind === "i") {
+    return {
+      startAbs: bestPair.open + 1,
+      endAbs: bestPair.close,
+    };
+  }
+
+  return {
+    startAbs: bestPair.open,
+    endAbs: bestPair.close + 1,
+  };
+}
+
+export function resolveBracketObjectRange(
+  text: string,
+  cursorAbs: number,
+  kind: TextObjectKind,
+  open: string,
+  close: string,
+): TextObjectRange | null {
+  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;
+    }
+
+    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 };
+      }
+    }
+  }
+
+  if (bestPair === null) return null;
+
+  if (kind === "i") {
+    return {
+      startAbs: bestPair.open + 1,
+      endAbs: bestPair.close,
+    };
+  }
+
+  return {
+    startAbs: bestPair.open,
+    endAbs: bestPair.close + 1,
+  };
+}
+
+export function resolveDelimitedTextObjectRange(
+  text: string,
+  cursorAbs: number,
+  kind: TextObjectKind,
+  key: string,
+): TextObjectRange | null {
+  const spec = normalizeDelimiterKey(key);
+  if (spec === null) return null;
+
+  if (spec.type === "quote") {
+    return resolveQuoteObjectRange(text, cursorAbs, kind, spec.open);
+  }
+
+  if (spec.type === "bracket") {
+    return resolveBracketObjectRange(text, cursorAbs, kind, spec.open, spec.close);
+  }
+
+  return null;
+}
+
+export function resolveWordTextObjectRange(
+  line: string,
+  lineStartAbs: number,
+  cursorCol: number,
+  kind: TextObjectKind,
+  count: number = 1,
+  semanticClass: WordTextObjectClass = "word",
+): TextObjectRange | null {
+  if (line.length === 0) return null;
+
+  const cursor = clampCursorCol(line, cursorCol);
+  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)
+  );
+
+  let col = Math.max(bounds.start, Math.min(cursor, bounds.end - 1));
+
+  if (!hasWordChar(col)) {
+    let right = col;
+    while (right < bounds.end && !hasWordChar(right)) right++;
+
+    if (right < bounds.end) {
+      col = right;
+    } else {
+      let left = Math.min(col, bounds.end - 1);
+      while (left >= bounds.start && !hasWordChar(left)) left--;
+      if (left < bounds.start) return null;
+      col = left;
+    }
+  }
+
+  let start = col;
+  while (start > bounds.start && hasWordChar(start - 1)) start--;
+
+  let end = col + 1;
+  while (end < bounds.end && hasWordChar(end)) end++;
+
+  let remaining = normalizeCount(count) - 1;
+  while (remaining > 0) {
+    let nextWordStart = end;
+    while (nextWordStart < bounds.end && !hasWordChar(nextWordStart)) nextWordStart++;
+    if (nextWordStart >= bounds.end) break;
+
+    let nextWordEnd = nextWordStart + 1;
+    while (nextWordEnd < bounds.end && hasWordChar(nextWordEnd)) nextWordEnd++;
+
+    end = nextWordEnd;
+    remaining--;
+  }
+
+  if (kind === "a") {
+    let aroundEnd = end;
+    while (aroundEnd < bounds.end && isWhitespace(line[aroundEnd])) aroundEnd++;
+
+    if (aroundEnd > end) {
+      end = aroundEnd;
+    } else {
+      while (start > bounds.start && isWhitespace(line[start - 1])) start--;
+    }
+  }
+
+  return {
+    startAbs: lineStartAbs + start,
+    endAbs: lineStartAbs + end,
+  };
+}

package/word-boundary-cache.ts

@@ -53,7 +53,7 @@ function buildWordBoundaryData(
   }
 
   for (let runStart = 0; runStart < len;) {
-    const runType = charTypes[runStart]!;
+    const runType = charTypes[runStart] ?? CharType.Space;
     let runEnd = runStart;
     while (runEnd + 1 < len && charTypes[runEnd + 1] === runType) {
       runEnd++;
@@ -109,13 +109,13 @@ function findTargetInLine(
 
     if (target === "start") {
       if (data.charTypes[i] !== CharType.Space) {
-        i = data.runEndByIndex[i]! + 1;
+        i = (data.runEndByIndex[i] ?? i) + 1;
       }
 
       if (i >= len) return len;
 
       if (data.charTypes[i] === CharType.Space) {
-        const next = data.nextNonSpaceAtOrAfter[i]!;
+        const next = data.nextNonSpaceAtOrAfter[i] ?? -1;
         return next === -1 ? len : next;
       }
 
@@ -127,23 +127,23 @@ function findTargetInLine(
     if (i >= len) return len;
 
     if (data.charTypes[i] === CharType.Space) {
-      const next = data.nextNonSpaceAtOrAfter[i]!;
+      const next = data.nextNonSpaceAtOrAfter[i] ?? -1;
       if (next === -1) return len;
       i = next;
     }
 
-    return data.runEndByIndex[i]!;
+    return data.runEndByIndex[i] ?? i;
   }
 
   if (i >= len) i = len - 1;
   if (i > 0) i--;
 
   if (data.charTypes[i] === CharType.Space) {
-    const prev = data.prevNonSpaceAtOrBefore[i]!;
+    const prev = data.prevNonSpaceAtOrBefore[i] ?? -1;
     if (prev !== -1) i = prev;
   }
 
-  return data.runStartByIndex[i]!;
+  return data.runStartByIndex[i] ?? i;
 }
 
 const DEFAULT_MAX_CACHE_ENTRIES = 256;