| |
| |
| |
| |
| |
|
|
| import { |
| describe, |
| it, |
| expect, |
| vi, |
| beforeEach, |
| afterEach, |
| type Mock, |
| type MockInstance, |
| } from 'vitest'; |
| import * as fs from 'node:fs'; |
| import { loadSettings, SettingScope } from '../../config/settings.js'; |
| import { debugLogger } from '@google/gemini-cli-core'; |
| import { handleMigrateFromClaude } from './migrate.js'; |
|
|
| vi.mock('node:fs'); |
| vi.mock('../utils.js', () => ({ |
| exitCli: vi.fn(), |
| })); |
|
|
| vi.mock('../../config/settings.js', async () => { |
| const actual = await vi.importActual('../../config/settings.js'); |
| return { |
| ...actual, |
| loadSettings: vi.fn(), |
| }; |
| }); |
|
|
| const mockedLoadSettings = loadSettings as Mock; |
| const mockedFs = vi.mocked(fs); |
|
|
| describe('migrate command', () => { |
| let mockSetValue: Mock; |
| let debugLoggerLogSpy: MockInstance; |
| let debugLoggerErrorSpy: MockInstance; |
| let originalCwd: () => string; |
|
|
| beforeEach(() => { |
| vi.resetAllMocks(); |
|
|
| mockSetValue = vi.fn(); |
| debugLoggerLogSpy = vi |
| .spyOn(debugLogger, 'log') |
| .mockImplementation(() => {}); |
| debugLoggerErrorSpy = vi |
| .spyOn(debugLogger, 'error') |
| .mockImplementation(() => {}); |
|
|
| |
| originalCwd = process.cwd; |
| process.cwd = vi.fn(() => '/test/project'); |
|
|
| mockedLoadSettings.mockReturnValue({ |
| merged: { |
| hooks: {}, |
| }, |
| setValue: mockSetValue, |
| workspace: { path: '/test/project/.gemini' }, |
| }); |
| }); |
|
|
| afterEach(() => { |
| process.cwd = originalCwd; |
| vi.restoreAllMocks(); |
| }); |
|
|
| it('should log error when no Claude settings files exist', async () => { |
| mockedFs.existsSync.mockReturnValue(false); |
|
|
| await handleMigrateFromClaude(); |
|
|
| expect(debugLoggerErrorSpy).toHaveBeenCalledWith( |
| 'No Claude Code settings found in .claude directory. Expected settings.json or settings.local.json', |
| ); |
| expect(mockSetValue).not.toHaveBeenCalled(); |
| }); |
|
|
| it('should migrate hooks from settings.json when it exists', async () => { |
| const claudeSettings = { |
| hooks: { |
| PreToolUse: [ |
| { |
| matcher: 'Edit', |
| hooks: [ |
| { |
| type: 'command', |
| command: 'echo "Before Edit"', |
| timeout: 30, |
| }, |
| ], |
| }, |
| ], |
| }, |
| }; |
|
|
| mockedFs.existsSync.mockImplementation((path) => |
| path.toString().endsWith('settings.json'), |
| ); |
|
|
| mockedFs.readFileSync.mockReturnValue(JSON.stringify(claudeSettings)); |
|
|
| await handleMigrateFromClaude(); |
|
|
| expect(mockSetValue).toHaveBeenCalledWith( |
| SettingScope.Workspace, |
| 'hooks', |
| expect.objectContaining({ |
| BeforeTool: expect.arrayContaining([ |
| expect.objectContaining({ |
| matcher: 'replace', |
| hooks: expect.arrayContaining([ |
| expect.objectContaining({ |
| command: 'echo "Before Edit"', |
| type: 'command', |
| timeout: 30, |
| }), |
| ]), |
| }), |
| ]), |
| }), |
| ); |
|
|
| expect(debugLoggerLogSpy).toHaveBeenCalledWith( |
| expect.stringContaining('Found Claude Code settings'), |
| ); |
| expect(debugLoggerLogSpy).toHaveBeenCalledWith( |
| expect.stringContaining('Migrating 1 hook event'), |
| ); |
| expect(debugLoggerLogSpy).toHaveBeenCalledWith( |
| '✓ Hooks successfully migrated to .gemini/settings.json', |
| ); |
| }); |
|
|
| it('should prefer settings.local.json over settings.json', async () => { |
| const localSettings = { |
| hooks: { |
| SessionStart: [ |
| { |
| hooks: [ |
| { |
| type: 'command', |
| command: 'echo "Local session start"', |
| }, |
| ], |
| }, |
| ], |
| }, |
| }; |
|
|
| mockedFs.existsSync.mockReturnValue(true); |
| mockedFs.readFileSync.mockReturnValue(JSON.stringify(localSettings)); |
|
|
| await handleMigrateFromClaude(); |
|
|
| expect(mockedFs.readFileSync).toHaveBeenCalledWith( |
| expect.stringContaining('settings.local.json'), |
| 'utf-8', |
| ); |
| expect(mockSetValue).toHaveBeenCalledWith( |
| SettingScope.Workspace, |
| 'hooks', |
| expect.objectContaining({ |
| SessionStart: expect.any(Array), |
| }), |
| ); |
| }); |
|
|
| it('should migrate all supported event types', async () => { |
| const claudeSettings = { |
| hooks: { |
| PreToolUse: [{ hooks: [{ type: 'command', command: 'echo 1' }] }], |
| PostToolUse: [{ hooks: [{ type: 'command', command: 'echo 2' }] }], |
| UserPromptSubmit: [{ hooks: [{ type: 'command', command: 'echo 3' }] }], |
| Stop: [{ hooks: [{ type: 'command', command: 'echo 4' }] }], |
| SubAgentStop: [{ hooks: [{ type: 'command', command: 'echo 5' }] }], |
| SessionStart: [{ hooks: [{ type: 'command', command: 'echo 6' }] }], |
| SessionEnd: [{ hooks: [{ type: 'command', command: 'echo 7' }] }], |
| PreCompact: [{ hooks: [{ type: 'command', command: 'echo 8' }] }], |
| Notification: [{ hooks: [{ type: 'command', command: 'echo 9' }] }], |
| }, |
| }; |
|
|
| mockedFs.existsSync.mockReturnValue(true); |
| mockedFs.readFileSync.mockReturnValue(JSON.stringify(claudeSettings)); |
|
|
| await handleMigrateFromClaude(); |
|
|
| const migratedHooks = mockSetValue.mock.calls[0][2]; |
|
|
| expect(migratedHooks).toHaveProperty('BeforeTool'); |
| expect(migratedHooks).toHaveProperty('AfterTool'); |
| expect(migratedHooks).toHaveProperty('BeforeAgent'); |
| expect(migratedHooks).toHaveProperty('AfterAgent'); |
| expect(migratedHooks).toHaveProperty('SessionStart'); |
| expect(migratedHooks).toHaveProperty('SessionEnd'); |
| expect(migratedHooks).toHaveProperty('PreCompress'); |
| expect(migratedHooks).toHaveProperty('Notification'); |
| }); |
|
|
| it('should transform tool names in matchers', async () => { |
| const claudeSettings = { |
| hooks: { |
| PreToolUse: [ |
| { |
| matcher: 'Edit|Bash|Read|Write|Glob|Grep', |
| hooks: [{ type: 'command', command: 'echo "test"' }], |
| }, |
| ], |
| }, |
| }; |
|
|
| mockedFs.existsSync.mockReturnValue(true); |
| mockedFs.readFileSync.mockReturnValue(JSON.stringify(claudeSettings)); |
|
|
| await handleMigrateFromClaude(); |
|
|
| const migratedHooks = mockSetValue.mock.calls[0][2]; |
| expect(migratedHooks.BeforeTool[0].matcher).toBe( |
| 'replace|run_shell_command|read_file|write_file|glob|grep', |
| ); |
| }); |
|
|
| it('should replace $CLAUDE_PROJECT_DIR with $GEMINI_PROJECT_DIR', async () => { |
| const claudeSettings = { |
| hooks: { |
| PreToolUse: [ |
| { |
| hooks: [ |
| { |
| type: 'command', |
| command: 'cd $CLAUDE_PROJECT_DIR && ls', |
| }, |
| ], |
| }, |
| ], |
| }, |
| }; |
|
|
| mockedFs.existsSync.mockReturnValue(true); |
| mockedFs.readFileSync.mockReturnValue(JSON.stringify(claudeSettings)); |
|
|
| await handleMigrateFromClaude(); |
|
|
| const migratedHooks = mockSetValue.mock.calls[0][2]; |
| expect(migratedHooks.BeforeTool[0].hooks[0].command).toBe( |
| 'cd $GEMINI_PROJECT_DIR && ls', |
| ); |
| }); |
|
|
| it('should preserve sequential flag', async () => { |
| const claudeSettings = { |
| hooks: { |
| PreToolUse: [ |
| { |
| sequential: true, |
| hooks: [{ type: 'command', command: 'echo "test"' }], |
| }, |
| ], |
| }, |
| }; |
|
|
| mockedFs.existsSync.mockReturnValue(true); |
| mockedFs.readFileSync.mockReturnValue(JSON.stringify(claudeSettings)); |
|
|
| await handleMigrateFromClaude(); |
|
|
| const migratedHooks = mockSetValue.mock.calls[0][2]; |
| expect(migratedHooks.BeforeTool[0].sequential).toBe(true); |
| }); |
|
|
| it('should preserve timeout values', async () => { |
| const claudeSettings = { |
| hooks: { |
| PreToolUse: [ |
| { |
| hooks: [ |
| { |
| type: 'command', |
| command: 'echo "test"', |
| timeout: 60, |
| }, |
| ], |
| }, |
| ], |
| }, |
| }; |
|
|
| mockedFs.existsSync.mockReturnValue(true); |
| mockedFs.readFileSync.mockReturnValue(JSON.stringify(claudeSettings)); |
|
|
| await handleMigrateFromClaude(); |
|
|
| const migratedHooks = mockSetValue.mock.calls[0][2]; |
| expect(migratedHooks.BeforeTool[0].hooks[0].timeout).toBe(60); |
| }); |
|
|
| it('should merge with existing Gemini hooks', async () => { |
| const claudeSettings = { |
| hooks: { |
| PreToolUse: [ |
| { |
| hooks: [{ type: 'command', command: 'echo "claude"' }], |
| }, |
| ], |
| }, |
| }; |
|
|
| mockedLoadSettings.mockReturnValue({ |
| merged: { |
| hooks: { |
| AfterTool: [ |
| { |
| hooks: [{ type: 'command', command: 'echo "existing"' }], |
| }, |
| ], |
| }, |
| }, |
| setValue: mockSetValue, |
| workspace: { path: '/test/project/.gemini' }, |
| }); |
|
|
| mockedFs.existsSync.mockReturnValue(true); |
| mockedFs.readFileSync.mockReturnValue(JSON.stringify(claudeSettings)); |
|
|
| await handleMigrateFromClaude(); |
|
|
| const migratedHooks = mockSetValue.mock.calls[0][2]; |
| expect(migratedHooks).toHaveProperty('BeforeTool'); |
| expect(migratedHooks).toHaveProperty('AfterTool'); |
| expect(migratedHooks.AfterTool[0].hooks[0].command).toBe('echo "existing"'); |
| expect(migratedHooks.BeforeTool[0].hooks[0].command).toBe('echo "claude"'); |
| }); |
|
|
| it('should handle JSON with comments', async () => { |
| const claudeSettingsWithComments = `{ |
| // This is a comment |
| "hooks": { |
| /* Block comment */ |
| "PreToolUse": [ |
| { |
| "hooks": [ |
| { |
| "type": "command", |
| "command": "echo test" // Inline comment |
| } |
| ] |
| } |
| ] |
| } |
| }`; |
|
|
| mockedFs.existsSync.mockReturnValue(true); |
| mockedFs.readFileSync.mockReturnValue(claudeSettingsWithComments); |
|
|
| await handleMigrateFromClaude(); |
|
|
| expect(mockSetValue).toHaveBeenCalledWith( |
| SettingScope.Workspace, |
| 'hooks', |
| expect.objectContaining({ |
| BeforeTool: expect.any(Array), |
| }), |
| ); |
| }); |
|
|
| it('should handle malformed JSON gracefully', async () => { |
| mockedFs.existsSync.mockReturnValue(true); |
| mockedFs.readFileSync.mockReturnValue('{ invalid json }'); |
|
|
| await handleMigrateFromClaude(); |
|
|
| expect(debugLoggerErrorSpy).toHaveBeenCalledWith( |
| expect.stringContaining('Error reading'), |
| ); |
| expect(mockSetValue).not.toHaveBeenCalled(); |
| }); |
|
|
| it('should log info when no hooks are found in Claude settings', async () => { |
| const claudeSettings = { |
| someOtherSetting: 'value', |
| }; |
|
|
| mockedFs.existsSync.mockReturnValue(true); |
| mockedFs.readFileSync.mockReturnValue(JSON.stringify(claudeSettings)); |
|
|
| await handleMigrateFromClaude(); |
|
|
| expect(debugLoggerLogSpy).toHaveBeenCalledWith( |
| 'No hooks found in Claude Code settings to migrate.', |
| ); |
| expect(mockSetValue).not.toHaveBeenCalled(); |
| }); |
|
|
| it('should handle setValue errors gracefully', async () => { |
| const claudeSettings = { |
| hooks: { |
| PreToolUse: [ |
| { |
| hooks: [{ type: 'command', command: 'echo "test"' }], |
| }, |
| ], |
| }, |
| }; |
|
|
| mockedFs.existsSync.mockReturnValue(true); |
| mockedFs.readFileSync.mockReturnValue(JSON.stringify(claudeSettings)); |
| mockSetValue.mockImplementation(() => { |
| throw new Error('Failed to save'); |
| }); |
|
|
| await handleMigrateFromClaude(); |
|
|
| expect(debugLoggerErrorSpy).toHaveBeenCalledWith( |
| 'Error saving migrated hooks: Failed to save', |
| ); |
| }); |
|
|
| it('should handle hooks with matcher but no command', async () => { |
| const claudeSettings = { |
| hooks: { |
| PreToolUse: [ |
| { |
| matcher: 'Edit', |
| hooks: [ |
| { |
| type: 'command', |
| }, |
| ], |
| }, |
| ], |
| }, |
| }; |
|
|
| mockedFs.existsSync.mockReturnValue(true); |
| mockedFs.readFileSync.mockReturnValue(JSON.stringify(claudeSettings)); |
|
|
| await handleMigrateFromClaude(); |
|
|
| const migratedHooks = mockSetValue.mock.calls[0][2]; |
| expect(migratedHooks.BeforeTool[0].matcher).toBe('replace'); |
| expect(migratedHooks.BeforeTool[0].hooks[0].type).toBe('command'); |
| }); |
|
|
| it('should handle empty hooks array', async () => { |
| const claudeSettings = { |
| hooks: { |
| PreToolUse: [ |
| { |
| hooks: [], |
| }, |
| ], |
| }, |
| }; |
|
|
| mockedFs.existsSync.mockReturnValue(true); |
| mockedFs.readFileSync.mockReturnValue(JSON.stringify(claudeSettings)); |
|
|
| await handleMigrateFromClaude(); |
|
|
| const migratedHooks = mockSetValue.mock.calls[0][2]; |
| expect(migratedHooks.BeforeTool[0].hooks).toEqual([]); |
| }); |
|
|
| it('should handle non-array event config gracefully', async () => { |
| const claudeSettings = { |
| hooks: { |
| PreToolUse: 'not an array', |
| PostToolUse: [ |
| { |
| hooks: [{ type: 'command', command: 'echo "test"' }], |
| }, |
| ], |
| }, |
| }; |
|
|
| mockedFs.existsSync.mockReturnValue(true); |
| mockedFs.readFileSync.mockReturnValue(JSON.stringify(claudeSettings)); |
|
|
| await handleMigrateFromClaude(); |
|
|
| const migratedHooks = mockSetValue.mock.calls[0][2]; |
| expect(migratedHooks).not.toHaveProperty('BeforeTool'); |
| expect(migratedHooks).toHaveProperty('AfterTool'); |
| }); |
|
|
| it('should display migration instructions after successful migration', async () => { |
| const claudeSettings = { |
| hooks: { |
| PreToolUse: [ |
| { |
| hooks: [{ type: 'command', command: 'echo "test"' }], |
| }, |
| ], |
| }, |
| }; |
|
|
| mockedFs.existsSync.mockReturnValue(true); |
| mockedFs.readFileSync.mockReturnValue(JSON.stringify(claudeSettings)); |
|
|
| await handleMigrateFromClaude(); |
|
|
| expect(debugLoggerLogSpy).toHaveBeenCalledWith( |
| '✓ Hooks successfully migrated to .gemini/settings.json', |
| ); |
| expect(debugLoggerLogSpy).toHaveBeenCalledWith( |
| '\nMigration complete! Please review the migrated hooks in .gemini/settings.json', |
| ); |
| }); |
| }); |
|
|
