@pellux/goodvibes-agent 0.1.0

package/src/input/input-history.ts

@@ -0,0 +1,297 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+
+/**
+ * InputHistory — Persisted command history with arrow-key navigation.
+ *
+ * Navigation model:
+ *   position = -1   : not browsing (at the live draft)
+ *   position = 0    : most recent entry
+ *   position = N-1  : oldest visible entry
+ *
+ * Up arrow goes to older entries (position increases).
+ * Down arrow goes to newer entries (position decreases), then back to draft.
+ */
+export interface HistorySearchMatch {
+  entry: string;
+  matchStart: number;
+  matchLength: number;
+}
+
+export class HistorySearch {
+  active = false;
+  query = '';
+  matches: HistorySearchMatch[] = [];
+  matchIndex = 0;
+  savedDraft = '';
+
+  constructor(private getEntries: () => readonly string[]) {}
+
+  open(draft: string): void {
+    this.active = true;
+    this.savedDraft = draft;
+    this.query = '';
+    this.matches = [];
+    this.matchIndex = 0;
+  }
+
+  search(query: string): void {
+    this.query = query;
+    const q = query.toLowerCase();
+    this.matches = [];
+    if (!q) return;
+    for (const entry of this.getEntries()) {
+      const idx = entry.toLowerCase().indexOf(q);
+      if (idx >= 0) {
+        this.matches.push({ entry, matchStart: idx, matchLength: q.length });
+      }
+    }
+    this.matchIndex = 0;
+  }
+
+  appendChar(ch: string): void {
+    this.search(this.query + ch);
+  }
+
+  deleteChar(): void {
+    if (this.query.length > 0) {
+      this.search(this.query.slice(0, -1));
+    }
+  }
+
+  /** Move to next older match (higher index). */
+  stepOlder(): void {
+    if (this.matches.length > 0 && this.matchIndex < this.matches.length - 1) {
+      this.matchIndex++;
+    }
+  }
+
+  /** Move to next newer match (lower index). */
+  stepNewer(): void {
+    if (this.matchIndex > 0) {
+      this.matchIndex--;
+    }
+  }
+
+  get currentMatch(): HistorySearchMatch | null {
+    return this.matches[this.matchIndex] ?? null;
+  }
+
+  accept(): string {
+    const match = this.currentMatch;
+    this.close();
+    return match?.entry ?? '';
+  }
+
+  cancel(): string {
+    const draft = this.savedDraft;
+    this.close();
+    return draft;
+  }
+
+  private close(): void {
+    this.active = false;
+    this.query = '';
+    this.matches = [];
+    this.matchIndex = 0;
+    this.savedDraft = '';
+  }
+}
+
+export interface InputHistoryOptions {
+  readonly historyPath?: string;
+  readonly userRoot?: string;
+  readonly homeDirectory?: string;
+  readonly persist?: boolean;
+}
+
+type StoredInputHistoryEntry = string | {
+  readonly text: string;
+  readonly recallText?: string;
+};
+
+function resolveHistoryPath(options?: InputHistoryOptions): string {
+  if (options?.historyPath) {
+    return options.historyPath;
+  }
+  const userRoot = options?.userRoot ?? options?.homeDirectory;
+  if (!userRoot) {
+    throw new Error('InputHistory requires historyPath or an explicit userRoot/homeDirectory.');
+  }
+  return join(userRoot, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'input-history.json');
+}
+
+export class InputHistory {
+  private entries: StoredInputHistoryEntry[] = [];
+  private position = -1;  // -1 = not browsing
+  private draft = '';     // Saves current input when entering history
+  private maxEntries = 500;
+  private historyPath: string;
+  private persist: boolean;
+
+  constructor(options: InputHistoryOptions) {
+    this.persist = options.persist ?? true;
+    this.historyPath = resolveHistoryPath(options);
+    if (this.persist) {
+      this.load();
+    }
+  }
+
+  /**
+   * Add a new entry. Called on submit.
+   * - Ignores empty/whitespace-only strings.
+   * - Deduplicates consecutive identical entries.
+   * - Resets browsing position.
+   */
+  add(text: string, options: { readonly recallText?: string } = {}): void {
+    const trimmed = text.trim();
+    if (!trimmed) return;
+    const recallText = options.recallText?.trim();
+    const entry: StoredInputHistoryEntry = recallText && recallText !== trimmed
+      ? { text: trimmed, recallText }
+      : trimmed;
+
+    // Dedup: skip if same as most recent entry
+    if (this.entries.length > 0 && this.sameEntry(this.entries[0]!, entry)) {
+      this.resetPosition();
+      return;
+    }
+
+    this.entries.unshift(entry);
+    if (this.entries.length > this.maxEntries) {
+      this.entries.length = this.maxEntries;
+    }
+
+    this.resetPosition();
+
+    if (this.persist) {
+      this.save();
+    }
+  }
+
+  /**
+   * Navigate up (older entry).
+   * On first call, saves currentInput as draft.
+   * Returns the entry to display, or null if at boundary.
+   */
+  up(currentInput: string): string | null {
+    if (this.entries.length === 0) return null;
+
+    // Save draft on first navigation
+    if (this.position === -1) {
+      this.draft = currentInput;
+    }
+
+    const next = this.position + 1;
+    if (next < this.entries.length) {
+      this.position = next;
+      return this.getRecallText(this.entries[this.position]!);
+    }
+
+    // At oldest boundary
+    return null;
+  }
+
+  /**
+   * Navigate down (newer entry).
+   * Returns newer entry, or draft when reaching the end.
+   * Returns null if not currently browsing.
+   */
+  down(): string | null {
+    if (this.position === -1) return null;
+
+    const prev = this.position - 1;
+    if (prev >= 0) {
+      this.position = prev;
+      return this.getRecallText(this.entries[this.position]!);
+    }
+
+    // Back to draft
+    this.position = -1;
+    return this.draft;
+  }
+
+  /**
+   * Reset browsing position. Called when user types new text.
+   */
+  resetPosition(): void {
+    this.position = -1;
+    this.draft = '';
+  }
+
+  /**
+   * Whether currently browsing history.
+   */
+  get isBrowsing(): boolean {
+    return this.position !== -1;
+  }
+
+  /**
+   * Return entries as readonly for use by HistorySearch.
+   */
+  getEntries(): readonly string[] {
+    return this.entries.map((entry) => this.getRecallText(entry));
+  }
+
+  /**
+   * Save history to disk.
+   */
+  save(): void {
+    try {
+      mkdirSync(dirname(this.historyPath), { recursive: true });
+      writeFileSync(this.historyPath, JSON.stringify(this.entries), 'utf-8');
+    } catch (err) {
+      logger.debug('InputHistory save failed (non-fatal)', { error: summarizeError(err) });
+    }
+  }
+
+  /**
+   * Load history from disk.
+   */
+  load(): void {
+    try {
+      if (existsSync(this.historyPath)) {
+        const raw = readFileSync(this.historyPath, 'utf-8');
+        const parsed = JSON.parse(raw) as unknown;
+        if (Array.isArray(parsed)) {
+          this.entries = (parsed as unknown[])
+            .map((entry) => this.normalizeStoredEntry(entry))
+            .filter((entry): entry is StoredInputHistoryEntry => entry !== null)
+            .slice(0, this.maxEntries);
+        }
+      }
+    } catch (err) {
+      logger.debug('InputHistory load failed (non-fatal, using empty history)', { error: summarizeError(err) });
+      this.entries = [];
+    }
+  }
+
+  private getDisplayText(entry: StoredInputHistoryEntry): string {
+    return typeof entry === 'string' ? entry : entry.text;
+  }
+
+  private getRecallText(entry: StoredInputHistoryEntry): string {
+    return typeof entry === 'string' ? entry : entry.recallText ?? entry.text;
+  }
+
+  private sameEntry(a: StoredInputHistoryEntry, b: StoredInputHistoryEntry): boolean {
+    return this.getDisplayText(a) === this.getDisplayText(b)
+      && this.getRecallText(a) === this.getRecallText(b);
+  }
+
+  private normalizeStoredEntry(entry: unknown): StoredInputHistoryEntry | null {
+    if (typeof entry === 'string') return entry;
+    if (!entry || typeof entry !== 'object') return null;
+    const record = entry as Record<string, unknown>;
+    if (typeof record.text !== 'string') return null;
+    const text = record.text.trim();
+    if (!text) return null;
+    if (typeof record.recallText === 'string' && record.recallText.trim() && record.recallText.trim() !== text) {
+      return { text, recallText: record.recallText.trim() };
+    }
+    return text;
+  }
+}

package/src/input/keybindings.ts

@@ -0,0 +1,292 @@
+/**
+ * KeybindingsManager — loads and merges keyboard shortcut configuration.
+ *
+ * Default bindings are hardcoded here. Users can override any binding by
+ * creating ~/.goodvibes/agent/keybindings.json.
+ *
+ * Config file format example:
+ * {
+ *   "search": { "key": "g", "ctrl": true },
+ *   "block-copy": { "key": "c", "ctrl": true, "alt": true }
+ * }
+ *
+ * Each value is a KeyCombo or an array of KeyCombos for multi-binding support.
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import { resolveSurfaceDirectory } from '@/runtime/index.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+
+/** Identifies a specific key press with modifiers. */
+export interface KeyCombo {
+  /** Logical key name (single char like 'f', or named key like 'r', 'z', 'f2', etc.) */
+  key: string;
+  ctrl?: boolean;
+  shift?: boolean;
+  alt?: boolean;
+}
+
+/** All bindable action identifiers. */
+export type KeyAction =
+  | 'copy-selection'
+  | 'clear-cancel'
+  | 'screen-clear'
+  | 'panel-picker'
+  | 'panel-close'
+  | 'panel-close-all'
+  | 'panel-tab-next'
+  | 'panel-tab-prev'
+  | 'history-search'
+  | 'search'
+  | 'block-copy'
+  | 'bookmark'
+  | 'block-save'
+  | 'delete-word'
+  | 'apply-diff-line-start'
+  | 'next-error-line-end'
+  | 'kill-line'
+  | 'clear-prompt'
+  | 'undo'
+  | 'redo'
+  | 'paste'
+  | 'replay-panel';
+
+/** Human-readable description for each action (used in /keybindings display). */
+export const ACTION_DESCRIPTIONS: Record<KeyAction, string> = {
+  'copy-selection':        'Copy selected text to clipboard',
+  'clear-cancel':          'Clear input / cancel generation / exit (double)',
+  'screen-clear':          'Repaint the screen',
+  'panel-picker':          'Open, focus, or hide the panel workspace',
+  'panel-close':            'Close the currently active panel',
+  'panel-close-all':         'Close all open panels',
+  'panel-tab-next':        'Next workspace panel tab',
+  'panel-tab-prev':        'Previous workspace panel tab',
+  'history-search':        'Reverse input history search',
+  'search':                'Toggle conversation search',
+  'block-copy':            'Copy nearest block to clipboard',
+  'bookmark':              'Bookmark / unbookmark nearest block',
+  'block-save':            'Save nearest block to file',
+  'delete-word':           'Delete word backward',
+  'apply-diff-line-start': 'Apply nearest diff / move to line start',
+  'next-error-line-end':   'Navigate to next error / move to line end',
+  'kill-line':             'Kill to end of line',
+  'clear-prompt':          'Clear the prompt',
+  'undo':                  'Undo last prompt edit',
+  'redo':                  'Redo last undone edit',
+  'paste':                 'Paste from clipboard (image priority)',
+  'replay-panel':          'Open / close the Replay panel',
+};
+
+/** Default key bindings for all actions. */
+export const DEFAULT_KEYBINDINGS: Record<KeyAction, KeyCombo[]> = {
+  'copy-selection':        [{ key: 'c', ctrl: true, shift: true }],
+  'clear-cancel':          [{ key: 'c', ctrl: true }],
+  'screen-clear':          [{ key: 'l', ctrl: true }],
+  'panel-picker':          [{ key: 'p', ctrl: true }],
+  'panel-close':            [{ key: 'x', ctrl: true }],
+  'panel-close-all':         [{ key: 'x', ctrl: true, shift: true }],
+  'panel-tab-next':        [{ key: ']', ctrl: true }],
+  'panel-tab-prev':        [{ key: '[', ctrl: true }],
+  'history-search':        [{ key: 'r', ctrl: true }],
+  'search':                [{ key: 'f', ctrl: true }],
+  'block-copy':            [{ key: 'y', ctrl: true }],
+  'bookmark':              [{ key: 'b', ctrl: true }],
+  'block-save':            [{ key: 's', ctrl: true }],
+  'delete-word':           [{ key: 'w', ctrl: true }],
+  'apply-diff-line-start': [{ key: 'a', ctrl: true }],
+  'next-error-line-end':   [{ key: 'e', ctrl: true }],
+  'kill-line':             [{ key: 'k', ctrl: true }],
+  'clear-prompt':          [{ key: 'u', ctrl: true }],
+  'undo':                  [{ key: 'z', ctrl: true }],
+  'redo':                  [{ key: 'z', ctrl: true, shift: true }],
+  'paste':                 [{ key: 'v', ctrl: true }],
+  'replay-panel':          [{ key: 'r', ctrl: true, shift: true }],
+};
+
+/** Resolved overrides type: each key can be a single combo or array. */
+type KeybindingsFile = Partial<Record<KeyAction, KeyCombo | KeyCombo[]>>;
+
+export interface KeybindingsManagerOptions {
+  readonly configPath?: string;
+  readonly userRoot?: string;
+  readonly homeDirectory?: string;
+  readonly surfaceRoot?: string;
+}
+
+function resolveKeybindingsPath(options?: KeybindingsManagerOptions): string {
+  if (options?.configPath) {
+    return options.configPath;
+  }
+  const userRoot = options?.userRoot ?? options?.homeDirectory;
+  if (!userRoot) {
+    throw new Error('KeybindingsManager requires configPath or an explicit userRoot/homeDirectory.');
+  }
+  if (options?.surfaceRoot) {
+    return resolveSurfaceDirectory(userRoot, options.surfaceRoot, 'keybindings.json');
+  }
+  return join(userRoot, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'keybindings.json');
+}
+
+/**
+ * KeybindingsManager — owns the resolved keybinding table.
+ *
+ * Call loadFromDisk() once at startup (in main.ts) to merge user config.
+ * Then use matches() anywhere a key token is being evaluated.
+ */
+export class KeybindingsManager {
+  private bindings: Record<KeyAction, KeyCombo[]>;
+  private configPath: string;
+  /** Inverted lookup map: composite key → KeyAction. Built in buildLookupMap(). */
+  private lookupMap = new Map<string, KeyAction>();
+
+  constructor(options: KeybindingsManagerOptions) {
+    this.configPath = resolveKeybindingsPath(options);
+    // Start with deep copy of defaults
+    this.bindings = this.cloneDefaults();
+    this.buildLookupMap();
+  }
+
+  private cloneDefaults(): Record<KeyAction, KeyCombo[]> {
+    const result = {} as Record<KeyAction, KeyCombo[]>;
+    for (const [action, combos] of Object.entries(DEFAULT_KEYBINDINGS) as [KeyAction, KeyCombo[]][]) {
+      result[action] = combos.map(c => ({ ...c }));
+    }
+    return result;
+  }
+
+  /**
+   * Load user overrides from disk and merge into the binding table.
+   * Unknown actions are ignored with a debug log. Malformed entries are skipped.
+   * Safe to call multiple times (reloads on each call).
+   */
+  loadFromDisk(): void {
+    if (!existsSync(this.configPath)) return;
+    try {
+      const raw = readFileSync(this.configPath, 'utf-8');
+      const parsed = JSON.parse(raw) as KeybindingsFile;
+      const validActions = new Set(Object.keys(DEFAULT_KEYBINDINGS) as KeyAction[]);
+
+      // Reset to defaults before applying overrides
+      this.bindings = this.cloneDefaults();
+
+      for (const [action, combo] of Object.entries(parsed)) {
+        if (!validActions.has(action as KeyAction)) {
+          logger.debug('keybindings: unknown action, skipping', { action });
+          continue;
+        }
+        const normalized = Array.isArray(combo) ? combo : [combo];
+        if (!this.validateCombos(normalized)) {
+          logger.debug('keybindings: invalid combo for action, skipping', { action, combo });
+          continue;
+        }
+        this.bindings[action as KeyAction] = normalized;
+      }
+      logger.debug('keybindings: loaded overrides from disk', { path: this.configPath });
+    } catch (err) {
+      logger.debug('keybindings: failed to load config file', { path: this.configPath, err: summarizeError(err) });
+    }
+    this.buildLookupMap();
+  }
+
+  /**
+   * buildLookupMap — Rebuild the inverted lookup map from the current bindings table.
+   * Called after constructor init and after loadFromDisk().
+   * Map key format: "logicalName:ctrl:shift:alt" (booleans as 0/1).
+   * Last writer wins for duplicate combos (deterministic: iterate actions in order).
+   */
+  private buildLookupMap(): void {
+    this.lookupMap.clear();
+    for (const [action, combos] of Object.entries(this.bindings) as [KeyAction, KeyCombo[]][]) {
+      for (const combo of combos) {
+        const key = `${combo.key}:${combo.ctrl ? 1 : 0}:${combo.shift ? 1 : 0}:${combo.alt ? 1 : 0}`;
+        this.lookupMap.set(key, action);
+      }
+    }
+  }
+
+  /**
+   * lookup — O(1) keybinding lookup by token.
+   * Returns the matching KeyAction, or null if no binding matches.
+   */
+  lookup(token: { logicalName?: string; ctrl?: boolean; shift?: boolean; alt?: boolean }): KeyAction | null {
+    if (!token.logicalName) return null;
+    const key = `${token.logicalName}:${token.ctrl ? 1 : 0}:${token.shift ? 1 : 0}:${token.alt ? 1 : 0}`;
+    return this.lookupMap.get(key) ?? null;
+  }
+
+  private validateCombos(combos: unknown[]): combos is KeyCombo[] {
+    return combos.every((c) => {
+      if (typeof c !== 'object' || c === null) return false;
+      const combo = c as Record<string, unknown>;
+      return typeof combo['key'] === 'string' && combo['key'].length > 0;
+    });
+  }
+
+  /**
+   * matches — Check whether a keyboard token matches the given action.
+   *
+   * @param action  The action to test.
+   * @param token   The parsed keyboard token from InputTokenizer.
+   *                Expects: { logicalName: string; ctrl?: boolean; shift?: boolean; alt?: boolean }
+   */
+  matches(
+    action: KeyAction,
+    token: { logicalName?: string; ctrl?: boolean; shift?: boolean; alt?: boolean },
+  ): boolean {
+    const combos = this.bindings[action];
+    if (!combos) return false;
+    return combos.some((combo) => this.comboMatches(combo, token));
+  }
+
+  private comboMatches(
+    combo: KeyCombo,
+    token: { logicalName?: string; ctrl?: boolean; shift?: boolean; alt?: boolean },
+  ): boolean {
+    if (token.logicalName !== combo.key) return false;
+    if (!!combo.ctrl !== !!token.ctrl) return false;
+    if (!!combo.shift !== !!token.shift) return false;
+    if (!!combo.alt !== !!token.alt) return false;
+    return true;
+  }
+
+  /**
+   * getAll — Return the full resolved binding table for display purposes.
+   */
+  getAll(): Array<{ action: KeyAction; combos: KeyCombo[]; description: string }> {
+    return (Object.keys(this.bindings) as KeyAction[]).map((action) => ({
+      action,
+      combos: this.bindings[action],
+      description: ACTION_DESCRIPTIONS[action],
+    }));
+  }
+
+  /**
+   * getComboLabel — Return a human-readable label for the first combo of an action.
+   * Example: { key: 'f', ctrl: true } → "Ctrl+F"
+   */
+  getComboLabel(action: KeyAction): string {
+    const combos = this.bindings[action];
+    if (!combos?.length) return '(unbound)';
+    return this.formatCombo(combos[0]);
+  }
+
+  /**
+   * formatCombo — Format a KeyCombo as a human-readable string.
+   */
+  formatCombo(combo: KeyCombo): string {
+    const parts: string[] = [];
+    if (combo.ctrl) parts.push('Ctrl');
+    if (combo.alt) parts.push('Alt');
+    if (combo.shift) parts.push('Shift');
+    parts.push(combo.key.length === 1 ? combo.key.toUpperCase() : combo.key);
+    return parts.join('+');
+  }
+
+  /** Return the config file path. */
+  getConfigPath(): string {
+    return this.configPath;
+  }
+}