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

package/dist/src/config/config.test.js

@@ -4,7 +4,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { Config, ApprovalMode, DEFAULT_FILE_FILTERING_OPTIONS, } from './config.js';
+import { Config, DEFAULT_FILE_FILTERING_OPTIONS } from './config.js';
+import { ExperimentFlags } from '../code_assist/experiments/flagNames.js';
+import { debugLogger } from '../utils/debugLogger.js';
+import { ApprovalMode } from '../policy/types.js';
+import { HookType, HookEventName } from '../hooks/types.js';
 import * as path from 'node:path';
 import { setGeminiMdFilename as mockSetGeminiMdFilename } from '../tools/memoryTool.js';
 import { DEFAULT_TELEMETRY_TARGET, DEFAULT_OTLP_ENDPOINT, } from '../telemetry/index.js';
@@ -19,6 +23,15 @@ import { RipGrepTool, canUseRipgrep } from '../tools/ripGrep.js';
 import { logRipgrepFallback } from '../telemetry/loggers.js';
 import { RipgrepFallbackEvent } from '../telemetry/types.js';
 import { ToolRegistry } from '../tools/tool-registry.js';
+import { DEFAULT_MODEL_CONFIGS } from './defaultModelConfigs.js';
+const mockCoreEvents = vi.hoisted(() => ({
+    emit: vi.fn(),
+    emitFeedback: vi.fn(),
+    emitModelChanged: vi.fn(),
+}));
+vi.mock('../utils/events.js', () => ({
+    coreEvents: mockCoreEvents,
+}));
 vi.mock('fs', async (importOriginal) => {
     const actual = await importOriginal();
     return {
@@ -35,6 +48,7 @@ vi.mock('../tools/tool-registry', () => {
     const ToolRegistryMock = vi.fn();
     ToolRegistryMock.prototype.registerTool = vi.fn();
     ToolRegistryMock.prototype.discoverAllTools = vi.fn();
+    ToolRegistryMock.prototype.sortTools = vi.fn();
     ToolRegistryMock.prototype.getAllTools = vi.fn(() => []); // Mock methods if needed
     ToolRegistryMock.prototype.getTool = vi.fn();
     ToolRegistryMock.prototype.getFunctionDeclarations = vi.fn(() => []);
@@ -121,10 +135,14 @@ vi.mock('../agents/subagent-tool-wrapper.js', () => ({
 import { BaseLlmClient } from '../core/baseLlmClient.js';
 import { tokenLimit } from '../core/tokenLimits.js';
 import { uiTelemetryService } from '../telemetry/index.js';
+import { getCodeAssistServer } from '../code_assist/codeAssist.js';
+import { getExperiments } from '../code_assist/experiments/experiments.js';
 vi.mock('../core/baseLlmClient.js');
 vi.mock('../core/tokenLimits.js', () => ({
     tokenLimit: vi.fn(),
 }));
+vi.mock('../code_assist/codeAssist.js');
+vi.mock('../code_assist/experiments/experiments.js');
 describe('Server Config (config.ts)', () => {
     const MODEL = 'gemini-pro';
     const SANDBOX = {
@@ -197,7 +215,7 @@ describe('Server Config (config.ts)', () => {
                 ...baseParams,
                 experiments: {
                     flags: {
-                        GeminiCLIContextCompression__threshold_fraction: {
+                        [ExperimentFlags.CONTEXT_COMPRESSION_THRESHOLD]: {
                             floatValue: 0.8,
                         },
                     },
@@ -210,7 +228,7 @@ describe('Server Config (config.ts)', () => {
                 ...baseParams,
                 experiments: {
                     flags: {
-                        GeminiCLIContextCompression__threshold_fraction: {
+                        [ExperimentFlags.CONTEXT_COMPRESSION_THRESHOLD]: {
                             floatValue: 0.0,
                         },
                     },
@@ -222,6 +240,40 @@ describe('Server Config (config.ts)', () => {
             const config = new Config(baseParams);
             expect(await config.getCompressionThreshold()).toBeUndefined();
         });
+        describe('getUserCaching', () => {
+            it('should return the remote experiment flag when available', async () => {
+                const config = new Config({
+                    ...baseParams,
+                    experiments: {
+                        flags: {
+                            [ExperimentFlags.USER_CACHING]: {
+                                boolValue: true,
+                            },
+                        },
+                        experimentIds: [],
+                    },
+                });
+                expect(await config.getUserCaching()).toBe(true);
+            });
+            it('should return false when the remote flag is false', async () => {
+                const config = new Config({
+                    ...baseParams,
+                    experiments: {
+                        flags: {
+                            [ExperimentFlags.USER_CACHING]: {
+                                boolValue: false,
+                            },
+                        },
+                        experimentIds: [],
+                    },
+                });
+                expect(await config.getUserCaching()).toBe(false);
+            });
+            it('should return undefined if there are no experiments', async () => {
+                const config = new Config(baseParams);
+                expect(await config.getUserCaching()).toBeUndefined();
+            });
+        });
     });
     describe('refreshAuth', () => {
         it('should refresh auth and update config', async () => {
@@ -255,6 +307,13 @@ describe('Server Config (config.ts)', () => {
             await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE, vi.fn());
             expect(config.getGeminiClient().stripThoughtsFromHistory).toHaveBeenCalledWith();
         });
+        it('should strip thoughts when switching from GenAI to Vertex AI', async () => {
+            const config = new Config(baseParams);
+            vi.mocked(createContentGeneratorConfig).mockImplementation(async (_, authType) => ({ authType }));
+            await config.refreshAuth(AuthType.USE_GEMINI);
+            await config.refreshAuth(AuthType.USE_VERTEX_AI);
+            expect(config.getGeminiClient().stripThoughtsFromHistory).toHaveBeenCalledWith();
+        });
         it('should not strip thoughts when switching from Vertex to GenAI', async () => {
             const config = new Config(baseParams);
             vi.mocked(createContentGeneratorConfig).mockImplementation(async (_, authType) => Promise.resolve({
@@ -265,6 +324,72 @@ describe('Server Config (config.ts)', () => {
             expect(config.getGeminiClient().stripThoughtsFromHistory).not.toHaveBeenCalledWith();
         });
     });
+    describe('Preview Features Logic in refreshAuth', () => {
+        beforeEach(() => {
+            // Set up default mock behavior for these functions before each test
+            vi.mocked(getCodeAssistServer).mockReturnValue(undefined);
+            vi.mocked(getExperiments).mockResolvedValue({
+                flags: {},
+                experimentIds: [],
+            });
+        });
+        it('should enable preview features for Google auth when remote flag is true', async () => {
+            // Override the default mock for this specific test
+            vi.mocked(getCodeAssistServer).mockReturnValue({}); // Simulate Google auth by returning a truthy value
+            vi.mocked(getExperiments).mockResolvedValue({
+                flags: {
+                    [ExperimentFlags.ENABLE_PREVIEW]: { boolValue: true },
+                },
+                experimentIds: [],
+            });
+            const config = new Config({ ...baseParams, previewFeatures: undefined });
+            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+            expect(config.getPreviewFeatures()).toBe(true);
+        });
+        it('should disable preview features for Google auth when remote flag is false', async () => {
+            // Override the default mock
+            vi.mocked(getCodeAssistServer).mockReturnValue({});
+            vi.mocked(getExperiments).mockResolvedValue({
+                flags: {
+                    [ExperimentFlags.ENABLE_PREVIEW]: { boolValue: false },
+                },
+                experimentIds: [],
+            });
+            const config = new Config({ ...baseParams, previewFeatures: undefined });
+            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+            expect(config.getPreviewFeatures()).toBe(undefined);
+        });
+        it('should disable preview features for Google auth when remote flag is missing', async () => {
+            // Override the default mock for getCodeAssistServer, the getExperiments mock is already correct
+            vi.mocked(getCodeAssistServer).mockReturnValue({});
+            const config = new Config({ ...baseParams, previewFeatures: undefined });
+            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+            expect(config.getPreviewFeatures()).toBe(undefined);
+        });
+        it('should not change preview features or model if it is already set to true', async () => {
+            const initialModel = 'some-other-model';
+            const config = new Config({
+                ...baseParams,
+                previewFeatures: true,
+                model: initialModel,
+            });
+            // It doesn't matter which auth method we use here, the logic should exit early
+            await config.refreshAuth(AuthType.USE_GEMINI);
+            expect(config.getPreviewFeatures()).toBe(true);
+            expect(config.getModel()).toBe(initialModel);
+        });
+        it('should not change preview features or model if it is already set to false', async () => {
+            const initialModel = 'some-other-model';
+            const config = new Config({
+                ...baseParams,
+                previewFeatures: false,
+                model: initialModel,
+            });
+            await config.refreshAuth(AuthType.USE_GEMINI);
+            expect(config.getPreviewFeatures()).toBe(false);
+            expect(config.getModel()).toBe(initialModel);
+        });
+    });
     it('Config constructor should store userMemory correctly', () => {
         const config = new Config(baseParams);
         expect(config.getUserMemory()).toBe(USER_MEMORY);
@@ -305,7 +430,8 @@ describe('Server Config (config.ts)', () => {
         expect(config.getFileFilteringRespectGitIgnore()).toBe(false);
     });
     it('should initialize WorkspaceContext with includeDirectories', () => {
-        const includeDirectories = ['/path/to/dir1', '/path/to/dir2'];
+        const resolved = path.resolve(baseParams.targetDir);
+        const includeDirectories = ['dir1', 'dir2'];
         const paramsWithIncludeDirs = {
             ...baseParams,
             includeDirectories,
@@ -315,9 +441,9 @@ describe('Server Config (config.ts)', () => {
         const directories = workspaceContext.getDirectories();
         // Should include the target directory plus the included directories
         expect(directories).toHaveLength(3);
-        expect(directories).toContain(path.resolve(baseParams.targetDir));
-        expect(directories).toContain('/path/to/dir1');
-        expect(directories).toContain('/path/to/dir2');
+        expect(directories).toContain(resolved);
+        expect(directories).toContain(path.join(resolved, 'dir1'));
+        expect(directories).toContain(path.join(resolved, 'dir2'));
     });
     it('Config constructor should set telemetry to true when provided as true', () => {
         const paramsWithTelemetry = {
@@ -674,18 +800,6 @@ describe('Server Config (config.ts)', () => {
                 const wasShellToolRegistered = registerToolMock.mock.calls.some((call) => call[0] instanceof vi.mocked(ShellTool));
                 expect(wasShellToolRegistered).toBe(true);
             });
-            it('should not register a tool if excludeTools contains the non-minified class name', async () => {
-                const params = {
-                    ...baseParams,
-                    coreTools: undefined, // all tools enabled by default
-                    excludeTools: ['ShellTool'],
-                };
-                const config = new Config(params);
-                await config.initialize();
-                const registerToolMock = (await vi.importMock('../tools/tool-registry')).ToolRegistry.prototype.registerTool;
-                const wasShellToolRegistered = registerToolMock.mock.calls.some((call) => call[0] instanceof vi.mocked(ShellTool));
-                expect(wasShellToolRegistered).toBe(false);
-            });
             it('should register a tool if coreTools contains an argument-specific pattern with the non-minified class name', async () => {
                 const params = {
                     ...baseParams,
@@ -872,4 +986,307 @@ describe('BaseLlmClient Lifecycle', () => {
         expect(BaseLlmClient).toHaveBeenCalledWith(config.getContentGenerator(), config);
     });
 });
+describe('Generation Config Merging (HACK)', () => {
+    const MODEL = 'gemini-pro';
+    const SANDBOX = {
+        command: 'docker',
+        image: 'gemini-cli-sandbox',
+    };
+    const TARGET_DIR = '/path/to/target';
+    const DEBUG_MODE = false;
+    const QUESTION = 'test question';
+    const USER_MEMORY = 'Test User Memory';
+    const TELEMETRY_SETTINGS = { enabled: false };
+    const EMBEDDING_MODEL = 'gemini-embedding';
+    const SESSION_ID = 'test-session-id';
+    const baseParams = {
+        cwd: '/tmp',
+        embeddingModel: EMBEDDING_MODEL,
+        sandbox: SANDBOX,
+        targetDir: TARGET_DIR,
+        debugMode: DEBUG_MODE,
+        question: QUESTION,
+        userMemory: USER_MEMORY,
+        telemetry: TELEMETRY_SETTINGS,
+        sessionId: SESSION_ID,
+        model: MODEL,
+        usageStatisticsEnabled: false,
+    };
+    it('should merge default aliases when user provides only overrides', () => {
+        const userOverrides = [
+            {
+                match: { model: 'test-model' },
+                modelConfig: { generateContentConfig: { temperature: 0.1 } },
+            },
+        ];
+        const params = {
+            ...baseParams,
+            modelConfigServiceConfig: {
+                overrides: userOverrides,
+            },
+        };
+        const config = new Config(params);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const serviceConfig = config.modelConfigService.config;
+        // Assert that the default aliases are present
+        expect(serviceConfig.aliases).toEqual(DEFAULT_MODEL_CONFIGS.aliases);
+        // Assert that the user's overrides are present
+        expect(serviceConfig.overrides).toEqual(userOverrides);
+    });
+    it('should use user-provided aliases if they exist', () => {
+        const userAliases = {
+            'my-alias': {
+                modelConfig: { model: 'my-model' },
+            },
+        };
+        const params = {
+            ...baseParams,
+            modelConfigServiceConfig: {
+                aliases: userAliases,
+            },
+        };
+        const config = new Config(params);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const serviceConfig = config.modelConfigService.config;
+        // Assert that the user's aliases are used, not the defaults
+        expect(serviceConfig.aliases).toEqual(userAliases);
+    });
+    it('should use default generation config if none is provided', () => {
+        const params = { ...baseParams };
+        const config = new Config(params);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const serviceConfig = config.modelConfigService.config;
+        // Assert that the full default config is used
+        expect(serviceConfig).toEqual(DEFAULT_MODEL_CONFIGS);
+    });
+});
+describe('Config getHooks', () => {
+    const baseParams = {
+        cwd: '/tmp',
+        targetDir: '/path/to/target',
+        debugMode: false,
+        sessionId: 'test-session-id',
+        model: 'gemini-pro',
+        usageStatisticsEnabled: false,
+    };
+    it('should return undefined when no hooks are provided', () => {
+        const config = new Config(baseParams);
+        expect(config.getHooks()).toBeUndefined();
+    });
+    it('should return empty object when empty hooks are provided', () => {
+        const configWithEmptyHooks = new Config({
+            ...baseParams,
+            hooks: {},
+        });
+        expect(configWithEmptyHooks.getHooks()).toEqual({});
+    });
+    it('should return the hooks configuration when provided', () => {
+        const mockHooks = {
+            [HookEventName.BeforeTool]: [
+                {
+                    matcher: 'write_file',
+                    hooks: [
+                        {
+                            type: HookType.Command,
+                            command: 'echo "test hook"',
+                            timeout: 5000,
+                        },
+                    ],
+                },
+            ],
+            [HookEventName.AfterTool]: [
+                {
+                    hooks: [
+                        {
+                            type: HookType.Command,
+                            command: './hooks/after-tool.sh',
+                            timeout: 10000,
+                        },
+                    ],
+                },
+            ],
+        };
+        const config = new Config({
+            ...baseParams,
+            hooks: mockHooks,
+        });
+        const retrievedHooks = config.getHooks();
+        expect(retrievedHooks).toEqual(mockHooks);
+        expect(retrievedHooks).toBe(mockHooks); // Should return the same reference
+    });
+    it('should return hooks with all supported event types', () => {
+        const allEventHooks = {
+            [HookEventName.BeforeAgent]: [
+                { hooks: [{ type: HookType.Command, command: 'test1' }] },
+            ],
+            [HookEventName.AfterAgent]: [
+                { hooks: [{ type: HookType.Command, command: 'test2' }] },
+            ],
+            [HookEventName.BeforeTool]: [
+                { hooks: [{ type: HookType.Command, command: 'test3' }] },
+            ],
+            [HookEventName.AfterTool]: [
+                { hooks: [{ type: HookType.Command, command: 'test4' }] },
+            ],
+            [HookEventName.BeforeModel]: [
+                { hooks: [{ type: HookType.Command, command: 'test5' }] },
+            ],
+            [HookEventName.AfterModel]: [
+                { hooks: [{ type: HookType.Command, command: 'test6' }] },
+            ],
+            [HookEventName.BeforeToolSelection]: [
+                { hooks: [{ type: HookType.Command, command: 'test7' }] },
+            ],
+            [HookEventName.Notification]: [
+                { hooks: [{ type: HookType.Command, command: 'test8' }] },
+            ],
+            [HookEventName.SessionStart]: [
+                { hooks: [{ type: HookType.Command, command: 'test9' }] },
+            ],
+            [HookEventName.SessionEnd]: [
+                { hooks: [{ type: HookType.Command, command: 'test10' }] },
+            ],
+            [HookEventName.PreCompress]: [
+                { hooks: [{ type: HookType.Command, command: 'test11' }] },
+            ],
+        };
+        const config = new Config({
+            ...baseParams,
+            hooks: allEventHooks,
+        });
+        const retrievedHooks = config.getHooks();
+        expect(retrievedHooks).toEqual(allEventHooks);
+        expect(Object.keys(retrievedHooks)).toHaveLength(11); // All hook event types
+    });
+    describe('setModel', () => {
+        it('should allow setting a pro (any) model and disable fallback mode', () => {
+            const config = new Config(baseParams);
+            config.setFallbackMode(true);
+            expect(config.isInFallbackMode()).toBe(true);
+            const proModel = 'gemini-2.5-pro';
+            config.setModel(proModel);
+            expect(config.getModel()).toBe(proModel);
+            expect(config.isInFallbackMode()).toBe(false);
+            expect(mockCoreEvents.emitModelChanged).toHaveBeenCalledWith(proModel);
+        });
+        it('should allow setting auto model from non-auto model and disable fallback mode', () => {
+            const config = new Config(baseParams);
+            config.setFallbackMode(true);
+            expect(config.isInFallbackMode()).toBe(true);
+            config.setModel('auto');
+            expect(config.getModel()).toBe('auto');
+            expect(config.isInFallbackMode()).toBe(false);
+            expect(mockCoreEvents.emitModelChanged).toHaveBeenCalledWith('auto');
+        });
+        it('should allow setting auto model from auto model if it is in the fallback mode', () => {
+            const config = new Config({
+                cwd: '/tmp',
+                targetDir: '/path/to/target',
+                debugMode: false,
+                sessionId: 'test-session-id',
+                model: 'auto',
+                usageStatisticsEnabled: false,
+            });
+            config.setFallbackMode(true);
+            expect(config.isInFallbackMode()).toBe(true);
+            config.setModel('auto');
+            expect(config.getModel()).toBe('auto');
+            expect(config.isInFallbackMode()).toBe(false);
+            expect(mockCoreEvents.emitModelChanged).toHaveBeenCalledWith('auto');
+        });
+    });
+});
+describe('Config getExperiments', () => {
+    const baseParams = {
+        cwd: '/tmp',
+        targetDir: '/path/to/target',
+        debugMode: false,
+        sessionId: 'test-session-id',
+        model: 'gemini-pro',
+        usageStatisticsEnabled: false,
+    };
+    it('should return undefined when no experiments are provided', () => {
+        const config = new Config(baseParams);
+        expect(config.getExperiments()).toBeUndefined();
+    });
+    it('should return empty object when empty experiments are provided', () => {
+        const configWithEmptyExps = new Config({
+            ...baseParams,
+            experiments: { flags: {}, experimentIds: [] },
+        });
+        expect(configWithEmptyExps.getExperiments()).toEqual({
+            flags: {},
+            experimentIds: [],
+        });
+    });
+    it('should return the experiments configuration when provided', () => {
+        const mockExps = {
+            flags: {
+                testFlag: { boolValue: true },
+            },
+            experimentIds: [],
+        };
+        const config = new Config({
+            ...baseParams,
+            experiments: mockExps,
+        });
+        const retrievedExps = config.getExperiments();
+        expect(retrievedExps).toEqual(mockExps);
+        expect(retrievedExps).toBe(mockExps); // Should return the same reference
+    });
+});
+describe('Config setExperiments logging', () => {
+    const baseParams = {
+        cwd: '/tmp',
+        targetDir: '/path/to/target',
+        debugMode: false,
+        sessionId: 'test-session-id',
+        model: 'gemini-pro',
+        usageStatisticsEnabled: false,
+    };
+    it('logs a sorted, non-truncated summary of experiments when they are set', () => {
+        const config = new Config(baseParams);
+        const debugSpy = vi
+            .spyOn(debugLogger, 'debug')
+            .mockImplementation(() => { });
+        const experiments = {
+            flags: {
+                ZetaFlag: {
+                    boolValue: true,
+                    stringValue: 'zeta',
+                    int32ListValue: { values: [1, 2] },
+                },
+                AlphaFlag: {
+                    boolValue: false,
+                    stringValue: 'alpha',
+                    stringListValue: { values: ['a', 'b', 'c'] },
+                },
+                MiddleFlag: {
+                    // Intentionally sparse to ensure undefined values are omitted
+                    floatValue: 0.42,
+                    int32ListValue: { values: [] },
+                },
+            },
+            experimentIds: [101, 99],
+        };
+        config.setExperiments(experiments);
+        const logCall = debugSpy.mock.calls.find(([message]) => message === 'Experiments loaded');
+        expect(logCall).toBeDefined();
+        const loggedSummary = logCall?.[1];
+        expect(typeof loggedSummary).toBe('string');
+        expect(loggedSummary).toContain('experimentIds');
+        expect(loggedSummary).toContain('101');
+        expect(loggedSummary).toContain('AlphaFlag');
+        expect(loggedSummary).toContain('ZetaFlag');
+        const alphaIndex = loggedSummary.indexOf('AlphaFlag');
+        const zetaIndex = loggedSummary.indexOf('ZetaFlag');
+        expect(alphaIndex).toBeGreaterThan(-1);
+        expect(zetaIndex).toBeGreaterThan(-1);
+        expect(alphaIndex).toBeLessThan(zetaIndex);
+        expect(loggedSummary).toContain('\n');
+        expect(loggedSummary).not.toContain('stringListLength: 0');
+        expect(loggedSummary).not.toContain('int32ListLength: 0');
+        debugSpy.mockRestore();
+    });
+});
 //# sourceMappingURL=config.test.js.map