@renxqoo/renx-code 0.0.2 → 0.0.4

package/src/hooks/use-slash-command-menu.ts

@@ -0,0 +1,154 @@
+import type { KeyEvent, TextareaRenderable } from '@opentui/core';
+import { useCallback, useEffect, useMemo, useState, type RefObject } from 'react';
+
+import { filterSlashCommands, type SlashCommandDefinition } from '../commands/slash-commands';
+
+type UseSlashCommandMenuParams = {
+  value: string;
+  onValueChange: (value: string) => void;
+  textareaRef: RefObject<TextareaRenderable | null>;
+  onCommandSelected?: (command: SlashCommandDefinition) => boolean;
+  disabled?: boolean;
+};
+
+type UseSlashCommandMenuResult = {
+  visible: boolean;
+  options: SlashCommandDefinition[];
+  selectedIndex: number;
+  handleKeyDown: (event: KeyEvent) => boolean;
+};
+
+const getSlashQuery = (value: string): string | null => {
+  if (!/^\/[^\s]*$/.test(value)) {
+    return null;
+  }
+  return value.slice(1);
+};
+
+export const useSlashCommandMenu = ({
+  value,
+  onValueChange,
+  textareaRef,
+  onCommandSelected,
+  disabled = false,
+}: UseSlashCommandMenuParams): UseSlashCommandMenuResult => {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [dismissedQuery, setDismissedQuery] = useState<string | null>(null);
+
+  const query = useMemo(() => getSlashQuery(value), [value]);
+
+  useEffect(() => {
+    if (query !== dismissedQuery) {
+      return;
+    }
+    setDismissedQuery(null);
+  }, [dismissedQuery, query]);
+
+  const options = useMemo(() => {
+    if (query === null) {
+      return [];
+    }
+    return filterSlashCommands(query);
+  }, [query]);
+
+  const visible = !disabled && query !== null && query !== dismissedQuery && options.length > 0;
+
+  useEffect(() => {
+    setSelectedIndex(0);
+  }, [query]);
+
+  useEffect(() => {
+    if (selectedIndex < options.length) {
+      return;
+    }
+    setSelectedIndex(0);
+  }, [options.length, selectedIndex]);
+
+  const applySelection = useCallback(
+    (index: number) => {
+      const command = options[index];
+      if (!command) {
+        return false;
+      }
+
+      if (onCommandSelected?.(command)) {
+        return true;
+      }
+
+      const nextValue = `/${command.name} `;
+      onValueChange(nextValue);
+
+      const textarea = textareaRef.current;
+      if (textarea) {
+        textarea.setText(nextValue);
+        textarea.cursorOffset = nextValue.length;
+      }
+
+      return true;
+    },
+    [onCommandSelected, onValueChange, options, textareaRef]
+  );
+
+  const moveSelection = useCallback(
+    (step: number) => {
+      if (!visible || options.length === 0) {
+        return;
+      }
+      setSelectedIndex(current => {
+        const total = options.length;
+        const next = (current + step + total) % total;
+        return next;
+      });
+    },
+    [options.length, visible]
+  );
+
+  const handleKeyDown = useCallback(
+    (event: KeyEvent): boolean => {
+      if (!visible) {
+        return false;
+      }
+
+      const name = (event.name ?? '').toLowerCase();
+      const ctrlOnly = !!event.ctrl && !event.shift && !event.meta;
+      const isUp = name === 'up' || (ctrlOnly && name === 'p');
+      const isDown = name === 'down' || (ctrlOnly && name === 'n');
+
+      if (isUp) {
+        moveSelection(-1);
+        event.preventDefault();
+        return true;
+      }
+
+      if (isDown) {
+        moveSelection(1);
+        event.preventDefault();
+        return true;
+      }
+
+      if (name === 'escape') {
+        setDismissedQuery(query);
+        event.preventDefault();
+        return true;
+      }
+
+      if (name === 'return' || name === 'enter' || name === 'tab') {
+        const applied = applySelection(selectedIndex);
+        if (applied) {
+          event.preventDefault();
+          return true;
+        }
+      }
+
+      return false;
+    },
+    [applySelection, moveSelection, query, selectedIndex, visible]
+  );
+
+  return {
+    visible,
+    options,
+    selectedIndex,
+    handleKeyDown,
+  };
+};

package/src/index.tsx

@@ -0,0 +1,55 @@
+import { createCliRenderer } from '@opentui/core';
+import { createRoot } from '@opentui/react';
+
+import { App } from './App';
+import {
+  bindExitGuards,
+  hardResetTerminal,
+  initExitRuntime,
+  registerTerminalBackgroundRestore,
+} from './runtime/exit';
+import {
+  probeTerminalColors,
+  setTerminalWindowBackground,
+  setTerminalWindowForeground,
+} from './runtime/terminal-theme';
+import { applyMarkdownThemeMode } from './ui/opencode-markdown';
+import { applyUiThemeMode, uiTheme } from './ui/theme';
+
+bindExitGuards();
+// OpenTUI exposes OPENTUI_FORCE_WCWIDTH for terminals where CJK width handling
+// is more accurate with wcwidth than the default Unicode capability probe.
+process.env.OPENTUI_FORCE_WCWIDTH ??= '1';
+const terminalColors = await probeTerminalColors();
+applyUiThemeMode(terminalColors.mode);
+applyMarkdownThemeMode(terminalColors.mode, process.platform);
+
+if (
+  terminalColors.rawBackgroundColor &&
+  terminalColors.rawBackgroundColor.toLowerCase() !== uiTheme.bg.toLowerCase()
+) {
+  const originalBackground = terminalColors.rawBackgroundColor;
+  setTerminalWindowBackground(uiTheme.bg);
+  registerTerminalBackgroundRestore(() => {
+    setTerminalWindowBackground(originalBackground);
+  });
+}
+
+if (
+  terminalColors.rawForegroundColor &&
+  terminalColors.rawForegroundColor.toLowerCase() !== uiTheme.userPromptText.toLowerCase()
+) {
+  const originalForeground = terminalColors.rawForegroundColor;
+  setTerminalWindowForeground(uiTheme.userPromptText);
+  registerTerminalBackgroundRestore(() => {
+    setTerminalWindowForeground(originalForeground);
+  });
+}
+
+const renderer = await createCliRenderer({
+  exitOnCtrlC: false,
+  onDestroy: hardResetTerminal,
+  backgroundColor: uiTheme.bg,
+});
+initExitRuntime(renderer);
+createRoot(renderer).render(<App />);

package/src/runtime/clipboard.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'bun:test';
+
+import { getClipboardCommandCandidates } from './clipboard';
+
+describe('clipboard runtime', () => {
+  it('returns pbcopy on macOS', () => {
+    expect(getClipboardCommandCandidates('darwin', {} as NodeJS.ProcessEnv)).toEqual([
+      { command: 'pbcopy', args: [] },
+    ]);
+  });
+
+  it('returns clip on Windows', () => {
+    expect(getClipboardCommandCandidates('win32', {} as NodeJS.ProcessEnv)).toEqual([
+      { command: 'cmd', args: ['/c', 'clip'] },
+    ]);
+  });
+
+  it('prefers Wayland tools when WAYLAND_DISPLAY is present', () => {
+    expect(
+      getClipboardCommandCandidates('linux', {
+        WAYLAND_DISPLAY: 'wayland-0',
+      } as NodeJS.ProcessEnv)
+    ).toEqual([{ command: 'wl-copy', args: [] }]);
+  });
+
+  it('returns X11 candidates when DISPLAY is present', () => {
+    expect(
+      getClipboardCommandCandidates('linux', {
+        DISPLAY: ':0',
+      } as NodeJS.ProcessEnv)
+    ).toEqual([
+      { command: 'xclip', args: ['-selection', 'clipboard'] },
+      { command: 'xsel', args: ['--clipboard', '--input'] },
+      { command: 'wl-copy', args: [] },
+    ]);
+  });
+
+  it('falls back to wl-copy on Linux without display hints', () => {
+    expect(getClipboardCommandCandidates('linux', {} as NodeJS.ProcessEnv)).toEqual([
+      { command: 'wl-copy', args: [] },
+    ]);
+  });
+});

package/src/runtime/clipboard.ts

@@ -0,0 +1,89 @@
+import type { CliRenderer } from '@opentui/core';
+import { spawn } from 'node:child_process';
+
+type ClipboardCommand = {
+  command: string;
+  args: string[];
+};
+
+type ClipboardRenderer = Pick<CliRenderer, 'copyToClipboardOSC52'>;
+
+const runClipboardCommand = (text: string, candidate: ClipboardCommand): Promise<boolean> => {
+  return new Promise(resolve => {
+    let settled = false;
+    const finish = (success: boolean) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve(success);
+    };
+
+    try {
+      const child = spawn(candidate.command, candidate.args, {
+        stdio: ['pipe', 'ignore', 'ignore'],
+        windowsHide: true,
+      });
+
+      child.once('error', () => {
+        finish(false);
+      });
+      child.once('close', code => {
+        finish(code === 0);
+      });
+      child.stdin.on('error', () => {
+        finish(false);
+      });
+      child.stdin.end(text);
+    } catch {
+      finish(false);
+    }
+  });
+};
+
+export const getClipboardCommandCandidates = (
+  platform: NodeJS.Platform = process.platform,
+  env: NodeJS.ProcessEnv = process.env
+): ClipboardCommand[] => {
+  if (platform === 'darwin') {
+    return [{ command: 'pbcopy', args: [] }];
+  }
+
+  if (platform === 'win32') {
+    return [{ command: 'cmd', args: ['/c', 'clip'] }];
+  }
+
+  const candidates: ClipboardCommand[] = [];
+
+  if (env['WAYLAND_DISPLAY']) {
+    candidates.push({ command: 'wl-copy', args: [] });
+  }
+
+  if (env['DISPLAY']) {
+    candidates.push({ command: 'xclip', args: ['-selection', 'clipboard'] });
+    candidates.push({ command: 'xsel', args: ['--clipboard', '--input'] });
+  }
+
+  if (!env['WAYLAND_DISPLAY']) {
+    candidates.push({ command: 'wl-copy', args: [] });
+  }
+
+  return candidates;
+};
+
+export const copyTextToClipboard = async (
+  text: string,
+  renderer: ClipboardRenderer | null = null
+): Promise<boolean> => {
+  if (!text) {
+    return false;
+  }
+
+  for (const candidate of getClipboardCommandCandidates()) {
+    if (await runClipboardCommand(text, candidate)) {
+      return true;
+    }
+  }
+
+  return renderer?.copyToClipboardOSC52(text) ?? false;
+};

package/src/runtime/exit.test.ts

@@ -0,0 +1,177 @@
+import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test';
+import type { CliRenderer } from '@opentui/core';
+import {
+  bindExitGuards,
+  hardResetTerminal,
+  initExitRuntime,
+  registerTerminalBackgroundRestore,
+  requestExit,
+} from './exit';
+
+const originalProcess = global.process;
+const mockProcess = {
+  ...originalProcess,
+  stdout: {
+    ...originalProcess.stdout,
+    isTTY: true,
+    write: mock(() => {}),
+  },
+  stdin: {
+    ...originalProcess.stdin,
+    isTTY: true,
+    setRawMode: mock(() => {}),
+  },
+  on: mock(() => {}),
+  once: mock(() => {}),
+  exit: mock(() => {}),
+};
+
+const originalConsoleError = console.error;
+const mockConsoleError = mock(() => {});
+
+describe('exit module', () => {
+  beforeEach(() => {
+    mockProcess.stdout.write.mockClear();
+    mockProcess.stdin.setRawMode.mockClear();
+    mockProcess.on.mockClear();
+    mockProcess.once.mockClear();
+    mockProcess.exit.mockClear();
+    mockConsoleError.mockClear();
+    mockProcess.stdout.isTTY = true;
+    mockProcess.stdin.isTTY = true;
+
+    global.process = mockProcess as typeof process;
+    console.error = mockConsoleError as typeof console.error;
+  });
+
+  afterEach(() => {
+    global.process = originalProcess;
+    console.error = originalConsoleError;
+  });
+
+  describe('registerTerminalBackgroundRestore', () => {
+    it('registers restore function', () => {
+      const restoreFn = () => undefined;
+      registerTerminalBackgroundRestore(restoreFn);
+      expect(() => registerTerminalBackgroundRestore(restoreFn)).not.toThrow();
+    });
+
+    it('allows null restore function', () => {
+      expect(() => registerTerminalBackgroundRestore(null)).not.toThrow();
+    });
+  });
+
+  describe('hardResetTerminal', () => {
+    it('resets terminal when stdout is TTY', () => {
+      hardResetTerminal();
+
+      expect(mockProcess.stdout.write).toHaveBeenCalled();
+      expect(mockProcess.stdin.setRawMode).toHaveBeenCalledWith(false);
+    });
+
+    it('does not reset terminal when stdout is not TTY', () => {
+      mockProcess.stdout.isTTY = false;
+      mockProcess.stdin.isTTY = false;
+
+      hardResetTerminal();
+
+      expect(mockProcess.stdout.write).not.toHaveBeenCalled();
+      expect(mockProcess.stdin.setRawMode).not.toHaveBeenCalled();
+    });
+
+    it('calls registered restore function', () => {
+      const restoreFn = mock(() => {});
+      registerTerminalBackgroundRestore(restoreFn);
+
+      hardResetTerminal();
+
+      expect(restoreFn).toHaveBeenCalled();
+    });
+
+    it('handles write errors gracefully', () => {
+      mockProcess.stdout.write.mockImplementation(() => {
+        throw new Error('Write error');
+      });
+
+      expect(() => hardResetTerminal()).not.toThrow();
+    });
+  });
+
+  describe('initExitRuntime', () => {
+    it('stores renderer reference', () => {
+      const mockRenderer = {} as CliRenderer;
+      initExitRuntime(mockRenderer);
+
+      expect(() => initExitRuntime(mockRenderer)).not.toThrow();
+    });
+  });
+
+  describe('requestExit', () => {
+    it('exits with default code 0', async () => {
+      const mockRenderer = {
+        useMouse: false,
+        setTerminalTitle: mock(() => {}),
+        disableKittyKeyboard: mock(() => {}),
+        destroy: mock(() => {}),
+      } as CliRenderer;
+
+      initExitRuntime(mockRenderer);
+      await requestExit();
+
+      expect(mockRenderer.destroy).toHaveBeenCalled();
+      expect(mockProcess.exit).toHaveBeenCalledWith(0);
+    });
+
+    it('exits with specified code', async () => {
+      initExitRuntime(null as unknown as CliRenderer);
+      await requestExit(1);
+      expect(mockProcess.exit).toHaveBeenCalledWith(1);
+    });
+
+    it('does not exit twice if already cleaned up', async () => {
+      initExitRuntime(null as unknown as CliRenderer);
+      await requestExit(0);
+      expect(mockProcess.exit).toHaveBeenCalledTimes(1);
+
+      mockProcess.exit.mockClear();
+
+      await requestExit(0);
+      expect(mockProcess.exit).not.toHaveBeenCalled();
+    });
+
+    it('handles missing renderer gracefully', async () => {
+      initExitRuntime(null as unknown as CliRenderer);
+      await expect(requestExit(0)).resolves.toBeUndefined();
+    });
+
+    it('handles renderer errors gracefully', async () => {
+      const mockRenderer = {
+        useMouse: false,
+        setTerminalTitle: mock(() => {
+          throw new Error('Title error');
+        }),
+        disableKittyKeyboard: mock(() => {
+          throw new Error('Keyboard error');
+        }),
+        destroy: mock(() => {
+          throw new Error('Destroy error');
+        }),
+      } as CliRenderer;
+
+      initExitRuntime(mockRenderer);
+
+      await expect(requestExit(0)).resolves.toBeUndefined();
+      expect(mockProcess.exit).toHaveBeenCalledWith(0);
+    });
+  });
+
+  describe('bindExitGuards', () => {
+    it('binds exit handlers', () => {
+      bindExitGuards();
+
+      expect(mockProcess.once).toHaveBeenCalledWith('SIGINT', expect.any(Function));
+      expect(mockProcess.once).toHaveBeenCalledWith('SIGTERM', expect.any(Function));
+      expect(mockProcess.once).toHaveBeenCalledWith('exit', expect.any(Function));
+    });
+  });
+});

package/src/runtime/exit.ts

@@ -0,0 +1,98 @@
+import type { CliRenderer } from '@opentui/core';
+import { disposeAgentRuntime } from '../agent/runtime/runtime';
+
+const TERMINAL_RESET_SEQUENCE = [
+  '\u001b[0m',
+  '\u001b[?25h',
+  '\u001b[?1000l',
+  '\u001b[?1002l',
+  '\u001b[?1003l',
+  '\u001b[?1006l',
+  '\u001b[?2004l',
+  '\u001b[?2026l',
+  '\u001b[?2027l',
+  '\u001b[?2031l',
+  '\u001b[?1049l',
+].join('');
+
+let rendererRef: CliRenderer | null = null;
+let hasCleanedUp = false;
+let terminalBackgroundRestore: (() => void) | null = null;
+let exitPromise: Promise<void> | null = null;
+
+export const registerTerminalBackgroundRestore = (restore: (() => void) | null) => {
+  terminalBackgroundRestore = restore;
+};
+
+export const hardResetTerminal = () => {
+  if (!globalThis.process.stdout.isTTY) {
+    return;
+  }
+
+  try {
+    const restore = terminalBackgroundRestore;
+    terminalBackgroundRestore = null;
+    restore?.();
+
+    globalThis.process.stdout.write(TERMINAL_RESET_SEQUENCE);
+    if (
+      globalThis.process.stdin.isTTY &&
+      typeof globalThis.process.stdin.setRawMode === 'function'
+    ) {
+      globalThis.process.stdin.setRawMode(false);
+    }
+  } catch {
+    // Ignore errors during terminal reset
+  }
+};
+
+export const initExitRuntime = (renderer: CliRenderer) => {
+  hasCleanedUp = false;
+  exitPromise = null;
+  rendererRef = renderer;
+};
+
+export const requestExit = async (exitCode = 0): Promise<void> => {
+  if (exitPromise) {
+    return exitPromise;
+  }
+
+  exitPromise = (async () => {
+    if (hasCleanedUp) {
+      return;
+    }
+    hasCleanedUp = true;
+
+    try {
+      await disposeAgentRuntime();
+    } catch {
+      // Ignore errors during runtime disposal and continue exiting
+    }
+
+    try {
+      if (rendererRef) {
+        rendererRef.useMouse = false;
+        rendererRef.setTerminalTitle('');
+        rendererRef.disableKittyKeyboard();
+        rendererRef.destroy();
+      }
+    } catch {
+      // Ignore errors during renderer cleanup
+    }
+
+    hardResetTerminal();
+    globalThis.process.exit(exitCode);
+  })();
+
+  return exitPromise;
+};
+
+export const bindExitGuards = () => {
+  globalThis.process.once('SIGINT', () => {
+    void requestExit(0);
+  });
+  globalThis.process.once('SIGTERM', () => {
+    void requestExit(0);
+  });
+  globalThis.process.once('exit', hardResetTerminal);
+};

package/src/runtime/runtime-support.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  ensureSupportedRuntime,
+  getUnsupportedRuntimeMessage,
+  isBunRuntime,
+} from './runtime-support';
+
+describe('runtime support', () => {
+  it('detects bun via process.versions.bun', () => {
+    const originalVersions = process.versions;
+    vi.stubGlobal('process', {
+      ...process,
+      versions: {
+        ...originalVersions,
+        bun: '1.2.0',
+      },
+    });
+
+    expect(isBunRuntime()).toBe(true);
+
+    vi.unstubAllGlobals();
+  });
+
+  it('returns false and prints a helpful message when bun is unavailable', () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    expect(ensureSupportedRuntime()).toBe(false);
+    expect(errorSpy).toHaveBeenCalledWith(getUnsupportedRuntimeMessage());
+  });
+});

package/src/runtime/terminal-theme.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+
+import { extractOsc11Color, modeFromColor, parseTerminalColor } from './terminal-theme';
+
+describe('parseTerminalColor', () => {
+  it('parses rgb:RRRR/GGGG/BBBB format', () => {
+    expect(parseTerminalColor('rgb:ffff/8080/0000')).toEqual({
+      r: 255,
+      g: 128,
+      b: 0,
+    });
+  });
+
+  it('parses #RRGGBB format', () => {
+    expect(parseTerminalColor('#1a2b3c')).toEqual({
+      r: 26,
+      g: 43,
+      b: 60,
+    });
+  });
+
+  it('parses rgb(R,G,B) format', () => {
+    expect(parseTerminalColor('rgb(12, 34, 56)')).toEqual({
+      r: 12,
+      g: 34,
+      b: 56,
+    });
+  });
+
+  it('returns null for unsupported values', () => {
+    expect(parseTerminalColor('rgba(1,2,3,0.5)')).toBeNull();
+    expect(parseTerminalColor('#12345')).toBeNull();
+  });
+});
+
+describe('extractOsc11Color', () => {
+  it('extracts OSC 11 color payload', () => {
+    const input = '\u001b]11;rgb:ffff/eeee/dddd\u0007';
+    expect(extractOsc11Color(input)).toBe('rgb:ffff/eeee/dddd');
+  });
+
+  it('returns null when payload is absent', () => {
+    expect(extractOsc11Color('plain text')).toBeNull();
+  });
+});
+
+describe('modeFromColor', () => {
+  it('detects dark backgrounds', () => {
+    expect(modeFromColor({ r: 5, g: 6, b: 8 })).toBe('dark');
+  });
+
+  it('detects light backgrounds', () => {
+    expect(modeFromColor({ r: 245, g: 246, b: 248 })).toBe('light');
+  });
+});