@renxqoo/renx-code 0.0.8 → 0.0.10

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

@@ -1,154 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,177 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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');
-  });
-});