@aemonge-dev/pi-stardeck 0.0.0-stage → 0.6.0

package/packages/pi-vim-top-border/settings.ts

@@ -0,0 +1,287 @@
+import { SettingsManager } from '@earendil-works/pi-coding-agent';
+
+export type ModeColorSettings = {
+  insert?: string;
+  normal?: string;
+  visual?: string;
+  ex?: string;
+};
+
+export type ModeChangeSettings = {
+  insert?: string;
+  normal?: string;
+};
+
+export type ExCommandSettings = {
+  piDispatch: boolean;
+  copyInputToClipboard: boolean;
+};
+
+export type BorderSyncMode = boolean | 'inherit';
+
+// Per-surface paint policy for a single mode:
+//   - "mode"     always paint that mode's color;
+//   - "host"     always show the host's current border color;
+//   - "thinking" show the host color while its border is away from the neutral
+//                resting default, otherwise paint the mode color.
+export type SurfaceSync = 'mode' | 'host' | 'thinking';
+export type SurfaceSyncMap = {
+  insert: SurfaceSync;
+  normal: SurfaceSync;
+  visual: SurfaceSync;
+  ex: SurfaceSync;
+};
+
+export type PiVimSettings = {
+  clipboardMirror?: unknown;
+  exCommand?: unknown;
+  globalExCommand?: unknown;
+  modeColors?: ModeColorSettings;
+  modeChange?: ModeChangeSettings;
+  // Per-mode paint policy for Pi's input border. Default: every mode "host".
+  borderSync?: SurfaceSyncMap;
+  // Per-mode paint policy for pi-vim's footer mode label. Default: "mode".
+  labelSync?: SurfaceSyncMap;
+  // Deprecated, never-released alias superseded by borderSync/labelSync; still
+  // accepted and translated in `resolveSurfaceSyncMaps`. `false`/absent → both
+  // maps at their defaults; `true` → borderSync all "mode"; the never-released
+  // `"inherit"` → both maps all "thinking".
+  syncBorderColorWithMode?: BorderSyncMode;
+};
+
+export const DEFAULT_EX_COMMAND_SETTINGS: ExCommandSettings = {
+  piDispatch: true,
+  copyInputToClipboard: false,
+};
+
+const M = Symbol(),
+  C = ['insert', 'normal', 'visual', 'ex'] as const,
+  MC = ['insert', 'normal'] 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;
+}
+
+const BORDER_SYNC_DEFAULT: SurfaceSync = 'host';
+const LABEL_SYNC_DEFAULT: SurfaceSync = 'mode';
+
+// Validates a per-mode paint-policy map. Like `colors`, a project map is a
+// whole-setting override: missing or invalid entries fall back to the surface
+// default (not to the global map). Returns undefined when no valid entry is
+// present so the caller can defer to the legacy key.
+function surfaceMap(v: unknown, dflt: SurfaceSync): SurfaceSyncMap | undefined {
+  if (!rec(v)) return;
+  const r: SurfaceSyncMap = {
+    insert: dflt,
+    normal: dflt,
+    visual: dflt,
+    ex: dflt,
+  };
+  let any = false;
+  for (const k of C) {
+    const x = v[k];
+    if (x === 'mode' || x === 'host' || x === 'thinking') {
+      r[k] = x;
+      any = true;
+    }
+  }
+  return any ? r : undefined;
+}
+
+function fill(value: SurfaceSync): SurfaceSyncMap {
+  return { insert: value, normal: value, visual: value, ex: value };
+}
+
+function modeChange(v: unknown): ModeChangeSettings | undefined {
+  if (!rec(v)) return;
+  const r: ModeChangeSettings = {};
+  for (const k of MC) {
+    const x = v[k];
+    if (typeof x !== 'string') continue;
+    const t = x.trim();
+    if (t.length > 0) 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 readPiVimExCommandSetting(g: unknown, p: unknown) {
+  // The bridge only selects among commands Pi already trusts; it grants no new
+  // capability, so a project file may turn it off (unlike modeChange).
+  let v = get(p, 'exCommand');
+  if (v !== M) return v;
+  v = get(g, 'exCommand');
+  return v === M ? undefined : v;
+}
+
+export function readPiVimGlobalExCommandSetting(g: unknown, p: unknown) {
+  void p;
+  // Copying the prompt to the OS clipboard is an exfiltration capability, so
+  // only the user-global settings file is trusted. Project settings may be
+  // checked into a repo and must not be able to enable clipboard writes.
+  const v = get(g, 'exCommand');
+  return v === M ? undefined : v;
+}
+
+export function resolveExCommandSettings(
+  value: unknown,
+  globalValue: unknown,
+): {
+  settings: ExCommandSettings;
+  warning?: string;
+} {
+  const settings = { ...DEFAULT_EX_COMMAND_SETTINGS };
+  let invalidObject = false;
+  const invalid: string[] = [];
+  for (const [k, source] of [
+    ['piDispatch', value],
+    ['copyInputToClipboard', globalValue],
+  ] as const) {
+    if (source === undefined) continue;
+    if (!rec(source)) {
+      invalidObject = true;
+      continue;
+    }
+    if (!Object.hasOwn(source, k)) continue;
+    const v = source[k];
+    if (typeof v === 'boolean') settings[k] = v;
+    else invalid.push(k);
+  }
+
+  if (invalidObject) {
+    return {
+      settings,
+      warning: 'Invalid piVim.exCommand; expected an object.',
+    };
+  }
+  if (!invalid[0]) return { settings };
+  return {
+    settings,
+    warning: `Invalid piVim.exCommand ${invalid.join(', ')}; expected a boolean.`,
+  };
+}
+
+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 readPiVimModeChange(g: unknown, p: unknown) {
+  void p;
+  // modeChange executes a shell command, so only the user-global settings file
+  // is trusted. Project settings may be checked into a repo; treating them as
+  // executable hook config would let a checkout run arbitrary commands when the
+  // editor changes mode.
+  const v = get(g, 'modeChange');
+  return modeChange(v);
+}
+
+export function readPiVimBorderSyncSetting(
+  g: unknown,
+  p: unknown,
+): BorderSyncMode | undefined {
+  const read = (v: unknown): BorderSyncMode | undefined =>
+    v === 'inherit' || v === true || v === false ? v : undefined;
+  const v = get(p, 'syncBorderColorWithMode');
+  if (v !== M) return read(v);
+  return read(get(g, 'syncBorderColorWithMode'));
+}
+
+export function readPiVimBorderSync(
+  g: unknown,
+  p: unknown,
+): SurfaceSyncMap | undefined {
+  // Project settings are a whole-setting override (as with modeColors): a
+  // present project value wins even if invalid, so its global counterpart never
+  // leaks through.
+  const v = get(p, 'borderSync');
+  if (v !== M) return surfaceMap(v, BORDER_SYNC_DEFAULT);
+  return surfaceMap(get(g, 'borderSync'), BORDER_SYNC_DEFAULT);
+}
+
+export function readPiVimLabelSync(g: unknown, p: unknown): SurfaceSyncMap | undefined {
+  const v = get(p, 'labelSync');
+  if (v !== M) return surfaceMap(v, LABEL_SYNC_DEFAULT);
+  return surfaceMap(get(g, 'labelSync'), LABEL_SYNC_DEFAULT);
+}
+
+// Collapses the two new per-mode maps and the deprecated legacy key into the
+// two full maps pi-vim paints with. A present new map wins over the legacy key
+// for its surface; otherwise the legacy value is translated:
+//   - `true`      → borderSync all "mode"        (label stays default "mode")
+//   - `"inherit"` → borderSync/labelSync all "thinking"
+//   - `false`/absent → both maps at their defaults ("host" / "mode")
+export function resolveSurfaceSyncMaps(settings: {
+  borderSync?: SurfaceSyncMap;
+  labelSync?: SurfaceSyncMap;
+  syncBorderColorWithMode?: BorderSyncMode;
+}): { borderSync: SurfaceSyncMap; labelSync: SurfaceSyncMap } {
+  const legacy = settings.syncBorderColorWithMode;
+  const borderSync =
+    settings.borderSync ??
+    (legacy === true
+      ? fill('mode')
+      : legacy === 'inherit'
+        ? fill('thinking')
+        : fill(BORDER_SYNC_DEFAULT));
+  const labelSync =
+    settings.labelSync ??
+    (legacy === 'inherit' ? fill('thinking') : fill(LABEL_SYNC_DEFAULT));
+  return { borderSync, labelSync };
+}
+
+function disk(cwd: string): PiVimSettings {
+  const s = SettingsManager.create(cwd),
+    g = s.getGlobalSettings(),
+    p = s.getProjectSettings();
+  return {
+    clipboardMirror: readPiVimClipboardMirrorSetting(g, p),
+    exCommand: readPiVimExCommandSetting(g, p),
+    globalExCommand: readPiVimGlobalExCommandSetting(g, p),
+    modeColors: readPiVimModeColors(g, p),
+    modeChange: readPiVimModeChange(g, p),
+    borderSync: readPiVimBorderSync(g, p),
+    labelSync: readPiVimLabelSync(g, p),
+    syncBorderColorWithMode: readPiVimBorderSyncSetting(g, p),
+  };
+}
+
+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/packages/pi-vim-top-border/text-objects.ts

@@ -0,0 +1,389 @@
+import { getLineGraphemes } from './motions.js';
+
+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;
+};
+
+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);
+}
+
+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 };
+}
+
+/**
+ * Vim character classes for word text objects: 0 = blank, 1 = other
+ * (non-blank punctuation/symbol), 2 = word (keyword). `iW`/`aW` collapse
+ * every non-blank character into the single word class. Matches nvim's
+ * `cls()` split, which is what `iw`/`aw` scan over.
+ */
+type WordCharClass = 0 | 1 | 2;
+
+// Unicode-aware keyword test: letters, numbers, combining marks (so grapheme
+// clusters such as a base letter plus combining accent stay in one word), and
+// underscore. Mirrors nvim treating accented Latin and CJK as word characters,
+// unlike the ASCII-only `\w`.
+const WORD_CHAR_PATTERN = /[\p{L}\p{N}\p{M}_]/u;
+
+function isWordChar(ch: string): boolean {
+  return WORD_CHAR_PATTERN.test(ch);
+}
+
+function pairKind(ch?: string): MatchingPairKind | null {
+  return ch === '(' || ch === ')'
+    ? '()'
+    : ch === '[' || ch === ']'
+      ? '[]'
+      : ch === '{' || ch === '}'
+        ? '{}'
+        : null;
+}
+
+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;
+
+  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 = 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.start; index < bounds.end; index++) {
+    if (text[index] !== quote || isEscapedDelimiter(text, index)) continue;
+
+    if (openIndex === null) {
+      openIndex = index;
+      continue;
+    }
+
+    if (openIndex <= cursor && cursor <= index) {
+      if (bestPair === null || index - openIndex < bestPair.close - bestPair.open) {
+        bestPair = { open: openIndex, close: index };
+      }
+    }
+    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);
+  let bestPair = null as { open: number; close: number } | null;
+
+  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;
+
+  if (kind === 'i') {
+    return {
+      startAbs: bestPair.open + 1,
+      endAbs: bestPair.close,
+    };
+  }
+
+  return {
+    startAbs: bestPair.open,
+    endAbs: bestPair.close + 1,
+  };
+}
+
+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,
+  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;
+
+  // Classify by grapheme (keyed on the grapheme's first code point), not by a
+  // single UTF-16 code unit. Indexing `line[idx]` splits astral letters — a
+  // lone surrogate half fails the `\p{L}` keyword test and scores as
+  // punctuation (`a𐐀b` becomes three runs) — and detaches a base character
+  // from its trailing combining marks, so an emoji plus variation selector
+  // (`☕️`) breaks into a symbol run and a mark run. nvim keeps each grapheme in
+  // one class run; classifying the grapheme's leading code point and stamping
+  // that class across the grapheme's UTF-16 offsets reproduces that while the
+  // returned ranges stay in UTF-16 offsets.
+  const classByOffset = new Int8Array(line.length).fill(-1);
+  for (const { start: gStart, end: gEnd } of getLineGraphemes(line)) {
+    const codePoint = line.codePointAt(gStart);
+    const ch = codePoint === undefined ? '' : String.fromCodePoint(codePoint);
+    // A newline (only ever its own grapheme) stays a -1 boundary sentinel.
+    if (ch === '' || ch === '\n') continue;
+    const cls: WordCharClass = /\s/.test(ch)
+      ? 0
+      : semanticClass === 'WORD'
+        ? 2
+        : isWordChar(ch)
+          ? 2
+          : 1;
+    classByOffset.fill(cls, gStart, gEnd);
+  }
+
+  // Class of the grapheme covering idx within the current logical line, or null
+  // when idx falls outside the line or lands on a newline (a boundary).
+  const classAt = (idx: number): WordCharClass | null => {
+    if (idx < bounds.start || idx >= bounds.end) return null;
+    const cls = classByOffset[idx];
+    return cls === undefined || cls < 0 ? null : (cls as WordCharClass);
+  };
+
+  // Extend `end` over the maximal run of the class starting at `end`.
+  const extendRun = (end: number): number => {
+    const runClass = classAt(end);
+    if (runClass === null) return end;
+    let next = end;
+    while (next < bounds.end && classAt(next) === runClass) next++;
+    return next;
+  };
+
+  const totalCount = normalizeCount(count);
+  const cursorCol0 = Math.max(bounds.start, Math.min(cursor, bounds.end - 1));
+  const cursorClass = classAt(cursorCol0);
+  if (cursorClass === null) return null;
+
+  // The run under the cursor, whatever its class (word, punctuation, or the
+  // whitespace run itself — nvim's `iw`/`aw` select whichever the cursor is on).
+  let start = cursorCol0;
+  while (start > bounds.start && classAt(start - 1) === cursorClass) start--;
+  let end = cursorCol0 + 1;
+  while (end < bounds.end && classAt(end) === cursorClass) end++;
+
+  if (kind === 'i') {
+    // `count` consecutive runs (whitespace runs are counted too), forward.
+    let remaining = totalCount - 1;
+    while (remaining > 0 && end < bounds.end) {
+      end = extendRun(end);
+      remaining--;
+    }
+    // A count that runs out of line before it is satisfied is a no-op in nvim,
+    // not a partial delete (`2diw` on the sole word `foo` preserves the
+    // register); cancel by returning null.
+    if (remaining > 0) return null;
+    return { startAbs: lineStartAbs + start, endAbs: lineStartAbs + end };
+  }
+
+  // kind === "a"
+  if (cursorClass === 0) {
+    // On whitespace: the run plus the following word(s); if there is no
+    // following word at all, there is nothing to select (nvim beeps / no-ops).
+    if (end >= bounds.end) return null;
+    let words = totalCount;
+    while (words > 0 && end < bounds.end) {
+      while (end < bounds.end && classAt(end) === 0) end++;
+      if (end >= bounds.end) break;
+      end = extendRun(end);
+      words--;
+    }
+    // Not enough following words to satisfy the count: no-op (nvim preserves
+    // the register) rather than deleting a partial span.
+    if (words > 0) return null;
+    return { startAbs: lineStartAbs + start, endAbs: lineStartAbs + end };
+  }
+
+  // On a word/punctuation run: `count` non-blank words with the whitespace
+  // between them, then trailing whitespace; if none, leading whitespace.
+  let words = totalCount - 1;
+  while (words > 0 && end < bounds.end) {
+    while (end < bounds.end && classAt(end) === 0) end++;
+    if (end >= bounds.end) break;
+    end = extendRun(end);
+    words--;
+  }
+  // The count reached past the last word: no-op (nvim preserves the register,
+  // e.g. `2daw` on the final word) instead of deleting whatever was collected.
+  if (words > 0) return null;
+
+  if (classAt(end) === 0) {
+    end = extendRun(end); // trailing whitespace
+  } else {
+    while (start > bounds.start && classAt(start - 1) === 0) start--;
+  }
+
+  return { startAbs: lineStartAbs + start, endAbs: lineStartAbs + end };
+}