@pugi/cli 0.1.0-beta.22 → 0.1.0-beta.24

package/dist/core/vim/keymap.js

@@ -0,0 +1,288 @@
+/**
+ * Leak L26 (2026-05-27) — Vim-style modal editing keymap.
+ *
+ * Pure, data-only motion + edit primitives. The TUI layer
+ * (`tui/vim-input.tsx`) maps Ink key events onto these helpers so the
+ * keymap stays trivially testable and the React component stays free
+ * of motion arithmetic.
+ *
+ * Scope (matches the leak research surface for Claude Code `/vim`):
+ *
+ *   Normal-mode motions
+ *     h / j / k / l        → left / down / up / right (j/k are
+ *                            no-ops on a single-line buffer; we keep
+ *                            the kind in the discriminator so the
+ *                            multi-line buffer follow-up can extend
+ *                            without churning the call sites).
+ *     0 / $                → line start / line end
+ *     w / b                → word forward / word backward
+ *
+ *   Normal-mode edits
+ *     x                    → delete the char under the cursor
+ *     dd                   → delete the entire line (clears the buffer
+ *                            for the single-line REPL prompt)
+ *     i / a                → enter insert mode (`a` advances cursor by
+ *                            one column first, capped at line length)
+ *
+ *   Ex-line commands (typed after `:` in normal mode)
+ *     :w                   → submit current buffer (same as Enter in
+ *                            insert mode)
+ *     :q                   → clear buffer + return to prompt (no
+ *                            submission)
+ *
+ *   Mode transitions
+ *     Esc                  → return to normal mode
+ *     i / a in normal      → insert mode
+ *
+ * The motion helpers return both the new cursor position AND a
+ * structured discriminator so the TUI layer can react (e.g. animate
+ * the caret, log an undo entry, etc.) without re-parsing the key.
+ *
+ * The keymap is intentionally NOT a full vim implementation. We model
+ * just the subset that maps cleanly onto a single-line input buffer +
+ * the four REPL verbs (submit / cancel / accept-insert / leave-insert).
+ * Counts (`3dd`, `5j`), registers, marks, search (`/pattern`), visual
+ * mode, undo/redo, and macros are explicitly out of scope and left
+ * for a follow-up sprint once the single-line surface is shipped.
+ */
+export const PENDING_NONE = { kind: 'none' };
+/**
+ * Whitespace classifier used by `w` / `b`. Matches vim's default
+ * "word" classification loosely — treat any non-whitespace, non-
+ * punctuation byte as a word character; collapse runs.
+ *
+ * We DELIBERATELY do not split on punctuation the way vim's `w`/`b`
+ * do (`hello-world` is two words in vim but one here). The REPL
+ * brief is prose-heavy and operators expect `w` to skip whole tokens
+ * — splitting on punctuation surprised every internal tester.
+ */
+function isWordChar(ch) {
+    return /[^\s]/.test(ch);
+}
+/**
+ * Move cursor forward by one word: skip the current run of word
+ * chars, then skip the run of whitespace, land on the first char of
+ * the next word. Clamps at `line.length` so end-of-line is safe.
+ */
+export function wordForward(line, cursor) {
+    if (cursor >= line.length)
+        return line.length;
+    let i = cursor;
+    // Skip current word chars (if we're on one).
+    while (i < line.length && isWordChar(line[i] ?? ''))
+        i++;
+    // Skip whitespace gap.
+    while (i < line.length && !isWordChar(line[i] ?? ''))
+        i++;
+    return i;
+}
+/**
+ * Move cursor backward by one word: step back over whitespace, then
+ * step back over the previous word. Clamps at 0.
+ */
+export function wordBackward(line, cursor) {
+    if (cursor <= 0)
+        return 0;
+    let i = cursor - 1;
+    // Skip whitespace behind cursor.
+    while (i > 0 && !isWordChar(line[i] ?? ''))
+        i--;
+    // Skip the word until we hit whitespace or start.
+    while (i > 0 && isWordChar(line[i - 1] ?? ''))
+        i--;
+    return i;
+}
+/**
+ * Single-character delete under the cursor (`x`). When the cursor sits
+ * past end-of-line (legal in insert mode) we no-op.
+ *
+ * The cursor stays at the same offset after the splice unless the
+ * deleted char was the trailing one — in which case we step back so
+ * the caret does not sit past EOL.
+ */
+function deleteCharUnder(line, cursor) {
+    if (cursor < 0 || cursor >= line.length)
+        return { line, cursor };
+    const next = line.slice(0, cursor) + line.slice(cursor + 1);
+    const nextCursor = cursor >= next.length ? Math.max(0, next.length - (next.length === 0 ? 0 : 1)) : cursor;
+    // Subtle: when the deletion empties the buffer we want cursor=0,
+    // NOT length-1=−1. The Math.max above guards it but spell it out.
+    return { line: next, cursor: next.length === 0 ? 0 : nextCursor };
+}
+/**
+ * Apply a normal-mode keystroke and return the new buffer + cursor +
+ * mode + pending state. Pure — no side effects. The TUI is the only
+ * caller; tests exercise this directly.
+ */
+export function handleNormalKey(input) {
+    const { line, cursor, pending, ch } = input;
+    // Esc resets any in-flight multi-key sequence and re-asserts normal
+    // mode (we stay in normal — the caller invoked us BECAUSE we are in
+    // normal, but a stale `pending=d` should not survive an Esc).
+    if (input.escape) {
+        return {
+            result: { kind: 'noop', cursor, line, mode: 'normal' },
+            pending: PENDING_NONE,
+        };
+    }
+    // ─── Ex-line composition ───────────────────────────────────────
+    // Once `:` has been pressed we accumulate keystrokes into the
+    // pending buffer until Enter (commit) or Esc (cancel, handled
+    // above). Backspace shortens the buffer; any other char extends.
+    if (pending.kind === 'ex') {
+        if (input.enter) {
+            const cmd = pending.buffer;
+            if (cmd === 'w') {
+                return {
+                    result: { kind: 'submit', cursor, line, mode: 'normal', payload: line },
+                    pending: PENDING_NONE,
+                };
+            }
+            if (cmd === 'q') {
+                return {
+                    result: { kind: 'cancel', cursor: 0, line: '', mode: 'normal' },
+                    pending: PENDING_NONE,
+                };
+            }
+            // Unknown ex command — drop silently. The TUI may surface a
+            // dim hint but the keymap stays narrow (only `:w` / `:q` are
+            // contractual today).
+            return {
+                result: { kind: 'noop', cursor, line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        }
+        if (input.backspace) {
+            const nextBuf = pending.buffer.slice(0, -1);
+            if (nextBuf.length === 0) {
+                // Operator backspaced past `:` — exit ex composition.
+                return {
+                    result: { kind: 'noop', cursor, line, mode: 'normal' },
+                    pending: PENDING_NONE,
+                };
+            }
+            return {
+                result: { kind: 'noop', cursor, line, mode: 'normal' },
+                pending: { kind: 'ex', buffer: nextBuf },
+            };
+        }
+        if (ch.length > 0) {
+            return {
+                result: { kind: 'noop', cursor, line, mode: 'normal' },
+                pending: { kind: 'ex', buffer: pending.buffer + ch },
+            };
+        }
+        return {
+            result: { kind: 'noop', cursor, line, mode: 'normal' },
+            pending,
+        };
+    }
+    // ─── Single-shot bindings ──────────────────────────────────────
+    switch (ch) {
+        case 'i':
+            return {
+                result: { kind: 'mode', cursor, line, mode: 'insert' },
+                pending: PENDING_NONE,
+            };
+        case 'a': {
+            // `a` = append: advance cursor by one (capped) then enter
+            // insert. Matches vim semantics for the single-line case.
+            const next = Math.min(line.length, cursor + 1);
+            return {
+                result: { kind: 'mode', cursor: next, line, mode: 'insert' },
+                pending: PENDING_NONE,
+            };
+        }
+        case 'h':
+            return {
+                result: { kind: 'move', cursor: Math.max(0, cursor - 1), line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        case 'l':
+            return {
+                result: { kind: 'move', cursor: Math.min(line.length, cursor + 1), line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        case 'j':
+        case 'k':
+            // Single-line buffer — j/k are inert today. Returning a `move`
+            // keeps the discriminator consistent; the multi-line follow-up
+            // will compute a real new offset here.
+            return {
+                result: { kind: 'move', cursor, line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        case '0':
+            return {
+                result: { kind: 'move', cursor: 0, line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        case '$':
+            return {
+                result: { kind: 'move', cursor: line.length, line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        case 'w':
+            return {
+                result: { kind: 'move', cursor: wordForward(line, cursor), line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        case 'b':
+            return {
+                result: { kind: 'move', cursor: wordBackward(line, cursor), line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        case 'x': {
+            const { line: nextLine, cursor: nextCursor } = deleteCharUnder(line, cursor);
+            return {
+                result: { kind: 'edit', cursor: nextCursor, line: nextLine, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+        }
+        case 'd': {
+            // First `d` arms the dd sequence; second `d` commits the line
+            // delete. Any other key intervenes the sequence collapses
+            // (handled below in the fall-through path).
+            if (pending.kind === 'd') {
+                return {
+                    result: { kind: 'edit', cursor: 0, line: '', mode: 'normal' },
+                    pending: PENDING_NONE,
+                };
+            }
+            return {
+                result: { kind: 'noop', cursor, line, mode: 'normal' },
+                pending: { kind: 'd' },
+            };
+        }
+        case ':':
+            return {
+                result: { kind: 'noop', cursor, line, mode: 'normal' },
+                pending: { kind: 'ex', buffer: '' },
+            };
+        default:
+            // Unknown binding in normal mode — drop the keystroke + reset
+            // any pending sequence so a stale `d` does not silently arm a
+            // future delete after the operator wandered through unbound
+            // keys.
+            return {
+                result: { kind: 'noop', cursor, line, mode: 'normal' },
+                pending: PENDING_NONE,
+            };
+    }
+}
+/**
+ * Tiny helper exposed for the TUI so the banner / status line can
+ * render the active pending state without re-implementing the
+ * discriminator switch.
+ */
+export function describePending(pending) {
+    switch (pending.kind) {
+        case 'none':
+            return '';
+        case 'd':
+            return 'd';
+        case 'ex':
+            return `:${pending.buffer}`;
+    }
+}
+//# sourceMappingURL=keymap.js.map

package/dist/core/vim/state.js

@@ -0,0 +1,92 @@
+/**
+ * Leak L26 (2026-05-27) — Vim mode preference persistence.
+ *
+ * Single-tier storage (user-only, `~/.pugi/config.json`):
+ *
+ *   `{ ..., "vimMode": true }`
+ *
+ * The leak research shows Claude Code persists `/vim` as a user-level
+ * preference (not per-workspace) — vim-style editing is a body-memory
+ * trait of the operator, not a per-repo concern. We match that.
+ *
+ * Reader tolerances mirror `core/output-style/state.ts`:
+ *   - missing file        → returns `false` (vim mode off, the default)
+ *   - empty file          → returns `false`
+ *   - malformed JSON      → returns `false` (REPL must not crash on a
+ *                            hand-edited config)
+ *   - non-boolean         → returns `false`
+ *
+ * Writer is a read-modify-write — neighbouring keys (`outputStyle`,
+ * `permissionMode`, …) survive a vim-mode flip.
+ *
+ * File mode 0o600 mirrors `core/output-style/state.ts` so the same
+ * config does not silently downgrade its permission bits depending on
+ * which helper last touched it.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, resolve } from 'node:path';
+/**
+ * Env override for `~/.pugi`. Re-uses the same `PUGI_HOME` knob as
+ * the output-style helpers so test sandboxes are uniform.
+ */
+export const PUGI_HOME_ENV = 'PUGI_HOME';
+/** Default when the file is missing / malformed / does not set the key. */
+export const VIM_MODE_DEFAULT = false;
+/**
+ * Read the persisted vim-mode preference. Pure read, never throws —
+ * every IO failure path degrades to `VIM_MODE_DEFAULT`.
+ */
+export function resolveVimMode(io = {}) {
+    const config = readConfigFile(userConfigPath(io.env ?? process.env));
+    return typeof config.vimMode === 'boolean' ? config.vimMode : VIM_MODE_DEFAULT;
+}
+/**
+ * Write the vim-mode preference. Read-modify-write so neighbouring
+ * config keys survive (`outputStyle`, `permissionMode`, …).
+ */
+export function setVimMode(value, io = {}) {
+    const path = userConfigPath(io.env ?? process.env);
+    const config = readConfigFile(path);
+    config.vimMode = value;
+    writeConfigFile(path, config);
+}
+/**
+ * Path resolver exported for the spec; production callers should use
+ * `resolveVimMode` / `setVimMode`.
+ */
+export function userConfigPath(env = process.env) {
+    const home = env[PUGI_HOME_ENV] ?? resolve(homedir(), '.pugi');
+    return resolve(home, 'config.json');
+}
+function readConfigFile(path) {
+    if (!existsSync(path))
+        return {};
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch {
+        return {};
+    }
+    if (raw.trim().length === 0)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return {};
+    return parsed;
+}
+function writeConfigFile(path, config) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, {
+        encoding: 'utf8',
+        mode: 0o600,
+    });
+}
+//# sourceMappingURL=state.js.map