@machina.ai/cell-cli 1.41.1-rc1 → 1.45.1-rc1

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

@@ -65,6 +65,9 @@ vi.mock('../hooks/useReverseSearchCompletion.js');
 vi.mock('clipboardy');
 vi.mock('../utils/clipboardUtils.js');
 vi.mock('../hooks/useKittyKeyboardProtocol.js');
+vi.mock('./ListeningIndicator.js', () => ({
+    ListeningIndicator: vi.fn(({ color }) => _jsx(Text, { color: color, children: "~~~ " })),
+}));
 // Mock ink BEFORE importing components that use it to intercept terminalCursorPosition
 vi.mock('ink', async (importOriginal) => {
     const actual = await importOriginal();
@@ -272,7 +275,7 @@ describe('InputPrompt', () => {
             visualToLogicalMap: [[0, 0]],
             visualToTransformedMap: [0],
             transformationsByLine: [],
-            getOffset: vi.fn().mockReturnValue(0),
+            getOffset: vi.fn().mockImplementation(() => mockBuffer.cursor[1]),
             pastedContent: {},
         };
         mockShellHistory = {
@@ -1472,8 +1475,8 @@ describe('InputPrompt', () => {
             },
             {
                 name: 'should NOT trigger completion when cursor is after space following /',
-                text: '/memory add',
-                cursor: [0, 11],
+                text: '/memory list',
+                cursor: [0, 12],
                 showSuggestions: false,
             },
             {
@@ -3698,6 +3701,34 @@ describe('InputPrompt', () => {
             });
             unmount();
         });
+        it('should NOT open shortcuts help with ? in vim NORMAL mode', async () => {
+            const setShortcutsHelpVisible = vi.fn();
+            const vimHandleInput = vi.fn().mockReturnValue(true);
+            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, vimEnabled: true, vimMode: "NORMAL", vimHandleInput: vimHandleInput }), {
+                uiActions: { setShortcutsHelpVisible },
+            });
+            await act(async () => {
+                stdin.write('?');
+            });
+            expect(setShortcutsHelpVisible).not.toHaveBeenCalled();
+            expect(vimHandleInput).toHaveBeenCalled();
+            expect(mockBuffer.handleInput).not.toHaveBeenCalled();
+            unmount();
+        });
+        it('should open shortcuts help with ? in vim INSERT mode', async () => {
+            const setShortcutsHelpVisible = vi.fn();
+            const vimHandleInput = vi.fn().mockReturnValue(false);
+            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, vimEnabled: true, vimMode: "INSERT", vimHandleInput: vimHandleInput }), {
+                uiActions: { setShortcutsHelpVisible },
+            });
+            await act(async () => {
+                stdin.write('?');
+            });
+            await waitFor(() => {
+                expect(setShortcutsHelpVisible).toHaveBeenCalledWith(true);
+            });
+            unmount();
+        });
         it.each([
             {
                 name: 'terminal paste event occurs',
@@ -3765,23 +3796,19 @@ describe('InputPrompt', () => {
                 }),
             });
             // Initially not recording
-            expect(lastFrame()).not.toContain('🎙️ Listening...');
-            expect(lastFrame()).toContain('Voice mode: Space to start/stop recording');
+            expect(lastFrame()).toContain('🎤 >');
+            expect(lastFrame()).toContain('Type your message or space to talk (Esc to exit)');
             // Press space to start
             await act(async () => {
                 stdin.write(' ');
             });
-            // Now should show listening
-            await waitFor(() => {
-                expect(lastFrame()).toContain('🎙️ Listening...');
-            });
             unmount();
         });
         it('should toggle recording off when space is pressed again (toggle)', async () => {
             await act(async () => {
                 mockBuffer.setText('');
             });
-            const { stdin, unmount, lastFrame } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
+            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
                 uiState: { isVoiceModeEnabled: true },
                 settings: createMockSettings({
                     experimental: { voice: { activationMode: 'toggle' } },
@@ -3791,22 +3818,15 @@ describe('InputPrompt', () => {
             await act(async () => {
                 stdin.write(' ');
             });
-            await waitFor(() => {
-                expect(lastFrame()).toContain('🎙️ Listening...');
-            });
             // Stop recording
             await act(async () => {
                 stdin.write(' ');
             });
-            await waitFor(() => {
-                expect(lastFrame()).not.toContain('🎙️ Listening...');
-                expect(lastFrame()).toContain('Voice mode: Space to start/stop recording');
-            });
             unmount();
         });
         it('should resume recording when space is pressed even if buffer is not empty (toggle)', async () => {
             await act(async () => {
-                mockBuffer.setText('some existing text');
+                mockBuffer.setText('First turn.');
             });
             const { stdin, unmount, lastFrame } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
                 uiState: { isVoiceModeEnabled: true },
@@ -3814,23 +3834,20 @@ describe('InputPrompt', () => {
                     experimental: { voice: { activationMode: 'toggle' } },
                 }),
             });
-            // Should show voice mode hint even if buffer is not empty (new behavior)
-            expect(lastFrame()).toContain('Voice mode: Space to start/stop recording');
-            expect(lastFrame()).toContain('some existing text');
+            // Should show voice mode prefix even if buffer is not empty
+            expect(lastFrame()).toContain('🎤 >');
+            expect(lastFrame()).toContain('First turn.');
             // Press space to start recording again
             await act(async () => {
                 stdin.write(' ');
             });
-            await waitFor(() => {
-                expect(lastFrame()).toContain('🎙️ Listening...');
-            });
             unmount();
         });
         it('should not start recording if voice mode is disabled (toggle)', async () => {
             await act(async () => {
                 mockBuffer.setText('');
             });
-            const { stdin, unmount, lastFrame } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
+            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
                 uiState: { isVoiceModeEnabled: false },
                 settings: createMockSettings({
                     experimental: { voice: { activationMode: 'toggle' } },
@@ -3841,7 +3858,6 @@ describe('InputPrompt', () => {
                 stdin.write(' ');
             });
             // Should NOT show listening, instead should call handleInput which handles space
-            expect(lastFrame()).not.toContain('🎙️ Listening...');
             expect(mockBuffer.handleInput).toHaveBeenCalled();
             unmount();
         });
@@ -3864,19 +3880,17 @@ describe('InputPrompt', () => {
                 fakeTranscriptionProvider.emit('transcription', 'hello');
             });
             await waitFor(() => {
-                expect(mockBuffer.setText).toHaveBeenCalledWith('initial hello', 'end');
+                expect(mockBuffer.setText).toHaveBeenCalledWith('initial hello', 13);
             });
-            // Emit turnComplete (Gemini Live starts over after this)
+            // turnComplete advances the baseline; next turn appends after it
             await act(async () => {
                 fakeTranscriptionProvider.emit('turnComplete');
             });
-            // Emit second part (Gemini Live sends new turn text starting from empty)
             await act(async () => {
                 fakeTranscriptionProvider.emit('transcription', 'world');
             });
             await waitFor(() => {
-                // Should have appended 'world' to the baseline 'initial hello'
-                expect(mockBuffer.setText).toHaveBeenCalledWith('initial hello world', 'end');
+                expect(mockBuffer.setText).toHaveBeenCalledWith('initial hello world', 19);
             });
             unmount();
         });
@@ -3899,7 +3913,30 @@ describe('InputPrompt', () => {
                 fakeTranscriptionProvider.emit('transcription', 'Second turn.');
             });
             await waitFor(() => {
-                expect(mockBuffer.setText).toHaveBeenCalledWith('First turn. Second turn.', 'end');
+                expect(mockBuffer.setText).toHaveBeenCalledWith('First turn. Second turn.', 24);
+            });
+            unmount();
+        });
+        it('should insert transcription at cursor position when buffer has text before and after (toggle)', async () => {
+            await act(async () => {
+                mockBuffer.setText('hello world');
+                mockBuffer.cursor = [0, 5]; // cursor after 'hello'
+            });
+            const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
+                uiState: { isVoiceModeEnabled: true },
+                settings: createMockSettings({
+                    experimental: { voice: { activationMode: 'toggle' } },
+                }),
+            });
+            await act(async () => {
+                stdin.write(' ');
+            });
+            await act(async () => {
+                fakeTranscriptionProvider.emit('transcription', 'there');
+            });
+            // 'hello'(5) + ' '(1) + 'there'(5) = cursor at 11; ' world' preserved after
+            await waitFor(() => {
+                expect(mockBuffer.setText).toHaveBeenCalledWith('hello there world', 11);
             });
             unmount();
         });
@@ -3917,23 +3954,22 @@ describe('InputPrompt', () => {
                         experimental: { voice: { activationMode: 'push-to-talk' } },
                     }),
                 });
-                expect(lastFrame()).toContain('Voice mode: Hold Space to record');
+                expect(lastFrame()).toContain('🎤 >');
+                expect(lastFrame()).toContain('Type your message or hold space to talk (Esc to exit)');
                 // Press space once
                 await act(async () => {
                     stdin.write(' ');
                 });
                 // Should insert space optimistically
                 expect(mockBuffer.insert).toHaveBeenCalledWith(' ');
-                expect(lastFrame()).not.toContain('🎙️ Listening...');
                 // Advance timer past HOLD_DELAY_MS
                 await act(async () => {
                     vi.advanceTimersByTime(700);
                 });
-                expect(lastFrame()).not.toContain('🎙️ Listening...');
                 unmount();
             });
             it('should start recording on hold (simulated by repeat spaces)', async () => {
-                const { stdin, unmount, lastFrame } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
+                const { stdin, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props, focus: true, buffer: mockBuffer }), {
                     uiState: { isVoiceModeEnabled: true },
                     settings: createMockSettings({
                         experimental: { voice: { activationMode: 'push-to-talk' } },
@@ -3951,8 +3987,6 @@ describe('InputPrompt', () => {
                 await waitFor(() => {
                     // Should have backspaced the optimistic space
                     expect(mockBuffer.backspace).toHaveBeenCalled();
-                    // Should show listening
-                    expect(lastFrame()).toContain('🎙️ Listening...');
                 });
                 unmount();
             });
@@ -3968,23 +4002,16 @@ describe('InputPrompt', () => {
                     stdin.write(' ');
                     stdin.write(' ');
                 });
-                // Use a short interval in waitFor to prevent advancing fake timers past the 300ms RELEASE_DELAY_MS
-                await waitFor(() => {
-                    expect(lastFrame()).toContain('🎙️ Listening...');
-                }, { interval: 10 });
                 // Simulate heartbeat (held key) - send space first to reset timer, then advance
                 await act(async () => {
                     stdin.write(' ');
                     vi.advanceTimersByTime(100);
                 });
-                expect(lastFrame()).toContain('🎙️ Listening...');
+                expect(lastFrame()).toContain('~~~ >');
                 // Stop heartbeat (release)
                 await act(async () => {
                     vi.advanceTimersByTime(400); // Past RELEASE_DELAY_MS
                 });
-                await waitFor(() => {
-                    expect(lastFrame()).not.toContain('🎙️ Listening...');
-                });
                 unmount();
             });
             it('should cancel hold state if non-space key is pressed after first space', async () => {
@@ -4012,6 +4039,28 @@ describe('InputPrompt', () => {
             });
         });
     });
+    describe('terminal buffer rendering', () => {
+        it('does not clip the last char of a visual line whose width equals inputWidth', async () => {
+            const fullLine = '1234567890'; // 10 chars, exactly props.inputWidth
+            props.inputWidth = 10;
+            props.suggestionsWidth = 10;
+            vi.spyOn(props.config, 'getUseTerminalBuffer').mockReturnValue(true);
+            mockBuffer.text = fullLine;
+            mockBuffer.lines = [fullLine];
+            mockBuffer.allVisualLines = [fullLine];
+            mockBuffer.viewportVisualLines = [fullLine];
+            mockBuffer.visualToLogicalMap = [[0, 0]];
+            mockBuffer.visualToTransformedMap = [0];
+            mockBuffer.transformationsByLine = [[]];
+            mockBuffer.cursor = [0, fullLine.length];
+            mockBuffer.visualCursor = [0, fullLine.length];
+            const { lastFrame, unmount } = await renderWithProviders(_jsx(TestInputPrompt, { ...props }), { uiActions });
+            await waitFor(() => {
+                expect(clean(lastFrame())).toContain(fullLine);
+            });
+            unmount();
+        });
+    });
 });
 function clean(str) {
     if (!str)