@didim365/agent-cli 0.1.1 → 0.1.2

package/dist/src/ui/components/InputPrompt.test.js

@@ -1,2596 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { renderWithProviders, createMockSettings, } from '../../test-utils/render.js';
-import { waitFor } from '../../test-utils/async.js';
-import { act, useState } from 'react';
-import { InputPrompt } from './InputPrompt.js';
-import { calculateTransformationsForLine, calculateTransformedLine, } from './shared/text-buffer.js';
-import { ApprovalMode, debugLogger } from '@didim365/agent-cli-core';
-import * as path from 'node:path';
-import { CommandKind } from '../commands/types.js';
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { useShellHistory } from '../hooks/useShellHistory.js';
-import { useCommandCompletion, CompletionMode, } from '../hooks/useCommandCompletion.js';
-import { useInputHistory } from '../hooks/useInputHistory.js';
-import { useReverseSearchCompletion } from '../hooks/useReverseSearchCompletion.js';
-import clipboardy from 'clipboardy';
-import * as clipboardUtils from '../utils/clipboardUtils.js';
-import { useKittyKeyboardProtocol } from '../hooks/useKittyKeyboardProtocol.js';
-import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
-import stripAnsi from 'strip-ansi';
-import chalk from 'chalk';
-import { StreamingState } from '../types.js';
-import { terminalCapabilityManager } from '../utils/terminalCapabilityManager.js';
-import { isLowColorDepth } from '../utils/terminalUtils.js';
-vi.mock('../hooks/useShellHistory.js');
-vi.mock('../hooks/useCommandCompletion.js');
-vi.mock('../hooks/useInputHistory.js');
-vi.mock('../hooks/useReverseSearchCompletion.js');
-vi.mock('clipboardy');
-vi.mock('../utils/clipboardUtils.js');
-vi.mock('../hooks/useKittyKeyboardProtocol.js');
-vi.mock('../utils/terminalUtils.js', () => ({
-    isLowColorDepth: vi.fn(() => false),
-}));
-const mockSlashCommands = [
-    {
-        name: 'clear',
-        kind: CommandKind.BUILT_IN,
-        description: 'Clear screen',
-        action: vi.fn(),
-    },
-    {
-        name: 'memory',
-        kind: CommandKind.BUILT_IN,
-        description: 'Manage memory',
-        subCommands: [
-            {
-                name: 'show',
-                kind: CommandKind.BUILT_IN,
-                description: 'Show memory',
-                action: vi.fn(),
-            },
-            {
-                name: 'add',
-                kind: CommandKind.BUILT_IN,
-                description: 'Add to memory',
-                action: vi.fn(),
-            },
-            {
-                name: 'refresh',
-                kind: CommandKind.BUILT_IN,
-                description: 'Refresh memory',
-                action: vi.fn(),
-            },
-        ],
-    },
-    {
-        name: 'chat',
-        description: 'Manage chats',
-        kind: CommandKind.BUILT_IN,
-        subCommands: [
-            {
-                name: 'resume',
-                description: 'Resume a chat',
-                kind: CommandKind.BUILT_IN,
-                action: vi.fn(),
-                completion: async () => ['fix-foo', 'fix-bar'],
-            },
-        ],
-    },
-    {
-        name: 'resume',
-        description: 'Browse and resume sessions',
-        kind: CommandKind.BUILT_IN,
-        action: vi.fn(),
-    },
-];
-describe('InputPrompt', () => {
-    let props;
-    let mockShellHistory;
-    let mockCommandCompletion;
-    let mockInputHistory;
-    let mockReverseSearchCompletion;
-    let mockBuffer;
-    let mockCommandContext;
-    const mockedUseShellHistory = vi.mocked(useShellHistory);
-    const mockedUseCommandCompletion = vi.mocked(useCommandCompletion);
-    const mockedUseInputHistory = vi.mocked(useInputHistory);
-    const mockedUseReverseSearchCompletion = vi.mocked(useReverseSearchCompletion);
-    const mockedUseKittyKeyboardProtocol = vi.mocked(useKittyKeyboardProtocol);
-    const mockSetEmbeddedShellFocused = vi.fn();
-    const uiActions = {
-        setEmbeddedShellFocused: mockSetEmbeddedShellFocused,
-    };
-    beforeEach(() => {
-        vi.resetAllMocks();
-        vi.spyOn(terminalCapabilityManager, 'isKittyProtocolEnabled').mockReturnValue(true);
-        mockCommandContext = createMockCommandContext();
-        mockBuffer = {
-            text: '',
-            cursor: [0, 0],
-            lines: [''],
-            setText: vi.fn((newText) => {
-                mockBuffer.text = newText;
-                mockBuffer.lines = [newText];
-                mockBuffer.cursor = [0, newText.length];
-                mockBuffer.viewportVisualLines = [newText];
-                mockBuffer.allVisualLines = [newText];
-                mockBuffer.visualToLogicalMap = [[0, 0]];
-            }),
-            replaceRangeByOffset: vi.fn(),
-            viewportVisualLines: [''],
-            allVisualLines: [''],
-            visualCursor: [0, 0],
-            visualScrollRow: 0,
-            handleInput: vi.fn(),
-            move: vi.fn(),
-            moveToOffset: vi.fn((offset) => {
-                mockBuffer.cursor = [0, offset];
-            }),
-            moveToVisualPosition: vi.fn(),
-            killLineRight: vi.fn(),
-            killLineLeft: vi.fn(),
-            openInExternalEditor: vi.fn(),
-            newline: vi.fn(),
-            undo: vi.fn(),
-            redo: vi.fn(),
-            backspace: vi.fn(),
-            preferredCol: null,
-            selectionAnchor: null,
-            insert: vi.fn(),
-            del: vi.fn(),
-            replaceRange: vi.fn(),
-            deleteWordLeft: vi.fn(),
-            deleteWordRight: vi.fn(),
-            visualToLogicalMap: [[0, 0]],
-            visualToTransformedMap: [0],
-            transformationsByLine: [],
-            getOffset: vi.fn().mockReturnValue(0),
-            pastedContent: {},
-        };
-        mockShellHistory = {
-            history: [],
-            addCommandToHistory: vi.fn(),
-            getPreviousCommand: vi.fn().mockReturnValue(null),
-            getNextCommand: vi.fn().mockReturnValue(null),
-            resetHistoryPosition: vi.fn(),
-        };
-        mockedUseShellHistory.mockReturnValue(mockShellHistory);
-        mockCommandCompletion = {
-            suggestions: [],
-            activeSuggestionIndex: -1,
-            isLoadingSuggestions: false,
-            showSuggestions: false,
-            visibleStartIndex: 0,
-            isPerfectMatch: false,
-            navigateUp: vi.fn(),
-            navigateDown: vi.fn(),
-            resetCompletionState: vi.fn(),
-            setActiveSuggestionIndex: vi.fn(),
-            setShowSuggestions: vi.fn(),
-            handleAutocomplete: vi.fn(),
-            promptCompletion: {
-                text: '',
-                accept: vi.fn(),
-                clear: vi.fn(),
-                isLoading: false,
-                isActive: false,
-                markSelected: vi.fn(),
-            },
-            getCommandFromSuggestion: vi.fn().mockReturnValue(undefined),
-            slashCompletionRange: {
-                completionStart: -1,
-                completionEnd: -1,
-                getCommandFromSuggestion: vi.fn().mockReturnValue(undefined),
-                isArgumentCompletion: false,
-                leafCommand: null,
-            },
-            getCompletedText: vi.fn().mockReturnValue(null),
-            completionMode: CompletionMode.IDLE,
-        };
-        mockedUseCommandCompletion.mockReturnValue(mockCommandCompletion);
-        mockInputHistory = {
-            navigateUp: vi.fn(),
-            navigateDown: vi.fn(),
-            handleSubmit: vi.fn(),
-        };
-        mockedUseInputHistory.mockReturnValue(mockInputHistory);
-        mockReverseSearchCompletion = {
-            suggestions: [],
-            activeSuggestionIndex: -1,
-            visibleStartIndex: 0,
-            showSuggestions: false,
-            isLoadingSuggestions: false,
-            navigateUp: vi.fn(),
-            navigateDown: vi.fn(),
-            handleAutocomplete: vi.fn(),
-            resetCompletionState: vi.fn(),
-        };
-        mockedUseReverseSearchCompletion.mockReturnValue(mockReverseSearchCompletion);
-        mockedUseKittyKeyboardProtocol.mockReturnValue({
-            enabled: false,
-            checking: false,
-        });
-        vi.mocked(clipboardy.read).mockResolvedValue('');
-        props = {
-            buffer: mockBuffer,
-            onSubmit: vi.fn(),
-            userMessages: [],
-            onClearScreen: vi.fn(),
-            config: {
-                getProjectRoot: () => path.join('test', 'project'),
-                getTargetDir: () => path.join('test', 'project', 'src'),
-                getVimMode: () => false,
-                getUseBackgroundColor: () => true,
-                getTerminalBackground: () => undefined,
-                getWorkspaceContext: () => ({
-                    getDirectories: () => ['/test/project/src'],
-                }),
-            },
-            slashCommands: mockSlashCommands,
-            commandContext: mockCommandContext,
-            shellModeActive: false,
-            setShellModeActive: vi.fn(),
-            approvalMode: ApprovalMode.DEFAULT,
-            inputWidth: 80,
-            suggestionsWidth: 80,
-            focus: true,
-            setQueueErrorMessage: vi.fn(),
-            streamingState: StreamingState.Idle,
-            setBannerVisible: vi.fn(),
-        };
-    });
-    it('should call shellHistory.getPreviousCommand on up arrow in shell mode', async () => {
-        props.shellModeActive = true;
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\u001B[A');
-        });
-        await waitFor(() => expect(mockShellHistory.getPreviousCommand).toHaveBeenCalled());
-        unmount();
-    });
-    it('should call shellHistory.getNextCommand on down arrow in shell mode', async () => {
-        props.shellModeActive = true;
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\u001B[B');
-            await waitFor(() => expect(mockShellHistory.getNextCommand).toHaveBeenCalled());
-        });
-        unmount();
-    });
-    it('should set the buffer text when a shell history command is retrieved', async () => {
-        props.shellModeActive = true;
-        vi.mocked(mockShellHistory.getPreviousCommand).mockReturnValue('previous command');
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\u001B[A');
-        });
-        await waitFor(() => {
-            expect(mockShellHistory.getPreviousCommand).toHaveBeenCalled();
-            expect(props.buffer.setText).toHaveBeenCalledWith('previous command');
-        });
-        unmount();
-    });
-    it('should call shellHistory.addCommandToHistory on submit in shell mode', async () => {
-        props.shellModeActive = true;
-        props.buffer.setText('ls -l');
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => {
-            expect(mockShellHistory.addCommandToHistory).toHaveBeenCalledWith('ls -l');
-            expect(props.onSubmit).toHaveBeenCalledWith('ls -l');
-        });
-        unmount();
-    });
-    it('should NOT call shell history methods when not in shell mode', async () => {
-        props.buffer.setText('some text');
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\u001B[A'); // Up arrow
-        });
-        await waitFor(() => expect(mockInputHistory.navigateUp).toHaveBeenCalled());
-        await act(async () => {
-            stdin.write('\u001B[B'); // Down arrow
-        });
-        await waitFor(() => expect(mockInputHistory.navigateDown).toHaveBeenCalled());
-        await act(async () => {
-            stdin.write('\r'); // Enter
-        });
-        await waitFor(() => expect(props.onSubmit).toHaveBeenCalledWith('some text'));
-        expect(mockShellHistory.getPreviousCommand).not.toHaveBeenCalled();
-        expect(mockShellHistory.getNextCommand).not.toHaveBeenCalled();
-        expect(mockShellHistory.addCommandToHistory).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('should call completion.navigateUp for both up arrow and Ctrl+P when suggestions are showing', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [
-                { label: 'memory', value: 'memory' },
-                { label: 'memcache', value: 'memcache' },
-            ],
-        });
-        props.buffer.setText('/mem');
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        // Test up arrow
-        await act(async () => {
-            stdin.write('\u001B[A'); // Up arrow
-        });
-        await waitFor(() => expect(mockCommandCompletion.navigateUp).toHaveBeenCalledTimes(1));
-        await act(async () => {
-            stdin.write('\u0010'); // Ctrl+P
-        });
-        await waitFor(() => expect(mockCommandCompletion.navigateUp).toHaveBeenCalledTimes(2));
-        expect(mockCommandCompletion.navigateDown).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('should call completion.navigateDown for both down arrow and Ctrl+N when suggestions are showing', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [
-                { label: 'memory', value: 'memory' },
-                { label: 'memcache', value: 'memcache' },
-            ],
-        });
-        props.buffer.setText('/mem');
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        // Test down arrow
-        await act(async () => {
-            stdin.write('\u001B[B'); // Down arrow
-        });
-        await waitFor(() => expect(mockCommandCompletion.navigateDown).toHaveBeenCalledTimes(1));
-        await act(async () => {
-            stdin.write('\u000E'); // Ctrl+N
-        });
-        await waitFor(() => expect(mockCommandCompletion.navigateDown).toHaveBeenCalledTimes(2));
-        expect(mockCommandCompletion.navigateUp).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('should NOT call completion navigation when suggestions are not showing', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: false,
-        });
-        props.buffer.setText('some text');
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\u001B[A'); // Up arrow
-        });
-        await waitFor(() => expect(mockInputHistory.navigateUp).toHaveBeenCalled());
-        await act(async () => {
-            stdin.write('\u001B[B'); // Down arrow
-        });
-        await waitFor(() => expect(mockInputHistory.navigateDown).toHaveBeenCalled());
-        await act(async () => {
-            stdin.write('\u0010'); // Ctrl+P
-        });
-        await act(async () => {
-            stdin.write('\u000E'); // Ctrl+N
-        });
-        await waitFor(() => {
-            expect(mockCommandCompletion.navigateUp).not.toHaveBeenCalled();
-            expect(mockCommandCompletion.navigateDown).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    describe('clipboard image paste', () => {
-        beforeEach(() => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-            vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue(null);
-            vi.mocked(clipboardUtils.cleanupOldClipboardImages).mockResolvedValue(undefined);
-        });
-        it('should handle Ctrl+V when clipboard has an image', async () => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(true);
-            vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue('/test/.gemini-clipboard/clipboard-123.png');
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            // Send Ctrl+V
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(clipboardUtils.clipboardHasImage).toHaveBeenCalled();
-                expect(clipboardUtils.saveClipboardImage).toHaveBeenCalledWith(props.config.getTargetDir());
-                expect(clipboardUtils.cleanupOldClipboardImages).toHaveBeenCalledWith(props.config.getTargetDir());
-                expect(mockBuffer.replaceRangeByOffset).toHaveBeenCalled();
-            });
-            unmount();
-        });
-        it('should not insert anything when clipboard has no image', async () => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(clipboardUtils.clipboardHasImage).toHaveBeenCalled();
-            });
-            expect(clipboardUtils.saveClipboardImage).not.toHaveBeenCalled();
-            expect(mockBuffer.setText).not.toHaveBeenCalled();
-            unmount();
-        });
-        it('should handle image save failure gracefully', async () => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(true);
-            vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue(null);
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(clipboardUtils.saveClipboardImage).toHaveBeenCalled();
-            });
-            expect(mockBuffer.setText).not.toHaveBeenCalled();
-            unmount();
-        });
-        it('should insert image path at cursor position with proper spacing', async () => {
-            const imagePath = path.join('test', '.gemini-clipboard', 'clipboard-456.png');
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(true);
-            vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue(imagePath);
-            // Set initial text and cursor position
-            mockBuffer.text = 'Hello world';
-            mockBuffer.cursor = [0, 5]; // Cursor after "Hello"
-            vi.mocked(mockBuffer.getOffset).mockReturnValue(5);
-            mockBuffer.lines = ['Hello world'];
-            mockBuffer.replaceRangeByOffset = vi.fn();
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                // Should insert at cursor position with spaces
-                expect(mockBuffer.replaceRangeByOffset).toHaveBeenCalled();
-            });
-            // Get the actual call to see what path was used
-            const actualCall = vi.mocked(mockBuffer.replaceRangeByOffset).mock
-                .calls[0];
-            expect(actualCall[0]).toBe(5); // start offset
-            expect(actualCall[1]).toBe(5); // end offset
-            expect(actualCall[2]).toBe(' @' + path.relative(path.join('test', 'project', 'src'), imagePath));
-            unmount();
-        });
-        it('should handle errors during clipboard operations', async () => {
-            const debugLoggerErrorSpy = vi
-                .spyOn(debugLogger, 'error')
-                .mockImplementation(() => { });
-            vi.mocked(clipboardUtils.clipboardHasImage).mockRejectedValue(new Error('Clipboard error'));
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(debugLoggerErrorSpy).toHaveBeenCalledWith('Error handling paste:', expect.any(Error));
-            });
-            expect(mockBuffer.setText).not.toHaveBeenCalled();
-            debugLoggerErrorSpy.mockRestore();
-            unmount();
-        });
-    });
-    describe('clipboard text paste', () => {
-        it('should insert text from clipboard on Ctrl+V', async () => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-            vi.mocked(clipboardy.read).mockResolvedValue('pasted text');
-            vi.mocked(mockBuffer.replaceRangeByOffset).mockClear();
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(clipboardy.read).toHaveBeenCalled();
-                expect(mockBuffer.insert).toHaveBeenCalledWith('pasted text', expect.objectContaining({ paste: true }));
-            });
-            unmount();
-        });
-        it('should use OSC 52 when useOSC52Paste setting is enabled', async () => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-            const settings = createMockSettings({
-                experimental: { useOSC52Paste: true },
-            });
-            const { stdout, stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { settings });
-            const writeSpy = vi.spyOn(stdout, 'write');
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(writeSpy).toHaveBeenCalledWith('\x1b]52;c;?\x07');
-            });
-            // Should NOT call clipboardy.read()
-            expect(clipboardy.read).not.toHaveBeenCalled();
-            unmount();
-        });
-    });
-    it.each([
-        {
-            name: 'should complete a partial parent command',
-            bufferText: '/mem',
-            suggestions: [{ label: 'memory', value: 'memory', description: '...' }],
-            activeIndex: 0,
-        },
-        {
-            name: 'should append a sub-command when parent command is complete',
-            bufferText: '/memory ',
-            suggestions: [
-                { label: 'show', value: 'show' },
-                { label: 'add', value: 'add' },
-            ],
-            activeIndex: 1,
-        },
-        {
-            name: 'should handle the backspace edge case correctly',
-            bufferText: '/memory',
-            suggestions: [
-                { label: 'show', value: 'show' },
-                { label: 'add', value: 'add' },
-            ],
-            activeIndex: 0,
-        },
-        {
-            name: 'should complete a partial argument for a command',
-            bufferText: '/chat resume fi-',
-            suggestions: [{ label: 'fix-foo', value: 'fix-foo' }],
-            activeIndex: 0,
-        },
-    ])('$name', async ({ bufferText, suggestions, activeIndex }) => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions,
-            activeSuggestionIndex: activeIndex,
-        });
-        props.buffer.setText(bufferText);
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => stdin.write('\t'));
-        await waitFor(() => expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(activeIndex));
-        unmount();
-    });
-    it('should autocomplete on Enter when suggestions are active, without submitting', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [{ label: 'memory', value: 'memory' }],
-            activeSuggestionIndex: 0,
-        });
-        props.buffer.setText('/mem');
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => {
-            // The app should autocomplete the text, NOT submit.
-            expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
-        });
-        expect(props.onSubmit).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('should complete a command based on its altNames', async () => {
-        props.slashCommands = [
-            {
-                name: 'help',
-                altNames: ['?'],
-                kind: CommandKind.BUILT_IN,
-                description: '...',
-            },
-        ];
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [{ label: 'help', value: 'help' }],
-            activeSuggestionIndex: 0,
-        });
-        props.buffer.setText('/?');
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\t'); // Press Tab for autocomplete
-        });
-        await waitFor(() => expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0));
-        unmount();
-    });
-    it('should not submit on Enter when the buffer is empty or only contains whitespace', async () => {
-        props.buffer.setText('   '); // Set buffer to whitespace
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r'); // Press Enter
-        });
-        await waitFor(() => {
-            expect(props.onSubmit).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should submit directly on Enter when isPerfectMatch is true', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: false,
-            isPerfectMatch: true,
-        });
-        props.buffer.setText('/clear');
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => expect(props.onSubmit).toHaveBeenCalledWith('/clear'));
-        unmount();
-    });
-    it('should execute perfect match on Enter even if suggestions are showing, if at first suggestion', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [
-                { label: 'review', value: 'review' }, // Match is now at index 0
-                { label: 'review-frontend', value: 'review-frontend' },
-            ],
-            activeSuggestionIndex: 0,
-            isPerfectMatch: true,
-        });
-        props.buffer.text = '/review';
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => {
-            expect(props.onSubmit).toHaveBeenCalledWith('/review');
-        });
-        unmount();
-    });
-    it('should autocomplete and NOT execute on Enter if a DIFFERENT suggestion is selected even if perfect match', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [
-                { label: 'review', value: 'review' },
-                { label: 'review-frontend', value: 'review-frontend' },
-            ],
-            activeSuggestionIndex: 1, // review-frontend selected (not the perfect match at 0)
-            isPerfectMatch: true, // /review is a perfect match
-        });
-        props.buffer.text = '/review';
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => {
-            // Should handle autocomplete for index 1
-            expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(1);
-            // Should NOT submit
-            expect(props.onSubmit).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should submit directly on Enter when a complete leaf command is typed', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: false,
-            isPerfectMatch: false, // Added explicit isPerfectMatch false
-        });
-        props.buffer.setText('/clear');
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => expect(props.onSubmit).toHaveBeenCalledWith('/clear'));
-        unmount();
-    });
-    it('should auto-execute commands with autoExecute: true on Enter', async () => {
-        const aboutCommand = {
-            name: 'about',
-            kind: CommandKind.BUILT_IN,
-            description: 'About command',
-            action: vi.fn(),
-            autoExecute: true,
-        };
-        const suggestion = { label: 'about', value: 'about' };
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [suggestion],
-            activeSuggestionIndex: 0,
-            getCommandFromSuggestion: vi.fn().mockReturnValue(aboutCommand),
-            getCompletedText: vi.fn().mockReturnValue('/about'),
-            slashCompletionRange: {
-                completionStart: 1,
-                completionEnd: 3, // "/ab" -> start at 1, end at 3
-                getCommandFromSuggestion: vi.fn(),
-                isArgumentCompletion: false,
-                leafCommand: null,
-            },
-        });
-        // User typed partial command
-        props.buffer.setText('/ab');
-        props.buffer.lines = ['/ab'];
-        props.buffer.cursor = [0, 3];
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r'); // Enter
-        });
-        await waitFor(() => {
-            // Should submit the full command constructed from buffer + suggestion
-            expect(props.onSubmit).toHaveBeenCalledWith('/about');
-            // Should NOT handle autocomplete (which just fills text)
-            expect(mockCommandCompletion.handleAutocomplete).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should autocomplete commands with autoExecute: false on Enter', async () => {
-        const shareCommand = {
-            name: 'share',
-            kind: CommandKind.BUILT_IN,
-            description: 'Share conversation to file',
-            action: vi.fn(),
-            autoExecute: false, // Explicitly set to false
-        };
-        const suggestion = { label: 'share', value: 'share' };
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [suggestion],
-            activeSuggestionIndex: 0,
-            getCommandFromSuggestion: vi.fn().mockReturnValue(shareCommand),
-            getCompletedText: vi.fn().mockReturnValue('/share'),
-        });
-        props.buffer.setText('/sh');
-        props.buffer.lines = ['/sh'];
-        props.buffer.cursor = [0, 3];
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r'); // Enter
-        });
-        await waitFor(() => {
-            // Should autocomplete to allow adding file argument
-            expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
-            expect(props.onSubmit).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should autocomplete on Tab, even for executable commands', async () => {
-        const executableCommand = {
-            name: 'about',
-            kind: CommandKind.BUILT_IN,
-            description: 'About info',
-            action: vi.fn(),
-            autoExecute: true,
-        };
-        const suggestion = { label: 'about', value: 'about' };
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [suggestion],
-            activeSuggestionIndex: 0,
-            getCommandFromSuggestion: vi.fn().mockReturnValue(executableCommand),
-            getCompletedText: vi.fn().mockReturnValue('/about'),
-        });
-        props.buffer.setText('/ab');
-        props.buffer.lines = ['/ab'];
-        props.buffer.cursor = [0, 3];
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\t'); // Tab
-        });
-        await waitFor(() => {
-            // Tab always autocompletes, never executes
-            expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
-            expect(props.onSubmit).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should autocomplete custom commands from .toml files on Enter', async () => {
-        const customCommand = {
-            name: 'find-capital',
-            kind: CommandKind.FILE,
-            description: 'Find capital of a country',
-            action: vi.fn(),
-            // No autoExecute flag - custom commands default to undefined
-        };
-        const suggestion = { label: 'find-capital', value: 'find-capital' };
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [suggestion],
-            activeSuggestionIndex: 0,
-            getCommandFromSuggestion: vi.fn().mockReturnValue(customCommand),
-            getCompletedText: vi.fn().mockReturnValue('/find-capital'),
-        });
-        props.buffer.setText('/find');
-        props.buffer.lines = ['/find'];
-        props.buffer.cursor = [0, 5];
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r'); // Enter
-        });
-        await waitFor(() => {
-            // Should autocomplete (not execute) since autoExecute is undefined
-            expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
-            expect(props.onSubmit).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should auto-execute argument completion when command has autoExecute: true', async () => {
-        // Simulates: /mcp auth <server> where user selects a server from completions
-        const authCommand = {
-            name: 'auth',
-            kind: CommandKind.BUILT_IN,
-            description: 'Authenticate with MCP server',
-            action: vi.fn(),
-            autoExecute: true,
-            completion: vi.fn().mockResolvedValue(['server1', 'server2']),
-        };
-        const suggestion = { label: 'server1', value: 'server1' };
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [suggestion],
-            activeSuggestionIndex: 0,
-            getCommandFromSuggestion: vi.fn().mockReturnValue(authCommand),
-            getCompletedText: vi.fn().mockReturnValue('/mcp auth server1'),
-            slashCompletionRange: {
-                completionStart: 10,
-                completionEnd: 10,
-                getCommandFromSuggestion: vi.fn(),
-                isArgumentCompletion: true,
-                leafCommand: authCommand,
-            },
-        });
-        props.buffer.setText('/mcp auth ');
-        props.buffer.lines = ['/mcp auth '];
-        props.buffer.cursor = [0, 10];
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r'); // Enter
-        });
-        await waitFor(() => {
-            // Should auto-execute with the completed command
-            expect(props.onSubmit).toHaveBeenCalledWith('/mcp auth server1');
-            expect(mockCommandCompletion.handleAutocomplete).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should autocomplete argument completion when command has autoExecute: false', async () => {
-        // Simulates: /extensions enable <ext> where multi-arg completions should NOT auto-execute
-        const enableCommand = {
-            name: 'enable',
-            kind: CommandKind.BUILT_IN,
-            description: 'Enable an extension',
-            action: vi.fn(),
-            autoExecute: false,
-            completion: vi.fn().mockResolvedValue(['ext1 --scope user']),
-        };
-        const suggestion = {
-            label: 'ext1 --scope user',
-            value: 'ext1 --scope user',
-        };
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [suggestion],
-            activeSuggestionIndex: 0,
-            getCommandFromSuggestion: vi.fn().mockReturnValue(enableCommand),
-            getCompletedText: vi
-                .fn()
-                .mockReturnValue('/extensions enable ext1 --scope user'),
-            slashCompletionRange: {
-                completionStart: 19,
-                completionEnd: 19,
-                getCommandFromSuggestion: vi.fn(),
-                isArgumentCompletion: true,
-                leafCommand: enableCommand,
-            },
-        });
-        props.buffer.setText('/extensions enable ');
-        props.buffer.lines = ['/extensions enable '];
-        props.buffer.cursor = [0, 19];
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r'); // Enter
-        });
-        await waitFor(() => {
-            // Should autocomplete (not execute) to allow user to modify
-            expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
-            expect(props.onSubmit).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should autocomplete command name even with autoExecute: true if command has completion function', async () => {
-        // Simulates: /chat resu -> should NOT auto-execute, should autocomplete to show arg completions
-        const resumeCommand = {
-            name: 'resume',
-            kind: CommandKind.BUILT_IN,
-            description: 'Resume a conversation',
-            action: vi.fn(),
-            autoExecute: true,
-            completion: vi.fn().mockResolvedValue(['chat1', 'chat2']),
-        };
-        const suggestion = { label: 'resume', value: 'resume' };
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [suggestion],
-            activeSuggestionIndex: 0,
-            getCommandFromSuggestion: vi.fn().mockReturnValue(resumeCommand),
-            getCompletedText: vi.fn().mockReturnValue('/chat resume'),
-            slashCompletionRange: {
-                completionStart: 6,
-                completionEnd: 10,
-                getCommandFromSuggestion: vi.fn(),
-                isArgumentCompletion: false,
-                leafCommand: null,
-            },
-        });
-        props.buffer.setText('/chat resu');
-        props.buffer.lines = ['/chat resu'];
-        props.buffer.cursor = [0, 10];
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r'); // Enter
-        });
-        await waitFor(() => {
-            // Should autocomplete to allow selecting an argument, NOT auto-execute
-            expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
-            expect(props.onSubmit).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should autocomplete an @-path on Enter without submitting', async () => {
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
-            suggestions: [{ label: 'index.ts', value: 'index.ts' }],
-            activeSuggestionIndex: 0,
-        });
-        props.buffer.setText('@src/components/');
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0));
-        expect(props.onSubmit).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('should add a newline on enter when the line ends with a backslash', async () => {
-        // This test simulates multi-line input, not submission
-        mockBuffer.text = 'first line\\';
-        mockBuffer.cursor = [0, 11];
-        mockBuffer.lines = ['first line\\'];
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\r');
-        });
-        await waitFor(() => {
-            expect(props.buffer.backspace).toHaveBeenCalled();
-            expect(props.buffer.newline).toHaveBeenCalled();
-        });
-        expect(props.onSubmit).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('should clear the buffer on Ctrl+C if it has text', async () => {
-        await act(async () => {
-            props.buffer.setText('some text to clear');
-        });
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\x03'); // Ctrl+C character
-        });
-        await waitFor(() => {
-            expect(props.buffer.setText).toHaveBeenCalledWith('');
-            expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
-        });
-        expect(props.onSubmit).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('should render correctly in plan mode', async () => {
-        props.approvalMode = ApprovalMode.PLAN;
-        const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await waitFor(() => {
-            const frame = stdout.lastFrame();
-            // In plan mode it uses '>' but with success color.
-            // We check that it contains '>' and not '*' or '!'.
-            expect(frame).toContain('>');
-            expect(frame).not.toContain('*');
-            expect(frame).not.toContain('!');
-        });
-        unmount();
-    });
-    it('should NOT clear the buffer on Ctrl+C if it is empty', async () => {
-        props.buffer.text = '';
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\x03'); // Ctrl+C character
-        });
-        await waitFor(() => {
-            expect(props.buffer.setText).not.toHaveBeenCalled();
-        });
-        unmount();
-    });
-    it('should call setBannerVisible(false) when clear screen key is pressed', async () => {
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            uiActions,
-        });
-        await act(async () => {
-            stdin.write('\x0C'); // Ctrl+L
-        });
-        await waitFor(() => {
-            expect(props.setBannerVisible).toHaveBeenCalledWith(false);
-        });
-        unmount();
-    });
-    describe('Background Color Styles', () => {
-        beforeEach(() => {
-            vi.mocked(isLowColorDepth).mockReturnValue(false);
-        });
-        afterEach(() => {
-            vi.restoreAllMocks();
-        });
-        it('should render with background color by default', async () => {
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await waitFor(() => {
-                const frame = stdout.lastFrame();
-                expect(frame).toContain('▀');
-                expect(frame).toContain('▄');
-            });
-            unmount();
-        });
-        it.each([
-            { color: 'black', name: 'black' },
-            { color: '#000000', name: '#000000' },
-            { color: '#000', name: '#000' },
-            { color: undefined, name: 'default (black)' },
-            { color: 'white', name: 'white' },
-            { color: '#ffffff', name: '#ffffff' },
-            { color: '#fff', name: '#fff' },
-        ])('should render with safe grey background but NO side borders in 8-bit mode when background is $name', async ({ color }) => {
-            vi.mocked(isLowColorDepth).mockReturnValue(true);
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-                uiState: {
-                    terminalBackgroundColor: color,
-                },
-            });
-            const isWhite = color === 'white' || color === '#ffffff' || color === '#fff';
-            const expectedBgColor = isWhite ? '#eeeeee' : '#1c1c1c';
-            await waitFor(() => {
-                const frame = stdout.lastFrame();
-                // Use chalk to get the expected background color escape sequence
-                const bgCheck = chalk.bgHex(expectedBgColor)(' ');
-                const bgCode = bgCheck.substring(0, bgCheck.indexOf(' '));
-                // Background color code should be present
-                expect(frame).toContain(bgCode);
-                // Background characters should be rendered
-                expect(frame).toContain('▀');
-                expect(frame).toContain('▄');
-                // Side borders should STILL be removed
-                expect(frame).not.toContain('│');
-            });
-            unmount();
-        });
-        it('should NOT render with background color but SHOULD render horizontal lines when color depth is < 24 and background is NOT black', async () => {
-            vi.mocked(isLowColorDepth).mockReturnValue(true);
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-                uiState: {
-                    terminalBackgroundColor: '#333333',
-                },
-            });
-            await waitFor(() => {
-                const frame = stdout.lastFrame();
-                expect(frame).not.toContain('▀');
-                expect(frame).not.toContain('▄');
-                // It SHOULD have horizontal fallback lines
-                expect(frame).toContain('─');
-                // It SHOULD NOT have vertical side borders (standard Box borders have │)
-                expect(frame).not.toContain('│');
-            });
-            unmount();
-        });
-        it('should handle 4-bit color mode (16 colors) as low color depth', async () => {
-            vi.mocked(isLowColorDepth).mockReturnValue(true);
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await waitFor(() => {
-                const frame = stdout.lastFrame();
-                expect(frame).toContain('▀');
-                expect(frame).not.toContain('│');
-            });
-            unmount();
-        });
-        it('should render horizontal lines (but NO background) in 8-bit mode when background is blue', async () => {
-            vi.mocked(isLowColorDepth).mockReturnValue(true);
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-                uiState: {
-                    terminalBackgroundColor: 'blue',
-                },
-            });
-            await waitFor(() => {
-                const frame = stdout.lastFrame();
-                // Should NOT have background characters
-                expect(frame).not.toContain('▀');
-                expect(frame).not.toContain('▄');
-                // Should HAVE horizontal lines from the fallback Box borders
-                // Box style "round" uses these for top/bottom
-                expect(frame).toContain('─');
-                // Should NOT have vertical side borders
-                expect(frame).not.toContain('│');
-            });
-            unmount();
-        });
-        it('should render with plain borders when useBackgroundColor is false', async () => {
-            props.config.getUseBackgroundColor = () => false;
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await waitFor(() => {
-                const frame = stdout.lastFrame();
-                expect(frame).not.toContain('▀');
-                expect(frame).not.toContain('▄');
-                // Check for Box borders (round style uses unicode box chars)
-                expect(frame).toMatch(/[─│┐└┘┌]/);
-            });
-            unmount();
-        });
-    });
-    describe('cursor-based completion trigger', () => {
-        it.each([
-            {
-                name: 'should trigger completion when cursor is after @ without spaces',
-                text: '@src/components',
-                cursor: [0, 15],
-                showSuggestions: true,
-            },
-            {
-                name: 'should trigger completion when cursor is after / without spaces',
-                text: '/memory',
-                cursor: [0, 7],
-                showSuggestions: true,
-            },
-            {
-                name: 'should NOT trigger completion when cursor is after space following @',
-                text: '@src/file.ts hello',
-                cursor: [0, 18],
-                showSuggestions: false,
-            },
-            {
-                name: 'should NOT trigger completion when cursor is after space following /',
-                text: '/memory add',
-                cursor: [0, 11],
-                showSuggestions: false,
-            },
-            {
-                name: 'should NOT trigger completion when cursor is not after @ or /',
-                text: 'hello world',
-                cursor: [0, 5],
-                showSuggestions: false,
-            },
-            {
-                name: 'should handle multiline text correctly',
-                text: 'first line\n/memory',
-                cursor: [1, 7],
-                showSuggestions: false,
-            },
-            {
-                name: 'should handle Unicode characters (emojis) correctly in paths',
-                text: '@src/file👍.txt',
-                cursor: [0, 14],
-                showSuggestions: true,
-            },
-            {
-                name: 'should handle Unicode characters with spaces after them',
-                text: '@src/file👍.txt hello',
-                cursor: [0, 20],
-                showSuggestions: false,
-            },
-            {
-                name: 'should handle escaped spaces in paths correctly',
-                text: '@src/my\\ file.txt',
-                cursor: [0, 16],
-                showSuggestions: true,
-            },
-            {
-                name: 'should NOT trigger completion after unescaped space following escaped space',
-                text: '@path/my\\ file.txt hello',
-                cursor: [0, 24],
-                showSuggestions: false,
-            },
-            {
-                name: 'should handle multiple escaped spaces in paths',
-                text: '@docs/my\\ long\\ file\\ name.md',
-                cursor: [0, 29],
-                showSuggestions: true,
-            },
-            {
-                name: 'should handle escaped spaces in slash commands',
-                text: '/memory\\ test',
-                cursor: [0, 13],
-                showSuggestions: true,
-            },
-            {
-                name: 'should handle Unicode characters with escaped spaces',
-                text: `@${path.join('files', 'emoji\\ 👍\\ test.txt')}`,
-                cursor: [0, 25],
-                showSuggestions: true,
-            },
-        ])('$name', async ({ text, cursor, showSuggestions }) => {
-            mockBuffer.text = text;
-            mockBuffer.lines = text.split('\n');
-            mockBuffer.cursor = cursor;
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
-                showSuggestions,
-                suggestions: showSuggestions
-                    ? [{ label: 'suggestion', value: 'suggestion' }]
-                    : [],
-            });
-            const { unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-                uiActions,
-            });
-            await waitFor(() => {
-                expect(mockedUseCommandCompletion).toHaveBeenCalledWith(mockBuffer, path.join('test', 'project', 'src'), mockSlashCommands, mockCommandContext, false, false, expect.any(Object));
-            });
-            unmount();
-        });
-    });
-    describe('vim mode', () => {
-        it.each([
-            {
-                name: 'should not call buffer.handleInput when vim handles input',
-                vimHandled: true,
-                expectBufferHandleInput: false,
-            },
-            {
-                name: 'should call buffer.handleInput when vim does not handle input',
-                vimHandled: false,
-                expectBufferHandleInput: true,
-            },
-            {
-                name: 'should call handleInput when vim mode is disabled',
-                vimHandled: false,
-                expectBufferHandleInput: true,
-            },
-        ])('$name', async ({ vimHandled, expectBufferHandleInput }) => {
-            props.vimHandleInput = vi.fn().mockReturnValue(vimHandled);
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => stdin.write('i'));
-            await waitFor(() => {
-                expect(props.vimHandleInput).toHaveBeenCalled();
-                if (expectBufferHandleInput) {
-                    expect(mockBuffer.handleInput).toHaveBeenCalled();
-                }
-                else {
-                    expect(mockBuffer.handleInput).not.toHaveBeenCalled();
-                }
-            });
-            unmount();
-        });
-    });
-    describe('unfocused paste', () => {
-        it('should handle bracketed paste when not focused', async () => {
-            props.focus = false;
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x1B[200~pasted text\x1B[201~');
-            });
-            await waitFor(() => {
-                expect(mockBuffer.handleInput).toHaveBeenCalledWith(expect.objectContaining({
-                    name: 'paste',
-                    sequence: 'pasted text',
-                }));
-            });
-            unmount();
-        });
-        it('should ignore regular keypresses when not focused', async () => {
-            props.focus = false;
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('a');
-            });
-            await waitFor(() => { });
-            expect(mockBuffer.handleInput).not.toHaveBeenCalled();
-            unmount();
-        });
-    });
-    describe('Highlighting and Cursor Display', () => {
-        describe('single-line scenarios', () => {
-            it.each([
-                {
-                    name: 'mid-word',
-                    text: 'hello world',
-                    visualCursor: [0, 3],
-                    expected: `hel${chalk.inverse('l')}o world`,
-                },
-                {
-                    name: 'at the beginning of the line',
-                    text: 'hello',
-                    visualCursor: [0, 0],
-                    expected: `${chalk.inverse('h')}ello`,
-                },
-                {
-                    name: 'at the end of the line',
-                    text: 'hello',
-                    visualCursor: [0, 5],
-                    expected: `hello${chalk.inverse(' ')}`,
-                },
-                {
-                    name: 'on a highlighted token',
-                    text: 'run @path/to/file',
-                    visualCursor: [0, 9],
-                    expected: `@path/${chalk.inverse('t')}o/file`,
-                },
-                {
-                    name: 'for multi-byte unicode characters',
-                    text: 'hello 👍 world',
-                    visualCursor: [0, 6],
-                    expected: `hello ${chalk.inverse('👍')} world`,
-                },
-                {
-                    name: 'at the end of a line with unicode characters',
-                    text: 'hello 👍',
-                    visualCursor: [0, 8],
-                    expected: `hello 👍${chalk.inverse(' ')}`,
-                },
-                {
-                    name: 'on an empty line',
-                    text: '',
-                    visualCursor: [0, 0],
-                    expected: chalk.inverse(' '),
-                },
-                {
-                    name: 'on a space between words',
-                    text: 'hello world',
-                    visualCursor: [0, 5],
-                    expected: `hello${chalk.inverse(' ')}world`,
-                },
-            ])('should display cursor correctly $name', async ({ text, visualCursor, expected }) => {
-                mockBuffer.text = text;
-                mockBuffer.lines = [text];
-                mockBuffer.viewportVisualLines = [text];
-                mockBuffer.visualCursor = visualCursor;
-                props.config.getUseBackgroundColor = () => false;
-                const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-                await waitFor(() => {
-                    const frame = stdout.lastFrame();
-                    expect(frame).toContain(expected);
-                });
-                unmount();
-            });
-        });
-        describe('multi-line scenarios', () => {
-            it.each([
-                {
-                    name: 'in the middle of a line',
-                    text: 'first line\nsecond line\nthird line',
-                    visualCursor: [1, 3],
-                    visualToLogicalMap: [
-                        [0, 0],
-                        [1, 0],
-                        [2, 0],
-                    ],
-                    expected: `sec${chalk.inverse('o')}nd line`,
-                },
-                {
-                    name: 'at the beginning of a line',
-                    text: 'first line\nsecond line',
-                    visualCursor: [1, 0],
-                    visualToLogicalMap: [
-                        [0, 0],
-                        [1, 0],
-                    ],
-                    expected: `${chalk.inverse('s')}econd line`,
-                },
-                {
-                    name: 'at the end of a line',
-                    text: 'first line\nsecond line',
-                    visualCursor: [0, 10],
-                    visualToLogicalMap: [
-                        [0, 0],
-                        [1, 0],
-                    ],
-                    expected: `first line${chalk.inverse(' ')}`,
-                },
-            ])('should display cursor correctly $name in a multiline block', async ({ text, visualCursor, expected, visualToLogicalMap }) => {
-                mockBuffer.text = text;
-                mockBuffer.lines = text.split('\n');
-                mockBuffer.viewportVisualLines = text.split('\n');
-                mockBuffer.visualCursor = visualCursor;
-                mockBuffer.visualToLogicalMap = visualToLogicalMap;
-                props.config.getUseBackgroundColor = () => false;
-                const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-                await waitFor(() => {
-                    const frame = stdout.lastFrame();
-                    expect(frame).toContain(expected);
-                });
-                unmount();
-            });
-            it('should display cursor on a blank line in a multiline block', async () => {
-                const text = 'first line\n\nthird line';
-                mockBuffer.text = text;
-                mockBuffer.lines = text.split('\n');
-                mockBuffer.viewportVisualLines = text.split('\n');
-                mockBuffer.visualCursor = [1, 0]; // cursor on the blank line
-                mockBuffer.visualToLogicalMap = [
-                    [0, 0],
-                    [1, 0],
-                    [2, 0],
-                ];
-                props.config.getUseBackgroundColor = () => false;
-                const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-                await waitFor(() => {
-                    const frame = stdout.lastFrame();
-                    const lines = frame.split('\n');
-                    // The line with the cursor should just be an inverted space inside the box border
-                    expect(lines.find((l) => l.includes(chalk.inverse(' ')))).not.toBeUndefined();
-                });
-                unmount();
-            });
-        });
-    });
-    describe('multiline rendering', () => {
-        it('should correctly render multiline input including blank lines', async () => {
-            const text = 'hello\n\nworld';
-            mockBuffer.text = text;
-            mockBuffer.lines = text.split('\n');
-            mockBuffer.viewportVisualLines = text.split('\n');
-            mockBuffer.allVisualLines = text.split('\n');
-            mockBuffer.visualCursor = [2, 5]; // cursor at the end of "world"
-            // Provide a visual-to-logical mapping for each visual line
-            mockBuffer.visualToLogicalMap = [
-                [0, 0],
-                [1, 0],
-                [2, 0],
-            ];
-            props.config.getUseBackgroundColor = () => false;
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await waitFor(() => {
-                const frame = stdout.lastFrame();
-                // Check that all lines, including the empty one, are rendered.
-                // This implicitly tests that the Box wrapper provides height for the empty line.
-                expect(frame).toContain('hello');
-                expect(frame).toContain(`world${chalk.inverse(' ')}`);
-                const outputLines = frame.split('\n');
-                // The number of lines should be 2 for the border plus 3 for the content.
-                expect(outputLines.length).toBe(5);
-            });
-            unmount();
-        });
-    });
-    describe('multiline paste', () => {
-        it.each([
-            {
-                description: 'with \n newlines',
-                pastedText: 'This \n is \n a \n multiline \n paste.',
-            },
-            {
-                description: 'with extra slashes before \n newlines',
-                pastedText: 'This \\\n is \\\n a \\\n multiline \\\n paste.',
-            },
-            {
-                description: 'with \r\n newlines',
-                pastedText: 'This\r\nis\r\na\r\nmultiline\r\npaste.',
-            },
-        ])('should handle multiline paste $description', async ({ pastedText }) => {
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            // Simulate a bracketed paste event from the terminal
-            await act(async () => {
-                stdin.write(`\x1b[200~${pastedText}\x1b[201~`);
-            });
-            await waitFor(() => {
-                // Verify that the buffer's handleInput was called once with the full text
-                expect(props.buffer.handleInput).toHaveBeenCalledTimes(1);
-                expect(props.buffer.handleInput).toHaveBeenCalledWith(expect.objectContaining({
-                    name: 'paste',
-                    sequence: pastedText,
-                }));
-            });
-            unmount();
-        });
-    });
-    describe('large paste placeholder', () => {
-        it('should handle large clipboard paste (lines > 5) by calling buffer.insert', async () => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-            const largeText = '1\n2\n3\n4\n5\n6';
-            vi.mocked(clipboardy.read).mockResolvedValue(largeText);
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(mockBuffer.insert).toHaveBeenCalledWith(largeText, expect.objectContaining({ paste: true }));
-            });
-            unmount();
-        });
-        it('should handle large clipboard paste (chars > 500) by calling buffer.insert', async () => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-            const largeText = 'a'.repeat(501);
-            vi.mocked(clipboardy.read).mockResolvedValue(largeText);
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(mockBuffer.insert).toHaveBeenCalledWith(largeText, expect.objectContaining({ paste: true }));
-            });
-            unmount();
-        });
-        it('should handle normal clipboard paste by calling buffer.insert', async () => {
-            vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
-            const smallText = 'hello world';
-            vi.mocked(clipboardy.read).mockResolvedValue(smallText);
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x16'); // Ctrl+V
-            });
-            await waitFor(() => {
-                expect(mockBuffer.insert).toHaveBeenCalledWith(smallText, expect.objectContaining({ paste: true }));
-            });
-            unmount();
-        });
-        it('should replace placeholder with actual content on submit', async () => {
-            // Setup buffer to have the placeholder
-            const largeText = '1\n2\n3\n4\n5\n6';
-            const id = '[Pasted Text: 6 lines]';
-            mockBuffer.text = `Check this: ${id}`;
-            mockBuffer.pastedContent = { [id]: largeText };
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\r'); // Enter
-            });
-            await waitFor(() => {
-                expect(props.onSubmit).toHaveBeenCalledWith(`Check this: ${largeText}`);
-            });
-            unmount();
-        });
-    });
-    describe('paste auto-submission protection', () => {
-        beforeEach(() => {
-            vi.useFakeTimers();
-            mockedUseKittyKeyboardProtocol.mockReturnValue({
-                enabled: false,
-                checking: false,
-            });
-        });
-        afterEach(() => {
-            vi.useRealTimers();
-            vi.restoreAllMocks();
-        });
-        it('should prevent auto-submission immediately after an unsafe paste', async () => {
-            // isTerminalPasteTrusted will be false due to beforeEach setup.
-            props.buffer.text = 'some command';
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Simulate a paste operation (this should set the paste protection)
-            await act(async () => {
-                stdin.write(`\x1b[200~pasted content\x1b[201~`);
-            });
-            // Simulate an Enter key press immediately after paste
-            await act(async () => {
-                stdin.write('\r');
-            });
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Verify that onSubmit was NOT called due to recent paste protection
-            expect(props.onSubmit).not.toHaveBeenCalled();
-            // It should call newline() instead
-            expect(props.buffer.newline).toHaveBeenCalled();
-            unmount();
-        });
-        it('should allow submission after unsafe paste protection timeout', async () => {
-            // isTerminalPasteTrusted will be false due to beforeEach setup.
-            props.buffer.text = 'pasted text';
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Simulate a paste operation (this sets the protection)
-            await act(async () => {
-                stdin.write('\x1b[200~pasted text\x1b[201~');
-            });
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Advance timers past the protection timeout
-            await act(async () => {
-                await vi.advanceTimersByTimeAsync(50);
-            });
-            // Now Enter should work normally
-            await act(async () => {
-                stdin.write('\r');
-            });
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            expect(props.onSubmit).toHaveBeenCalledWith('pasted text');
-            expect(props.buffer.newline).not.toHaveBeenCalled();
-            unmount();
-        });
-        it.each([
-            {
-                name: 'kitty',
-                setup: () => mockedUseKittyKeyboardProtocol.mockReturnValue({
-                    enabled: true,
-                    checking: false,
-                }),
-            },
-        ])('should allow immediate submission for a trusted paste ($name)', async ({ setup }) => {
-            setup();
-            props.buffer.text = 'pasted command';
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Simulate a paste operation
-            await act(async () => {
-                stdin.write('\x1b[200~some pasted stuff\x1b[201~');
-            });
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Simulate an Enter key press immediately after paste
-            await act(async () => {
-                stdin.write('\r');
-            });
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Verify that onSubmit was called
-            expect(props.onSubmit).toHaveBeenCalledWith('pasted command');
-            unmount();
-        });
-        it('should not interfere with normal Enter key submission when no recent paste', async () => {
-            // Set up buffer with text before rendering to ensure submission works
-            props.buffer.text = 'normal command';
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Press Enter without any recent paste
-            await act(async () => {
-                stdin.write('\r');
-            });
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            // Verify that onSubmit was called normally
-            expect(props.onSubmit).toHaveBeenCalledWith('normal command');
-            unmount();
-        });
-    });
-    describe('enhanced input UX - keyboard shortcuts', () => {
-        beforeEach(() => vi.useFakeTimers());
-        afterEach(() => vi.useRealTimers());
-        it('should clear buffer on Ctrl-C', async () => {
-            const onEscapePromptChange = vi.fn();
-            props.onEscapePromptChange = onEscapePromptChange;
-            props.buffer.setText('text to clear');
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x03');
-                vi.advanceTimersByTime(100);
-                expect(props.buffer.setText).toHaveBeenCalledWith('');
-                expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
-            });
-            unmount();
-        });
-        it('should submit /rewind on double ESC when buffer is empty', async () => {
-            const onEscapePromptChange = vi.fn();
-            props.onEscapePromptChange = onEscapePromptChange;
-            props.buffer.setText('');
-            vi.mocked(props.buffer.setText).mockClear();
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-                uiState: {
-                    history: [{ id: 1, type: 'user', text: 'test' }],
-                },
-            });
-            await act(async () => {
-                stdin.write('\x1B\x1B');
-                vi.advanceTimersByTime(100);
-            });
-            await waitFor(() => {
-                expect(props.onSubmit).toHaveBeenCalledWith('/rewind');
-            });
-            unmount();
-        });
-        it('should clear the buffer on esc esc if it has text', async () => {
-            const onEscapePromptChange = vi.fn();
-            props.onEscapePromptChange = onEscapePromptChange;
-            props.buffer.setText('some text');
-            vi.mocked(props.buffer.setText).mockClear();
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x1B\x1B');
-                vi.advanceTimersByTime(100);
-                expect(props.buffer.setText).toHaveBeenCalledWith('');
-                expect(props.onSubmit).not.toHaveBeenCalledWith('/rewind');
-            });
-            unmount();
-        });
-        it('should reset escape state on any non-ESC key', async () => {
-            const onEscapePromptChange = vi.fn();
-            props.onEscapePromptChange = onEscapePromptChange;
-            props.buffer.setText('some text');
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x1B');
-                await waitFor(() => {
-                    expect(onEscapePromptChange).toHaveBeenCalledWith(false);
-                });
-            });
-            await act(async () => {
-                stdin.write('a');
-                await waitFor(() => {
-                    expect(onEscapePromptChange).toHaveBeenCalledWith(false);
-                });
-            });
-            unmount();
-        });
-        it('should handle ESC in shell mode by disabling shell mode', async () => {
-            props.shellModeActive = true;
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x1B');
-                vi.advanceTimersByTime(100);
-                expect(props.setShellModeActive).toHaveBeenCalledWith(false);
-            });
-            unmount();
-        });
-        it('should handle ESC when completion suggestions are showing', async () => {
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
-                showSuggestions: true,
-                suggestions: [{ label: 'suggestion', value: 'suggestion' }],
-            });
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x1B');
-                vi.advanceTimersByTime(100);
-                expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
-            });
-            unmount();
-        });
-        it('should not call onEscapePromptChange when not provided', async () => {
-            props.onEscapePromptChange = undefined;
-            props.buffer.setText('some text');
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            await act(async () => {
-                stdin.write('\x1B');
-            });
-            await act(async () => {
-                await vi.runAllTimersAsync();
-            });
-            unmount();
-        });
-        it('should not interfere with existing keyboard shortcuts', async () => {
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x0C');
-            });
-            await waitFor(() => expect(props.onClearScreen).toHaveBeenCalled());
-            await act(async () => {
-                stdin.write('\x01');
-            });
-            await waitFor(() => expect(props.buffer.move).toHaveBeenCalledWith('home'));
-            unmount();
-        });
-    });
-    describe('reverse search', () => {
-        beforeEach(async () => {
-            props.shellModeActive = true;
-            vi.mocked(useShellHistory).mockReturnValue({
-                history: ['echo hello', 'echo world', 'ls'],
-                getPreviousCommand: vi.fn(),
-                getNextCommand: vi.fn(),
-                addCommandToHistory: vi.fn(),
-                resetHistoryPosition: vi.fn(),
-            });
-        });
-        it('invokes reverse search on Ctrl+R', async () => {
-            // Mock the reverse search completion to return suggestions
-            mockedUseReverseSearchCompletion.mockReturnValue({
-                ...mockReverseSearchCompletion,
-                suggestions: [
-                    { label: 'echo hello', value: 'echo hello' },
-                    { label: 'echo world', value: 'echo world' },
-                    { label: 'ls', value: 'ls' },
-                ],
-                showSuggestions: true,
-                activeSuggestionIndex: 0,
-            });
-            const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            // Trigger reverse search with Ctrl+R
-            await act(async () => {
-                stdin.write('\x12');
-            });
-            await waitFor(() => {
-                const frame = stdout.lastFrame();
-                expect(frame).toContain('(r:)');
-                expect(frame).toContain('echo hello');
-                expect(frame).toContain('echo world');
-                expect(frame).toContain('ls');
-            });
-            unmount();
-        });
-        it.each([
-            { name: 'standard', escapeSequence: '\x1B' },
-            { name: 'kitty', escapeSequence: '\u001b[27u' },
-        ])('resets reverse search state on Escape ($name)', async ({ escapeSequence }) => {
-            const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x12');
-            });
-            // Wait for reverse search to be active
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('(r:)');
-            });
-            await act(async () => {
-                stdin.write(escapeSequence);
-            });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).not.toContain('(r:)');
-                expect(stdout.lastFrame()).not.toContain('echo hello');
-            });
-            unmount();
-        });
-        it('completes the highlighted entry on Tab and exits reverse-search', async () => {
-            // Mock the reverse search completion
-            const mockHandleAutocomplete = vi.fn(() => {
-                props.buffer.setText('echo hello');
-            });
-            mockedUseReverseSearchCompletion.mockImplementation((buffer, shellHistory, reverseSearchActive) => ({
-                ...mockReverseSearchCompletion,
-                suggestions: reverseSearchActive
-                    ? [
-                        { label: 'echo hello', value: 'echo hello' },
-                        { label: 'echo world', value: 'echo world' },
-                        { label: 'ls', value: 'ls' },
-                    ]
-                    : [],
-                showSuggestions: reverseSearchActive,
-                activeSuggestionIndex: reverseSearchActive ? 0 : -1,
-                handleAutocomplete: mockHandleAutocomplete,
-            }));
-            const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            // Enter reverse search mode with Ctrl+R
-            await act(async () => {
-                stdin.write('\x12');
-            });
-            // Verify reverse search is active
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('(r:)');
-            });
-            // Press Tab to complete the highlighted entry
-            await act(async () => {
-                stdin.write('\t');
-            });
-            await waitFor(() => {
-                expect(mockHandleAutocomplete).toHaveBeenCalledWith(0);
-                expect(props.buffer.setText).toHaveBeenCalledWith('echo hello');
-            });
-            unmount();
-        }, 15000);
-        it('submits the highlighted entry on Enter and exits reverse-search', async () => {
-            // Mock the reverse search completion to return suggestions
-            mockedUseReverseSearchCompletion.mockReturnValue({
-                ...mockReverseSearchCompletion,
-                suggestions: [
-                    { label: 'echo hello', value: 'echo hello' },
-                    { label: 'echo world', value: 'echo world' },
-                    { label: 'ls', value: 'ls' },
-                ],
-                showSuggestions: true,
-                activeSuggestionIndex: 0,
-            });
-            const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x12');
-            });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('(r:)');
-            });
-            await act(async () => {
-                stdin.write('\r');
-            });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).not.toContain('(r:)');
-            });
-            expect(props.onSubmit).toHaveBeenCalledWith('echo hello');
-            unmount();
-        });
-        it('should restore text and cursor position after reverse search"', async () => {
-            const initialText = 'initial text';
-            const initialCursor = [0, 3];
-            props.buffer.setText(initialText);
-            props.buffer.cursor = initialCursor;
-            // Mock the reverse search completion to be active and then reset
-            mockedUseReverseSearchCompletion.mockImplementation((buffer, shellHistory, reverseSearchActiveFromInputPrompt) => ({
-                ...mockReverseSearchCompletion,
-                suggestions: reverseSearchActiveFromInputPrompt
-                    ? [{ label: 'history item', value: 'history item' }]
-                    : [],
-                showSuggestions: reverseSearchActiveFromInputPrompt,
-            }));
-            const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            // reverse search with Ctrl+R
-            await act(async () => {
-                stdin.write('\x12');
-            });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('(r:)');
-            });
-            // Press kitty escape key
-            await act(async () => {
-                stdin.write('\u001b[27u');
-            });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).not.toContain('(r:)');
-                expect(props.buffer.text).toBe(initialText);
-                expect(props.buffer.cursor).toEqual(initialCursor);
-            });
-            unmount();
-        });
-    });
-    describe('Ctrl+E keyboard shortcut', () => {
-        it('should move cursor to end of current line in multiline input', async () => {
-            props.buffer.text = 'line 1\nline 2\nline 3';
-            props.buffer.cursor = [1, 2];
-            props.buffer.lines = ['line 1', 'line 2', 'line 3'];
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x05'); // Ctrl+E
-            });
-            await waitFor(() => {
-                expect(props.buffer.move).toHaveBeenCalledWith('end');
-            });
-            expect(props.buffer.moveToOffset).not.toHaveBeenCalled();
-            unmount();
-        });
-        it('should move cursor to end of current line for single line input', async () => {
-            props.buffer.text = 'single line text';
-            props.buffer.cursor = [0, 5];
-            props.buffer.lines = ['single line text'];
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x05'); // Ctrl+E
-            });
-            await waitFor(() => {
-                expect(props.buffer.move).toHaveBeenCalledWith('end');
-            });
-            expect(props.buffer.moveToOffset).not.toHaveBeenCalled();
-            unmount();
-        });
-    });
-    describe('command search (Ctrl+R when not in shell)', () => {
-        it('enters command search on Ctrl+R and shows suggestions', async () => {
-            props.shellModeActive = false;
-            vi.mocked(useReverseSearchCompletion).mockImplementation((buffer, data, isActive) => ({
-                ...mockReverseSearchCompletion,
-                suggestions: isActive
-                    ? [
-                        { label: 'git commit -m "msg"', value: 'git commit -m "msg"' },
-                        { label: 'git push', value: 'git push' },
-                    ]
-                    : [],
-                showSuggestions: !!isActive,
-                activeSuggestionIndex: isActive ? 0 : -1,
-            }));
-            const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x12'); // Ctrl+R
-            });
-            await waitFor(() => {
-                const frame = stdout.lastFrame() ?? '';
-                expect(frame).toContain('(r:)');
-                expect(frame).toContain('git commit');
-                expect(frame).toContain('git push');
-            });
-            unmount();
-        });
-        it('expands and collapses long suggestion via Right/Left arrows', async () => {
-            props.shellModeActive = false;
-            const longValue = 'l'.repeat(200);
-            vi.mocked(useReverseSearchCompletion).mockReturnValue({
-                ...mockReverseSearchCompletion,
-                suggestions: [{ label: longValue, value: longValue, matchedIndex: 0 }],
-                showSuggestions: true,
-                activeSuggestionIndex: 0,
-                visibleStartIndex: 0,
-                isLoadingSuggestions: false,
-            });
-            const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x12');
-            });
-            await waitFor(() => {
-                expect(clean(stdout.lastFrame())).toContain('→');
-            });
-            await act(async () => {
-                stdin.write('\u001B[C');
-            });
-            await waitFor(() => {
-                expect(clean(stdout.lastFrame())).toContain('←');
-            });
-            expect(stdout.lastFrame()).toMatchSnapshot('command-search-render-expanded-match');
-            await act(async () => {
-                stdin.write('\u001B[D');
-            });
-            await waitFor(() => {
-                expect(clean(stdout.lastFrame())).toContain('→');
-            });
-            expect(stdout.lastFrame()).toMatchSnapshot('command-search-render-collapsed-match');
-            unmount();
-        });
-        it('renders match window and expanded view (snapshots)', async () => {
-            props.shellModeActive = false;
-            props.buffer.setText('commit');
-            const label = 'git commit -m "feat: add search" in src/app';
-            const matchedIndex = label.indexOf('commit');
-            vi.mocked(useReverseSearchCompletion).mockReturnValue({
-                ...mockReverseSearchCompletion,
-                suggestions: [{ label, value: label, matchedIndex }],
-                showSuggestions: true,
-                activeSuggestionIndex: 0,
-                visibleStartIndex: 0,
-                isLoadingSuggestions: false,
-            });
-            const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x12');
-            });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('(r:)');
-            });
-            expect(stdout.lastFrame()).toMatchSnapshot('command-search-render-collapsed-match');
-            await act(async () => {
-                stdin.write('\u001B[C');
-            });
-            await waitFor(() => {
-                // Just wait for any update to ensure it is stable.
-                // We could also wait for specific text if we knew it.
-                expect(stdout.lastFrame()).toContain('(r:)');
-            });
-            expect(stdout.lastFrame()).toMatchSnapshot('command-search-render-expanded-match');
-            unmount();
-        });
-        it('does not show expand/collapse indicator for short suggestions', async () => {
-            props.shellModeActive = false;
-            const shortValue = 'echo hello';
-            vi.mocked(useReverseSearchCompletion).mockReturnValue({
-                ...mockReverseSearchCompletion,
-                suggestions: [{ label: shortValue, value: shortValue }],
-                showSuggestions: true,
-                activeSuggestionIndex: 0,
-                visibleStartIndex: 0,
-                isLoadingSuggestions: false,
-            });
-            const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\x12');
-            });
-            await waitFor(() => {
-                const frame = clean(stdout.lastFrame());
-                // Ensure it rendered the search mode
-                expect(frame).toContain('(r:)');
-                expect(frame).not.toContain('→');
-                expect(frame).not.toContain('←');
-            });
-            unmount();
-        });
-    });
-    describe('Tab focus toggle', () => {
-        it.each([
-            {
-                name: 'should toggle focus in on Tab when no suggestions or ghost text',
-                showSuggestions: false,
-                ghostText: '',
-                suggestions: [],
-                expectedFocusToggle: true,
-            },
-            {
-                name: 'should accept ghost text and NOT toggle focus on Tab',
-                showSuggestions: false,
-                ghostText: 'ghost text',
-                suggestions: [],
-                expectedFocusToggle: false,
-                expectedAcceptCall: true,
-            },
-            {
-                name: 'should NOT toggle focus on Tab when suggestions are present',
-                showSuggestions: true,
-                ghostText: '',
-                suggestions: [{ label: 'test', value: 'test' }],
-                expectedFocusToggle: false,
-            },
-        ])('$name', async ({ showSuggestions, ghostText, suggestions, expectedFocusToggle, expectedAcceptCall, }) => {
-            const mockAccept = vi.fn();
-            mockedUseCommandCompletion.mockReturnValue({
-                ...mockCommandCompletion,
-                showSuggestions,
-                suggestions,
-                promptCompletion: {
-                    text: ghostText,
-                    accept: mockAccept,
-                    clear: vi.fn(),
-                    isLoading: false,
-                    isActive: ghostText !== '',
-                    markSelected: vi.fn(),
-                },
-            });
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-                uiActions,
-                uiState: { activePtyId: 1 },
-            });
-            await act(async () => {
-                stdin.write('\t');
-            });
-            await waitFor(() => {
-                if (expectedFocusToggle) {
-                    expect(uiActions.setEmbeddedShellFocused).toHaveBeenCalledWith(true);
-                }
-                else {
-                    expect(uiActions.setEmbeddedShellFocused).not.toHaveBeenCalled();
-                }
-                if (expectedAcceptCall) {
-                    expect(mockAccept).toHaveBeenCalled();
-                }
-            });
-            unmount();
-        });
-    });
-    describe('mouse interaction', () => {
-        it.each([
-            {
-                name: 'first line, first char',
-                relX: 0,
-                relY: 0,
-                mouseCol: 4,
-                mouseRow: 2,
-            },
-            {
-                name: 'first line, middle char',
-                relX: 6,
-                relY: 0,
-                mouseCol: 10,
-                mouseRow: 2,
-            },
-            {
-                name: 'second line, first char',
-                relX: 0,
-                relY: 1,
-                mouseCol: 4,
-                mouseRow: 3,
-            },
-            {
-                name: 'second line, end char',
-                relX: 5,
-                relY: 1,
-                mouseCol: 9,
-                mouseRow: 3,
-            },
-        ])('should move cursor on mouse click - $name', async ({ relX, relY, mouseCol, mouseRow }) => {
-            props.buffer.text = 'hello world\nsecond line';
-            props.buffer.lines = ['hello world', 'second line'];
-            props.buffer.viewportVisualLines = ['hello world', 'second line'];
-            props.buffer.visualToLogicalMap = [
-                [0, 0],
-                [1, 0],
-            ];
-            props.buffer.visualCursor = [0, 11];
-            props.buffer.visualScrollRow = 0;
-            const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { mouseEventsEnabled: true, uiActions });
-            // Wait for initial render
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('hello world');
-            });
-            // Simulate left mouse press at calculated coordinates.
-            // Without left border: inner box is at x=3, y=1 based on padding(1)+prompt(2) and border-top(1).
-            await act(async () => {
-                stdin.write(`\x1b[<0;${mouseCol};${mouseRow}M`);
-            });
-            await waitFor(() => {
-                expect(props.buffer.moveToVisualPosition).toHaveBeenCalledWith(relY, relX);
-            });
-            unmount();
-        });
-        it('should unfocus embedded shell on click', async () => {
-            props.buffer.text = 'hello';
-            props.buffer.lines = ['hello'];
-            props.buffer.viewportVisualLines = ['hello'];
-            props.buffer.visualToLogicalMap = [[0, 0]];
-            props.isEmbeddedShellFocused = true;
-            const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { mouseEventsEnabled: true, uiActions });
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('hello');
-            });
-            await act(async () => {
-                // Click somewhere in the prompt
-                stdin.write(`\x1b[<0;5;2M`);
-            });
-            await waitFor(() => {
-                expect(mockSetEmbeddedShellFocused).toHaveBeenCalledWith(false);
-            });
-            unmount();
-        });
-        it('should toggle paste expansion on double-click', async () => {
-            const id = '[Pasted Text: 10 lines]';
-            const largeText = 'line1\nline2\nline3\nline4\nline5\nline6\nline7\nline8\nline9\nline10';
-            const baseProps = props;
-            const TestWrapper = () => {
-                const [isExpanded, setIsExpanded] = useState(false);
-                const currentLines = isExpanded ? largeText.split('\n') : [id];
-                const currentText = isExpanded ? largeText : id;
-                const buffer = {
-                    ...baseProps.buffer,
-                    text: currentText,
-                    lines: currentLines,
-                    viewportVisualLines: currentLines,
-                    allVisualLines: currentLines,
-                    pastedContent: { [id]: largeText },
-                    transformationsByLine: isExpanded
-                        ? currentLines.map(() => [])
-                        : [
-                            [
-                                {
-                                    logStart: 0,
-                                    logEnd: id.length,
-                                    logicalText: id,
-                                    collapsedText: id,
-                                    type: 'paste',
-                                    id,
-                                },
-                            ],
-                        ],
-                    visualScrollRow: 0,
-                    visualToLogicalMap: currentLines.map((_, i) => [i, 0]),
-                    visualToTransformedMap: currentLines.map(() => 0),
-                    getLogicalPositionFromVisual: vi.fn().mockReturnValue({
-                        row: 0,
-                        col: 2,
-                    }),
-                    togglePasteExpansion: vi.fn().mockImplementation(() => {
-                        setIsExpanded(!isExpanded);
-                    }),
-                    getExpandedPasteAtLine: vi
-                        .fn()
-                        .mockReturnValue(isExpanded ? id : null),
-                };
-                return _jsx(InputPrompt, { ...baseProps, buffer: buffer });
-            };
-            const { stdin, stdout, unmount, simulateClick } = renderWithProviders(_jsx(TestWrapper, {}), {
-                mouseEventsEnabled: true,
-                useAlternateBuffer: true,
-                uiActions,
-            });
-            // 1. Verify initial placeholder
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toMatchSnapshot();
-            });
-            // Simulate double-click to expand
-            await simulateClick(stdin, 5, 2);
-            await simulateClick(stdin, 5, 2);
-            // 2. Verify expanded content is visible
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toMatchSnapshot();
-            });
-            // Simulate double-click to collapse
-            await simulateClick(stdin, 5, 2);
-            await simulateClick(stdin, 5, 2);
-            // 3. Verify placeholder is restored
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toMatchSnapshot();
-            });
-            unmount();
-        });
-        it('should move cursor on mouse click with plain borders', async () => {
-            props.config.getUseBackgroundColor = () => false;
-            props.buffer.text = 'hello world';
-            props.buffer.lines = ['hello world'];
-            props.buffer.viewportVisualLines = ['hello world'];
-            props.buffer.visualToLogicalMap = [[0, 0]];
-            props.buffer.visualCursor = [0, 11];
-            props.buffer.visualScrollRow = 0;
-            const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { mouseEventsEnabled: true, uiActions });
-            // Wait for initial render
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('hello world');
-            });
-            // With plain borders: 1(border) + 1(padding) + 2(prompt) = 4 offset (x=4, col=5)
-            await act(async () => {
-                stdin.write(`\x1b[<0;5;2M`); // Click at col 5, row 2
-            });
-            await waitFor(() => {
-                expect(props.buffer.moveToVisualPosition).toHaveBeenCalledWith(0, 0);
-            });
-            unmount();
-        });
-    });
-    describe('queued message editing', () => {
-        it('should load all queued messages when up arrow is pressed with empty input', async () => {
-            const mockPopAllMessages = vi.fn();
-            mockPopAllMessages.mockReturnValue('Message 1\n\nMessage 2\n\nMessage 3');
-            props.popAllMessages = mockPopAllMessages;
-            props.buffer.text = '';
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
-            expect(props.buffer.setText).toHaveBeenCalledWith('Message 1\n\nMessage 2\n\nMessage 3');
-            unmount();
-        });
-        it('should not load queued messages when input is not empty', async () => {
-            const mockPopAllMessages = vi.fn();
-            props.popAllMessages = mockPopAllMessages;
-            props.buffer.text = 'some text';
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            await waitFor(() => expect(mockInputHistory.navigateUp).toHaveBeenCalled());
-            expect(mockPopAllMessages).not.toHaveBeenCalled();
-            unmount();
-        });
-        it('should handle undefined messages from popAllMessages', async () => {
-            const mockPopAllMessages = vi.fn();
-            mockPopAllMessages.mockReturnValue(undefined);
-            props.popAllMessages = mockPopAllMessages;
-            props.buffer.text = '';
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
-            expect(props.buffer.setText).not.toHaveBeenCalled();
-            expect(mockInputHistory.navigateUp).toHaveBeenCalled();
-            unmount();
-        });
-        it('should work with NAVIGATION_UP key as well', async () => {
-            const mockPopAllMessages = vi.fn();
-            props.popAllMessages = mockPopAllMessages;
-            props.buffer.text = '';
-            props.buffer.allVisualLines = [''];
-            props.buffer.visualCursor = [0, 0];
-            props.buffer.visualScrollRow = 0;
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
-            unmount();
-        });
-        it('should handle single queued message', async () => {
-            const mockPopAllMessages = vi.fn();
-            mockPopAllMessages.mockReturnValue('Single message');
-            props.popAllMessages = mockPopAllMessages;
-            props.buffer.text = '';
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
-            expect(props.buffer.setText).toHaveBeenCalledWith('Single message');
-            unmount();
-        });
-        it('should only check for queued messages when buffer text is trimmed empty', async () => {
-            const mockPopAllMessages = vi.fn();
-            props.popAllMessages = mockPopAllMessages;
-            props.buffer.text = '   '; // Whitespace only
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
-            unmount();
-        });
-        it('should not call popAllMessages if it is not provided', async () => {
-            props.popAllMessages = undefined;
-            props.buffer.text = '';
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            await waitFor(() => expect(mockInputHistory.navigateUp).toHaveBeenCalled());
-            unmount();
-        });
-        it('should navigate input history on fresh start when no queued messages exist', async () => {
-            const mockPopAllMessages = vi.fn();
-            mockPopAllMessages.mockReturnValue(undefined);
-            props.popAllMessages = mockPopAllMessages;
-            props.buffer.text = '';
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\u001B[A');
-            });
-            await waitFor(() => expect(mockPopAllMessages).toHaveBeenCalled());
-            expect(mockInputHistory.navigateUp).toHaveBeenCalled();
-            expect(props.buffer.setText).not.toHaveBeenCalled();
-            unmount();
-        });
-    });
-    describe('snapshots', () => {
-        it('should render correctly in shell mode', async () => {
-            props.shellModeActive = true;
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await waitFor(() => expect(stdout.lastFrame()).toContain('!'));
-            expect(stdout.lastFrame()).toMatchSnapshot();
-            unmount();
-        });
-        it('should render correctly when accepting edits', async () => {
-            props.approvalMode = ApprovalMode.AUTO_EDIT;
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await waitFor(() => expect(stdout.lastFrame()).toContain('>'));
-            expect(stdout.lastFrame()).toMatchSnapshot();
-            unmount();
-        });
-        it('should render correctly in yolo mode', async () => {
-            props.approvalMode = ApprovalMode.YOLO;
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await waitFor(() => expect(stdout.lastFrame()).toContain('*'));
-            expect(stdout.lastFrame()).toMatchSnapshot();
-            unmount();
-        });
-        it('should not show inverted cursor when shell is focused', async () => {
-            props.isEmbeddedShellFocused = true;
-            props.focus = false;
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await waitFor(() => {
-                expect(stdout.lastFrame()).not.toContain(`{chalk.inverse(' ')}`);
-            });
-            expect(stdout.lastFrame()).toMatchSnapshot();
-            unmount();
-        });
-    });
-    it('should still allow input when shell is not focused', async () => {
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), {
-            shellFocus: false,
-        });
-        await act(async () => {
-            stdin.write('a');
-        });
-        await waitFor(() => expect(mockBuffer.handleInput).toHaveBeenCalled());
-        unmount();
-    });
-    describe('command queuing while streaming', () => {
-        beforeEach(() => {
-            props.streamingState = StreamingState.Responding;
-            props.setQueueErrorMessage = vi.fn();
-            props.onSubmit = vi.fn();
-        });
-        it.each([
-            {
-                name: 'should prevent slash commands',
-                bufferText: '/help',
-                shellMode: false,
-                shouldSubmit: false,
-                errorMessage: 'Slash commands cannot be queued',
-            },
-            {
-                name: 'should prevent shell commands',
-                bufferText: 'ls',
-                shellMode: true,
-                shouldSubmit: false,
-                errorMessage: 'Shell commands cannot be queued',
-            },
-            {
-                name: 'should allow regular messages',
-                bufferText: 'regular message',
-                shellMode: false,
-                shouldSubmit: true,
-                errorMessage: null,
-            },
-        ])('$name', async ({ bufferText, shellMode, shouldSubmit, errorMessage }) => {
-            props.buffer.text = bufferText;
-            props.shellModeActive = shellMode;
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('\r');
-            });
-            await waitFor(() => {
-                if (shouldSubmit) {
-                    expect(props.onSubmit).toHaveBeenCalledWith(bufferText);
-                    expect(props.setQueueErrorMessage).not.toHaveBeenCalled();
-                }
-                else {
-                    expect(props.onSubmit).not.toHaveBeenCalled();
-                    expect(props.setQueueErrorMessage).toHaveBeenCalledWith(errorMessage);
-                }
-            });
-            unmount();
-        });
-    });
-    describe('image path transformation snapshots', () => {
-        const logicalLine = '@/path/to/screenshots/screenshot2x.png';
-        const transformations = calculateTransformationsForLine(logicalLine);
-        const applyVisualState = (visualLine, cursorCol) => {
-            mockBuffer.text = logicalLine;
-            mockBuffer.lines = [logicalLine];
-            mockBuffer.viewportVisualLines = [visualLine];
-            mockBuffer.allVisualLines = [visualLine];
-            mockBuffer.visualToLogicalMap = [[0, 0]];
-            mockBuffer.visualToTransformedMap = [0];
-            mockBuffer.transformationsByLine = [transformations];
-            mockBuffer.cursor = [0, cursorCol];
-            mockBuffer.visualCursor = [0, 0];
-        };
-        it('should snapshot collapsed image path', async () => {
-            const { transformedLine } = calculateTransformedLine(logicalLine, 0, [0, transformations[0].logEnd + 5], transformations);
-            applyVisualState(transformedLine, transformations[0].logEnd + 5);
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('[Image');
-            });
-            expect(stdout.lastFrame()).toMatchSnapshot();
-            unmount();
-        });
-        it('should snapshot expanded image path when cursor is on it', async () => {
-            const { transformedLine } = calculateTransformedLine(logicalLine, 0, [0, transformations[0].logStart + 1], transformations);
-            applyVisualState(transformedLine, transformations[0].logStart + 1);
-            const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await waitFor(() => {
-                expect(stdout.lastFrame()).toContain('@/path/to/screenshots');
-            });
-            expect(stdout.lastFrame()).toMatchSnapshot();
-            unmount();
-        });
-    });
-});
-function clean(str) {
-    if (!str)
-        return '';
-    // Remove ANSI escape codes and trim whitespace
-    return stripAnsi(str).trim();
-}
-//# sourceMappingURL=InputPrompt.test.js.map