@machina.ai/cell-cli 1.19.4-rc3 → 1.22.5-rc1

package/dist/src/ui/AppContainer.test.js

@@ -36,14 +36,23 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
         writeToStdout: vi.fn((...args) => process.stdout.write(...args)),
         writeToStderr: vi.fn((...args) => process.stderr.write(...args)),
         patchStdio: vi.fn(() => () => { }),
-        createInkStdio: vi.fn(() => ({
+        createWorkingStdio: vi.fn(() => ({
             stdout: process.stdout,
             stderr: process.stderr,
         })),
         enableMouseEvents: vi.fn(),
         disableMouseEvents: vi.fn(),
+        FileDiscoveryService: vi.fn().mockImplementation(() => ({
+            initialize: vi.fn(),
+        })),
+        startupProfiler: {
+            flush: vi.fn(),
+            start: vi.fn(),
+            end: vi.fn(),
+        },
     };
 });
+import ansiEscapes from 'ansi-escapes';
 import { useQuotaAndFallback } from './hooks/useQuotaAndFallback.js';
 import { UIStateContext } from './contexts/UIStateContext.js';
 import { UIActionsContext, } from './contexts/UIActionsContext.js';
@@ -95,6 +104,7 @@ vi.mock('./contexts/VimModeContext.js');
 vi.mock('./contexts/SessionContext.js');
 vi.mock('./components/shared/text-buffer.js');
 vi.mock('./hooks/useLogger.js');
+vi.mock('./hooks/useInputHistoryStore.js');
 // Mock external utilities
 vi.mock('../utils/events.js');
 vi.mock('../utils/handleAutoUpdate.js');
@@ -120,6 +130,7 @@ import { useSessionStats } from './contexts/SessionContext.js';
 import { useTextBuffer } from './components/shared/text-buffer.js';
 import { useLogger } from './hooks/useLogger.js';
 import { useLoadingIndicator } from './hooks/useLoadingIndicator.js';
+import { useInputHistoryStore } from './hooks/useInputHistoryStore.js';
 import { useKeypress } from './hooks/useKeypress.js';
 import { measureElement } from 'ink';
 import { useTerminalSize } from './hooks/useTerminalSize.js';
@@ -157,6 +168,7 @@ describe('AppContainer State Management', () => {
     const mockedUseLogger = useLogger;
     const mockedUseLoadingIndicator = useLoadingIndicator;
     const mockedUseKeypress = useKeypress;
+    const mockedUseInputHistoryStore = useInputHistoryStore;
     beforeEach(() => {
         vi.clearAllMocks();
         // Initialize mock stdout for terminal title tests
@@ -267,7 +279,12 @@ describe('AppContainer State Management', () => {
             // Add other properties if AppContainer uses them
         });
         mockedUseLogger.mockReturnValue({
-            getPreviousUserMessages: vi.fn().mockReturnValue(new Promise(() => { })),
+            getPreviousUserMessages: vi.fn().mockResolvedValue([]),
+        });
+        mockedUseInputHistoryStore.mockReturnValue({
+            inputHistory: [],
+            addInput: vi.fn(),
+            initializeFromLogger: vi.fn(),
         });
         mockedUseLoadingIndicator.mockReturnValue({
             elapsedTime: '0.0s',
@@ -277,6 +294,8 @@ describe('AppContainer State Management', () => {
         mockConfig = makeFakeConfig();
         // Mock config's getTargetDir to return consistent workspace directory
         vi.spyOn(mockConfig, 'getTargetDir').mockReturnValue('/test/workspace');
+        vi.spyOn(mockConfig, 'initialize').mockResolvedValue(undefined);
+        vi.spyOn(mockConfig, 'getDebugMode').mockReturnValue(false);
         mockExtensionManager = vi.mockObject({
             getExtensions: vi.fn().mockReturnValue([]),
             setRequestConsent: vi.fn(),
@@ -312,13 +331,21 @@ describe('AppContainer State Management', () => {
     });
     describe('Basic Rendering', () => {
         it('renders without crashing with minimal props', async () => {
-            const { unmount } = renderAppContainer();
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             unmount();
         });
         it('renders with startup warnings', async () => {
             const startupWarnings = ['Warning 1', 'Warning 2'];
-            const { unmount } = renderAppContainer({ startupWarnings });
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer({ startupWarnings });
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             unmount();
         });
@@ -329,8 +356,12 @@ describe('AppContainer State Management', () => {
                 ...mockInitResult,
                 themeError: 'Failed to load theme',
             };
-            const { unmount } = renderAppContainer({
-                initResult: initResultWithError,
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer({
+                    initResult: initResultWithError,
+                });
+                unmount = result.unmount;
             });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             unmount();
@@ -345,23 +376,39 @@ describe('AppContainer State Management', () => {
     });
     describe('Context Providers', () => {
         it('provides AppContext with correct values', async () => {
-            const { unmount } = renderAppContainer({ version: '2.0.0' });
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer({ version: '2.0.0' });
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             // Should render and unmount cleanly
             expect(() => unmount()).not.toThrow();
         });
         it('provides UIStateContext with state management', async () => {
-            const { unmount } = renderAppContainer();
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             unmount();
         });
         it('provides UIActionsContext with action handlers', async () => {
-            const { unmount } = renderAppContainer();
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             unmount();
         });
         it('provides ConfigContext with config object', async () => {
-            const { unmount } = renderAppContainer();
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             unmount();
         });
@@ -376,7 +423,11 @@ describe('AppContainer State Management', () => {
                     showMemoryUsage: false,
                 },
             };
-            const { unmount } = renderAppContainer({ settings: settingsAllHidden });
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer({ settings: settingsAllHidden });
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             unmount();
         });
@@ -389,14 +440,22 @@ describe('AppContainer State Management', () => {
                     showMemoryUsage: true,
                 },
             };
-            const { unmount } = renderAppContainer({ settings: settingsWithMemory });
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer({ settings: settingsWithMemory });
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             unmount();
         });
     });
     describe('Version Handling', () => {
         it.each(['1.0.0', '2.1.3-beta', '3.0.0-nightly'])('handles version format: %s', async (version) => {
-            const { unmount } = renderAppContainer({ version });
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer({ version });
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             unmount();
         });
@@ -415,7 +474,11 @@ describe('AppContainer State Management', () => {
             const undefinedSettings = {
                 merged: {},
             };
-            const { unmount } = renderAppContainer({ settings: undefinedSettings });
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer({ settings: undefinedSettings });
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             unmount();
         });
@@ -711,7 +774,11 @@ describe('AppContainer State Management', () => {
     describe('Quota and Fallback Integration', () => {
         it('passes a null proQuotaRequest to UIStateContext by default', async () => {
             // The default mock from beforeEach already sets proQuotaRequest to null
-            const { unmount } = renderAppContainer();
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => {
                 // Assert that the context value is as expected
                 expect(capturedUIState.proQuotaRequest).toBeNull();
@@ -730,7 +797,11 @@ describe('AppContainer State Management', () => {
                 handleProQuotaChoice: vi.fn(),
             });
             // Act: Render the container
-            const { unmount } = renderAppContainer();
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => {
                 // Assert: The mock request is correctly passed through the context
                 expect(capturedUIState.proQuotaRequest).toEqual(mockRequest);
@@ -745,7 +816,11 @@ describe('AppContainer State Management', () => {
                 handleProQuotaChoice: mockHandler,
             });
             // Act: Render the container
-            const { unmount } = renderAppContainer();
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => {
                 // Assert: The action in the context is the mock handler we provided
                 expect(capturedUIActions.handleProQuotaChoice).toBe(mockHandler);
@@ -1091,7 +1166,11 @@ describe('AppContainer State Management', () => {
                 cancelOngoingRequest: vi.fn(),
                 activePtyId: 'some-id',
             });
-            const { unmount } = renderAppContainer();
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(resizePtySpy).toHaveBeenCalled());
             const lastCall = resizePtySpy.mock.calls[resizePtySpy.mock.calls.length - 1];
             // Check the height argument specifically
@@ -1375,7 +1454,11 @@ describe('AppContainer State Management', () => {
                 openModelDialog: vi.fn(),
                 closeModelDialog: vi.fn(),
             });
-            const { unmount } = renderAppContainer();
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             expect(capturedUIState.isModelDialogOpen).toBe(true);
             unmount();
@@ -1387,7 +1470,11 @@ describe('AppContainer State Management', () => {
                 openModelDialog: vi.fn(),
                 closeModelDialog: mockCloseModelDialog,
             });
-            const { unmount } = renderAppContainer();
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             // Verify that the actions are correctly passed through context
             act(() => {
@@ -1399,20 +1486,32 @@ describe('AppContainer State Management', () => {
     });
     describe('CoreEvents Integration', () => {
         it('subscribes to UserFeedback and drains backlog on mount', async () => {
-            const { unmount } = renderAppContainer();
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             expect(mockCoreEvents.on).toHaveBeenCalledWith(CoreEvent.UserFeedback, expect.any(Function));
             expect(mockCoreEvents.drainBacklogs).toHaveBeenCalledTimes(1);
             unmount();
         });
         it('unsubscribes from UserFeedback on unmount', async () => {
-            const { unmount } = renderAppContainer();
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             unmount();
             expect(mockCoreEvents.off).toHaveBeenCalledWith(CoreEvent.UserFeedback, expect.any(Function));
         });
         it('adds history item when UserFeedback event is received', async () => {
-            const { unmount } = renderAppContainer();
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             // Get the registered handler
             const handler = mockCoreEvents.on.mock.calls.find((call) => call[0] === CoreEvent.UserFeedback)?.[1];
@@ -1434,7 +1533,11 @@ describe('AppContainer State Management', () => {
         it('updates currentModel when ModelChanged event is received', async () => {
             // Arrange: Mock initial model
             vi.spyOn(mockConfig, 'getModel').mockReturnValue('initial-model');
-            const { unmount } = renderAppContainer();
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => {
                 expect(capturedUIState?.currentModel).toBe('initial-model');
             });
@@ -1442,6 +1545,8 @@ describe('AppContainer State Management', () => {
             const handler = mockCoreEvents.on.mock.calls.find((call) => call[0] === CoreEvent.ModelChanged)?.[1];
             expect(handler).toBeDefined();
             // Act: Simulate ModelChanged event
+            // Update config mock to return new model since the handler reads from config
+            vi.spyOn(mockConfig, 'getModel').mockReturnValue('new-model');
             act(() => {
                 handler({ model: 'new-model' });
             });
@@ -1467,7 +1572,11 @@ describe('AppContainer State Management', () => {
                 activePtyId: 'some-pty-id', // Make sure activePtyId is set
             });
             // The main assertion is that the render does not throw.
-            const { unmount } = render(_jsx(SettingsContext.Provider, { value: mockSettings, children: _jsx(AppContainer, { config: mockConfig, version: "1.0.0", initializationResult: mockInitResult }) }));
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(resizePtySpy).toHaveBeenCalled());
             unmount();
         });
@@ -1479,7 +1588,11 @@ describe('AppContainer State Management', () => {
                 authType: AuthType.USE_GEMINI,
                 apiKey: 'fake-key',
             });
-            const { unmount } = renderAppContainer();
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => {
                 expect(capturedUIState.bannerData.defaultText).toBeDefined();
                 unmount();
@@ -1501,7 +1614,11 @@ describe('AppContainer State Management', () => {
             });
         });
         it('clears the prompt when onCancelSubmit is called with shouldRestorePrompt=false', async () => {
-            const { unmount } = renderAppContainer();
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
+            });
             await waitFor(() => expect(capturedUIState).toBeTruthy());
             const { onCancelSubmit } = extractUseGeminiStreamArgs(mockedUseGeminiStream.mock.lastCall);
             act(() => {
@@ -1511,12 +1628,17 @@ describe('AppContainer State Management', () => {
             unmount();
         });
         it('restores the prompt when onCancelSubmit is called with shouldRestorePrompt=true (or undefined)', async () => {
-            mockedUseLogger.mockReturnValue({
-                getPreviousUserMessages: vi
-                    .fn()
-                    .mockResolvedValue(['previous message']),
+            // Mock useInputHistoryStore to provide input history
+            mockedUseInputHistoryStore.mockReturnValue({
+                inputHistory: ['previous message'],
+                addInput: vi.fn(),
+                initializeFromLogger: vi.fn(),
+            });
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                unmount = result.unmount;
             });
-            const { unmount } = renderAppContainer();
             await waitFor(() => expect(capturedUIState.userMessages).toContain('previous message'));
             const { onCancelSubmit } = extractUseGeminiStreamArgs(mockedUseGeminiStream.mock.lastCall);
             await act(async () => {
@@ -1525,59 +1647,67 @@ describe('AppContainer State Management', () => {
             expect(mockSetText).toHaveBeenCalledWith('previous message');
             unmount();
         });
-        it('correctly restores prompt even if userMessages is stale (race condition fix)', async () => {
-            // Setup initial history with one message
-            const initialHistory = [{ type: 'user', text: 'Previous Prompt' }];
-            mockedUseHistory.mockReturnValue({
-                history: initialHistory,
-                addItem: vi.fn(),
-                updateItem: vi.fn(),
-                clearItems: vi.fn(),
-                loadHistory: vi.fn(),
+        it('input history is independent from conversation history (survives /clear)', async () => {
+            // This test verifies that input history (used for up-arrow navigation) is maintained
+            // separately from conversation history and survives /clear operations.
+            const mockAddInput = vi.fn();
+            mockedUseInputHistoryStore.mockReturnValue({
+                inputHistory: ['first prompt', 'second prompt'],
+                addInput: mockAddInput,
+                initializeFromLogger: vi.fn(),
             });
-            let resolveLoggerPromise;
-            const loggerPromise = new Promise((resolve) => {
-                resolveLoggerPromise = resolve;
-            });
-            // Mock logger to control when userMessages updates
-            const getPreviousUserMessagesMock = vi
-                .fn()
-                .mockResolvedValueOnce([]) // Initial mount
-                .mockReturnValueOnce(loggerPromise); // Second render (simulated update)
-            mockedUseLogger.mockReturnValue({
-                getPreviousUserMessages: getPreviousUserMessagesMock,
-            });
-            const { unmount, rerender } = renderAppContainer();
-            // Wait for userMessages to be populated with 'Previous Prompt'
-            await waitFor(() => expect(capturedUIState.userMessages).toContain('Previous Prompt'));
-            // Simulate a new prompt being added (e.g., user sent it, but it overflowed)
-            const newPrompt = 'Current Prompt that Overflowed';
-            const newHistory = [...initialHistory, { type: 'user', text: newPrompt }];
+            let rerender;
+            let unmount;
+            await act(async () => {
+                const result = renderAppContainer();
+                rerender = result.rerender;
+                unmount = result.unmount;
+            });
+            // Verify userMessages is populated from inputHistory
+            await waitFor(() => expect(capturedUIState.userMessages).toContain('first prompt'));
+            expect(capturedUIState.userMessages).toContain('second prompt');
+            // Clear the conversation history (simulating /clear command)
+            const mockClearItems = vi.fn();
             mockedUseHistory.mockReturnValue({
-                history: newHistory,
+                history: [],
                 addItem: vi.fn(),
                 updateItem: vi.fn(),
-                clearItems: vi.fn(),
+                clearItems: mockClearItems,
                 loadHistory: vi.fn(),
             });
-            // Rerender to reflect the history change.
-            // This triggers the effect to update userMessages, but it hangs on loggerPromise.
-            rerender(getAppContainer());
-            const { onCancelSubmit } = extractUseGeminiStreamArgs(mockedUseGeminiStream.mock.lastCall);
-            // Call onCancelSubmit immediately. userMessages is still stale (has only 'Previous Prompt')
-            // because the effect is waiting on loggerPromise.
-            act(() => {
-                onCancelSubmit(true);
+            await act(async () => {
+                // Rerender to apply the new mock.
+                rerender(getAppContainer());
             });
-            // Now resolve the promise to let the effect complete and update userMessages
+            // Verify that userMessages still contains the input history
+            // (it should not be affected by clearing conversation history)
+            expect(capturedUIState.userMessages).toContain('first prompt');
+            expect(capturedUIState.userMessages).toContain('second prompt');
+            unmount();
+        });
+    });
+    describe('Regression Tests', () => {
+        it('does not refresh static on startup if banner text is empty', async () => {
+            // Mock banner text to be empty strings
+            vi.spyOn(mockConfig, 'getBannerTextNoCapacityIssues').mockResolvedValue('');
+            vi.spyOn(mockConfig, 'getBannerTextCapacityIssues').mockResolvedValue('');
+            // Clear previous calls
+            mocks.mockStdout.write.mockClear();
+            let compUnmount = () => { };
             await act(async () => {
-                resolveLoggerPromise([]);
+                const { unmount } = renderAppContainer();
+                compUnmount = unmount;
             });
-            // With the fix, it should have waited for userMessages to update and then set the new prompt
-            await waitFor(() => {
-                expect(mockSetText).toHaveBeenCalledWith(newPrompt);
+            // Allow async effects to run
+            await waitFor(() => expect(capturedUIState).toBeTruthy());
+            // Wait for fetchBannerTexts to complete
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 100));
             });
-            unmount();
+            // Check that clearTerminal was NOT written to stdout
+            const clearTerminalCalls = mocks.mockStdout.write.mock.calls.filter((call) => call[0] === ansiEscapes.clearTerminal);
+            expect(clearTerminalCalls).toHaveLength(0);
+            compUnmount();
         });
     });
 });