Add files using upload-large-folder tool

projects/ui/qwen-code/packages/cli/src/ui/hooks/useReverseSearchCompletion.tsx

@@ -0,0 +1,95 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useEffect, useCallback } from 'react';
+import { useCompletion } from './useCompletion.js';
+import { TextBuffer } from '../components/shared/text-buffer.js';
+import { Suggestion } from '../components/SuggestionsDisplay.js';
+
+export interface UseReverseSearchCompletionReturn {
+  suggestions: Suggestion[];
+  activeSuggestionIndex: number;
+  visibleStartIndex: number;
+  showSuggestions: boolean;
+  isLoadingSuggestions: boolean;
+  navigateUp: () => void;
+  navigateDown: () => void;
+  handleAutocomplete: (i: number) => void;
+  resetCompletionState: () => void;
+}
+
+export function useReverseSearchCompletion(
+  buffer: TextBuffer,
+  shellHistory: readonly string[],
+  reverseSearchActive: boolean,
+): UseReverseSearchCompletionReturn {
+  const {
+    suggestions,
+    activeSuggestionIndex,
+    visibleStartIndex,
+    showSuggestions,
+    isLoadingSuggestions,
+
+    setSuggestions,
+    setShowSuggestions,
+    setActiveSuggestionIndex,
+    resetCompletionState,
+    navigateUp,
+    navigateDown,
+  } = useCompletion();
+
+  useEffect(() => {
+    if (!reverseSearchActive) {
+      resetCompletionState();
+    }
+  }, [reverseSearchActive, resetCompletionState]);
+
+  useEffect(() => {
+    if (!reverseSearchActive) {
+      return;
+    }
+
+    const q = buffer.text.toLowerCase();
+    const matches = shellHistory.reduce<Suggestion[]>((acc, cmd) => {
+      const idx = cmd.toLowerCase().indexOf(q);
+      if (idx !== -1) {
+        acc.push({ label: cmd, value: cmd, matchedIndex: idx });
+      }
+      return acc;
+    }, []);
+    setSuggestions(matches);
+    setShowSuggestions(matches.length > 0);
+    setActiveSuggestionIndex(matches.length > 0 ? 0 : -1);
+  }, [
+    buffer.text,
+    shellHistory,
+    reverseSearchActive,
+    setActiveSuggestionIndex,
+    setShowSuggestions,
+    setSuggestions,
+  ]);
+
+  const handleAutocomplete = useCallback(
+    (i: number) => {
+      if (i < 0 || i >= suggestions.length) return;
+      buffer.setText(suggestions[i].value);
+      resetCompletionState();
+    },
+    [buffer, suggestions, resetCompletionState],
+  );
+
+  return {
+    suggestions,
+    activeSuggestionIndex,
+    visibleStartIndex,
+    showSuggestions,
+    isLoadingSuggestions,
+    navigateUp,
+    navigateDown,
+    handleAutocomplete,
+    resetCompletionState,
+  };
+}

projects/ui/qwen-code/packages/cli/src/ui/hooks/useSettingsCommand.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useCallback } from 'react';
+
+export function useSettingsCommand() {
+  const [isSettingsDialogOpen, setIsSettingsDialogOpen] = useState(false);
+
+  const openSettingsDialog = useCallback(() => {
+    setIsSettingsDialogOpen(true);
+  }, []);
+
+  const closeSettingsDialog = useCallback(() => {
+    setIsSettingsDialogOpen(false);
+  }, []);
+
+  return {
+    isSettingsDialogOpen,
+    openSettingsDialog,
+    closeSettingsDialog,
+  };
+}

projects/ui/qwen-code/packages/cli/src/ui/hooks/useShellHistory.test.ts

@@ -0,0 +1,219 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { renderHook, act, waitFor } from '@testing-library/react';
+import { useShellHistory } from './useShellHistory.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import * as crypto from 'crypto';
+
+vi.mock('fs/promises');
+vi.mock('os');
+vi.mock('crypto');
+
+const MOCKED_PROJECT_ROOT = '/test/project';
+const MOCKED_HOME_DIR = '/test/home';
+const MOCKED_PROJECT_HASH = 'mocked_hash';
+
+const MOCKED_HISTORY_DIR = path.join(
+  MOCKED_HOME_DIR,
+  '.qwen',
+  'tmp',
+  MOCKED_PROJECT_HASH,
+);
+const MOCKED_HISTORY_FILE = path.join(MOCKED_HISTORY_DIR, 'shell_history');
+
+describe('useShellHistory', () => {
+  const mockedFs = vi.mocked(fs);
+  const mockedOs = vi.mocked(os);
+  const mockedCrypto = vi.mocked(crypto);
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+
+    mockedFs.readFile.mockResolvedValue('');
+    mockedFs.writeFile.mockResolvedValue(undefined);
+    mockedFs.mkdir.mockResolvedValue(undefined);
+    mockedOs.homedir.mockReturnValue(MOCKED_HOME_DIR);
+
+    const hashMock = {
+      update: vi.fn().mockReturnThis(),
+      digest: vi.fn().mockReturnValue(MOCKED_PROJECT_HASH),
+    };
+    mockedCrypto.createHash.mockReturnValue(hashMock as never);
+  });
+
+  it('should initialize and read the history file from the correct path', async () => {
+    mockedFs.readFile.mockResolvedValue('cmd1\ncmd2');
+    const { result } = renderHook(() => useShellHistory(MOCKED_PROJECT_ROOT));
+
+    await waitFor(() => {
+      expect(mockedFs.readFile).toHaveBeenCalledWith(
+        MOCKED_HISTORY_FILE,
+        'utf-8',
+      );
+    });
+
+    let command: string | null = null;
+    act(() => {
+      command = result.current.getPreviousCommand();
+    });
+
+    // History is loaded newest-first: ['cmd2', 'cmd1']
+    expect(command).toBe('cmd2');
+  });
+
+  it('should handle a nonexistent history file gracefully', async () => {
+    const error = new Error('File not found') as NodeJS.ErrnoException;
+    error.code = 'ENOENT';
+    mockedFs.readFile.mockRejectedValue(error);
+
+    const { result } = renderHook(() => useShellHistory(MOCKED_PROJECT_ROOT));
+
+    await waitFor(() => {
+      expect(mockedFs.readFile).toHaveBeenCalled();
+    });
+
+    let command: string | null = null;
+    act(() => {
+      command = result.current.getPreviousCommand();
+    });
+
+    expect(command).toBe(null);
+  });
+
+  it('should add a command and write to the history file', async () => {
+    const { result } = renderHook(() => useShellHistory(MOCKED_PROJECT_ROOT));
+
+    await waitFor(() => expect(mockedFs.readFile).toHaveBeenCalled());
+
+    act(() => {
+      result.current.addCommandToHistory('new_command');
+    });
+
+    await waitFor(() => {
+      expect(mockedFs.mkdir).toHaveBeenCalledWith(MOCKED_HISTORY_DIR, {
+        recursive: true,
+      });
+      expect(mockedFs.writeFile).toHaveBeenCalledWith(
+        MOCKED_HISTORY_FILE,
+        'new_command', // Written to file oldest-first.
+      );
+    });
+
+    let command: string | null = null;
+    act(() => {
+      command = result.current.getPreviousCommand();
+    });
+    expect(command).toBe('new_command');
+  });
+
+  it('should navigate history correctly with previous/next commands', async () => {
+    mockedFs.readFile.mockResolvedValue('cmd1\ncmd2\ncmd3');
+    const { result } = renderHook(() => useShellHistory(MOCKED_PROJECT_ROOT));
+
+    // Wait for history to be loaded: ['cmd3', 'cmd2', 'cmd1']
+    await waitFor(() => expect(mockedFs.readFile).toHaveBeenCalled());
+
+    let command: string | null = null;
+
+    act(() => {
+      command = result.current.getPreviousCommand();
+    });
+    expect(command).toBe('cmd3');
+
+    act(() => {
+      command = result.current.getPreviousCommand();
+    });
+    expect(command).toBe('cmd2');
+
+    act(() => {
+      command = result.current.getPreviousCommand();
+    });
+    expect(command).toBe('cmd1');
+
+    // Should stay at the oldest command
+    act(() => {
+      command = result.current.getPreviousCommand();
+    });
+    expect(command).toBe('cmd1');
+
+    act(() => {
+      command = result.current.getNextCommand();
+    });
+    expect(command).toBe('cmd2');
+
+    act(() => {
+      command = result.current.getNextCommand();
+    });
+    expect(command).toBe('cmd3');
+
+    // Should return to the "new command" line (represented as empty string)
+    act(() => {
+      command = result.current.getNextCommand();
+    });
+    expect(command).toBe('');
+  });
+
+  it('should not add empty or whitespace-only commands to history', async () => {
+    const { result } = renderHook(() => useShellHistory(MOCKED_PROJECT_ROOT));
+    await waitFor(() => expect(mockedFs.readFile).toHaveBeenCalled());
+
+    act(() => {
+      result.current.addCommandToHistory('   ');
+    });
+
+    expect(mockedFs.writeFile).not.toHaveBeenCalled();
+  });
+
+  it('should truncate history to MAX_HISTORY_LENGTH (100)', async () => {
+    const oldCommands = Array.from({ length: 120 }, (_, i) => `old_cmd_${i}`);
+    mockedFs.readFile.mockResolvedValue(oldCommands.join('\n'));
+
+    const { result } = renderHook(() => useShellHistory(MOCKED_PROJECT_ROOT));
+    await waitFor(() => expect(mockedFs.readFile).toHaveBeenCalled());
+
+    act(() => {
+      result.current.addCommandToHistory('new_cmd');
+    });
+
+    // Wait for the async write to happen and then inspect the arguments.
+    await waitFor(() => expect(mockedFs.writeFile).toHaveBeenCalled());
+
+    // The hook stores history newest-first.
+    // Initial state: ['old_cmd_119', ..., 'old_cmd_0']
+    // After adding 'new_cmd': ['new_cmd', 'old_cmd_119', ..., 'old_cmd_21'] (100 items)
+    // Written to file (reversed): ['old_cmd_21', ..., 'old_cmd_119', 'new_cmd']
+    const writtenContent = mockedFs.writeFile.mock.calls[0][1] as string;
+    const writtenLines = writtenContent.split('\n');
+
+    expect(writtenLines.length).toBe(100);
+    expect(writtenLines[0]).toBe('old_cmd_21'); // New oldest command
+    expect(writtenLines[99]).toBe('new_cmd'); // Newest command
+  });
+
+  it('should move an existing command to the top when re-added', async () => {
+    mockedFs.readFile.mockResolvedValue('cmd1\ncmd2\ncmd3');
+    const { result } = renderHook(() => useShellHistory(MOCKED_PROJECT_ROOT));
+
+    // Initial state: ['cmd3', 'cmd2', 'cmd1']
+    await waitFor(() => expect(mockedFs.readFile).toHaveBeenCalled());
+
+    act(() => {
+      result.current.addCommandToHistory('cmd1');
+    });
+
+    // After re-adding 'cmd1': ['cmd1', 'cmd3', 'cmd2']
+    // Written to file (reversed): ['cmd2', 'cmd3', 'cmd1']
+    await waitFor(() => expect(mockedFs.writeFile).toHaveBeenCalled());
+
+    const writtenContent = mockedFs.writeFile.mock.calls[0][1] as string;
+    const writtenLines = writtenContent.split('\n');
+
+    expect(writtenLines).toEqual(['cmd2', 'cmd3', 'cmd1']);
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/hooks/useShellHistory.ts

@@ -0,0 +1,133 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useEffect, useCallback } from 'react';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { isNodeError, getProjectTempDir } from '@qwen-code/qwen-code-core';
+
+const HISTORY_FILE = 'shell_history';
+const MAX_HISTORY_LENGTH = 100;
+
+export interface UseShellHistoryReturn {
+  history: string[];
+  addCommandToHistory: (command: string) => void;
+  getPreviousCommand: () => string | null;
+  getNextCommand: () => string | null;
+  resetHistoryPosition: () => void;
+}
+
+async function getHistoryFilePath(projectRoot: string): Promise<string> {
+  const historyDir = getProjectTempDir(projectRoot);
+  return path.join(historyDir, HISTORY_FILE);
+}
+
+// Handle multiline commands
+async function readHistoryFile(filePath: string): Promise<string[]> {
+  try {
+    const text = await fs.readFile(filePath, 'utf-8');
+    const result: string[] = [];
+    let cur = '';
+
+    for (const raw of text.split(/\r?\n/)) {
+      if (!raw.trim()) continue;
+      const line = raw;
+
+      const m = cur.match(/(\\+)$/);
+      if (m && m[1].length % 2) {
+        // odd number of trailing '\'
+        cur = cur.slice(0, -1) + ' ' + line;
+      } else {
+        if (cur) result.push(cur);
+        cur = line;
+      }
+    }
+
+    if (cur) result.push(cur);
+    return result;
+  } catch (err) {
+    if (isNodeError(err) && err.code === 'ENOENT') return [];
+    console.error('Error reading history:', err);
+    return [];
+  }
+}
+
+async function writeHistoryFile(
+  filePath: string,
+  history: string[],
+): Promise<void> {
+  try {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, history.join('\n'));
+  } catch (error) {
+    console.error('Error writing shell history:', error);
+  }
+}
+
+export function useShellHistory(projectRoot: string): UseShellHistoryReturn {
+  const [history, setHistory] = useState<string[]>([]);
+  const [historyIndex, setHistoryIndex] = useState(-1);
+  const [historyFilePath, setHistoryFilePath] = useState<string | null>(null);
+
+  useEffect(() => {
+    async function loadHistory() {
+      const filePath = await getHistoryFilePath(projectRoot);
+      setHistoryFilePath(filePath);
+      const loadedHistory = await readHistoryFile(filePath);
+      setHistory(loadedHistory.reverse()); // Newest first
+    }
+    loadHistory();
+  }, [projectRoot]);
+
+  const addCommandToHistory = useCallback(
+    (command: string) => {
+      if (!command.trim() || !historyFilePath) {
+        return;
+      }
+      const newHistory = [command, ...history.filter((c) => c !== command)]
+        .slice(0, MAX_HISTORY_LENGTH)
+        .filter(Boolean);
+      setHistory(newHistory);
+      // Write to file in reverse order (oldest first)
+      writeHistoryFile(historyFilePath, [...newHistory].reverse());
+      setHistoryIndex(-1);
+    },
+    [history, historyFilePath],
+  );
+
+  const getPreviousCommand = useCallback(() => {
+    if (history.length === 0) {
+      return null;
+    }
+    const newIndex = Math.min(historyIndex + 1, history.length - 1);
+    setHistoryIndex(newIndex);
+    return history[newIndex] ?? null;
+  }, [history, historyIndex]);
+
+  const getNextCommand = useCallback(() => {
+    if (historyIndex < 0) {
+      return null;
+    }
+    const newIndex = historyIndex - 1;
+    setHistoryIndex(newIndex);
+    if (newIndex < 0) {
+      return '';
+    }
+    return history[newIndex] ?? null;
+  }, [history, historyIndex]);
+
+  const resetHistoryPosition = useCallback(() => {
+    setHistoryIndex(-1);
+  }, []);
+
+  return {
+    history,
+    addCommandToHistory,
+    getPreviousCommand,
+    getNextCommand,
+    resetHistoryPosition,
+  };
+}

projects/ui/qwen-code/packages/cli/src/ui/hooks/useShowMemoryCommand.ts

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Message, MessageType } from '../types.js';
+import { Config } from '@qwen-code/qwen-code-core';
+import { LoadedSettings } from '../../config/settings.js';
+
+export function createShowMemoryAction(
+  config: Config | null,
+  settings: LoadedSettings,
+  addMessage: (message: Message) => void,
+) {
+  return async () => {
+    if (!config) {
+      addMessage({
+        type: MessageType.ERROR,
+        content: 'Configuration not available. Cannot show memory.',
+        timestamp: new Date(),
+      });
+      return;
+    }
+
+    const debugMode = config.getDebugMode();
+
+    if (debugMode) {
+      console.log('[DEBUG] Show Memory command invoked.');
+    }
+
+    const currentMemory = config.getUserMemory();
+    const fileCount = config.getGeminiMdFileCount();
+    const contextFileName = settings.merged.contextFileName;
+    const contextFileNames = Array.isArray(contextFileName)
+      ? contextFileName
+      : [contextFileName];
+
+    if (debugMode) {
+      console.log(
+        `[DEBUG] Showing memory. Content from config.getUserMemory() (first 200 chars): ${currentMemory.substring(0, 200)}...`,
+      );
+      console.log(`[DEBUG] Number of context files loaded: ${fileCount}`);
+    }
+
+    if (fileCount > 0) {
+      const allNamesTheSame = new Set(contextFileNames).size < 2;
+      const name = allNamesTheSame ? contextFileNames[0] : 'context';
+      addMessage({
+        type: MessageType.INFO,
+        content: `Loaded memory from ${fileCount} ${name} file${
+          fileCount > 1 ? 's' : ''
+        }.`,
+        timestamp: new Date(),
+      });
+    }
+
+    if (currentMemory && currentMemory.trim().length > 0) {
+      addMessage({
+        type: MessageType.INFO,
+        content: `Current combined memory content:\n\`\`\`markdown\n${currentMemory}\n\`\`\``,
+        timestamp: new Date(),
+      });
+    } else {
+      addMessage({
+        type: MessageType.INFO,
+        content:
+          fileCount > 0
+            ? 'Hierarchical memory (QWEN.md or other context files) is loaded but content is empty.'
+            : 'No hierarchical memory (QWEN.md or other context files) is currently loaded.',
+        timestamp: new Date(),
+      });
+    }
+  };
+}

projects/ui/qwen-code/packages/cli/src/ui/hooks/useSlashCompletion.test.ts

@@ -0,0 +1,434 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/** @vitest-environment jsdom */
+
+import { describe, it, expect, vi } from 'vitest';
+import { renderHook, waitFor } from '@testing-library/react';
+import { useSlashCompletion } from './useSlashCompletion.js';
+import { CommandContext, SlashCommand } from '../commands/types.js';
+import { useState } from 'react';
+import { Suggestion } from '../components/SuggestionsDisplay.js';
+
+// Test harness to capture the state from the hook's callbacks.
+function useTestHarnessForSlashCompletion(
+  enabled: boolean,
+  query: string | null,
+  slashCommands: readonly SlashCommand[],
+  commandContext: CommandContext,
+) {
+  const [suggestions, setSuggestions] = useState<Suggestion[]>([]);
+  const [isLoadingSuggestions, setIsLoadingSuggestions] = useState(false);
+  const [isPerfectMatch, setIsPerfectMatch] = useState(false);
+
+  const { completionStart, completionEnd } = useSlashCompletion({
+    enabled,
+    query,
+    slashCommands,
+    commandContext,
+    setSuggestions,
+    setIsLoadingSuggestions,
+    setIsPerfectMatch,
+  });
+
+  return {
+    suggestions,
+    isLoadingSuggestions,
+    isPerfectMatch,
+    completionStart,
+    completionEnd,
+  };
+}
+
+describe('useSlashCompletion', () => {
+  // A minimal mock is sufficient for these tests.
+  const mockCommandContext = {} as CommandContext;
+
+  describe('Top-Level Commands', () => {
+    it('should suggest all top-level commands for the root slash', async () => {
+      const slashCommands = [
+        { name: 'help', altNames: ['?'], description: 'Show help' },
+        {
+          name: 'stats',
+          altNames: ['usage'],
+          description: 'check session stats. Usage: /stats [model|tools]',
+        },
+        { name: 'clear', description: 'Clear the screen' },
+        {
+          name: 'memory',
+          description: 'Manage memory',
+          subCommands: [{ name: 'show', description: 'Show memory' }],
+        },
+        { name: 'chat', description: 'Manage chat history' },
+      ] as unknown as SlashCommand[];
+      const { result } = renderHook(() =>
+        useTestHarnessForSlashCompletion(
+          true,
+          '/',
+          slashCommands,
+          mockCommandContext,
+        ),
+      );
+
+      expect(result.current.suggestions.length).toBe(slashCommands.length);
+      expect(result.current.suggestions.map((s) => s.label)).toEqual(
+        expect.arrayContaining(['help', 'clear', 'memory', 'chat', 'stats']),
+      );
+    });
+
+    it('should filter commands based on partial input', async () => {
+      const slashCommands = [
+        { name: 'memory', description: 'Manage memory' },
+      ] as unknown as SlashCommand[];
+      const { result } = renderHook(() =>
+        useTestHarnessForSlashCompletion(
+          true,
+          '/mem',
+          slashCommands,
+          mockCommandContext,
+        ),
+      );
+
+      expect(result.current.suggestions).toEqual([
+        { label: 'memory', value: 'memory', description: 'Manage memory' },
+      ]);
+    });
+
+    it('should suggest commands based on partial altNames', async () => {
+      const slashCommands = [
+        {
+          name: 'stats',
+          altNames: ['usage'],
+          description: 'check session stats. Usage: /stats [model|tools]',
+        },
+      ] as unknown as SlashCommand[];
+      const { result } = renderHook(() =>
+        useTestHarnessForSlashCompletion(
+          true,
+          '/usag',
+          slashCommands,
+          mockCommandContext,
+        ),
+      );
+
+      expect(result.current.suggestions).toEqual([
+        {
+          label: 'stats',
+          value: 'stats',
+          description: 'check session stats. Usage: /stats [model|tools]',
+        },
+      ]);
+    });
+
+    it('should NOT provide suggestions for a perfectly typed command that is a leaf node', async () => {
+      const slashCommands = [
+        { name: 'clear', description: 'Clear the screen', action: vi.fn() },
+      ] as unknown as SlashCommand[];
+      const { result } = renderHook(() =>
+        useTestHarnessForSlashCompletion(
+          true,
+          '/clear',
+          slashCommands,
+          mockCommandContext,
+        ),
+      );
+
+      expect(result.current.suggestions).toHaveLength(0);
+    });
+
+    it.each([['/?'], ['/usage']])(
+      'should not suggest commands when altNames is fully typed',
+      async (query) => {
+        const mockSlashCommands = [
+          {
+            name: 'help',
+            altNames: ['?'],
+            description: 'Show help',
+            action: vi.fn(),
+          },
+          {
+            name: 'stats',
+            altNames: ['usage'],
+            description: 'check session stats. Usage: /stats [model|tools]',
+            action: vi.fn(),
+          },
+        ] as unknown as SlashCommand[];
+
+        const { result } = renderHook(() =>
+          useTestHarnessForSlashCompletion(
+            true,
+            query,
+            mockSlashCommands,
+            mockCommandContext,
+          ),
+        );
+
+        expect(result.current.suggestions).toHaveLength(0);
+      },
+    );
+
+    it('should not provide suggestions for a fully typed command that has no sub-commands or argument completion', async () => {
+      const slashCommands = [
+        { name: 'clear', description: 'Clear the screen' },
+      ] as unknown as SlashCommand[];
+      const { result } = renderHook(() =>
+        useTestHarnessForSlashCompletion(
+          true,
+          '/clear ',
+          slashCommands,
+          mockCommandContext,
+        ),
+      );
+
+      expect(result.current.suggestions).toHaveLength(0);
+    });
+
+    it('should not provide suggestions for an unknown command', async () => {
+      const slashCommands = [
+        { name: 'help', description: 'Show help' },
+      ] as unknown as SlashCommand[];
+      const { result } = renderHook(() =>
+        useTestHarnessForSlashCompletion(
+          true,
+          '/unknown-command',
+          slashCommands,
+          mockCommandContext,
+        ),
+      );
+
+      expect(result.current.suggestions).toHaveLength(0);
+    });
+  });
+
+  describe('Sub-Commands', () => {
+    it('should suggest sub-commands for a parent command', async () => {
+      const slashCommands = [
+        {
+          name: 'memory',
+          description: 'Manage memory',
+          subCommands: [
+            { name: 'show', description: 'Show memory' },
+            { name: 'add', description: 'Add to memory' },
+          ],
+        },
+      ] as unknown as SlashCommand[];
+
+      const { result } = renderHook(() =>
+        useTestHarnessForSlashCompletion(
+          true,
+          '/memory',
+          slashCommands,
+          mockCommandContext,
+        ),
+      );
+
+      expect(result.current.suggestions).toHaveLength(2);
+      expect(result.current.suggestions).toEqual(
+        expect.arrayContaining([
+          { label: 'show', value: 'show', description: 'Show memory' },
+          { label: 'add', value: 'add', description: 'Add to memory' },
+        ]),
+      );
+    });
+
+    it('should suggest all sub-commands when the query ends with the parent command and a space', async () => {
+      const slashCommands = [
+        {
+          name: 'memory',
+          description: 'Manage memory',
+          subCommands: [
+            { name: 'show', description: 'Show memory' },
+            { name: 'add', description: 'Add to memory' },
+          ],
+        },
+      ] as unknown as SlashCommand[];
+      const { result } = renderHook(() =>
+        useTestHarnessForSlashCompletion(
+          true,
+          '/memory ',
+          slashCommands,
+          mockCommandContext,
+        ),
+      );
+
+      expect(result.current.suggestions).toHaveLength(2);
+      expect(result.current.suggestions).toEqual(
+        expect.arrayContaining([
+          { label: 'show', value: 'show', description: 'Show memory' },
+          { label: 'add', value: 'add', description: 'Add to memory' },
+        ]),
+      );
+    });
+
+    it('should filter sub-commands by prefix', async () => {
+      const slashCommands = [
+        {
+          name: 'memory',
+          description: 'Manage memory',
+          subCommands: [
+            { name: 'show', description: 'Show memory' },
+            { name: 'add', description: 'Add to memory' },
+          ],
+        },
+      ] as unknown as SlashCommand[];
+      const { result } = renderHook(() =>
+        useTestHarnessForSlashCompletion(
+          true,
+          '/memory a',
+          slashCommands,
+          mockCommandContext,
+        ),
+      );
+
+      expect(result.current.suggestions).toEqual([
+        { label: 'add', value: 'add', description: 'Add to memory' },
+      ]);
+    });
+
+    it('should provide no suggestions for an invalid sub-command', async () => {
+      const slashCommands = [
+        {
+          name: 'memory',
+          description: 'Manage memory',
+          subCommands: [
+            { name: 'show', description: 'Show memory' },
+            { name: 'add', description: 'Add to memory' },
+          ],
+        },
+      ] as unknown as SlashCommand[];
+      const { result } = renderHook(() =>
+        useTestHarnessForSlashCompletion(
+          true,
+          '/memory dothisnow',
+          slashCommands,
+          mockCommandContext,
+        ),
+      );
+
+      expect(result.current.suggestions).toHaveLength(0);
+    });
+  });
+
+  describe('Argument Completion', () => {
+    it('should call the command.completion function for argument suggestions', async () => {
+      const availableTags = [
+        'my-chat-tag-1',
+        'my-chat-tag-2',
+        'another-channel',
+      ];
+      const mockCompletionFn = vi
+        .fn()
+        .mockImplementation(
+          async (_context: CommandContext, partialArg: string) =>
+            availableTags.filter((tag) => tag.startsWith(partialArg)),
+        );
+
+      const slashCommands = [
+        {
+          name: 'chat',
+          description: 'Manage chat history',
+          subCommands: [
+            {
+              name: 'resume',
+              description: 'Resume a saved chat',
+              completion: mockCompletionFn,
+            },
+          ],
+        },
+      ] as unknown as SlashCommand[];
+
+      const { result } = renderHook(() =>
+        useTestHarnessForSlashCompletion(
+          true,
+          '/chat resume my-ch',
+          slashCommands,
+          mockCommandContext,
+        ),
+      );
+
+      await waitFor(() => {
+        expect(mockCompletionFn).toHaveBeenCalledWith(
+          mockCommandContext,
+          'my-ch',
+        );
+      });
+
+      await waitFor(() => {
+        expect(result.current.suggestions).toEqual([
+          { label: 'my-chat-tag-1', value: 'my-chat-tag-1' },
+          { label: 'my-chat-tag-2', value: 'my-chat-tag-2' },
+        ]);
+      });
+    });
+
+    it('should call command.completion with an empty string when args start with a space', async () => {
+      const mockCompletionFn = vi
+        .fn()
+        .mockResolvedValue(['my-chat-tag-1', 'my-chat-tag-2', 'my-channel']);
+
+      const slashCommands = [
+        {
+          name: 'chat',
+          description: 'Manage chat history',
+          subCommands: [
+            {
+              name: 'resume',
+              description: 'Resume a saved chat',
+              completion: mockCompletionFn,
+            },
+          ],
+        },
+      ] as unknown as SlashCommand[];
+
+      const { result } = renderHook(() =>
+        useTestHarnessForSlashCompletion(
+          true,
+          '/chat resume ',
+          slashCommands,
+          mockCommandContext,
+        ),
+      );
+
+      await waitFor(() => {
+        expect(mockCompletionFn).toHaveBeenCalledWith(mockCommandContext, '');
+      });
+
+      await waitFor(() => {
+        expect(result.current.suggestions).toHaveLength(3);
+      });
+    });
+
+    it('should handle completion function that returns null', async () => {
+      const completionFn = vi.fn().mockResolvedValue(null);
+      const slashCommands = [
+        {
+          name: 'chat',
+          description: 'Manage chat history',
+          subCommands: [
+            {
+              name: 'resume',
+              description: 'Resume a saved chat',
+              completion: completionFn,
+            },
+          ],
+        },
+      ] as unknown as SlashCommand[];
+
+      const { result } = renderHook(() =>
+        useTestHarnessForSlashCompletion(
+          true,
+          '/chat resume ',
+          slashCommands,
+          mockCommandContext,
+        ),
+      );
+
+      await waitFor(() => {
+        expect(result.current.suggestions).toHaveLength(0);
+      });
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/hooks/useSlashCompletion.ts

@@ -0,0 +1,187 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useEffect } from 'react';
+import { Suggestion } from '../components/SuggestionsDisplay.js';
+import { CommandContext, SlashCommand } from '../commands/types.js';
+
+export interface UseSlashCompletionProps {
+  enabled: boolean;
+  query: string | null;
+  slashCommands: readonly SlashCommand[];
+  commandContext: CommandContext;
+  setSuggestions: (suggestions: Suggestion[]) => void;
+  setIsLoadingSuggestions: (isLoading: boolean) => void;
+  setIsPerfectMatch: (isMatch: boolean) => void;
+}
+
+export function useSlashCompletion(props: UseSlashCompletionProps): {
+  completionStart: number;
+  completionEnd: number;
+} {
+  const {
+    enabled,
+    query,
+    slashCommands,
+    commandContext,
+    setSuggestions,
+    setIsLoadingSuggestions,
+    setIsPerfectMatch,
+  } = props;
+  const [completionStart, setCompletionStart] = useState(-1);
+  const [completionEnd, setCompletionEnd] = useState(-1);
+
+  useEffect(() => {
+    if (!enabled || query === null) {
+      return;
+    }
+
+    const fullPath = query?.substring(1) || '';
+    const hasTrailingSpace = !!query?.endsWith(' ');
+    const rawParts = fullPath.split(/\s+/).filter((p) => p);
+    let commandPathParts = rawParts;
+    let partial = '';
+
+    if (!hasTrailingSpace && rawParts.length > 0) {
+      partial = rawParts[rawParts.length - 1];
+      commandPathParts = rawParts.slice(0, -1);
+    }
+
+    let currentLevel: readonly SlashCommand[] | undefined = slashCommands;
+    let leafCommand: SlashCommand | null = null;
+
+    for (const part of commandPathParts) {
+      if (!currentLevel) {
+        leafCommand = null;
+        currentLevel = [];
+        break;
+      }
+      const found: SlashCommand | undefined = currentLevel.find(
+        (cmd) => cmd.name === part || cmd.altNames?.includes(part),
+      );
+      if (found) {
+        leafCommand = found;
+        currentLevel = found.subCommands as readonly SlashCommand[] | undefined;
+      } else {
+        leafCommand = null;
+        currentLevel = [];
+        break;
+      }
+    }
+
+    let exactMatchAsParent: SlashCommand | undefined;
+    if (!hasTrailingSpace && currentLevel) {
+      exactMatchAsParent = currentLevel.find(
+        (cmd) =>
+          (cmd.name === partial || cmd.altNames?.includes(partial)) &&
+          cmd.subCommands,
+      );
+
+      if (exactMatchAsParent) {
+        leafCommand = exactMatchAsParent;
+        currentLevel = exactMatchAsParent.subCommands;
+        partial = '';
+      }
+    }
+
+    setIsPerfectMatch(false);
+    if (!hasTrailingSpace) {
+      if (leafCommand && partial === '' && leafCommand.action) {
+        setIsPerfectMatch(true);
+      } else if (currentLevel) {
+        const perfectMatch = currentLevel.find(
+          (cmd) =>
+            (cmd.name === partial || cmd.altNames?.includes(partial)) &&
+            cmd.action,
+        );
+        if (perfectMatch) {
+          setIsPerfectMatch(true);
+        }
+      }
+    }
+
+    const depth = commandPathParts.length;
+    const isArgumentCompletion =
+      leafCommand?.completion &&
+      (hasTrailingSpace ||
+        (rawParts.length > depth && depth > 0 && partial !== ''));
+
+    if (hasTrailingSpace || exactMatchAsParent) {
+      setCompletionStart(query.length);
+      setCompletionEnd(query.length);
+    } else if (partial) {
+      if (isArgumentCompletion) {
+        const commandSoFar = `/${commandPathParts.join(' ')}`;
+        const argStartIndex =
+          commandSoFar.length + (commandPathParts.length > 0 ? 1 : 0);
+        setCompletionStart(argStartIndex);
+      } else {
+        setCompletionStart(query.length - partial.length);
+      }
+      setCompletionEnd(query.length);
+    } else {
+      setCompletionStart(1);
+      setCompletionEnd(query.length);
+    }
+
+    if (isArgumentCompletion) {
+      const fetchAndSetSuggestions = async () => {
+        setIsLoadingSuggestions(true);
+        const argString = rawParts.slice(depth).join(' ');
+        const results =
+          (await leafCommand!.completion!(commandContext, argString)) || [];
+        const finalSuggestions = results.map((s) => ({ label: s, value: s }));
+        setSuggestions(finalSuggestions);
+        setIsLoadingSuggestions(false);
+      };
+      fetchAndSetSuggestions();
+      return;
+    }
+
+    const commandsToSearch = currentLevel || [];
+    if (commandsToSearch.length > 0) {
+      let potentialSuggestions = commandsToSearch.filter(
+        (cmd) =>
+          cmd.description &&
+          (cmd.name.startsWith(partial) ||
+            cmd.altNames?.some((alt) => alt.startsWith(partial))),
+      );
+
+      if (potentialSuggestions.length > 0 && !hasTrailingSpace) {
+        const perfectMatch = potentialSuggestions.find(
+          (s) => s.name === partial || s.altNames?.includes(partial),
+        );
+        if (perfectMatch && perfectMatch.action) {
+          potentialSuggestions = [];
+        }
+      }
+
+      const finalSuggestions = potentialSuggestions.map((cmd) => ({
+        label: cmd.name,
+        value: cmd.name,
+        description: cmd.description,
+      }));
+
+      setSuggestions(finalSuggestions);
+      return;
+    }
+
+    setSuggestions([]);
+  }, [
+    enabled,
+    query,
+    slashCommands,
+    commandContext,
+    setSuggestions,
+    setIsLoadingSuggestions,
+    setIsPerfectMatch,
+  ]);
+
+  return {
+    completionStart,
+    completionEnd,
+  };
+}

projects/ui/qwen-code/packages/cli/src/ui/hooks/useStateAndRef.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+
+// Hook to return state, state setter, and ref to most up-to-date value of state.
+// We need this in order to setState and reference the updated state multiple
+// times in the same function.
+export const useStateAndRef = <
+  // Everything but function.
+  T extends object | null | undefined | number | string,
+>(
+  initialValue: T,
+) => {
+  const [_, setState] = React.useState<T>(initialValue);
+  const ref = React.useRef<T>(initialValue);
+
+  const setStateInternal = React.useCallback<typeof setState>(
+    (newStateOrCallback) => {
+      let newValue: T;
+      if (typeof newStateOrCallback === 'function') {
+        newValue = newStateOrCallback(ref.current);
+      } else {
+        newValue = newStateOrCallback;
+      }
+      setState(newValue);
+      ref.current = newValue;
+    },
+    [],
+  );
+
+  return [ref, setStateInternal] as const;
+};

projects/ui/qwen-code/packages/cli/src/ui/hooks/useTerminalSize.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useEffect, useState } from 'react';
+
+const TERMINAL_PADDING_X = 8;
+
+export function useTerminalSize(): { columns: number; rows: number } {
+  const [size, setSize] = useState({
+    columns: (process.stdout.columns || 60) - TERMINAL_PADDING_X,
+    rows: process.stdout.rows || 20,
+  });
+
+  useEffect(() => {
+    function updateSize() {
+      setSize({
+        columns: (process.stdout.columns || 60) - TERMINAL_PADDING_X,
+        rows: process.stdout.rows || 20,
+      });
+    }
+
+    process.stdout.on('resize', updateSize);
+    return () => {
+      process.stdout.off('resize', updateSize);
+    };
+  }, []);
+
+  return size;
+}

projects/ui/qwen-code/packages/cli/src/ui/hooks/useThemeCommand.ts

@@ -0,0 +1,110 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useCallback, useEffect } from 'react';
+import { themeManager } from '../themes/theme-manager.js';
+import { LoadedSettings, SettingScope } from '../../config/settings.js'; // Import LoadedSettings, AppSettings, MergedSetting
+import { type HistoryItem, MessageType } from '../types.js';
+import process from 'node:process';
+
+interface UseThemeCommandReturn {
+  isThemeDialogOpen: boolean;
+  openThemeDialog: () => void;
+  handleThemeSelect: (
+    themeName: string | undefined,
+    scope: SettingScope,
+  ) => void; // Added scope
+  handleThemeHighlight: (themeName: string | undefined) => void;
+}
+
+export const useThemeCommand = (
+  loadedSettings: LoadedSettings,
+  setThemeError: (error: string | null) => void,
+  addItem: (item: Omit<HistoryItem, 'id'>, timestamp: number) => void,
+): UseThemeCommandReturn => {
+  const [isThemeDialogOpen, setIsThemeDialogOpen] = useState(false);
+
+  // Check for invalid theme configuration on startup
+  useEffect(() => {
+    const effectiveTheme = loadedSettings.merged.theme;
+    if (effectiveTheme && !themeManager.findThemeByName(effectiveTheme)) {
+      setIsThemeDialogOpen(true);
+      setThemeError(`Theme "${effectiveTheme}" not found.`);
+    } else {
+      setThemeError(null);
+    }
+  }, [loadedSettings.merged.theme, setThemeError]);
+
+  const openThemeDialog = useCallback(() => {
+    if (process.env['NO_COLOR']) {
+      addItem(
+        {
+          type: MessageType.INFO,
+          text: 'Theme configuration unavailable due to NO_COLOR env variable.',
+        },
+        Date.now(),
+      );
+      return;
+    }
+    setIsThemeDialogOpen(true);
+  }, [addItem]);
+
+  const applyTheme = useCallback(
+    (themeName: string | undefined) => {
+      if (!themeManager.setActiveTheme(themeName)) {
+        // If theme is not found, open the theme selection dialog and set error message
+        setIsThemeDialogOpen(true);
+        setThemeError(`Theme "${themeName}" not found.`);
+      } else {
+        setThemeError(null); // Clear any previous theme error on success
+      }
+    },
+    [setThemeError],
+  );
+
+  const handleThemeHighlight = useCallback(
+    (themeName: string | undefined) => {
+      applyTheme(themeName);
+    },
+    [applyTheme],
+  );
+
+  const handleThemeSelect = useCallback(
+    (themeName: string | undefined, scope: SettingScope) => {
+      try {
+        // Merge user and workspace custom themes (workspace takes precedence)
+        const mergedCustomThemes = {
+          ...(loadedSettings.user.settings.customThemes || {}),
+          ...(loadedSettings.workspace.settings.customThemes || {}),
+        };
+        // Only allow selecting themes available in the merged custom themes or built-in themes
+        const isBuiltIn = themeManager.findThemeByName(themeName);
+        const isCustom = themeName && mergedCustomThemes[themeName];
+        if (!isBuiltIn && !isCustom) {
+          setThemeError(`Theme "${themeName}" not found in selected scope.`);
+          setIsThemeDialogOpen(true);
+          return;
+        }
+        loadedSettings.setValue(scope, 'theme', themeName); // Update the merged settings
+        if (loadedSettings.merged.customThemes) {
+          themeManager.loadCustomThemes(loadedSettings.merged.customThemes);
+        }
+        applyTheme(loadedSettings.merged.theme); // Apply the current theme
+        setThemeError(null);
+      } finally {
+        setIsThemeDialogOpen(false); // Close the dialog
+      }
+    },
+    [applyTheme, loadedSettings, setThemeError],
+  );
+
+  return {
+    isThemeDialogOpen,
+    openThemeDialog,
+    handleThemeSelect,
+    handleThemeHighlight,
+  };
+};

projects/ui/qwen-code/packages/cli/src/ui/hooks/useTimer.test.ts

@@ -0,0 +1,120 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useTimer } from './useTimer.js';
+
+describe('useTimer', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should initialize with 0', () => {
+    const { result } = renderHook(() => useTimer(false, 0));
+    expect(result.current).toBe(0);
+  });
+
+  it('should not increment time if isActive is false', () => {
+    const { result } = renderHook(() => useTimer(false, 0));
+    act(() => {
+      vi.advanceTimersByTime(5000);
+    });
+    expect(result.current).toBe(0);
+  });
+
+  it('should increment time every second if isActive is true', () => {
+    const { result } = renderHook(() => useTimer(true, 0));
+    act(() => {
+      vi.advanceTimersByTime(1000);
+    });
+    expect(result.current).toBe(1);
+    act(() => {
+      vi.advanceTimersByTime(2000);
+    });
+    expect(result.current).toBe(3);
+  });
+
+  it('should reset to 0 and start incrementing when isActive becomes true from false', () => {
+    const { result, rerender } = renderHook(
+      ({ isActive, resetKey }) => useTimer(isActive, resetKey),
+      { initialProps: { isActive: false, resetKey: 0 } },
+    );
+    expect(result.current).toBe(0);
+
+    rerender({ isActive: true, resetKey: 0 });
+    expect(result.current).toBe(0); // Should reset to 0 upon becoming active
+
+    act(() => {
+      vi.advanceTimersByTime(1000);
+    });
+    expect(result.current).toBe(1);
+  });
+
+  it('should reset to 0 when resetKey changes while active', () => {
+    const { result, rerender } = renderHook(
+      ({ isActive, resetKey }) => useTimer(isActive, resetKey),
+      { initialProps: { isActive: true, resetKey: 0 } },
+    );
+    act(() => {
+      vi.advanceTimersByTime(3000); // 3s
+    });
+    expect(result.current).toBe(3);
+
+    rerender({ isActive: true, resetKey: 1 }); // Change resetKey
+    expect(result.current).toBe(0); // Should reset to 0
+
+    act(() => {
+      vi.advanceTimersByTime(1000);
+    });
+    expect(result.current).toBe(1); // Starts incrementing from 0
+  });
+
+  it('should be 0 if isActive is false, regardless of resetKey changes', () => {
+    const { result, rerender } = renderHook(
+      ({ isActive, resetKey }) => useTimer(isActive, resetKey),
+      { initialProps: { isActive: false, resetKey: 0 } },
+    );
+    expect(result.current).toBe(0);
+
+    rerender({ isActive: false, resetKey: 1 });
+    expect(result.current).toBe(0);
+  });
+
+  it('should clear timer on unmount', () => {
+    const { unmount } = renderHook(() => useTimer(true, 0));
+    const clearIntervalSpy = vi.spyOn(global, 'clearInterval');
+    unmount();
+    expect(clearIntervalSpy).toHaveBeenCalledOnce();
+  });
+
+  it('should preserve elapsedTime when isActive becomes false, and reset to 0 when it becomes active again', () => {
+    const { result, rerender } = renderHook(
+      ({ isActive, resetKey }) => useTimer(isActive, resetKey),
+      { initialProps: { isActive: true, resetKey: 0 } },
+    );
+
+    act(() => {
+      vi.advanceTimersByTime(3000); // Advance to 3 seconds
+    });
+    expect(result.current).toBe(3);
+
+    rerender({ isActive: false, resetKey: 0 });
+    expect(result.current).toBe(3); // Time should be preserved when timer becomes inactive
+
+    // Now make it active again, it should reset to 0
+    rerender({ isActive: true, resetKey: 0 });
+    expect(result.current).toBe(0);
+    act(() => {
+      vi.advanceTimersByTime(1000);
+    });
+    expect(result.current).toBe(1);
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/hooks/useTimer.ts

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useEffect, useRef } from 'react';
+
+/**
+ * Custom hook to manage a timer that increments every second.
+ * @param isActive Whether the timer should be running.
+ * @param resetKey A key that, when changed, will reset the timer to 0 and restart the interval.
+ * @returns The elapsed time in seconds.
+ */
+export const useTimer = (isActive: boolean, resetKey: unknown) => {
+  const [elapsedTime, setElapsedTime] = useState(0);
+  const timerRef = useRef<NodeJS.Timeout | null>(null);
+  const prevResetKeyRef = useRef(resetKey);
+  const prevIsActiveRef = useRef(isActive);
+
+  useEffect(() => {
+    let shouldResetTime = false;
+
+    if (prevResetKeyRef.current !== resetKey) {
+      shouldResetTime = true;
+      prevResetKeyRef.current = resetKey;
+    }
+
+    if (prevIsActiveRef.current === false && isActive) {
+      // Transitioned from inactive to active
+      shouldResetTime = true;
+    }
+
+    if (shouldResetTime) {
+      setElapsedTime(0);
+    }
+    prevIsActiveRef.current = isActive;
+
+    // Manage interval
+    if (isActive) {
+      // Clear previous interval unconditionally before starting a new one
+      // This handles resetKey changes while active, ensuring a fresh interval start.
+      if (timerRef.current) {
+        clearInterval(timerRef.current);
+      }
+      timerRef.current = setInterval(() => {
+        setElapsedTime((prev) => prev + 1);
+      }, 1000);
+    } else {
+      if (timerRef.current) {
+        clearInterval(timerRef.current);
+        timerRef.current = null;
+      }
+    }
+
+    return () => {
+      if (timerRef.current) {
+        clearInterval(timerRef.current);
+        timerRef.current = null;
+      }
+    };
+  }, [isActive, resetKey]);
+
+  return elapsedTime;
+};

projects/ui/qwen-code/packages/cli/src/ui/hooks/useToolScheduler.test.ts

@@ -0,0 +1,1123 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach, afterEach, Mock } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import {
+  useReactToolScheduler,
+  mapToDisplay,
+} from './useReactToolScheduler.js';
+import { PartUnion, FunctionResponse } from '@google/genai';
+import {
+  Config,
+  ToolCallRequestInfo,
+  ToolRegistry,
+  ToolResult,
+  ToolCallConfirmationDetails,
+  ToolConfirmationOutcome,
+  ToolCallResponseInfo,
+  ToolCall, // Import from core
+  Status as ToolCallStatusType,
+  ApprovalMode,
+  Kind,
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  ToolInvocation,
+  AnyDeclarativeTool,
+  AnyToolInvocation,
+} from '@qwen-code/qwen-code-core';
+import {
+  HistoryItemWithoutId,
+  ToolCallStatus,
+  HistoryItemToolGroup,
+} from '../types.js';
+
+// Mocks
+vi.mock('@qwen-code/qwen-code-core', async () => {
+  const actual = await vi.importActual('@qwen-code/qwen-code-core');
+  return {
+    ...actual,
+    ToolRegistry: vi.fn(),
+    Config: vi.fn(),
+  };
+});
+
+const mockToolRegistry = {
+  getTool: vi.fn(),
+};
+
+const mockConfig = {
+  getToolRegistry: vi.fn(() => mockToolRegistry as unknown as ToolRegistry),
+  getApprovalMode: vi.fn(() => ApprovalMode.DEFAULT),
+  getUsageStatisticsEnabled: () => true,
+  getDebugMode: () => false,
+  getSessionId: () => 'test-session-id',
+  getContentGeneratorConfig: () => ({
+    model: 'test-model',
+    authType: 'oauth-personal',
+  }),
+};
+
+class MockToolInvocation extends BaseToolInvocation<object, ToolResult> {
+  constructor(
+    private readonly tool: MockTool,
+    params: object,
+  ) {
+    super(params);
+  }
+
+  getDescription(): string {
+    return JSON.stringify(this.params);
+  }
+
+  override shouldConfirmExecute(
+    abortSignal: AbortSignal,
+  ): Promise<ToolCallConfirmationDetails | false> {
+    return this.tool.shouldConfirmExecute(this.params, abortSignal);
+  }
+
+  execute(
+    signal: AbortSignal,
+    updateOutput?: (output: string) => void,
+    terminalColumns?: number,
+    terminalRows?: number,
+  ): Promise<ToolResult> {
+    return this.tool.execute(
+      this.params,
+      signal,
+      updateOutput,
+      terminalColumns,
+      terminalRows,
+    );
+  }
+}
+
+class MockTool extends BaseDeclarativeTool<object, ToolResult> {
+  constructor(
+    name: string,
+    displayName: string,
+    canUpdateOutput = false,
+    shouldConfirm = false,
+    isOutputMarkdown = false,
+  ) {
+    super(
+      name,
+      displayName,
+      'A mock tool for testing',
+      Kind.Other,
+      {},
+      isOutputMarkdown,
+      canUpdateOutput,
+    );
+    if (shouldConfirm) {
+      this.shouldConfirmExecute.mockImplementation(
+        async (): Promise<ToolCallConfirmationDetails | false> => ({
+          type: 'edit',
+          title: 'Mock Tool Requires Confirmation',
+          onConfirm: mockOnUserConfirmForToolConfirmation,
+          filePath: 'mock',
+          fileName: 'mockToolRequiresConfirmation.ts',
+          fileDiff: 'Mock tool requires confirmation',
+          originalContent: 'Original content',
+          newContent: 'New content',
+        }),
+      );
+    }
+  }
+
+  execute = vi.fn();
+  shouldConfirmExecute = vi.fn();
+
+  protected createInvocation(
+    params: object,
+  ): ToolInvocation<object, ToolResult> {
+    return new MockToolInvocation(this, params);
+  }
+}
+
+const mockTool = new MockTool('mockTool', 'Mock Tool');
+const mockToolWithLiveOutput = new MockTool(
+  'mockToolWithLiveOutput',
+  'Mock Tool With Live Output',
+  true,
+);
+let mockOnUserConfirmForToolConfirmation: Mock;
+const mockToolRequiresConfirmation = new MockTool(
+  'mockToolRequiresConfirmation',
+  'Mock Tool Requires Confirmation',
+  false,
+  true,
+);
+
+describe('useReactToolScheduler in YOLO Mode', () => {
+  let onComplete: Mock;
+  let setPendingHistoryItem: Mock;
+
+  beforeEach(() => {
+    onComplete = vi.fn();
+    setPendingHistoryItem = vi.fn();
+    mockToolRegistry.getTool.mockClear();
+    (mockToolRequiresConfirmation.execute as Mock).mockClear();
+    (mockToolRequiresConfirmation.shouldConfirmExecute as Mock).mockClear();
+
+    // IMPORTANT: Enable YOLO mode for this test suite
+    (mockConfig.getApprovalMode as Mock).mockReturnValue(ApprovalMode.YOLO);
+
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.clearAllTimers();
+    vi.useRealTimers();
+    // IMPORTANT: Disable YOLO mode after this test suite
+    (mockConfig.getApprovalMode as Mock).mockReturnValue(ApprovalMode.DEFAULT);
+  });
+
+  const renderSchedulerInYoloMode = () =>
+    renderHook(() =>
+      useReactToolScheduler(
+        onComplete,
+        mockConfig as unknown as Config,
+        setPendingHistoryItem,
+        () => undefined,
+        () => {},
+      ),
+    );
+
+  it('should skip confirmation and execute tool directly when yoloMode is true', async () => {
+    mockToolRegistry.getTool.mockReturnValue(mockToolRequiresConfirmation);
+    const expectedOutput = 'YOLO Confirmed output';
+    (mockToolRequiresConfirmation.execute as Mock).mockResolvedValue({
+      llmContent: expectedOutput,
+      returnDisplay: 'YOLO Formatted tool output',
+      summary: 'YOLO summary',
+    } as ToolResult);
+
+    const { result } = renderSchedulerInYoloMode();
+    const schedule = result.current[1];
+    const request: ToolCallRequestInfo = {
+      callId: 'yoloCall',
+      name: 'mockToolRequiresConfirmation',
+      args: { data: 'any data' },
+    } as any;
+
+    act(() => {
+      schedule(request, new AbortController().signal);
+    });
+
+    await act(async () => {
+      await vi.runAllTimersAsync(); // Process validation
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync(); // Process scheduling
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync(); // Process execution
+    });
+
+    // Check that shouldConfirmExecute was NOT called
+    expect(
+      mockToolRequiresConfirmation.shouldConfirmExecute,
+    ).not.toHaveBeenCalled();
+
+    // Check that execute WAS called
+    expect(mockToolRequiresConfirmation.execute).toHaveBeenCalledWith(
+      request.args,
+      expect.any(AbortSignal),
+      undefined,
+      undefined,
+      undefined,
+    );
+
+    // Check that onComplete was called with success
+    expect(onComplete).toHaveBeenCalledWith([
+      expect.objectContaining({
+        status: 'success',
+        request,
+        response: expect.objectContaining({
+          resultDisplay: 'YOLO Formatted tool output',
+          responseParts: {
+            functionResponse: {
+              id: 'yoloCall',
+              name: 'mockToolRequiresConfirmation',
+              response: { output: expectedOutput },
+            },
+          },
+        }),
+      }),
+    ]);
+
+    // Ensure no confirmation UI was triggered (setPendingHistoryItem should not have been called with confirmation details)
+    const setPendingHistoryItemCalls = setPendingHistoryItem.mock.calls;
+    const confirmationCall = setPendingHistoryItemCalls.find((call) => {
+      const item = typeof call[0] === 'function' ? call[0]({}) : call[0];
+      return item?.tools?.[0]?.confirmationDetails;
+    });
+    expect(confirmationCall).toBeUndefined();
+  });
+});
+
+describe('useReactToolScheduler', () => {
+  // TODO(ntaylormullen): The following tests are skipped due to difficulties in
+  // reliably testing the asynchronous state updates and interactions with timers.
+  // These tests involve complex sequences of events, including confirmations,
+  // live output updates, and cancellations, which are challenging to assert
+  // correctly with the current testing setup. Further investigation is needed
+  // to find a robust way to test these scenarios.
+  let onComplete: Mock;
+  let setPendingHistoryItem: Mock;
+  let capturedOnConfirmForTest:
+    | ((outcome: ToolConfirmationOutcome) => void | Promise<void>)
+    | undefined;
+
+  beforeEach(() => {
+    onComplete = vi.fn();
+    capturedOnConfirmForTest = undefined;
+    setPendingHistoryItem = vi.fn((updaterOrValue) => {
+      let pendingItem: HistoryItemWithoutId | null = null;
+      if (typeof updaterOrValue === 'function') {
+        // Loosen the type for prevState to allow for more flexible updates in tests
+        const prevState: Partial<HistoryItemToolGroup> = {
+          type: 'tool_group', // Still default to tool_group for most cases
+          tools: [],
+        };
+
+        pendingItem = updaterOrValue(prevState as any); // Allow any for more flexibility
+      } else {
+        pendingItem = updaterOrValue;
+      }
+      // Capture onConfirm if it exists, regardless of the exact type of pendingItem
+      // This is a common pattern in these tests.
+      if (
+        (pendingItem as HistoryItemToolGroup)?.tools?.[0]?.confirmationDetails
+          ?.onConfirm
+      ) {
+        capturedOnConfirmForTest = (pendingItem as HistoryItemToolGroup)
+          .tools[0].confirmationDetails?.onConfirm;
+      }
+    });
+
+    mockToolRegistry.getTool.mockClear();
+    (mockTool.execute as Mock).mockClear();
+    (mockTool.shouldConfirmExecute as Mock).mockClear();
+    (mockToolWithLiveOutput.execute as Mock).mockClear();
+    (mockToolWithLiveOutput.shouldConfirmExecute as Mock).mockClear();
+    (mockToolRequiresConfirmation.execute as Mock).mockClear();
+    (mockToolRequiresConfirmation.shouldConfirmExecute as Mock).mockClear();
+
+    mockOnUserConfirmForToolConfirmation = vi.fn();
+    (
+      mockToolRequiresConfirmation.shouldConfirmExecute as Mock
+    ).mockImplementation(
+      async (): Promise<ToolCallConfirmationDetails | null> =>
+        ({
+          onConfirm: mockOnUserConfirmForToolConfirmation,
+          fileName: 'mockToolRequiresConfirmation.ts',
+          fileDiff: 'Mock tool requires confirmation',
+          type: 'edit',
+          title: 'Mock Tool Requires Confirmation',
+        }) as any,
+    );
+
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.clearAllTimers();
+    vi.useRealTimers();
+  });
+
+  const renderScheduler = () =>
+    renderHook(() =>
+      useReactToolScheduler(
+        onComplete,
+        mockConfig as unknown as Config,
+        setPendingHistoryItem,
+        () => undefined,
+        () => {},
+      ),
+    );
+
+  it('initial state should be empty', () => {
+    const { result } = renderScheduler();
+    expect(result.current[0]).toEqual([]);
+  });
+
+  it('should schedule and execute a tool call successfully', async () => {
+    mockToolRegistry.getTool.mockReturnValue(mockTool);
+    (mockTool.execute as Mock).mockResolvedValue({
+      llmContent: 'Tool output',
+      returnDisplay: 'Formatted tool output',
+      summary: 'Formatted summary',
+    } as ToolResult);
+    (mockTool.shouldConfirmExecute as Mock).mockResolvedValue(null);
+
+    const { result } = renderScheduler();
+    const schedule = result.current[1];
+    const request: ToolCallRequestInfo = {
+      callId: 'call1',
+      name: 'mockTool',
+      args: { param: 'value' },
+    } as any;
+
+    act(() => {
+      schedule(request, new AbortController().signal);
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(mockTool.execute).toHaveBeenCalledWith(
+      request.args,
+      expect.any(AbortSignal),
+      undefined,
+      undefined,
+      undefined,
+    );
+    expect(onComplete).toHaveBeenCalledWith([
+      expect.objectContaining({
+        status: 'success',
+        request,
+        response: expect.objectContaining({
+          resultDisplay: 'Formatted tool output',
+          responseParts: {
+            functionResponse: {
+              id: 'call1',
+              name: 'mockTool',
+              response: { output: 'Tool output' },
+            },
+          },
+        }),
+      }),
+    ]);
+    expect(result.current[0]).toEqual([]);
+  });
+
+  it('should handle tool not found', async () => {
+    mockToolRegistry.getTool.mockReturnValue(undefined);
+    const { result } = renderScheduler();
+    const schedule = result.current[1];
+    const request: ToolCallRequestInfo = {
+      callId: 'call1',
+      name: 'nonexistentTool',
+      args: {},
+    } as any;
+
+    act(() => {
+      schedule(request, new AbortController().signal);
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(onComplete).toHaveBeenCalledWith([
+      expect.objectContaining({
+        status: 'error',
+        request,
+        response: expect.objectContaining({
+          error: expect.objectContaining({
+            message: 'Tool "nonexistentTool" not found in registry.',
+          }),
+        }),
+      }),
+    ]);
+    expect(result.current[0]).toEqual([]);
+  });
+
+  it('should handle error during shouldConfirmExecute', async () => {
+    mockToolRegistry.getTool.mockReturnValue(mockTool);
+    const confirmError = new Error('Confirmation check failed');
+    (mockTool.shouldConfirmExecute as Mock).mockRejectedValue(confirmError);
+
+    const { result } = renderScheduler();
+    const schedule = result.current[1];
+    const request: ToolCallRequestInfo = {
+      callId: 'call1',
+      name: 'mockTool',
+      args: {},
+    } as any;
+
+    act(() => {
+      schedule(request, new AbortController().signal);
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(onComplete).toHaveBeenCalledWith([
+      expect.objectContaining({
+        status: 'error',
+        request,
+        response: expect.objectContaining({
+          error: confirmError,
+        }),
+      }),
+    ]);
+    expect(result.current[0]).toEqual([]);
+  });
+
+  it('should handle error during execute', async () => {
+    mockToolRegistry.getTool.mockReturnValue(mockTool);
+    (mockTool.shouldConfirmExecute as Mock).mockResolvedValue(null);
+    const execError = new Error('Execution failed');
+    (mockTool.execute as Mock).mockRejectedValue(execError);
+
+    const { result } = renderScheduler();
+    const schedule = result.current[1];
+    const request: ToolCallRequestInfo = {
+      callId: 'call1',
+      name: 'mockTool',
+      args: {},
+    } as any;
+
+    act(() => {
+      schedule(request, new AbortController().signal);
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(onComplete).toHaveBeenCalledWith([
+      expect.objectContaining({
+        status: 'error',
+        request,
+        response: expect.objectContaining({
+          error: execError,
+        }),
+      }),
+    ]);
+    expect(result.current[0]).toEqual([]);
+  });
+
+  it.skip('should handle tool requiring confirmation - approved', async () => {
+    mockToolRegistry.getTool.mockReturnValue(mockToolRequiresConfirmation);
+    const expectedOutput = 'Confirmed output';
+    (mockToolRequiresConfirmation.execute as Mock).mockResolvedValue({
+      llmContent: expectedOutput,
+      returnDisplay: 'Confirmed display',
+      summary: 'Confirmed summary',
+    } as ToolResult);
+
+    const { result } = renderScheduler();
+    const schedule = result.current[1];
+    const request: ToolCallRequestInfo = {
+      callId: 'callConfirm',
+      name: 'mockToolRequiresConfirmation',
+      args: { data: 'sensitive' },
+    } as any;
+
+    act(() => {
+      schedule(request, new AbortController().signal);
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(setPendingHistoryItem).toHaveBeenCalled();
+    expect(capturedOnConfirmForTest).toBeDefined();
+
+    await act(async () => {
+      await capturedOnConfirmForTest?.(ToolConfirmationOutcome.ProceedOnce);
+    });
+
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(mockOnUserConfirmForToolConfirmation).toHaveBeenCalledWith(
+      ToolConfirmationOutcome.ProceedOnce,
+    );
+    expect(mockToolRequiresConfirmation.execute).toHaveBeenCalled();
+    expect(onComplete).toHaveBeenCalledWith([
+      expect.objectContaining({
+        status: 'success',
+        request,
+        response: expect.objectContaining({
+          resultDisplay: 'Confirmed display',
+          responseParts: expect.arrayContaining([
+            expect.objectContaining({
+              functionResponse: expect.objectContaining({
+                response: { output: expectedOutput },
+              }),
+            }),
+          ]),
+        }),
+      }),
+    ]);
+  });
+
+  it.skip('should handle tool requiring confirmation - cancelled by user', async () => {
+    mockToolRegistry.getTool.mockReturnValue(mockToolRequiresConfirmation);
+    const { result } = renderScheduler();
+    const schedule = result.current[1];
+    const request: ToolCallRequestInfo = {
+      callId: 'callConfirmCancel',
+      name: 'mockToolRequiresConfirmation',
+      args: {},
+    } as any;
+
+    act(() => {
+      schedule(request, new AbortController().signal);
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(setPendingHistoryItem).toHaveBeenCalled();
+    expect(capturedOnConfirmForTest).toBeDefined();
+
+    await act(async () => {
+      await capturedOnConfirmForTest?.(ToolConfirmationOutcome.Cancel);
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(mockOnUserConfirmForToolConfirmation).toHaveBeenCalledWith(
+      ToolConfirmationOutcome.Cancel,
+    );
+    expect(onComplete).toHaveBeenCalledWith([
+      expect.objectContaining({
+        status: 'cancelled',
+        request,
+        response: expect.objectContaining({
+          responseParts: expect.arrayContaining([
+            expect.objectContaining({
+              functionResponse: expect.objectContaining({
+                response: expect.objectContaining({
+                  error: `User did not allow tool call ${request.name}. Reason: User cancelled.`,
+                }),
+              }),
+            }),
+          ]),
+        }),
+      }),
+    ]);
+  });
+
+  it.skip('should handle live output updates', async () => {
+    mockToolRegistry.getTool.mockReturnValue(mockToolWithLiveOutput);
+    let liveUpdateFn: ((output: string) => void) | undefined;
+    let resolveExecutePromise: (value: ToolResult) => void;
+    const executePromise = new Promise<ToolResult>((resolve) => {
+      resolveExecutePromise = resolve;
+    });
+
+    (mockToolWithLiveOutput.execute as Mock).mockImplementation(
+      async (
+        _args: Record<string, unknown>,
+        _signal: AbortSignal,
+        updateFn: ((output: string) => void) | undefined,
+      ) => {
+        liveUpdateFn = updateFn;
+        return executePromise;
+      },
+    );
+    (mockToolWithLiveOutput.shouldConfirmExecute as Mock).mockResolvedValue(
+      null,
+    );
+
+    const { result } = renderScheduler();
+    const schedule = result.current[1];
+    const request: ToolCallRequestInfo = {
+      callId: 'liveCall',
+      name: 'mockToolWithLiveOutput',
+      args: {},
+    } as any;
+
+    act(() => {
+      schedule(request, new AbortController().signal);
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(liveUpdateFn).toBeDefined();
+    expect(setPendingHistoryItem).toHaveBeenCalled();
+
+    await act(async () => {
+      liveUpdateFn?.('Live output 1');
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    await act(async () => {
+      liveUpdateFn?.('Live output 2');
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    act(() => {
+      resolveExecutePromise({
+        llmContent: 'Final output',
+        returnDisplay: 'Final display',
+        summary: 'Final summary',
+      } as ToolResult);
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(onComplete).toHaveBeenCalledWith([
+      expect.objectContaining({
+        status: 'success',
+        request,
+        response: expect.objectContaining({
+          resultDisplay: 'Final display',
+          responseParts: expect.arrayContaining([
+            expect.objectContaining({
+              functionResponse: expect.objectContaining({
+                response: { output: 'Final output' },
+              }),
+            }),
+          ]),
+        }),
+      }),
+    ]);
+    expect(result.current[0]).toEqual([]);
+  });
+
+  it('should schedule and execute multiple tool calls', async () => {
+    const tool1 = new MockTool('tool1', 'Tool 1');
+    tool1.execute.mockResolvedValue({
+      llmContent: 'Output 1',
+      returnDisplay: 'Display 1',
+      summary: 'Summary 1',
+    } as ToolResult);
+    tool1.shouldConfirmExecute.mockResolvedValue(null);
+
+    const tool2 = new MockTool('tool2', 'Tool 2');
+    tool2.execute.mockResolvedValue({
+      llmContent: 'Output 2',
+      returnDisplay: 'Display 2',
+      summary: 'Summary 2',
+    } as ToolResult);
+    tool2.shouldConfirmExecute.mockResolvedValue(null);
+
+    mockToolRegistry.getTool.mockImplementation((name) => {
+      if (name === 'tool1') return tool1;
+      if (name === 'tool2') return tool2;
+      return undefined;
+    });
+
+    const { result } = renderScheduler();
+    const schedule = result.current[1];
+    const requests: ToolCallRequestInfo[] = [
+      { callId: 'multi1', name: 'tool1', args: { p: 1 } } as any,
+      { callId: 'multi2', name: 'tool2', args: { p: 2 } } as any,
+    ];
+
+    act(() => {
+      schedule(requests, new AbortController().signal);
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(onComplete).toHaveBeenCalledTimes(1);
+    const completedCalls = onComplete.mock.calls[0][0] as ToolCall[];
+    expect(completedCalls.length).toBe(2);
+
+    const call1Result = completedCalls.find(
+      (c) => c.request.callId === 'multi1',
+    );
+    const call2Result = completedCalls.find(
+      (c) => c.request.callId === 'multi2',
+    );
+
+    expect(call1Result).toMatchObject({
+      status: 'success',
+      request: requests[0],
+      response: expect.objectContaining({
+        resultDisplay: 'Display 1',
+        responseParts: {
+          functionResponse: {
+            id: 'multi1',
+            name: 'tool1',
+            response: { output: 'Output 1' },
+          },
+        },
+      }),
+    });
+    expect(call2Result).toMatchObject({
+      status: 'success',
+      request: requests[1],
+      response: expect.objectContaining({
+        resultDisplay: 'Display 2',
+        responseParts: {
+          functionResponse: {
+            id: 'multi2',
+            name: 'tool2',
+            response: { output: 'Output 2' },
+          },
+        },
+      }),
+    });
+    expect(result.current[0]).toEqual([]);
+  });
+
+  it.skip('should throw error if scheduling while already running', async () => {
+    mockToolRegistry.getTool.mockReturnValue(mockTool);
+    const longExecutePromise = new Promise<ToolResult>((resolve) =>
+      setTimeout(
+        () =>
+          resolve({
+            llmContent: 'done',
+            returnDisplay: 'done display',
+            summary: 'done summary',
+          }),
+        50,
+      ),
+    );
+    (mockTool.execute as Mock).mockReturnValue(longExecutePromise);
+    (mockTool.shouldConfirmExecute as Mock).mockResolvedValue(null);
+
+    const { result } = renderScheduler();
+    const schedule = result.current[1];
+    const request1: ToolCallRequestInfo = {
+      callId: 'run1',
+      name: 'mockTool',
+      args: {},
+    } as any;
+    const request2: ToolCallRequestInfo = {
+      callId: 'run2',
+      name: 'mockTool',
+      args: {},
+    } as any;
+
+    act(() => {
+      schedule(request1, new AbortController().signal);
+    });
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+
+    expect(() => schedule(request2, new AbortController().signal)).toThrow(
+      'Cannot schedule tool calls while other tool calls are running',
+    );
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(50);
+      await vi.runAllTimersAsync();
+      await act(async () => {
+        await vi.runAllTimersAsync();
+      });
+    });
+    expect(onComplete).toHaveBeenCalledWith([
+      expect.objectContaining({
+        status: 'success',
+        request: request1,
+        response: expect.objectContaining({ resultDisplay: 'done display' }),
+      }),
+    ]);
+    expect(result.current[0]).toEqual([]);
+  });
+});
+
+describe('mapToDisplay', () => {
+  const baseRequest: ToolCallRequestInfo = {
+    callId: 'testCallId',
+    name: 'testTool',
+    args: { foo: 'bar' },
+  } as any;
+
+  const baseTool = new MockTool('testTool', 'Test Tool Display');
+
+  const baseResponse: ToolCallResponseInfo = {
+    callId: 'testCallId',
+    responseParts: [
+      {
+        functionResponse: {
+          name: 'testTool',
+          id: 'testCallId',
+          response: { output: 'Test output' },
+        } as FunctionResponse,
+      } as PartUnion,
+    ],
+    resultDisplay: 'Test display output',
+    error: undefined,
+  } as any;
+
+  // Define a more specific type for extraProps for these tests
+  // This helps ensure that tool and confirmationDetails are only accessed when they are expected to exist.
+  type MapToDisplayExtraProps =
+    | {
+        tool?: AnyDeclarativeTool;
+        invocation?: AnyToolInvocation;
+        liveOutput?: string;
+        response?: ToolCallResponseInfo;
+        confirmationDetails?: ToolCallConfirmationDetails;
+      }
+    | {
+        tool: AnyDeclarativeTool;
+        invocation?: AnyToolInvocation;
+        response?: ToolCallResponseInfo;
+        confirmationDetails?: ToolCallConfirmationDetails;
+      }
+    | {
+        response: ToolCallResponseInfo;
+        tool?: undefined;
+        confirmationDetails?: ToolCallConfirmationDetails;
+      }
+    | {
+        confirmationDetails: ToolCallConfirmationDetails;
+        tool?: AnyDeclarativeTool;
+        invocation?: AnyToolInvocation;
+        response?: ToolCallResponseInfo;
+      };
+
+  const baseInvocation = baseTool.build(baseRequest.args);
+  const testCases: Array<{
+    name: string;
+    status: ToolCallStatusType;
+    extraProps?: MapToDisplayExtraProps;
+    expectedStatus: ToolCallStatus;
+    expectedResultDisplay?: string;
+    expectedName?: string;
+    expectedDescription?: string;
+  }> = [
+    {
+      name: 'validating',
+      status: 'validating',
+      extraProps: { tool: baseTool, invocation: baseInvocation },
+      expectedStatus: ToolCallStatus.Executing,
+      expectedName: baseTool.displayName,
+      expectedDescription: baseInvocation.getDescription(),
+    },
+    {
+      name: 'awaiting_approval',
+      status: 'awaiting_approval',
+      extraProps: {
+        tool: baseTool,
+        invocation: baseInvocation,
+        confirmationDetails: {
+          onConfirm: vi.fn(),
+          type: 'edit',
+          title: 'Test Tool Display',
+          serverName: 'testTool',
+          toolName: 'testTool',
+          toolDisplayName: 'Test Tool Display',
+          filePath: 'mock',
+          fileName: 'test.ts',
+          fileDiff: 'Test diff',
+          originalContent: 'Original content',
+          newContent: 'New content',
+        } as ToolCallConfirmationDetails,
+      },
+      expectedStatus: ToolCallStatus.Confirming,
+      expectedName: baseTool.displayName,
+      expectedDescription: baseInvocation.getDescription(),
+    },
+    {
+      name: 'scheduled',
+      status: 'scheduled',
+      extraProps: { tool: baseTool, invocation: baseInvocation },
+      expectedStatus: ToolCallStatus.Pending,
+      expectedName: baseTool.displayName,
+      expectedDescription: baseInvocation.getDescription(),
+    },
+    {
+      name: 'executing no live output',
+      status: 'executing',
+      extraProps: { tool: baseTool, invocation: baseInvocation },
+      expectedStatus: ToolCallStatus.Executing,
+      expectedName: baseTool.displayName,
+      expectedDescription: baseInvocation.getDescription(),
+    },
+    {
+      name: 'executing with live output',
+      status: 'executing',
+      extraProps: {
+        tool: baseTool,
+        invocation: baseInvocation,
+        liveOutput: 'Live test output',
+      },
+      expectedStatus: ToolCallStatus.Executing,
+      expectedResultDisplay: 'Live test output',
+      expectedName: baseTool.displayName,
+      expectedDescription: baseInvocation.getDescription(),
+    },
+    {
+      name: 'success',
+      status: 'success',
+      extraProps: {
+        tool: baseTool,
+        invocation: baseInvocation,
+        response: baseResponse,
+      },
+      expectedStatus: ToolCallStatus.Success,
+      expectedResultDisplay: baseResponse.resultDisplay as any,
+      expectedName: baseTool.displayName,
+      expectedDescription: baseInvocation.getDescription(),
+    },
+    {
+      name: 'error tool not found',
+      status: 'error',
+      extraProps: {
+        response: {
+          ...baseResponse,
+          error: new Error('Test error tool not found'),
+          resultDisplay: 'Error display tool not found',
+        },
+      },
+      expectedStatus: ToolCallStatus.Error,
+      expectedResultDisplay: 'Error display tool not found',
+      expectedName: baseRequest.name,
+      expectedDescription: JSON.stringify(baseRequest.args),
+    },
+    {
+      name: 'error tool execution failed',
+      status: 'error',
+      extraProps: {
+        tool: baseTool,
+        response: {
+          ...baseResponse,
+          error: new Error('Tool execution failed'),
+          resultDisplay: 'Execution failed display',
+        },
+      },
+      expectedStatus: ToolCallStatus.Error,
+      expectedResultDisplay: 'Execution failed display',
+      expectedName: baseTool.displayName, // Changed from baseTool.name
+      expectedDescription: baseInvocation.getDescription(),
+    },
+    {
+      name: 'cancelled',
+      status: 'cancelled',
+      extraProps: {
+        tool: baseTool,
+        invocation: baseInvocation,
+        response: {
+          ...baseResponse,
+          resultDisplay: 'Cancelled display',
+        },
+      },
+      expectedStatus: ToolCallStatus.Canceled,
+      expectedResultDisplay: 'Cancelled display',
+      expectedName: baseTool.displayName,
+      expectedDescription: baseInvocation.getDescription(),
+    },
+  ];
+
+  testCases.forEach(
+    ({
+      name: testName,
+      status,
+      extraProps,
+      expectedStatus,
+      expectedResultDisplay,
+      expectedName,
+      expectedDescription,
+    }) => {
+      it(`should map ToolCall with status '${status}' (${testName}) correctly`, () => {
+        const toolCall: ToolCall = {
+          request: baseRequest,
+          status,
+          ...(extraProps || {}),
+        } as ToolCall;
+
+        const display = mapToDisplay(toolCall);
+        expect(display.type).toBe('tool_group');
+        expect(display.tools.length).toBe(1);
+        const toolDisplay = display.tools[0];
+
+        expect(toolDisplay.callId).toBe(baseRequest.callId);
+        expect(toolDisplay.status).toBe(expectedStatus);
+        expect(toolDisplay.resultDisplay).toBe(expectedResultDisplay);
+
+        expect(toolDisplay.name).toBe(expectedName);
+        expect(toolDisplay.description).toBe(expectedDescription);
+
+        expect(toolDisplay.renderOutputAsMarkdown).toBe(
+          extraProps?.tool?.isOutputMarkdown ?? false,
+        );
+        if (status === 'awaiting_approval') {
+          expect(toolDisplay.confirmationDetails).toBe(
+            extraProps!.confirmationDetails,
+          );
+        } else {
+          expect(toolDisplay.confirmationDetails).toBeUndefined();
+        }
+      });
+    },
+  );
+
+  it('should map an array of ToolCalls correctly', () => {
+    const toolCall1: ToolCall = {
+      request: { ...baseRequest, callId: 'call1' },
+      status: 'success',
+      tool: baseTool,
+      invocation: baseTool.build(baseRequest.args),
+      response: { ...baseResponse, callId: 'call1' },
+    } as ToolCall;
+    const toolForCall2 = new MockTool(
+      baseTool.name,
+      baseTool.displayName,
+      false,
+      false,
+      true,
+    );
+    const toolCall2: ToolCall = {
+      request: { ...baseRequest, callId: 'call2' },
+      status: 'executing',
+      tool: toolForCall2,
+      invocation: toolForCall2.build(baseRequest.args),
+      liveOutput: 'markdown output',
+    } as ToolCall;
+
+    const display = mapToDisplay([toolCall1, toolCall2]);
+    expect(display.tools.length).toBe(2);
+    expect(display.tools[0].callId).toBe('call1');
+    expect(display.tools[0].status).toBe(ToolCallStatus.Success);
+    expect(display.tools[0].renderOutputAsMarkdown).toBe(false);
+    expect(display.tools[1].callId).toBe('call2');
+    expect(display.tools[1].status).toBe(ToolCallStatus.Executing);
+    expect(display.tools[1].resultDisplay).toBe('markdown output');
+    expect(display.tools[1].renderOutputAsMarkdown).toBe(true);
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/hooks/vim.test.ts

@@ -0,0 +1,1691 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import React from 'react';
+import { useVim } from './vim.js';
+import type { TextBuffer } from '../components/shared/text-buffer.js';
+import { textBufferReducer } from '../components/shared/text-buffer.js';
+
+// Mock the VimModeContext
+const mockVimContext = {
+  vimEnabled: true,
+  vimMode: 'NORMAL' as const,
+  toggleVimEnabled: vi.fn(),
+  setVimMode: vi.fn(),
+};
+
+vi.mock('../contexts/VimModeContext.js', () => ({
+  useVimMode: () => mockVimContext,
+  VimModeProvider: ({ children }: { children: React.ReactNode }) => children,
+}));
+
+// Test constants
+const TEST_SEQUENCES = {
+  ESCAPE: { sequence: '\u001b', name: 'escape' },
+  LEFT: { sequence: 'h' },
+  RIGHT: { sequence: 'l' },
+  UP: { sequence: 'k' },
+  DOWN: { sequence: 'j' },
+  INSERT: { sequence: 'i' },
+  APPEND: { sequence: 'a' },
+  DELETE_CHAR: { sequence: 'x' },
+  DELETE: { sequence: 'd' },
+  CHANGE: { sequence: 'c' },
+  WORD_FORWARD: { sequence: 'w' },
+  WORD_BACKWARD: { sequence: 'b' },
+  WORD_END: { sequence: 'e' },
+  LINE_START: { sequence: '0' },
+  LINE_END: { sequence: '$' },
+  REPEAT: { sequence: '.' },
+} as const;
+
+describe('useVim hook', () => {
+  let mockBuffer: Partial<TextBuffer>;
+  let mockHandleFinalSubmit: vi.Mock;
+
+  const createMockBuffer = (
+    text = 'hello world',
+    cursor: [number, number] = [0, 5],
+  ) => {
+    const cursorState = { pos: cursor };
+    const lines = text.split('\n');
+
+    return {
+      lines,
+      get cursor() {
+        return cursorState.pos;
+      },
+      set cursor(newPos: [number, number]) {
+        cursorState.pos = newPos;
+      },
+      text,
+      move: vi.fn().mockImplementation((direction: string) => {
+        let [row, col] = cursorState.pos;
+        const _line = lines[row] || '';
+        if (direction === 'left') {
+          col = Math.max(0, col - 1);
+        } else if (direction === 'right') {
+          col = Math.min(line.length, col + 1);
+        } else if (direction === 'home') {
+          col = 0;
+        } else if (direction === 'end') {
+          col = line.length;
+        }
+        cursorState.pos = [row, col];
+      }),
+      del: vi.fn(),
+      moveToOffset: vi.fn(),
+      insert: vi.fn(),
+      newline: vi.fn(),
+      replaceRangeByOffset: vi.fn(),
+      handleInput: vi.fn(),
+      setText: vi.fn(),
+      // Vim-specific methods
+      vimDeleteWordForward: vi.fn(),
+      vimDeleteWordBackward: vi.fn(),
+      vimDeleteWordEnd: vi.fn(),
+      vimChangeWordForward: vi.fn(),
+      vimChangeWordBackward: vi.fn(),
+      vimChangeWordEnd: vi.fn(),
+      vimDeleteLine: vi.fn(),
+      vimChangeLine: vi.fn(),
+      vimDeleteToEndOfLine: vi.fn(),
+      vimChangeToEndOfLine: vi.fn(),
+      vimChangeMovement: vi.fn(),
+      vimMoveLeft: vi.fn(),
+      vimMoveRight: vi.fn(),
+      vimMoveUp: vi.fn(),
+      vimMoveDown: vi.fn(),
+      vimMoveWordForward: vi.fn(),
+      vimMoveWordBackward: vi.fn(),
+      vimMoveWordEnd: vi.fn(),
+      vimDeleteChar: vi.fn(),
+      vimInsertAtCursor: vi.fn(),
+      vimAppendAtCursor: vi.fn().mockImplementation(() => {
+        // Append moves cursor right (vim 'a' behavior - position after current char)
+        const [row, col] = cursorState.pos;
+        const _line = lines[row] || '';
+        // In vim, 'a' moves cursor to position after current character
+        // This allows inserting at the end of the line
+        cursorState.pos = [row, col + 1];
+      }),
+      vimOpenLineBelow: vi.fn(),
+      vimOpenLineAbove: vi.fn(),
+      vimAppendAtLineEnd: vi.fn(),
+      vimInsertAtLineStart: vi.fn(),
+      vimMoveToLineStart: vi.fn(),
+      vimMoveToLineEnd: vi.fn(),
+      vimMoveToFirstNonWhitespace: vi.fn(),
+      vimMoveToFirstLine: vi.fn(),
+      vimMoveToLastLine: vi.fn(),
+      vimMoveToLine: vi.fn(),
+      vimEscapeInsertMode: vi.fn().mockImplementation(() => {
+        // Escape moves cursor left unless at beginning of line
+        const [row, col] = cursorState.pos;
+        if (col > 0) {
+          cursorState.pos = [row, col - 1];
+        }
+      }),
+    };
+  };
+
+  const _createMockSettings = (vimMode = true) => ({
+    getValue: vi.fn().mockReturnValue(vimMode),
+    setValue: vi.fn(),
+    merged: { vimMode },
+  });
+
+  const renderVimHook = (buffer?: Partial<TextBuffer>) =>
+    renderHook(() =>
+      useVim((buffer || mockBuffer) as TextBuffer, mockHandleFinalSubmit),
+    );
+
+  const exitInsertMode = (result: {
+    current: {
+      handleInput: (input: { sequence: string; name: string }) => void;
+    };
+  }) => {
+    act(() => {
+      result.current.handleInput({ sequence: '\u001b', name: 'escape' });
+    });
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockHandleFinalSubmit = vi.fn();
+    mockBuffer = createMockBuffer();
+    // Reset mock context to default state
+    mockVimContext.vimEnabled = true;
+    mockVimContext.vimMode = 'NORMAL';
+    mockVimContext.toggleVimEnabled.mockClear();
+    mockVimContext.setVimMode.mockClear();
+  });
+
+  describe('Mode switching', () => {
+    it('should start in NORMAL mode', () => {
+      const { result } = renderVimHook();
+      expect(result.current.mode).toBe('NORMAL');
+    });
+
+    it('should switch to INSERT mode with i command', () => {
+      const { result } = renderVimHook();
+
+      act(() => {
+        result.current.handleInput(TEST_SEQUENCES.INSERT);
+      });
+
+      expect(result.current.mode).toBe('INSERT');
+      expect(mockVimContext.setVimMode).toHaveBeenCalledWith('INSERT');
+    });
+
+    it('should switch back to NORMAL mode with Escape', () => {
+      const { result } = renderVimHook();
+
+      act(() => {
+        result.current.handleInput(TEST_SEQUENCES.INSERT);
+      });
+      expect(result.current.mode).toBe('INSERT');
+
+      exitInsertMode(result);
+      expect(result.current.mode).toBe('NORMAL');
+    });
+
+    it('should properly handle escape followed immediately by a command', () => {
+      const testBuffer = createMockBuffer('hello world test', [0, 6]);
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'i' });
+      });
+      expect(result.current.mode).toBe('INSERT');
+
+      vi.clearAllMocks();
+
+      exitInsertMode(result);
+      expect(result.current.mode).toBe('NORMAL');
+
+      act(() => {
+        result.current.handleInput({ sequence: 'b' });
+      });
+
+      expect(testBuffer.vimMoveWordBackward).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('Navigation commands', () => {
+    it('should handle h (left movement)', () => {
+      const { result } = renderVimHook();
+
+      act(() => {
+        result.current.handleInput({ sequence: 'h' });
+      });
+
+      expect(mockBuffer.vimMoveLeft).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle l (right movement)', () => {
+      const { result } = renderVimHook();
+
+      act(() => {
+        result.current.handleInput({ sequence: 'l' });
+      });
+
+      expect(mockBuffer.vimMoveRight).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle j (down movement)', () => {
+      const testBuffer = createMockBuffer('first line\nsecond line');
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'j' });
+      });
+
+      expect(testBuffer.vimMoveDown).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle k (up movement)', () => {
+      const testBuffer = createMockBuffer('first line\nsecond line');
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'k' });
+      });
+
+      expect(testBuffer.vimMoveUp).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle 0 (move to start of line)', () => {
+      const { result } = renderVimHook();
+
+      act(() => {
+        result.current.handleInput({ sequence: '0' });
+      });
+
+      expect(mockBuffer.vimMoveToLineStart).toHaveBeenCalled();
+    });
+
+    it('should handle $ (move to end of line)', () => {
+      const { result } = renderVimHook();
+
+      act(() => {
+        result.current.handleInput({ sequence: '$' });
+      });
+
+      expect(mockBuffer.vimMoveToLineEnd).toHaveBeenCalled();
+    });
+  });
+
+  describe('Mode switching commands', () => {
+    it('should handle a (append after cursor)', () => {
+      const { result } = renderVimHook();
+
+      act(() => {
+        result.current.handleInput({ sequence: 'a' });
+      });
+
+      expect(mockBuffer.vimAppendAtCursor).toHaveBeenCalled();
+      expect(result.current.mode).toBe('INSERT');
+    });
+
+    it('should handle A (append at end of line)', () => {
+      const { result } = renderVimHook();
+
+      act(() => {
+        result.current.handleInput({ sequence: 'A' });
+      });
+
+      expect(mockBuffer.vimAppendAtLineEnd).toHaveBeenCalled();
+      expect(result.current.mode).toBe('INSERT');
+    });
+
+    it('should handle o (open line below)', () => {
+      const { result } = renderVimHook();
+
+      act(() => {
+        result.current.handleInput({ sequence: 'o' });
+      });
+
+      expect(mockBuffer.vimOpenLineBelow).toHaveBeenCalled();
+      expect(result.current.mode).toBe('INSERT');
+    });
+
+    it('should handle O (open line above)', () => {
+      const { result } = renderVimHook();
+
+      act(() => {
+        result.current.handleInput({ sequence: 'O' });
+      });
+
+      expect(mockBuffer.vimOpenLineAbove).toHaveBeenCalled();
+      expect(result.current.mode).toBe('INSERT');
+    });
+  });
+
+  describe('Edit commands', () => {
+    it('should handle x (delete character)', () => {
+      const { result } = renderVimHook();
+      vi.clearAllMocks();
+
+      act(() => {
+        result.current.handleInput({ sequence: 'x' });
+      });
+
+      expect(mockBuffer.vimDeleteChar).toHaveBeenCalledWith(1);
+    });
+
+    it('should move cursor left when deleting last character on line (vim behavior)', () => {
+      const testBuffer = createMockBuffer('hello', [0, 4]);
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'x' });
+      });
+
+      expect(testBuffer.vimDeleteChar).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle first d key (sets pending state)', () => {
+      const { result } = renderVimHook();
+
+      act(() => {
+        result.current.handleInput({ sequence: 'd' });
+      });
+
+      expect(mockBuffer.replaceRangeByOffset).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Count handling', () => {
+    it('should handle count input and return to count 0 after command', () => {
+      const { result } = renderVimHook();
+
+      act(() => {
+        const handled = result.current.handleInput({ sequence: '3' });
+        expect(handled).toBe(true);
+      });
+
+      act(() => {
+        const handled = result.current.handleInput({ sequence: 'h' });
+        expect(handled).toBe(true);
+      });
+
+      expect(mockBuffer.vimMoveLeft).toHaveBeenCalledWith(3);
+    });
+
+    it('should only delete 1 character with x command when no count is specified', () => {
+      const testBuffer = createMockBuffer();
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'x' });
+      });
+
+      expect(testBuffer.vimDeleteChar).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('Word movement', () => {
+    it('should properly initialize vim hook with word movement support', () => {
+      const testBuffer = createMockBuffer('cat elephant mouse', [0, 0]);
+      const { result } = renderVimHook(testBuffer);
+
+      expect(result.current.vimModeEnabled).toBe(true);
+      expect(result.current.mode).toBe('NORMAL');
+      expect(result.current.handleInput).toBeDefined();
+    });
+
+    it('should support vim mode and basic operations across multiple lines', () => {
+      const testBuffer = createMockBuffer(
+        'first line word\nsecond line word',
+        [0, 11],
+      );
+      const { result } = renderVimHook(testBuffer);
+
+      expect(result.current.vimModeEnabled).toBe(true);
+      expect(result.current.mode).toBe('NORMAL');
+      expect(result.current.handleInput).toBeDefined();
+      expect(testBuffer.replaceRangeByOffset).toBeDefined();
+      expect(testBuffer.moveToOffset).toBeDefined();
+    });
+
+    it('should handle w (next word)', () => {
+      const testBuffer = createMockBuffer('hello world test');
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'w' });
+      });
+
+      expect(testBuffer.vimMoveWordForward).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle b (previous word)', () => {
+      const testBuffer = createMockBuffer('hello world test', [0, 6]);
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'b' });
+      });
+
+      expect(testBuffer.vimMoveWordBackward).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle e (end of word)', () => {
+      const testBuffer = createMockBuffer('hello world test');
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'e' });
+      });
+
+      expect(testBuffer.vimMoveWordEnd).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle w when cursor is on the last word', () => {
+      const testBuffer = createMockBuffer('hello world', [0, 8]);
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'w' });
+      });
+
+      expect(testBuffer.vimMoveWordForward).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle first c key (sets pending change state)', () => {
+      const { result } = renderVimHook();
+
+      act(() => {
+        result.current.handleInput({ sequence: 'c' });
+      });
+
+      expect(result.current.mode).toBe('NORMAL');
+      expect(mockBuffer.del).not.toHaveBeenCalled();
+    });
+
+    it('should clear pending state on invalid command sequence (df)', () => {
+      const { result } = renderVimHook();
+
+      act(() => {
+        result.current.handleInput({ sequence: 'd' });
+        result.current.handleInput({ sequence: 'f' });
+      });
+
+      expect(mockBuffer.replaceRangeByOffset).not.toHaveBeenCalled();
+      expect(mockBuffer.del).not.toHaveBeenCalled();
+    });
+
+    it('should clear pending state with Escape in NORMAL mode', () => {
+      const { result } = renderVimHook();
+
+      act(() => {
+        result.current.handleInput({ sequence: 'd' });
+      });
+
+      exitInsertMode(result);
+
+      expect(mockBuffer.replaceRangeByOffset).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Disabled vim mode', () => {
+    it('should not respond to vim commands when disabled', () => {
+      mockVimContext.vimEnabled = false;
+      const { result } = renderVimHook(mockBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'h' });
+      });
+
+      expect(mockBuffer.move).not.toHaveBeenCalled();
+    });
+  });
+
+  // These tests are no longer applicable at the hook level
+
+  describe('Command repeat system', () => {
+    it('should repeat x command from current cursor position', () => {
+      const testBuffer = createMockBuffer('abcd\nefgh\nijkl', [0, 1]);
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'x' });
+      });
+      expect(testBuffer.vimDeleteChar).toHaveBeenCalledWith(1);
+
+      testBuffer.cursor = [1, 2];
+
+      act(() => {
+        result.current.handleInput({ sequence: '.' });
+      });
+      expect(testBuffer.vimDeleteChar).toHaveBeenCalledWith(1);
+    });
+
+    it('should repeat dd command from current position', () => {
+      const testBuffer = createMockBuffer('line1\nline2\nline3', [1, 0]);
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'd' });
+      });
+      act(() => {
+        result.current.handleInput({ sequence: 'd' });
+      });
+      expect(testBuffer.vimDeleteLine).toHaveBeenCalledTimes(1);
+
+      testBuffer.cursor = [0, 0];
+
+      act(() => {
+        result.current.handleInput({ sequence: '.' });
+      });
+
+      expect(testBuffer.vimDeleteLine).toHaveBeenCalledTimes(2);
+    });
+
+    it('should repeat ce command from current position', () => {
+      const testBuffer = createMockBuffer('word', [0, 0]);
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'c' });
+      });
+      act(() => {
+        result.current.handleInput({ sequence: 'e' });
+      });
+      expect(testBuffer.vimChangeWordEnd).toHaveBeenCalledTimes(1);
+
+      // Exit INSERT mode to complete the command
+      exitInsertMode(result);
+
+      testBuffer.cursor = [0, 2];
+
+      act(() => {
+        result.current.handleInput({ sequence: '.' });
+      });
+
+      expect(testBuffer.vimChangeWordEnd).toHaveBeenCalledTimes(2);
+    });
+
+    it('should repeat cc command from current position', () => {
+      const testBuffer = createMockBuffer('line1\nline2\nline3', [1, 2]);
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'c' });
+      });
+      act(() => {
+        result.current.handleInput({ sequence: 'c' });
+      });
+      expect(testBuffer.vimChangeLine).toHaveBeenCalledTimes(1);
+
+      // Exit INSERT mode to complete the command
+      exitInsertMode(result);
+
+      testBuffer.cursor = [0, 1];
+
+      act(() => {
+        result.current.handleInput({ sequence: '.' });
+      });
+
+      expect(testBuffer.vimChangeLine).toHaveBeenCalledTimes(2);
+    });
+
+    it('should repeat cw command from current position', () => {
+      const testBuffer = createMockBuffer('hello world test', [0, 6]);
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'c' });
+      });
+      act(() => {
+        result.current.handleInput({ sequence: 'w' });
+      });
+      expect(testBuffer.vimChangeWordForward).toHaveBeenCalledTimes(1);
+
+      // Exit INSERT mode to complete the command
+      exitInsertMode(result);
+
+      testBuffer.cursor = [0, 0];
+
+      act(() => {
+        result.current.handleInput({ sequence: '.' });
+      });
+
+      expect(testBuffer.vimChangeWordForward).toHaveBeenCalledTimes(2);
+    });
+
+    it('should repeat D command from current position', () => {
+      const testBuffer = createMockBuffer('hello world test', [0, 6]);
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'D' });
+      });
+      expect(testBuffer.vimDeleteToEndOfLine).toHaveBeenCalledTimes(1);
+
+      testBuffer.cursor = [0, 2];
+      vi.clearAllMocks(); // Clear all mocks instead of just one method
+
+      act(() => {
+        result.current.handleInput({ sequence: '.' });
+      });
+
+      expect(testBuffer.vimDeleteToEndOfLine).toHaveBeenCalledTimes(1);
+    });
+
+    it('should repeat C command from current position', () => {
+      const testBuffer = createMockBuffer('hello world test', [0, 6]);
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'C' });
+      });
+      expect(testBuffer.vimChangeToEndOfLine).toHaveBeenCalledTimes(1);
+
+      // Exit INSERT mode to complete the command
+      exitInsertMode(result);
+
+      testBuffer.cursor = [0, 2];
+
+      act(() => {
+        result.current.handleInput({ sequence: '.' });
+      });
+
+      expect(testBuffer.vimChangeToEndOfLine).toHaveBeenCalledTimes(2);
+    });
+
+    it('should repeat command after cursor movement', () => {
+      const testBuffer = createMockBuffer('test text', [0, 0]);
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'x' });
+      });
+      expect(testBuffer.vimDeleteChar).toHaveBeenCalledWith(1);
+
+      testBuffer.cursor = [0, 2];
+
+      act(() => {
+        result.current.handleInput({ sequence: '.' });
+      });
+      expect(testBuffer.vimDeleteChar).toHaveBeenCalledWith(1);
+    });
+
+    it('should move cursor to the correct position after exiting INSERT mode with "a"', () => {
+      const testBuffer = createMockBuffer('hello world', [0, 10]);
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'a' });
+      });
+      expect(result.current.mode).toBe('INSERT');
+      expect(testBuffer.cursor).toEqual([0, 11]);
+
+      exitInsertMode(result);
+      expect(result.current.mode).toBe('NORMAL');
+      expect(testBuffer.cursor).toEqual([0, 10]);
+    });
+  });
+
+  describe('Special characters and edge cases', () => {
+    it('should handle ^ (move to first non-whitespace character)', () => {
+      const testBuffer = createMockBuffer('   hello world', [0, 5]);
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: '^' });
+      });
+
+      expect(testBuffer.vimMoveToFirstNonWhitespace).toHaveBeenCalled();
+    });
+
+    it('should handle G without count (go to last line)', () => {
+      const testBuffer = createMockBuffer('line1\nline2\nline3', [0, 0]);
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: 'G' });
+      });
+
+      expect(testBuffer.vimMoveToLastLine).toHaveBeenCalled();
+    });
+
+    it('should handle gg (go to first line)', () => {
+      const testBuffer = createMockBuffer('line1\nline2\nline3', [2, 0]);
+      const { result } = renderVimHook(testBuffer);
+
+      // First 'g' sets pending state
+      act(() => {
+        result.current.handleInput({ sequence: 'g' });
+      });
+
+      // Second 'g' executes the command
+      act(() => {
+        result.current.handleInput({ sequence: 'g' });
+      });
+
+      expect(testBuffer.vimMoveToFirstLine).toHaveBeenCalled();
+    });
+
+    it('should handle count with movement commands', () => {
+      const testBuffer = createMockBuffer('hello world test', [0, 0]);
+      const { result } = renderVimHook(testBuffer);
+
+      act(() => {
+        result.current.handleInput({ sequence: '3' });
+      });
+
+      act(() => {
+        result.current.handleInput(TEST_SEQUENCES.WORD_FORWARD);
+      });
+
+      expect(testBuffer.vimMoveWordForward).toHaveBeenCalledWith(3);
+    });
+  });
+
+  describe('Vim word operations', () => {
+    describe('dw (delete word forward)', () => {
+      it('should delete from cursor to start of next word', () => {
+        const testBuffer = createMockBuffer('hello world test', [0, 0]);
+        const { result } = renderVimHook(testBuffer);
+
+        act(() => {
+          result.current.handleInput({ sequence: 'd' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'w' });
+        });
+
+        expect(testBuffer.vimDeleteWordForward).toHaveBeenCalledWith(1);
+      });
+
+      it('should actually delete the complete word including trailing space', () => {
+        // This test uses the real text-buffer reducer instead of mocks
+        const initialState = {
+          lines: ['hello world test'],
+          cursorRow: 0,
+          cursorCol: 0,
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_delete_word_forward',
+          payload: { count: 1 },
+        });
+
+        // Should delete "hello " (word + space), leaving "world test"
+        expect(result.lines).toEqual(['world test']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(0);
+      });
+
+      it('should delete word from middle of word correctly', () => {
+        const initialState = {
+          lines: ['hello world test'],
+          cursorRow: 0,
+          cursorCol: 2, // cursor on 'l' in "hello"
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_delete_word_forward',
+          payload: { count: 1 },
+        });
+
+        // Should delete "llo " (rest of word + space), leaving "he world test"
+        expect(result.lines).toEqual(['heworld test']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(2);
+      });
+
+      it('should handle dw at end of line', () => {
+        const initialState = {
+          lines: ['hello world'],
+          cursorRow: 0,
+          cursorCol: 6, // cursor on 'w' in "world"
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_delete_word_forward',
+          payload: { count: 1 },
+        });
+
+        // Should delete "world" (no trailing space at end), leaving "hello "
+        expect(result.lines).toEqual(['hello ']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(6);
+      });
+
+      it('should delete multiple words with count', () => {
+        const testBuffer = createMockBuffer('one two three four', [0, 0]);
+        const { result } = renderVimHook(testBuffer);
+
+        act(() => {
+          result.current.handleInput({ sequence: '2' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'd' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'w' });
+        });
+
+        expect(testBuffer.vimDeleteWordForward).toHaveBeenCalledWith(2);
+      });
+
+      it('should record command for repeat with dot', () => {
+        const testBuffer = createMockBuffer('hello world test', [0, 0]);
+        const { result } = renderVimHook(testBuffer);
+
+        // Execute dw
+        act(() => {
+          result.current.handleInput({ sequence: 'd' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'w' });
+        });
+
+        vi.clearAllMocks();
+
+        // Execute dot repeat
+        act(() => {
+          result.current.handleInput({ sequence: '.' });
+        });
+
+        expect(testBuffer.vimDeleteWordForward).toHaveBeenCalledWith(1);
+      });
+    });
+
+    describe('de (delete word end)', () => {
+      it('should delete from cursor to end of current word', () => {
+        const testBuffer = createMockBuffer('hello world test', [0, 1]);
+        const { result } = renderVimHook(testBuffer);
+
+        act(() => {
+          result.current.handleInput({ sequence: 'd' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'e' });
+        });
+
+        expect(testBuffer.vimDeleteWordEnd).toHaveBeenCalledWith(1);
+      });
+
+      it('should handle count with de', () => {
+        const testBuffer = createMockBuffer('one two three four', [0, 0]);
+        const { result } = renderVimHook(testBuffer);
+
+        act(() => {
+          result.current.handleInput({ sequence: '3' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'd' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'e' });
+        });
+
+        expect(testBuffer.vimDeleteWordEnd).toHaveBeenCalledWith(3);
+      });
+    });
+
+    describe('cw (change word forward)', () => {
+      it('should change from cursor to start of next word and enter INSERT mode', () => {
+        const testBuffer = createMockBuffer('hello world test', [0, 0]);
+        const { result } = renderVimHook(testBuffer);
+
+        act(() => {
+          result.current.handleInput({ sequence: 'c' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'w' });
+        });
+
+        expect(testBuffer.vimChangeWordForward).toHaveBeenCalledWith(1);
+        expect(result.current.mode).toBe('INSERT');
+        expect(mockVimContext.setVimMode).toHaveBeenCalledWith('INSERT');
+      });
+
+      it('should handle count with cw', () => {
+        const testBuffer = createMockBuffer('one two three four', [0, 0]);
+        const { result } = renderVimHook(testBuffer);
+
+        act(() => {
+          result.current.handleInput({ sequence: '2' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'c' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'w' });
+        });
+
+        expect(testBuffer.vimChangeWordForward).toHaveBeenCalledWith(2);
+        expect(result.current.mode).toBe('INSERT');
+      });
+
+      it('should be repeatable with dot', () => {
+        const testBuffer = createMockBuffer('hello world test more', [0, 0]);
+        const { result } = renderVimHook(testBuffer);
+
+        // Execute cw
+        act(() => {
+          result.current.handleInput({ sequence: 'c' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'w' });
+        });
+
+        // Exit INSERT mode
+        exitInsertMode(result);
+
+        vi.clearAllMocks();
+        mockVimContext.setVimMode.mockClear();
+
+        // Execute dot repeat
+        act(() => {
+          result.current.handleInput({ sequence: '.' });
+        });
+
+        expect(testBuffer.vimChangeWordForward).toHaveBeenCalledWith(1);
+        expect(result.current.mode).toBe('INSERT');
+      });
+    });
+
+    describe('ce (change word end)', () => {
+      it('should change from cursor to end of word and enter INSERT mode', () => {
+        const testBuffer = createMockBuffer('hello world test', [0, 1]);
+        const { result } = renderVimHook(testBuffer);
+
+        act(() => {
+          result.current.handleInput({ sequence: 'c' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'e' });
+        });
+
+        expect(testBuffer.vimChangeWordEnd).toHaveBeenCalledWith(1);
+        expect(result.current.mode).toBe('INSERT');
+      });
+
+      it('should handle count with ce', () => {
+        const testBuffer = createMockBuffer('one two three four', [0, 0]);
+        const { result } = renderVimHook(testBuffer);
+
+        act(() => {
+          result.current.handleInput({ sequence: '2' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'c' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'e' });
+        });
+
+        expect(testBuffer.vimChangeWordEnd).toHaveBeenCalledWith(2);
+        expect(result.current.mode).toBe('INSERT');
+      });
+    });
+
+    describe('cc (change line)', () => {
+      it('should change entire line and enter INSERT mode', () => {
+        const testBuffer = createMockBuffer('hello world\nsecond line', [0, 5]);
+        const { result } = renderVimHook(testBuffer);
+
+        act(() => {
+          result.current.handleInput({ sequence: 'c' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'c' });
+        });
+
+        expect(testBuffer.vimChangeLine).toHaveBeenCalledWith(1);
+        expect(result.current.mode).toBe('INSERT');
+      });
+
+      it('should change multiple lines with count', () => {
+        const testBuffer = createMockBuffer(
+          'line1\nline2\nline3\nline4',
+          [1, 0],
+        );
+        const { result } = renderVimHook(testBuffer);
+
+        act(() => {
+          result.current.handleInput({ sequence: '3' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'c' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'c' });
+        });
+
+        expect(testBuffer.vimChangeLine).toHaveBeenCalledWith(3);
+        expect(result.current.mode).toBe('INSERT');
+      });
+
+      it('should be repeatable with dot', () => {
+        const testBuffer = createMockBuffer('line1\nline2\nline3', [0, 0]);
+        const { result } = renderVimHook(testBuffer);
+
+        // Execute cc
+        act(() => {
+          result.current.handleInput({ sequence: 'c' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'c' });
+        });
+
+        // Exit INSERT mode
+        exitInsertMode(result);
+
+        vi.clearAllMocks();
+        mockVimContext.setVimMode.mockClear();
+
+        // Execute dot repeat
+        act(() => {
+          result.current.handleInput({ sequence: '.' });
+        });
+
+        expect(testBuffer.vimChangeLine).toHaveBeenCalledWith(1);
+        expect(result.current.mode).toBe('INSERT');
+      });
+    });
+
+    describe('db (delete word backward)', () => {
+      it('should delete from cursor to start of previous word', () => {
+        const testBuffer = createMockBuffer('hello world test', [0, 11]);
+        const { result } = renderVimHook(testBuffer);
+
+        act(() => {
+          result.current.handleInput({ sequence: 'd' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'b' });
+        });
+
+        expect(testBuffer.vimDeleteWordBackward).toHaveBeenCalledWith(1);
+      });
+
+      it('should handle count with db', () => {
+        const testBuffer = createMockBuffer('one two three four', [0, 18]);
+        const { result } = renderVimHook(testBuffer);
+
+        act(() => {
+          result.current.handleInput({ sequence: '2' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'd' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'b' });
+        });
+
+        expect(testBuffer.vimDeleteWordBackward).toHaveBeenCalledWith(2);
+      });
+    });
+
+    describe('cb (change word backward)', () => {
+      it('should change from cursor to start of previous word and enter INSERT mode', () => {
+        const testBuffer = createMockBuffer('hello world test', [0, 11]);
+        const { result } = renderVimHook(testBuffer);
+
+        act(() => {
+          result.current.handleInput({ sequence: 'c' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'b' });
+        });
+
+        expect(testBuffer.vimChangeWordBackward).toHaveBeenCalledWith(1);
+        expect(result.current.mode).toBe('INSERT');
+      });
+
+      it('should handle count with cb', () => {
+        const testBuffer = createMockBuffer('one two three four', [0, 18]);
+        const { result } = renderVimHook(testBuffer);
+
+        act(() => {
+          result.current.handleInput({ sequence: '3' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'c' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'b' });
+        });
+
+        expect(testBuffer.vimChangeWordBackward).toHaveBeenCalledWith(3);
+        expect(result.current.mode).toBe('INSERT');
+      });
+    });
+
+    describe('Pending state handling', () => {
+      it('should clear pending delete state after dw', () => {
+        const testBuffer = createMockBuffer('hello world', [0, 0]);
+        const { result } = renderVimHook(testBuffer);
+
+        // Press 'd' to enter pending delete state
+        act(() => {
+          result.current.handleInput({ sequence: 'd' });
+        });
+
+        // Complete with 'w'
+        act(() => {
+          result.current.handleInput({ sequence: 'w' });
+        });
+
+        // Next 'd' should start a new pending state, not continue the previous one
+        act(() => {
+          result.current.handleInput({ sequence: 'd' });
+        });
+
+        // This should trigger dd (delete line), not an error
+        act(() => {
+          result.current.handleInput({ sequence: 'd' });
+        });
+
+        expect(testBuffer.vimDeleteLine).toHaveBeenCalledWith(1);
+      });
+
+      it('should clear pending change state after cw', () => {
+        const testBuffer = createMockBuffer('hello world', [0, 0]);
+        const { result } = renderVimHook(testBuffer);
+
+        // Execute cw
+        act(() => {
+          result.current.handleInput({ sequence: 'c' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'w' });
+        });
+
+        // Exit INSERT mode
+        exitInsertMode(result);
+
+        // Next 'c' should start a new pending state
+        act(() => {
+          result.current.handleInput({ sequence: 'c' });
+        });
+        act(() => {
+          result.current.handleInput({ sequence: 'c' });
+        });
+
+        expect(testBuffer.vimChangeLine).toHaveBeenCalledWith(1);
+      });
+
+      it('should clear pending state with escape', () => {
+        const testBuffer = createMockBuffer('hello world', [0, 0]);
+        const { result } = renderVimHook(testBuffer);
+
+        // Enter pending delete state
+        act(() => {
+          result.current.handleInput({ sequence: 'd' });
+        });
+
+        // Press escape to clear pending state
+        act(() => {
+          result.current.handleInput({ name: 'escape' });
+        });
+
+        // Now 'w' should just move cursor, not delete
+        act(() => {
+          result.current.handleInput({ sequence: 'w' });
+        });
+
+        expect(testBuffer.vimDeleteWordForward).not.toHaveBeenCalled();
+        // w should move to next word after clearing pending state
+        expect(testBuffer.vimMoveWordForward).toHaveBeenCalledWith(1);
+      });
+    });
+
+    describe('NORMAL mode escape behavior', () => {
+      it('should pass escape through when no pending operator is active', () => {
+        mockVimContext.vimMode = 'NORMAL';
+        const { result } = renderVimHook();
+
+        const handled = result.current.handleInput({ name: 'escape' });
+
+        expect(handled).toBe(false);
+      });
+
+      it('should handle escape and clear pending operator', () => {
+        mockVimContext.vimMode = 'NORMAL';
+        const { result } = renderVimHook();
+
+        act(() => {
+          result.current.handleInput({ sequence: 'd' });
+        });
+
+        let handled: boolean | undefined;
+        act(() => {
+          handled = result.current.handleInput({ name: 'escape' });
+        });
+
+        expect(handled).toBe(true);
+      });
+    });
+  });
+
+  describe('Shell command pass-through', () => {
+    it('should pass through ctrl+r in INSERT mode', () => {
+      mockVimContext.vimMode = 'INSERT';
+      const { result } = renderVimHook();
+
+      const handled = result.current.handleInput({ name: 'r', ctrl: true });
+
+      expect(handled).toBe(false);
+    });
+
+    it('should pass through ! in INSERT mode when buffer is empty', () => {
+      mockVimContext.vimMode = 'INSERT';
+      const emptyBuffer = createMockBuffer('');
+      const { result } = renderVimHook(emptyBuffer);
+
+      const handled = result.current.handleInput({ sequence: '!' });
+
+      expect(handled).toBe(false);
+    });
+
+    it('should handle ! as input in INSERT mode when buffer is not empty', () => {
+      mockVimContext.vimMode = 'INSERT';
+      const nonEmptyBuffer = createMockBuffer('not empty');
+      const { result } = renderVimHook(nonEmptyBuffer);
+      const key = { sequence: '!', name: '!' };
+
+      act(() => {
+        result.current.handleInput(key);
+      });
+
+      expect(nonEmptyBuffer.handleInput).toHaveBeenCalledWith(
+        expect.objectContaining(key),
+      );
+    });
+  });
+
+  // Line operations (dd, cc) are tested in text-buffer.test.ts
+
+  describe('Reducer-based integration tests', () => {
+    describe('de (delete word end)', () => {
+      it('should delete from cursor to end of current word', () => {
+        const initialState = {
+          lines: ['hello world test'],
+          cursorRow: 0,
+          cursorCol: 1, // cursor on 'e' in "hello"
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_delete_word_end',
+          payload: { count: 1 },
+        });
+
+        // Should delete "ello" (from cursor to end of word), leaving "h world test"
+        expect(result.lines).toEqual(['h world test']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(1);
+      });
+
+      it('should delete multiple word ends with count', () => {
+        const initialState = {
+          lines: ['hello world test more'],
+          cursorRow: 0,
+          cursorCol: 1, // cursor on 'e' in "hello"
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_delete_word_end',
+          payload: { count: 2 },
+        });
+
+        // Should delete "ello world" (to end of second word), leaving "h test more"
+        expect(result.lines).toEqual(['h test more']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(1);
+      });
+    });
+
+    describe('db (delete word backward)', () => {
+      it('should delete from cursor to start of previous word', () => {
+        const initialState = {
+          lines: ['hello world test'],
+          cursorRow: 0,
+          cursorCol: 11, // cursor on 't' in "test"
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_delete_word_backward',
+          payload: { count: 1 },
+        });
+
+        // Should delete "world" (previous word only), leaving "hello  test"
+        expect(result.lines).toEqual(['hello  test']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(6);
+      });
+
+      it('should delete multiple words backward with count', () => {
+        const initialState = {
+          lines: ['hello world test more'],
+          cursorRow: 0,
+          cursorCol: 17, // cursor on 'm' in "more"
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_delete_word_backward',
+          payload: { count: 2 },
+        });
+
+        // Should delete "world test " (two words backward), leaving "hello more"
+        expect(result.lines).toEqual(['hello more']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(6);
+      });
+    });
+
+    describe('cw (change word forward)', () => {
+      it('should delete from cursor to start of next word', () => {
+        const initialState = {
+          lines: ['hello world test'],
+          cursorRow: 0,
+          cursorCol: 0, // cursor on 'h' in "hello"
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_change_word_forward',
+          payload: { count: 1 },
+        });
+
+        // Should delete "hello " (word + space), leaving "world test"
+        expect(result.lines).toEqual(['world test']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(0);
+      });
+
+      it('should change multiple words with count', () => {
+        const initialState = {
+          lines: ['hello world test more'],
+          cursorRow: 0,
+          cursorCol: 0,
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_change_word_forward',
+          payload: { count: 2 },
+        });
+
+        // Should delete "hello world " (two words), leaving "test more"
+        expect(result.lines).toEqual(['test more']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(0);
+      });
+    });
+
+    describe('ce (change word end)', () => {
+      it('should change from cursor to end of current word', () => {
+        const initialState = {
+          lines: ['hello world test'],
+          cursorRow: 0,
+          cursorCol: 1, // cursor on 'e' in "hello"
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_change_word_end',
+          payload: { count: 1 },
+        });
+
+        // Should delete "ello" (from cursor to end of word), leaving "h world test"
+        expect(result.lines).toEqual(['h world test']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(1);
+      });
+
+      it('should change multiple word ends with count', () => {
+        const initialState = {
+          lines: ['hello world test'],
+          cursorRow: 0,
+          cursorCol: 1, // cursor on 'e' in "hello"
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_change_word_end',
+          payload: { count: 2 },
+        });
+
+        // Should delete "ello world" (to end of second word), leaving "h test"
+        expect(result.lines).toEqual(['h test']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(1);
+      });
+    });
+
+    describe('cb (change word backward)', () => {
+      it('should change from cursor to start of previous word', () => {
+        const initialState = {
+          lines: ['hello world test'],
+          cursorRow: 0,
+          cursorCol: 11, // cursor on 't' in "test"
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_change_word_backward',
+          payload: { count: 1 },
+        });
+
+        // Should delete "world" (previous word only), leaving "hello  test"
+        expect(result.lines).toEqual(['hello  test']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(6);
+      });
+    });
+
+    describe('cc (change line)', () => {
+      it('should clear the line and place cursor at the start', () => {
+        const initialState = {
+          lines: ['  hello world'],
+          cursorRow: 0,
+          cursorCol: 5, // cursor on 'o'
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_change_line',
+          payload: { count: 1 },
+        });
+
+        expect(result.lines).toEqual(['']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(0);
+      });
+    });
+
+    describe('dd (delete line)', () => {
+      it('should delete the current line', () => {
+        const initialState = {
+          lines: ['line1', 'line2', 'line3'],
+          cursorRow: 1,
+          cursorCol: 2,
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_delete_line',
+          payload: { count: 1 },
+        });
+
+        expect(result.lines).toEqual(['line1', 'line3']);
+        expect(result.cursorRow).toBe(1);
+        expect(result.cursorCol).toBe(0);
+      });
+
+      it('should delete multiple lines with count', () => {
+        const initialState = {
+          lines: ['line1', 'line2', 'line3', 'line4'],
+          cursorRow: 1,
+          cursorCol: 2,
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_delete_line',
+          payload: { count: 2 },
+        });
+
+        // Should delete lines 1 and 2
+        expect(result.lines).toEqual(['line1', 'line4']);
+        expect(result.cursorRow).toBe(1);
+        expect(result.cursorCol).toBe(0);
+      });
+
+      it('should handle deleting last line', () => {
+        const initialState = {
+          lines: ['only line'],
+          cursorRow: 0,
+          cursorCol: 3,
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_delete_line',
+          payload: { count: 1 },
+        });
+
+        // Should leave an empty line when deleting the only line
+        expect(result.lines).toEqual(['']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(0);
+      });
+    });
+
+    describe('D (delete to end of line)', () => {
+      it('should delete from cursor to end of line', () => {
+        const initialState = {
+          lines: ['hello world test'],
+          cursorRow: 0,
+          cursorCol: 6, // cursor on 'w' in "world"
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_delete_to_end_of_line',
+        });
+
+        // Should delete "world test", leaving "hello "
+        expect(result.lines).toEqual(['hello ']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(6);
+      });
+
+      it('should handle D at end of line', () => {
+        const initialState = {
+          lines: ['hello world'],
+          cursorRow: 0,
+          cursorCol: 11, // cursor at end
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_delete_to_end_of_line',
+        });
+
+        // Should not change anything when at end of line
+        expect(result.lines).toEqual(['hello world']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(11);
+      });
+    });
+
+    describe('C (change to end of line)', () => {
+      it('should change from cursor to end of line', () => {
+        const initialState = {
+          lines: ['hello world test'],
+          cursorRow: 0,
+          cursorCol: 6, // cursor on 'w' in "world"
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_change_to_end_of_line',
+        });
+
+        // Should delete "world test", leaving "hello "
+        expect(result.lines).toEqual(['hello ']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(6);
+      });
+
+      it('should handle C at beginning of line', () => {
+        const initialState = {
+          lines: ['hello world'],
+          cursorRow: 0,
+          cursorCol: 0,
+          preferredCol: null,
+          undoStack: [],
+          redoStack: [],
+          clipboard: null,
+          selectionAnchor: null,
+        };
+
+        const result = textBufferReducer(initialState, {
+          type: 'vim_change_to_end_of_line',
+        });
+
+        // Should delete entire line content
+        expect(result.lines).toEqual(['']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(0);
+      });
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/hooks/vim.ts

@@ -0,0 +1,784 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useCallback, useReducer, useEffect } from 'react';
+import type { Key } from './useKeypress.js';
+import type { TextBuffer } from '../components/shared/text-buffer.js';
+import { useVimMode } from '../contexts/VimModeContext.js';
+
+export type VimMode = 'NORMAL' | 'INSERT';
+
+// Constants
+const DIGIT_MULTIPLIER = 10;
+const DEFAULT_COUNT = 1;
+const DIGIT_1_TO_9 = /^[1-9]$/;
+
+// Command types
+const CMD_TYPES = {
+  DELETE_WORD_FORWARD: 'dw',
+  DELETE_WORD_BACKWARD: 'db',
+  DELETE_WORD_END: 'de',
+  CHANGE_WORD_FORWARD: 'cw',
+  CHANGE_WORD_BACKWARD: 'cb',
+  CHANGE_WORD_END: 'ce',
+  DELETE_CHAR: 'x',
+  DELETE_LINE: 'dd',
+  CHANGE_LINE: 'cc',
+  DELETE_TO_EOL: 'D',
+  CHANGE_TO_EOL: 'C',
+  CHANGE_MOVEMENT: {
+    LEFT: 'ch',
+    DOWN: 'cj',
+    UP: 'ck',
+    RIGHT: 'cl',
+  },
+} as const;
+
+// Helper function to clear pending state
+const createClearPendingState = () => ({
+  count: 0,
+  pendingOperator: null as 'g' | 'd' | 'c' | null,
+});
+
+// State and action types for useReducer
+type VimState = {
+  mode: VimMode;
+  count: number;
+  pendingOperator: 'g' | 'd' | 'c' | null;
+  lastCommand: { type: string; count: number } | null;
+};
+
+type VimAction =
+  | { type: 'SET_MODE'; mode: VimMode }
+  | { type: 'SET_COUNT'; count: number }
+  | { type: 'INCREMENT_COUNT'; digit: number }
+  | { type: 'CLEAR_COUNT' }
+  | { type: 'SET_PENDING_OPERATOR'; operator: 'g' | 'd' | 'c' | null }
+  | {
+      type: 'SET_LAST_COMMAND';
+      command: { type: string; count: number } | null;
+    }
+  | { type: 'CLEAR_PENDING_STATES' }
+  | { type: 'ESCAPE_TO_NORMAL' };
+
+const initialVimState: VimState = {
+  mode: 'NORMAL',
+  count: 0,
+  pendingOperator: null,
+  lastCommand: null,
+};
+
+// Reducer function
+const vimReducer = (state: VimState, action: VimAction): VimState => {
+  switch (action.type) {
+    case 'SET_MODE':
+      return { ...state, mode: action.mode };
+
+    case 'SET_COUNT':
+      return { ...state, count: action.count };
+
+    case 'INCREMENT_COUNT':
+      return { ...state, count: state.count * DIGIT_MULTIPLIER + action.digit };
+
+    case 'CLEAR_COUNT':
+      return { ...state, count: 0 };
+
+    case 'SET_PENDING_OPERATOR':
+      return { ...state, pendingOperator: action.operator };
+
+    case 'SET_LAST_COMMAND':
+      return { ...state, lastCommand: action.command };
+
+    case 'CLEAR_PENDING_STATES':
+      return {
+        ...state,
+        ...createClearPendingState(),
+      };
+
+    case 'ESCAPE_TO_NORMAL':
+      // Handle escape - clear all pending states (mode is updated via context)
+      return {
+        ...state,
+        ...createClearPendingState(),
+      };
+
+    default:
+      return state;
+  }
+};
+
+/**
+ * React hook that provides vim-style editing functionality for text input.
+ *
+ * Features:
+ * - Modal editing (INSERT/NORMAL modes)
+ * - Navigation: h,j,k,l,w,b,e,0,$,^,gg,G with count prefixes
+ * - Editing: x,a,i,o,O,A,I,d,c,D,C with count prefixes
+ * - Complex operations: dd,cc,dw,cw,db,cb,de,ce
+ * - Command repetition (.)
+ * - Settings persistence
+ *
+ * @param buffer - TextBuffer instance for text manipulation
+ * @param onSubmit - Optional callback for command submission
+ * @returns Object with vim state and input handler
+ */
+export function useVim(buffer: TextBuffer, onSubmit?: (value: string) => void) {
+  const { vimEnabled, vimMode, setVimMode } = useVimMode();
+  const [state, dispatch] = useReducer(vimReducer, initialVimState);
+
+  // Sync vim mode from context to local state
+  useEffect(() => {
+    dispatch({ type: 'SET_MODE', mode: vimMode });
+  }, [vimMode]);
+
+  // Helper to update mode in both reducer and context
+  const updateMode = useCallback(
+    (mode: VimMode) => {
+      setVimMode(mode);
+      dispatch({ type: 'SET_MODE', mode });
+    },
+    [setVimMode],
+  );
+
+  // Helper functions using the reducer state
+  const getCurrentCount = useCallback(
+    () => state.count || DEFAULT_COUNT,
+    [state.count],
+  );
+
+  /** Executes common commands to eliminate duplication in dot (.) repeat command */
+  const executeCommand = useCallback(
+    (cmdType: string, count: number) => {
+      switch (cmdType) {
+        case CMD_TYPES.DELETE_WORD_FORWARD: {
+          buffer.vimDeleteWordForward(count);
+          break;
+        }
+
+        case CMD_TYPES.DELETE_WORD_BACKWARD: {
+          buffer.vimDeleteWordBackward(count);
+          break;
+        }
+
+        case CMD_TYPES.DELETE_WORD_END: {
+          buffer.vimDeleteWordEnd(count);
+          break;
+        }
+
+        case CMD_TYPES.CHANGE_WORD_FORWARD: {
+          buffer.vimChangeWordForward(count);
+          updateMode('INSERT');
+          break;
+        }
+
+        case CMD_TYPES.CHANGE_WORD_BACKWARD: {
+          buffer.vimChangeWordBackward(count);
+          updateMode('INSERT');
+          break;
+        }
+
+        case CMD_TYPES.CHANGE_WORD_END: {
+          buffer.vimChangeWordEnd(count);
+          updateMode('INSERT');
+          break;
+        }
+
+        case CMD_TYPES.DELETE_CHAR: {
+          buffer.vimDeleteChar(count);
+          break;
+        }
+
+        case CMD_TYPES.DELETE_LINE: {
+          buffer.vimDeleteLine(count);
+          break;
+        }
+
+        case CMD_TYPES.CHANGE_LINE: {
+          buffer.vimChangeLine(count);
+          updateMode('INSERT');
+          break;
+        }
+
+        case CMD_TYPES.CHANGE_MOVEMENT.LEFT:
+        case CMD_TYPES.CHANGE_MOVEMENT.DOWN:
+        case CMD_TYPES.CHANGE_MOVEMENT.UP:
+        case CMD_TYPES.CHANGE_MOVEMENT.RIGHT: {
+          const movementMap: Record<string, 'h' | 'j' | 'k' | 'l'> = {
+            [CMD_TYPES.CHANGE_MOVEMENT.LEFT]: 'h',
+            [CMD_TYPES.CHANGE_MOVEMENT.DOWN]: 'j',
+            [CMD_TYPES.CHANGE_MOVEMENT.UP]: 'k',
+            [CMD_TYPES.CHANGE_MOVEMENT.RIGHT]: 'l',
+          };
+          const movementType = movementMap[cmdType];
+          if (movementType) {
+            buffer.vimChangeMovement(movementType, count);
+            updateMode('INSERT');
+          }
+          break;
+        }
+
+        case CMD_TYPES.DELETE_TO_EOL: {
+          buffer.vimDeleteToEndOfLine();
+          break;
+        }
+
+        case CMD_TYPES.CHANGE_TO_EOL: {
+          buffer.vimChangeToEndOfLine();
+          updateMode('INSERT');
+          break;
+        }
+
+        default:
+          return false;
+      }
+      return true;
+    },
+    [buffer, updateMode],
+  );
+
+  /**
+   * Handles key input in INSERT mode
+   * @param normalizedKey - The normalized key input
+   * @returns boolean indicating if the key was handled
+   */
+  const handleInsertModeInput = useCallback(
+    (normalizedKey: Key): boolean => {
+      // Handle escape key immediately - switch to NORMAL mode on any escape
+      if (normalizedKey.name === 'escape') {
+        // Vim behavior: move cursor left when exiting insert mode (unless at beginning of line)
+        buffer.vimEscapeInsertMode();
+        dispatch({ type: 'ESCAPE_TO_NORMAL' });
+        updateMode('NORMAL');
+        return true;
+      }
+
+      // In INSERT mode, let InputPrompt handle completion keys and special commands
+      if (
+        normalizedKey.name === 'tab' ||
+        (normalizedKey.name === 'return' && !normalizedKey.ctrl) ||
+        normalizedKey.name === 'up' ||
+        normalizedKey.name === 'down' ||
+        (normalizedKey.ctrl && normalizedKey.name === 'r')
+      ) {
+        return false; // Let InputPrompt handle completion
+      }
+
+      // Let InputPrompt handle Ctrl+V for clipboard image pasting
+      if (normalizedKey.ctrl && normalizedKey.name === 'v') {
+        return false; // Let InputPrompt handle clipboard functionality
+      }
+
+      // Let InputPrompt handle shell commands
+      if (normalizedKey.sequence === '!' && buffer.text.length === 0) {
+        return false;
+      }
+
+      // Special handling for Enter key to allow command submission (lower priority than completion)
+      if (
+        normalizedKey.name === 'return' &&
+        !normalizedKey.ctrl &&
+        !normalizedKey.meta
+      ) {
+        if (buffer.text.trim() && onSubmit) {
+          // Handle command submission directly
+          const submittedValue = buffer.text;
+          buffer.setText('');
+          onSubmit(submittedValue);
+          return true;
+        }
+        return true; // Handled by vim (even if no onSubmit callback)
+      }
+
+      // useKeypress already provides the correct format for TextBuffer
+      buffer.handleInput(normalizedKey);
+      return true; // Handled by vim
+    },
+    [buffer, dispatch, updateMode, onSubmit],
+  );
+
+  /**
+   * Normalizes key input to ensure all required properties are present
+   * @param key - Raw key input
+   * @returns Normalized key with all properties
+   */
+  const normalizeKey = useCallback(
+    (key: Key): Key => ({
+      name: key.name || '',
+      sequence: key.sequence || '',
+      ctrl: key.ctrl || false,
+      meta: key.meta || false,
+      shift: key.shift || false,
+      paste: key.paste || false,
+    }),
+    [],
+  );
+
+  /**
+   * Handles change movement commands (ch, cj, ck, cl)
+   * @param movement - The movement direction
+   * @returns boolean indicating if command was handled
+   */
+  const handleChangeMovement = useCallback(
+    (movement: 'h' | 'j' | 'k' | 'l'): boolean => {
+      const count = getCurrentCount();
+      dispatch({ type: 'CLEAR_COUNT' });
+      buffer.vimChangeMovement(movement, count);
+      updateMode('INSERT');
+
+      const cmdTypeMap = {
+        h: CMD_TYPES.CHANGE_MOVEMENT.LEFT,
+        j: CMD_TYPES.CHANGE_MOVEMENT.DOWN,
+        k: CMD_TYPES.CHANGE_MOVEMENT.UP,
+        l: CMD_TYPES.CHANGE_MOVEMENT.RIGHT,
+      };
+
+      dispatch({
+        type: 'SET_LAST_COMMAND',
+        command: { type: cmdTypeMap[movement], count },
+      });
+      dispatch({ type: 'SET_PENDING_OPERATOR', operator: null });
+      return true;
+    },
+    [getCurrentCount, dispatch, buffer, updateMode],
+  );
+
+  /**
+   * Handles operator-motion commands (dw/cw, db/cb, de/ce)
+   * @param operator - The operator type ('d' for delete, 'c' for change)
+   * @param motion - The motion type ('w', 'b', 'e')
+   * @returns boolean indicating if command was handled
+   */
+  const handleOperatorMotion = useCallback(
+    (operator: 'd' | 'c', motion: 'w' | 'b' | 'e'): boolean => {
+      const count = getCurrentCount();
+
+      const commandMap = {
+        d: {
+          w: CMD_TYPES.DELETE_WORD_FORWARD,
+          b: CMD_TYPES.DELETE_WORD_BACKWARD,
+          e: CMD_TYPES.DELETE_WORD_END,
+        },
+        c: {
+          w: CMD_TYPES.CHANGE_WORD_FORWARD,
+          b: CMD_TYPES.CHANGE_WORD_BACKWARD,
+          e: CMD_TYPES.CHANGE_WORD_END,
+        },
+      };
+
+      const cmdType = commandMap[operator][motion];
+      executeCommand(cmdType, count);
+
+      dispatch({
+        type: 'SET_LAST_COMMAND',
+        command: { type: cmdType, count },
+      });
+      dispatch({ type: 'CLEAR_COUNT' });
+      dispatch({ type: 'SET_PENDING_OPERATOR', operator: null });
+
+      return true;
+    },
+    [getCurrentCount, executeCommand, dispatch],
+  );
+
+  const handleInput = useCallback(
+    (key: Key): boolean => {
+      if (!vimEnabled) {
+        return false; // Let InputPrompt handle it
+      }
+
+      let normalizedKey: Key;
+      try {
+        normalizedKey = normalizeKey(key);
+      } catch (error) {
+        // Handle malformed key inputs gracefully
+        console.warn('Malformed key input in vim mode:', key, error);
+        return false;
+      }
+
+      // Handle INSERT mode
+      if (state.mode === 'INSERT') {
+        return handleInsertModeInput(normalizedKey);
+      }
+
+      // Handle NORMAL mode
+      if (state.mode === 'NORMAL') {
+        // If in NORMAL mode, allow escape to pass through to other handlers
+        // if there's no pending operation.
+        if (normalizedKey.name === 'escape') {
+          if (state.pendingOperator) {
+            dispatch({ type: 'CLEAR_PENDING_STATES' });
+            return true; // Handled by vim
+          }
+          return false; // Pass through to other handlers
+        }
+
+        // Handle count input (numbers 1-9, and 0 if count > 0)
+        if (
+          DIGIT_1_TO_9.test(normalizedKey.sequence) ||
+          (normalizedKey.sequence === '0' && state.count > 0)
+        ) {
+          dispatch({
+            type: 'INCREMENT_COUNT',
+            digit: parseInt(normalizedKey.sequence, 10),
+          });
+          return true; // Handled by vim
+        }
+
+        const repeatCount = getCurrentCount();
+
+        switch (normalizedKey.sequence) {
+          case 'h': {
+            // Check if this is part of a change command (ch)
+            if (state.pendingOperator === 'c') {
+              return handleChangeMovement('h');
+            }
+
+            // Normal left movement
+            buffer.vimMoveLeft(repeatCount);
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'j': {
+            // Check if this is part of a change command (cj)
+            if (state.pendingOperator === 'c') {
+              return handleChangeMovement('j');
+            }
+
+            // Normal down movement
+            buffer.vimMoveDown(repeatCount);
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'k': {
+            // Check if this is part of a change command (ck)
+            if (state.pendingOperator === 'c') {
+              return handleChangeMovement('k');
+            }
+
+            // Normal up movement
+            buffer.vimMoveUp(repeatCount);
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'l': {
+            // Check if this is part of a change command (cl)
+            if (state.pendingOperator === 'c') {
+              return handleChangeMovement('l');
+            }
+
+            // Normal right movement
+            buffer.vimMoveRight(repeatCount);
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'w': {
+            // Check if this is part of a delete or change command (dw/cw)
+            if (state.pendingOperator === 'd') {
+              return handleOperatorMotion('d', 'w');
+            }
+            if (state.pendingOperator === 'c') {
+              return handleOperatorMotion('c', 'w');
+            }
+
+            // Normal word movement
+            buffer.vimMoveWordForward(repeatCount);
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'b': {
+            // Check if this is part of a delete or change command (db/cb)
+            if (state.pendingOperator === 'd') {
+              return handleOperatorMotion('d', 'b');
+            }
+            if (state.pendingOperator === 'c') {
+              return handleOperatorMotion('c', 'b');
+            }
+
+            // Normal backward word movement
+            buffer.vimMoveWordBackward(repeatCount);
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'e': {
+            // Check if this is part of a delete or change command (de/ce)
+            if (state.pendingOperator === 'd') {
+              return handleOperatorMotion('d', 'e');
+            }
+            if (state.pendingOperator === 'c') {
+              return handleOperatorMotion('c', 'e');
+            }
+
+            // Normal word end movement
+            buffer.vimMoveWordEnd(repeatCount);
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'x': {
+            // Delete character under cursor
+            buffer.vimDeleteChar(repeatCount);
+            dispatch({
+              type: 'SET_LAST_COMMAND',
+              command: { type: CMD_TYPES.DELETE_CHAR, count: repeatCount },
+            });
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'i': {
+            // Enter INSERT mode at current position
+            buffer.vimInsertAtCursor();
+            updateMode('INSERT');
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'a': {
+            // Enter INSERT mode after current position
+            buffer.vimAppendAtCursor();
+            updateMode('INSERT');
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'o': {
+            // Insert new line after current line and enter INSERT mode
+            buffer.vimOpenLineBelow();
+            updateMode('INSERT');
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'O': {
+            // Insert new line before current line and enter INSERT mode
+            buffer.vimOpenLineAbove();
+            updateMode('INSERT');
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case '0': {
+            // Move to start of line
+            buffer.vimMoveToLineStart();
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case '$': {
+            // Move to end of line
+            buffer.vimMoveToLineEnd();
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case '^': {
+            // Move to first non-whitespace character
+            buffer.vimMoveToFirstNonWhitespace();
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'g': {
+            if (state.pendingOperator === 'g') {
+              // Second 'g' - go to first line (gg command)
+              buffer.vimMoveToFirstLine();
+              dispatch({ type: 'SET_PENDING_OPERATOR', operator: null });
+            } else {
+              // First 'g' - wait for second g
+              dispatch({ type: 'SET_PENDING_OPERATOR', operator: 'g' });
+            }
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'G': {
+            if (state.count > 0) {
+              // Go to specific line number (1-based) when a count was provided
+              buffer.vimMoveToLine(state.count);
+            } else {
+              // Go to last line when no count was provided
+              buffer.vimMoveToLastLine();
+            }
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'I': {
+            // Enter INSERT mode at start of line (first non-whitespace)
+            buffer.vimInsertAtLineStart();
+            updateMode('INSERT');
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'A': {
+            // Enter INSERT mode at end of line
+            buffer.vimAppendAtLineEnd();
+            updateMode('INSERT');
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'd': {
+            if (state.pendingOperator === 'd') {
+              // Second 'd' - delete N lines (dd command)
+              const repeatCount = getCurrentCount();
+              executeCommand(CMD_TYPES.DELETE_LINE, repeatCount);
+              dispatch({
+                type: 'SET_LAST_COMMAND',
+                command: { type: CMD_TYPES.DELETE_LINE, count: repeatCount },
+              });
+              dispatch({ type: 'CLEAR_COUNT' });
+              dispatch({ type: 'SET_PENDING_OPERATOR', operator: null });
+            } else {
+              // First 'd' - wait for movement command
+              dispatch({ type: 'SET_PENDING_OPERATOR', operator: 'd' });
+            }
+            return true;
+          }
+
+          case 'c': {
+            if (state.pendingOperator === 'c') {
+              // Second 'c' - change N entire lines (cc command)
+              const repeatCount = getCurrentCount();
+              executeCommand(CMD_TYPES.CHANGE_LINE, repeatCount);
+              dispatch({
+                type: 'SET_LAST_COMMAND',
+                command: { type: CMD_TYPES.CHANGE_LINE, count: repeatCount },
+              });
+              dispatch({ type: 'CLEAR_COUNT' });
+              dispatch({ type: 'SET_PENDING_OPERATOR', operator: null });
+            } else {
+              // First 'c' - wait for movement command
+              dispatch({ type: 'SET_PENDING_OPERATOR', operator: 'c' });
+            }
+            return true;
+          }
+
+          case 'D': {
+            // Delete from cursor to end of line (equivalent to d$)
+            executeCommand(CMD_TYPES.DELETE_TO_EOL, 1);
+            dispatch({
+              type: 'SET_LAST_COMMAND',
+              command: { type: CMD_TYPES.DELETE_TO_EOL, count: 1 },
+            });
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case 'C': {
+            // Change from cursor to end of line (equivalent to c$)
+            executeCommand(CMD_TYPES.CHANGE_TO_EOL, 1);
+            dispatch({
+              type: 'SET_LAST_COMMAND',
+              command: { type: CMD_TYPES.CHANGE_TO_EOL, count: 1 },
+            });
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          case '.': {
+            // Repeat last command
+            if (state.lastCommand) {
+              const cmdData = state.lastCommand;
+
+              // All repeatable commands are now handled by executeCommand
+              executeCommand(cmdData.type, cmdData.count);
+            }
+
+            dispatch({ type: 'CLEAR_COUNT' });
+            return true;
+          }
+
+          default: {
+            // Check for arrow keys (they have different sequences but known names)
+            if (normalizedKey.name === 'left') {
+              // Left arrow - same as 'h'
+              if (state.pendingOperator === 'c') {
+                return handleChangeMovement('h');
+              }
+
+              // Normal left movement (same as 'h')
+              buffer.vimMoveLeft(repeatCount);
+              dispatch({ type: 'CLEAR_COUNT' });
+              return true;
+            }
+
+            if (normalizedKey.name === 'down') {
+              // Down arrow - same as 'j'
+              if (state.pendingOperator === 'c') {
+                return handleChangeMovement('j');
+              }
+
+              // Normal down movement (same as 'j')
+              buffer.vimMoveDown(repeatCount);
+              dispatch({ type: 'CLEAR_COUNT' });
+              return true;
+            }
+
+            if (normalizedKey.name === 'up') {
+              // Up arrow - same as 'k'
+              if (state.pendingOperator === 'c') {
+                return handleChangeMovement('k');
+              }
+
+              // Normal up movement (same as 'k')
+              buffer.vimMoveUp(repeatCount);
+              dispatch({ type: 'CLEAR_COUNT' });
+              return true;
+            }
+
+            if (normalizedKey.name === 'right') {
+              // Right arrow - same as 'l'
+              if (state.pendingOperator === 'c') {
+                return handleChangeMovement('l');
+              }
+
+              // Normal right movement (same as 'l')
+              buffer.vimMoveRight(repeatCount);
+              dispatch({ type: 'CLEAR_COUNT' });
+              return true;
+            }
+
+            // Unknown command, clear count and pending states
+            dispatch({ type: 'CLEAR_PENDING_STATES' });
+            return true; // Still handled by vim to prevent other handlers
+          }
+        }
+      }
+
+      return false; // Not handled by vim
+    },
+    [
+      vimEnabled,
+      normalizeKey,
+      handleInsertModeInput,
+      state.mode,
+      state.count,
+      state.pendingOperator,
+      state.lastCommand,
+      dispatch,
+      getCurrentCount,
+      handleChangeMovement,
+      handleOperatorMotion,
+      buffer,
+      executeCommand,
+      updateMode,
+    ],
+  );
+
+  return {
+    mode: state.mode,
+    vimModeEnabled: vimEnabled,
+    handleInput, // Expose the input handler for InputPrompt to use
+  };
+}

projects/ui/qwen-code/packages/cli/src/ui/privacy/CloudFreePrivacyNotice.tsx

@@ -0,0 +1,117 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Box, Newline, Text } from 'ink';
+import { RadioButtonSelect } from '../components/shared/RadioButtonSelect.js';
+import { usePrivacySettings } from '../hooks/usePrivacySettings.js';
+import { CloudPaidPrivacyNotice } from './CloudPaidPrivacyNotice.js';
+import { Config } from '@qwen-code/qwen-code-core';
+import { Colors } from '../colors.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+
+interface CloudFreePrivacyNoticeProps {
+  config: Config;
+  onExit: () => void;
+}
+
+export const CloudFreePrivacyNotice = ({
+  config,
+  onExit,
+}: CloudFreePrivacyNoticeProps) => {
+  const { privacyState, updateDataCollectionOptIn } =
+    usePrivacySettings(config);
+
+  useKeypress(
+    (key) => {
+      if (privacyState.error && key.name === 'escape') {
+        onExit();
+      }
+    },
+    { isActive: true },
+  );
+
+  if (privacyState.isLoading) {
+    return <Text color={Colors.Gray}>Loading...</Text>;
+  }
+
+  if (privacyState.error) {
+    return (
+      <Box flexDirection="column" marginY={1}>
+        <Text color={Colors.AccentRed}>
+          Error loading Opt-in settings: {privacyState.error}
+        </Text>
+        <Text color={Colors.Gray}>Press Esc to exit.</Text>
+      </Box>
+    );
+  }
+
+  if (privacyState.isFreeTier === false) {
+    return <CloudPaidPrivacyNotice onExit={onExit} />;
+  }
+
+  const items = [
+    { label: 'Yes', value: true },
+    { label: 'No', value: false },
+  ];
+
+  return (
+    <Box flexDirection="column" marginY={1}>
+      <Text bold color={Colors.AccentPurple}>
+        Gemini Code Assist for Individuals Privacy Notice
+      </Text>
+      <Newline />
+      <Text>
+        This notice and our Privacy Policy
+        <Text color={Colors.AccentBlue}>[1]</Text> describe how Gemini Code
+        Assist handles your data. Please read them carefully.
+      </Text>
+      <Newline />
+      <Text>
+        When you use Gemini Code Assist for individuals with Gemini CLI, Google
+        collects your prompts, related code, generated output, code edits,
+        related feature usage information, and your feedback to provide,
+        improve, and develop Google products and services and machine learning
+        technologies.
+      </Text>
+      <Newline />
+      <Text>
+        To help with quality and improve our products (such as generative
+        machine-learning models), human reviewers may read, annotate, and
+        process the data collected above. We take steps to protect your privacy
+        as part of this process. This includes disconnecting the data from your
+        Google Account before reviewers see or annotate it, and storing those
+        disconnected copies for up to 18 months. Please don&apos;t submit
+        confidential information or any data you wouldn&apos;t want a reviewer
+        to see or Google to use to improve our products, services and
+        machine-learning technologies.
+      </Text>
+      <Newline />
+      <Box flexDirection="column">
+        <Text>
+          Allow Google to use this data to develop and improve our products?
+        </Text>
+        <RadioButtonSelect
+          items={items}
+          initialIndex={privacyState.dataCollectionOptIn ? 0 : 1}
+          onSelect={(value) => {
+            updateDataCollectionOptIn(value);
+            // Only exit if there was no error.
+            if (!privacyState.error) {
+              onExit();
+            }
+          }}
+        />
+      </Box>
+      <Newline />
+      <Text>
+        <Text color={Colors.AccentBlue}>[1]</Text>{' '}
+        https://policies.google.com/privacy
+      </Text>
+      <Newline />
+      <Text color={Colors.Gray}>Press Enter to choose an option and exit.</Text>
+    </Box>
+  );
+};

projects/ui/qwen-code/packages/cli/src/ui/privacy/CloudPaidPrivacyNotice.tsx

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Box, Newline, Text } from 'ink';
+import { Colors } from '../colors.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+
+interface CloudPaidPrivacyNoticeProps {
+  onExit: () => void;
+}
+
+export const CloudPaidPrivacyNotice = ({
+  onExit,
+}: CloudPaidPrivacyNoticeProps) => {
+  useKeypress(
+    (key) => {
+      if (key.name === 'escape') {
+        onExit();
+      }
+    },
+    { isActive: true },
+  );
+
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      <Text bold color={Colors.AccentPurple}>
+        Vertex AI Notice
+      </Text>
+      <Newline />
+      <Text>
+        Service Specific Terms<Text color={Colors.AccentBlue}>[1]</Text> are
+        incorporated into the agreement under which Google has agreed to provide
+        Google Cloud Platform<Text color={Colors.AccentGreen}>[2]</Text> to
+        Customer (the “Agreement”). If the Agreement authorizes the resale or
+        supply of Google Cloud Platform under a Google Cloud partner or reseller
+        program, then except for in the section entitled “Partner-Specific
+        Terms”, all references to Customer in the Service Specific Terms mean
+        Partner or Reseller (as applicable), and all references to Customer Data
+        in the Service Specific Terms mean Partner Data. Capitalized terms used
+        but not defined in the Service Specific Terms have the meaning given to
+        them in the Agreement.
+      </Text>
+      <Newline />
+      <Text>
+        <Text color={Colors.AccentBlue}>[1]</Text>{' '}
+        https://cloud.google.com/terms/service-terms
+      </Text>
+      <Text>
+        <Text color={Colors.AccentGreen}>[2]</Text>{' '}
+        https://cloud.google.com/terms/services
+      </Text>
+      <Newline />
+      <Text color={Colors.Gray}>Press Esc to exit.</Text>
+    </Box>
+  );
+};

projects/ui/qwen-code/packages/cli/src/ui/privacy/GeminiPrivacyNotice.tsx

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Box, Newline, Text } from 'ink';
+import { Colors } from '../colors.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+
+interface GeminiPrivacyNoticeProps {
+  onExit: () => void;
+}
+
+export const GeminiPrivacyNotice = ({ onExit }: GeminiPrivacyNoticeProps) => {
+  useKeypress(
+    (key) => {
+      if (key.name === 'escape') {
+        onExit();
+      }
+    },
+    { isActive: true },
+  );
+
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      <Text bold color={Colors.AccentPurple}>
+        Gemini API Key Notice
+      </Text>
+      <Newline />
+      <Text>
+        By using the Gemini API<Text color={Colors.AccentBlue}>[1]</Text>,
+        Google AI Studio
+        <Text color={Colors.AccentRed}>[2]</Text>, and the other Google
+        developer services that reference these terms (collectively, the
+        &quot;APIs&quot; or &quot;Services&quot;), you are agreeing to Google
+        APIs Terms of Service (the &quot;API Terms&quot;)
+        <Text color={Colors.AccentGreen}>[3]</Text>, and the Gemini API
+        Additional Terms of Service (the &quot;Additional Terms&quot;)
+        <Text color={Colors.AccentPurple}>[4]</Text>.
+      </Text>
+      <Newline />
+      <Text>
+        <Text color={Colors.AccentBlue}>[1]</Text>{' '}
+        https://ai.google.dev/docs/gemini_api_overview
+      </Text>
+      <Text>
+        <Text color={Colors.AccentRed}>[2]</Text> https://aistudio.google.com/
+      </Text>
+      <Text>
+        <Text color={Colors.AccentGreen}>[3]</Text>{' '}
+        https://developers.google.com/terms
+      </Text>
+      <Text>
+        <Text color={Colors.AccentPurple}>[4]</Text>{' '}
+        https://ai.google.dev/gemini-api/terms
+      </Text>
+      <Newline />
+      <Text color={Colors.Gray}>Press Esc to exit.</Text>
+    </Box>
+  );
+};

projects/ui/qwen-code/packages/cli/src/ui/privacy/PrivacyNotice.tsx

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Box } from 'ink';
+import { type Config, AuthType } from '@qwen-code/qwen-code-core';
+import { GeminiPrivacyNotice } from './GeminiPrivacyNotice.js';
+import { CloudPaidPrivacyNotice } from './CloudPaidPrivacyNotice.js';
+import { CloudFreePrivacyNotice } from './CloudFreePrivacyNotice.js';
+
+interface PrivacyNoticeProps {
+  onExit: () => void;
+  config: Config;
+}
+
+const PrivacyNoticeText = ({
+  config,
+  onExit,
+}: {
+  config: Config;
+  onExit: () => void;
+}) => {
+  const authType = config.getContentGeneratorConfig()?.authType;
+
+  switch (authType) {
+    case AuthType.USE_GEMINI:
+      return <GeminiPrivacyNotice onExit={onExit} />;
+    case AuthType.USE_VERTEX_AI:
+      return <CloudPaidPrivacyNotice onExit={onExit} />;
+    case AuthType.LOGIN_WITH_GOOGLE:
+    default:
+      return <CloudFreePrivacyNotice config={config} onExit={onExit} />;
+  }
+};
+
+export const PrivacyNotice = ({ onExit, config }: PrivacyNoticeProps) => (
+  <Box borderStyle="round" padding={1} flexDirection="column">
+    <PrivacyNoticeText config={config} onExit={onExit} />
+  </Box>
+);

projects/ui/qwen-code/packages/cli/src/ui/themes/ansi-light.ts

@@ -0,0 +1,150 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { type ColorsTheme, Theme } from './theme.js';
+import { lightSemanticColors } from './semantic-tokens.js';
+
+const ansiLightColors: ColorsTheme = {
+  type: 'light',
+  Background: 'white',
+  Foreground: '#444',
+  LightBlue: 'blue',
+  AccentBlue: 'blue',
+  AccentPurple: 'purple',
+  AccentCyan: 'cyan',
+  AccentGreen: 'green',
+  AccentYellow: 'orange',
+  AccentRed: 'red',
+  DiffAdded: '#E5F2E5',
+  DiffRemoved: '#FFE5E5',
+  Comment: 'gray',
+  Gray: 'gray',
+  GradientColors: ['blue', 'green'],
+};
+
+export const ANSILight: Theme = new Theme(
+  'ANSI Light',
+  'light',
+  {
+    hljs: {
+      display: 'block',
+      overflowX: 'auto',
+      padding: '0.5em',
+      background: 'white',
+      color: 'black',
+    },
+    'hljs-keyword': {
+      color: 'blue',
+    },
+    'hljs-literal': {
+      color: 'blue',
+    },
+    'hljs-symbol': {
+      color: 'blue',
+    },
+    'hljs-name': {
+      color: 'blue',
+    },
+    'hljs-link': {
+      color: 'blue',
+    },
+    'hljs-built_in': {
+      color: 'cyan',
+    },
+    'hljs-type': {
+      color: 'cyan',
+    },
+    'hljs-number': {
+      color: 'green',
+    },
+    'hljs-class': {
+      color: 'green',
+    },
+    'hljs-string': {
+      color: 'red',
+    },
+    'hljs-meta-string': {
+      color: 'red',
+    },
+    'hljs-regexp': {
+      color: 'magenta',
+    },
+    'hljs-template-tag': {
+      color: 'magenta',
+    },
+    'hljs-subst': {
+      color: 'black',
+    },
+    'hljs-function': {
+      color: 'black',
+    },
+    'hljs-title': {
+      color: 'black',
+    },
+    'hljs-params': {
+      color: 'black',
+    },
+    'hljs-formula': {
+      color: 'black',
+    },
+    'hljs-comment': {
+      color: 'gray',
+    },
+    'hljs-quote': {
+      color: 'gray',
+    },
+    'hljs-doctag': {
+      color: 'gray',
+    },
+    'hljs-meta': {
+      color: 'gray',
+    },
+    'hljs-meta-keyword': {
+      color: 'gray',
+    },
+    'hljs-tag': {
+      color: 'gray',
+    },
+    'hljs-variable': {
+      color: 'purple',
+    },
+    'hljs-template-variable': {
+      color: 'purple',
+    },
+    'hljs-attr': {
+      color: 'blue',
+    },
+    'hljs-attribute': {
+      color: 'blue',
+    },
+    'hljs-builtin-name': {
+      color: 'blue',
+    },
+    'hljs-section': {
+      color: 'orange',
+    },
+    'hljs-bullet': {
+      color: 'orange',
+    },
+    'hljs-selector-tag': {
+      color: 'orange',
+    },
+    'hljs-selector-id': {
+      color: 'orange',
+    },
+    'hljs-selector-class': {
+      color: 'orange',
+    },
+    'hljs-selector-attr': {
+      color: 'orange',
+    },
+    'hljs-selector-pseudo': {
+      color: 'orange',
+    },
+  },
+  ansiLightColors,
+  lightSemanticColors,
+);