@machina.ai/cell-cli 1.20.2-rc1 → 1.25.0-rc3

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

@@ -4,16 +4,17 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { renderWithProviders } from '../../test-utils/render.js';
+import { renderWithProviders, createMockSettings, } from '../../test-utils/render.js';
 import { waitFor } from '../../test-utils/async.js';
 import { act } from 'react';
 import { InputPrompt } from './InputPrompt.js';
-import { ApprovalMode } from '@google/gemini-cli-core';
+import { calculateTransformationsForLine, calculateTransformedLine, } from './shared/text-buffer.js';
+import { ApprovalMode, debugLogger } from '@google/gemini-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 } from '../hooks/useCommandCompletion.js';
+import { useCommandCompletion, CompletionMode, } from '../hooks/useCommandCompletion.js';
 import { useInputHistory } from '../hooks/useInputHistory.js';
 import { useReverseSearchCompletion } from '../hooks/useReverseSearchCompletion.js';
 import clipboardy from 'clipboardy';
@@ -23,6 +24,7 @@ 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';
 vi.mock('../hooks/useShellHistory.js');
 vi.mock('../hooks/useCommandCompletion.js');
 vi.mock('../hooks/useInputHistory.js');
@@ -102,6 +104,7 @@ describe('InputPrompt', () => {
     };
     beforeEach(() => {
         vi.resetAllMocks();
+        vi.spyOn(terminalCapabilityManager, 'isKittyProtocolEnabled').mockReturnValue(true);
         mockCommandContext = createMockCommandContext();
         mockBuffer = {
             text: '',
@@ -141,6 +144,8 @@ describe('InputPrompt', () => {
             deleteWordLeft: vi.fn(),
             deleteWordRight: vi.fn(),
             visualToLogicalMap: [[0, 0]],
+            visualToTransformedMap: [0],
+            transformationsByLine: [],
             getOffset: vi.fn().mockReturnValue(0),
         };
         mockShellHistory = {
@@ -177,8 +182,11 @@ describe('InputPrompt', () => {
                 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 = {
@@ -457,8 +465,8 @@ describe('InputPrompt', () => {
             unmount();
         });
         it('should handle errors during clipboard operations', async () => {
-            const consoleErrorSpy = vi
-                .spyOn(console, 'error')
+            const debugLoggerErrorSpy = vi
+                .spyOn(debugLogger, 'error')
                 .mockImplementation(() => { });
             vi.mocked(clipboardUtils.clipboardHasImage).mockRejectedValue(new Error('Clipboard error'));
             const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
@@ -466,10 +474,10 @@ describe('InputPrompt', () => {
                 stdin.write('\x16'); // Ctrl+V
             });
             await waitFor(() => {
-                expect(consoleErrorSpy).toHaveBeenCalledWith('Error handling clipboard image:', expect.any(Error));
+                expect(debugLoggerErrorSpy).toHaveBeenCalledWith('Error handling paste:', expect.any(Error));
             });
             expect(mockBuffer.setText).not.toHaveBeenCalled();
-            consoleErrorSpy.mockRestore();
+            debugLoggerErrorSpy.mockRestore();
             unmount();
         });
     });
@@ -488,6 +496,23 @@ describe('InputPrompt', () => {
             });
             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([
         {
@@ -610,6 +635,55 @@ describe('InputPrompt', () => {
         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,
@@ -646,6 +720,8 @@ describe('InputPrompt', () => {
                 completionStart: 1,
                 completionEnd: 3, // "/ab" -> start at 1, end at 3
                 getCommandFromSuggestion: vi.fn(),
+                isArgumentCompletion: false,
+                leafCommand: null,
             },
         });
         // User typed partial command
@@ -765,6 +841,137 @@ describe('InputPrompt', () => {
         });
         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,
@@ -1713,6 +1920,66 @@ describe('InputPrompt', () => {
             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([
             {
@@ -1979,6 +2246,39 @@ describe('InputPrompt', () => {
             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()).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()).toMatchSnapshot();
+            });
+            unmount();
+        });
+    });
 });
 function clean(str) {
     if (!str)