rl-rockcli 0.0.9 → 0.0.11

package/commands/attach/ink-repl/shortcuts/defaultKeybindings.js

@@ -0,0 +1,138 @@
+/**
+ * Default keybindings for attach REPL
+ *
+ * This module defines the default key bindings and their display labels.
+ * Users can override these in ~/.rock/settings.json under attach.keybindings
+ */
+
+/**
+ * Default keybindings configuration
+ * Each action maps to an array of key combinations
+ */
+export const DEFAULT_KEYBINDINGS = {
+  // Global actions
+  exit: ['ctrl+c', 'ctrl+d'],
+  cancelExecution: ['escape'],
+  toggleConsole: ['f12'],
+  // toggleMouseCapture: ['f11'], // REMOVED - mouse always enabled
+  viewOutput: ['ctrl+v'],
+  copyLastOutput: ['ctrl+y'],
+
+  // History navigation
+  historyUp: ['up'],
+  historyDown: ['down'],
+
+  // Editing
+  deleteWord: ['alt+backspace', 'meta+backspace'],
+
+  // Completion
+  autoComplete: ['tab'],
+
+  // Command submission
+  submit: ['enter'],
+
+  // Menu actions
+  closeMenu: ['escape'],
+  menuConfirm: ['enter', 'tab'],
+  menuUp: ['up'],
+  menuDown: ['down'],
+
+  // Detail view actions
+  detailScrollUp: ['up', 'k'],
+  detailScrollDown: ['down', 'j'],
+  detailExit: ['escape'],
+
+  // Console actions
+  consoleScrollUp: ['pageup'],
+  consoleScrollDown: ['pagedown'],
+};
+
+/**
+ * Display labels for key names
+ * Used to generate human-readable hints in StatusBar
+ */
+export const KEY_LABELS = {
+  'ctrl+c': 'ctrl+c',
+  'ctrl+d': 'ctrl+d',
+  'ctrl+v': 'ctrl+v',
+  'ctrl+y': 'ctrl+y',
+  'alt+backspace': 'alt+⌫',
+  'meta+backspace': 'opt+⌫',
+  'pageup': 'PgUp',
+  'pagedown': 'PgDn',
+  'f1': 'F1',
+  'f2': 'F2',
+  'f3': 'F3',
+  'f4': 'F4',
+  'f5': 'F5',
+  'f6': 'F6',
+  'f7': 'F7',
+  'f8': 'F8',
+  'f9': 'F9',
+  'f10': 'F10',
+  'f11': 'F11',
+  'f12': 'F12',
+  'enter': '⏎',
+  'tab': '⇥',
+  'escape': 'esc',
+  'up': '↑',
+  'down': '↓',
+  'left': '←',
+  'right': '→',
+  'space': 'space',
+  'backspace': '⌫',
+  'delete': '⌦',
+};
+
+/**
+ * Function key escape sequences (xterm/VT style)
+ * Maps raw terminal escape sequences to key names
+ */
+export const FN_KEY_SEQUENCES = {
+  '\x1b[11~': 'f1',
+  '\x1b[12~': 'f2',
+  '\x1b[13~': 'f3',
+  '\x1b[14~': 'f4',
+  '\x1b[15~': 'f5',
+  '\x1b[17~': 'f6',
+  '\x1b[18~': 'f7',
+  '\x1b[19~': 'f8',
+  '\x1b[20~': 'f9',
+  '\x1b[21~': 'f10',
+  '\x1b[23~': 'f11',
+  '\x1b[24~': 'f12',
+  // Alternative sequences (some terminals)
+  '\x1bOP': 'f1',
+  '\x1bOQ': 'f2',
+  '\x1bOR': 'f3',
+  '\x1bOS': 'f4',
+  // Page Up/Down
+  '\x1b[5~': 'pageup',
+  '\x1b[6~': 'pagedown',
+};
+
+/**
+ * Action descriptions for help text
+ */
+export const ACTION_DESCRIPTIONS = {
+  exit: 'Exit',
+  cancelExecution: 'Cancel execution',
+  toggleConsole: 'Toggle console',
+  // toggleMouseCapture: 'Toggle mouse capture', // REMOVED - always enabled
+  viewOutput: 'View full output',
+  copyLastOutput: 'Copy last output',
+  historyUp: 'Previous command',
+  historyDown: 'Next command',
+  deleteWord: 'Delete word',
+  autoComplete: 'Auto-complete',
+  submit: 'Submit command',
+  closeMenu: 'Close menu',
+  menuConfirm: 'Confirm selection',
+  menuUp: 'Move up',
+  menuDown: 'Move down',
+  detailScrollUp: 'Scroll up',
+  detailScrollDown: 'Scroll down',
+  detailExit: 'Exit detail view',
+  consoleScrollUp: 'Scroll console up',
+  consoleScrollDown: 'Scroll console down',
+};

package/commands/attach/ink-repl/shortcuts/index.js

@@ -0,0 +1,332 @@
+/**
+ * Keybinding Manager for attach REPL
+ *
+ * Provides configurable keyboard shortcuts with user customization support.
+ * Settings are stored in ~/.rock/settings.json under attach.keybindings
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+
+import {
+  DEFAULT_KEYBINDINGS,
+  KEY_LABELS,
+  FN_KEY_SEQUENCES,
+} from './defaultKeybindings.js';
+
+const CONFIG_PATH = path.join(os.homedir(), '.rock', 'settings.json');
+
+/**
+ * KeybindingManager class
+ * Manages keybindings with support for user customization
+ */
+export class KeybindingManager {
+  constructor() {
+    this.keybindings = null;
+  }
+
+  /**
+   * Load keybindings from config file, merged with defaults
+   * @returns {Object} Merged keybindings
+   */
+  loadKeybindings() {
+    if (this.keybindings) {
+      return this.keybindings;
+    }
+
+    let userBindings = {};
+
+    try {
+      if (fs.existsSync(CONFIG_PATH)) {
+        const config = fs.readJsonSync(CONFIG_PATH);
+        if (config.attach && config.attach.keybindings) {
+          userBindings = config.attach.keybindings;
+        }
+      }
+    } catch (error) {
+      // Ignore config read errors, use defaults
+    }
+
+    // Merge: user bindings override defaults
+    this.keybindings = {
+      ...DEFAULT_KEYBINDINGS,
+      ...userBindings,
+    };
+
+    return this.keybindings;
+  }
+
+  /**
+   * Get keybindings (load if not already loaded)
+   * @returns {Object} Current keybindings
+   */
+  getKeybindings() {
+    if (!this.keybindings) {
+      this.loadKeybindings();
+    }
+    return this.keybindings;
+  }
+
+  /**
+   * Normalize a key string to lowercase
+   * @param {string} key Key string
+   * @returns {string} Normalized key
+   */
+  normalizeKey(key) {
+    return key.toLowerCase();
+  }
+
+  /**
+   * Parse ink useInput (input, key) into a normalized key string
+   * @param {string} input The input character
+   * @param {Object} key The key object from useInput
+   * @returns {string} Normalized key string like 'ctrl+c', 'up', 'enter'
+   */
+  parseInkKey(input, key) {
+    // Handle special keys
+    if (key.return) return 'enter';
+    if (key.escape) return 'escape';
+    if (key.tab) return 'tab';
+    if (key.upArrow) return 'up';
+    if (key.downArrow) return 'down';
+    if (key.leftArrow) return 'left';
+    if (key.rightArrow) return 'right';
+
+    // Handle meta/alt + backspace (Option+Delete on macOS)
+    if ((key.meta || key.alt) && (key.backspace || key.delete)) {
+      return 'meta+backspace';
+    }
+
+    // Handle regular backspace
+    if (key.backspace || key.delete) return 'backspace';
+
+    // Handle Ctrl+D (EOT character)
+    if (input === '\u0004') return 'ctrl+d';
+
+    // Handle ctrl/meta combinations
+    if (key.ctrl && input) {
+      return `ctrl+${input.toLowerCase()}`;
+    }
+    if ((key.meta || key.alt) && input) {
+      return `meta+${input.toLowerCase()}`;
+    }
+
+    // Regular character
+    if (input) {
+      return input.toLowerCase();
+    }
+
+    return '';
+  }
+
+  /**
+   * Check if useInput matches an action
+   * @param {string} action Action name (e.g., 'exit', 'submit')
+   * @param {string} input The input from useInput
+   * @param {Object} key The key object from useInput
+   * @returns {boolean} True if matches
+   */
+  matchesAction(action, input, key) {
+    const bindings = this.getKeybindings();
+    const actionKeys = bindings[action];
+
+    if (!actionKeys || !Array.isArray(actionKeys)) {
+      return false;
+    }
+
+    const parsedKey = this.parseInkKey(input, key);
+    return actionKeys.some(k => this.normalizeKey(k) === parsedKey);
+  }
+
+  /**
+   * Parse raw terminal input for function keys
+   * @param {string} rawInput Raw terminal input
+   * @returns {string|null} Function key name or null
+   */
+  parseFunctionKey(rawInput) {
+    return FN_KEY_SEQUENCES[rawInput] || null;
+  }
+
+  /**
+   * Check if a function key matches an action
+   * @param {string} action Action name
+   * @param {string} rawInput Raw terminal input
+   * @returns {boolean} True if matches
+   */
+  matchesFunctionKeyAction(action, rawInput) {
+    const bindings = this.getKeybindings();
+    const actionKeys = bindings[action];
+
+    if (!actionKeys || !Array.isArray(actionKeys)) {
+      return false;
+    }
+
+    const fnKey = this.parseFunctionKey(rawInput);
+    if (!fnKey) {
+      return false;
+    }
+
+    return actionKeys.some(k => this.normalizeKey(k) === fnKey);
+  }
+
+  /**
+   * Get the display label for a key
+   * @param {string} key Key string
+   * @returns {string} Display label
+   */
+  getKeyLabel(key) {
+    const normalized = this.normalizeKey(key);
+    return KEY_LABELS[normalized] || key.toUpperCase();
+  }
+
+  /**
+   * Get display labels for an action's first key
+   * @param {string} action Action name
+   * @returns {string} Display label for the first bound key
+   */
+  getActionKeyLabel(action) {
+    const bindings = this.getKeybindings();
+    const actionKeys = bindings[action];
+
+    if (!actionKeys || actionKeys.length === 0) {
+      return '';
+    }
+
+    return this.getKeyLabel(actionKeys[0]);
+  }
+
+  /**
+   * Get keyboard hints for StatusBar based on current mode and state
+   * @param {string} mode Current mode ('repl' or 'detail')
+   * @param {Object} state Current state object
+   * @returns {string} Formatted hint string
+   */
+  getKeyHints(mode, state = {}) {
+    const { menuVisible, isExecuting, consoleVisible } = state;
+
+    if (mode === 'detail') {
+      const upKey = this.getActionKeyLabel('detailScrollUp');
+      const downKey = this.getActionKeyLabel('detailScrollDown');
+      const exitKey = this.getActionKeyLabel('detailExit');
+      const consoleKey = this.getActionKeyLabel('toggleConsole');
+      return `${upKey}${downKey}/wheel scroll  ${exitKey} back  ${consoleKey} console`;
+    }
+
+    if (isExecuting) {
+      const exitKey = this.getActionKeyLabel('exit');
+      const consoleKey = this.getActionKeyLabel('toggleConsole');
+      return `${exitKey} cancel  ${consoleKey} console`;
+    }
+
+    if (menuVisible) {
+      const upKey = this.getActionKeyLabel('menuUp');
+      const downKey = this.getActionKeyLabel('menuDown');
+      const confirmKey = this.getActionKeyLabel('menuConfirm');
+      const closeKey = this.getActionKeyLabel('closeMenu');
+      return `${upKey}${downKey} select  ${confirmKey} confirm  ${closeKey} close`;
+    }
+
+    if (consoleVisible) {
+      const consoleKey = this.getActionKeyLabel('toggleConsole');
+      const exitKey = this.getActionKeyLabel('exit');
+      return `${consoleKey} hide console  ${exitKey} exit`;
+    }
+
+    // Default REPL mode
+    const historyUpKey = this.getActionKeyLabel('historyUp');
+    const historyDownKey = this.getActionKeyLabel('historyDown');
+    const copyKey = this.getActionKeyLabel('copyLastOutput');
+    const consoleKey = this.getActionKeyLabel('toggleConsole');
+    const scrollUpKey = this.getActionKeyLabel('consoleScrollUp');
+    const scrollDownKey = this.getActionKeyLabel('consoleScrollDown');
+    const exitKey = this.getActionKeyLabel('exit');
+    return `/ cmds  ${historyUpKey}${historyDownKey} history  ${copyKey} copy  ${consoleKey} console  ${scrollUpKey}${scrollDownKey} scroll/wheel  ${exitKey} exit`;
+  }
+
+  /**
+   * Save custom keybindings to config file
+   * @param {Object} keybindings Keybindings to save
+   * @returns {boolean} Success status
+   */
+  saveKeybindings(keybindings) {
+    try {
+      let config = {};
+
+      if (fs.existsSync(CONFIG_PATH)) {
+        config = fs.readJsonSync(CONFIG_PATH);
+      }
+
+      if (!config.attach) {
+        config.attach = {};
+      }
+
+      config.attach.keybindings = keybindings;
+
+      // Ensure directory exists
+      const configDir = path.dirname(CONFIG_PATH);
+      if (!fs.existsSync(configDir)) {
+        fs.mkdirpSync(configDir);
+      }
+
+      fs.writeJsonSync(CONFIG_PATH, config, { spaces: 2 });
+
+      // Update cached keybindings
+      this.keybindings = {
+        ...DEFAULT_KEYBINDINGS,
+        ...keybindings,
+      };
+
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Reset keybindings to defaults (removes user customizations)
+   * @returns {boolean} Success status
+   */
+  resetToDefaults() {
+    try {
+      if (fs.existsSync(CONFIG_PATH)) {
+        const config = fs.readJsonSync(CONFIG_PATH);
+
+        if (config.attach && config.attach.keybindings) {
+          delete config.attach.keybindings;
+
+          // Clean up empty attach object
+          if (Object.keys(config.attach).length === 0) {
+            delete config.attach;
+          }
+
+          fs.writeJsonSync(CONFIG_PATH, config, { spaces: 2 });
+        }
+      }
+
+      // Reset cached keybindings to defaults
+      this.keybindings = { ...DEFAULT_KEYBINDINGS };
+
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Reload keybindings from config (useful after external changes)
+   * @returns {Object} Reloaded keybindings
+   */
+  reloadKeybindings() {
+    this.keybindings = null;
+    return this.loadKeybindings();
+  }
+}
+
+// Singleton instance
+export const keybindingManager = new KeybindingManager();
+
+export default keybindingManager;
+
+// Re-export constants for convenience
+export { DEFAULT_KEYBINDINGS, KEY_LABELS, FN_KEY_SEQUENCES } from './defaultKeybindings.js';

package/commands/attach/ink-repl/themes/defaultDark.js

@@ -0,0 +1,18 @@
+import { createTheme, defaultGradient } from './themeTokens.js';
+
+export const DefaultDark = createTheme('rock-dark', {
+  background: '#1e1e2e',
+  surface: '#181825',
+  surfaceHighlight: '#11111b',
+  border: '#313244',
+  textPrimary: '#cdd6f4',
+  textSecondary: '#a6adc8',
+  accent: '#89b4fa',
+  accentMuted: '#b4befe',
+  warning: '#f9e2af',
+  success: '#a6e3a1',
+  danger: '#f38ba8',
+  prompt: '#89dceb',
+  cursor: '#cdd6f4',
+  gradient: defaultGradient,
+});

package/commands/attach/ink-repl/themes/defaultLight.js

@@ -0,0 +1,18 @@
+import { createTheme, defaultGradient } from './themeTokens.js';
+
+export const DefaultLight = createTheme('rock-light', {
+  background: '#fafafa',
+  surface: '#ffffff',
+  surfaceHighlight: '#f3f4f6',
+  border: '#d0d7de',
+  textPrimary: '#1f2328',
+  textSecondary: '#4c566a',
+  accent: '#4796e4',
+  accentMuted: '#c3677f',
+  warning: '#bf6500',
+  success: '#1a7f37',
+  danger: '#b62324',
+  prompt: '#0a3069',
+  cursor: '#1f2328',
+  gradient: defaultGradient,
+});

package/commands/attach/ink-repl/themes/index.js

@@ -0,0 +1,4 @@
+export { themeManager } from './themeManager.js';
+export { DefaultDark } from './defaultDark.js';
+export { DefaultLight } from './defaultLight.js';
+export { DEFAULT_THEME_NAME } from './themeTokens.js';

package/commands/attach/ink-repl/themes/themeManager.js

@@ -0,0 +1,45 @@
+import { DEFAULT_THEME_NAME } from './themeTokens.js';
+import { DefaultDark } from './defaultDark.js';
+import { DefaultLight } from './defaultLight.js';
+
+const BUILTIN_THEMES = [DefaultDark, DefaultLight];
+
+class ThemeManager {
+  constructor() {
+    this.themes = new Map();
+    BUILTIN_THEMES.forEach(theme => {
+      this.themes.set(theme.name, theme);
+    });
+    this.activeThemeName = DEFAULT_THEME_NAME;
+  }
+
+  getActiveTheme() {
+    return this.themes.get(this.activeThemeName) || DefaultDark;
+  }
+
+  getTheme(name) {
+    return this.themes.get(name);
+  }
+
+  listThemes() {
+    return Array.from(this.themes.values()).map(theme => ({
+      name: theme.name,
+      type: theme.type,
+    }));
+  }
+
+  registerTheme(theme) {
+    if (!theme || !theme.name) return;
+    this.themes.set(theme.name, theme);
+  }
+
+  setActiveTheme(name) {
+    if (this.themes.has(name)) {
+      this.activeThemeName = name;
+      return true;
+    }
+    return false;
+  }
+}
+
+export const themeManager = new ThemeManager();

package/commands/attach/ink-repl/themes/themeTokens.js

@@ -0,0 +1,15 @@
+export const DEFAULT_THEME_NAME = 'rock-dark';
+
+export function createTheme(name, colors, type = 'default') {
+  return {
+    name,
+    type,
+    colors,
+    semantic: {
+      banner: colors.gradient || defaultGradient,
+    },
+  };
+}
+
+// Logo/banner gradient aligned with web (blue → indigo → purple).
+export const defaultGradient = ['#2563EB', '#4F46E5', '#7C3AED'];