@machina.ai/cell-cli 1.13.0-rc5 → 1.16.0-rc1

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

@@ -207,6 +207,7 @@ describe('InputPrompt', () => {
             focus: true,
             setQueueErrorMessage: vi.fn(),
             streamingState: StreamingState.Idle,
+            setBannerVisible: vi.fn(),
         };
     });
     it('should call shellHistory.getPreviousCommand on up arrow in shell mode', async () => {
@@ -436,77 +437,48 @@ describe('InputPrompt', () => {
             unmount();
         });
     });
-    it('should complete a partial parent command', async () => {
-        // SCENARIO: /mem -> Tab
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
+    it.each([
+        {
+            name: 'should complete a partial parent command',
+            bufferText: '/mem',
             suggestions: [{ label: 'memory', value: 'memory', description: '...' }],
-            activeSuggestionIndex: 0,
-        });
-        props.buffer.setText('/mem');
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await act(async () => {
-            stdin.write('\t'); // Press Tab
-        });
-        await waitFor(() => expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0));
-        unmount();
-    });
-    it('should append a sub-command when the parent command is already complete', async () => {
-        // SCENARIO: /memory -> Tab (to accept 'add')
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
+            activeIndex: 0,
+        },
+        {
+            name: 'should append a sub-command when parent command is complete',
+            bufferText: '/memory ',
             suggestions: [
                 { label: 'show', value: 'show' },
                 { label: 'add', value: 'add' },
             ],
-            activeSuggestionIndex: 1, // 'add' is highlighted
-        });
-        props.buffer.setText('/memory ');
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await act(async () => {
-            stdin.write('\t'); // Press Tab
-        });
-        await waitFor(() => expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(1));
-        unmount();
-    });
-    it('should handle the "backspace" edge case correctly', async () => {
-        // SCENARIO: /memory -> Backspace -> /memory -> Tab (to accept 'show')
-        mockedUseCommandCompletion.mockReturnValue({
-            ...mockCommandCompletion,
-            showSuggestions: true,
+            activeIndex: 1,
+        },
+        {
+            name: 'should handle the backspace edge case correctly',
+            bufferText: '/memory',
             suggestions: [
                 { label: 'show', value: 'show' },
                 { label: 'add', value: 'add' },
             ],
-            activeSuggestionIndex: 0, // 'show' is highlighted
-        });
-        // The user has backspaced, so the query is now just '/memory'
-        props.buffer.setText('/memory');
-        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await act(async () => {
-            stdin.write('\t'); // Press Tab
-        });
-        await waitFor(() => 
-        // It should NOT become '/show'. It should correctly become '/memory show'.
-        expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0));
-        unmount();
-    });
-    it('should complete a partial argument for a command', async () => {
-        // SCENARIO: /chat resume fi- -> Tab
+            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: [{ label: 'fix-foo', value: 'fix-foo' }],
-            activeSuggestionIndex: 0,
+            suggestions,
+            activeSuggestionIndex: activeIndex,
         });
-        props.buffer.setText('/chat resume fi-');
+        props.buffer.setText(bufferText);
         const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-        await act(async () => {
-            stdin.write('\t'); // Press Tab
-        });
-        await waitFor(() => expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0));
+        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 () => {
@@ -648,6 +620,16 @@ describe('InputPrompt', () => {
         });
         unmount();
     });
+    it('should call setBannerVisible(false) when clear screen key is pressed', async () => {
+        const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
+        await act(async () => {
+            stdin.write('\x0C'); // Ctrl+L
+        });
+        await waitFor(() => {
+            expect(props.setBannerVisible).toHaveBeenCalledWith(false);
+        });
+        unmount();
+    });
     describe('cursor-based completion trigger', () => {
         it.each([
             {
@@ -747,40 +729,34 @@ describe('InputPrompt', () => {
         });
     });
     describe('vim mode', () => {
-        it('should not call buffer.handleInput when vim mode is enabled and vim handles the input', async () => {
-            props.vimHandleInput = vi.fn().mockReturnValue(true); // Mock that vim handled it.
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('i');
-            });
-            await waitFor(() => {
-                expect(props.vimHandleInput).toHaveBeenCalled();
-            });
-            expect(mockBuffer.handleInput).not.toHaveBeenCalled();
-            unmount();
-        });
-        it('should call buffer.handleInput when vim mode is enabled but vim does not handle the input', async () => {
-            props.vimHandleInput = vi.fn().mockReturnValue(false); // Mock that vim did NOT handle it.
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
-            await act(async () => {
-                stdin.write('i');
-            });
-            await waitFor(() => {
-                expect(props.vimHandleInput).toHaveBeenCalled();
-                expect(mockBuffer.handleInput).toHaveBeenCalled();
-            });
-            unmount();
-        });
-        it('should call handleInput when vim mode is disabled', async () => {
-            // Mock vimHandleInput to return false (vim didn't handle the input)
-            props.vimHandleInput = vi.fn().mockReturnValue(false);
+        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 act(async () => stdin.write('i'));
             await waitFor(() => {
                 expect(props.vimHandleInput).toHaveBeenCalled();
-                expect(mockBuffer.handleInput).toHaveBeenCalled();
+                if (expectBufferHandleInput) {
+                    expect(mockBuffer.handleInput).toHaveBeenCalled();
+                }
+                else {
+                    expect(mockBuffer.handleInput).not.toHaveBeenCalled();
+                }
             });
             unmount();
         });
@@ -1079,7 +1055,7 @@ describe('InputPrompt', () => {
         ])('should allow immediate submission for a trusted paste ($name)', async ({ setup }) => {
             setup();
             props.buffer.text = 'pasted command';
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { kittyProtocolEnabled: true });
+            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
             await act(async () => {
                 await vi.runAllTimersAsync();
             });
@@ -1121,23 +1097,36 @@ describe('InputPrompt', () => {
         });
     });
     describe('enhanced input UX - double ESC clear functionality', () => {
+        beforeEach(() => vi.useFakeTimers());
+        afterEach(() => vi.useRealTimers());
         it('should clear buffer on second ESC press', async () => {
             const onEscapePromptChange = vi.fn();
             props.onEscapePromptChange = onEscapePromptChange;
             props.buffer.setText('text to clear');
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { kittyProtocolEnabled: false });
+            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
             await act(async () => {
                 stdin.write('\x1B');
-                await waitFor(() => {
-                    expect(onEscapePromptChange).toHaveBeenCalledWith(false);
-                });
+                vi.advanceTimersByTime(100);
+                expect(onEscapePromptChange).toHaveBeenCalledWith(false);
             });
             await act(async () => {
                 stdin.write('\x1B');
-                await waitFor(() => {
-                    expect(props.buffer.setText).toHaveBeenCalledWith('');
-                    expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
-                });
+                vi.advanceTimersByTime(100);
+                expect(props.buffer.setText).toHaveBeenCalledWith('');
+                expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
+            });
+            unmount();
+        });
+        it('should clear buffer on double ESC', 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('\x1B\x1B');
+                vi.advanceTimersByTime(100);
+                expect(props.buffer.setText).toHaveBeenCalledWith('');
+                expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
             });
             unmount();
         });
@@ -1145,7 +1134,7 @@ describe('InputPrompt', () => {
             const onEscapePromptChange = vi.fn();
             props.onEscapePromptChange = onEscapePromptChange;
             props.buffer.setText('some text');
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { kittyProtocolEnabled: false });
+            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
             await act(async () => {
                 stdin.write('\x1B');
                 await waitFor(() => {
@@ -1162,10 +1151,11 @@ describe('InputPrompt', () => {
         });
         it('should handle ESC in shell mode by disabling shell mode', async () => {
             props.shellModeActive = true;
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { kittyProtocolEnabled: false });
+            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
             await act(async () => {
                 stdin.write('\x1B');
-                await waitFor(() => expect(props.setShellModeActive).toHaveBeenCalledWith(false));
+                vi.advanceTimersByTime(100);
+                expect(props.setShellModeActive).toHaveBeenCalledWith(false);
             });
             unmount();
         });
@@ -1175,18 +1165,18 @@ describe('InputPrompt', () => {
                 showSuggestions: true,
                 suggestions: [{ label: 'suggestion', value: 'suggestion' }],
             });
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { kittyProtocolEnabled: false });
+            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
             await act(async () => {
                 stdin.write('\x1B');
+                vi.advanceTimersByTime(100);
+                expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
             });
-            await waitFor(() => expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled());
             unmount();
         });
         it('should not call onEscapePromptChange when not provided', async () => {
-            vi.useFakeTimers();
             props.onEscapePromptChange = undefined;
             props.buffer.setText('some text');
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { kittyProtocolEnabled: false });
+            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
             await act(async () => {
                 await vi.runAllTimersAsync();
             });
@@ -1196,11 +1186,10 @@ describe('InputPrompt', () => {
             await act(async () => {
                 await vi.runAllTimersAsync();
             });
-            vi.useRealTimers();
             unmount();
         });
         it('should not interfere with existing keyboard shortcuts', async () => {
-            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { kittyProtocolEnabled: false });
+            const { stdin, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
             await act(async () => {
                 stdin.write('\x0C');
             });
@@ -1250,14 +1239,10 @@ describe('InputPrompt', () => {
             unmount();
         });
         it.each([
-            { name: 'standard', kittyProtocolEnabled: false, escapeSequence: '\x1B' },
-            {
-                name: 'kitty',
-                kittyProtocolEnabled: true,
-                escapeSequence: '\u001b[27u',
-            },
-        ])('resets reverse search state on Escape ($name)', async ({ kittyProtocolEnabled, escapeSequence }) => {
-            const { stdin, stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }), { kittyProtocolEnabled });
+            { 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');
             });
@@ -1711,8 +1696,6 @@ describe('InputPrompt', () => {
             const { stdout, unmount } = renderWithProviders(_jsx(InputPrompt, { ...props }));
             await waitFor(() => {
                 expect(stdout.lastFrame()).not.toContain(`{chalk.inverse(' ')}`);
-                // This snapshot is good to make sure there was an input prompt but does
-                // not show the inverted cursor because snapshots do not show colors.
                 expect(stdout.lastFrame()).toMatchSnapshot();
             });
             unmount();