pi-vim 0.1.0

package/motions.ts

@@ -0,0 +1,125 @@
+/**
+ * Motion calculation utilities for vim-mode
+ */
+
+import type { CharMotion } from "./types.js";
+
+// Character types for word boundary detection
+enum CharType {
+  Space = 0,
+  Keyword = 1, // alphanumeric + underscore
+  Other = 2, // punctuation/symbols
+}
+
+function getCharType(c: string | undefined): CharType {
+  if (!c || /\s/.test(c)) return CharType.Space;
+  if (/\w/.test(c)) return CharType.Keyword;
+  return CharType.Other;
+}
+
+/**
+ * Reverse a character motion direction (f ↔ F, t ↔ T).
+ */
+export function reverseCharMotion(motion: CharMotion): CharMotion {
+  const reverseMap: Record<CharMotion, CharMotion> = {
+    f: "F",
+    F: "f",
+    t: "T",
+    T: "t",
+  };
+  return reverseMap[motion];
+}
+
+/**
+ * Find target column for a character motion (f/F/t/T).
+ * @returns target column or null if not found
+ */
+export function findCharMotionTarget(
+  line: string,
+  col: number,
+  motion: CharMotion,
+  targetChar: string,
+  isRepeat: boolean = false,
+): number | null {
+  const isForward = motion === "f" || motion === "t";
+  const isTill = motion === "t" || motion === "T";
+
+  // For till repeats (;/,), we need extra offset to skip past the character we stopped before/after
+  const tillRepeatOffset = isTill && isRepeat ? 1 : 0;
+
+  if (isForward) {
+    const searchStart = col + 1 + tillRepeatOffset;
+    const idx = line.indexOf(targetChar, searchStart);
+    if (idx !== -1) {
+      return isTill ? idx - 1 : idx;
+    }
+  } else {
+    const searchStart = col - 1 - tillRepeatOffset;
+    const idx = line.lastIndexOf(targetChar, searchStart);
+    if (idx !== -1) {
+      return isTill ? idx + 1 : idx;
+    }
+  }
+  return null;
+}
+
+/**
+ * Calculate word motion target column.
+ */
+export function findWordMotionTarget(
+  line: string,
+  col: number,
+  direction: "forward" | "backward",
+  target: "start" | "end",
+): number {
+  const len = line.length;
+  if (len === 0) return 0;
+
+  let i = Math.max(0, Math.min(col, len));
+
+  if (direction === "forward") {
+    if (i >= len) return len;
+
+    if (target === "start") {
+      // w: move to start of next word
+      const startType = getCharType(line[i]);
+
+      // Skip current word/punct block
+      if (startType !== CharType.Space) {
+        while (i < len && getCharType(line[i]) === startType) i++;
+      }
+
+      // Skip whitespace
+      while (i < len && getCharType(line[i]) === CharType.Space) i++;
+
+      return i;
+    }
+
+    // e: move to end of current/next word
+    if (i < len - 1) i++;
+
+    // Skip whitespace forward
+    while (i < len && getCharType(line[i]) === CharType.Space) i++;
+
+    // Now at start of next word (or end of line). Find end.
+    if (i >= len) return len;
+
+    const type = getCharType(line[i]);
+    while (i < len - 1 && getCharType(line[i + 1]) === type) i++;
+
+    return i;
+  }
+
+  // b: move to start of previous word
+  if (i >= len) i = len - 1;
+  if (i > 0) i--;
+
+  // Skip whitespace backward
+  while (i > 0 && getCharType(line[i]) === CharType.Space) i--;
+
+  // Now at end of prev word (or start of line). Find start.
+  const type = getCharType(line[i]);
+  while (i > 0 && getCharType(line[i - 1]) === type) i--;
+
+  return i;
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "pi-vim",
+  "version": "0.1.0",
+  "description": "Vim-style modal editing for Pi's TUI editor",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "vim",
+    "editor"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lajarre/pi-vim.git"
+  },
+  "files": [
+    "*.ts",
+    "!*.test.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "echo 'nothing to build'",
+    "test": "node --import tsx/esm --test 'test/**/*.test.ts'",
+    "check": "npm run test"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "devDependencies": {
+    "tsx": "^4.19.3"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*"
+  }
+}

package/types.ts

@@ -0,0 +1,49 @@
+/**
+ * Types and constants for vim-mode extension
+ */
+
+export type Mode = "normal" | "insert";
+export type CharMotion = "f" | "F" | "t" | "T";
+export type PendingMotion = CharMotion | null;
+export type PendingOperator = "d" | "c" | "y" | null;
+
+export interface LastCharMotion {
+  motion: CharMotion;
+  char: string;
+}
+
+// Normal mode key mappings: key -> escape sequence (or null for mode switch)
+export const NORMAL_KEYS: Record<string, string | null> = {
+  h: "\x1b[D", // left
+  j: "\x1b[B", // down
+  k: "\x1b[A", // up
+  l: "\x1b[C", // right
+  "0": "\x01", // line start
+  $: "\x05", // line end
+  x: null, // delete char (custom clipboard handling)
+  D: null, // delete to end of line (custom clipboard handling)
+  C: null, // change to end of line (delete to end + insert mode)
+  S: null, // substitute line (delete line content + insert mode)
+  s: null, // substitute char (delete char + insert mode)
+  i: null, // insert mode
+  a: null, // append (insert + right)
+  A: null, // append at end of line
+  I: null, // insert at start of line
+  o: null, // open line below
+  O: null, // open line above
+};
+
+// Character motion keys that wait for a target character
+export const CHAR_MOTION_KEYS = new Set<string>(["f", "F", "t", "T"]);
+
+// Escape sequences
+export const ESC_LEFT = "\x1b[D";
+export const ESC_RIGHT = "\x1b[C";
+export const ESC_DELETE = "\x1b[3~";
+export const CTRL_A = "\x01"; // line start
+export const CTRL_E = "\x05"; // line end
+export const CTRL_K = "\x0b"; // kill to end of line
+export const CTRL_UNDERSCORE = "\x1f"; // ctrl+_ — readline undo
+export const NEWLINE = "\n"; // newline character
+export const ESC_UP = "\x1b[A"; // cursor up
+export const ESC_DOWN = "\x1b[B"; // cursor down

package/word-boundary-cache.ts

@@ -0,0 +1,180 @@
+/**
+ * Line-local cache for Vim word motion boundaries.
+ *
+ * Keyed by exact line content to avoid stale boundary reuse.
+ */
+
+export type WordMotionDirection = "forward" | "backward";
+export type WordMotionTarget = "start" | "end";
+
+enum CharType {
+  Space = 0,
+  Word = 1,
+  Other = 2,
+}
+
+export interface WordBoundaryData {
+  readonly length: number;
+  readonly charTypes: Uint8Array;
+  readonly runStartByIndex: Int32Array;
+  readonly runEndByIndex: Int32Array;
+  readonly nextNonSpaceAtOrAfter: Int32Array;
+  readonly prevNonSpaceAtOrBefore: Int32Array;
+}
+
+function getCharType(ch: string | undefined): CharType {
+  if (!ch || /\s/.test(ch)) return CharType.Space;
+  if (/\w/.test(ch)) return CharType.Word;
+  return CharType.Other;
+}
+
+function buildWordBoundaryData(line: string): WordBoundaryData {
+  const len = line.length;
+  const charTypes = new Uint8Array(len);
+  const runStartByIndex = new Int32Array(len);
+  const runEndByIndex = new Int32Array(len);
+  const nextNonSpaceAtOrAfter = new Int32Array(len + 1);
+  const prevNonSpaceAtOrBefore = new Int32Array(len);
+
+  nextNonSpaceAtOrAfter.fill(-1);
+  prevNonSpaceAtOrBefore.fill(-1);
+
+  for (let i = 0; i < len; i++) {
+    charTypes[i] = getCharType(line[i]);
+  }
+
+  for (let runStart = 0; runStart < len;) {
+    const runType = charTypes[runStart]!;
+    let runEnd = runStart;
+    while (runEnd + 1 < len && charTypes[runEnd + 1] === runType) {
+      runEnd++;
+    }
+
+    for (let i = runStart; i <= runEnd; i++) {
+      runStartByIndex[i] = runStart;
+      runEndByIndex[i] = runEnd;
+    }
+
+    runStart = runEnd + 1;
+  }
+
+  let nextNonSpace = -1;
+  for (let i = len - 1; i >= 0; i--) {
+    if (charTypes[i] !== CharType.Space) {
+      nextNonSpace = i;
+    }
+    nextNonSpaceAtOrAfter[i] = nextNonSpace;
+  }
+
+  let prevNonSpace = -1;
+  for (let i = 0; i < len; i++) {
+    if (charTypes[i] !== CharType.Space) {
+      prevNonSpace = i;
+    }
+    prevNonSpaceAtOrBefore[i] = prevNonSpace;
+  }
+
+  return {
+    length: len,
+    charTypes,
+    runStartByIndex,
+    runEndByIndex,
+    nextNonSpaceAtOrAfter,
+    prevNonSpaceAtOrBefore,
+  };
+}
+
+function findTargetInLine(
+  data: WordBoundaryData,
+  col: number,
+  direction: WordMotionDirection,
+  target: WordMotionTarget,
+): number {
+  const len = data.length;
+  if (len === 0) return 0;
+
+  let i = Math.max(0, Math.min(col, len));
+
+  if (direction === "forward") {
+    if (i >= len) return len;
+
+    if (target === "start") {
+      if (data.charTypes[i] !== CharType.Space) {
+        i = data.runEndByIndex[i]! + 1;
+      }
+
+      if (i >= len) return len;
+
+      if (data.charTypes[i] === CharType.Space) {
+        const next = data.nextNonSpaceAtOrAfter[i]!;
+        return next === -1 ? len : next;
+      }
+
+      return i;
+    }
+
+    if (i < len - 1) i++;
+
+    if (i >= len) return len;
+
+    if (data.charTypes[i] === CharType.Space) {
+      const next = data.nextNonSpaceAtOrAfter[i]!;
+      if (next === -1) return len;
+      i = next;
+    }
+
+    return data.runEndByIndex[i]!;
+  }
+
+  if (i >= len) i = len - 1;
+  if (i > 0) i--;
+
+  if (data.charTypes[i] === CharType.Space) {
+    const prev = data.prevNonSpaceAtOrBefore[i]!;
+    if (prev !== -1) i = prev;
+  }
+
+  return data.runStartByIndex[i]!;
+}
+
+const DEFAULT_MAX_CACHE_ENTRIES = 256;
+
+export class WordBoundaryCache {
+  private readonly entries = new Map<string, WordBoundaryData>();
+  private readonly maxEntries: number;
+
+  constructor(maxEntries: number = DEFAULT_MAX_CACHE_ENTRIES) {
+    this.maxEntries = Number.isInteger(maxEntries) && maxEntries > 0
+      ? maxEntries
+      : DEFAULT_MAX_CACHE_ENTRIES;
+  }
+
+  get(line: string): WordBoundaryData {
+    const cached = this.entries.get(line);
+    if (cached) return cached;
+
+    const built = buildWordBoundaryData(line);
+
+    if (this.entries.size >= this.maxEntries) {
+      const oldestKey = this.entries.keys().next().value;
+      if (oldestKey !== undefined) {
+        this.entries.delete(oldestKey);
+      }
+    }
+
+    this.entries.set(line, built);
+    return built;
+  }
+
+  tryFindTarget(
+    line: string,
+    col: number,
+    direction: WordMotionDirection,
+    target: WordMotionTarget,
+  ): number | null {
+    if (!Number.isInteger(col) || col < 0) return null;
+
+    const boundaries = this.get(line);
+    return findTargetInLine(boundaries, col, direction, target);
+  }
+}