Add files using upload-large-folder tool

projects/ui/qwen-code/packages/cli/src/ui/components/messages/ToolConfirmationMessage.test.tsx

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { ToolConfirmationMessage } from './ToolConfirmationMessage.js';
+import { ToolCallConfirmationDetails } from '@qwen-code/qwen-code-core';
+import { renderWithProviders } from '../../../test-utils/render.js';
+
+describe('ToolConfirmationMessage', () => {
+  it('should not display urls if prompt and url are the same', () => {
+    const confirmationDetails: ToolCallConfirmationDetails = {
+      type: 'info',
+      title: 'Confirm Web Fetch',
+      prompt: 'https://example.com',
+      urls: ['https://example.com'],
+      onConfirm: vi.fn(),
+    };
+
+    const { lastFrame } = renderWithProviders(
+      <ToolConfirmationMessage
+        confirmationDetails={confirmationDetails}
+        availableTerminalHeight={30}
+        terminalWidth={80}
+      />,
+    );
+
+    expect(lastFrame()).not.toContain('URLs to fetch:');
+  });
+
+  it('should display urls if prompt and url are different', () => {
+    const confirmationDetails: ToolCallConfirmationDetails = {
+      type: 'info',
+      title: 'Confirm Web Fetch',
+      prompt:
+        'fetch https://github.com/google/gemini-react/blob/main/README.md',
+      urls: [
+        'https://raw.githubusercontent.com/google/gemini-react/main/README.md',
+      ],
+      onConfirm: vi.fn(),
+    };
+
+    const { lastFrame } = renderWithProviders(
+      <ToolConfirmationMessage
+        confirmationDetails={confirmationDetails}
+        availableTerminalHeight={30}
+        terminalWidth={80}
+      />,
+    );
+
+    expect(lastFrame()).toContain('URLs to fetch:');
+    expect(lastFrame()).toContain(
+      '- https://raw.githubusercontent.com/google/gemini-react/main/README.md',
+    );
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx

@@ -0,0 +1,297 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { Box, Text } from 'ink';
+import { DiffRenderer } from './DiffRenderer.js';
+import { Colors } from '../../colors.js';
+import { RenderInline } from '../../utils/InlineMarkdownRenderer.js';
+import {
+  ToolCallConfirmationDetails,
+  ToolConfirmationOutcome,
+  ToolExecuteConfirmationDetails,
+  ToolMcpConfirmationDetails,
+  Config,
+} from '@qwen-code/qwen-code-core';
+import {
+  RadioButtonSelect,
+  RadioSelectItem,
+} from '../shared/RadioButtonSelect.js';
+import { MaxSizedBox } from '../shared/MaxSizedBox.js';
+import { useKeypress } from '../../hooks/useKeypress.js';
+
+export interface ToolConfirmationMessageProps {
+  confirmationDetails: ToolCallConfirmationDetails;
+  config?: Config;
+  isFocused?: boolean;
+  availableTerminalHeight?: number;
+  terminalWidth: number;
+}
+
+export const ToolConfirmationMessage: React.FC<
+  ToolConfirmationMessageProps
+> = ({
+  confirmationDetails,
+  config,
+  isFocused = true,
+  availableTerminalHeight,
+  terminalWidth,
+}) => {
+  const { onConfirm } = confirmationDetails;
+  const childWidth = terminalWidth - 2; // 2 for padding
+
+  const handleConfirm = async (outcome: ToolConfirmationOutcome) => {
+    if (confirmationDetails.type === 'edit') {
+      const ideClient = config?.getIdeClient();
+      if (config?.getIdeMode()) {
+        const cliOutcome =
+          outcome === ToolConfirmationOutcome.Cancel ? 'rejected' : 'accepted';
+        await ideClient?.resolveDiffFromCli(
+          confirmationDetails.filePath,
+          cliOutcome,
+        );
+      }
+    }
+    onConfirm(outcome);
+  };
+
+  useKeypress(
+    (key) => {
+      if (!isFocused) return;
+      if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+        handleConfirm(ToolConfirmationOutcome.Cancel);
+      }
+    },
+    { isActive: isFocused },
+  );
+
+  const handleSelect = (item: ToolConfirmationOutcome) => handleConfirm(item);
+
+  let bodyContent: React.ReactNode | null = null; // Removed contextDisplay here
+  let question: string;
+
+  const options: Array<RadioSelectItem<ToolConfirmationOutcome>> = new Array<
+    RadioSelectItem<ToolConfirmationOutcome>
+  >();
+
+  // Body content is now the DiffRenderer, passing filename to it
+  // The bordered box is removed from here and handled within DiffRenderer
+
+  function availableBodyContentHeight() {
+    if (options.length === 0) {
+      // This should not happen in practice as options are always added before this is called.
+      throw new Error('Options not provided for confirmation message');
+    }
+
+    if (availableTerminalHeight === undefined) {
+      return undefined;
+    }
+
+    // Calculate the vertical space (in lines) consumed by UI elements
+    // surrounding the main body content.
+    const PADDING_OUTER_Y = 2; // Main container has `padding={1}` (top & bottom).
+    const MARGIN_BODY_BOTTOM = 1; // margin on the body container.
+    const HEIGHT_QUESTION = 1; // The question text is one line.
+    const MARGIN_QUESTION_BOTTOM = 1; // Margin on the question container.
+    const HEIGHT_OPTIONS = options.length; // Each option in the radio select takes one line.
+
+    const surroundingElementsHeight =
+      PADDING_OUTER_Y +
+      MARGIN_BODY_BOTTOM +
+      HEIGHT_QUESTION +
+      MARGIN_QUESTION_BOTTOM +
+      HEIGHT_OPTIONS;
+    return Math.max(availableTerminalHeight - surroundingElementsHeight, 1);
+  }
+
+  if (confirmationDetails.type === 'edit') {
+    if (confirmationDetails.isModifying) {
+      return (
+        <Box
+          minWidth="90%"
+          borderStyle="round"
+          borderColor={Colors.Gray}
+          justifyContent="space-around"
+          padding={1}
+          overflow="hidden"
+        >
+          <Text>Modify in progress: </Text>
+          <Text color={Colors.AccentGreen}>
+            Save and close external editor to continue
+          </Text>
+        </Box>
+      );
+    }
+
+    question = `Apply this change?`;
+    options.push(
+      {
+        label: 'Yes, allow once',
+        value: ToolConfirmationOutcome.ProceedOnce,
+      },
+      {
+        label: 'Yes, allow always',
+        value: ToolConfirmationOutcome.ProceedAlways,
+      },
+    );
+    if (config?.getIdeMode()) {
+      options.push({
+        label: 'No (esc)',
+        value: ToolConfirmationOutcome.Cancel,
+      });
+    } else {
+      options.push({
+        label: 'Modify with external editor',
+        value: ToolConfirmationOutcome.ModifyWithEditor,
+      });
+      options.push({
+        label: 'No, suggest changes (esc)',
+        value: ToolConfirmationOutcome.Cancel,
+      });
+    }
+
+    bodyContent = (
+      <DiffRenderer
+        diffContent={confirmationDetails.fileDiff}
+        filename={confirmationDetails.fileName}
+        availableTerminalHeight={availableBodyContentHeight()}
+        terminalWidth={childWidth}
+      />
+    );
+  } else if (confirmationDetails.type === 'exec') {
+    const executionProps =
+      confirmationDetails as ToolExecuteConfirmationDetails;
+
+    question = `Allow execution of: '${executionProps.rootCommand}'?`;
+    options.push(
+      {
+        label: `Yes, allow once`,
+        value: ToolConfirmationOutcome.ProceedOnce,
+      },
+      {
+        label: `Yes, allow always ...`,
+        value: ToolConfirmationOutcome.ProceedAlways,
+      },
+      {
+        label: 'No, suggest changes (esc)',
+        value: ToolConfirmationOutcome.Cancel,
+      },
+    );
+
+    let bodyContentHeight = availableBodyContentHeight();
+    if (bodyContentHeight !== undefined) {
+      bodyContentHeight -= 2; // Account for padding;
+    }
+    bodyContent = (
+      <Box flexDirection="column">
+        <Box paddingX={1} marginLeft={1}>
+          <MaxSizedBox
+            maxHeight={bodyContentHeight}
+            maxWidth={Math.max(childWidth - 4, 1)}
+          >
+            <Box>
+              <Text color={Colors.AccentCyan}>{executionProps.command}</Text>
+            </Box>
+          </MaxSizedBox>
+        </Box>
+      </Box>
+    );
+  } else if (confirmationDetails.type === 'info') {
+    const infoProps = confirmationDetails;
+    const displayUrls =
+      infoProps.urls &&
+      !(infoProps.urls.length === 1 && infoProps.urls[0] === infoProps.prompt);
+
+    question = `Do you want to proceed?`;
+    options.push(
+      {
+        label: 'Yes, allow once',
+        value: ToolConfirmationOutcome.ProceedOnce,
+      },
+      {
+        label: 'Yes, allow always',
+        value: ToolConfirmationOutcome.ProceedAlways,
+      },
+      {
+        label: 'No, suggest changes (esc)',
+        value: ToolConfirmationOutcome.Cancel,
+      },
+    );
+
+    bodyContent = (
+      <Box flexDirection="column" paddingX={1} marginLeft={1}>
+        <Text color={Colors.AccentCyan}>
+          <RenderInline text={infoProps.prompt} />
+        </Text>
+        {displayUrls && infoProps.urls && infoProps.urls.length > 0 && (
+          <Box flexDirection="column" marginTop={1}>
+            <Text>URLs to fetch:</Text>
+            {infoProps.urls.map((url) => (
+              <Text key={url}>
+                {' '}
+                - <RenderInline text={url} />
+              </Text>
+            ))}
+          </Box>
+        )}
+      </Box>
+    );
+  } else {
+    // mcp tool confirmation
+    const mcpProps = confirmationDetails as ToolMcpConfirmationDetails;
+
+    bodyContent = (
+      <Box flexDirection="column" paddingX={1} marginLeft={1}>
+        <Text color={Colors.AccentCyan}>MCP Server: {mcpProps.serverName}</Text>
+        <Text color={Colors.AccentCyan}>Tool: {mcpProps.toolName}</Text>
+      </Box>
+    );
+
+    question = `Allow execution of MCP tool "${mcpProps.toolName}" from server "${mcpProps.serverName}"?`;
+    options.push(
+      {
+        label: 'Yes, allow once',
+        value: ToolConfirmationOutcome.ProceedOnce,
+      },
+      {
+        label: `Yes, always allow tool "${mcpProps.toolName}" from server "${mcpProps.serverName}"`,
+        value: ToolConfirmationOutcome.ProceedAlwaysTool, // Cast until types are updated
+      },
+      {
+        label: `Yes, always allow all tools from server "${mcpProps.serverName}"`,
+        value: ToolConfirmationOutcome.ProceedAlwaysServer,
+      },
+      {
+        label: 'No, suggest changes (esc)',
+        value: ToolConfirmationOutcome.Cancel,
+      },
+    );
+  }
+
+  return (
+    <Box flexDirection="column" padding={1} width={childWidth}>
+      {/* Body Content (Diff Renderer or Command Info) */}
+      {/* No separate context display here anymore for edits */}
+      <Box flexGrow={1} flexShrink={1} overflow="hidden" marginBottom={1}>
+        {bodyContent}
+      </Box>
+
+      {/* Confirmation Question */}
+      <Box marginBottom={1} flexShrink={0}>
+        <Text wrap="truncate">{question}</Text>
+      </Box>
+
+      {/* Select Input for Options */}
+      <Box flexShrink={0}>
+        <RadioButtonSelect
+          items={options}
+          onSelect={handleSelect}
+          isFocused={isFocused}
+        />
+      </Box>
+    </Box>
+  );
+};

projects/ui/qwen-code/packages/cli/src/ui/components/messages/ToolGroupMessage.tsx

@@ -0,0 +1,126 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React, { useMemo } from 'react';
+import { Box } from 'ink';
+import { IndividualToolCallDisplay, ToolCallStatus } from '../../types.js';
+import { ToolMessage } from './ToolMessage.js';
+import { ToolConfirmationMessage } from './ToolConfirmationMessage.js';
+import { Colors } from '../../colors.js';
+import { Config } from '@qwen-code/qwen-code-core';
+import { SHELL_COMMAND_NAME } from '../../constants.js';
+
+interface ToolGroupMessageProps {
+  groupId: number;
+  toolCalls: IndividualToolCallDisplay[];
+  availableTerminalHeight?: number;
+  terminalWidth: number;
+  config?: Config;
+  isFocused?: boolean;
+}
+
+// Main component renders the border and maps the tools using ToolMessage
+export const ToolGroupMessage: React.FC<ToolGroupMessageProps> = ({
+  toolCalls,
+  availableTerminalHeight,
+  terminalWidth,
+  config,
+  isFocused = true,
+}) => {
+  const hasPending = !toolCalls.every(
+    (t) => t.status === ToolCallStatus.Success,
+  );
+  const isShellCommand = toolCalls.some((t) => t.name === SHELL_COMMAND_NAME);
+  const borderColor =
+    hasPending || isShellCommand ? Colors.AccentYellow : Colors.Gray;
+
+  const staticHeight = /* border */ 2 + /* marginBottom */ 1;
+  // This is a bit of a magic number, but it accounts for the border and
+  // marginLeft.
+  const innerWidth = terminalWidth - 4;
+
+  // only prompt for tool approval on the first 'confirming' tool in the list
+  // note, after the CTA, this automatically moves over to the next 'confirming' tool
+  const toolAwaitingApproval = useMemo(
+    () => toolCalls.find((tc) => tc.status === ToolCallStatus.Confirming),
+    [toolCalls],
+  );
+
+  let countToolCallsWithResults = 0;
+  for (const tool of toolCalls) {
+    if (tool.resultDisplay !== undefined && tool.resultDisplay !== '') {
+      countToolCallsWithResults++;
+    }
+  }
+  const countOneLineToolCalls = toolCalls.length - countToolCallsWithResults;
+  const availableTerminalHeightPerToolMessage = availableTerminalHeight
+    ? Math.max(
+        Math.floor(
+          (availableTerminalHeight - staticHeight - countOneLineToolCalls) /
+            Math.max(1, countToolCallsWithResults),
+        ),
+        1,
+      )
+    : undefined;
+
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="round"
+      /*
+        This width constraint is highly important and protects us from an Ink rendering bug.
+        Since the ToolGroup can typically change rendering states frequently, it can cause
+        Ink to render the border of the box incorrectly and span multiple lines and even
+        cause tearing.
+      */
+      width="100%"
+      marginLeft={1}
+      borderDimColor={hasPending}
+      borderColor={borderColor}
+    >
+      {toolCalls.map((tool) => {
+        const isConfirming = toolAwaitingApproval?.callId === tool.callId;
+        return (
+          <Box key={tool.callId} flexDirection="column" minHeight={1}>
+            <Box flexDirection="row" alignItems="center">
+              <ToolMessage
+                callId={tool.callId}
+                name={tool.name}
+                description={tool.description}
+                resultDisplay={tool.resultDisplay}
+                status={tool.status}
+                confirmationDetails={tool.confirmationDetails}
+                availableTerminalHeight={availableTerminalHeightPerToolMessage}
+                terminalWidth={innerWidth}
+                emphasis={
+                  isConfirming
+                    ? 'high'
+                    : toolAwaitingApproval
+                      ? 'low'
+                      : 'medium'
+                }
+                renderOutputAsMarkdown={tool.renderOutputAsMarkdown}
+              />
+            </Box>
+            {tool.status === ToolCallStatus.Confirming &&
+              isConfirming &&
+              tool.confirmationDetails && (
+                <ToolConfirmationMessage
+                  confirmationDetails={tool.confirmationDetails}
+                  config={config}
+                  isFocused={isFocused}
+                  availableTerminalHeight={
+                    availableTerminalHeightPerToolMessage
+                  }
+                  terminalWidth={innerWidth}
+                />
+              )}
+          </Box>
+        );
+      })}
+    </Box>
+  );
+};

projects/ui/qwen-code/packages/cli/src/ui/components/messages/ToolMessage.test.tsx

@@ -0,0 +1,183 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { ToolMessage, ToolMessageProps } from './ToolMessage.js';
+import { StreamingState, ToolCallStatus } from '../../types.js';
+import { Text } from 'ink';
+import { StreamingContext } from '../../contexts/StreamingContext.js';
+
+// Mock child components or utilities if they are complex or have side effects
+vi.mock('../GeminiRespondingSpinner.js', () => ({
+  GeminiRespondingSpinner: ({
+    nonRespondingDisplay,
+  }: {
+    nonRespondingDisplay?: string;
+  }) => {
+    const streamingState = React.useContext(StreamingContext)!;
+    if (streamingState === StreamingState.Responding) {
+      return <Text>MockRespondingSpinner</Text>;
+    }
+    return nonRespondingDisplay ? <Text>{nonRespondingDisplay}</Text> : null;
+  },
+}));
+vi.mock('./DiffRenderer.js', () => ({
+  DiffRenderer: function MockDiffRenderer({
+    diffContent,
+  }: {
+    diffContent: string;
+  }) {
+    return <Text>MockDiff:{diffContent}</Text>;
+  },
+}));
+vi.mock('../../utils/MarkdownDisplay.js', () => ({
+  MarkdownDisplay: function MockMarkdownDisplay({ text }: { text: string }) {
+    return <Text>MockMarkdown:{text}</Text>;
+  },
+}));
+
+// Helper to render with context
+const renderWithContext = (
+  ui: React.ReactElement,
+  streamingState: StreamingState,
+) => {
+  const contextValue: StreamingState = streamingState;
+  return render(
+    <StreamingContext.Provider value={contextValue}>
+      {ui}
+    </StreamingContext.Provider>,
+  );
+};
+
+describe('<ToolMessage />', () => {
+  const baseProps: ToolMessageProps = {
+    callId: 'tool-123',
+    name: 'test-tool',
+    description: 'A tool for testing',
+    resultDisplay: 'Test result',
+    status: ToolCallStatus.Success,
+    terminalWidth: 80,
+    confirmationDetails: undefined,
+    emphasis: 'medium',
+  };
+
+  it('renders basic tool information', () => {
+    const { lastFrame } = renderWithContext(
+      <ToolMessage {...baseProps} />,
+      StreamingState.Idle,
+    );
+    const output = lastFrame();
+    expect(output).toContain('✔'); // Success indicator
+    expect(output).toContain('test-tool');
+    expect(output).toContain('A tool for testing');
+    expect(output).toContain('MockMarkdown:Test result');
+  });
+
+  describe('ToolStatusIndicator rendering', () => {
+    it('shows ✔ for Success status', () => {
+      const { lastFrame } = renderWithContext(
+        <ToolMessage {...baseProps} status={ToolCallStatus.Success} />,
+        StreamingState.Idle,
+      );
+      expect(lastFrame()).toContain('✔');
+    });
+
+    it('shows o for Pending status', () => {
+      const { lastFrame } = renderWithContext(
+        <ToolMessage {...baseProps} status={ToolCallStatus.Pending} />,
+        StreamingState.Idle,
+      );
+      expect(lastFrame()).toContain('o');
+    });
+
+    it('shows ? for Confirming status', () => {
+      const { lastFrame } = renderWithContext(
+        <ToolMessage {...baseProps} status={ToolCallStatus.Confirming} />,
+        StreamingState.Idle,
+      );
+      expect(lastFrame()).toContain('?');
+    });
+
+    it('shows - for Canceled status', () => {
+      const { lastFrame } = renderWithContext(
+        <ToolMessage {...baseProps} status={ToolCallStatus.Canceled} />,
+        StreamingState.Idle,
+      );
+      expect(lastFrame()).toContain('-');
+    });
+
+    it('shows x for Error status', () => {
+      const { lastFrame } = renderWithContext(
+        <ToolMessage {...baseProps} status={ToolCallStatus.Error} />,
+        StreamingState.Idle,
+      );
+      expect(lastFrame()).toContain('x');
+    });
+
+    it('shows paused spinner for Executing status when streamingState is Idle', () => {
+      const { lastFrame } = renderWithContext(
+        <ToolMessage {...baseProps} status={ToolCallStatus.Executing} />,
+        StreamingState.Idle,
+      );
+      expect(lastFrame()).toContain('⊷');
+      expect(lastFrame()).not.toContain('MockRespondingSpinner');
+      expect(lastFrame()).not.toContain('✔');
+    });
+
+    it('shows paused spinner for Executing status when streamingState is WaitingForConfirmation', () => {
+      const { lastFrame } = renderWithContext(
+        <ToolMessage {...baseProps} status={ToolCallStatus.Executing} />,
+        StreamingState.WaitingForConfirmation,
+      );
+      expect(lastFrame()).toContain('⊷');
+      expect(lastFrame()).not.toContain('MockRespondingSpinner');
+      expect(lastFrame()).not.toContain('✔');
+    });
+
+    it('shows MockRespondingSpinner for Executing status when streamingState is Responding', () => {
+      const { lastFrame } = renderWithContext(
+        <ToolMessage {...baseProps} status={ToolCallStatus.Executing} />,
+        StreamingState.Responding, // Simulate app still responding
+      );
+      expect(lastFrame()).toContain('MockRespondingSpinner');
+      expect(lastFrame()).not.toContain('✔');
+    });
+  });
+
+  it('renders DiffRenderer for diff results', () => {
+    const diffResult = {
+      fileDiff: '--- a/file.txt\n+++ b/file.txt\n@@ -1 +1 @@\n-old\n+new',
+      fileName: 'file.txt',
+      originalContent: 'old',
+      newContent: 'new',
+    };
+    const { lastFrame } = renderWithContext(
+      <ToolMessage {...baseProps} resultDisplay={diffResult} />,
+      StreamingState.Idle,
+    );
+    // Check that the output contains the MockDiff content as part of the whole message
+    expect(lastFrame()).toMatch(/MockDiff:--- a\/file\.txt/);
+  });
+
+  it('renders emphasis correctly', () => {
+    const { lastFrame: highEmphasisFrame } = renderWithContext(
+      <ToolMessage {...baseProps} emphasis="high" />,
+      StreamingState.Idle,
+    );
+    // Check for trailing indicator or specific color if applicable (Colors are not easily testable here)
+    expect(highEmphasisFrame()).toContain('←'); // Trailing indicator for high emphasis
+
+    const { lastFrame: lowEmphasisFrame } = renderWithContext(
+      <ToolMessage {...baseProps} emphasis="low" />,
+      StreamingState.Idle,
+    );
+    // For low emphasis, the name and description might be dimmed (check for dimColor if possible)
+    // This is harder to assert directly in text output without color checks.
+    // We can at least ensure it doesn't have the high emphasis indicator.
+    expect(lowEmphasisFrame()).not.toContain('←');
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/components/messages/ToolMessage.tsx

@@ -0,0 +1,296 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { Box, Text } from 'ink';
+import { IndividualToolCallDisplay, ToolCallStatus } from '../../types.js';
+import { DiffRenderer } from './DiffRenderer.js';
+import { Colors } from '../../colors.js';
+import { MarkdownDisplay } from '../../utils/MarkdownDisplay.js';
+import { GeminiRespondingSpinner } from '../GeminiRespondingSpinner.js';
+import { MaxSizedBox } from '../shared/MaxSizedBox.js';
+import { TodoDisplay } from '../TodoDisplay.js';
+import { TodoResultDisplay } from '@qwen-code/qwen-code-core';
+
+const STATIC_HEIGHT = 1;
+const RESERVED_LINE_COUNT = 5; // for tool name, status, padding etc.
+const STATUS_INDICATOR_WIDTH = 3;
+const MIN_LINES_SHOWN = 2; // show at least this many lines
+
+// Large threshold to ensure we don't cause performance issues for very large
+// outputs that will get truncated further MaxSizedBox anyway.
+const MAXIMUM_RESULT_DISPLAY_CHARACTERS = 1000000;
+export type TextEmphasis = 'high' | 'medium' | 'low';
+
+type DisplayRendererResult =
+  | { type: 'none' }
+  | { type: 'todo'; data: TodoResultDisplay }
+  | { type: 'string'; data: string }
+  | { type: 'diff'; data: { fileDiff: string; fileName: string } };
+
+/**
+ * Custom hook to determine the type of result display and return appropriate rendering info
+ */
+const useResultDisplayRenderer = (
+  resultDisplay: unknown,
+): DisplayRendererResult =>
+  React.useMemo(() => {
+    if (!resultDisplay) {
+      return { type: 'none' };
+    }
+
+    // Check for TodoResultDisplay
+    if (
+      typeof resultDisplay === 'object' &&
+      resultDisplay !== null &&
+      'type' in resultDisplay &&
+      resultDisplay.type === 'todo_list'
+    ) {
+      return {
+        type: 'todo',
+        data: resultDisplay as TodoResultDisplay,
+      };
+    }
+
+    // Check for FileDiff
+    if (
+      typeof resultDisplay === 'object' &&
+      resultDisplay !== null &&
+      'fileDiff' in resultDisplay
+    ) {
+      return {
+        type: 'diff',
+        data: resultDisplay as { fileDiff: string; fileName: string },
+      };
+    }
+
+    // Default to string
+    return {
+      type: 'string',
+      data: resultDisplay as string,
+    };
+  }, [resultDisplay]);
+
+/**
+ * Component to render todo list results
+ */
+const TodoResultRenderer: React.FC<{ data: TodoResultDisplay }> = ({
+  data,
+}) => <TodoDisplay todos={data.todos} />;
+
+/**
+ * Component to render string results (markdown or plain text)
+ */
+const StringResultRenderer: React.FC<{
+  data: string;
+  renderAsMarkdown: boolean;
+  availableHeight?: number;
+  childWidth: number;
+}> = ({ data, renderAsMarkdown, availableHeight, childWidth }) => {
+  let displayData = data;
+
+  // Truncate if too long
+  if (displayData.length > MAXIMUM_RESULT_DISPLAY_CHARACTERS) {
+    displayData = '...' + displayData.slice(-MAXIMUM_RESULT_DISPLAY_CHARACTERS);
+  }
+
+  if (renderAsMarkdown) {
+    return (
+      <Box flexDirection="column">
+        <MarkdownDisplay
+          text={displayData}
+          isPending={false}
+          availableTerminalHeight={availableHeight}
+          terminalWidth={childWidth}
+        />
+      </Box>
+    );
+  }
+
+  return (
+    <MaxSizedBox maxHeight={availableHeight} maxWidth={childWidth}>
+      <Box>
+        <Text wrap="wrap">{displayData}</Text>
+      </Box>
+    </MaxSizedBox>
+  );
+};
+
+/**
+ * Component to render diff results
+ */
+const DiffResultRenderer: React.FC<{
+  data: { fileDiff: string; fileName: string };
+  availableHeight?: number;
+  childWidth: number;
+}> = ({ data, availableHeight, childWidth }) => (
+  <DiffRenderer
+    diffContent={data.fileDiff}
+    filename={data.fileName}
+    availableTerminalHeight={availableHeight}
+    terminalWidth={childWidth}
+  />
+);
+
+export interface ToolMessageProps extends IndividualToolCallDisplay {
+  availableTerminalHeight?: number;
+  terminalWidth: number;
+  emphasis?: TextEmphasis;
+  renderOutputAsMarkdown?: boolean;
+}
+
+export const ToolMessage: React.FC<ToolMessageProps> = ({
+  name,
+  description,
+  resultDisplay,
+  status,
+  availableTerminalHeight,
+  terminalWidth,
+  emphasis = 'medium',
+  renderOutputAsMarkdown = true,
+}) => {
+  const availableHeight = availableTerminalHeight
+    ? Math.max(
+        availableTerminalHeight - STATIC_HEIGHT - RESERVED_LINE_COUNT,
+        MIN_LINES_SHOWN + 1, // enforce minimum lines shown
+      )
+    : undefined;
+
+  // Long tool call response in MarkdownDisplay doesn't respect availableTerminalHeight properly,
+  // we're forcing it to not render as markdown when the response is too long, it will fallback
+  // to render as plain text, which is contained within the terminal using MaxSizedBox
+  if (availableHeight) {
+    renderOutputAsMarkdown = false;
+  }
+
+  const childWidth = terminalWidth - 3; // account for padding.
+
+  // Use the custom hook to determine the display type
+  const displayRenderer = useResultDisplayRenderer(resultDisplay);
+
+  return (
+    <Box paddingX={1} paddingY={0} flexDirection="column">
+      <Box minHeight={1}>
+        <ToolStatusIndicator status={status} />
+        <ToolInfo
+          name={name}
+          status={status}
+          description={description}
+          emphasis={emphasis}
+        />
+        {emphasis === 'high' && <TrailingIndicator />}
+      </Box>
+      {displayRenderer.type !== 'none' && (
+        <Box paddingLeft={STATUS_INDICATOR_WIDTH} width="100%" marginTop={1}>
+          <Box flexDirection="column">
+            {displayRenderer.type === 'todo' && (
+              <TodoResultRenderer data={displayRenderer.data} />
+            )}
+            {displayRenderer.type === 'string' && (
+              <StringResultRenderer
+                data={displayRenderer.data}
+                renderAsMarkdown={renderOutputAsMarkdown}
+                availableHeight={availableHeight}
+                childWidth={childWidth}
+              />
+            )}
+            {displayRenderer.type === 'diff' && (
+              <DiffResultRenderer
+                data={displayRenderer.data}
+                availableHeight={availableHeight}
+                childWidth={childWidth}
+              />
+            )}
+          </Box>
+        </Box>
+      )}
+    </Box>
+  );
+};
+
+type ToolStatusIndicatorProps = {
+  status: ToolCallStatus;
+};
+
+const ToolStatusIndicator: React.FC<ToolStatusIndicatorProps> = ({
+  status,
+}) => (
+  <Box minWidth={STATUS_INDICATOR_WIDTH}>
+    {status === ToolCallStatus.Pending && (
+      <Text color={Colors.AccentGreen}>o</Text>
+    )}
+    {status === ToolCallStatus.Executing && (
+      <GeminiRespondingSpinner
+        spinnerType="toggle"
+        nonRespondingDisplay={'⊷'}
+      />
+    )}
+    {status === ToolCallStatus.Success && (
+      <Text color={Colors.AccentGreen}>✔</Text>
+    )}
+    {status === ToolCallStatus.Confirming && (
+      <Text color={Colors.AccentYellow}>?</Text>
+    )}
+    {status === ToolCallStatus.Canceled && (
+      <Text color={Colors.AccentYellow} bold>
+        -
+      </Text>
+    )}
+    {status === ToolCallStatus.Error && (
+      <Text color={Colors.AccentRed} bold>
+        x
+      </Text>
+    )}
+  </Box>
+);
+
+type ToolInfo = {
+  name: string;
+  description: string;
+  status: ToolCallStatus;
+  emphasis: TextEmphasis;
+};
+const ToolInfo: React.FC<ToolInfo> = ({
+  name,
+  description,
+  status,
+  emphasis,
+}) => {
+  const nameColor = React.useMemo<string>(() => {
+    switch (emphasis) {
+      case 'high':
+        return Colors.Foreground;
+      case 'medium':
+        return Colors.Foreground;
+      case 'low':
+        return Colors.Gray;
+      default: {
+        const exhaustiveCheck: never = emphasis;
+        return exhaustiveCheck;
+      }
+    }
+  }, [emphasis]);
+  return (
+    <Box>
+      <Text
+        wrap="truncate-end"
+        strikethrough={status === ToolCallStatus.Canceled}
+      >
+        <Text color={nameColor} bold>
+          {name}
+        </Text>{' '}
+        <Text color={Colors.Gray}>{description}</Text>
+      </Text>
+    </Box>
+  );
+};
+
+const TrailingIndicator: React.FC = () => (
+  <Text color={Colors.Foreground} wrap="truncate">
+    {' '}
+    ←
+  </Text>
+);

projects/ui/qwen-code/packages/cli/src/ui/components/messages/UserMessage.tsx

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { Text, Box } from 'ink';
+import { Colors } from '../../colors.js';
+
+interface UserMessageProps {
+  text: string;
+}
+
+export const UserMessage: React.FC<UserMessageProps> = ({ text }) => {
+  const prefix = '> ';
+  const prefixWidth = prefix.length;
+  const isSlashCommand = text.startsWith('/');
+
+  const textColor = isSlashCommand ? Colors.AccentPurple : Colors.Gray;
+  const borderColor = isSlashCommand ? Colors.AccentPurple : Colors.Gray;
+
+  return (
+    <Box
+      borderStyle="round"
+      borderColor={borderColor}
+      flexDirection="row"
+      paddingX={2}
+      paddingY={0}
+      marginY={1}
+      alignSelf="flex-start"
+    >
+      <Box width={prefixWidth}>
+        <Text color={textColor}>{prefix}</Text>
+      </Box>
+      <Box flexGrow={1}>
+        <Text wrap="wrap" color={textColor}>
+          {text}
+        </Text>
+      </Box>
+    </Box>
+  );
+};

projects/ui/qwen-code/packages/cli/src/ui/components/messages/UserShellMessage.tsx

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { Box, Text } from 'ink';
+import { Colors } from '../../colors.js';
+
+interface UserShellMessageProps {
+  text: string;
+}
+
+export const UserShellMessage: React.FC<UserShellMessageProps> = ({ text }) => {
+  // Remove leading '!' if present, as App.tsx adds it for the processor.
+  const commandToDisplay = text.startsWith('!') ? text.substring(1) : text;
+
+  return (
+    <Box>
+      <Text color={Colors.AccentCyan}>$ </Text>
+      <Text>{commandToDisplay}</Text>
+    </Box>
+  );
+};

projects/ui/qwen-code/packages/cli/src/ui/components/shared/MaxSizedBox.test.tsx

@@ -0,0 +1,425 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { render } from 'ink-testing-library';
+import { OverflowProvider } from '../../contexts/OverflowContext.js';
+import { MaxSizedBox, setMaxSizedBoxDebugging } from './MaxSizedBox.js';
+import { Box, Text } from 'ink';
+import { describe, it, expect } from 'vitest';
+
+describe('<MaxSizedBox />', () => {
+  // Make sure MaxSizedBox logs errors on invalid configurations.
+  // This is useful for debugging issues with the component.
+  // It should be set to false in production for performance and to avoid
+  // cluttering the console if there are ignorable issues.
+  setMaxSizedBoxDebugging(true);
+
+  it('renders children without truncation when they fit', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={80} maxHeight={10}>
+          <Box>
+            <Text>Hello, World!</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+    expect(lastFrame()).equals('Hello, World!');
+  });
+
+  it('hides lines when content exceeds maxHeight', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={80} maxHeight={2}>
+          <Box>
+            <Text>Line 1</Text>
+          </Box>
+          <Box>
+            <Text>Line 2</Text>
+          </Box>
+          <Box>
+            <Text>Line 3</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+    expect(lastFrame()).equals(`... first 2 lines hidden ...
+Line 3`);
+  });
+
+  it('hides lines at the end when content exceeds maxHeight and overflowDirection is bottom', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={80} maxHeight={2} overflowDirection="bottom">
+          <Box>
+            <Text>Line 1</Text>
+          </Box>
+          <Box>
+            <Text>Line 2</Text>
+          </Box>
+          <Box>
+            <Text>Line 3</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+    expect(lastFrame()).equals(`Line 1
+... last 2 lines hidden ...`);
+  });
+
+  it('wraps text that exceeds maxWidth', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={10} maxHeight={5}>
+          <Box>
+            <Text wrap="wrap">This is a long line of text</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+
+    expect(lastFrame()).equals(`This is a
+long line
+of text`);
+  });
+
+  it('handles mixed wrapping and non-wrapping segments', () => {
+    const multilineText = `This part will wrap around.
+And has a line break.
+  Leading spaces preserved.`;
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={20} maxHeight={20}>
+          <Box>
+            <Text>Example</Text>
+          </Box>
+          <Box>
+            <Text>No Wrap: </Text>
+            <Text wrap="wrap">{multilineText}</Text>
+          </Box>
+          <Box>
+            <Text>Longer No Wrap: </Text>
+            <Text wrap="wrap">This part will wrap around.</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+
+    expect(lastFrame()).equals(
+      `Example
+No Wrap: This part
+         will wrap
+         around.
+         And has a
+         line break.
+           Leading
+         spaces
+         preserved.
+Longer No Wrap: This
+                part
+                will
+                wrap
+                arou
+                nd.`,
+    );
+  });
+
+  it('handles words longer than maxWidth by splitting them', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={5} maxHeight={5}>
+          <Box>
+            <Text wrap="wrap">Supercalifragilisticexpialidocious</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+
+    expect(lastFrame()).equals(`... …
+istic
+expia
+lidoc
+ious`);
+  });
+
+  it('does not truncate when maxHeight is undefined', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={80} maxHeight={undefined}>
+          <Box>
+            <Text>Line 1</Text>
+          </Box>
+          <Box>
+            <Text>Line 2</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+    expect(lastFrame()).equals(`Line 1
+Line 2`);
+  });
+
+  it('shows plural "lines" when more than one line is hidden', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={80} maxHeight={2}>
+          <Box>
+            <Text>Line 1</Text>
+          </Box>
+          <Box>
+            <Text>Line 2</Text>
+          </Box>
+          <Box>
+            <Text>Line 3</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+    expect(lastFrame()).equals(`... first 2 lines hidden ...
+Line 3`);
+  });
+
+  it('shows plural "lines" when more than one line is hidden and overflowDirection is bottom', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={80} maxHeight={2} overflowDirection="bottom">
+          <Box>
+            <Text>Line 1</Text>
+          </Box>
+          <Box>
+            <Text>Line 2</Text>
+          </Box>
+          <Box>
+            <Text>Line 3</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+    expect(lastFrame()).equals(`Line 1
+... last 2 lines hidden ...`);
+  });
+
+  it('renders an empty box for empty children', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={80} maxHeight={10}></MaxSizedBox>
+      </OverflowProvider>,
+    );
+    // Expect an empty string or a box with nothing in it.
+    // Ink renders an empty box as an empty string.
+    expect(lastFrame()).equals('');
+  });
+
+  it('wraps text with multi-byte unicode characters correctly', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={5} maxHeight={5}>
+          <Box>
+            <Text wrap="wrap">你好世界</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+
+    // "你好" has a visual width of 4. "世界" has a visual width of 4.
+    // With maxWidth=5, it should wrap after the second character.
+    expect(lastFrame()).equals(`你好
+世界`);
+  });
+
+  it('wraps text with multi-byte emoji characters correctly', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={5} maxHeight={5}>
+          <Box>
+            <Text wrap="wrap">🐶🐶🐶🐶🐶</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+
+    // Each "🐶" has a visual width of 2.
+    // With maxWidth=5, it should wrap every 2 emojis.
+    expect(lastFrame()).equals(`🐶🐶
+🐶🐶
+🐶`);
+  });
+
+  it('falls back to an ellipsis when width is extremely small', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={2} maxHeight={2}>
+          <Box>
+            <Text>No</Text>
+            <Text wrap="wrap">wrap</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+
+    expect(lastFrame()).equals('N…');
+  });
+
+  it('truncates long non-wrapping text with ellipsis', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={3} maxHeight={2}>
+          <Box>
+            <Text>ABCDE</Text>
+            <Text wrap="wrap">wrap</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+
+    expect(lastFrame()).equals('AB…');
+  });
+
+  it('truncates non-wrapping text containing line breaks', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={3} maxHeight={2}>
+          <Box>
+            <Text>{'A\nBCDE'}</Text>
+            <Text wrap="wrap">wrap</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+
+    expect(lastFrame()).equals(`A\n…`);
+  });
+
+  it('truncates emoji characters correctly with ellipsis', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={3} maxHeight={2}>
+          <Box>
+            <Text>🐶🐶🐶</Text>
+            <Text wrap="wrap">wrap</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+
+    expect(lastFrame()).equals(`🐶…`);
+  });
+
+  it('shows ellipsis for multiple rows with long non-wrapping text', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={3} maxHeight={3}>
+          <Box>
+            <Text>AAA</Text>
+            <Text wrap="wrap">first</Text>
+          </Box>
+          <Box>
+            <Text>BBB</Text>
+            <Text wrap="wrap">second</Text>
+          </Box>
+          <Box>
+            <Text>CCC</Text>
+            <Text wrap="wrap">third</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+
+    expect(lastFrame()).equals(`AA…\nBB…\nCC…`);
+  });
+
+  it('accounts for additionalHiddenLinesCount', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={80} maxHeight={2} additionalHiddenLinesCount={5}>
+          <Box>
+            <Text>Line 1</Text>
+          </Box>
+          <Box>
+            <Text>Line 2</Text>
+          </Box>
+          <Box>
+            <Text>Line 3</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+    // 1 line is hidden by overflow, 5 are additionally hidden.
+    expect(lastFrame()).equals(`... first 7 lines hidden ...
+Line 3`);
+  });
+
+  it('handles React.Fragment as a child', () => {
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={80} maxHeight={10}>
+          <>
+            <Box>
+              <Text>Line 1 from Fragment</Text>
+            </Box>
+            <Box>
+              <Text>Line 2 from Fragment</Text>
+            </Box>
+          </>
+          <Box>
+            <Text>Line 3 direct child</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+    expect(lastFrame()).equals(`Line 1 from Fragment
+Line 2 from Fragment
+Line 3 direct child`);
+  });
+
+  it('clips a long single text child from the top', () => {
+    const THIRTY_LINES = Array.from(
+      { length: 30 },
+      (_, i) => `Line ${i + 1}`,
+    ).join('\n');
+
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={80} maxHeight={10}>
+          <Box>
+            <Text>{THIRTY_LINES}</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+
+    const expected = [
+      '... first 21 lines hidden ...',
+      ...Array.from({ length: 9 }, (_, i) => `Line ${22 + i}`),
+    ].join('\n');
+
+    expect(lastFrame()).equals(expected);
+  });
+
+  it('clips a long single text child from the bottom', () => {
+    const THIRTY_LINES = Array.from(
+      { length: 30 },
+      (_, i) => `Line ${i + 1}`,
+    ).join('\n');
+
+    const { lastFrame } = render(
+      <OverflowProvider>
+        <MaxSizedBox maxWidth={80} maxHeight={10} overflowDirection="bottom">
+          <Box>
+            <Text>{THIRTY_LINES}</Text>
+          </Box>
+        </MaxSizedBox>
+      </OverflowProvider>,
+    );
+
+    const expected = [
+      ...Array.from({ length: 9 }, (_, i) => `Line ${i + 1}`),
+      '... last 21 lines hidden ...',
+    ].join('\n');
+
+    expect(lastFrame()).equals(expected);
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/components/shared/MaxSizedBox.tsx

@@ -0,0 +1,624 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React, { Fragment, useEffect, useId } from 'react';
+import { Box, Text } from 'ink';
+import stringWidth from 'string-width';
+import { Colors } from '../../colors.js';
+import { toCodePoints } from '../../utils/textUtils.js';
+import { useOverflowActions } from '../../contexts/OverflowContext.js';
+
+let enableDebugLog = false;
+
+/**
+ * Minimum height for the MaxSizedBox component.
+ * This ensures there is room for at least one line of content as well as the
+ * message that content was truncated.
+ */
+export const MINIMUM_MAX_HEIGHT = 2;
+
+export function setMaxSizedBoxDebugging(value: boolean) {
+  enableDebugLog = value;
+}
+
+function debugReportError(message: string, element: React.ReactNode) {
+  if (!enableDebugLog) return;
+
+  if (!React.isValidElement(element)) {
+    console.error(
+      message,
+      `Invalid element: '${String(element)}' typeof=${typeof element}`,
+    );
+    return;
+  }
+
+  let sourceMessage = '<Unknown file>';
+  try {
+    const elementWithSource = element as {
+      _source?: { fileName?: string; lineNumber?: number };
+    };
+    const fileName = elementWithSource._source?.fileName;
+    const lineNumber = elementWithSource._source?.lineNumber;
+    sourceMessage = fileName ? `${fileName}:${lineNumber}` : '<Unknown file>';
+  } catch (error) {
+    console.error('Error while trying to get file name:', error);
+  }
+
+  console.error(message, `${String(element.type)}. Source: ${sourceMessage}`);
+}
+interface MaxSizedBoxProps {
+  children?: React.ReactNode;
+  maxWidth?: number;
+  maxHeight: number | undefined;
+  overflowDirection?: 'top' | 'bottom';
+  additionalHiddenLinesCount?: number;
+}
+
+/**
+ * A React component that constrains the size of its children and provides
+ * content-aware truncation when the content exceeds the specified `maxHeight`.
+ *
+ * `MaxSizedBox` requires a specific structure for its children to correctly
+ * measure and render the content:
+ *
+ * 1.  **Direct children must be `<Box>` elements.** Each `<Box>` represents a
+ *     single row of content.
+ * 2.  **Row `<Box>` elements must contain only `<Text>` elements.** These
+ *     `<Text>` elements can be nested and there are no restrictions to Text
+ *     element styling other than that non-wrapping text elements must be
+ *     before wrapping text elements.
+ *
+ * **Constraints:**
+ * - **Box Properties:** Custom properties on the child `<Box>` elements are
+ *   ignored. In debug mode, runtime checks will report errors for any
+ *   unsupported properties.
+ * - **Text Wrapping:** Within a single row, `<Text>` elements with no wrapping
+ *   (e.g., headers, labels) must appear before any `<Text>` elements that wrap.
+ * - **Element Types:** Runtime checks will warn if unsupported element types
+ *   are used as children.
+ *
+ * @example
+ * <MaxSizedBox maxWidth={80} maxHeight={10}>
+ *   <Box>
+ *     <Text>This is the first line.</Text>
+ *   </Box>
+ *   <Box>
+ *     <Text color="cyan" wrap="truncate">Non-wrapping Header: </Text>
+ *     <Text>This is the rest of the line which will wrap if it's too long.</Text>
+ *   </Box>
+ *   <Box>
+ *     <Text>
+ *       Line 3 with <Text color="yellow">nested styled text</Text> inside of it.
+ *     </Text>
+ *   </Box>
+ * </MaxSizedBox>
+ */
+export const MaxSizedBox: React.FC<MaxSizedBoxProps> = ({
+  children,
+  maxWidth,
+  maxHeight,
+  overflowDirection = 'top',
+  additionalHiddenLinesCount = 0,
+}) => {
+  const id = useId();
+  const { addOverflowingId, removeOverflowingId } = useOverflowActions() || {};
+
+  const laidOutStyledText: StyledText[][] = [];
+  const targetMaxHeight = Math.max(
+    Math.round(maxHeight ?? Number.MAX_SAFE_INTEGER),
+    MINIMUM_MAX_HEIGHT,
+  );
+
+  if (maxWidth === undefined) {
+    throw new Error('maxWidth must be defined when maxHeight is set.');
+  }
+  function visitRows(element: React.ReactNode) {
+    if (!React.isValidElement<{ children?: React.ReactNode }>(element)) {
+      return;
+    }
+
+    if (element.type === Fragment) {
+      React.Children.forEach(element.props.children, visitRows);
+      return;
+    }
+
+    if (element.type === Box) {
+      layoutInkElementAsStyledText(element, maxWidth!, laidOutStyledText);
+      return;
+    }
+
+    debugReportError('MaxSizedBox children must be <Box> elements', element);
+  }
+
+  React.Children.forEach(children, visitRows);
+
+  const contentWillOverflow =
+    (targetMaxHeight !== undefined &&
+      laidOutStyledText.length > targetMaxHeight) ||
+    additionalHiddenLinesCount > 0;
+  const visibleContentHeight =
+    contentWillOverflow && targetMaxHeight !== undefined
+      ? targetMaxHeight - 1
+      : targetMaxHeight;
+
+  const hiddenLinesCount =
+    visibleContentHeight !== undefined
+      ? Math.max(0, laidOutStyledText.length - visibleContentHeight)
+      : 0;
+  const totalHiddenLines = hiddenLinesCount + additionalHiddenLinesCount;
+
+  useEffect(() => {
+    if (totalHiddenLines > 0) {
+      addOverflowingId?.(id);
+    } else {
+      removeOverflowingId?.(id);
+    }
+
+    return () => {
+      removeOverflowingId?.(id);
+    };
+  }, [id, totalHiddenLines, addOverflowingId, removeOverflowingId]);
+
+  const visibleStyledText =
+    hiddenLinesCount > 0
+      ? overflowDirection === 'top'
+        ? laidOutStyledText.slice(hiddenLinesCount, laidOutStyledText.length)
+        : laidOutStyledText.slice(0, visibleContentHeight)
+      : laidOutStyledText;
+
+  const visibleLines = visibleStyledText.map((line, index) => (
+    <Box key={index}>
+      {line.length > 0 ? (
+        line.map((segment, segIndex) => (
+          <Text key={segIndex} {...segment.props}>
+            {segment.text}
+          </Text>
+        ))
+      ) : (
+        <Text> </Text>
+      )}
+    </Box>
+  ));
+
+  return (
+    <Box flexDirection="column" width={maxWidth} flexShrink={0}>
+      {totalHiddenLines > 0 && overflowDirection === 'top' && (
+        <Text color={Colors.Gray} wrap="truncate">
+          ... first {totalHiddenLines} line{totalHiddenLines === 1 ? '' : 's'}{' '}
+          hidden ...
+        </Text>
+      )}
+      {visibleLines}
+      {totalHiddenLines > 0 && overflowDirection === 'bottom' && (
+        <Text color={Colors.Gray} wrap="truncate">
+          ... last {totalHiddenLines} line{totalHiddenLines === 1 ? '' : 's'}{' '}
+          hidden ...
+        </Text>
+      )}
+    </Box>
+  );
+};
+
+// Define a type for styled text segments
+interface StyledText {
+  text: string;
+  props: Record<string, unknown>;
+}
+
+/**
+ * Single row of content within the MaxSizedBox.
+ *
+ * A row can contain segments that are not wrapped, followed by segments that
+ * are. This is a minimal implementation that only supports the functionality
+ * needed today.
+ */
+interface Row {
+  noWrapSegments: StyledText[];
+  segments: StyledText[];
+}
+
+/**
+ * Flattens the child elements of MaxSizedBox into an array of `Row` objects.
+ *
+ * This function expects a specific child structure to function correctly:
+ * 1. The top-level child of `MaxSizedBox` should be a single `<Box>`. This
+ *    outer box is primarily for structure and is not directly rendered.
+ * 2. Inside the outer `<Box>`, there should be one or more children. Each of
+ *    these children must be a `<Box>` that represents a row.
+ * 3. Inside each "row" `<Box>`, the children must be `<Text>` components.
+ *
+ * The structure should look like this:
+ * <MaxSizedBox>
+ *   <Box> // Row 1
+ *     <Text>...</Text>
+ *     <Text>...</Text>
+ *   </Box>
+ *   <Box> // Row 2
+ *     <Text>...</Text>
+ *   </Box>
+ * </MaxSizedBox>
+ *
+ * It is an error for a <Text> child without wrapping to appear after a
+ * <Text> child with wrapping within the same row Box.
+ *
+ * @param element The React node to flatten.
+ * @returns An array of `Row` objects.
+ */
+function visitBoxRow(element: React.ReactNode): Row {
+  if (
+    !React.isValidElement<{ children?: React.ReactNode }>(element) ||
+    element.type !== Box
+  ) {
+    debugReportError(
+      `All children of MaxSizedBox must be <Box> elements`,
+      element,
+    );
+    return {
+      noWrapSegments: [{ text: '<ERROR>', props: {} }],
+      segments: [],
+    };
+  }
+
+  if (enableDebugLog) {
+    const boxProps = element.props as {
+      children?: React.ReactNode | undefined;
+      readonly flexDirection?:
+        | 'row'
+        | 'column'
+        | 'row-reverse'
+        | 'column-reverse'
+        | undefined;
+    };
+    // Ensure the Box has no props other than the default ones and key.
+    let maxExpectedProps = 4;
+    if (boxProps.children !== undefined) {
+      // Allow the key prop, which is automatically added by React.
+      maxExpectedProps += 1;
+    }
+    if (
+      boxProps.flexDirection !== undefined &&
+      boxProps.flexDirection !== 'row'
+    ) {
+      debugReportError(
+        'MaxSizedBox children must have flexDirection="row".',
+        element,
+      );
+    }
+    if (Object.keys(boxProps).length > maxExpectedProps) {
+      debugReportError(
+        `Boxes inside MaxSizedBox must not have additional props. ${Object.keys(
+          boxProps,
+        ).join(', ')}`,
+        element,
+      );
+    }
+  }
+
+  const row: Row = {
+    noWrapSegments: [],
+    segments: [],
+  };
+
+  let hasSeenWrapped = false;
+
+  function visitRowChild(
+    element: React.ReactNode,
+    parentProps: Record<string, unknown> | undefined,
+  ) {
+    if (element === null) {
+      return;
+    }
+    if (typeof element === 'string' || typeof element === 'number') {
+      const text = String(element);
+      // Ignore empty strings as they don't need to be rendered.
+      if (!text) {
+        return;
+      }
+
+      const segment: StyledText = { text, props: parentProps ?? {} };
+
+      // Check the 'wrap' property from the merged props to decide the segment type.
+      if (parentProps === undefined || parentProps['wrap'] === 'wrap') {
+        hasSeenWrapped = true;
+        row.segments.push(segment);
+      } else {
+        if (!hasSeenWrapped) {
+          row.noWrapSegments.push(segment);
+        } else {
+          // put in the wrapped segment as the row is already stuck in wrapped mode.
+          row.segments.push(segment);
+          debugReportError(
+            'Text elements without wrapping cannot appear after elements with wrapping in the same row.',
+            element,
+          );
+        }
+      }
+      return;
+    }
+
+    if (!React.isValidElement<{ children?: React.ReactNode }>(element)) {
+      debugReportError('Invalid element.', element);
+      return;
+    }
+
+    if (element.type === Fragment) {
+      React.Children.forEach(element.props.children, (child) =>
+        visitRowChild(child, parentProps),
+      );
+      return;
+    }
+
+    if (element.type !== Text) {
+      debugReportError(
+        'Children of a row Box must be <Text> elements.',
+        element,
+      );
+      return;
+    }
+
+    // Merge props from parent <Text> elements. Child props take precedence.
+    const { children, ...currentProps } = element.props;
+    const mergedProps =
+      parentProps === undefined
+        ? currentProps
+        : { ...parentProps, ...currentProps };
+    React.Children.forEach(children, (child) =>
+      visitRowChild(child, mergedProps),
+    );
+  }
+
+  React.Children.forEach(element.props.children, (child) =>
+    visitRowChild(child, undefined),
+  );
+
+  return row;
+}
+
+function layoutInkElementAsStyledText(
+  element: React.ReactElement,
+  maxWidth: number,
+  output: StyledText[][],
+) {
+  const row = visitBoxRow(element);
+  if (row.segments.length === 0 && row.noWrapSegments.length === 0) {
+    // Return a single empty line if there are no segments to display
+    output.push([]);
+    return;
+  }
+
+  const lines: StyledText[][] = [];
+  const nonWrappingContent: StyledText[] = [];
+  let noWrappingWidth = 0;
+
+  // First, lay out the non-wrapping segments
+  row.noWrapSegments.forEach((segment) => {
+    nonWrappingContent.push(segment);
+    noWrappingWidth += stringWidth(segment.text);
+  });
+
+  if (row.segments.length === 0) {
+    // This is a bit of a special case when there are no segments that allow
+    // wrapping. It would be ideal to unify.
+    const lines: StyledText[][] = [];
+    let currentLine: StyledText[] = [];
+    nonWrappingContent.forEach((segment) => {
+      const textLines = segment.text.split('\n');
+      textLines.forEach((text, index) => {
+        if (index > 0) {
+          lines.push(currentLine);
+          currentLine = [];
+        }
+        if (text) {
+          currentLine.push({ text, props: segment.props });
+        }
+      });
+    });
+    if (
+      currentLine.length > 0 ||
+      (nonWrappingContent.length > 0 &&
+        nonWrappingContent[nonWrappingContent.length - 1].text.endsWith('\n'))
+    ) {
+      lines.push(currentLine);
+    }
+    for (const line of lines) {
+      output.push(line);
+    }
+    return;
+  }
+
+  const availableWidth = maxWidth - noWrappingWidth;
+
+  if (availableWidth < 1) {
+    // No room to render the wrapping segments. Truncate the non-wrapping
+    // content and append an ellipsis so the line always fits within maxWidth.
+
+    // Handle line breaks in non-wrapping content when truncating
+    const lines: StyledText[][] = [];
+    let currentLine: StyledText[] = [];
+    let currentLineWidth = 0;
+
+    for (const segment of nonWrappingContent) {
+      const textLines = segment.text.split('\n');
+      textLines.forEach((text, index) => {
+        if (index > 0) {
+          // New line encountered, finish current line and start new one
+          lines.push(currentLine);
+          currentLine = [];
+          currentLineWidth = 0;
+        }
+
+        if (text) {
+          const textWidth = stringWidth(text);
+
+          // When there's no room for wrapping content, be very conservative
+          // For lines after the first line break, show only ellipsis if the text would be truncated
+          if (index > 0 && textWidth > 0) {
+            // This is content after a line break - just show ellipsis to indicate truncation
+            currentLine.push({ text: '…', props: {} });
+            currentLineWidth = stringWidth('…');
+          } else {
+            // This is the first line or a continuation, try to fit what we can
+            const maxContentWidth = Math.max(0, maxWidth - stringWidth('…'));
+
+            if (textWidth <= maxContentWidth && currentLineWidth === 0) {
+              // Text fits completely on this line
+              currentLine.push({ text, props: segment.props });
+              currentLineWidth += textWidth;
+            } else {
+              // Text needs truncation
+              const codePoints = toCodePoints(text);
+              let truncatedWidth = currentLineWidth;
+              let sliceEndIndex = 0;
+
+              for (const char of codePoints) {
+                const charWidth = stringWidth(char);
+                if (truncatedWidth + charWidth > maxContentWidth) {
+                  break;
+                }
+                truncatedWidth += charWidth;
+                sliceEndIndex++;
+              }
+
+              const slice = codePoints.slice(0, sliceEndIndex).join('');
+              if (slice) {
+                currentLine.push({ text: slice, props: segment.props });
+              }
+              currentLine.push({ text: '…', props: {} });
+              currentLineWidth = truncatedWidth + stringWidth('…');
+            }
+          }
+        }
+      });
+    }
+
+    // Add the last line if it has content or if the last segment ended with \n
+    if (
+      currentLine.length > 0 ||
+      (nonWrappingContent.length > 0 &&
+        nonWrappingContent[nonWrappingContent.length - 1].text.endsWith('\n'))
+    ) {
+      lines.push(currentLine);
+    }
+
+    // If we don't have any lines yet, add an ellipsis line
+    if (lines.length === 0) {
+      lines.push([{ text: '…', props: {} }]);
+    }
+
+    for (const line of lines) {
+      output.push(line);
+    }
+    return;
+  }
+
+  // Now, lay out the wrapping segments
+  let wrappingPart: StyledText[] = [];
+  let wrappingPartWidth = 0;
+
+  function addWrappingPartToLines() {
+    if (lines.length === 0) {
+      lines.push([...nonWrappingContent, ...wrappingPart]);
+    } else {
+      if (noWrappingWidth > 0) {
+        lines.push([
+          ...[{ text: ' '.repeat(noWrappingWidth), props: {} }],
+          ...wrappingPart,
+        ]);
+      } else {
+        lines.push(wrappingPart);
+      }
+    }
+    wrappingPart = [];
+    wrappingPartWidth = 0;
+  }
+
+  function addToWrappingPart(text: string, props: Record<string, unknown>) {
+    if (
+      wrappingPart.length > 0 &&
+      wrappingPart[wrappingPart.length - 1].props === props
+    ) {
+      wrappingPart[wrappingPart.length - 1].text += text;
+    } else {
+      wrappingPart.push({ text, props });
+    }
+  }
+
+  row.segments.forEach((segment) => {
+    const linesFromSegment = segment.text.split('\n');
+
+    linesFromSegment.forEach((lineText, lineIndex) => {
+      if (lineIndex > 0) {
+        addWrappingPartToLines();
+      }
+
+      const words = lineText.split(/(\s+)/); // Split by whitespace
+
+      words.forEach((word) => {
+        if (!word) return;
+        const wordWidth = stringWidth(word);
+
+        if (
+          wrappingPartWidth + wordWidth > availableWidth &&
+          wrappingPartWidth > 0
+        ) {
+          addWrappingPartToLines();
+          if (/^\s+$/.test(word)) {
+            return;
+          }
+        }
+
+        if (wordWidth > availableWidth) {
+          // Word is too long, needs to be split across lines
+          const wordAsCodePoints = toCodePoints(word);
+          let remainingWordAsCodePoints = wordAsCodePoints;
+          while (remainingWordAsCodePoints.length > 0) {
+            let splitIndex = 0;
+            let currentSplitWidth = 0;
+            for (const char of remainingWordAsCodePoints) {
+              const charWidth = stringWidth(char);
+              if (
+                wrappingPartWidth + currentSplitWidth + charWidth >
+                availableWidth
+              ) {
+                break;
+              }
+              currentSplitWidth += charWidth;
+              splitIndex++;
+            }
+
+            if (splitIndex > 0) {
+              const part = remainingWordAsCodePoints
+                .slice(0, splitIndex)
+                .join('');
+              addToWrappingPart(part, segment.props);
+              wrappingPartWidth += stringWidth(part);
+              remainingWordAsCodePoints =
+                remainingWordAsCodePoints.slice(splitIndex);
+            }
+
+            if (remainingWordAsCodePoints.length > 0) {
+              addWrappingPartToLines();
+            }
+          }
+        } else {
+          addToWrappingPart(word, segment.props);
+          wrappingPartWidth += wordWidth;
+        }
+      });
+    });
+    // Split omits a trailing newline, so we need to handle it here
+    if (segment.text.endsWith('\n')) {
+      addWrappingPartToLines();
+    }
+  });
+
+  if (wrappingPart.length > 0) {
+    addWrappingPartToLines();
+  }
+  for (const line of lines) {
+    output.push(line);
+  }
+}

projects/ui/qwen-code/packages/cli/src/ui/components/shared/RadioButtonSelect.test.tsx

@@ -0,0 +1,181 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { renderWithProviders } from '../../../test-utils/render.js';
+import { waitFor } from '@testing-library/react';
+import {
+  RadioButtonSelect,
+  type RadioSelectItem,
+} from './RadioButtonSelect.js';
+import { describe, it, expect, vi } from 'vitest';
+
+const ITEMS: Array<RadioSelectItem<string>> = [
+  { label: 'Option 1', value: 'one' },
+  { label: 'Option 2', value: 'two' },
+  { label: 'Option 3', value: 'three', disabled: true },
+];
+
+describe('<RadioButtonSelect />', () => {
+  it('renders a list of items and matches snapshot', () => {
+    const { lastFrame } = renderWithProviders(
+      <RadioButtonSelect items={ITEMS} onSelect={() => {}} isFocused={true} />,
+    );
+    expect(lastFrame()).toMatchSnapshot();
+  });
+
+  it('renders with the second item selected and matches snapshot', () => {
+    const { lastFrame } = renderWithProviders(
+      <RadioButtonSelect items={ITEMS} initialIndex={1} onSelect={() => {}} />,
+    );
+    expect(lastFrame()).toMatchSnapshot();
+  });
+
+  it('renders with numbers hidden and matches snapshot', () => {
+    const { lastFrame } = renderWithProviders(
+      <RadioButtonSelect
+        items={ITEMS}
+        onSelect={() => {}}
+        showNumbers={false}
+      />,
+    );
+    expect(lastFrame()).toMatchSnapshot();
+  });
+
+  it('renders with scroll arrows and matches snapshot', () => {
+    const manyItems = Array.from({ length: 20 }, (_, i) => ({
+      label: `Item ${i + 1}`,
+      value: `item-${i + 1}`,
+    }));
+    const { lastFrame } = renderWithProviders(
+      <RadioButtonSelect
+        items={manyItems}
+        onSelect={() => {}}
+        showScrollArrows={true}
+        maxItemsToShow={5}
+      />,
+    );
+    expect(lastFrame()).toMatchSnapshot();
+  });
+
+  it('renders with special theme display and matches snapshot', () => {
+    const themeItems: Array<RadioSelectItem<string>> = [
+      {
+        label: 'Theme A (Light)',
+        value: 'a-light',
+        themeNameDisplay: 'Theme A',
+        themeTypeDisplay: '(Light)',
+      },
+      {
+        label: 'Theme B (Dark)',
+        value: 'b-dark',
+        themeNameDisplay: 'Theme B',
+        themeTypeDisplay: '(Dark)',
+      },
+    ];
+    const { lastFrame } = renderWithProviders(
+      <RadioButtonSelect items={themeItems} onSelect={() => {}} />,
+    );
+    expect(lastFrame()).toMatchSnapshot();
+  });
+
+  it('renders a list with >10 items and matches snapshot', () => {
+    const manyItems = Array.from({ length: 12 }, (_, i) => ({
+      label: `Item ${i + 1}`,
+      value: `item-${i + 1}`,
+    }));
+    const { lastFrame } = renderWithProviders(
+      <RadioButtonSelect items={manyItems} onSelect={() => {}} />,
+    );
+    expect(lastFrame()).toMatchSnapshot();
+  });
+
+  it('renders nothing when no items are provided', () => {
+    const { lastFrame } = renderWithProviders(
+      <RadioButtonSelect items={[]} onSelect={() => {}} isFocused={true} />,
+    );
+    expect(lastFrame()).toBe('');
+  });
+});
+
+describe('keyboard navigation', () => {
+  it('should call onSelect when "enter" is pressed', () => {
+    const onSelect = vi.fn();
+    const { stdin } = renderWithProviders(
+      <RadioButtonSelect items={ITEMS} onSelect={onSelect} />,
+    );
+
+    stdin.write('\r');
+
+    expect(onSelect).toHaveBeenCalledWith('one');
+  });
+
+  describe('when isFocused is false', () => {
+    it('should not handle any keyboard input', () => {
+      const onSelect = vi.fn();
+      const { stdin } = renderWithProviders(
+        <RadioButtonSelect
+          items={ITEMS}
+          onSelect={onSelect}
+          isFocused={false}
+        />,
+      );
+
+      stdin.write('\u001B[B'); // Down arrow
+      stdin.write('\u001B[A'); // Up arrow
+      stdin.write('\r'); // Enter
+
+      expect(onSelect).not.toHaveBeenCalled();
+    });
+  });
+
+  describe.each([
+    { description: 'when isFocused is true', isFocused: true },
+    { description: 'when isFocused is omitted', isFocused: undefined },
+  ])('$description', ({ isFocused }) => {
+    it('should navigate down with arrow key and select with enter', async () => {
+      const onSelect = vi.fn();
+      const { stdin, lastFrame } = renderWithProviders(
+        <RadioButtonSelect
+          items={ITEMS}
+          onSelect={onSelect}
+          isFocused={isFocused}
+        />,
+      );
+
+      stdin.write('\u001B[B'); // Down arrow
+
+      await waitFor(() => {
+        expect(lastFrame()).toContain('● 2. Option 2');
+      });
+
+      stdin.write('\r');
+
+      expect(onSelect).toHaveBeenCalledWith('two');
+    });
+
+    it('should navigate up with arrow key and select with enter', async () => {
+      const onSelect = vi.fn();
+      const { stdin, lastFrame } = renderWithProviders(
+        <RadioButtonSelect
+          items={ITEMS}
+          onSelect={onSelect}
+          initialIndex={1}
+          isFocused={isFocused}
+        />,
+      );
+
+      stdin.write('\u001B[A'); // Up arrow
+
+      await waitFor(() => {
+        expect(lastFrame()).toContain('● 1. Option 1');
+      });
+
+      stdin.write('\r');
+
+      expect(onSelect).toHaveBeenCalledWith('one');
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/components/shared/RadioButtonSelect.tsx

@@ -0,0 +1,234 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React, { useEffect, useState, useRef } from 'react';
+import { Text, Box } from 'ink';
+import { Colors } from '../../colors.js';
+import { useKeypress } from '../../hooks/useKeypress.js';
+
+/**
+ * Represents a single option for the RadioButtonSelect.
+ * Requires a label for display and a value to be returned on selection.
+ */
+export interface RadioSelectItem<T> {
+  label: string;
+  value: T;
+  disabled?: boolean;
+  themeNameDisplay?: string;
+  themeTypeDisplay?: string;
+}
+
+/**
+ * Props for the RadioButtonSelect component.
+ * @template T The type of the value associated with each radio item.
+ */
+export interface RadioButtonSelectProps<T> {
+  /** An array of items to display as radio options. */
+  items: Array<RadioSelectItem<T>>;
+  /** The initial index selected */
+  initialIndex?: number;
+  /** Function called when an item is selected. Receives the `value` of the selected item. */
+  onSelect: (value: T) => void;
+  /** Function called when an item is highlighted. Receives the `value` of the selected item. */
+  onHighlight?: (value: T) => void;
+  /** Whether this select input is currently focused and should respond to input. */
+  isFocused?: boolean;
+  /** Whether to show the scroll arrows. */
+  showScrollArrows?: boolean;
+  /** The maximum number of items to show at once. */
+  maxItemsToShow?: number;
+  /** Whether to show numbers next to items. */
+  showNumbers?: boolean;
+}
+
+/**
+ * A custom component that displays a list of items with radio buttons,
+ * supporting scrolling and keyboard navigation.
+ *
+ * @template T The type of the value associated with each radio item.
+ */
+export function RadioButtonSelect<T>({
+  items,
+  initialIndex = 0,
+  onSelect,
+  onHighlight,
+  isFocused = true,
+  showScrollArrows = false,
+  maxItemsToShow = 10,
+  showNumbers = true,
+}: RadioButtonSelectProps<T>): React.JSX.Element {
+  const [activeIndex, setActiveIndex] = useState(initialIndex);
+  const [scrollOffset, setScrollOffset] = useState(0);
+  const [numberInput, setNumberInput] = useState('');
+  const numberInputTimer = useRef<NodeJS.Timeout | null>(null);
+
+  useEffect(() => {
+    const newScrollOffset = Math.max(
+      0,
+      Math.min(activeIndex - maxItemsToShow + 1, items.length - maxItemsToShow),
+    );
+    if (activeIndex < scrollOffset) {
+      setScrollOffset(activeIndex);
+    } else if (activeIndex >= scrollOffset + maxItemsToShow) {
+      setScrollOffset(newScrollOffset);
+    }
+  }, [activeIndex, items.length, scrollOffset, maxItemsToShow]);
+
+  useEffect(
+    () => () => {
+      if (numberInputTimer.current) {
+        clearTimeout(numberInputTimer.current);
+      }
+    },
+    [],
+  );
+
+  useKeypress(
+    (key) => {
+      const { sequence, name } = key;
+      const isNumeric = showNumbers && /^[0-9]$/.test(sequence);
+
+      // Any key press that is not a digit should clear the number input buffer.
+      if (!isNumeric && numberInputTimer.current) {
+        clearTimeout(numberInputTimer.current);
+        setNumberInput('');
+      }
+
+      if (name === 'k' || name === 'up') {
+        const newIndex = activeIndex > 0 ? activeIndex - 1 : items.length - 1;
+        setActiveIndex(newIndex);
+        onHighlight?.(items[newIndex]!.value);
+        return;
+      }
+
+      if (name === 'j' || name === 'down') {
+        const newIndex = activeIndex < items.length - 1 ? activeIndex + 1 : 0;
+        setActiveIndex(newIndex);
+        onHighlight?.(items[newIndex]!.value);
+        return;
+      }
+
+      if (name === 'return') {
+        onSelect(items[activeIndex]!.value);
+        return;
+      }
+
+      // Handle numeric input for selection.
+      if (isNumeric) {
+        if (numberInputTimer.current) {
+          clearTimeout(numberInputTimer.current);
+        }
+
+        const newNumberInput = numberInput + sequence;
+        setNumberInput(newNumberInput);
+
+        const targetIndex = Number.parseInt(newNumberInput, 10) - 1;
+
+        // A single '0' is not a valid selection since items are 1-indexed.
+        if (newNumberInput === '0') {
+          numberInputTimer.current = setTimeout(() => setNumberInput(''), 350);
+          return;
+        }
+
+        if (targetIndex >= 0 && targetIndex < items.length) {
+          const targetItem = items[targetIndex]!;
+          setActiveIndex(targetIndex);
+          onHighlight?.(targetItem.value);
+
+          // If the typed number can't be a prefix for another valid number,
+          // select it immediately. Otherwise, wait for more input.
+          const potentialNextNumber = Number.parseInt(newNumberInput + '0', 10);
+          if (potentialNextNumber > items.length) {
+            onSelect(targetItem.value);
+            setNumberInput('');
+          } else {
+            numberInputTimer.current = setTimeout(() => {
+              onSelect(targetItem.value);
+              setNumberInput('');
+            }, 350); // Debounce time for multi-digit input.
+          }
+        } else {
+          // The typed number is out of bounds, clear the buffer
+          setNumberInput('');
+        }
+      }
+    },
+    { isActive: !!(isFocused && items.length > 0) },
+  );
+
+  const visibleItems = items.slice(scrollOffset, scrollOffset + maxItemsToShow);
+
+  return (
+    <Box flexDirection="column">
+      {showScrollArrows && (
+        <Text color={scrollOffset > 0 ? Colors.Foreground : Colors.Gray}>
+          ▲
+        </Text>
+      )}
+      {visibleItems.map((item, index) => {
+        const itemIndex = scrollOffset + index;
+        const isSelected = activeIndex === itemIndex;
+
+        let textColor = Colors.Foreground;
+        let numberColor = Colors.Foreground;
+        if (isSelected) {
+          textColor = Colors.AccentGreen;
+          numberColor = Colors.AccentGreen;
+        } else if (item.disabled) {
+          textColor = Colors.Gray;
+          numberColor = Colors.Gray;
+        }
+
+        if (!showNumbers) {
+          numberColor = Colors.Gray;
+        }
+
+        const numberColumnWidth = String(items.length).length;
+        const itemNumberText = `${String(itemIndex + 1).padStart(
+          numberColumnWidth,
+        )}.`;
+
+        return (
+          <Box key={item.label} alignItems="center">
+            <Box minWidth={2} flexShrink={0}>
+              <Text color={isSelected ? Colors.AccentGreen : Colors.Foreground}>
+                {isSelected ? '●' : ' '}
+              </Text>
+            </Box>
+            <Box
+              marginRight={1}
+              flexShrink={0}
+              minWidth={itemNumberText.length}
+            >
+              <Text color={numberColor}>{itemNumberText}</Text>
+            </Box>
+            {item.themeNameDisplay && item.themeTypeDisplay ? (
+              <Text color={textColor} wrap="truncate">
+                {item.themeNameDisplay}{' '}
+                <Text color={Colors.Gray}>{item.themeTypeDisplay}</Text>
+              </Text>
+            ) : (
+              <Text color={textColor} wrap="truncate">
+                {item.label}
+              </Text>
+            )}
+          </Box>
+        );
+      })}
+      {showScrollArrows && (
+        <Text
+          color={
+            scrollOffset + maxItemsToShow < items.length
+              ? Colors.Foreground
+              : Colors.Gray
+          }
+        >
+          ▼
+        </Text>
+      )}
+    </Box>
+  );
+}

projects/ui/qwen-code/packages/cli/src/ui/components/shared/__snapshots__/RadioButtonSelect.test.tsx.snap

@@ -0,0 +1,47 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`<RadioButtonSelect /> > renders a list of items and matches snapshot 1`] = `
+"● 1. Option 1
+  2. Option 2
+  3. Option 3"
+`;
+
+exports[`<RadioButtonSelect /> > renders a list with >10 items and matches snapshot 1`] = `
+"●  1. Item 1
+   2. Item 2
+   3. Item 3
+   4. Item 4
+   5. Item 5
+   6. Item 6
+   7. Item 7
+   8. Item 8
+   9. Item 9
+  10. Item 10"
+`;
+
+exports[`<RadioButtonSelect /> > renders with numbers hidden and matches snapshot 1`] = `
+"● 1. Option 1
+  2. Option 2
+  3. Option 3"
+`;
+
+exports[`<RadioButtonSelect /> > renders with scroll arrows and matches snapshot 1`] = `
+"▲
+●  1. Item 1
+   2. Item 2
+   3. Item 3
+   4. Item 4
+   5. Item 5
+▼"
+`;
+
+exports[`<RadioButtonSelect /> > renders with special theme display and matches snapshot 1`] = `
+"● 1. Theme A (Light)
+  2. Theme B (Dark)"
+`;
+
+exports[`<RadioButtonSelect /> > renders with the second item selected and matches snapshot 1`] = `
+"  1. Option 1
+● 2. Option 2
+  3. Option 3"
+`;

projects/ui/qwen-code/packages/cli/src/ui/components/shared/text-buffer.test.ts

@@ -0,0 +1,1728 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import stripAnsi from 'strip-ansi';
+import { renderHook, act } from '@testing-library/react';
+import {
+  useTextBuffer,
+  Viewport,
+  TextBuffer,
+  offsetToLogicalPos,
+  logicalPosToOffset,
+  textBufferReducer,
+  TextBufferState,
+  TextBufferAction,
+  findWordEndInLine,
+  findNextWordStartInLine,
+  isWordCharStrict,
+} from './text-buffer.js';
+import { cpLen } from '../../utils/textUtils.js';
+
+const initialState: TextBufferState = {
+  lines: [''],
+  cursorRow: 0,
+  cursorCol: 0,
+  preferredCol: null,
+  undoStack: [],
+  redoStack: [],
+  clipboard: null,
+  selectionAnchor: null,
+};
+
+describe('textBufferReducer', () => {
+  it('should return the initial state if state is undefined', () => {
+    const action = { type: 'unknown_action' } as unknown as TextBufferAction;
+    const state = textBufferReducer(initialState, action);
+    expect(state).toHaveOnlyValidCharacters();
+    expect(state).toEqual(initialState);
+  });
+
+  describe('set_text action', () => {
+    it('should set new text and move cursor to the end', () => {
+      const action: TextBufferAction = {
+        type: 'set_text',
+        payload: 'hello\nworld',
+      };
+      const state = textBufferReducer(initialState, action);
+      expect(state).toHaveOnlyValidCharacters();
+      expect(state.lines).toEqual(['hello', 'world']);
+      expect(state.cursorRow).toBe(1);
+      expect(state.cursorCol).toBe(5);
+      expect(state.undoStack.length).toBe(1);
+    });
+
+    it('should not create an undo snapshot if pushToUndo is false', () => {
+      const action: TextBufferAction = {
+        type: 'set_text',
+        payload: 'no undo',
+        pushToUndo: false,
+      };
+      const state = textBufferReducer(initialState, action);
+      expect(state).toHaveOnlyValidCharacters();
+      expect(state.lines).toEqual(['no undo']);
+      expect(state.undoStack.length).toBe(0);
+    });
+  });
+
+  describe('insert action', () => {
+    it('should insert a character', () => {
+      const action: TextBufferAction = { type: 'insert', payload: 'a' };
+      const state = textBufferReducer(initialState, action);
+      expect(state).toHaveOnlyValidCharacters();
+      expect(state.lines).toEqual(['a']);
+      expect(state.cursorCol).toBe(1);
+    });
+
+    it('should insert a newline', () => {
+      const stateWithText = { ...initialState, lines: ['hello'] };
+      const action: TextBufferAction = { type: 'insert', payload: '\n' };
+      const state = textBufferReducer(stateWithText, action);
+      expect(state).toHaveOnlyValidCharacters();
+      expect(state.lines).toEqual(['', 'hello']);
+      expect(state.cursorRow).toBe(1);
+      expect(state.cursorCol).toBe(0);
+    });
+  });
+
+  describe('backspace action', () => {
+    it('should remove a character', () => {
+      const stateWithText: TextBufferState = {
+        ...initialState,
+        lines: ['a'],
+        cursorRow: 0,
+        cursorCol: 1,
+      };
+      const action: TextBufferAction = { type: 'backspace' };
+      const state = textBufferReducer(stateWithText, action);
+      expect(state).toHaveOnlyValidCharacters();
+      expect(state.lines).toEqual(['']);
+      expect(state.cursorCol).toBe(0);
+    });
+
+    it('should join lines if at the beginning of a line', () => {
+      const stateWithText: TextBufferState = {
+        ...initialState,
+        lines: ['hello', 'world'],
+        cursorRow: 1,
+        cursorCol: 0,
+      };
+      const action: TextBufferAction = { type: 'backspace' };
+      const state = textBufferReducer(stateWithText, action);
+      expect(state).toHaveOnlyValidCharacters();
+      expect(state.lines).toEqual(['helloworld']);
+      expect(state.cursorRow).toBe(0);
+      expect(state.cursorCol).toBe(5);
+    });
+  });
+
+  describe('undo/redo actions', () => {
+    it('should undo and redo a change', () => {
+      // 1. Insert text
+      const insertAction: TextBufferAction = {
+        type: 'insert',
+        payload: 'test',
+      };
+      const stateAfterInsert = textBufferReducer(initialState, insertAction);
+      expect(stateAfterInsert).toHaveOnlyValidCharacters();
+      expect(stateAfterInsert.lines).toEqual(['test']);
+      expect(stateAfterInsert.undoStack.length).toBe(1);
+
+      // 2. Undo
+      const undoAction: TextBufferAction = { type: 'undo' };
+      const stateAfterUndo = textBufferReducer(stateAfterInsert, undoAction);
+      expect(stateAfterUndo).toHaveOnlyValidCharacters();
+      expect(stateAfterUndo.lines).toEqual(['']);
+      expect(stateAfterUndo.undoStack.length).toBe(0);
+      expect(stateAfterUndo.redoStack.length).toBe(1);
+
+      // 3. Redo
+      const redoAction: TextBufferAction = { type: 'redo' };
+      const stateAfterRedo = textBufferReducer(stateAfterUndo, redoAction);
+      expect(stateAfterRedo).toHaveOnlyValidCharacters();
+      expect(stateAfterRedo.lines).toEqual(['test']);
+      expect(stateAfterRedo.undoStack.length).toBe(1);
+      expect(stateAfterRedo.redoStack.length).toBe(0);
+    });
+  });
+
+  describe('create_undo_snapshot action', () => {
+    it('should create a snapshot without changing state', () => {
+      const stateWithText: TextBufferState = {
+        ...initialState,
+        lines: ['hello'],
+        cursorRow: 0,
+        cursorCol: 5,
+      };
+      const action: TextBufferAction = { type: 'create_undo_snapshot' };
+      const state = textBufferReducer(stateWithText, action);
+      expect(state).toHaveOnlyValidCharacters();
+
+      expect(state.lines).toEqual(['hello']);
+      expect(state.cursorRow).toBe(0);
+      expect(state.cursorCol).toBe(5);
+      expect(state.undoStack.length).toBe(1);
+      expect(state.undoStack[0].lines).toEqual(['hello']);
+      expect(state.undoStack[0].cursorRow).toBe(0);
+      expect(state.undoStack[0].cursorCol).toBe(5);
+    });
+  });
+});
+
+// Helper to get the state from the hook
+const getBufferState = (result: { current: TextBuffer }) => {
+  expect(result.current).toHaveOnlyValidCharacters();
+  return {
+    text: result.current.text,
+    lines: [...result.current.lines], // Clone for safety
+    cursor: [...result.current.cursor] as [number, number],
+    allVisualLines: [...result.current.allVisualLines],
+    viewportVisualLines: [...result.current.viewportVisualLines],
+    visualCursor: [...result.current.visualCursor] as [number, number],
+    visualScrollRow: result.current.visualScrollRow,
+    preferredCol: result.current.preferredCol,
+  };
+};
+
+describe('useTextBuffer', () => {
+  let viewport: Viewport;
+
+  beforeEach(() => {
+    viewport = { width: 10, height: 3 }; // Default viewport for tests
+  });
+
+  describe('Initialization', () => {
+    it('should initialize with empty text and cursor at (0,0) by default', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => false }),
+      );
+      const state = getBufferState(result);
+      expect(state.text).toBe('');
+      expect(state.lines).toEqual(['']);
+      expect(state.cursor).toEqual([0, 0]);
+      expect(state.allVisualLines).toEqual(['']);
+      expect(state.viewportVisualLines).toEqual(['']);
+      expect(state.visualCursor).toEqual([0, 0]);
+      expect(state.visualScrollRow).toBe(0);
+    });
+
+    it('should initialize with provided initialText', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'hello',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      const state = getBufferState(result);
+      expect(state.text).toBe('hello');
+      expect(state.lines).toEqual(['hello']);
+      expect(state.cursor).toEqual([0, 0]); // Default cursor if offset not given
+      expect(state.allVisualLines).toEqual(['hello']);
+      expect(state.viewportVisualLines).toEqual(['hello']);
+      expect(state.visualCursor).toEqual([0, 0]);
+    });
+
+    it('should initialize with initialText and initialCursorOffset', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'hello\nworld',
+          initialCursorOffset: 7, // Should be at 'o' in 'world'
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      const state = getBufferState(result);
+      expect(state.text).toBe('hello\nworld');
+      expect(state.lines).toEqual(['hello', 'world']);
+      expect(state.cursor).toEqual([1, 1]); // Logical cursor at 'o' in "world"
+      expect(state.allVisualLines).toEqual(['hello', 'world']);
+      expect(state.viewportVisualLines).toEqual(['hello', 'world']);
+      expect(state.visualCursor[0]).toBe(1); // On the second visual line
+      expect(state.visualCursor[1]).toBe(1); // At 'o' in "world"
+    });
+
+    it('should wrap visual lines', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'The quick brown fox jumps over the lazy dog.',
+          initialCursorOffset: 2, // After '好'
+          viewport: { width: 15, height: 4 },
+          isValidPath: () => false,
+        }),
+      );
+      const state = getBufferState(result);
+      expect(state.allVisualLines).toEqual([
+        'The quick',
+        'brown fox',
+        'jumps over the',
+        'lazy dog.',
+      ]);
+    });
+
+    it('should wrap visual lines with multiple spaces', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'The  quick  brown fox    jumps over the lazy dog.',
+          viewport: { width: 15, height: 4 },
+          isValidPath: () => false,
+        }),
+      );
+      const state = getBufferState(result);
+      // Including multiple spaces at the end of the lines like this is
+      // consistent with Google docs behavior and makes it intuitive to edit
+      // the spaces as needed.
+      expect(state.allVisualLines).toEqual([
+        'The  quick ',
+        'brown fox   ',
+        'jumps over the',
+        'lazy dog.',
+      ]);
+    });
+
+    it('should wrap visual lines even without spaces', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: '123456789012345ABCDEFG', // 4 chars, 12 bytes
+          viewport: { width: 15, height: 2 },
+          isValidPath: () => false,
+        }),
+      );
+      const state = getBufferState(result);
+      // Including multiple spaces at the end of the lines like this is
+      // consistent with Google docs behavior and makes it intuitive to edit
+      // the spaces as needed.
+      expect(state.allVisualLines).toEqual(['123456789012345', 'ABCDEFG']);
+    });
+
+    it('should initialize with multi-byte unicode characters and correct cursor offset', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: '你好世界', // 4 chars, 12 bytes
+          initialCursorOffset: 2, // After '好'
+          viewport: { width: 5, height: 2 },
+          isValidPath: () => false,
+        }),
+      );
+      const state = getBufferState(result);
+      expect(state.text).toBe('你好世界');
+      expect(state.lines).toEqual(['你好世界']);
+      expect(state.cursor).toEqual([0, 2]);
+      // Visual: "你好" (width 4), "世"界" (width 4) with viewport width 5
+      expect(state.allVisualLines).toEqual(['你好', '世界']);
+      expect(state.visualCursor).toEqual([1, 0]);
+    });
+  });
+
+  describe('Basic Editing', () => {
+    it('insert: should insert a character and update cursor', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => false }),
+      );
+      act(() => result.current.insert('a'));
+      let state = getBufferState(result);
+      expect(state.text).toBe('a');
+      expect(state.cursor).toEqual([0, 1]);
+      expect(state.visualCursor).toEqual([0, 1]);
+
+      act(() => result.current.insert('b'));
+      state = getBufferState(result);
+      expect(state.text).toBe('ab');
+      expect(state.cursor).toEqual([0, 2]);
+      expect(state.visualCursor).toEqual([0, 2]);
+    });
+
+    it('insert: should insert text in the middle of a line', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'abc',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.move('right'));
+      act(() => result.current.insert('-NEW-'));
+      const state = getBufferState(result);
+      expect(state.text).toBe('a-NEW-bc');
+      expect(state.cursor).toEqual([0, 6]);
+    });
+
+    it('newline: should create a new line and move cursor', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'ab',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.move('end')); // cursor at [0,2]
+      act(() => result.current.newline());
+      const state = getBufferState(result);
+      expect(state.text).toBe('ab\n');
+      expect(state.lines).toEqual(['ab', '']);
+      expect(state.cursor).toEqual([1, 0]);
+      expect(state.allVisualLines).toEqual(['ab', '']);
+      expect(state.viewportVisualLines).toEqual(['ab', '']); // viewport height 3
+      expect(state.visualCursor).toEqual([1, 0]); // On the new visual line
+    });
+
+    it('backspace: should delete char to the left or merge lines', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'a\nb',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => {
+        result.current.move('down');
+      });
+      act(() => {
+        result.current.move('end'); // cursor to [1,1] (end of 'b')
+      });
+      act(() => result.current.backspace()); // delete 'b'
+      let state = getBufferState(result);
+      expect(state.text).toBe('a\n');
+      expect(state.cursor).toEqual([1, 0]);
+
+      act(() => result.current.backspace()); // merge lines
+      state = getBufferState(result);
+      expect(state.text).toBe('a');
+      expect(state.cursor).toEqual([0, 1]); // cursor after 'a'
+      expect(state.allVisualLines).toEqual(['a']);
+      expect(state.viewportVisualLines).toEqual(['a']);
+      expect(state.visualCursor).toEqual([0, 1]);
+    });
+
+    it('del: should delete char to the right or merge lines', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'a\nb',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      // cursor at [0,0]
+      act(() => result.current.del()); // delete 'a'
+      let state = getBufferState(result);
+      expect(state.text).toBe('\nb');
+      expect(state.cursor).toEqual([0, 0]);
+
+      act(() => result.current.del()); // merge lines (deletes newline)
+      state = getBufferState(result);
+      expect(state.text).toBe('b');
+      expect(state.cursor).toEqual([0, 0]);
+      expect(state.allVisualLines).toEqual(['b']);
+      expect(state.viewportVisualLines).toEqual(['b']);
+      expect(state.visualCursor).toEqual([0, 0]);
+    });
+  });
+
+  describe('Drag and Drop File Paths', () => {
+    it('should prepend @ to a valid file path on insert', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => true }),
+      );
+      const filePath = '/path/to/a/valid/file.txt';
+      act(() => result.current.insert(filePath, { paste: true }));
+      expect(getBufferState(result).text).toBe(`@${filePath} `);
+    });
+
+    it('should not prepend @ to an invalid file path on insert', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => false }),
+      );
+      const notAPath = 'this is just some long text';
+      act(() => result.current.insert(notAPath, { paste: true }));
+      expect(getBufferState(result).text).toBe(notAPath);
+    });
+
+    it('should handle quoted paths', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => true }),
+      );
+      const filePath = "'/path/to/a/valid/file.txt'";
+      act(() => result.current.insert(filePath, { paste: true }));
+      expect(getBufferState(result).text).toBe(`@/path/to/a/valid/file.txt `);
+    });
+
+    it('should not prepend @ to short text that is not a path', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => true }),
+      );
+      const shortText = 'ab';
+      act(() => result.current.insert(shortText, { paste: true }));
+      expect(getBufferState(result).text).toBe(shortText);
+    });
+  });
+
+  describe('Shell Mode Behavior', () => {
+    it('should not prepend @ to valid file paths when shellModeActive is true', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          viewport,
+          isValidPath: () => true,
+          shellModeActive: true,
+        }),
+      );
+      const filePath = '/path/to/a/valid/file.txt';
+      act(() => result.current.insert(filePath, { paste: true }));
+      expect(getBufferState(result).text).toBe(filePath); // No @ prefix
+    });
+
+    it('should not prepend @ to quoted paths when shellModeActive is true', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          viewport,
+          isValidPath: () => true,
+          shellModeActive: true,
+        }),
+      );
+      const quotedFilePath = "'/path/to/a/valid/file.txt'";
+      act(() => result.current.insert(quotedFilePath, { paste: true }));
+      expect(getBufferState(result).text).toBe(quotedFilePath); // No @ prefix, keeps quotes
+    });
+
+    it('should behave normally with invalid paths when shellModeActive is true', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          viewport,
+          isValidPath: () => false,
+          shellModeActive: true,
+        }),
+      );
+      const notAPath = 'this is just some text';
+      act(() => result.current.insert(notAPath, { paste: true }));
+      expect(getBufferState(result).text).toBe(notAPath);
+    });
+
+    it('should behave normally with short text when shellModeActive is true', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          viewport,
+          isValidPath: () => true,
+          shellModeActive: true,
+        }),
+      );
+      const shortText = 'ls';
+      act(() => result.current.insert(shortText, { paste: true }));
+      expect(getBufferState(result).text).toBe(shortText); // No @ prefix for short text
+    });
+  });
+
+  describe('Cursor Movement', () => {
+    it('move: left/right should work within and across visual lines (due to wrapping)', () => {
+      // Text: "long line1next line2" (20 chars)
+      // Viewport width 5. Word wrapping should produce:
+      // "long " (5)
+      // "line1" (5)
+      // "next " (5)
+      // "line2" (5)
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'long line1next line2', // Corrected: was 'long line1next line2'
+          viewport: { width: 5, height: 4 },
+          isValidPath: () => false,
+        }),
+      );
+      // Initial cursor [0,0] logical, visual [0,0] ("l" of "long ")
+
+      act(() => result.current.move('right')); // visual [0,1] ("o")
+      expect(getBufferState(result).visualCursor).toEqual([0, 1]);
+      act(() => result.current.move('right')); // visual [0,2] ("n")
+      act(() => result.current.move('right')); // visual [0,3] ("g")
+      act(() => result.current.move('right')); // visual [0,4] (" ")
+      expect(getBufferState(result).visualCursor).toEqual([0, 4]);
+
+      act(() => result.current.move('right')); // visual [1,0] ("l" of "line1")
+      expect(getBufferState(result).visualCursor).toEqual([1, 0]);
+      expect(getBufferState(result).cursor).toEqual([0, 5]); // logical cursor
+
+      act(() => result.current.move('left')); // visual [0,4] (" " of "long ")
+      expect(getBufferState(result).visualCursor).toEqual([0, 4]);
+      expect(getBufferState(result).cursor).toEqual([0, 4]); // logical cursor
+    });
+
+    it('move: up/down should preserve preferred visual column', () => {
+      const text = 'abcde\nxy\n12345';
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: text,
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      expect(result.current.allVisualLines).toEqual(['abcde', 'xy', '12345']);
+      // Place cursor at the end of "abcde" -> logical [0,5]
+      act(() => {
+        result.current.move('home'); // to [0,0]
+      });
+      for (let i = 0; i < 5; i++) {
+        act(() => {
+          result.current.move('right'); // to [0,5]
+        });
+      }
+      expect(getBufferState(result).cursor).toEqual([0, 5]);
+      expect(getBufferState(result).visualCursor).toEqual([0, 5]);
+
+      // Set preferredCol by moving up then down to the same spot, then test.
+      act(() => {
+        result.current.move('down'); // to xy, logical [1,2], visual [1,2], preferredCol should be 5
+      });
+      let state = getBufferState(result);
+      expect(state.cursor).toEqual([1, 2]); // Logical cursor at end of 'xy'
+      expect(state.visualCursor).toEqual([1, 2]); // Visual cursor at end of 'xy'
+      expect(state.preferredCol).toBe(5);
+
+      act(() => result.current.move('down')); // to '12345', preferredCol=5.
+      state = getBufferState(result);
+      expect(state.cursor).toEqual([2, 5]); // Logical cursor at end of '12345'
+      expect(state.visualCursor).toEqual([2, 5]); // Visual cursor at end of '12345'
+      expect(state.preferredCol).toBe(5); // Preferred col is maintained
+
+      act(() => result.current.move('left')); // preferredCol should reset
+      state = getBufferState(result);
+      expect(state.preferredCol).toBe(null);
+    });
+
+    it('move: home/end should go to visual line start/end', () => {
+      const initialText = 'line one\nsecond line';
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText,
+          viewport: { width: 5, height: 5 },
+          isValidPath: () => false,
+        }),
+      );
+      expect(result.current.allVisualLines).toEqual([
+        'line',
+        'one',
+        'secon',
+        'd',
+        'line',
+      ]);
+      // Initial cursor [0,0] (start of "line")
+      act(() => result.current.move('down')); // visual cursor from [0,0] to [1,0] ("o" of "one")
+      act(() => result.current.move('right')); // visual cursor to [1,1] ("n" of "one")
+      expect(getBufferState(result).visualCursor).toEqual([1, 1]);
+
+      act(() => result.current.move('home')); // visual cursor to [1,0] (start of "one")
+      expect(getBufferState(result).visualCursor).toEqual([1, 0]);
+
+      act(() => result.current.move('end')); // visual cursor to [1,3] (end of "one")
+      expect(getBufferState(result).visualCursor).toEqual([1, 3]); // "one" is 3 chars
+    });
+  });
+
+  describe('Visual Layout & Viewport', () => {
+    it('should wrap long lines correctly into visualLines', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'This is a very long line of text.', // 33 chars
+          viewport: { width: 10, height: 5 },
+          isValidPath: () => false,
+        }),
+      );
+      const state = getBufferState(result);
+      // Expected visual lines with word wrapping (viewport width 10):
+      // "This is a"
+      // "very long"
+      // "line of"
+      // "text."
+      expect(state.allVisualLines.length).toBe(4);
+      expect(state.allVisualLines[0]).toBe('This is a');
+      expect(state.allVisualLines[1]).toBe('very long');
+      expect(state.allVisualLines[2]).toBe('line of');
+      expect(state.allVisualLines[3]).toBe('text.');
+    });
+
+    it('should update visualScrollRow when visualCursor moves out of viewport', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'l1\nl2\nl3\nl4\nl5',
+          viewport: { width: 5, height: 3 }, // Can show 3 visual lines
+          isValidPath: () => false,
+        }),
+      );
+      // Initial: l1, l2, l3 visible. visualScrollRow = 0. visualCursor = [0,0]
+      expect(getBufferState(result).visualScrollRow).toBe(0);
+      expect(getBufferState(result).allVisualLines).toEqual([
+        'l1',
+        'l2',
+        'l3',
+        'l4',
+        'l5',
+      ]);
+      expect(getBufferState(result).viewportVisualLines).toEqual([
+        'l1',
+        'l2',
+        'l3',
+      ]);
+
+      act(() => result.current.move('down')); // vc=[1,0]
+      act(() => result.current.move('down')); // vc=[2,0] (l3)
+      expect(getBufferState(result).visualScrollRow).toBe(0);
+
+      act(() => result.current.move('down')); // vc=[3,0] (l4) - scroll should happen
+      // Now: l2, l3, l4 visible. visualScrollRow = 1.
+      let state = getBufferState(result);
+      expect(state.visualScrollRow).toBe(1);
+      expect(state.allVisualLines).toEqual(['l1', 'l2', 'l3', 'l4', 'l5']);
+      expect(state.viewportVisualLines).toEqual(['l2', 'l3', 'l4']);
+      expect(state.visualCursor).toEqual([3, 0]);
+
+      act(() => result.current.move('up')); // vc=[2,0] (l3)
+      act(() => result.current.move('up')); // vc=[1,0] (l2)
+      expect(getBufferState(result).visualScrollRow).toBe(1);
+
+      act(() => result.current.move('up')); // vc=[0,0] (l1) - scroll up
+      // Now: l1, l2, l3 visible. visualScrollRow = 0
+      state = getBufferState(result); // Assign to the existing `state` variable
+      expect(state.visualScrollRow).toBe(0);
+      expect(state.allVisualLines).toEqual(['l1', 'l2', 'l3', 'l4', 'l5']);
+      expect(state.viewportVisualLines).toEqual(['l1', 'l2', 'l3']);
+      expect(state.visualCursor).toEqual([0, 0]);
+    });
+  });
+
+  describe('Undo/Redo', () => {
+    it('should undo and redo an insert operation', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => false }),
+      );
+      act(() => result.current.insert('a'));
+      expect(getBufferState(result).text).toBe('a');
+
+      act(() => result.current.undo());
+      expect(getBufferState(result).text).toBe('');
+      expect(getBufferState(result).cursor).toEqual([0, 0]);
+
+      act(() => result.current.redo());
+      expect(getBufferState(result).text).toBe('a');
+      expect(getBufferState(result).cursor).toEqual([0, 1]);
+    });
+
+    it('should undo and redo a newline operation', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'test',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.move('end'));
+      act(() => result.current.newline());
+      expect(getBufferState(result).text).toBe('test\n');
+
+      act(() => result.current.undo());
+      expect(getBufferState(result).text).toBe('test');
+      expect(getBufferState(result).cursor).toEqual([0, 4]);
+
+      act(() => result.current.redo());
+      expect(getBufferState(result).text).toBe('test\n');
+      expect(getBufferState(result).cursor).toEqual([1, 0]);
+    });
+  });
+
+  describe('Unicode Handling', () => {
+    it('insert: should correctly handle multi-byte unicode characters', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => false }),
+      );
+      act(() => result.current.insert('你好'));
+      const state = getBufferState(result);
+      expect(state.text).toBe('你好');
+      expect(state.cursor).toEqual([0, 2]); // Cursor is 2 (char count)
+      expect(state.visualCursor).toEqual([0, 2]);
+    });
+
+    it('backspace: should correctly delete multi-byte unicode characters', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: '你好',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.move('end')); // cursor at [0,2]
+      act(() => result.current.backspace()); // delete '好'
+      let state = getBufferState(result);
+      expect(state.text).toBe('你');
+      expect(state.cursor).toEqual([0, 1]);
+
+      act(() => result.current.backspace()); // delete '你'
+      state = getBufferState(result);
+      expect(state.text).toBe('');
+      expect(state.cursor).toEqual([0, 0]);
+    });
+
+    it('move: left/right should treat multi-byte chars as single units for visual cursor', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: '🐶🐱',
+          viewport: { width: 5, height: 1 },
+          isValidPath: () => false,
+        }),
+      );
+      // Initial: visualCursor [0,0]
+      act(() => result.current.move('right')); // visualCursor [0,1] (after 🐶)
+      let state = getBufferState(result);
+      expect(state.cursor).toEqual([0, 1]);
+      expect(state.visualCursor).toEqual([0, 1]);
+
+      act(() => result.current.move('right')); // visualCursor [0,2] (after 🐱)
+      state = getBufferState(result);
+      expect(state.cursor).toEqual([0, 2]);
+      expect(state.visualCursor).toEqual([0, 2]);
+
+      act(() => result.current.move('left')); // visualCursor [0,1] (before 🐱 / after 🐶)
+      state = getBufferState(result);
+      expect(state.cursor).toEqual([0, 1]);
+      expect(state.visualCursor).toEqual([0, 1]);
+    });
+  });
+
+  describe('handleInput', () => {
+    it('should insert printable characters', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => false }),
+      );
+      act(() =>
+        result.current.handleInput({
+          name: 'h',
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: false,
+          sequence: 'h',
+        }),
+      );
+      act(() =>
+        result.current.handleInput({
+          name: 'i',
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: false,
+          sequence: 'i',
+        }),
+      );
+      expect(getBufferState(result).text).toBe('hi');
+    });
+
+    it('should handle "Enter" key as newline', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => false }),
+      );
+      act(() =>
+        result.current.handleInput({
+          name: 'return',
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: false,
+          sequence: '\r',
+        }),
+      );
+      expect(getBufferState(result).lines).toEqual(['', '']);
+    });
+
+    it('should handle "Backspace" key', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'a',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.move('end'));
+      act(() =>
+        result.current.handleInput({
+          name: 'backspace',
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: false,
+          sequence: '\x7f',
+        }),
+      );
+      expect(getBufferState(result).text).toBe('');
+    });
+
+    it('should handle multiple delete characters in one input', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'abcde',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.move('end')); // cursor at the end
+      expect(getBufferState(result).cursor).toEqual([0, 5]);
+
+      act(() => {
+        result.current.handleInput({
+          name: 'backspace',
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: false,
+          sequence: '\x7f',
+        });
+        result.current.handleInput({
+          name: 'backspace',
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: false,
+          sequence: '\x7f',
+        });
+        result.current.handleInput({
+          name: 'backspace',
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: false,
+          sequence: '\x7f',
+        });
+      });
+      expect(getBufferState(result).text).toBe('ab');
+      expect(getBufferState(result).cursor).toEqual([0, 2]);
+    });
+
+    it('should handle inserts that contain delete characters ', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'abcde',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.move('end')); // cursor at the end
+      expect(getBufferState(result).cursor).toEqual([0, 5]);
+
+      act(() => {
+        result.current.insert('\x7f\x7f\x7f');
+      });
+      expect(getBufferState(result).text).toBe('ab');
+      expect(getBufferState(result).cursor).toEqual([0, 2]);
+    });
+
+    it('should handle inserts with a mix of regular and delete characters ', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'abcde',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.move('end')); // cursor at the end
+      expect(getBufferState(result).cursor).toEqual([0, 5]);
+
+      act(() => {
+        result.current.insert('\x7fI\x7f\x7fNEW');
+      });
+      expect(getBufferState(result).text).toBe('abcNEW');
+      expect(getBufferState(result).cursor).toEqual([0, 6]);
+    });
+
+    it('should handle arrow keys for movement', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'ab',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.move('end')); // cursor [0,2]
+      act(() =>
+        result.current.handleInput({
+          name: 'left',
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: false,
+          sequence: '\x1b[D',
+        }),
+      ); // cursor [0,1]
+      expect(getBufferState(result).cursor).toEqual([0, 1]);
+      act(() =>
+        result.current.handleInput({
+          name: 'right',
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: false,
+          sequence: '\x1b[C',
+        }),
+      ); // cursor [0,2]
+      expect(getBufferState(result).cursor).toEqual([0, 2]);
+    });
+
+    it('should strip ANSI escape codes when pasting text', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => false }),
+      );
+      const textWithAnsi = '\x1B[31mHello\x1B[0m \x1B[32mWorld\x1B[0m';
+      // Simulate pasting by calling handleInput with a string longer than 1 char
+      act(() =>
+        result.current.handleInput({
+          name: '',
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: false,
+          sequence: textWithAnsi,
+        }),
+      );
+      expect(getBufferState(result).text).toBe('Hello World');
+    });
+
+    it('should handle VSCode terminal Shift+Enter as newline', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => false }),
+      );
+      act(() =>
+        result.current.handleInput({
+          name: 'return',
+          ctrl: false,
+          meta: false,
+          shift: true,
+          paste: false,
+          sequence: '\r',
+        }),
+      ); // Simulates Shift+Enter in VSCode terminal
+      expect(getBufferState(result).lines).toEqual(['', '']);
+    });
+
+    it('should correctly handle repeated pasting of long text', () => {
+      const longText = `not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.
+
+Why do we use it?
+It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using 'Content here, content here', making it look like readable English. Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, and a search for 'lorem ipsum' will uncover many web sites still in their infancy. Various versions have evolved over the years, sometimes by accident, sometimes on purpose (injected humour and the like).
+
+Where does it come from?
+Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots in a piece of classical Latin literature from 45 BC, making it over 2000 years old. Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, consectetur, from a Lore
+`;
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => false }),
+      );
+
+      // Simulate pasting the long text multiple times
+      act(() => {
+        result.current.insert(longText, { paste: true });
+        result.current.insert(longText, { paste: true });
+        result.current.insert(longText, { paste: true });
+      });
+
+      const state = getBufferState(result);
+      // Check that the text is the result of three concatenations.
+      expect(state.lines).toStrictEqual(
+        (longText + longText + longText).split('\n'),
+      );
+      const expectedCursorPos = offsetToLogicalPos(
+        state.text,
+        state.text.length,
+      );
+      expect(state.cursor).toEqual(expectedCursorPos);
+    });
+  });
+
+  // More tests would be needed for:
+  // - setText, replaceRange
+  // - deleteWordLeft, deleteWordRight
+  // - More complex undo/redo scenarios
+  // - Selection and clipboard (copy/paste) - might need clipboard API mocks or internal state check
+  // - openInExternalEditor (heavy mocking of fs, child_process, os)
+  // - All edge cases for visual scrolling and wrapping with different viewport sizes and text content.
+
+  describe('replaceRange', () => {
+    it('should replace a single-line range with single-line text', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: '@pac',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.replaceRange(0, 1, 0, 4, 'packages'));
+      const state = getBufferState(result);
+      expect(state.text).toBe('@packages');
+      expect(state.cursor).toEqual([0, 9]); // cursor after 'typescript'
+    });
+
+    it('should replace a multi-line range with single-line text', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'hello\nworld\nagain',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.replaceRange(0, 2, 1, 3, ' new ')); // replace 'llo\nwor' with ' new '
+      const state = getBufferState(result);
+      expect(state.text).toBe('he new ld\nagain');
+      expect(state.cursor).toEqual([0, 7]); // cursor after ' new '
+    });
+
+    it('should delete a range when replacing with an empty string', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'hello world',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.replaceRange(0, 5, 0, 11, '')); // delete ' world'
+      const state = getBufferState(result);
+      expect(state.text).toBe('hello');
+      expect(state.cursor).toEqual([0, 5]);
+    });
+
+    it('should handle replacing at the beginning of the text', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'world',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.replaceRange(0, 0, 0, 0, 'hello '));
+      const state = getBufferState(result);
+      expect(state.text).toBe('hello world');
+      expect(state.cursor).toEqual([0, 6]);
+    });
+
+    it('should handle replacing at the end of the text', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'hello',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.replaceRange(0, 5, 0, 5, ' world'));
+      const state = getBufferState(result);
+      expect(state.text).toBe('hello world');
+      expect(state.cursor).toEqual([0, 11]);
+    });
+
+    it('should handle replacing the entire buffer content', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'old text',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.replaceRange(0, 0, 0, 8, 'new text'));
+      const state = getBufferState(result);
+      expect(state.text).toBe('new text');
+      expect(state.cursor).toEqual([0, 8]);
+    });
+
+    it('should correctly replace with unicode characters', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'hello *** world',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.replaceRange(0, 6, 0, 9, '你好'));
+      const state = getBufferState(result);
+      expect(state.text).toBe('hello 你好 world');
+      expect(state.cursor).toEqual([0, 8]); // after '你好'
+    });
+
+    it('should handle invalid range by returning false and not changing text', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'test',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => {
+        result.current.replaceRange(0, 5, 0, 3, 'fail'); // startCol > endCol in same line
+      });
+
+      expect(getBufferState(result).text).toBe('test');
+
+      act(() => {
+        result.current.replaceRange(1, 0, 0, 0, 'fail'); // startRow > endRow
+      });
+      expect(getBufferState(result).text).toBe('test');
+    });
+
+    it('replaceRange: multiple lines with a single character', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'first\nsecond\nthird',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      act(() => result.current.replaceRange(0, 2, 2, 3, 'X')); // Replace 'rst\nsecond\nthi'
+      const state = getBufferState(result);
+      expect(state.text).toBe('fiXrd');
+      expect(state.cursor).toEqual([0, 3]); // After 'X'
+    });
+
+    it('should replace a single-line range with multi-line text', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({
+          initialText: 'one two three',
+          viewport,
+          isValidPath: () => false,
+        }),
+      );
+      // Replace "two" with "new\nline"
+      act(() => result.current.replaceRange(0, 4, 0, 7, 'new\nline'));
+      const state = getBufferState(result);
+      expect(state.lines).toEqual(['one new', 'line three']);
+      expect(state.text).toBe('one new\nline three');
+      expect(state.cursor).toEqual([1, 4]); // cursor after 'line'
+    });
+  });
+
+  describe('Input Sanitization', () => {
+    it('should strip ANSI escape codes from input', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => false }),
+      );
+      const textWithAnsi = '\x1B[31mHello\x1B[0m \x1B[32mWorld\x1B[0m';
+      act(() =>
+        result.current.handleInput({
+          name: '',
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: false,
+          sequence: textWithAnsi,
+        }),
+      );
+      expect(getBufferState(result).text).toBe('Hello World');
+    });
+
+    it('should strip control characters from input', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => false }),
+      );
+      const textWithControlChars = 'H\x07e\x08l\x0Bl\x0Co'; // BELL, BACKSPACE, VT, FF
+      act(() =>
+        result.current.handleInput({
+          name: '',
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: false,
+          sequence: textWithControlChars,
+        }),
+      );
+      expect(getBufferState(result).text).toBe('Hello');
+    });
+
+    it('should strip mixed ANSI and control characters from input', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => false }),
+      );
+      const textWithMixed = '\u001B[4mH\u001B[0mello';
+      act(() =>
+        result.current.handleInput({
+          name: '',
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: false,
+          sequence: textWithMixed,
+        }),
+      );
+      expect(getBufferState(result).text).toBe('Hello');
+    });
+
+    it('should not strip standard characters or newlines', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => false }),
+      );
+      const validText = 'Hello World\nThis is a test.';
+      act(() =>
+        result.current.handleInput({
+          name: '',
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: false,
+          sequence: validText,
+        }),
+      );
+      expect(getBufferState(result).text).toBe(validText);
+    });
+
+    it('should sanitize pasted text via handleInput', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => false }),
+      );
+      const pastedText = '\u001B[4mPasted\u001B[4m Text';
+      act(() =>
+        result.current.handleInput({
+          name: '',
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: false,
+          sequence: pastedText,
+        }),
+      );
+      expect(getBufferState(result).text).toBe('Pasted Text');
+    });
+
+    it('should not strip popular emojis', () => {
+      const { result } = renderHook(() =>
+        useTextBuffer({ viewport, isValidPath: () => false }),
+      );
+      const emojis = '🐍🐳🦀🦄';
+      act(() =>
+        result.current.handleInput({
+          name: '',
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: false,
+          sequence: emojis,
+        }),
+      );
+      expect(getBufferState(result).text).toBe(emojis);
+    });
+  });
+
+  describe('stripAnsi', () => {
+    it('should correctly strip ANSI escape codes', () => {
+      const textWithAnsi = '\x1B[31mHello\x1B[0m World';
+      expect(stripAnsi(textWithAnsi)).toBe('Hello World');
+    });
+
+    it('should handle multiple ANSI codes', () => {
+      const textWithMultipleAnsi = '\x1B[1m\x1B[34mBold Blue\x1B[0m Text';
+      expect(stripAnsi(textWithMultipleAnsi)).toBe('Bold Blue Text');
+    });
+
+    it('should not modify text without ANSI codes', () => {
+      const plainText = 'Plain text';
+      expect(stripAnsi(plainText)).toBe('Plain text');
+    });
+
+    it('should handle empty string', () => {
+      expect(stripAnsi('')).toBe('');
+    });
+  });
+});
+
+describe('offsetToLogicalPos', () => {
+  it('should return [0,0] for offset 0', () => {
+    expect(offsetToLogicalPos('any text', 0)).toEqual([0, 0]);
+  });
+
+  it('should handle single line text', () => {
+    const text = 'hello';
+    expect(offsetToLogicalPos(text, 0)).toEqual([0, 0]); // Start
+    expect(offsetToLogicalPos(text, 2)).toEqual([0, 2]); // Middle 'l'
+    expect(offsetToLogicalPos(text, 5)).toEqual([0, 5]); // End
+    expect(offsetToLogicalPos(text, 10)).toEqual([0, 5]); // Beyond end
+  });
+
+  it('should handle multi-line text', () => {
+    const text = 'hello\nworld\n123';
+    // "hello" (5) + \n (1) + "world" (5) + \n (1) + "123" (3)
+    // h e l l o \n w o r l d \n 1 2 3
+    // 0 1 2 3 4  5  6 7 8 9 0  1  2 3 4
+    // Line 0: "hello" (length 5)
+    expect(offsetToLogicalPos(text, 0)).toEqual([0, 0]); // Start of 'hello'
+    expect(offsetToLogicalPos(text, 3)).toEqual([0, 3]); // 'l' in 'hello'
+    expect(offsetToLogicalPos(text, 5)).toEqual([0, 5]); // End of 'hello' (before \n)
+
+    // Line 1: "world" (length 5)
+    expect(offsetToLogicalPos(text, 6)).toEqual([1, 0]); // Start of 'world' (after \n)
+    expect(offsetToLogicalPos(text, 8)).toEqual([1, 2]); // 'r' in 'world'
+    expect(offsetToLogicalPos(text, 11)).toEqual([1, 5]); // End of 'world' (before \n)
+
+    // Line 2: "123" (length 3)
+    expect(offsetToLogicalPos(text, 12)).toEqual([2, 0]); // Start of '123' (after \n)
+    expect(offsetToLogicalPos(text, 13)).toEqual([2, 1]); // '2' in '123'
+    expect(offsetToLogicalPos(text, 15)).toEqual([2, 3]); // End of '123'
+    expect(offsetToLogicalPos(text, 20)).toEqual([2, 3]); // Beyond end of text
+  });
+
+  it('should handle empty lines', () => {
+    const text = 'a\n\nc'; // "a" (1) + \n (1) + "" (0) + \n (1) + "c" (1)
+    expect(offsetToLogicalPos(text, 0)).toEqual([0, 0]); // 'a'
+    expect(offsetToLogicalPos(text, 1)).toEqual([0, 1]); // End of 'a'
+    expect(offsetToLogicalPos(text, 2)).toEqual([1, 0]); // Start of empty line
+    expect(offsetToLogicalPos(text, 3)).toEqual([2, 0]); // Start of 'c'
+    expect(offsetToLogicalPos(text, 4)).toEqual([2, 1]); // End of 'c'
+  });
+
+  it('should handle text ending with a newline', () => {
+    const text = 'hello\n'; // "hello" (5) + \n (1)
+    expect(offsetToLogicalPos(text, 5)).toEqual([0, 5]); // End of 'hello'
+    expect(offsetToLogicalPos(text, 6)).toEqual([1, 0]); // Position on the new empty line after
+
+    expect(offsetToLogicalPos(text, 7)).toEqual([1, 0]); // Still on the new empty line
+  });
+
+  it('should handle text starting with a newline', () => {
+    const text = '\nhello'; // "" (0) + \n (1) + "hello" (5)
+    expect(offsetToLogicalPos(text, 0)).toEqual([0, 0]); // Start of first empty line
+    expect(offsetToLogicalPos(text, 1)).toEqual([1, 0]); // Start of 'hello'
+    expect(offsetToLogicalPos(text, 3)).toEqual([1, 2]); // 'l' in 'hello'
+  });
+
+  it('should handle empty string input', () => {
+    expect(offsetToLogicalPos('', 0)).toEqual([0, 0]);
+    expect(offsetToLogicalPos('', 5)).toEqual([0, 0]);
+  });
+
+  it('should handle multi-byte unicode characters correctly', () => {
+    const text = '你好\n世界'; // "你好" (2 chars) + \n (1) + "世界" (2 chars)
+    // Total "code points" for offset calculation: 2 + 1 + 2 = 5
+    expect(offsetToLogicalPos(text, 0)).toEqual([0, 0]); // Start of '你好'
+    expect(offsetToLogicalPos(text, 1)).toEqual([0, 1]); // After '你', before '好'
+    expect(offsetToLogicalPos(text, 2)).toEqual([0, 2]); // End of '你好'
+    expect(offsetToLogicalPos(text, 3)).toEqual([1, 0]); // Start of '世界'
+    expect(offsetToLogicalPos(text, 4)).toEqual([1, 1]); // After '世', before '界'
+    expect(offsetToLogicalPos(text, 5)).toEqual([1, 2]); // End of '世界'
+    expect(offsetToLogicalPos(text, 6)).toEqual([1, 2]); // Beyond end
+  });
+
+  it('should handle offset exactly at newline character', () => {
+    const text = 'abc\ndef';
+    // a b c \n d e f
+    // 0 1 2  3  4 5 6
+    expect(offsetToLogicalPos(text, 3)).toEqual([0, 3]); // End of 'abc'
+    // The next character is the newline, so an offset of 4 means the start of the next line.
+    expect(offsetToLogicalPos(text, 4)).toEqual([1, 0]); // Start of 'def'
+  });
+
+  it('should handle offset in the middle of a multi-byte character (should place at start of that char)', () => {
+    // This scenario is tricky as "offset" is usually character-based.
+    // Assuming cpLen and related logic handles this by treating multi-byte as one unit.
+    // The current implementation of offsetToLogicalPos uses cpLen, so it should be code-point aware.
+    const text = '🐶🐱'; // 2 code points
+    expect(offsetToLogicalPos(text, 0)).toEqual([0, 0]);
+    expect(offsetToLogicalPos(text, 1)).toEqual([0, 1]); // After 🐶
+    expect(offsetToLogicalPos(text, 2)).toEqual([0, 2]); // After 🐱
+  });
+});
+
+describe('logicalPosToOffset', () => {
+  it('should convert row/col position to offset correctly', () => {
+    const lines = ['hello', 'world', '123'];
+
+    // Line 0: "hello" (5 chars)
+    expect(logicalPosToOffset(lines, 0, 0)).toBe(0); // Start of 'hello'
+    expect(logicalPosToOffset(lines, 0, 3)).toBe(3); // 'l' in 'hello'
+    expect(logicalPosToOffset(lines, 0, 5)).toBe(5); // End of 'hello'
+
+    // Line 1: "world" (5 chars), offset starts at 6 (5 + 1 for newline)
+    expect(logicalPosToOffset(lines, 1, 0)).toBe(6); // Start of 'world'
+    expect(logicalPosToOffset(lines, 1, 2)).toBe(8); // 'r' in 'world'
+    expect(logicalPosToOffset(lines, 1, 5)).toBe(11); // End of 'world'
+
+    // Line 2: "123" (3 chars), offset starts at 12 (5 + 1 + 5 + 1)
+    expect(logicalPosToOffset(lines, 2, 0)).toBe(12); // Start of '123'
+    expect(logicalPosToOffset(lines, 2, 1)).toBe(13); // '2' in '123'
+    expect(logicalPosToOffset(lines, 2, 3)).toBe(15); // End of '123'
+  });
+
+  it('should handle empty lines', () => {
+    const lines = ['a', '', 'c'];
+
+    expect(logicalPosToOffset(lines, 0, 0)).toBe(0); // 'a'
+    expect(logicalPosToOffset(lines, 0, 1)).toBe(1); // End of 'a'
+    expect(logicalPosToOffset(lines, 1, 0)).toBe(2); // Empty line
+    expect(logicalPosToOffset(lines, 2, 0)).toBe(3); // 'c'
+    expect(logicalPosToOffset(lines, 2, 1)).toBe(4); // End of 'c'
+  });
+
+  it('should handle single empty line', () => {
+    const lines = [''];
+
+    expect(logicalPosToOffset(lines, 0, 0)).toBe(0);
+  });
+
+  it('should be inverse of offsetToLogicalPos', () => {
+    const lines = ['hello', 'world', '123'];
+    const text = lines.join('\n');
+
+    // Test round-trip conversion
+    for (let offset = 0; offset <= text.length; offset++) {
+      const [row, col] = offsetToLogicalPos(text, offset);
+      const convertedOffset = logicalPosToOffset(lines, row, col);
+      expect(convertedOffset).toBe(offset);
+    }
+  });
+
+  it('should handle out-of-bounds positions', () => {
+    const lines = ['hello'];
+
+    // Beyond end of line
+    expect(logicalPosToOffset(lines, 0, 10)).toBe(5); // Clamps to end of line
+
+    // Beyond array bounds - should clamp to the last line
+    expect(logicalPosToOffset(lines, 5, 0)).toBe(0); // Clamps to start of last line (row 0)
+    expect(logicalPosToOffset(lines, 5, 10)).toBe(5); // Clamps to end of last line
+  });
+});
+
+describe('textBufferReducer vim operations', () => {
+  describe('vim_delete_line', () => {
+    it('should delete a single line including newline in multi-line text', () => {
+      const initialState: TextBufferState = {
+        lines: ['line1', 'line2', 'line3'],
+        cursorRow: 1,
+        cursorCol: 2,
+        preferredCol: null,
+        visualLines: [['line1'], ['line2'], ['line3']],
+        visualScrollRow: 0,
+        visualCursor: { row: 1, col: 2 },
+        viewport: { width: 10, height: 5 },
+        undoStack: [],
+        redoStack: [],
+      };
+
+      const action: TextBufferAction = {
+        type: 'vim_delete_line',
+        payload: { count: 1 },
+      };
+
+      const result = textBufferReducer(initialState, action);
+      expect(result).toHaveOnlyValidCharacters();
+
+      // After deleting line2, we should have line1 and line3, with cursor on line3 (now at index 1)
+      expect(result.lines).toEqual(['line1', 'line3']);
+      expect(result.cursorRow).toBe(1);
+      expect(result.cursorCol).toBe(0);
+    });
+
+    it('should delete multiple lines when count > 1', () => {
+      const initialState: TextBufferState = {
+        lines: ['line1', 'line2', 'line3', 'line4'],
+        cursorRow: 1,
+        cursorCol: 0,
+        preferredCol: null,
+        visualLines: [['line1'], ['line2'], ['line3'], ['line4']],
+        visualScrollRow: 0,
+        visualCursor: { row: 1, col: 0 },
+        viewport: { width: 10, height: 5 },
+        undoStack: [],
+        redoStack: [],
+      };
+
+      const action: TextBufferAction = {
+        type: 'vim_delete_line',
+        payload: { count: 2 },
+      };
+
+      const result = textBufferReducer(initialState, action);
+      expect(result).toHaveOnlyValidCharacters();
+
+      // Should delete line2 and line3, leaving line1 and line4
+      expect(result.lines).toEqual(['line1', 'line4']);
+      expect(result.cursorRow).toBe(1);
+      expect(result.cursorCol).toBe(0);
+    });
+
+    it('should clear single line content when only one line exists', () => {
+      const initialState: TextBufferState = {
+        lines: ['only line'],
+        cursorRow: 0,
+        cursorCol: 5,
+        preferredCol: null,
+        visualLines: [['only line']],
+        visualScrollRow: 0,
+        visualCursor: { row: 0, col: 5 },
+        viewport: { width: 10, height: 5 },
+        undoStack: [],
+        redoStack: [],
+      };
+
+      const action: TextBufferAction = {
+        type: 'vim_delete_line',
+        payload: { count: 1 },
+      };
+
+      const result = textBufferReducer(initialState, action);
+      expect(result).toHaveOnlyValidCharacters();
+
+      // Should clear the line content but keep the line
+      expect(result.lines).toEqual(['']);
+      expect(result.cursorRow).toBe(0);
+      expect(result.cursorCol).toBe(0);
+    });
+
+    it('should handle deleting the last line properly', () => {
+      const initialState: TextBufferState = {
+        lines: ['line1', 'line2'],
+        cursorRow: 1,
+        cursorCol: 0,
+        preferredCol: null,
+        visualLines: [['line1'], ['line2']],
+        visualScrollRow: 0,
+        visualCursor: { row: 1, col: 0 },
+        viewport: { width: 10, height: 5 },
+        undoStack: [],
+        redoStack: [],
+      };
+
+      const action: TextBufferAction = {
+        type: 'vim_delete_line',
+        payload: { count: 1 },
+      };
+
+      const result = textBufferReducer(initialState, action);
+      expect(result).toHaveOnlyValidCharacters();
+
+      // Should delete the last line completely, not leave empty line
+      expect(result.lines).toEqual(['line1']);
+      expect(result.cursorRow).toBe(0);
+      expect(result.cursorCol).toBe(0);
+    });
+
+    it('should handle deleting all lines and maintain valid state for subsequent paste', () => {
+      const initialState: TextBufferState = {
+        lines: ['line1', 'line2', 'line3', 'line4'],
+        cursorRow: 0,
+        cursorCol: 0,
+        preferredCol: null,
+        visualLines: [['line1'], ['line2'], ['line3'], ['line4']],
+        visualScrollRow: 0,
+        visualCursor: { row: 0, col: 0 },
+        viewport: { width: 10, height: 5 },
+        undoStack: [],
+        redoStack: [],
+      };
+
+      // Delete all 4 lines with 4dd
+      const deleteAction: TextBufferAction = {
+        type: 'vim_delete_line',
+        payload: { count: 4 },
+      };
+
+      const afterDelete = textBufferReducer(initialState, deleteAction);
+      expect(afterDelete).toHaveOnlyValidCharacters();
+
+      // After deleting all lines, should have one empty line
+      expect(afterDelete.lines).toEqual(['']);
+      expect(afterDelete.cursorRow).toBe(0);
+      expect(afterDelete.cursorCol).toBe(0);
+
+      // Now paste multiline content - this should work correctly
+      const pasteAction: TextBufferAction = {
+        type: 'insert',
+        payload: 'new1\nnew2\nnew3\nnew4',
+      };
+
+      const afterPaste = textBufferReducer(afterDelete, pasteAction);
+      expect(afterPaste).toHaveOnlyValidCharacters();
+
+      // All lines including the first one should be present
+      expect(afterPaste.lines).toEqual(['new1', 'new2', 'new3', 'new4']);
+      expect(afterPaste.cursorRow).toBe(3);
+      expect(afterPaste.cursorCol).toBe(4);
+    });
+  });
+});
+
+describe('Unicode helper functions', () => {
+  describe('findWordEndInLine with Unicode', () => {
+    it('should handle combining characters', () => {
+      // café with combining accent
+      const cafeWithCombining = 'cafe\u0301';
+      const result = findWordEndInLine(cafeWithCombining + ' test', 0);
+      expect(result).toBe(3); // End of 'café' at base character 'e', not combining accent
+    });
+
+    it('should handle precomposed characters with diacritics', () => {
+      // café with precomposed é (U+00E9)
+      const cafePrecomposed = 'café';
+      const result = findWordEndInLine(cafePrecomposed + ' test', 0);
+      expect(result).toBe(3); // End of 'café' at precomposed character 'é'
+    });
+
+    it('should return null when no word end found', () => {
+      const result = findWordEndInLine('   ', 0);
+      expect(result).toBeNull(); // No word end found in whitespace-only string string
+    });
+  });
+
+  describe('findNextWordStartInLine with Unicode', () => {
+    it('should handle right-to-left text', () => {
+      const result = findNextWordStartInLine('hello مرحبا world', 0);
+      expect(result).toBe(6); // Start of Arabic word
+    });
+
+    it('should handle Chinese characters', () => {
+      const result = findNextWordStartInLine('hello 你好 world', 0);
+      expect(result).toBe(6); // Start of Chinese word
+    });
+
+    it('should return null at end of line', () => {
+      const result = findNextWordStartInLine('hello', 10);
+      expect(result).toBeNull();
+    });
+
+    it('should handle combining characters', () => {
+      // café with combining accent + next word
+      const textWithCombining = 'cafe\u0301 test';
+      const result = findNextWordStartInLine(textWithCombining, 0);
+      expect(result).toBe(6); // Start of 'test' after 'café ' (combining char makes string longer)
+    });
+
+    it('should handle precomposed characters with diacritics', () => {
+      // café with precomposed é + next word
+      const textPrecomposed = 'café test';
+      const result = findNextWordStartInLine(textPrecomposed, 0);
+      expect(result).toBe(5); // Start of 'test' after 'café '
+    });
+  });
+
+  describe('isWordCharStrict with Unicode', () => {
+    it('should return true for ASCII word characters', () => {
+      expect(isWordCharStrict('a')).toBe(true);
+      expect(isWordCharStrict('Z')).toBe(true);
+      expect(isWordCharStrict('0')).toBe(true);
+      expect(isWordCharStrict('_')).toBe(true);
+    });
+
+    it('should return false for punctuation', () => {
+      expect(isWordCharStrict('.')).toBe(false);
+      expect(isWordCharStrict(',')).toBe(false);
+      expect(isWordCharStrict('!')).toBe(false);
+    });
+
+    it('should return true for non-Latin scripts', () => {
+      expect(isWordCharStrict('你')).toBe(true); // Chinese character
+      expect(isWordCharStrict('م')).toBe(true); // Arabic character
+    });
+
+    it('should return false for whitespace', () => {
+      expect(isWordCharStrict(' ')).toBe(false);
+      expect(isWordCharStrict('\t')).toBe(false);
+    });
+  });
+
+  describe('cpLen with Unicode', () => {
+    it('should handle combining characters', () => {
+      expect(cpLen('é')).toBe(1); // Precomposed
+      expect(cpLen('e\u0301')).toBe(2); // e + combining acute
+    });
+
+    it('should handle Chinese and Arabic text', () => {
+      expect(cpLen('hello 你好 world')).toBe(14); // 5 + 1 + 2 + 1 + 5 = 14
+      expect(cpLen('hello مرحبا world')).toBe(17);
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/components/shared/text-buffer.ts

@@ -0,0 +1,2227 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import stripAnsi from 'strip-ansi';
+import { stripVTControlCharacters } from 'util';
+import { spawnSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import pathMod from 'path';
+import { useState, useCallback, useEffect, useMemo, useReducer } from 'react';
+import stringWidth from 'string-width';
+import { unescapePath } from '@qwen-code/qwen-code-core';
+import { toCodePoints, cpLen, cpSlice } from '../../utils/textUtils.js';
+import { handleVimAction, VimAction } from './vim-buffer-actions.js';
+
+export type Direction =
+  | 'left'
+  | 'right'
+  | 'up'
+  | 'down'
+  | 'wordLeft'
+  | 'wordRight'
+  | 'home'
+  | 'end';
+
+// Simple helper for word‑wise ops.
+function isWordChar(ch: string | undefined): boolean {
+  if (ch === undefined) {
+    return false;
+  }
+  return !/[\s,.;!?]/.test(ch);
+}
+
+// Helper functions for line-based word navigation
+export const isWordCharStrict = (char: string): boolean =>
+  /[\w\p{L}\p{N}]/u.test(char); // Matches a single character that is any Unicode letter, any Unicode number, or an underscore
+
+export const isWhitespace = (char: string): boolean => /\s/.test(char);
+
+// Check if a character is a combining mark (only diacritics for now)
+export const isCombiningMark = (char: string): boolean => /\p{M}/u.test(char);
+
+// Check if a character should be considered part of a word (including combining marks)
+export const isWordCharWithCombining = (char: string): boolean =>
+  isWordCharStrict(char) || isCombiningMark(char);
+
+// Get the script of a character (simplified for common scripts)
+export const getCharScript = (char: string): string => {
+  if (/[\p{Script=Latin}]/u.test(char)) return 'latin'; // All Latin script chars including diacritics
+  if (/[\p{Script=Han}]/u.test(char)) return 'han'; // Chinese
+  if (/[\p{Script=Arabic}]/u.test(char)) return 'arabic';
+  if (/[\p{Script=Hiragana}]/u.test(char)) return 'hiragana';
+  if (/[\p{Script=Katakana}]/u.test(char)) return 'katakana';
+  if (/[\p{Script=Cyrillic}]/u.test(char)) return 'cyrillic';
+  return 'other';
+};
+
+// Check if two characters are from different scripts (indicating word boundary)
+export const isDifferentScript = (char1: string, char2: string): boolean => {
+  if (!isWordCharStrict(char1) || !isWordCharStrict(char2)) return false;
+  return getCharScript(char1) !== getCharScript(char2);
+};
+
+// Find next word start within a line, starting from col
+export const findNextWordStartInLine = (
+  line: string,
+  col: number,
+): number | null => {
+  const chars = toCodePoints(line);
+  let i = col;
+
+  if (i >= chars.length) return null;
+
+  const currentChar = chars[i];
+
+  // Skip current word/sequence based on character type
+  if (isWordCharStrict(currentChar)) {
+    while (i < chars.length && isWordCharWithCombining(chars[i])) {
+      // Check for script boundary - if next character is from different script, stop here
+      if (
+        i + 1 < chars.length &&
+        isWordCharStrict(chars[i + 1]) &&
+        isDifferentScript(chars[i], chars[i + 1])
+      ) {
+        i++; // Include current character
+        break; // Stop at script boundary
+      }
+      i++;
+    }
+  } else if (!isWhitespace(currentChar)) {
+    while (
+      i < chars.length &&
+      !isWordCharStrict(chars[i]) &&
+      !isWhitespace(chars[i])
+    ) {
+      i++;
+    }
+  }
+
+  // Skip whitespace
+  while (i < chars.length && isWhitespace(chars[i])) {
+    i++;
+  }
+
+  return i < chars.length ? i : null;
+};
+
+// Find previous word start within a line
+export const findPrevWordStartInLine = (
+  line: string,
+  col: number,
+): number | null => {
+  const chars = toCodePoints(line);
+  let i = col;
+
+  if (i <= 0) return null;
+
+  i--;
+
+  // Skip whitespace moving backwards
+  while (i >= 0 && isWhitespace(chars[i])) {
+    i--;
+  }
+
+  if (i < 0) return null;
+
+  if (isWordCharStrict(chars[i])) {
+    // We're in a word, move to its beginning
+    while (i >= 0 && isWordCharStrict(chars[i])) {
+      // Check for script boundary - if previous character is from different script, stop here
+      if (
+        i - 1 >= 0 &&
+        isWordCharStrict(chars[i - 1]) &&
+        isDifferentScript(chars[i], chars[i - 1])
+      ) {
+        return i; // Return current position at script boundary
+      }
+      i--;
+    }
+    return i + 1;
+  } else {
+    // We're in punctuation, move to its beginning
+    while (i >= 0 && !isWordCharStrict(chars[i]) && !isWhitespace(chars[i])) {
+      i--;
+    }
+    return i + 1;
+  }
+};
+
+// Find word end within a line
+export const findWordEndInLine = (line: string, col: number): number | null => {
+  const chars = toCodePoints(line);
+  let i = col;
+
+  // If we're already at the end of a word (including punctuation sequences), advance to next word
+  // This includes both regular word endings and script boundaries
+  const atEndOfWordChar =
+    i < chars.length &&
+    isWordCharWithCombining(chars[i]) &&
+    (i + 1 >= chars.length ||
+      !isWordCharWithCombining(chars[i + 1]) ||
+      (isWordCharStrict(chars[i]) &&
+        i + 1 < chars.length &&
+        isWordCharStrict(chars[i + 1]) &&
+        isDifferentScript(chars[i], chars[i + 1])));
+
+  const atEndOfPunctuation =
+    i < chars.length &&
+    !isWordCharWithCombining(chars[i]) &&
+    !isWhitespace(chars[i]) &&
+    (i + 1 >= chars.length ||
+      isWhitespace(chars[i + 1]) ||
+      isWordCharWithCombining(chars[i + 1]));
+
+  if (atEndOfWordChar || atEndOfPunctuation) {
+    // We're at the end of a word or punctuation sequence, move forward to find next word
+    i++;
+    // Skip whitespace to find next word or punctuation
+    while (i < chars.length && isWhitespace(chars[i])) {
+      i++;
+    }
+  }
+
+  // If we're not on a word character, find the next word or punctuation sequence
+  if (i < chars.length && !isWordCharWithCombining(chars[i])) {
+    // Skip whitespace to find next word or punctuation
+    while (i < chars.length && isWhitespace(chars[i])) {
+      i++;
+    }
+  }
+
+  // Move to end of current word (including combining marks, but stop at script boundaries)
+  let foundWord = false;
+  let lastBaseCharPos = -1;
+
+  if (i < chars.length && isWordCharWithCombining(chars[i])) {
+    // Handle word characters
+    while (i < chars.length && isWordCharWithCombining(chars[i])) {
+      foundWord = true;
+
+      // Track the position of the last base character (not combining mark)
+      if (isWordCharStrict(chars[i])) {
+        lastBaseCharPos = i;
+      }
+
+      // Check if next character is from a different script (word boundary)
+      if (
+        i + 1 < chars.length &&
+        isWordCharStrict(chars[i + 1]) &&
+        isDifferentScript(chars[i], chars[i + 1])
+      ) {
+        i++; // Include current character
+        if (isWordCharStrict(chars[i - 1])) {
+          lastBaseCharPos = i - 1;
+        }
+        break; // Stop at script boundary
+      }
+
+      i++;
+    }
+  } else if (i < chars.length && !isWhitespace(chars[i])) {
+    // Handle punctuation sequences (like ████)
+    while (
+      i < chars.length &&
+      !isWordCharStrict(chars[i]) &&
+      !isWhitespace(chars[i])
+    ) {
+      foundWord = true;
+      lastBaseCharPos = i;
+      i++;
+    }
+  }
+
+  // Only return a position if we actually found a word
+  // Return the position of the last base character, not combining marks
+  if (foundWord && lastBaseCharPos >= col) {
+    return lastBaseCharPos;
+  }
+
+  return null;
+};
+
+// Find next word across lines
+export const findNextWordAcrossLines = (
+  lines: string[],
+  cursorRow: number,
+  cursorCol: number,
+  searchForWordStart: boolean,
+): { row: number; col: number } | null => {
+  // First try current line
+  const currentLine = lines[cursorRow] || '';
+  const colInCurrentLine = searchForWordStart
+    ? findNextWordStartInLine(currentLine, cursorCol)
+    : findWordEndInLine(currentLine, cursorCol);
+
+  if (colInCurrentLine !== null) {
+    return { row: cursorRow, col: colInCurrentLine };
+  }
+
+  // Search subsequent lines
+  for (let row = cursorRow + 1; row < lines.length; row++) {
+    const line = lines[row] || '';
+    const chars = toCodePoints(line);
+
+    // For empty lines, if we haven't found any words yet, return the empty line
+    if (chars.length === 0) {
+      // Check if there are any words in remaining lines
+      let hasWordsInLaterLines = false;
+      for (let laterRow = row + 1; laterRow < lines.length; laterRow++) {
+        const laterLine = lines[laterRow] || '';
+        const laterChars = toCodePoints(laterLine);
+        let firstNonWhitespace = 0;
+        while (
+          firstNonWhitespace < laterChars.length &&
+          isWhitespace(laterChars[firstNonWhitespace])
+        ) {
+          firstNonWhitespace++;
+        }
+        if (firstNonWhitespace < laterChars.length) {
+          hasWordsInLaterLines = true;
+          break;
+        }
+      }
+
+      // If no words in later lines, return the empty line
+      if (!hasWordsInLaterLines) {
+        return { row, col: 0 };
+      }
+      continue;
+    }
+
+    // Find first non-whitespace
+    let firstNonWhitespace = 0;
+    while (
+      firstNonWhitespace < chars.length &&
+      isWhitespace(chars[firstNonWhitespace])
+    ) {
+      firstNonWhitespace++;
+    }
+
+    if (firstNonWhitespace < chars.length) {
+      if (searchForWordStart) {
+        return { row, col: firstNonWhitespace };
+      } else {
+        // For word end, find the end of the first word
+        const endCol = findWordEndInLine(line, firstNonWhitespace);
+        if (endCol !== null) {
+          return { row, col: endCol };
+        }
+      }
+    }
+  }
+
+  return null;
+};
+
+// Find previous word across lines
+export const findPrevWordAcrossLines = (
+  lines: string[],
+  cursorRow: number,
+  cursorCol: number,
+): { row: number; col: number } | null => {
+  // First try current line
+  const currentLine = lines[cursorRow] || '';
+  const colInCurrentLine = findPrevWordStartInLine(currentLine, cursorCol);
+
+  if (colInCurrentLine !== null) {
+    return { row: cursorRow, col: colInCurrentLine };
+  }
+
+  // Search previous lines
+  for (let row = cursorRow - 1; row >= 0; row--) {
+    const line = lines[row] || '';
+    const chars = toCodePoints(line);
+
+    if (chars.length === 0) continue;
+
+    // Find last word start
+    let lastWordStart = chars.length;
+    while (lastWordStart > 0 && isWhitespace(chars[lastWordStart - 1])) {
+      lastWordStart--;
+    }
+
+    if (lastWordStart > 0) {
+      // Find start of this word
+      const wordStart = findPrevWordStartInLine(line, lastWordStart);
+      if (wordStart !== null) {
+        return { row, col: wordStart };
+      }
+    }
+  }
+
+  return null;
+};
+
+// Helper functions for vim line operations
+export const getPositionFromOffsets = (
+  startOffset: number,
+  endOffset: number,
+  lines: string[],
+) => {
+  let offset = 0;
+  let startRow = 0;
+  let startCol = 0;
+  let endRow = 0;
+  let endCol = 0;
+
+  // Find start position
+  for (let i = 0; i < lines.length; i++) {
+    const lineLength = lines[i].length + 1; // +1 for newline
+    if (offset + lineLength > startOffset) {
+      startRow = i;
+      startCol = startOffset - offset;
+      break;
+    }
+    offset += lineLength;
+  }
+
+  // Find end position
+  offset = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const lineLength = lines[i].length + (i < lines.length - 1 ? 1 : 0); // +1 for newline except last line
+    if (offset + lineLength >= endOffset) {
+      endRow = i;
+      endCol = endOffset - offset;
+      break;
+    }
+    offset += lineLength;
+  }
+
+  return { startRow, startCol, endRow, endCol };
+};
+
+export const getLineRangeOffsets = (
+  startRow: number,
+  lineCount: number,
+  lines: string[],
+) => {
+  let startOffset = 0;
+
+  // Calculate start offset
+  for (let i = 0; i < startRow; i++) {
+    startOffset += lines[i].length + 1; // +1 for newline
+  }
+
+  // Calculate end offset
+  let endOffset = startOffset;
+  for (let i = 0; i < lineCount; i++) {
+    const lineIndex = startRow + i;
+    if (lineIndex < lines.length) {
+      endOffset += lines[lineIndex].length;
+      if (lineIndex < lines.length - 1) {
+        endOffset += 1; // +1 for newline
+      }
+    }
+  }
+
+  return { startOffset, endOffset };
+};
+
+export const replaceRangeInternal = (
+  state: TextBufferState,
+  startRow: number,
+  startCol: number,
+  endRow: number,
+  endCol: number,
+  text: string,
+): TextBufferState => {
+  const currentLine = (row: number) => state.lines[row] || '';
+  const currentLineLen = (row: number) => cpLen(currentLine(row));
+  const clamp = (value: number, min: number, max: number) =>
+    Math.min(Math.max(value, min), max);
+
+  if (
+    startRow > endRow ||
+    (startRow === endRow && startCol > endCol) ||
+    startRow < 0 ||
+    startCol < 0 ||
+    endRow >= state.lines.length ||
+    (endRow < state.lines.length && endCol > currentLineLen(endRow))
+  ) {
+    return state; // Invalid range
+  }
+
+  const newLines = [...state.lines];
+
+  const sCol = clamp(startCol, 0, currentLineLen(startRow));
+  const eCol = clamp(endCol, 0, currentLineLen(endRow));
+
+  const prefix = cpSlice(currentLine(startRow), 0, sCol);
+  const suffix = cpSlice(currentLine(endRow), eCol);
+
+  const normalisedReplacement = text
+    .replace(/\r\n/g, '\n')
+    .replace(/\r/g, '\n');
+  const replacementParts = normalisedReplacement.split('\n');
+
+  // The combined first line of the new text
+  const firstLine = prefix + replacementParts[0];
+
+  if (replacementParts.length === 1) {
+    // No newlines in replacement: combine prefix, replacement, and suffix on one line.
+    newLines.splice(startRow, endRow - startRow + 1, firstLine + suffix);
+  } else {
+    // Newlines in replacement: create new lines.
+    const lastLine = replacementParts[replacementParts.length - 1] + suffix;
+    const middleLines = replacementParts.slice(1, -1);
+    newLines.splice(
+      startRow,
+      endRow - startRow + 1,
+      firstLine,
+      ...middleLines,
+      lastLine,
+    );
+  }
+
+  const finalCursorRow = startRow + replacementParts.length - 1;
+  const finalCursorCol =
+    (replacementParts.length > 1 ? 0 : sCol) +
+    cpLen(replacementParts[replacementParts.length - 1]);
+
+  return {
+    ...state,
+    lines: newLines,
+    cursorRow: Math.min(Math.max(finalCursorRow, 0), newLines.length - 1),
+    cursorCol: Math.max(
+      0,
+      Math.min(finalCursorCol, cpLen(newLines[finalCursorRow] || '')),
+    ),
+    preferredCol: null,
+  };
+};
+
+/**
+ * Strip characters that can break terminal rendering.
+ *
+ * Uses Node.js built-in stripVTControlCharacters to handle VT sequences,
+ * then filters remaining control characters that can disrupt display.
+ *
+ * Characters stripped:
+ * - ANSI escape sequences (via strip-ansi)
+ * - VT control sequences (via Node.js util.stripVTControlCharacters)
+ * - C0 control chars (0x00-0x1F) except CR/LF which are handled elsewhere
+ * - C1 control chars (0x80-0x9F) that can cause display issues
+ *
+ * Characters preserved:
+ * - All printable Unicode including emojis
+ * - DEL (0x7F) - handled functionally by applyOperations, not a display issue
+ * - CR/LF (0x0D/0x0A) - needed for line breaks
+ */
+function stripUnsafeCharacters(str: string): string {
+  const strippedAnsi = stripAnsi(str);
+  const strippedVT = stripVTControlCharacters(strippedAnsi);
+
+  return toCodePoints(strippedVT)
+    .filter((char) => {
+      const code = char.codePointAt(0);
+      if (code === undefined) return false;
+
+      // Preserve CR/LF for line handling
+      if (code === 0x0a || code === 0x0d) return true;
+
+      // Remove C0 control chars (except CR/LF) that can break display
+      // Examples: BELL(0x07) makes noise, BS(0x08) moves cursor, VT(0x0B), FF(0x0C)
+      if (code >= 0x00 && code <= 0x1f) return false;
+
+      // Remove C1 control chars (0x80-0x9F) - legacy 8-bit control codes
+      if (code >= 0x80 && code <= 0x9f) return false;
+
+      // Preserve DEL (0x7F) - it's handled functionally by applyOperations as backspace
+      // and doesn't cause rendering issues when displayed
+
+      // Preserve all other characters including Unicode/emojis
+      return true;
+    })
+    .join('');
+}
+
+export interface Viewport {
+  height: number;
+  width: number;
+}
+
+function clamp(v: number, min: number, max: number): number {
+  return v < min ? min : v > max ? max : v;
+}
+
+/* ────────────────────────────────────────────────────────────────────────── */
+
+interface UseTextBufferProps {
+  initialText?: string;
+  initialCursorOffset?: number;
+  viewport: Viewport; // Viewport dimensions needed for scrolling
+  stdin?: NodeJS.ReadStream | null; // For external editor
+  setRawMode?: (mode: boolean) => void; // For external editor
+  onChange?: (text: string) => void; // Callback for when text changes
+  isValidPath: (path: string) => boolean;
+  shellModeActive?: boolean; // Whether the text buffer is in shell mode
+}
+
+interface UndoHistoryEntry {
+  lines: string[];
+  cursorRow: number;
+  cursorCol: number;
+}
+
+function calculateInitialCursorPosition(
+  initialLines: string[],
+  offset: number,
+): [number, number] {
+  let remainingChars = offset;
+  let row = 0;
+  while (row < initialLines.length) {
+    const lineLength = cpLen(initialLines[row]);
+    // Add 1 for the newline character (except for the last line)
+    const totalCharsInLineAndNewline =
+      lineLength + (row < initialLines.length - 1 ? 1 : 0);
+
+    if (remainingChars <= lineLength) {
+      // Cursor is on this line
+      return [row, remainingChars];
+    }
+    remainingChars -= totalCharsInLineAndNewline;
+    row++;
+  }
+  // Offset is beyond the text, place cursor at the end of the last line
+  if (initialLines.length > 0) {
+    const lastRow = initialLines.length - 1;
+    return [lastRow, cpLen(initialLines[lastRow])];
+  }
+  return [0, 0]; // Default for empty text
+}
+
+export function offsetToLogicalPos(
+  text: string,
+  offset: number,
+): [number, number] {
+  let row = 0;
+  let col = 0;
+  let currentOffset = 0;
+
+  if (offset === 0) return [0, 0];
+
+  const lines = text.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineLength = cpLen(line);
+    const lineLengthWithNewline = lineLength + (i < lines.length - 1 ? 1 : 0);
+
+    if (offset <= currentOffset + lineLength) {
+      // Check against lineLength first
+      row = i;
+      col = offset - currentOffset;
+      return [row, col];
+    } else if (offset <= currentOffset + lineLengthWithNewline) {
+      // Check if offset is the newline itself
+      row = i;
+      col = lineLength; // Position cursor at the end of the current line content
+      // If the offset IS the newline, and it's not the last line, advance to next line, col 0
+      if (
+        offset === currentOffset + lineLengthWithNewline &&
+        i < lines.length - 1
+      ) {
+        return [i + 1, 0];
+      }
+      return [row, col]; // Otherwise, it's at the end of the current line content
+    }
+    currentOffset += lineLengthWithNewline;
+  }
+
+  // If offset is beyond the text length, place cursor at the end of the last line
+  // or [0,0] if text is empty
+  if (lines.length > 0) {
+    row = lines.length - 1;
+    col = cpLen(lines[row]);
+  } else {
+    row = 0;
+    col = 0;
+  }
+  return [row, col];
+}
+
+/**
+ * Converts logical row/col position to absolute text offset
+ * Inverse operation of offsetToLogicalPos
+ */
+export function logicalPosToOffset(
+  lines: string[],
+  row: number,
+  col: number,
+): number {
+  let offset = 0;
+
+  // Clamp row to valid range
+  const actualRow = Math.min(row, lines.length - 1);
+
+  // Add lengths of all lines before the target row
+  for (let i = 0; i < actualRow; i++) {
+    offset += cpLen(lines[i]) + 1; // +1 for newline
+  }
+
+  // Add column offset within the target row
+  if (actualRow >= 0 && actualRow < lines.length) {
+    offset += Math.min(col, cpLen(lines[actualRow]));
+  }
+
+  return offset;
+}
+
+// Helper to calculate visual lines and map cursor positions
+function calculateVisualLayout(
+  logicalLines: string[],
+  logicalCursor: [number, number],
+  viewportWidth: number,
+): {
+  visualLines: string[];
+  visualCursor: [number, number];
+  logicalToVisualMap: Array<Array<[number, number]>>; // For each logical line, an array of [visualLineIndex, startColInLogical]
+  visualToLogicalMap: Array<[number, number]>; // For each visual line, its [logicalLineIndex, startColInLogical]
+} {
+  const visualLines: string[] = [];
+  const logicalToVisualMap: Array<Array<[number, number]>> = [];
+  const visualToLogicalMap: Array<[number, number]> = [];
+  let currentVisualCursor: [number, number] = [0, 0];
+
+  logicalLines.forEach((logLine, logIndex) => {
+    logicalToVisualMap[logIndex] = [];
+    if (logLine.length === 0) {
+      // Handle empty logical line
+      logicalToVisualMap[logIndex].push([visualLines.length, 0]);
+      visualToLogicalMap.push([logIndex, 0]);
+      visualLines.push('');
+      if (logIndex === logicalCursor[0] && logicalCursor[1] === 0) {
+        currentVisualCursor = [visualLines.length - 1, 0];
+      }
+    } else {
+      // Non-empty logical line
+      let currentPosInLogLine = 0; // Tracks position within the current logical line (code point index)
+      const codePointsInLogLine = toCodePoints(logLine);
+
+      while (currentPosInLogLine < codePointsInLogLine.length) {
+        let currentChunk = '';
+        let currentChunkVisualWidth = 0;
+        let numCodePointsInChunk = 0;
+        let lastWordBreakPoint = -1; // Index in codePointsInLogLine for word break
+        let numCodePointsAtLastWordBreak = 0;
+
+        // Iterate through code points to build the current visual line (chunk)
+        for (let i = currentPosInLogLine; i < codePointsInLogLine.length; i++) {
+          const char = codePointsInLogLine[i];
+          const charVisualWidth = stringWidth(char);
+
+          if (currentChunkVisualWidth + charVisualWidth > viewportWidth) {
+            // Character would exceed viewport width
+            if (
+              lastWordBreakPoint !== -1 &&
+              numCodePointsAtLastWordBreak > 0 &&
+              currentPosInLogLine + numCodePointsAtLastWordBreak < i
+            ) {
+              // We have a valid word break point to use, and it's not the start of the current segment
+              currentChunk = codePointsInLogLine
+                .slice(
+                  currentPosInLogLine,
+                  currentPosInLogLine + numCodePointsAtLastWordBreak,
+                )
+                .join('');
+              numCodePointsInChunk = numCodePointsAtLastWordBreak;
+            } else {
+              // No word break, or word break is at the start of this potential chunk, or word break leads to empty chunk.
+              // Hard break: take characters up to viewportWidth, or just the current char if it alone is too wide.
+              if (
+                numCodePointsInChunk === 0 &&
+                charVisualWidth > viewportWidth
+              ) {
+                // Single character is wider than viewport, take it anyway
+                currentChunk = char;
+                numCodePointsInChunk = 1;
+              } else if (
+                numCodePointsInChunk === 0 &&
+                charVisualWidth <= viewportWidth
+              ) {
+                // This case should ideally be caught by the next iteration if the char fits.
+                // If it doesn't fit (because currentChunkVisualWidth was already > 0 from a previous char that filled the line),
+                // then numCodePointsInChunk would not be 0.
+                // This branch means the current char *itself* doesn't fit an empty line, which is handled by the above.
+                // If we are here, it means the loop should break and the current chunk (which is empty) is finalized.
+              }
+            }
+            break; // Break from inner loop to finalize this chunk
+          }
+
+          currentChunk += char;
+          currentChunkVisualWidth += charVisualWidth;
+          numCodePointsInChunk++;
+
+          // Check for word break opportunity (space)
+          if (char === ' ') {
+            lastWordBreakPoint = i; // Store code point index of the space
+            // Store the state *before* adding the space, if we decide to break here.
+            numCodePointsAtLastWordBreak = numCodePointsInChunk - 1; // Chars *before* the space
+          }
+        }
+
+        // If the inner loop completed without breaking (i.e., remaining text fits)
+        // or if the loop broke but numCodePointsInChunk is still 0 (e.g. first char too wide for empty line)
+        if (
+          numCodePointsInChunk === 0 &&
+          currentPosInLogLine < codePointsInLogLine.length
+        ) {
+          // This can happen if the very first character considered for a new visual line is wider than the viewport.
+          // In this case, we take that single character.
+          const firstChar = codePointsInLogLine[currentPosInLogLine];
+          currentChunk = firstChar;
+          numCodePointsInChunk = 1; // Ensure we advance
+        }
+
+        // If after everything, numCodePointsInChunk is still 0 but we haven't processed the whole logical line,
+        // it implies an issue, like viewportWidth being 0 or less. Avoid infinite loop.
+        if (
+          numCodePointsInChunk === 0 &&
+          currentPosInLogLine < codePointsInLogLine.length
+        ) {
+          // Force advance by one character to prevent infinite loop if something went wrong
+          currentChunk = codePointsInLogLine[currentPosInLogLine];
+          numCodePointsInChunk = 1;
+        }
+
+        logicalToVisualMap[logIndex].push([
+          visualLines.length,
+          currentPosInLogLine,
+        ]);
+        visualToLogicalMap.push([logIndex, currentPosInLogLine]);
+        visualLines.push(currentChunk);
+
+        // Cursor mapping logic
+        // Note: currentPosInLogLine here is the start of the currentChunk within the logical line.
+        if (logIndex === logicalCursor[0]) {
+          const cursorLogCol = logicalCursor[1]; // This is a code point index
+          if (
+            cursorLogCol >= currentPosInLogLine &&
+            cursorLogCol < currentPosInLogLine + numCodePointsInChunk // Cursor is within this chunk
+          ) {
+            currentVisualCursor = [
+              visualLines.length - 1,
+              cursorLogCol - currentPosInLogLine, // Visual col is also code point index within visual line
+            ];
+          } else if (
+            cursorLogCol === currentPosInLogLine + numCodePointsInChunk &&
+            numCodePointsInChunk > 0
+          ) {
+            // Cursor is exactly at the end of this non-empty chunk
+            currentVisualCursor = [
+              visualLines.length - 1,
+              numCodePointsInChunk,
+            ];
+          }
+        }
+
+        const logicalStartOfThisChunk = currentPosInLogLine;
+        currentPosInLogLine += numCodePointsInChunk;
+
+        // If the chunk processed did not consume the entire logical line,
+        // and the character immediately following the chunk is a space,
+        // advance past this space as it acted as a delimiter for word wrapping.
+        if (
+          logicalStartOfThisChunk + numCodePointsInChunk <
+            codePointsInLogLine.length &&
+          currentPosInLogLine < codePointsInLogLine.length && // Redundant if previous is true, but safe
+          codePointsInLogLine[currentPosInLogLine] === ' '
+        ) {
+          currentPosInLogLine++;
+        }
+      }
+      // After all chunks of a non-empty logical line are processed,
+      // if the cursor is at the very end of this logical line, update visual cursor.
+      if (
+        logIndex === logicalCursor[0] &&
+        logicalCursor[1] === codePointsInLogLine.length // Cursor at end of logical line
+      ) {
+        const lastVisualLineIdx = visualLines.length - 1;
+        if (
+          lastVisualLineIdx >= 0 &&
+          visualLines[lastVisualLineIdx] !== undefined
+        ) {
+          currentVisualCursor = [
+            lastVisualLineIdx,
+            cpLen(visualLines[lastVisualLineIdx]), // Cursor at end of last visual line for this logical line
+          ];
+        }
+      }
+    }
+  });
+
+  // If the entire logical text was empty, ensure there's one empty visual line.
+  if (
+    logicalLines.length === 0 ||
+    (logicalLines.length === 1 && logicalLines[0] === '')
+  ) {
+    if (visualLines.length === 0) {
+      visualLines.push('');
+      if (!logicalToVisualMap[0]) logicalToVisualMap[0] = [];
+      logicalToVisualMap[0].push([0, 0]);
+      visualToLogicalMap.push([0, 0]);
+    }
+    currentVisualCursor = [0, 0];
+  }
+  // Handle cursor at the very end of the text (after all processing)
+  // This case might be covered by the loop end condition now, but kept for safety.
+  else if (
+    logicalCursor[0] === logicalLines.length - 1 &&
+    logicalCursor[1] === cpLen(logicalLines[logicalLines.length - 1]) &&
+    visualLines.length > 0
+  ) {
+    const lastVisLineIdx = visualLines.length - 1;
+    currentVisualCursor = [lastVisLineIdx, cpLen(visualLines[lastVisLineIdx])];
+  }
+
+  return {
+    visualLines,
+    visualCursor: currentVisualCursor,
+    logicalToVisualMap,
+    visualToLogicalMap,
+  };
+}
+
+// --- Start of reducer logic ---
+
+export interface TextBufferState {
+  lines: string[];
+  cursorRow: number;
+  cursorCol: number;
+  preferredCol: number | null; // This is visual preferred col
+  undoStack: UndoHistoryEntry[];
+  redoStack: UndoHistoryEntry[];
+  clipboard: string | null;
+  selectionAnchor: [number, number] | null;
+  viewportWidth: number;
+}
+
+const historyLimit = 100;
+
+export const pushUndo = (currentState: TextBufferState): TextBufferState => {
+  const snapshot = {
+    lines: [...currentState.lines],
+    cursorRow: currentState.cursorRow,
+    cursorCol: currentState.cursorCol,
+  };
+  const newStack = [...currentState.undoStack, snapshot];
+  if (newStack.length > historyLimit) {
+    newStack.shift();
+  }
+  return { ...currentState, undoStack: newStack, redoStack: [] };
+};
+
+export type TextBufferAction =
+  | { type: 'set_text'; payload: string; pushToUndo?: boolean }
+  | { type: 'insert'; payload: string }
+  | { type: 'backspace' }
+  | {
+      type: 'move';
+      payload: {
+        dir: Direction;
+      };
+    }
+  | { type: 'delete' }
+  | { type: 'delete_word_left' }
+  | { type: 'delete_word_right' }
+  | { type: 'kill_line_right' }
+  | { type: 'kill_line_left' }
+  | { type: 'undo' }
+  | { type: 'redo' }
+  | {
+      type: 'replace_range';
+      payload: {
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+        text: string;
+      };
+    }
+  | { type: 'move_to_offset'; payload: { offset: number } }
+  | { type: 'create_undo_snapshot' }
+  | { type: 'set_viewport_width'; payload: number }
+  | { type: 'vim_delete_word_forward'; payload: { count: number } }
+  | { type: 'vim_delete_word_backward'; payload: { count: number } }
+  | { type: 'vim_delete_word_end'; payload: { count: number } }
+  | { type: 'vim_change_word_forward'; payload: { count: number } }
+  | { type: 'vim_change_word_backward'; payload: { count: number } }
+  | { type: 'vim_change_word_end'; payload: { count: number } }
+  | { type: 'vim_delete_line'; payload: { count: number } }
+  | { type: 'vim_change_line'; payload: { count: number } }
+  | { type: 'vim_delete_to_end_of_line' }
+  | { type: 'vim_change_to_end_of_line' }
+  | {
+      type: 'vim_change_movement';
+      payload: { movement: 'h' | 'j' | 'k' | 'l'; count: number };
+    }
+  // New vim actions for stateless command handling
+  | { type: 'vim_move_left'; payload: { count: number } }
+  | { type: 'vim_move_right'; payload: { count: number } }
+  | { type: 'vim_move_up'; payload: { count: number } }
+  | { type: 'vim_move_down'; payload: { count: number } }
+  | { type: 'vim_move_word_forward'; payload: { count: number } }
+  | { type: 'vim_move_word_backward'; payload: { count: number } }
+  | { type: 'vim_move_word_end'; payload: { count: number } }
+  | { type: 'vim_delete_char'; payload: { count: number } }
+  | { type: 'vim_insert_at_cursor' }
+  | { type: 'vim_append_at_cursor' }
+  | { type: 'vim_open_line_below' }
+  | { type: 'vim_open_line_above' }
+  | { type: 'vim_append_at_line_end' }
+  | { type: 'vim_insert_at_line_start' }
+  | { type: 'vim_move_to_line_start' }
+  | { type: 'vim_move_to_line_end' }
+  | { type: 'vim_move_to_first_nonwhitespace' }
+  | { type: 'vim_move_to_first_line' }
+  | { type: 'vim_move_to_last_line' }
+  | { type: 'vim_move_to_line'; payload: { lineNumber: number } }
+  | { type: 'vim_escape_insert_mode' };
+
+export function textBufferReducer(
+  state: TextBufferState,
+  action: TextBufferAction,
+): TextBufferState {
+  const pushUndoLocal = pushUndo;
+
+  const currentLine = (r: number): string => state.lines[r] ?? '';
+  const currentLineLen = (r: number): number => cpLen(currentLine(r));
+
+  switch (action.type) {
+    case 'set_text': {
+      let nextState = state;
+      if (action.pushToUndo !== false) {
+        nextState = pushUndoLocal(state);
+      }
+      const newContentLines = action.payload
+        .replace(/\r\n?/g, '\n')
+        .split('\n');
+      const lines = newContentLines.length === 0 ? [''] : newContentLines;
+      const lastNewLineIndex = lines.length - 1;
+      return {
+        ...nextState,
+        lines,
+        cursorRow: lastNewLineIndex,
+        cursorCol: cpLen(lines[lastNewLineIndex] ?? ''),
+        preferredCol: null,
+      };
+    }
+
+    case 'insert': {
+      const nextState = pushUndoLocal(state);
+      const newLines = [...nextState.lines];
+      let newCursorRow = nextState.cursorRow;
+      let newCursorCol = nextState.cursorCol;
+
+      const currentLine = (r: number) => newLines[r] ?? '';
+
+      const str = stripUnsafeCharacters(
+        action.payload.replace(/\r\n/g, '\n').replace(/\r/g, '\n'),
+      );
+      const parts = str.split('\n');
+      const lineContent = currentLine(newCursorRow);
+      const before = cpSlice(lineContent, 0, newCursorCol);
+      const after = cpSlice(lineContent, newCursorCol);
+
+      if (parts.length > 1) {
+        newLines[newCursorRow] = before + parts[0];
+        const remainingParts = parts.slice(1);
+        const lastPartOriginal = remainingParts.pop() ?? '';
+        newLines.splice(newCursorRow + 1, 0, ...remainingParts);
+        newLines.splice(
+          newCursorRow + parts.length - 1,
+          0,
+          lastPartOriginal + after,
+        );
+        newCursorRow = newCursorRow + parts.length - 1;
+        newCursorCol = cpLen(lastPartOriginal);
+      } else {
+        newLines[newCursorRow] = before + parts[0] + after;
+        newCursorCol = cpLen(before) + cpLen(parts[0]);
+      }
+
+      return {
+        ...nextState,
+        lines: newLines,
+        cursorRow: newCursorRow,
+        cursorCol: newCursorCol,
+        preferredCol: null,
+      };
+    }
+
+    case 'backspace': {
+      const nextState = pushUndoLocal(state);
+      const newLines = [...nextState.lines];
+      let newCursorRow = nextState.cursorRow;
+      let newCursorCol = nextState.cursorCol;
+
+      const currentLine = (r: number) => newLines[r] ?? '';
+
+      if (newCursorCol === 0 && newCursorRow === 0) return state;
+
+      if (newCursorCol > 0) {
+        const lineContent = currentLine(newCursorRow);
+        newLines[newCursorRow] =
+          cpSlice(lineContent, 0, newCursorCol - 1) +
+          cpSlice(lineContent, newCursorCol);
+        newCursorCol--;
+      } else if (newCursorRow > 0) {
+        const prevLineContent = currentLine(newCursorRow - 1);
+        const currentLineContentVal = currentLine(newCursorRow);
+        const newCol = cpLen(prevLineContent);
+        newLines[newCursorRow - 1] = prevLineContent + currentLineContentVal;
+        newLines.splice(newCursorRow, 1);
+        newCursorRow--;
+        newCursorCol = newCol;
+      }
+
+      return {
+        ...nextState,
+        lines: newLines,
+        cursorRow: newCursorRow,
+        cursorCol: newCursorCol,
+        preferredCol: null,
+      };
+    }
+
+    case 'set_viewport_width': {
+      if (action.payload === state.viewportWidth) {
+        return state;
+      }
+      return { ...state, viewportWidth: action.payload };
+    }
+
+    case 'move': {
+      const { dir } = action.payload;
+      const { lines, cursorRow, cursorCol, viewportWidth } = state;
+      const visualLayout = calculateVisualLayout(
+        lines,
+        [cursorRow, cursorCol],
+        viewportWidth,
+      );
+      const { visualLines, visualCursor, visualToLogicalMap } = visualLayout;
+
+      let newVisualRow = visualCursor[0];
+      let newVisualCol = visualCursor[1];
+      let newPreferredCol = state.preferredCol;
+
+      const currentVisLineLen = cpLen(visualLines[newVisualRow] ?? '');
+
+      switch (dir) {
+        case 'left':
+          newPreferredCol = null;
+          if (newVisualCol > 0) {
+            newVisualCol--;
+          } else if (newVisualRow > 0) {
+            newVisualRow--;
+            newVisualCol = cpLen(visualLines[newVisualRow] ?? '');
+          }
+          break;
+        case 'right':
+          newPreferredCol = null;
+          if (newVisualCol < currentVisLineLen) {
+            newVisualCol++;
+          } else if (newVisualRow < visualLines.length - 1) {
+            newVisualRow++;
+            newVisualCol = 0;
+          }
+          break;
+        case 'up':
+          if (newVisualRow > 0) {
+            if (newPreferredCol === null) newPreferredCol = newVisualCol;
+            newVisualRow--;
+            newVisualCol = clamp(
+              newPreferredCol,
+              0,
+              cpLen(visualLines[newVisualRow] ?? ''),
+            );
+          }
+          break;
+        case 'down':
+          if (newVisualRow < visualLines.length - 1) {
+            if (newPreferredCol === null) newPreferredCol = newVisualCol;
+            newVisualRow++;
+            newVisualCol = clamp(
+              newPreferredCol,
+              0,
+              cpLen(visualLines[newVisualRow] ?? ''),
+            );
+          }
+          break;
+        case 'home':
+          newPreferredCol = null;
+          newVisualCol = 0;
+          break;
+        case 'end':
+          newPreferredCol = null;
+          newVisualCol = currentVisLineLen;
+          break;
+        case 'wordLeft': {
+          const { cursorRow, cursorCol, lines } = state;
+          if (cursorCol === 0 && cursorRow === 0) return state;
+
+          let newCursorRow = cursorRow;
+          let newCursorCol = cursorCol;
+
+          if (cursorCol === 0) {
+            newCursorRow--;
+            newCursorCol = cpLen(lines[newCursorRow] ?? '');
+          } else {
+            const lineContent = lines[cursorRow];
+            const arr = toCodePoints(lineContent);
+            let start = cursorCol;
+            let onlySpaces = true;
+            for (let i = 0; i < start; i++) {
+              if (isWordChar(arr[i])) {
+                onlySpaces = false;
+                break;
+              }
+            }
+            if (onlySpaces && start > 0) {
+              start--;
+            } else {
+              while (start > 0 && !isWordChar(arr[start - 1])) start--;
+              while (start > 0 && isWordChar(arr[start - 1])) start--;
+            }
+            newCursorCol = start;
+          }
+          return {
+            ...state,
+            cursorRow: newCursorRow,
+            cursorCol: newCursorCol,
+            preferredCol: null,
+          };
+        }
+        case 'wordRight': {
+          const { cursorRow, cursorCol, lines } = state;
+          if (
+            cursorRow === lines.length - 1 &&
+            cursorCol === cpLen(lines[cursorRow] ?? '')
+          ) {
+            return state;
+          }
+
+          let newCursorRow = cursorRow;
+          let newCursorCol = cursorCol;
+          const lineContent = lines[cursorRow] ?? '';
+          const arr = toCodePoints(lineContent);
+
+          if (cursorCol >= arr.length) {
+            newCursorRow++;
+            newCursorCol = 0;
+          } else {
+            let end = cursorCol;
+            while (end < arr.length && !isWordChar(arr[end])) end++;
+            while (end < arr.length && isWordChar(arr[end])) end++;
+            newCursorCol = end;
+          }
+          return {
+            ...state,
+            cursorRow: newCursorRow,
+            cursorCol: newCursorCol,
+            preferredCol: null,
+          };
+        }
+        default:
+          break;
+      }
+
+      if (visualToLogicalMap[newVisualRow]) {
+        const [logRow, logStartCol] = visualToLogicalMap[newVisualRow];
+        return {
+          ...state,
+          cursorRow: logRow,
+          cursorCol: clamp(
+            logStartCol + newVisualCol,
+            0,
+            cpLen(state.lines[logRow] ?? ''),
+          ),
+          preferredCol: newPreferredCol,
+        };
+      }
+      return state;
+    }
+
+    case 'delete': {
+      const { cursorRow, cursorCol, lines } = state;
+      const lineContent = currentLine(cursorRow);
+      if (cursorCol < currentLineLen(cursorRow)) {
+        const nextState = pushUndoLocal(state);
+        const newLines = [...nextState.lines];
+        newLines[cursorRow] =
+          cpSlice(lineContent, 0, cursorCol) +
+          cpSlice(lineContent, cursorCol + 1);
+        return { ...nextState, lines: newLines, preferredCol: null };
+      } else if (cursorRow < lines.length - 1) {
+        const nextState = pushUndoLocal(state);
+        const nextLineContent = currentLine(cursorRow + 1);
+        const newLines = [...nextState.lines];
+        newLines[cursorRow] = lineContent + nextLineContent;
+        newLines.splice(cursorRow + 1, 1);
+        return { ...nextState, lines: newLines, preferredCol: null };
+      }
+      return state;
+    }
+
+    case 'delete_word_left': {
+      const { cursorRow, cursorCol } = state;
+      if (cursorCol === 0 && cursorRow === 0) return state;
+      if (cursorCol === 0) {
+        // Act as a backspace
+        const nextState = pushUndoLocal(state);
+        const prevLineContent = currentLine(cursorRow - 1);
+        const currentLineContentVal = currentLine(cursorRow);
+        const newCol = cpLen(prevLineContent);
+        const newLines = [...nextState.lines];
+        newLines[cursorRow - 1] = prevLineContent + currentLineContentVal;
+        newLines.splice(cursorRow, 1);
+        return {
+          ...nextState,
+          lines: newLines,
+          cursorRow: cursorRow - 1,
+          cursorCol: newCol,
+          preferredCol: null,
+        };
+      }
+      const nextState = pushUndoLocal(state);
+      const lineContent = currentLine(cursorRow);
+      const arr = toCodePoints(lineContent);
+      let start = cursorCol;
+      let onlySpaces = true;
+      for (let i = 0; i < start; i++) {
+        if (isWordChar(arr[i])) {
+          onlySpaces = false;
+          break;
+        }
+      }
+      if (onlySpaces && start > 0) {
+        start--;
+      } else {
+        while (start > 0 && !isWordChar(arr[start - 1])) start--;
+        while (start > 0 && isWordChar(arr[start - 1])) start--;
+      }
+      const newLines = [...nextState.lines];
+      newLines[cursorRow] =
+        cpSlice(lineContent, 0, start) + cpSlice(lineContent, cursorCol);
+      return {
+        ...nextState,
+        lines: newLines,
+        cursorCol: start,
+        preferredCol: null,
+      };
+    }
+
+    case 'delete_word_right': {
+      const { cursorRow, cursorCol, lines } = state;
+      const lineContent = currentLine(cursorRow);
+      const arr = toCodePoints(lineContent);
+      if (cursorCol >= arr.length && cursorRow === lines.length - 1)
+        return state;
+      if (cursorCol >= arr.length) {
+        // Act as a delete
+        const nextState = pushUndoLocal(state);
+        const nextLineContent = currentLine(cursorRow + 1);
+        const newLines = [...nextState.lines];
+        newLines[cursorRow] = lineContent + nextLineContent;
+        newLines.splice(cursorRow + 1, 1);
+        return { ...nextState, lines: newLines, preferredCol: null };
+      }
+      const nextState = pushUndoLocal(state);
+      let end = cursorCol;
+      while (end < arr.length && !isWordChar(arr[end])) end++;
+      while (end < arr.length && isWordChar(arr[end])) end++;
+      const newLines = [...nextState.lines];
+      newLines[cursorRow] =
+        cpSlice(lineContent, 0, cursorCol) + cpSlice(lineContent, end);
+      return { ...nextState, lines: newLines, preferredCol: null };
+    }
+
+    case 'kill_line_right': {
+      const { cursorRow, cursorCol, lines } = state;
+      const lineContent = currentLine(cursorRow);
+      if (cursorCol < currentLineLen(cursorRow)) {
+        const nextState = pushUndoLocal(state);
+        const newLines = [...nextState.lines];
+        newLines[cursorRow] = cpSlice(lineContent, 0, cursorCol);
+        return { ...nextState, lines: newLines };
+      } else if (cursorRow < lines.length - 1) {
+        // Act as a delete
+        const nextState = pushUndoLocal(state);
+        const nextLineContent = currentLine(cursorRow + 1);
+        const newLines = [...nextState.lines];
+        newLines[cursorRow] = lineContent + nextLineContent;
+        newLines.splice(cursorRow + 1, 1);
+        return { ...nextState, lines: newLines, preferredCol: null };
+      }
+      return state;
+    }
+
+    case 'kill_line_left': {
+      const { cursorRow, cursorCol } = state;
+      if (cursorCol > 0) {
+        const nextState = pushUndoLocal(state);
+        const lineContent = currentLine(cursorRow);
+        const newLines = [...nextState.lines];
+        newLines[cursorRow] = cpSlice(lineContent, cursorCol);
+        return {
+          ...nextState,
+          lines: newLines,
+          cursorCol: 0,
+          preferredCol: null,
+        };
+      }
+      return state;
+    }
+
+    case 'undo': {
+      const stateToRestore = state.undoStack[state.undoStack.length - 1];
+      if (!stateToRestore) return state;
+
+      const currentSnapshot = {
+        lines: [...state.lines],
+        cursorRow: state.cursorRow,
+        cursorCol: state.cursorCol,
+      };
+      return {
+        ...state,
+        ...stateToRestore,
+        undoStack: state.undoStack.slice(0, -1),
+        redoStack: [...state.redoStack, currentSnapshot],
+      };
+    }
+
+    case 'redo': {
+      const stateToRestore = state.redoStack[state.redoStack.length - 1];
+      if (!stateToRestore) return state;
+
+      const currentSnapshot = {
+        lines: [...state.lines],
+        cursorRow: state.cursorRow,
+        cursorCol: state.cursorCol,
+      };
+      return {
+        ...state,
+        ...stateToRestore,
+        redoStack: state.redoStack.slice(0, -1),
+        undoStack: [...state.undoStack, currentSnapshot],
+      };
+    }
+
+    case 'replace_range': {
+      const { startRow, startCol, endRow, endCol, text } = action.payload;
+      const nextState = pushUndoLocal(state);
+      return replaceRangeInternal(
+        nextState,
+        startRow,
+        startCol,
+        endRow,
+        endCol,
+        text,
+      );
+    }
+
+    case 'move_to_offset': {
+      const { offset } = action.payload;
+      const [newRow, newCol] = offsetToLogicalPos(
+        state.lines.join('\n'),
+        offset,
+      );
+      return {
+        ...state,
+        cursorRow: newRow,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    case 'create_undo_snapshot': {
+      return pushUndoLocal(state);
+    }
+
+    // Vim-specific operations
+    case 'vim_delete_word_forward':
+    case 'vim_delete_word_backward':
+    case 'vim_delete_word_end':
+    case 'vim_change_word_forward':
+    case 'vim_change_word_backward':
+    case 'vim_change_word_end':
+    case 'vim_delete_line':
+    case 'vim_change_line':
+    case 'vim_delete_to_end_of_line':
+    case 'vim_change_to_end_of_line':
+    case 'vim_change_movement':
+    case 'vim_move_left':
+    case 'vim_move_right':
+    case 'vim_move_up':
+    case 'vim_move_down':
+    case 'vim_move_word_forward':
+    case 'vim_move_word_backward':
+    case 'vim_move_word_end':
+    case 'vim_delete_char':
+    case 'vim_insert_at_cursor':
+    case 'vim_append_at_cursor':
+    case 'vim_open_line_below':
+    case 'vim_open_line_above':
+    case 'vim_append_at_line_end':
+    case 'vim_insert_at_line_start':
+    case 'vim_move_to_line_start':
+    case 'vim_move_to_line_end':
+    case 'vim_move_to_first_nonwhitespace':
+    case 'vim_move_to_first_line':
+    case 'vim_move_to_last_line':
+    case 'vim_move_to_line':
+    case 'vim_escape_insert_mode':
+      return handleVimAction(state, action as VimAction);
+
+    default: {
+      const exhaustiveCheck: never = action;
+      console.error(`Unknown action encountered: ${exhaustiveCheck}`);
+      return state;
+    }
+  }
+}
+
+// --- End of reducer logic ---
+
+export function useTextBuffer({
+  initialText = '',
+  initialCursorOffset = 0,
+  viewport,
+  stdin,
+  setRawMode,
+  onChange,
+  isValidPath,
+  shellModeActive = false,
+}: UseTextBufferProps): TextBuffer {
+  const initialState = useMemo((): TextBufferState => {
+    const lines = initialText.split('\n');
+    const [initialCursorRow, initialCursorCol] = calculateInitialCursorPosition(
+      lines.length === 0 ? [''] : lines,
+      initialCursorOffset,
+    );
+    return {
+      lines: lines.length === 0 ? [''] : lines,
+      cursorRow: initialCursorRow,
+      cursorCol: initialCursorCol,
+      preferredCol: null,
+      undoStack: [],
+      redoStack: [],
+      clipboard: null,
+      selectionAnchor: null,
+      viewportWidth: viewport.width,
+    };
+  }, [initialText, initialCursorOffset, viewport.width]);
+
+  const [state, dispatch] = useReducer(textBufferReducer, initialState);
+  const { lines, cursorRow, cursorCol, preferredCol, selectionAnchor } = state;
+
+  const text = useMemo(() => lines.join('\n'), [lines]);
+
+  const visualLayout = useMemo(
+    () =>
+      calculateVisualLayout(lines, [cursorRow, cursorCol], state.viewportWidth),
+    [lines, cursorRow, cursorCol, state.viewportWidth],
+  );
+
+  const { visualLines, visualCursor } = visualLayout;
+
+  const [visualScrollRow, setVisualScrollRow] = useState<number>(0);
+
+  useEffect(() => {
+    if (onChange) {
+      onChange(text);
+    }
+  }, [text, onChange]);
+
+  useEffect(() => {
+    dispatch({ type: 'set_viewport_width', payload: viewport.width });
+  }, [viewport.width]);
+
+  // Update visual scroll (vertical)
+  useEffect(() => {
+    const { height } = viewport;
+    let newVisualScrollRow = visualScrollRow;
+
+    if (visualCursor[0] < visualScrollRow) {
+      newVisualScrollRow = visualCursor[0];
+    } else if (visualCursor[0] >= visualScrollRow + height) {
+      newVisualScrollRow = visualCursor[0] - height + 1;
+    }
+    if (newVisualScrollRow !== visualScrollRow) {
+      setVisualScrollRow(newVisualScrollRow);
+    }
+  }, [visualCursor, visualScrollRow, viewport]);
+
+  const insert = useCallback(
+    (ch: string, { paste = false }: { paste?: boolean } = {}): void => {
+      if (/[\n\r]/.test(ch)) {
+        dispatch({ type: 'insert', payload: ch });
+        return;
+      }
+
+      const minLengthToInferAsDragDrop = 3;
+      if (
+        ch.length >= minLengthToInferAsDragDrop &&
+        !shellModeActive &&
+        paste
+      ) {
+        let potentialPath = ch.trim();
+        const quoteMatch = potentialPath.match(/^'(.*)'$/);
+        if (quoteMatch) {
+          potentialPath = quoteMatch[1];
+        }
+
+        potentialPath = potentialPath.trim();
+        if (isValidPath(unescapePath(potentialPath))) {
+          ch = `@${potentialPath} `;
+        }
+      }
+
+      let currentText = '';
+      for (const char of toCodePoints(ch)) {
+        if (char.codePointAt(0) === 127) {
+          if (currentText.length > 0) {
+            dispatch({ type: 'insert', payload: currentText });
+            currentText = '';
+          }
+          dispatch({ type: 'backspace' });
+        } else {
+          currentText += char;
+        }
+      }
+      if (currentText.length > 0) {
+        dispatch({ type: 'insert', payload: currentText });
+      }
+    },
+    [isValidPath, shellModeActive],
+  );
+
+  const newline = useCallback((): void => {
+    dispatch({ type: 'insert', payload: '\n' });
+  }, []);
+
+  const backspace = useCallback((): void => {
+    dispatch({ type: 'backspace' });
+  }, []);
+
+  const del = useCallback((): void => {
+    dispatch({ type: 'delete' });
+  }, []);
+
+  const move = useCallback((dir: Direction): void => {
+    dispatch({ type: 'move', payload: { dir } });
+  }, []);
+
+  const undo = useCallback((): void => {
+    dispatch({ type: 'undo' });
+  }, []);
+
+  const redo = useCallback((): void => {
+    dispatch({ type: 'redo' });
+  }, []);
+
+  const setText = useCallback((newText: string): void => {
+    dispatch({ type: 'set_text', payload: newText });
+  }, []);
+
+  const deleteWordLeft = useCallback((): void => {
+    dispatch({ type: 'delete_word_left' });
+  }, []);
+
+  const deleteWordRight = useCallback((): void => {
+    dispatch({ type: 'delete_word_right' });
+  }, []);
+
+  const killLineRight = useCallback((): void => {
+    dispatch({ type: 'kill_line_right' });
+  }, []);
+
+  const killLineLeft = useCallback((): void => {
+    dispatch({ type: 'kill_line_left' });
+  }, []);
+
+  // Vim-specific operations
+  const vimDeleteWordForward = useCallback((count: number): void => {
+    dispatch({ type: 'vim_delete_word_forward', payload: { count } });
+  }, []);
+
+  const vimDeleteWordBackward = useCallback((count: number): void => {
+    dispatch({ type: 'vim_delete_word_backward', payload: { count } });
+  }, []);
+
+  const vimDeleteWordEnd = useCallback((count: number): void => {
+    dispatch({ type: 'vim_delete_word_end', payload: { count } });
+  }, []);
+
+  const vimChangeWordForward = useCallback((count: number): void => {
+    dispatch({ type: 'vim_change_word_forward', payload: { count } });
+  }, []);
+
+  const vimChangeWordBackward = useCallback((count: number): void => {
+    dispatch({ type: 'vim_change_word_backward', payload: { count } });
+  }, []);
+
+  const vimChangeWordEnd = useCallback((count: number): void => {
+    dispatch({ type: 'vim_change_word_end', payload: { count } });
+  }, []);
+
+  const vimDeleteLine = useCallback((count: number): void => {
+    dispatch({ type: 'vim_delete_line', payload: { count } });
+  }, []);
+
+  const vimChangeLine = useCallback((count: number): void => {
+    dispatch({ type: 'vim_change_line', payload: { count } });
+  }, []);
+
+  const vimDeleteToEndOfLine = useCallback((): void => {
+    dispatch({ type: 'vim_delete_to_end_of_line' });
+  }, []);
+
+  const vimChangeToEndOfLine = useCallback((): void => {
+    dispatch({ type: 'vim_change_to_end_of_line' });
+  }, []);
+
+  const vimChangeMovement = useCallback(
+    (movement: 'h' | 'j' | 'k' | 'l', count: number): void => {
+      dispatch({ type: 'vim_change_movement', payload: { movement, count } });
+    },
+    [],
+  );
+
+  // New vim navigation and operation methods
+  const vimMoveLeft = useCallback((count: number): void => {
+    dispatch({ type: 'vim_move_left', payload: { count } });
+  }, []);
+
+  const vimMoveRight = useCallback((count: number): void => {
+    dispatch({ type: 'vim_move_right', payload: { count } });
+  }, []);
+
+  const vimMoveUp = useCallback((count: number): void => {
+    dispatch({ type: 'vim_move_up', payload: { count } });
+  }, []);
+
+  const vimMoveDown = useCallback((count: number): void => {
+    dispatch({ type: 'vim_move_down', payload: { count } });
+  }, []);
+
+  const vimMoveWordForward = useCallback((count: number): void => {
+    dispatch({ type: 'vim_move_word_forward', payload: { count } });
+  }, []);
+
+  const vimMoveWordBackward = useCallback((count: number): void => {
+    dispatch({ type: 'vim_move_word_backward', payload: { count } });
+  }, []);
+
+  const vimMoveWordEnd = useCallback((count: number): void => {
+    dispatch({ type: 'vim_move_word_end', payload: { count } });
+  }, []);
+
+  const vimDeleteChar = useCallback((count: number): void => {
+    dispatch({ type: 'vim_delete_char', payload: { count } });
+  }, []);
+
+  const vimInsertAtCursor = useCallback((): void => {
+    dispatch({ type: 'vim_insert_at_cursor' });
+  }, []);
+
+  const vimAppendAtCursor = useCallback((): void => {
+    dispatch({ type: 'vim_append_at_cursor' });
+  }, []);
+
+  const vimOpenLineBelow = useCallback((): void => {
+    dispatch({ type: 'vim_open_line_below' });
+  }, []);
+
+  const vimOpenLineAbove = useCallback((): void => {
+    dispatch({ type: 'vim_open_line_above' });
+  }, []);
+
+  const vimAppendAtLineEnd = useCallback((): void => {
+    dispatch({ type: 'vim_append_at_line_end' });
+  }, []);
+
+  const vimInsertAtLineStart = useCallback((): void => {
+    dispatch({ type: 'vim_insert_at_line_start' });
+  }, []);
+
+  const vimMoveToLineStart = useCallback((): void => {
+    dispatch({ type: 'vim_move_to_line_start' });
+  }, []);
+
+  const vimMoveToLineEnd = useCallback((): void => {
+    dispatch({ type: 'vim_move_to_line_end' });
+  }, []);
+
+  const vimMoveToFirstNonWhitespace = useCallback((): void => {
+    dispatch({ type: 'vim_move_to_first_nonwhitespace' });
+  }, []);
+
+  const vimMoveToFirstLine = useCallback((): void => {
+    dispatch({ type: 'vim_move_to_first_line' });
+  }, []);
+
+  const vimMoveToLastLine = useCallback((): void => {
+    dispatch({ type: 'vim_move_to_last_line' });
+  }, []);
+
+  const vimMoveToLine = useCallback((lineNumber: number): void => {
+    dispatch({ type: 'vim_move_to_line', payload: { lineNumber } });
+  }, []);
+
+  const vimEscapeInsertMode = useCallback((): void => {
+    dispatch({ type: 'vim_escape_insert_mode' });
+  }, []);
+
+  const openInExternalEditor = useCallback(
+    async (opts: { editor?: string } = {}): Promise<void> => {
+      const editor =
+        opts.editor ??
+        process.env['VISUAL'] ??
+        process.env['EDITOR'] ??
+        (process.platform === 'win32' ? 'notepad' : 'vi');
+      const tmpDir = fs.mkdtempSync(pathMod.join(os.tmpdir(), 'gemini-edit-'));
+      const filePath = pathMod.join(tmpDir, 'buffer.txt');
+      fs.writeFileSync(filePath, text, 'utf8');
+
+      dispatch({ type: 'create_undo_snapshot' });
+
+      const wasRaw = stdin?.isRaw ?? false;
+      try {
+        setRawMode?.(false);
+        const { status, error } = spawnSync(editor, [filePath], {
+          stdio: 'inherit',
+        });
+        if (error) throw error;
+        if (typeof status === 'number' && status !== 0)
+          throw new Error(`External editor exited with status ${status}`);
+
+        let newText = fs.readFileSync(filePath, 'utf8');
+        newText = newText.replace(/\r\n?/g, '\n');
+        dispatch({ type: 'set_text', payload: newText, pushToUndo: false });
+      } catch (err) {
+        console.error('[useTextBuffer] external editor error', err);
+      } finally {
+        if (wasRaw) setRawMode?.(true);
+        try {
+          fs.unlinkSync(filePath);
+        } catch {
+          /* ignore */
+        }
+        try {
+          fs.rmdirSync(tmpDir);
+        } catch {
+          /* ignore */
+        }
+      }
+    },
+    [text, stdin, setRawMode],
+  );
+
+  const handleInput = useCallback(
+    (key: {
+      name: string;
+      ctrl: boolean;
+      meta: boolean;
+      shift: boolean;
+      paste: boolean;
+      sequence: string;
+    }): void => {
+      const { sequence: input } = key;
+
+      if (key.paste) {
+        // Do not do any other processing on pastes so ensure we handle them
+        // before all other cases.
+        insert(input, { paste: key.paste });
+        return;
+      }
+
+      if (
+        key.name === 'return' ||
+        input === '\r' ||
+        input === '\n' ||
+        input === '\\\r' // VSCode terminal represents shift + enter this way
+      )
+        newline();
+      else if (key.name === 'left' && !key.meta && !key.ctrl) move('left');
+      else if (key.ctrl && key.name === 'b') move('left');
+      else if (key.name === 'right' && !key.meta && !key.ctrl) move('right');
+      else if (key.ctrl && key.name === 'f') move('right');
+      else if (key.name === 'up') move('up');
+      else if (key.name === 'down') move('down');
+      else if ((key.ctrl || key.meta) && key.name === 'left') move('wordLeft');
+      else if (key.meta && key.name === 'b') move('wordLeft');
+      else if ((key.ctrl || key.meta) && key.name === 'right')
+        move('wordRight');
+      else if (key.meta && key.name === 'f') move('wordRight');
+      else if (key.name === 'home') move('home');
+      else if (key.ctrl && key.name === 'a') move('home');
+      else if (key.name === 'end') move('end');
+      else if (key.ctrl && key.name === 'e') move('end');
+      else if (key.ctrl && key.name === 'w') deleteWordLeft();
+      else if (
+        (key.meta || key.ctrl) &&
+        (key.name === 'backspace' || input === '\x7f')
+      )
+        deleteWordLeft();
+      else if ((key.meta || key.ctrl) && key.name === 'delete')
+        deleteWordRight();
+      else if (
+        key.name === 'backspace' ||
+        input === '\x7f' ||
+        (key.ctrl && key.name === 'h')
+      )
+        backspace();
+      else if (key.name === 'delete' || (key.ctrl && key.name === 'd')) del();
+      else if (input && !key.ctrl && !key.meta) {
+        insert(input, { paste: key.paste });
+      }
+    },
+    [newline, move, deleteWordLeft, deleteWordRight, backspace, del, insert],
+  );
+
+  const renderedVisualLines = useMemo(
+    () => visualLines.slice(visualScrollRow, visualScrollRow + viewport.height),
+    [visualLines, visualScrollRow, viewport.height],
+  );
+
+  const replaceRange = useCallback(
+    (
+      startRow: number,
+      startCol: number,
+      endRow: number,
+      endCol: number,
+      text: string,
+    ): void => {
+      dispatch({
+        type: 'replace_range',
+        payload: { startRow, startCol, endRow, endCol, text },
+      });
+    },
+    [],
+  );
+
+  const replaceRangeByOffset = useCallback(
+    (startOffset: number, endOffset: number, replacementText: string): void => {
+      const [startRow, startCol] = offsetToLogicalPos(text, startOffset);
+      const [endRow, endCol] = offsetToLogicalPos(text, endOffset);
+      replaceRange(startRow, startCol, endRow, endCol, replacementText);
+    },
+    [text, replaceRange],
+  );
+
+  const moveToOffset = useCallback((offset: number): void => {
+    dispatch({ type: 'move_to_offset', payload: { offset } });
+  }, []);
+
+  const returnValue: TextBuffer = {
+    lines,
+    text,
+    cursor: [cursorRow, cursorCol],
+    preferredCol,
+    selectionAnchor,
+
+    allVisualLines: visualLines,
+    viewportVisualLines: renderedVisualLines,
+    visualCursor,
+    visualScrollRow,
+
+    setText,
+    insert,
+    newline,
+    backspace,
+    del,
+    move,
+    undo,
+    redo,
+    replaceRange,
+    replaceRangeByOffset,
+    moveToOffset,
+    deleteWordLeft,
+    deleteWordRight,
+    killLineRight,
+    killLineLeft,
+    handleInput,
+    openInExternalEditor,
+    // Vim-specific operations
+    vimDeleteWordForward,
+    vimDeleteWordBackward,
+    vimDeleteWordEnd,
+    vimChangeWordForward,
+    vimChangeWordBackward,
+    vimChangeWordEnd,
+    vimDeleteLine,
+    vimChangeLine,
+    vimDeleteToEndOfLine,
+    vimChangeToEndOfLine,
+    vimChangeMovement,
+    vimMoveLeft,
+    vimMoveRight,
+    vimMoveUp,
+    vimMoveDown,
+    vimMoveWordForward,
+    vimMoveWordBackward,
+    vimMoveWordEnd,
+    vimDeleteChar,
+    vimInsertAtCursor,
+    vimAppendAtCursor,
+    vimOpenLineBelow,
+    vimOpenLineAbove,
+    vimAppendAtLineEnd,
+    vimInsertAtLineStart,
+    vimMoveToLineStart,
+    vimMoveToLineEnd,
+    vimMoveToFirstNonWhitespace,
+    vimMoveToFirstLine,
+    vimMoveToLastLine,
+    vimMoveToLine,
+    vimEscapeInsertMode,
+  };
+  return returnValue;
+}
+
+export interface TextBuffer {
+  // State
+  lines: string[]; // Logical lines
+  text: string;
+  cursor: [number, number]; // Logical cursor [row, col]
+  /**
+   * When the user moves the caret vertically we try to keep their original
+   * horizontal column even when passing through shorter lines.  We remember
+   * that *preferred* column in this field while the user is still travelling
+   * vertically.  Any explicit horizontal movement resets the preference.
+   */
+  preferredCol: number | null; // Preferred visual column
+  selectionAnchor: [number, number] | null; // Logical selection anchor
+
+  // Visual state (handles wrapping)
+  allVisualLines: string[]; // All visual lines for the current text and viewport width.
+  viewportVisualLines: string[]; // The subset of visual lines to be rendered based on visualScrollRow and viewport.height
+  visualCursor: [number, number]; // Visual cursor [row, col] relative to the start of all visualLines
+  visualScrollRow: number; // Scroll position for visual lines (index of the first visible visual line)
+
+  // Actions
+
+  /**
+   * Replaces the entire buffer content with the provided text.
+   * The operation is undoable.
+   */
+  setText: (text: string) => void;
+  /**
+   * Insert a single character or string without newlines.
+   */
+  insert: (ch: string, opts?: { paste?: boolean }) => void;
+  newline: () => void;
+  backspace: () => void;
+  del: () => void;
+  move: (dir: Direction) => void;
+  undo: () => void;
+  redo: () => void;
+  /**
+   * Replaces the text within the specified range with new text.
+   * Handles both single-line and multi-line ranges.
+   *
+   * @param startRow The starting row index (inclusive).
+   * @param startCol The starting column index (inclusive, code-point based).
+   * @param endRow The ending row index (inclusive).
+   * @param endCol The ending column index (exclusive, code-point based).
+   * @param text The new text to insert.
+   * @returns True if the buffer was modified, false otherwise.
+   */
+  replaceRange: (
+    startRow: number,
+    startCol: number,
+    endRow: number,
+    endCol: number,
+    text: string,
+  ) => void;
+  /**
+   * Delete the word to the *left* of the caret, mirroring common
+   * Ctrl/Alt+Backspace behaviour in editors & terminals. Both the adjacent
+   * whitespace *and* the word characters immediately preceding the caret are
+   * removed.  If the caret is already at column‑0 this becomes a no-op.
+   */
+  deleteWordLeft: () => void;
+  /**
+   * Delete the word to the *right* of the caret, akin to many editors'
+   * Ctrl/Alt+Delete shortcut.  Removes any whitespace/punctuation that
+   * follows the caret and the next contiguous run of word characters.
+   */
+  deleteWordRight: () => void;
+  /**
+   * Deletes text from the cursor to the end of the current line.
+   */
+  killLineRight: () => void;
+  /**
+   * Deletes text from the start of the current line to the cursor.
+   */
+  killLineLeft: () => void;
+  /**
+   * High level "handleInput" – receives what Ink gives us.
+   */
+  handleInput: (key: {
+    name: string;
+    ctrl: boolean;
+    meta: boolean;
+    shift: boolean;
+    paste: boolean;
+    sequence: string;
+  }) => void;
+  /**
+   * Opens the current buffer contents in the user's preferred terminal text
+   * editor ($VISUAL or $EDITOR, falling back to "vi").  The method blocks
+   * until the editor exits, then reloads the file and replaces the in‑memory
+   * buffer with whatever the user saved.
+   *
+   * The operation is treated as a single undoable edit – we snapshot the
+   * previous state *once* before launching the editor so one `undo()` will
+   * revert the entire change set.
+   *
+   * Note: We purposefully rely on the *synchronous* spawn API so that the
+   * calling process genuinely waits for the editor to close before
+   * continuing.  This mirrors Git's behaviour and simplifies downstream
+   * control‑flow (callers can simply `await` the Promise).
+   */
+  openInExternalEditor: (opts?: { editor?: string }) => Promise<void>;
+
+  replaceRangeByOffset: (
+    startOffset: number,
+    endOffset: number,
+    replacementText: string,
+  ) => void;
+  moveToOffset(offset: number): void;
+
+  // Vim-specific operations
+  /**
+   * Delete N words forward from cursor position (vim 'dw' command)
+   */
+  vimDeleteWordForward: (count: number) => void;
+  /**
+   * Delete N words backward from cursor position (vim 'db' command)
+   */
+  vimDeleteWordBackward: (count: number) => void;
+  /**
+   * Delete to end of N words from cursor position (vim 'de' command)
+   */
+  vimDeleteWordEnd: (count: number) => void;
+  /**
+   * Change N words forward from cursor position (vim 'cw' command)
+   */
+  vimChangeWordForward: (count: number) => void;
+  /**
+   * Change N words backward from cursor position (vim 'cb' command)
+   */
+  vimChangeWordBackward: (count: number) => void;
+  /**
+   * Change to end of N words from cursor position (vim 'ce' command)
+   */
+  vimChangeWordEnd: (count: number) => void;
+  /**
+   * Delete N lines from cursor position (vim 'dd' command)
+   */
+  vimDeleteLine: (count: number) => void;
+  /**
+   * Change N lines from cursor position (vim 'cc' command)
+   */
+  vimChangeLine: (count: number) => void;
+  /**
+   * Delete from cursor to end of line (vim 'D' command)
+   */
+  vimDeleteToEndOfLine: () => void;
+  /**
+   * Change from cursor to end of line (vim 'C' command)
+   */
+  vimChangeToEndOfLine: () => void;
+  /**
+   * Change movement operations (vim 'ch', 'cj', 'ck', 'cl' commands)
+   */
+  vimChangeMovement: (movement: 'h' | 'j' | 'k' | 'l', count: number) => void;
+  /**
+   * Move cursor left N times (vim 'h' command)
+   */
+  vimMoveLeft: (count: number) => void;
+  /**
+   * Move cursor right N times (vim 'l' command)
+   */
+  vimMoveRight: (count: number) => void;
+  /**
+   * Move cursor up N times (vim 'k' command)
+   */
+  vimMoveUp: (count: number) => void;
+  /**
+   * Move cursor down N times (vim 'j' command)
+   */
+  vimMoveDown: (count: number) => void;
+  /**
+   * Move cursor forward N words (vim 'w' command)
+   */
+  vimMoveWordForward: (count: number) => void;
+  /**
+   * Move cursor backward N words (vim 'b' command)
+   */
+  vimMoveWordBackward: (count: number) => void;
+  /**
+   * Move cursor to end of Nth word (vim 'e' command)
+   */
+  vimMoveWordEnd: (count: number) => void;
+  /**
+   * Delete N characters at cursor (vim 'x' command)
+   */
+  vimDeleteChar: (count: number) => void;
+  /**
+   * Enter insert mode at cursor (vim 'i' command)
+   */
+  vimInsertAtCursor: () => void;
+  /**
+   * Enter insert mode after cursor (vim 'a' command)
+   */
+  vimAppendAtCursor: () => void;
+  /**
+   * Open new line below and enter insert mode (vim 'o' command)
+   */
+  vimOpenLineBelow: () => void;
+  /**
+   * Open new line above and enter insert mode (vim 'O' command)
+   */
+  vimOpenLineAbove: () => void;
+  /**
+   * Move to end of line and enter insert mode (vim 'A' command)
+   */
+  vimAppendAtLineEnd: () => void;
+  /**
+   * Move to first non-whitespace and enter insert mode (vim 'I' command)
+   */
+  vimInsertAtLineStart: () => void;
+  /**
+   * Move cursor to beginning of line (vim '0' command)
+   */
+  vimMoveToLineStart: () => void;
+  /**
+   * Move cursor to end of line (vim '$' command)
+   */
+  vimMoveToLineEnd: () => void;
+  /**
+   * Move cursor to first non-whitespace character (vim '^' command)
+   */
+  vimMoveToFirstNonWhitespace: () => void;
+  /**
+   * Move cursor to first line (vim 'gg' command)
+   */
+  vimMoveToFirstLine: () => void;
+  /**
+   * Move cursor to last line (vim 'G' command)
+   */
+  vimMoveToLastLine: () => void;
+  /**
+   * Move cursor to specific line number (vim '[N]G' command)
+   */
+  vimMoveToLine: (lineNumber: number) => void;
+  /**
+   * Handle escape from insert mode (moves cursor left if not at line start)
+   */
+  vimEscapeInsertMode: () => void;
+}

projects/ui/qwen-code/packages/cli/src/ui/components/shared/vim-buffer-actions.test.ts

@@ -0,0 +1,1119 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { handleVimAction } from './vim-buffer-actions.js';
+import type { TextBufferState } from './text-buffer.js';
+
+// Helper to create test state
+const createTestState = (
+  lines: string[] = ['hello world'],
+  cursorRow = 0,
+  cursorCol = 0,
+): TextBufferState => ({
+  lines,
+  cursorRow,
+  cursorCol,
+  preferredCol: null,
+  undoStack: [],
+  redoStack: [],
+  clipboard: null,
+  selectionAnchor: null,
+  viewportWidth: 80,
+});
+
+describe('vim-buffer-actions', () => {
+  describe('Movement commands', () => {
+    describe('vim_move_left', () => {
+      it('should move cursor left by count', () => {
+        const state = createTestState(['hello world'], 0, 5);
+        const action = {
+          type: 'vim_move_left' as const,
+          payload: { count: 3 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(2);
+        expect(result.preferredCol).toBeNull();
+      });
+
+      it('should not move past beginning of line', () => {
+        const state = createTestState(['hello'], 0, 2);
+        const action = {
+          type: 'vim_move_left' as const,
+          payload: { count: 5 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(0);
+      });
+
+      it('should wrap to previous line when at beginning', () => {
+        const state = createTestState(['line1', 'line2'], 1, 0);
+        const action = {
+          type: 'vim_move_left' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(4); // On last character '1' of 'line1'
+      });
+
+      it('should handle multiple line wrapping', () => {
+        const state = createTestState(['abc', 'def', 'ghi'], 2, 0);
+        const action = {
+          type: 'vim_move_left' as const,
+          payload: { count: 5 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(1); // On 'b' after 5 left movements
+      });
+
+      it('should correctly handle h/l movement between lines', () => {
+        // Start at end of first line at 'd' (position 10)
+        let state = createTestState(['hello world', 'foo bar'], 0, 10);
+
+        // Move right - should go to beginning of next line
+        state = handleVimAction(state, {
+          type: 'vim_move_right' as const,
+          payload: { count: 1 },
+        });
+        expect(state).toHaveOnlyValidCharacters();
+        expect(state.cursorRow).toBe(1);
+        expect(state.cursorCol).toBe(0); // Should be on 'f'
+
+        // Move left - should go back to end of previous line on 'd'
+        state = handleVimAction(state, {
+          type: 'vim_move_left' as const,
+          payload: { count: 1 },
+        });
+        expect(state).toHaveOnlyValidCharacters();
+        expect(state.cursorRow).toBe(0);
+        expect(state.cursorCol).toBe(10); // Should be on 'd', not past it
+      });
+    });
+
+    describe('vim_move_right', () => {
+      it('should move cursor right by count', () => {
+        const state = createTestState(['hello world'], 0, 2);
+        const action = {
+          type: 'vim_move_right' as const,
+          payload: { count: 3 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(5);
+      });
+
+      it('should not move past last character of line', () => {
+        const state = createTestState(['hello'], 0, 3);
+        const action = {
+          type: 'vim_move_right' as const,
+          payload: { count: 5 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(4); // Last character of 'hello'
+      });
+
+      it('should wrap to next line when at end', () => {
+        const state = createTestState(['line1', 'line2'], 0, 4); // At end of 'line1'
+        const action = {
+          type: 'vim_move_right' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(1);
+        expect(result.cursorCol).toBe(0);
+      });
+
+      it('should skip over combining marks to avoid cursor disappearing', () => {
+        // Test case for combining character cursor disappearing bug
+        // "café test" where é is represented as e + combining acute accent
+        const state = createTestState(['cafe\u0301 test'], 0, 2); // Start at 'f'
+        const action = {
+          type: 'vim_move_right' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(3); // Should be on 'e' of 'café'
+
+        // Move right again - should skip combining mark and land on space
+        const result2 = handleVimAction(result, action);
+        expect(result2).toHaveOnlyValidCharacters();
+        expect(result2.cursorCol).toBe(5); // Should be on space after 'café'
+      });
+    });
+
+    describe('vim_move_up', () => {
+      it('should move cursor up by count', () => {
+        const state = createTestState(['line1', 'line2', 'line3'], 2, 3);
+        const action = { type: 'vim_move_up' as const, payload: { count: 2 } };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(3);
+      });
+
+      it('should not move past first line', () => {
+        const state = createTestState(['line1', 'line2'], 1, 3);
+        const action = { type: 'vim_move_up' as const, payload: { count: 5 } };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(0);
+      });
+
+      it('should adjust column for shorter lines', () => {
+        const state = createTestState(['short', 'very long line'], 1, 10);
+        const action = { type: 'vim_move_up' as const, payload: { count: 1 } };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(4); // Last character 't' of 'short', not past it
+      });
+    });
+
+    describe('vim_move_down', () => {
+      it('should move cursor down by count', () => {
+        const state = createTestState(['line1', 'line2', 'line3'], 0, 2);
+        const action = {
+          type: 'vim_move_down' as const,
+          payload: { count: 2 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(2);
+        expect(result.cursorCol).toBe(2);
+      });
+
+      it('should not move past last line', () => {
+        const state = createTestState(['line1', 'line2'], 0, 2);
+        const action = {
+          type: 'vim_move_down' as const,
+          payload: { count: 5 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(1);
+      });
+    });
+
+    describe('vim_move_word_forward', () => {
+      it('should move to start of next word', () => {
+        const state = createTestState(['hello world test'], 0, 0);
+        const action = {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(6); // Start of 'world'
+      });
+
+      it('should handle multiple words', () => {
+        const state = createTestState(['hello world test'], 0, 0);
+        const action = {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 2 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(12); // Start of 'test'
+      });
+
+      it('should handle punctuation correctly', () => {
+        const state = createTestState(['hello, world!'], 0, 0);
+        const action = {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(5); // Start of ','
+      });
+
+      it('should move across empty lines when starting from within a word', () => {
+        // Testing the exact scenario: cursor on 'w' of 'hello world', w should move to next line
+        const state = createTestState(['hello world', ''], 0, 6); // At 'w' of 'world'
+        const action = {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(1); // Should move to empty line
+        expect(result.cursorCol).toBe(0); // Beginning of empty line
+      });
+    });
+
+    describe('vim_move_word_backward', () => {
+      it('should move to start of previous word', () => {
+        const state = createTestState(['hello world test'], 0, 12);
+        const action = {
+          type: 'vim_move_word_backward' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(6); // Start of 'world'
+      });
+
+      it('should handle multiple words', () => {
+        const state = createTestState(['hello world test'], 0, 12);
+        const action = {
+          type: 'vim_move_word_backward' as const,
+          payload: { count: 2 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(0); // Start of 'hello'
+      });
+    });
+
+    describe('vim_move_word_end', () => {
+      it('should move to end of current word', () => {
+        const state = createTestState(['hello world'], 0, 0);
+        const action = {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(4); // End of 'hello'
+      });
+
+      it('should move to end of next word if already at word end', () => {
+        const state = createTestState(['hello world'], 0, 4);
+        const action = {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(10); // End of 'world'
+      });
+
+      it('should move across empty lines when at word end', () => {
+        const state = createTestState(['hello world', '', 'test'], 0, 10); // At 'd' of 'world'
+        const action = {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(2); // Should move to line with 'test'
+        expect(result.cursorCol).toBe(3); // Should be at 't' (end of 'test')
+      });
+
+      it('should handle consecutive word-end movements across empty lines', () => {
+        // Testing the exact scenario: cursor on 'w' of world, press 'e' twice
+        const state = createTestState(['hello world', ''], 0, 6); // At 'w' of 'world'
+
+        // First 'e' should move to 'd' of 'world'
+        let result = handleVimAction(state, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(10); // At 'd' of 'world'
+
+        // Second 'e' should move to the empty line (end of file in this case)
+        result = handleVimAction(result, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(1); // Should move to empty line
+        expect(result.cursorCol).toBe(0); // Empty line has col 0
+      });
+
+      it('should handle combining characters - advance from end of base character', () => {
+        // Test case for combining character word end bug
+        // "café test" where é is represented as e + combining acute accent
+        const state = createTestState(['cafe\u0301 test'], 0, 0); // Start at 'c'
+
+        // First 'e' command should move to the 'e' (position 3)
+        let result = handleVimAction(state, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(3); // At 'e' of café
+
+        // Second 'e' command should advance to end of "test" (position 9), not stay stuck
+        result = handleVimAction(result, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(9); // At 't' of "test"
+      });
+
+      it('should handle precomposed characters with diacritics', () => {
+        // Test case with precomposed é for comparison
+        const state = createTestState(['café test'], 0, 0); // Start at 'c'
+
+        // First 'e' command should move to the 'é' (position 3)
+        let result = handleVimAction(state, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(3); // At 'é' of café
+
+        // Second 'e' command should advance to end of "test" (position 8)
+        result = handleVimAction(result, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(8); // At 't' of "test"
+      });
+    });
+
+    describe('Position commands', () => {
+      it('vim_move_to_line_start should move to column 0', () => {
+        const state = createTestState(['hello world'], 0, 5);
+        const action = { type: 'vim_move_to_line_start' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(0);
+      });
+
+      it('vim_move_to_line_end should move to last character', () => {
+        const state = createTestState(['hello world'], 0, 0);
+        const action = { type: 'vim_move_to_line_end' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(10); // Last character of 'hello world'
+      });
+
+      it('vim_move_to_first_nonwhitespace should skip leading whitespace', () => {
+        const state = createTestState(['   hello world'], 0, 0);
+        const action = { type: 'vim_move_to_first_nonwhitespace' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(3); // Position of 'h'
+      });
+
+      it('vim_move_to_first_line should move to row 0', () => {
+        const state = createTestState(['line1', 'line2', 'line3'], 2, 5);
+        const action = { type: 'vim_move_to_first_line' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(0);
+      });
+
+      it('vim_move_to_last_line should move to last row', () => {
+        const state = createTestState(['line1', 'line2', 'line3'], 0, 5);
+        const action = { type: 'vim_move_to_last_line' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(2);
+        expect(result.cursorCol).toBe(0);
+      });
+
+      it('vim_move_to_line should move to specific line', () => {
+        const state = createTestState(['line1', 'line2', 'line3'], 0, 5);
+        const action = {
+          type: 'vim_move_to_line' as const,
+          payload: { lineNumber: 2 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(1); // 0-indexed
+        expect(result.cursorCol).toBe(0);
+      });
+
+      it('vim_move_to_line should clamp to valid range', () => {
+        const state = createTestState(['line1', 'line2'], 0, 0);
+        const action = {
+          type: 'vim_move_to_line' as const,
+          payload: { lineNumber: 10 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(1); // Last line
+      });
+    });
+  });
+
+  describe('Edit commands', () => {
+    describe('vim_delete_char', () => {
+      it('should delete single character', () => {
+        const state = createTestState(['hello'], 0, 1);
+        const action = {
+          type: 'vim_delete_char' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines[0]).toBe('hllo');
+        expect(result.cursorCol).toBe(1);
+      });
+
+      it('should delete multiple characters', () => {
+        const state = createTestState(['hello'], 0, 1);
+        const action = {
+          type: 'vim_delete_char' as const,
+          payload: { count: 3 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines[0]).toBe('ho');
+        expect(result.cursorCol).toBe(1);
+      });
+
+      it('should not delete past end of line', () => {
+        const state = createTestState(['hello'], 0, 3);
+        const action = {
+          type: 'vim_delete_char' as const,
+          payload: { count: 5 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines[0]).toBe('hel');
+        expect(result.cursorCol).toBe(3);
+      });
+
+      it('should do nothing at end of line', () => {
+        const state = createTestState(['hello'], 0, 5);
+        const action = {
+          type: 'vim_delete_char' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines[0]).toBe('hello');
+        expect(result.cursorCol).toBe(5);
+      });
+    });
+
+    describe('vim_delete_word_forward', () => {
+      it('should delete from cursor to next word start', () => {
+        const state = createTestState(['hello world test'], 0, 0);
+        const action = {
+          type: 'vim_delete_word_forward' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines[0]).toBe('world test');
+        expect(result.cursorCol).toBe(0);
+      });
+
+      it('should delete multiple words', () => {
+        const state = createTestState(['hello world test'], 0, 0);
+        const action = {
+          type: 'vim_delete_word_forward' as const,
+          payload: { count: 2 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines[0]).toBe('test');
+        expect(result.cursorCol).toBe(0);
+      });
+
+      it('should delete to end if no more words', () => {
+        const state = createTestState(['hello world'], 0, 6);
+        const action = {
+          type: 'vim_delete_word_forward' as const,
+          payload: { count: 2 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines[0]).toBe('hello ');
+        expect(result.cursorCol).toBe(6);
+      });
+    });
+
+    describe('vim_delete_word_backward', () => {
+      it('should delete from cursor to previous word start', () => {
+        const state = createTestState(['hello world test'], 0, 12);
+        const action = {
+          type: 'vim_delete_word_backward' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines[0]).toBe('hello test');
+        expect(result.cursorCol).toBe(6);
+      });
+
+      it('should delete multiple words backward', () => {
+        const state = createTestState(['hello world test'], 0, 12);
+        const action = {
+          type: 'vim_delete_word_backward' as const,
+          payload: { count: 2 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines[0]).toBe('test');
+        expect(result.cursorCol).toBe(0);
+      });
+    });
+
+    describe('vim_delete_line', () => {
+      it('should delete current line', () => {
+        const state = createTestState(['line1', 'line2', 'line3'], 1, 2);
+        const action = {
+          type: 'vim_delete_line' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines).toEqual(['line1', 'line3']);
+        expect(result.cursorRow).toBe(1);
+        expect(result.cursorCol).toBe(0);
+      });
+
+      it('should delete multiple lines', () => {
+        const state = createTestState(['line1', 'line2', 'line3'], 0, 2);
+        const action = {
+          type: 'vim_delete_line' as const,
+          payload: { count: 2 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines).toEqual(['line3']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(0);
+      });
+
+      it('should leave empty line when deleting all lines', () => {
+        const state = createTestState(['only line'], 0, 0);
+        const action = {
+          type: 'vim_delete_line' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines).toEqual(['']);
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(0);
+      });
+    });
+
+    describe('vim_delete_to_end_of_line', () => {
+      it('should delete from cursor to end of line', () => {
+        const state = createTestState(['hello world'], 0, 5);
+        const action = { type: 'vim_delete_to_end_of_line' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines[0]).toBe('hello');
+        expect(result.cursorCol).toBe(5);
+      });
+
+      it('should do nothing at end of line', () => {
+        const state = createTestState(['hello'], 0, 5);
+        const action = { type: 'vim_delete_to_end_of_line' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines[0]).toBe('hello');
+      });
+    });
+  });
+
+  describe('Insert mode commands', () => {
+    describe('vim_insert_at_cursor', () => {
+      it('should not change cursor position', () => {
+        const state = createTestState(['hello'], 0, 2);
+        const action = { type: 'vim_insert_at_cursor' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(2);
+      });
+    });
+
+    describe('vim_append_at_cursor', () => {
+      it('should move cursor right by one', () => {
+        const state = createTestState(['hello'], 0, 2);
+        const action = { type: 'vim_append_at_cursor' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(3);
+      });
+
+      it('should not move past end of line', () => {
+        const state = createTestState(['hello'], 0, 5);
+        const action = { type: 'vim_append_at_cursor' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(5);
+      });
+    });
+
+    describe('vim_append_at_line_end', () => {
+      it('should move cursor to end of line', () => {
+        const state = createTestState(['hello world'], 0, 3);
+        const action = { type: 'vim_append_at_line_end' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(11);
+      });
+    });
+
+    describe('vim_insert_at_line_start', () => {
+      it('should move to first non-whitespace character', () => {
+        const state = createTestState(['  hello world'], 0, 5);
+        const action = { type: 'vim_insert_at_line_start' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(2);
+      });
+
+      it('should move to column 0 for line with only whitespace', () => {
+        const state = createTestState(['   '], 0, 1);
+        const action = { type: 'vim_insert_at_line_start' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(3);
+      });
+    });
+
+    describe('vim_open_line_below', () => {
+      it('should insert a new line below the current one', () => {
+        const state = createTestState(['hello world'], 0, 5);
+        const action = { type: 'vim_open_line_below' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines).toEqual(['hello world', '']);
+        expect(result.cursorRow).toBe(1);
+        expect(result.cursorCol).toBe(0);
+      });
+    });
+
+    describe('vim_open_line_above', () => {
+      it('should insert a new line above the current one', () => {
+        const state = createTestState(['hello', 'world'], 1, 2);
+        const action = { type: 'vim_open_line_above' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines).toEqual(['hello', '', 'world']);
+        expect(result.cursorRow).toBe(1);
+        expect(result.cursorCol).toBe(0);
+      });
+    });
+
+    describe('vim_escape_insert_mode', () => {
+      it('should move cursor left', () => {
+        const state = createTestState(['hello'], 0, 3);
+        const action = { type: 'vim_escape_insert_mode' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(2);
+      });
+
+      it('should not move past beginning of line', () => {
+        const state = createTestState(['hello'], 0, 0);
+        const action = { type: 'vim_escape_insert_mode' as const };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(0);
+      });
+    });
+  });
+
+  describe('Change commands', () => {
+    describe('vim_change_word_forward', () => {
+      it('should delete from cursor to next word start', () => {
+        const state = createTestState(['hello world test'], 0, 0);
+        const action = {
+          type: 'vim_change_word_forward' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines[0]).toBe('world test');
+        expect(result.cursorCol).toBe(0);
+      });
+    });
+
+    describe('vim_change_line', () => {
+      it('should delete entire line content', () => {
+        const state = createTestState(['hello world'], 0, 5);
+        const action = {
+          type: 'vim_change_line' as const,
+          payload: { count: 1 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines[0]).toBe('');
+        expect(result.cursorCol).toBe(0);
+      });
+    });
+
+    describe('vim_change_movement', () => {
+      it('should change characters to the left', () => {
+        const state = createTestState(['hello world'], 0, 5);
+        const action = {
+          type: 'vim_change_movement' as const,
+          payload: { movement: 'h', count: 2 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines[0]).toBe('hel world');
+        expect(result.cursorCol).toBe(3);
+      });
+
+      it('should change characters to the right', () => {
+        const state = createTestState(['hello world'], 0, 5);
+        const action = {
+          type: 'vim_change_movement' as const,
+          payload: { movement: 'l', count: 3 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.lines[0]).toBe('hellorld'); // Deletes ' wo' (3 chars to the right)
+        expect(result.cursorCol).toBe(5);
+      });
+
+      it('should change multiple lines down', () => {
+        const state = createTestState(['line1', 'line2', 'line3'], 0, 2);
+        const action = {
+          type: 'vim_change_movement' as const,
+          payload: { movement: 'j', count: 2 },
+        };
+
+        const result = handleVimAction(state, action);
+        expect(result).toHaveOnlyValidCharacters();
+        // The movement 'j' with count 2 changes 2 lines starting from cursor row
+        // Since we're at cursor position 2, it changes lines starting from current row
+        expect(result.lines).toEqual(['line1', 'line2', 'line3']); // No change because count > available lines
+        expect(result.cursorRow).toBe(0);
+        expect(result.cursorCol).toBe(2);
+      });
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle empty text', () => {
+      const state = createTestState([''], 0, 0);
+      const action = {
+        type: 'vim_move_word_forward' as const,
+        payload: { count: 1 },
+      };
+
+      const result = handleVimAction(state, action);
+      expect(result).toHaveOnlyValidCharacters();
+      expect(result.cursorRow).toBe(0);
+      expect(result.cursorCol).toBe(0);
+    });
+
+    it('should handle single character line', () => {
+      const state = createTestState(['a'], 0, 0);
+      const action = { type: 'vim_move_to_line_end' as const };
+
+      const result = handleVimAction(state, action);
+      expect(result).toHaveOnlyValidCharacters();
+      expect(result.cursorCol).toBe(0); // Should be last character position
+    });
+
+    it('should handle empty lines in multi-line text', () => {
+      const state = createTestState(['line1', '', 'line3'], 1, 0);
+      const action = {
+        type: 'vim_move_word_forward' as const,
+        payload: { count: 1 },
+      };
+
+      const result = handleVimAction(state, action);
+      expect(result).toHaveOnlyValidCharacters();
+      // Should move to next line with content
+      expect(result.cursorRow).toBe(2);
+      expect(result.cursorCol).toBe(0);
+    });
+
+    it('should preserve undo stack in operations', () => {
+      const state = createTestState(['hello'], 0, 0);
+      state.undoStack = [{ lines: ['previous'], cursorRow: 0, cursorCol: 0 }];
+
+      const action = {
+        type: 'vim_delete_char' as const,
+        payload: { count: 1 },
+      };
+
+      const result = handleVimAction(state, action);
+      expect(result).toHaveOnlyValidCharacters();
+      expect(result.undoStack).toHaveLength(2); // Original plus new snapshot
+    });
+  });
+
+  describe('UTF-32 character handling in word/line operations', () => {
+    describe('Right-to-left text handling', () => {
+      it('should handle Arabic text in word movements', () => {
+        const state = createTestState(['hello مرحبا world'], 0, 0);
+
+        // Move to end of 'hello'
+        let result = handleVimAction(state, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(4); // End of 'hello'
+
+        // Move to end of Arabic word
+        result = handleVimAction(result, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(10); // End of Arabic word 'مرحبا'
+      });
+    });
+
+    describe('Chinese character handling', () => {
+      it('should handle Chinese characters in word movements', () => {
+        const state = createTestState(['hello 你好 world'], 0, 0);
+
+        // Move to end of 'hello'
+        let result = handleVimAction(state, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(4); // End of 'hello'
+
+        // Move forward to start of 'world'
+        result = handleVimAction(result, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(6); // Start of '你好'
+      });
+    });
+
+    describe('Mixed script handling', () => {
+      it('should handle mixed Latin and non-Latin scripts with word end commands', () => {
+        const state = createTestState(['test中文test'], 0, 0);
+
+        let result = handleVimAction(state, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(3); // End of 'test'
+
+        // Second word end command should move to end of '中文'
+        result = handleVimAction(result, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(5); // End of '中文'
+      });
+
+      it('should handle mixed Latin and non-Latin scripts with word forward commands', () => {
+        const state = createTestState(['test中文test'], 0, 0);
+
+        let result = handleVimAction(state, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(4); // Start of '中'
+
+        // Second word forward command should move to start of final 'test'
+        result = handleVimAction(result, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(6); // Start of final 'test'
+      });
+
+      it('should handle mixed Latin and non-Latin scripts with word backward commands', () => {
+        const state = createTestState(['test中文test'], 0, 9); // Start at end of final 'test'
+
+        let result = handleVimAction(state, {
+          type: 'vim_move_word_backward' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(6); // Start of final 'test'
+
+        // Second word backward command should move to start of '中文'
+        result = handleVimAction(result, {
+          type: 'vim_move_word_backward' as const,
+          payload: { count: 1 },
+        });
+        expect(result).toHaveOnlyValidCharacters();
+        expect(result.cursorCol).toBe(4); // Start of '中'
+      });
+
+      it('should handle Unicode block characters consistently with w and e commands', () => {
+        const state = createTestState(['██ █████ ██'], 0, 0);
+
+        // Test w command progression
+        let wResult = handleVimAction(state, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(wResult).toHaveOnlyValidCharacters();
+        expect(wResult.cursorCol).toBe(3); // Start of second block sequence
+
+        wResult = handleVimAction(wResult, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(wResult).toHaveOnlyValidCharacters();
+        expect(wResult.cursorCol).toBe(9); // Start of third block sequence
+
+        // Test e command progression from beginning
+        let eResult = handleVimAction(state, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(eResult).toHaveOnlyValidCharacters();
+        expect(eResult.cursorCol).toBe(1); // End of first block sequence
+
+        eResult = handleVimAction(eResult, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(eResult).toHaveOnlyValidCharacters();
+        expect(eResult.cursorCol).toBe(7); // End of second block sequence
+
+        eResult = handleVimAction(eResult, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(eResult).toHaveOnlyValidCharacters();
+        expect(eResult.cursorCol).toBe(10); // End of third block sequence
+      });
+
+      it('should handle strings starting with Chinese characters', () => {
+        const state = createTestState(['中文test英文word'], 0, 0);
+
+        // Test 'w' command - when at start of non-Latin word, w moves to next word
+        let wResult = handleVimAction(state, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(wResult).toHaveOnlyValidCharacters();
+        expect(wResult.cursorCol).toBe(2); // Start of 'test'
+
+        wResult = handleVimAction(wResult, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(wResult.cursorCol).toBe(6); // Start of '英文'
+
+        // Test 'e' command
+        let eResult = handleVimAction(state, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(eResult).toHaveOnlyValidCharacters();
+        expect(eResult.cursorCol).toBe(1); // End of 中文
+
+        eResult = handleVimAction(eResult, {
+          type: 'vim_move_word_end' as const,
+          payload: { count: 1 },
+        });
+        expect(eResult.cursorCol).toBe(5); // End of test
+      });
+
+      it('should handle strings starting with Arabic characters', () => {
+        const state = createTestState(['مرحباhelloسلام'], 0, 0);
+
+        // Test 'w' command - when at start of non-Latin word, w moves to next word
+        let wResult = handleVimAction(state, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(wResult).toHaveOnlyValidCharacters();
+        expect(wResult.cursorCol).toBe(5); // Start of 'hello'
+
+        wResult = handleVimAction(wResult, {
+          type: 'vim_move_word_forward' as const,
+          payload: { count: 1 },
+        });
+        expect(wResult.cursorCol).toBe(10); // Start of 'سلام'
+
+        // Test 'b' command from end
+        const bState = createTestState(['مرحباhelloسلام'], 0, 13);
+        let bResult = handleVimAction(bState, {
+          type: 'vim_move_word_backward' as const,
+          payload: { count: 1 },
+        });
+        expect(bResult).toHaveOnlyValidCharacters();
+        expect(bResult.cursorCol).toBe(10); // Start of سلام
+
+        bResult = handleVimAction(bResult, {
+          type: 'vim_move_word_backward' as const,
+          payload: { count: 1 },
+        });
+        expect(bResult.cursorCol).toBe(5); // Start of hello
+      });
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/components/shared/vim-buffer-actions.ts

@@ -0,0 +1,814 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  TextBufferState,
+  TextBufferAction,
+  getLineRangeOffsets,
+  getPositionFromOffsets,
+  replaceRangeInternal,
+  pushUndo,
+  isWordCharStrict,
+  isWordCharWithCombining,
+  isCombiningMark,
+  findNextWordAcrossLines,
+  findPrevWordAcrossLines,
+  findWordEndInLine,
+} from './text-buffer.js';
+import { cpLen, toCodePoints } from '../../utils/textUtils.js';
+import { assumeExhaustive } from '../../../utils/checks.js';
+
+// Check if we're at the end of a base word (on the last base character)
+// Returns true if current position has a base character followed only by combining marks until non-word
+function isAtEndOfBaseWord(lineCodePoints: string[], col: number): boolean {
+  if (!isWordCharStrict(lineCodePoints[col])) return false;
+
+  // Look ahead to see if we have only combining marks followed by non-word
+  let i = col + 1;
+
+  // Skip any combining marks
+  while (i < lineCodePoints.length && isCombiningMark(lineCodePoints[i])) {
+    i++;
+  }
+
+  // If we hit end of line or non-word character, we were at end of base word
+  return i >= lineCodePoints.length || !isWordCharStrict(lineCodePoints[i]);
+}
+
+export type VimAction = Extract<
+  TextBufferAction,
+  | { type: 'vim_delete_word_forward' }
+  | { type: 'vim_delete_word_backward' }
+  | { type: 'vim_delete_word_end' }
+  | { type: 'vim_change_word_forward' }
+  | { type: 'vim_change_word_backward' }
+  | { type: 'vim_change_word_end' }
+  | { type: 'vim_delete_line' }
+  | { type: 'vim_change_line' }
+  | { type: 'vim_delete_to_end_of_line' }
+  | { type: 'vim_change_to_end_of_line' }
+  | { type: 'vim_change_movement' }
+  | { type: 'vim_move_left' }
+  | { type: 'vim_move_right' }
+  | { type: 'vim_move_up' }
+  | { type: 'vim_move_down' }
+  | { type: 'vim_move_word_forward' }
+  | { type: 'vim_move_word_backward' }
+  | { type: 'vim_move_word_end' }
+  | { type: 'vim_delete_char' }
+  | { type: 'vim_insert_at_cursor' }
+  | { type: 'vim_append_at_cursor' }
+  | { type: 'vim_open_line_below' }
+  | { type: 'vim_open_line_above' }
+  | { type: 'vim_append_at_line_end' }
+  | { type: 'vim_insert_at_line_start' }
+  | { type: 'vim_move_to_line_start' }
+  | { type: 'vim_move_to_line_end' }
+  | { type: 'vim_move_to_first_nonwhitespace' }
+  | { type: 'vim_move_to_first_line' }
+  | { type: 'vim_move_to_last_line' }
+  | { type: 'vim_move_to_line' }
+  | { type: 'vim_escape_insert_mode' }
+>;
+
+export function handleVimAction(
+  state: TextBufferState,
+  action: VimAction,
+): TextBufferState {
+  const { lines, cursorRow, cursorCol } = state;
+
+  switch (action.type) {
+    case 'vim_delete_word_forward':
+    case 'vim_change_word_forward': {
+      const { count } = action.payload;
+      let endRow = cursorRow;
+      let endCol = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const nextWord = findNextWordAcrossLines(lines, endRow, endCol, true);
+        if (nextWord) {
+          endRow = nextWord.row;
+          endCol = nextWord.col;
+        } else {
+          // No more words, delete/change to end of current word or line
+          const currentLine = lines[endRow] || '';
+          const wordEnd = findWordEndInLine(currentLine, endCol);
+          if (wordEnd !== null) {
+            endCol = wordEnd + 1; // Include the character at word end
+          } else {
+            endCol = cpLen(currentLine);
+          }
+          break;
+        }
+      }
+
+      if (endRow !== cursorRow || endCol !== cursorCol) {
+        const nextState = pushUndo(state);
+        return replaceRangeInternal(
+          nextState,
+          cursorRow,
+          cursorCol,
+          endRow,
+          endCol,
+          '',
+        );
+      }
+      return state;
+    }
+
+    case 'vim_delete_word_backward':
+    case 'vim_change_word_backward': {
+      const { count } = action.payload;
+      let startRow = cursorRow;
+      let startCol = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const prevWord = findPrevWordAcrossLines(lines, startRow, startCol);
+        if (prevWord) {
+          startRow = prevWord.row;
+          startCol = prevWord.col;
+        } else {
+          break;
+        }
+      }
+
+      if (startRow !== cursorRow || startCol !== cursorCol) {
+        const nextState = pushUndo(state);
+        return replaceRangeInternal(
+          nextState,
+          startRow,
+          startCol,
+          cursorRow,
+          cursorCol,
+          '',
+        );
+      }
+      return state;
+    }
+
+    case 'vim_delete_word_end':
+    case 'vim_change_word_end': {
+      const { count } = action.payload;
+      let row = cursorRow;
+      let col = cursorCol;
+      let endRow = cursorRow;
+      let endCol = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const wordEnd = findNextWordAcrossLines(lines, row, col, false);
+        if (wordEnd) {
+          endRow = wordEnd.row;
+          endCol = wordEnd.col + 1; // Include the character at word end
+          // For next iteration, move to start of next word
+          if (i < count - 1) {
+            const nextWord = findNextWordAcrossLines(
+              lines,
+              wordEnd.row,
+              wordEnd.col + 1,
+              true,
+            );
+            if (nextWord) {
+              row = nextWord.row;
+              col = nextWord.col;
+            } else {
+              break; // No more words
+            }
+          }
+        } else {
+          break;
+        }
+      }
+
+      // Ensure we don't go past the end of the last line
+      if (endRow < lines.length) {
+        const lineLen = cpLen(lines[endRow] || '');
+        endCol = Math.min(endCol, lineLen);
+      }
+
+      if (endRow !== cursorRow || endCol !== cursorCol) {
+        const nextState = pushUndo(state);
+        return replaceRangeInternal(
+          nextState,
+          cursorRow,
+          cursorCol,
+          endRow,
+          endCol,
+          '',
+        );
+      }
+      return state;
+    }
+
+    case 'vim_delete_line': {
+      const { count } = action.payload;
+      if (lines.length === 0) return state;
+
+      const linesToDelete = Math.min(count, lines.length - cursorRow);
+      const totalLines = lines.length;
+
+      if (totalLines === 1 || linesToDelete >= totalLines) {
+        // If there's only one line, or we're deleting all remaining lines,
+        // clear the content but keep one empty line (text editors should never be completely empty)
+        const nextState = pushUndo(state);
+        return {
+          ...nextState,
+          lines: [''],
+          cursorRow: 0,
+          cursorCol: 0,
+          preferredCol: null,
+        };
+      }
+
+      const nextState = pushUndo(state);
+      const newLines = [...nextState.lines];
+      newLines.splice(cursorRow, linesToDelete);
+
+      // Adjust cursor position
+      const newCursorRow = Math.min(cursorRow, newLines.length - 1);
+      const newCursorCol = 0; // Vim places cursor at beginning of line after dd
+
+      return {
+        ...nextState,
+        lines: newLines,
+        cursorRow: newCursorRow,
+        cursorCol: newCursorCol,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_change_line': {
+      const { count } = action.payload;
+      if (lines.length === 0) return state;
+
+      const linesToChange = Math.min(count, lines.length - cursorRow);
+      const nextState = pushUndo(state);
+
+      const { startOffset, endOffset } = getLineRangeOffsets(
+        cursorRow,
+        linesToChange,
+        nextState.lines,
+      );
+      const { startRow, startCol, endRow, endCol } = getPositionFromOffsets(
+        startOffset,
+        endOffset,
+        nextState.lines,
+      );
+      return replaceRangeInternal(
+        nextState,
+        startRow,
+        startCol,
+        endRow,
+        endCol,
+        '',
+      );
+    }
+
+    case 'vim_delete_to_end_of_line':
+    case 'vim_change_to_end_of_line': {
+      const currentLine = lines[cursorRow] || '';
+      if (cursorCol < cpLen(currentLine)) {
+        const nextState = pushUndo(state);
+        return replaceRangeInternal(
+          nextState,
+          cursorRow,
+          cursorCol,
+          cursorRow,
+          cpLen(currentLine),
+          '',
+        );
+      }
+      return state;
+    }
+
+    case 'vim_change_movement': {
+      const { movement, count } = action.payload;
+      const totalLines = lines.length;
+
+      switch (movement) {
+        case 'h': {
+          // Left
+          // Change N characters to the left
+          const startCol = Math.max(0, cursorCol - count);
+          return replaceRangeInternal(
+            pushUndo(state),
+            cursorRow,
+            startCol,
+            cursorRow,
+            cursorCol,
+            '',
+          );
+        }
+
+        case 'j': {
+          // Down
+          const linesToChange = Math.min(count, totalLines - cursorRow);
+          if (linesToChange > 0) {
+            if (totalLines === 1) {
+              const currentLine = state.lines[0] || '';
+              return replaceRangeInternal(
+                pushUndo(state),
+                0,
+                0,
+                0,
+                cpLen(currentLine),
+                '',
+              );
+            } else {
+              const nextState = pushUndo(state);
+              const { startOffset, endOffset } = getLineRangeOffsets(
+                cursorRow,
+                linesToChange,
+                nextState.lines,
+              );
+              const { startRow, startCol, endRow, endCol } =
+                getPositionFromOffsets(startOffset, endOffset, nextState.lines);
+              return replaceRangeInternal(
+                nextState,
+                startRow,
+                startCol,
+                endRow,
+                endCol,
+                '',
+              );
+            }
+          }
+          return state;
+        }
+
+        case 'k': {
+          // Up
+          const upLines = Math.min(count, cursorRow + 1);
+          if (upLines > 0) {
+            if (state.lines.length === 1) {
+              const currentLine = state.lines[0] || '';
+              return replaceRangeInternal(
+                pushUndo(state),
+                0,
+                0,
+                0,
+                cpLen(currentLine),
+                '',
+              );
+            } else {
+              const startRow = Math.max(0, cursorRow - count + 1);
+              const linesToChange = cursorRow - startRow + 1;
+              const nextState = pushUndo(state);
+              const { startOffset, endOffset } = getLineRangeOffsets(
+                startRow,
+                linesToChange,
+                nextState.lines,
+              );
+              const {
+                startRow: newStartRow,
+                startCol,
+                endRow,
+                endCol,
+              } = getPositionFromOffsets(
+                startOffset,
+                endOffset,
+                nextState.lines,
+              );
+              const resultState = replaceRangeInternal(
+                nextState,
+                newStartRow,
+                startCol,
+                endRow,
+                endCol,
+                '',
+              );
+              return {
+                ...resultState,
+                cursorRow: startRow,
+                cursorCol: 0,
+              };
+            }
+          }
+          return state;
+        }
+
+        case 'l': {
+          // Right
+          // Change N characters to the right
+          return replaceRangeInternal(
+            pushUndo(state),
+            cursorRow,
+            cursorCol,
+            cursorRow,
+            Math.min(cpLen(lines[cursorRow] || ''), cursorCol + count),
+            '',
+          );
+        }
+
+        default:
+          return state;
+      }
+    }
+
+    case 'vim_move_left': {
+      const { count } = action.payload;
+      const { cursorRow, cursorCol, lines } = state;
+      let newRow = cursorRow;
+      let newCol = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        if (newCol > 0) {
+          newCol--;
+        } else if (newRow > 0) {
+          // Move to end of previous line
+          newRow--;
+          const prevLine = lines[newRow] || '';
+          const prevLineLength = cpLen(prevLine);
+          // Position on last character, or column 0 for empty lines
+          newCol = prevLineLength === 0 ? 0 : prevLineLength - 1;
+        }
+      }
+
+      return {
+        ...state,
+        cursorRow: newRow,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_right': {
+      const { count } = action.payload;
+      const { cursorRow, cursorCol, lines } = state;
+      let newRow = cursorRow;
+      let newCol = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const currentLine = lines[newRow] || '';
+        const lineLength = cpLen(currentLine);
+        // Don't move past the last character of the line
+        // For empty lines, stay at column 0; for non-empty lines, don't go past last character
+        if (lineLength === 0) {
+          // Empty line - try to move to next line
+          if (newRow < lines.length - 1) {
+            newRow++;
+            newCol = 0;
+          }
+        } else if (newCol < lineLength - 1) {
+          newCol++;
+
+          // Skip over combining marks - don't let cursor land on them
+          const currentLinePoints = toCodePoints(currentLine);
+          while (
+            newCol < currentLinePoints.length &&
+            isCombiningMark(currentLinePoints[newCol]) &&
+            newCol < lineLength - 1
+          ) {
+            newCol++;
+          }
+        } else if (newRow < lines.length - 1) {
+          // At end of line - move to beginning of next line
+          newRow++;
+          newCol = 0;
+        }
+      }
+
+      return {
+        ...state,
+        cursorRow: newRow,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_up': {
+      const { count } = action.payload;
+      const { cursorRow, cursorCol, lines } = state;
+      const newRow = Math.max(0, cursorRow - count);
+      const targetLine = lines[newRow] || '';
+      const targetLineLength = cpLen(targetLine);
+      const newCol = Math.min(
+        cursorCol,
+        targetLineLength > 0 ? targetLineLength - 1 : 0,
+      );
+
+      return {
+        ...state,
+        cursorRow: newRow,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_down': {
+      const { count } = action.payload;
+      const { cursorRow, cursorCol, lines } = state;
+      const newRow = Math.min(lines.length - 1, cursorRow + count);
+      const targetLine = lines[newRow] || '';
+      const targetLineLength = cpLen(targetLine);
+      const newCol = Math.min(
+        cursorCol,
+        targetLineLength > 0 ? targetLineLength - 1 : 0,
+      );
+
+      return {
+        ...state,
+        cursorRow: newRow,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_word_forward': {
+      const { count } = action.payload;
+      let row = cursorRow;
+      let col = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const nextWord = findNextWordAcrossLines(lines, row, col, true);
+        if (nextWord) {
+          row = nextWord.row;
+          col = nextWord.col;
+        } else {
+          // No more words to move to
+          break;
+        }
+      }
+
+      return {
+        ...state,
+        cursorRow: row,
+        cursorCol: col,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_word_backward': {
+      const { count } = action.payload;
+      let row = cursorRow;
+      let col = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const prevWord = findPrevWordAcrossLines(lines, row, col);
+        if (prevWord) {
+          row = prevWord.row;
+          col = prevWord.col;
+        } else {
+          break;
+        }
+      }
+
+      return {
+        ...state,
+        cursorRow: row,
+        cursorCol: col,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_word_end': {
+      const { count } = action.payload;
+      let row = cursorRow;
+      let col = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        // Special handling for the first iteration when we're at end of word
+        if (i === 0) {
+          const currentLine = lines[row] || '';
+          const lineCodePoints = toCodePoints(currentLine);
+
+          // Check if we're at the end of a word (on the last base character)
+          const atEndOfWord =
+            col < lineCodePoints.length &&
+            isWordCharStrict(lineCodePoints[col]) &&
+            (col + 1 >= lineCodePoints.length ||
+              !isWordCharWithCombining(lineCodePoints[col + 1]) ||
+              // Or if we're on a base char followed only by combining marks until non-word
+              (isWordCharStrict(lineCodePoints[col]) &&
+                isAtEndOfBaseWord(lineCodePoints, col)));
+
+          if (atEndOfWord) {
+            // We're already at end of word, find next word end
+            const nextWord = findNextWordAcrossLines(
+              lines,
+              row,
+              col + 1,
+              false,
+            );
+            if (nextWord) {
+              row = nextWord.row;
+              col = nextWord.col;
+              continue;
+            }
+          }
+        }
+
+        const wordEnd = findNextWordAcrossLines(lines, row, col, false);
+        if (wordEnd) {
+          row = wordEnd.row;
+          col = wordEnd.col;
+        } else {
+          break;
+        }
+      }
+
+      return {
+        ...state,
+        cursorRow: row,
+        cursorCol: col,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_delete_char': {
+      const { count } = action.payload;
+      const { cursorRow, cursorCol, lines } = state;
+      const currentLine = lines[cursorRow] || '';
+      const lineLength = cpLen(currentLine);
+
+      if (cursorCol < lineLength) {
+        const deleteCount = Math.min(count, lineLength - cursorCol);
+        const nextState = pushUndo(state);
+        return replaceRangeInternal(
+          nextState,
+          cursorRow,
+          cursorCol,
+          cursorRow,
+          cursorCol + deleteCount,
+          '',
+        );
+      }
+      return state;
+    }
+
+    case 'vim_insert_at_cursor': {
+      // Just return state - mode change is handled elsewhere
+      return state;
+    }
+
+    case 'vim_append_at_cursor': {
+      const { cursorRow, cursorCol, lines } = state;
+      const currentLine = lines[cursorRow] || '';
+      const newCol = cursorCol < cpLen(currentLine) ? cursorCol + 1 : cursorCol;
+
+      return {
+        ...state,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_open_line_below': {
+      const { cursorRow, lines } = state;
+      const nextState = pushUndo(state);
+
+      // Insert newline at end of current line
+      const endOfLine = cpLen(lines[cursorRow] || '');
+      return replaceRangeInternal(
+        nextState,
+        cursorRow,
+        endOfLine,
+        cursorRow,
+        endOfLine,
+        '\n',
+      );
+    }
+
+    case 'vim_open_line_above': {
+      const { cursorRow } = state;
+      const nextState = pushUndo(state);
+
+      // Insert newline at beginning of current line
+      const resultState = replaceRangeInternal(
+        nextState,
+        cursorRow,
+        0,
+        cursorRow,
+        0,
+        '\n',
+      );
+
+      // Move cursor to the new line above
+      return {
+        ...resultState,
+        cursorRow,
+        cursorCol: 0,
+      };
+    }
+
+    case 'vim_append_at_line_end': {
+      const { cursorRow, lines } = state;
+      const lineLength = cpLen(lines[cursorRow] || '');
+
+      return {
+        ...state,
+        cursorCol: lineLength,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_insert_at_line_start': {
+      const { cursorRow, lines } = state;
+      const currentLine = lines[cursorRow] || '';
+      let col = 0;
+
+      // Find first non-whitespace character using proper Unicode handling
+      const lineCodePoints = toCodePoints(currentLine);
+      while (col < lineCodePoints.length && /\s/.test(lineCodePoints[col])) {
+        col++;
+      }
+
+      return {
+        ...state,
+        cursorCol: col,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_to_line_start': {
+      return {
+        ...state,
+        cursorCol: 0,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_to_line_end': {
+      const { cursorRow, lines } = state;
+      const lineLength = cpLen(lines[cursorRow] || '');
+
+      return {
+        ...state,
+        cursorCol: lineLength > 0 ? lineLength - 1 : 0,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_to_first_nonwhitespace': {
+      const { cursorRow, lines } = state;
+      const currentLine = lines[cursorRow] || '';
+      let col = 0;
+
+      // Find first non-whitespace character using proper Unicode handling
+      const lineCodePoints = toCodePoints(currentLine);
+      while (col < lineCodePoints.length && /\s/.test(lineCodePoints[col])) {
+        col++;
+      }
+
+      return {
+        ...state,
+        cursorCol: col,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_to_first_line': {
+      return {
+        ...state,
+        cursorRow: 0,
+        cursorCol: 0,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_to_last_line': {
+      const { lines } = state;
+      const lastRow = lines.length - 1;
+
+      return {
+        ...state,
+        cursorRow: lastRow,
+        cursorCol: 0,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_to_line': {
+      const { lineNumber } = action.payload;
+      const { lines } = state;
+      const targetRow = Math.min(Math.max(0, lineNumber - 1), lines.length - 1);
+
+      return {
+        ...state,
+        cursorRow: targetRow,
+        cursorCol: 0,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_escape_insert_mode': {
+      // Move cursor left if not at beginning of line (vim behavior when exiting insert mode)
+      const { cursorCol } = state;
+      const newCol = cursorCol > 0 ? cursorCol - 1 : 0;
+
+      return {
+        ...state,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    default: {
+      // This should never happen if TypeScript is working correctly
+      assumeExhaustive(action);
+      return state;
+    }
+  }
+}

projects/ui/qwen-code/packages/cli/src/ui/utils/__snapshots__/MarkdownDisplay.test.tsx.snap

@@ -0,0 +1,93 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`<MarkdownDisplay /> > correctly parses a mix of markdown elements 1`] = `
+"Main Title
+
+Here is a paragraph.
+
+ - List item 1
+ - List item 2
+
+ 1 some code
+
+Another paragraph.
+"
+`;
+
+exports[`<MarkdownDisplay /> > handles a table at the end of the input 1`] = `
+"Some text before.
+| A | B |
+|---|
+| 1 | 2 |"
+`;
+
+exports[`<MarkdownDisplay /> > handles unclosed (pending) code blocks 1`] = `" 1 let y = 2;"`;
+
+exports[`<MarkdownDisplay /> > hides line numbers in code blocks when showLineNumbers is false 1`] = `" const x = 1;"`;
+
+exports[`<MarkdownDisplay /> > inserts a single space between paragraphs 1`] = `
+"Paragraph 1.
+
+Paragraph 2."
+`;
+
+exports[`<MarkdownDisplay /> > renders a fenced code block with a language 1`] = `
+" 1 const x = 1;
+ 2 console.log(x);"
+`;
+
+exports[`<MarkdownDisplay /> > renders a fenced code block without a language 1`] = `" 1 plain text"`;
+
+exports[`<MarkdownDisplay /> > renders a simple paragraph 1`] = `"Hello, world."`;
+
+exports[`<MarkdownDisplay /> > renders headers with correct levels 1`] = `
+"Header 1
+Header 2
+Header 3
+Header 4
+"
+`;
+
+exports[`<MarkdownDisplay /> > renders horizontal rules 1`] = `
+"Hello
+---
+World
+---
+Test
+"
+`;
+
+exports[`<MarkdownDisplay /> > renders nested unordered lists 1`] = `
+" * Level 1
+   * Level 2
+     * Level 3
+"
+`;
+
+exports[`<MarkdownDisplay /> > renders nothing for empty text 1`] = `""`;
+
+exports[`<MarkdownDisplay /> > renders ordered lists 1`] = `
+" 1. First item
+ 2. Second item
+"
+`;
+
+exports[`<MarkdownDisplay /> > renders tables correctly 1`] = `
+"
+┌──────────┬──────────┐
+│ Header 1 │ Header 2 │
+├──────────┼──────────┤
+│ Cell 1   │ Cell 2   │
+│ Cell 3   │ Cell 4   │
+└──────────┴──────────┘
+"
+`;
+
+exports[`<MarkdownDisplay /> > renders unordered lists with different markers 1`] = `
+" - item A
+ * item B
+ + item C
+"
+`;
+
+exports[`<MarkdownDisplay /> > shows line numbers in code blocks by default 1`] = `" 1 const x = 1;"`;

projects/ui/qwen-code/packages/core/src/code_assist/codeAssist.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { AuthType, ContentGenerator } from '../core/contentGenerator.js';
+import { getOauthClient } from './oauth2.js';
+import { setupUser } from './setup.js';
+import { CodeAssistServer, HttpOptions } from './server.js';
+import { Config } from '../config/config.js';
+
+export async function createCodeAssistContentGenerator(
+  httpOptions: HttpOptions,
+  authType: AuthType,
+  config: Config,
+  sessionId?: string,
+): Promise<ContentGenerator> {
+  if (
+    authType === AuthType.LOGIN_WITH_GOOGLE ||
+    authType === AuthType.CLOUD_SHELL
+  ) {
+    const authClient = await getOauthClient(authType, config);
+    const userData = await setupUser(authClient);
+    return new CodeAssistServer(
+      authClient,
+      userData.projectId,
+      httpOptions,
+      sessionId,
+      userData.userTier,
+    );
+  }
+
+  throw new Error(`Unsupported authType: ${authType}`);
+}

projects/ui/qwen-code/packages/core/src/index.test.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+
+describe('placeholder tests', () => {
+  it('should pass', () => {
+    expect(true).toBe(true);
+  });
+});

projects/ui/qwen-code/packages/core/src/index.ts

@@ -0,0 +1,107 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Export config
+export * from './config/config.js';
+
+// Export Core Logic
+export * from './core/client.js';
+export * from './core/contentGenerator.js';
+export * from './core/loggingContentGenerator.js';
+export * from './core/geminiChat.js';
+export * from './core/logger.js';
+export * from './core/prompts.js';
+export * from './core/tokenLimits.js';
+export * from './core/turn.js';
+export * from './core/geminiRequest.js';
+export * from './core/coreToolScheduler.js';
+export * from './core/nonInteractiveToolExecutor.js';
+
+export * from './code_assist/codeAssist.js';
+export * from './code_assist/oauth2.js';
+export * from './qwen/qwenOAuth2.js';
+export * from './code_assist/server.js';
+export * from './code_assist/types.js';
+
+// Export utilities
+export * from './utils/paths.js';
+export * from './utils/schemaValidator.js';
+export * from './utils/errors.js';
+export * from './utils/getFolderStructure.js';
+export * from './utils/memoryDiscovery.js';
+export * from './utils/gitIgnoreParser.js';
+export * from './utils/gitUtils.js';
+export * from './utils/editor.js';
+export * from './utils/quotaErrorDetection.js';
+export * from './utils/fileUtils.js';
+export * from './utils/retry.js';
+export * from './utils/shell-utils.js';
+export * from './utils/systemEncoding.js';
+export * from './utils/textUtils.js';
+export * from './utils/formatters.js';
+export * from './utils/filesearch/fileSearch.js';
+export * from './utils/errorParsing.js';
+
+// Export services
+export * from './services/fileDiscoveryService.js';
+export * from './services/gitService.js';
+export * from './services/chatRecordingService.js';
+export * from './services/fileSystemService.js';
+
+// Export IDE specific logic
+export * from './ide/ide-client.js';
+export * from './ide/ideContext.js';
+export * from './ide/ide-installer.js';
+export * from './ide/constants.js';
+export { getIdeInfo, DetectedIde, IdeInfo } from './ide/detect-ide.js';
+export * from './ide/constants.js';
+
+// Export Shell Execution Service
+export * from './services/shellExecutionService.js';
+
+// Export base tool definitions
+export * from './tools/tools.js';
+export * from './tools/tool-error.js';
+export * from './tools/tool-registry.js';
+
+// Export prompt logic
+export * from './prompts/mcp-prompts.js';
+
+// Export specific tool logic
+export * from './tools/read-file.js';
+export * from './tools/ls.js';
+export * from './tools/grep.js';
+export * from './tools/glob.js';
+export * from './tools/edit.js';
+export * from './tools/write-file.js';
+export * from './tools/web-fetch.js';
+export * from './tools/memoryTool.js';
+export * from './tools/shell.js';
+export * from './tools/web-search.js';
+export * from './tools/read-many-files.js';
+export * from './tools/mcp-client.js';
+export * from './tools/mcp-tool.js';
+
+// MCP OAuth
+export { MCPOAuthProvider } from './mcp/oauth-provider.js';
+export {
+  MCPOAuthToken,
+  MCPOAuthCredentials,
+  MCPOAuthTokenStorage,
+} from './mcp/oauth-token-storage.js';
+export type { MCPOAuthConfig } from './mcp/oauth-provider.js';
+export type {
+  OAuthAuthorizationServerMetadata,
+  OAuthProtectedResourceMetadata,
+} from './mcp/oauth-utils.js';
+export { OAuthUtils } from './mcp/oauth-utils.js';
+
+// Export telemetry functions
+export * from './telemetry/index.js';
+export { sessionId } from './utils/session.js';
+export * from './utils/browser.js';
+// OpenAI Logging Utilities
+export { OpenAILogger, openaiLogger } from './utils/openaiLogger.js';