feat: External editor settings (#882)
This commit is contained in:
Leo
GitHub
parent
dd53e5c96a
commit
1ef68e0612
|
|
@ -6,6 +6,11 @@ The Gemini CLI supports several built-in commands to help you manage your sessio
|
|||
|
||||
Slash commands provide meta-level control over the CLI itself. They can typically be executed by typing the command and pressing `Enter`.
|
||||
|
||||
- **`/editor`**
|
||||
|
||||
- **Description:** Allows you to configure your external editor for actions such as modifying Gemini's proposed code change.
|
||||
- **Action:** Opens a dialog for selecting supported editors.
|
||||
|
||||
- **`/help`** (or **`/?`**)
|
||||
|
||||
- **Description:** Displays help information about the Gemini CLI, including available commands and their usage.
|
||||
|
|
|
|||
|
|
@ -39,6 +39,7 @@ export interface Settings {
|
|||
accessibility?: AccessibilitySettings;
|
||||
telemetry?: boolean;
|
||||
enableModifyWithExternalEditors?: boolean;
|
||||
preferredEditor?: string;
|
||||
|
||||
// Git-aware file filtering settings
|
||||
fileFiltering?: {
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@ import { useTerminalSize } from './hooks/useTerminalSize.js';
|
|||
import { useGeminiStream } from './hooks/useGeminiStream.js';
|
||||
import { useLoadingIndicator } from './hooks/useLoadingIndicator.js';
|
||||
import { useThemeCommand } from './hooks/useThemeCommand.js';
|
||||
import { useEditorSettings } from './hooks/useEditorSettings.js';
|
||||
import { useSlashCommandProcessor } from './hooks/slashCommandProcessor.js';
|
||||
import { useAutoAcceptIndicator } from './hooks/useAutoAcceptIndicator.js';
|
||||
import { useConsoleMessages } from './hooks/useConsoleMessages.js';
|
||||
|
|
@ -29,6 +30,7 @@ import { ShellModeIndicator } from './components/ShellModeIndicator.js';
|
|||
import { InputPrompt } from './components/InputPrompt.js';
|
||||
import { Footer } from './components/Footer.js';
|
||||
import { ThemeDialog } from './components/ThemeDialog.js';
|
||||
import { EditorSettingsDialog } from './components/EditorSettingsDialog.js';
|
||||
import { Colors } from './colors.js';
|
||||
import { Help } from './components/Help.js';
|
||||
import { loadHierarchicalGeminiMemory } from '../config/config.js';
|
||||
|
|
@ -45,6 +47,8 @@ import {
|
|||
type Config,
|
||||
getCurrentGeminiMdFilename,
|
||||
ApprovalMode,
|
||||
isEditorAvailable,
|
||||
EditorType,
|
||||
} from '@gemini-cli/core';
|
||||
import { useLogger } from './hooks/useLogger.js';
|
||||
import { StreamingContext } from './contexts/StreamingContext.js';
|
||||
|
|
@ -82,6 +86,7 @@ const App = ({ config, settings, startupWarnings = [] }: AppProps) => {
|
|||
const [debugMessage, setDebugMessage] = useState<string>('');
|
||||
const [showHelp, setShowHelp] = useState<boolean>(false);
|
||||
const [themeError, setThemeError] = useState<string | null>(null);
|
||||
const [editorError, setEditorError] = useState<string | null>(null);
|
||||
const [footerHeight, setFooterHeight] = useState<number>(0);
|
||||
const [corgiMode, setCorgiMode] = useState(false);
|
||||
const [shellModeActive, setShellModeActive] = useState(false);
|
||||
|
|
@ -106,6 +111,13 @@ const App = ({ config, settings, startupWarnings = [] }: AppProps) => {
|
|||
handleThemeHighlight,
|
||||
} = useThemeCommand(settings, setThemeError, addItem);
|
||||
|
||||
const {
|
||||
isEditorDialogOpen,
|
||||
openEditorDialog,
|
||||
handleEditorSelect,
|
||||
exitEditorDialog,
|
||||
} = useEditorSettings(settings, setEditorError, addItem);
|
||||
|
||||
const toggleCorgiMode = useCallback(() => {
|
||||
setCorgiMode((prev) => !prev);
|
||||
}, []);
|
||||
|
|
@ -162,6 +174,7 @@ const App = ({ config, settings, startupWarnings = [] }: AppProps) => {
|
|||
setShowHelp,
|
||||
setDebugMessage,
|
||||
openThemeDialog,
|
||||
openEditorDialog,
|
||||
performMemoryRefresh,
|
||||
toggleCorgiMode,
|
||||
showToolDescriptions,
|
||||
|
|
@ -227,6 +240,16 @@ const App = ({ config, settings, startupWarnings = [] }: AppProps) => {
|
|||
}
|
||||
}, [config]);
|
||||
|
||||
const getPreferredEditor = useCallback(() => {
|
||||
const editorType = settings.merged.preferredEditor;
|
||||
const isValidEditor = isEditorAvailable(editorType);
|
||||
if (!isValidEditor) {
|
||||
openEditorDialog();
|
||||
return;
|
||||
}
|
||||
return editorType as EditorType;
|
||||
}, [settings, openEditorDialog]);
|
||||
|
||||
const { streamingState, submitQuery, initError, pendingHistoryItems } =
|
||||
useGeminiStream(
|
||||
config.getGeminiClient(),
|
||||
|
|
@ -237,6 +260,7 @@ const App = ({ config, settings, startupWarnings = [] }: AppProps) => {
|
|||
setDebugMessage,
|
||||
handleSlashCommand,
|
||||
shellModeActive,
|
||||
getPreferredEditor,
|
||||
);
|
||||
const { elapsedTime, currentLoadingPhrase } =
|
||||
useLoadingIndicator(streamingState);
|
||||
|
|
@ -409,6 +433,7 @@ const App = ({ config, settings, startupWarnings = [] }: AppProps) => {
|
|||
item={{ ...item, id: 0 }}
|
||||
isPending={true}
|
||||
config={config}
|
||||
isFocused={!isEditorDialogOpen}
|
||||
/>
|
||||
))}
|
||||
</Box>
|
||||
|
|
@ -444,6 +469,19 @@ const App = ({ config, settings, startupWarnings = [] }: AppProps) => {
|
|||
settings={settings}
|
||||
/>
|
||||
</Box>
|
||||
) : isEditorDialogOpen ? (
|
||||
<Box flexDirection="column">
|
||||
{editorError && (
|
||||
<Box marginBottom={1}>
|
||||
<Text color={Colors.AccentRed}>{editorError}</Text>
|
||||
</Box>
|
||||
)}
|
||||
<EditorSettingsDialog
|
||||
onSelect={handleEditorSelect}
|
||||
settings={settings}
|
||||
onExit={exitEditorDialog}
|
||||
/>
|
||||
</Box>
|
||||
) : (
|
||||
<>
|
||||
<LoadingIndicator
|
||||
|
|
|
|||
|
|
@ -0,0 +1,168 @@
|
|||
/**
|
||||
* @license
|
||||
* Copyright 2025 Google LLC
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
import React, { useState } from 'react';
|
||||
import { Box, Text, useInput } from 'ink';
|
||||
import { Colors } from '../colors.js';
|
||||
import {
|
||||
EDITOR_DISPLAY_NAMES,
|
||||
editorSettingsManager,
|
||||
type EditorDisplay,
|
||||
} from '../editors/editorSettingsManager.js';
|
||||
import { RadioButtonSelect } from './shared/RadioButtonSelect.js';
|
||||
import { LoadedSettings, SettingScope } from '../../config/settings.js';
|
||||
import { EditorType, isEditorAvailable } from '@gemini-cli/core';
|
||||
|
||||
interface EditorDialogProps {
|
||||
onSelect: (editorType: EditorType | undefined, scope: SettingScope) => void;
|
||||
settings: LoadedSettings;
|
||||
onExit: () => void;
|
||||
}
|
||||
|
||||
export function EditorSettingsDialog({
|
||||
onSelect,
|
||||
settings,
|
||||
onExit,
|
||||
}: EditorDialogProps): React.JSX.Element {
|
||||
const [selectedScope, setSelectedScope] = useState<SettingScope>(
|
||||
SettingScope.User,
|
||||
);
|
||||
const [focusedSection, setFocusedSection] = useState<'editor' | 'scope'>(
|
||||
'editor',
|
||||
);
|
||||
useInput((_, key) => {
|
||||
if (key.tab) {
|
||||
setFocusedSection((prev) => (prev === 'editor' ? 'scope' : 'editor'));
|
||||
}
|
||||
if (key.escape) {
|
||||
onExit();
|
||||
}
|
||||
});
|
||||
|
||||
const editorItems: EditorDisplay[] =
|
||||
editorSettingsManager.getAvailableEditorDisplays();
|
||||
|
||||
const currentPreference =
|
||||
settings.forScope(selectedScope).settings.preferredEditor;
|
||||
let editorIndex = currentPreference
|
||||
? editorItems.findIndex(
|
||||
(item: EditorDisplay) => item.type === currentPreference,
|
||||
)
|
||||
: 0;
|
||||
if (editorIndex === -1) {
|
||||
console.error(`Editor is not supported: ${currentPreference}`);
|
||||
editorIndex = 0;
|
||||
}
|
||||
|
||||
const scopeItems = [
|
||||
{ label: 'User Settings', value: SettingScope.User },
|
||||
{ label: 'Workspace Settings', value: SettingScope.Workspace },
|
||||
];
|
||||
|
||||
const handleEditorSelect = (editorType: EditorType | 'not_set') => {
|
||||
if (editorType === 'not_set') {
|
||||
onSelect(undefined, selectedScope);
|
||||
return;
|
||||
}
|
||||
onSelect(editorType, selectedScope);
|
||||
};
|
||||
|
||||
const handleScopeSelect = (scope: SettingScope) => {
|
||||
setSelectedScope(scope);
|
||||
setFocusedSection('editor');
|
||||
};
|
||||
|
||||
let otherScopeModifiedMessage = '';
|
||||
const otherScope =
|
||||
selectedScope === SettingScope.User
|
||||
? SettingScope.Workspace
|
||||
: SettingScope.User;
|
||||
if (settings.forScope(otherScope).settings.preferredEditor !== undefined) {
|
||||
otherScopeModifiedMessage =
|
||||
settings.forScope(selectedScope).settings.preferredEditor !== undefined
|
||||
? `(Also modified in ${otherScope})`
|
||||
: `(Modified in ${otherScope})`;
|
||||
}
|
||||
|
||||
let mergedEditorName = 'None';
|
||||
if (
|
||||
settings.merged.preferredEditor &&
|
||||
isEditorAvailable(settings.merged.preferredEditor)
|
||||
) {
|
||||
mergedEditorName =
|
||||
EDITOR_DISPLAY_NAMES[settings.merged.preferredEditor as EditorType];
|
||||
}
|
||||
|
||||
return (
|
||||
<Box
|
||||
borderStyle="round"
|
||||
borderColor={Colors.Gray}
|
||||
flexDirection="row"
|
||||
padding={1}
|
||||
width="100%"
|
||||
>
|
||||
<Box flexDirection="column" width="45%" paddingRight={2}>
|
||||
<Text bold={focusedSection === 'editor'}>
|
||||
{focusedSection === 'editor' ? '> ' : ' '}Select Editor{' '}
|
||||
<Text color={Colors.Gray}>{otherScopeModifiedMessage}</Text>
|
||||
</Text>
|
||||
<RadioButtonSelect
|
||||
items={editorItems.map((item) => ({
|
||||
label: item.name,
|
||||
value: item.type,
|
||||
disabled: item.disabled,
|
||||
}))}
|
||||
initialIndex={editorIndex}
|
||||
onSelect={handleEditorSelect}
|
||||
isFocused={focusedSection === 'editor'}
|
||||
key={selectedScope}
|
||||
/>
|
||||
|
||||
<Box marginTop={1} flexDirection="column">
|
||||
<Text bold={focusedSection === 'scope'}>
|
||||
{focusedSection === 'scope' ? '> ' : ' '}Apply To
|
||||
</Text>
|
||||
<RadioButtonSelect
|
||||
items={scopeItems}
|
||||
initialIndex={0}
|
||||
onSelect={handleScopeSelect}
|
||||
isFocused={focusedSection === 'scope'}
|
||||
/>
|
||||
</Box>
|
||||
|
||||
<Box marginTop={1}>
|
||||
<Text color={Colors.Gray}>
|
||||
(Use Enter to select, Tab to change focus)
|
||||
</Text>
|
||||
</Box>
|
||||
</Box>
|
||||
|
||||
<Box flexDirection="column" width="55%" paddingLeft={2}>
|
||||
<Text bold>Editor Preference</Text>
|
||||
<Box flexDirection="column" gap={1} marginTop={1}>
|
||||
<Text color={Colors.Gray}>
|
||||
These editors are currently supported. Please note that some editors
|
||||
cannot be used in sandbox mode.
|
||||
</Text>
|
||||
<Text color={Colors.Gray}>
|
||||
Your preferred editor is:{' '}
|
||||
<Text
|
||||
color={
|
||||
mergedEditorName === 'None'
|
||||
? Colors.AccentRed
|
||||
: Colors.AccentCyan
|
||||
}
|
||||
bold
|
||||
>
|
||||
{mergedEditorName}
|
||||
</Text>
|
||||
.
|
||||
</Text>
|
||||
</Box>
|
||||
</Box>
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
|
@ -24,6 +24,7 @@ interface HistoryItemDisplayProps {
|
|||
availableTerminalHeight: number;
|
||||
isPending: boolean;
|
||||
config?: Config;
|
||||
isFocused?: boolean;
|
||||
}
|
||||
|
||||
export const HistoryItemDisplay: React.FC<HistoryItemDisplayProps> = ({
|
||||
|
|
@ -31,6 +32,7 @@ export const HistoryItemDisplay: React.FC<HistoryItemDisplayProps> = ({
|
|||
availableTerminalHeight,
|
||||
isPending,
|
||||
config,
|
||||
isFocused = true,
|
||||
}) => (
|
||||
<Box flexDirection="column" key={item.id}>
|
||||
{/* Render standard message types */}
|
||||
|
|
@ -76,6 +78,7 @@ export const HistoryItemDisplay: React.FC<HistoryItemDisplayProps> = ({
|
|||
groupId={item.id}
|
||||
availableTerminalHeight={availableTerminalHeight}
|
||||
config={config}
|
||||
isFocused={isFocused}
|
||||
/>
|
||||
)}
|
||||
</Box>
|
||||
|
|
|
|||
|
|
@ -13,7 +13,6 @@ import {
|
|||
ToolConfirmationOutcome,
|
||||
ToolExecuteConfirmationDetails,
|
||||
ToolMcpConfirmationDetails,
|
||||
checkHasEditor,
|
||||
Config,
|
||||
} from '@gemini-cli/core';
|
||||
import {
|
||||
|
|
@ -24,14 +23,16 @@ import {
|
|||
export interface ToolConfirmationMessageProps {
|
||||
confirmationDetails: ToolCallConfirmationDetails;
|
||||
config?: Config;
|
||||
isFocused?: boolean;
|
||||
}
|
||||
|
||||
export const ToolConfirmationMessage: React.FC<
|
||||
ToolConfirmationMessageProps
|
||||
> = ({ confirmationDetails, config }) => {
|
||||
> = ({ confirmationDetails, config, isFocused = true }) => {
|
||||
const { onConfirm } = confirmationDetails;
|
||||
|
||||
useInput((_, key) => {
|
||||
if (!isFocused) return;
|
||||
if (key.escape) {
|
||||
onConfirm(ToolConfirmationOutcome.Cancel);
|
||||
}
|
||||
|
|
@ -86,40 +87,12 @@ export const ToolConfirmationMessage: React.FC<
|
|||
},
|
||||
);
|
||||
|
||||
// Conditionally add editor options if editors are installed
|
||||
const notUsingSandbox = !process.env.SANDBOX;
|
||||
const externalEditorsEnabled =
|
||||
config?.getEnableModifyWithExternalEditors() ?? false;
|
||||
|
||||
if (checkHasEditor('vscode') && notUsingSandbox && externalEditorsEnabled) {
|
||||
if (externalEditorsEnabled) {
|
||||
options.push({
|
||||
label: 'Modify with VS Code',
|
||||
value: ToolConfirmationOutcome.ModifyVSCode,
|
||||
});
|
||||
}
|
||||
|
||||
if (
|
||||
checkHasEditor('windsurf') &&
|
||||
notUsingSandbox &&
|
||||
externalEditorsEnabled
|
||||
) {
|
||||
options.push({
|
||||
label: 'Modify with Windsurf',
|
||||
value: ToolConfirmationOutcome.ModifyWindsurf,
|
||||
});
|
||||
}
|
||||
|
||||
if (checkHasEditor('cursor') && notUsingSandbox && externalEditorsEnabled) {
|
||||
options.push({
|
||||
label: 'Modify with Cursor',
|
||||
value: ToolConfirmationOutcome.ModifyCursor,
|
||||
});
|
||||
}
|
||||
|
||||
if (checkHasEditor('vim') && externalEditorsEnabled) {
|
||||
options.push({
|
||||
label: 'Modify with vim',
|
||||
value: ToolConfirmationOutcome.ModifyVim,
|
||||
label: 'Modify with external editor',
|
||||
value: ToolConfirmationOutcome.ModifyWithEditor,
|
||||
});
|
||||
}
|
||||
|
||||
|
|
@ -192,7 +165,11 @@ export const ToolConfirmationMessage: React.FC<
|
|||
|
||||
{/* Select Input for Options */}
|
||||
<Box flexShrink={0}>
|
||||
<RadioButtonSelect items={options} onSelect={handleSelect} />
|
||||
<RadioButtonSelect
|
||||
items={options}
|
||||
onSelect={handleSelect}
|
||||
isFocused={isFocused}
|
||||
/>
|
||||
</Box>
|
||||
</Box>
|
||||
);
|
||||
|
|
|
|||
|
|
@ -17,6 +17,7 @@ interface ToolGroupMessageProps {
|
|||
toolCalls: IndividualToolCallDisplay[];
|
||||
availableTerminalHeight: number;
|
||||
config?: Config;
|
||||
isFocused?: boolean;
|
||||
}
|
||||
|
||||
// Main component renders the border and maps the tools using ToolMessage
|
||||
|
|
@ -24,6 +25,7 @@ export const ToolGroupMessage: React.FC<ToolGroupMessageProps> = ({
|
|||
toolCalls,
|
||||
availableTerminalHeight,
|
||||
config,
|
||||
isFocused = true,
|
||||
}) => {
|
||||
const hasPending = !toolCalls.every(
|
||||
(t) => t.status === ToolCallStatus.Success,
|
||||
|
|
@ -84,6 +86,7 @@ export const ToolGroupMessage: React.FC<ToolGroupMessageProps> = ({
|
|||
<ToolConfirmationMessage
|
||||
confirmationDetails={tool.confirmationDetails}
|
||||
config={config}
|
||||
isFocused={isFocused}
|
||||
/>
|
||||
)}
|
||||
</Box>
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@ import { Colors } from '../../colors.js';
|
|||
export interface RadioSelectItem<T> {
|
||||
label: string;
|
||||
value: T;
|
||||
disabled?: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -97,11 +98,14 @@ export function RadioButtonSelect<T>({
|
|||
const itemWithThemeProps = props as typeof props & {
|
||||
themeNameDisplay?: string;
|
||||
themeTypeDisplay?: string;
|
||||
disabled?: boolean;
|
||||
};
|
||||
|
||||
let textColor = Colors.Foreground;
|
||||
if (isSelected) {
|
||||
textColor = Colors.AccentGreen;
|
||||
} else if (itemWithThemeProps.disabled === true) {
|
||||
textColor = Colors.Gray;
|
||||
}
|
||||
|
||||
if (
|
||||
|
|
|
|||
|
|
@ -0,0 +1,60 @@
|
|||
/**
|
||||
* @license
|
||||
* Copyright 2025 Google LLC
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
import {
|
||||
allowEditorTypeInSandbox,
|
||||
checkHasEditorType,
|
||||
type EditorType,
|
||||
} from '@gemini-cli/core';
|
||||
|
||||
export interface EditorDisplay {
|
||||
name: string;
|
||||
type: EditorType | 'not_set';
|
||||
disabled: boolean;
|
||||
}
|
||||
|
||||
export const EDITOR_DISPLAY_NAMES: Record<EditorType, string> = {
|
||||
vscode: 'VS Code',
|
||||
windsurf: 'Windsurf',
|
||||
cursor: 'Cursor',
|
||||
vim: 'Vim',
|
||||
};
|
||||
|
||||
class EditorSettingsManager {
|
||||
private readonly availableEditors: EditorDisplay[];
|
||||
|
||||
constructor() {
|
||||
const editorTypes: EditorType[] = ['vscode', 'windsurf', 'cursor', 'vim'];
|
||||
this.availableEditors = [
|
||||
{
|
||||
name: 'None',
|
||||
type: 'not_set',
|
||||
disabled: false,
|
||||
},
|
||||
...editorTypes.map((type) => {
|
||||
const hasEditor = checkHasEditorType(type);
|
||||
const isAllowedInSandbox = allowEditorTypeInSandbox(type);
|
||||
|
||||
let labelSuffix = !isAllowedInSandbox
|
||||
? ' (Not available in sandbox)'
|
||||
: '';
|
||||
labelSuffix = !hasEditor ? ' (Not installed)' : labelSuffix;
|
||||
|
||||
return {
|
||||
name: EDITOR_DISPLAY_NAMES[type] + labelSuffix,
|
||||
type,
|
||||
disabled: !hasEditor || !isAllowedInSandbox,
|
||||
};
|
||||
}),
|
||||
];
|
||||
}
|
||||
|
||||
getAvailableEditorDisplays(): EditorDisplay[] {
|
||||
return this.availableEditors;
|
||||
}
|
||||
}
|
||||
|
||||
export const editorSettingsManager = new EditorSettingsManager();
|
||||
|
|
@ -97,6 +97,7 @@ describe('useSlashCommandProcessor', () => {
|
|||
let mockSetShowHelp: ReturnType<typeof vi.fn>;
|
||||
let mockOnDebugMessage: ReturnType<typeof vi.fn>;
|
||||
let mockOpenThemeDialog: ReturnType<typeof vi.fn>;
|
||||
let mockOpenEditorDialog: ReturnType<typeof vi.fn>;
|
||||
let mockPerformMemoryRefresh: ReturnType<typeof vi.fn>;
|
||||
let mockSetQuittingMessages: ReturnType<typeof vi.fn>;
|
||||
let mockConfig: Config;
|
||||
|
|
@ -111,6 +112,7 @@ describe('useSlashCommandProcessor', () => {
|
|||
mockSetShowHelp = vi.fn();
|
||||
mockOnDebugMessage = vi.fn();
|
||||
mockOpenThemeDialog = vi.fn();
|
||||
mockOpenEditorDialog = vi.fn();
|
||||
mockPerformMemoryRefresh = vi.fn().mockResolvedValue(undefined);
|
||||
mockSetQuittingMessages = vi.fn();
|
||||
mockConfig = {
|
||||
|
|
@ -155,6 +157,7 @@ describe('useSlashCommandProcessor', () => {
|
|||
mockSetShowHelp,
|
||||
mockOnDebugMessage,
|
||||
mockOpenThemeDialog,
|
||||
mockOpenEditorDialog,
|
||||
mockPerformMemoryRefresh,
|
||||
mockCorgiMode,
|
||||
showToolDescriptions,
|
||||
|
|
@ -322,6 +325,16 @@ describe('useSlashCommandProcessor', () => {
|
|||
expect(mockSetShowHelp).toHaveBeenCalledWith(true);
|
||||
expect(commandResult).toBe(true);
|
||||
});
|
||||
|
||||
it('/editor should open editor dialog and return true', async () => {
|
||||
const { handleSlashCommand } = getProcessor();
|
||||
let commandResult: SlashCommandActionReturn | boolean = false;
|
||||
await act(async () => {
|
||||
commandResult = await handleSlashCommand('/editor');
|
||||
});
|
||||
expect(mockOpenEditorDialog).toHaveBeenCalled();
|
||||
expect(commandResult).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('/bug command', () => {
|
||||
|
|
|
|||
|
|
@ -66,6 +66,7 @@ export const useSlashCommandProcessor = (
|
|||
setShowHelp: React.Dispatch<React.SetStateAction<boolean>>,
|
||||
onDebugMessage: (message: string) => void,
|
||||
openThemeDialog: () => void,
|
||||
openEditorDialog: () => void,
|
||||
performMemoryRefresh: () => Promise<void>,
|
||||
toggleCorgiMode: () => void,
|
||||
showToolDescriptions: boolean = false,
|
||||
|
|
@ -181,6 +182,13 @@ export const useSlashCommandProcessor = (
|
|||
openThemeDialog();
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'editor',
|
||||
description: 'open the editor',
|
||||
action: (_mainCommand, _subCommand, _args) => {
|
||||
openEditorDialog();
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'stats',
|
||||
altName: 'usage',
|
||||
|
|
@ -745,6 +753,7 @@ Add any other context about the problem here.
|
|||
setShowHelp,
|
||||
refreshStatic,
|
||||
openThemeDialog,
|
||||
openEditorDialog,
|
||||
clearItems,
|
||||
performMemoryRefresh,
|
||||
showMemoryAction,
|
||||
|
|
|
|||
|
|
@ -0,0 +1,283 @@
|
|||
/**
|
||||
* @license
|
||||
* Copyright 2025 Google LLC
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
import {
|
||||
afterEach,
|
||||
beforeEach,
|
||||
describe,
|
||||
expect,
|
||||
it,
|
||||
vi,
|
||||
type MockedFunction,
|
||||
} from 'vitest';
|
||||
import { act } from 'react';
|
||||
import { renderHook } from '@testing-library/react';
|
||||
import { useEditorSettings } from './useEditorSettings.js';
|
||||
import { LoadedSettings, SettingScope } from '../../config/settings.js';
|
||||
import { MessageType, type HistoryItem } from '../types.js';
|
||||
import {
|
||||
type EditorType,
|
||||
checkHasEditorType,
|
||||
allowEditorTypeInSandbox,
|
||||
} from '@gemini-cli/core';
|
||||
|
||||
vi.mock('@gemini-cli/core', async () => {
|
||||
const actual = await vi.importActual('@gemini-cli/core');
|
||||
return {
|
||||
...actual,
|
||||
checkHasEditorType: vi.fn(() => true),
|
||||
allowEditorTypeInSandbox: vi.fn(() => true),
|
||||
};
|
||||
});
|
||||
|
||||
const mockCheckHasEditorType = vi.mocked(checkHasEditorType);
|
||||
const mockAllowEditorTypeInSandbox = vi.mocked(allowEditorTypeInSandbox);
|
||||
|
||||
describe('useEditorSettings', () => {
|
||||
let mockLoadedSettings: LoadedSettings;
|
||||
let mockSetEditorError: MockedFunction<(error: string | null) => void>;
|
||||
let mockAddItem: MockedFunction<
|
||||
(item: Omit<HistoryItem, 'id'>, timestamp: number) => void
|
||||
>;
|
||||
|
||||
beforeEach(() => {
|
||||
vi.resetAllMocks();
|
||||
|
||||
mockLoadedSettings = {
|
||||
setValue: vi.fn(),
|
||||
} as unknown as LoadedSettings;
|
||||
|
||||
mockSetEditorError = vi.fn();
|
||||
mockAddItem = vi.fn();
|
||||
|
||||
// Reset mock implementations to default
|
||||
mockCheckHasEditorType.mockReturnValue(true);
|
||||
mockAllowEditorTypeInSandbox.mockReturnValue(true);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
vi.restoreAllMocks();
|
||||
});
|
||||
|
||||
it('should initialize with dialog closed', () => {
|
||||
const { result } = renderHook(() =>
|
||||
useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
|
||||
);
|
||||
|
||||
expect(result.current.isEditorDialogOpen).toBe(false);
|
||||
});
|
||||
|
||||
it('should open editor dialog when openEditorDialog is called', () => {
|
||||
const { result } = renderHook(() =>
|
||||
useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
|
||||
);
|
||||
|
||||
act(() => {
|
||||
result.current.openEditorDialog();
|
||||
});
|
||||
|
||||
expect(result.current.isEditorDialogOpen).toBe(true);
|
||||
});
|
||||
|
||||
it('should close editor dialog when exitEditorDialog is called', () => {
|
||||
const { result } = renderHook(() =>
|
||||
useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
|
||||
);
|
||||
act(() => {
|
||||
result.current.openEditorDialog();
|
||||
result.current.exitEditorDialog();
|
||||
});
|
||||
expect(result.current.isEditorDialogOpen).toBe(false);
|
||||
});
|
||||
|
||||
it('should handle editor selection successfully', () => {
|
||||
const { result } = renderHook(() =>
|
||||
useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
|
||||
);
|
||||
|
||||
const editorType: EditorType = 'vscode';
|
||||
const scope = SettingScope.User;
|
||||
|
||||
act(() => {
|
||||
result.current.openEditorDialog();
|
||||
result.current.handleEditorSelect(editorType, scope);
|
||||
});
|
||||
|
||||
expect(mockLoadedSettings.setValue).toHaveBeenCalledWith(
|
||||
scope,
|
||||
'preferredEditor',
|
||||
editorType,
|
||||
);
|
||||
|
||||
expect(mockAddItem).toHaveBeenCalledWith(
|
||||
{
|
||||
type: MessageType.INFO,
|
||||
text: 'Editor preference set to "vscode" in User settings.',
|
||||
},
|
||||
expect.any(Number),
|
||||
);
|
||||
|
||||
expect(mockSetEditorError).toHaveBeenCalledWith(null);
|
||||
expect(result.current.isEditorDialogOpen).toBe(false);
|
||||
});
|
||||
|
||||
it('should handle clearing editor preference (undefined editor)', () => {
|
||||
const { result } = renderHook(() =>
|
||||
useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
|
||||
);
|
||||
|
||||
const scope = SettingScope.Workspace;
|
||||
|
||||
act(() => {
|
||||
result.current.openEditorDialog();
|
||||
result.current.handleEditorSelect(undefined, scope);
|
||||
});
|
||||
|
||||
expect(mockLoadedSettings.setValue).toHaveBeenCalledWith(
|
||||
scope,
|
||||
'preferredEditor',
|
||||
undefined,
|
||||
);
|
||||
|
||||
expect(mockAddItem).toHaveBeenCalledWith(
|
||||
{
|
||||
type: MessageType.INFO,
|
||||
text: 'Editor preference cleared in Workspace settings.',
|
||||
},
|
||||
expect.any(Number),
|
||||
);
|
||||
|
||||
expect(mockSetEditorError).toHaveBeenCalledWith(null);
|
||||
expect(result.current.isEditorDialogOpen).toBe(false);
|
||||
});
|
||||
|
||||
it('should handle different editor types', () => {
|
||||
const { result } = renderHook(() =>
|
||||
useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
|
||||
);
|
||||
|
||||
const editorTypes: EditorType[] = ['cursor', 'windsurf', 'vim'];
|
||||
const scope = SettingScope.User;
|
||||
|
||||
editorTypes.forEach((editorType) => {
|
||||
act(() => {
|
||||
result.current.handleEditorSelect(editorType, scope);
|
||||
});
|
||||
|
||||
expect(mockLoadedSettings.setValue).toHaveBeenCalledWith(
|
||||
scope,
|
||||
'preferredEditor',
|
||||
editorType,
|
||||
);
|
||||
|
||||
expect(mockAddItem).toHaveBeenCalledWith(
|
||||
{
|
||||
type: MessageType.INFO,
|
||||
text: `Editor preference set to "${editorType}" in User settings.`,
|
||||
},
|
||||
expect.any(Number),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
it('should handle different setting scopes', () => {
|
||||
const { result } = renderHook(() =>
|
||||
useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
|
||||
);
|
||||
|
||||
const editorType: EditorType = 'vscode';
|
||||
const scopes = [SettingScope.User, SettingScope.Workspace];
|
||||
|
||||
scopes.forEach((scope) => {
|
||||
act(() => {
|
||||
result.current.handleEditorSelect(editorType, scope);
|
||||
});
|
||||
|
||||
expect(mockLoadedSettings.setValue).toHaveBeenCalledWith(
|
||||
scope,
|
||||
'preferredEditor',
|
||||
editorType,
|
||||
);
|
||||
|
||||
expect(mockAddItem).toHaveBeenCalledWith(
|
||||
{
|
||||
type: MessageType.INFO,
|
||||
text: `Editor preference set to "vscode" in ${scope} settings.`,
|
||||
},
|
||||
expect.any(Number),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
it('should not set preference for unavailable editors', () => {
|
||||
const { result } = renderHook(() =>
|
||||
useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
|
||||
);
|
||||
|
||||
mockCheckHasEditorType.mockReturnValue(false);
|
||||
|
||||
const editorType: EditorType = 'vscode';
|
||||
const scope = SettingScope.User;
|
||||
|
||||
act(() => {
|
||||
result.current.openEditorDialog();
|
||||
result.current.handleEditorSelect(editorType, scope);
|
||||
});
|
||||
|
||||
expect(mockLoadedSettings.setValue).not.toHaveBeenCalled();
|
||||
expect(mockAddItem).not.toHaveBeenCalled();
|
||||
expect(result.current.isEditorDialogOpen).toBe(true);
|
||||
});
|
||||
|
||||
it('should not set preference for editors not allowed in sandbox', () => {
|
||||
const { result } = renderHook(() =>
|
||||
useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
|
||||
);
|
||||
|
||||
mockAllowEditorTypeInSandbox.mockReturnValue(false);
|
||||
|
||||
const editorType: EditorType = 'vscode';
|
||||
const scope = SettingScope.User;
|
||||
|
||||
act(() => {
|
||||
result.current.openEditorDialog();
|
||||
result.current.handleEditorSelect(editorType, scope);
|
||||
});
|
||||
|
||||
expect(mockLoadedSettings.setValue).not.toHaveBeenCalled();
|
||||
expect(mockAddItem).not.toHaveBeenCalled();
|
||||
expect(result.current.isEditorDialogOpen).toBe(true);
|
||||
});
|
||||
|
||||
it('should handle errors during editor selection', () => {
|
||||
const { result } = renderHook(() =>
|
||||
useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
|
||||
);
|
||||
|
||||
const errorMessage = 'Failed to save settings';
|
||||
(
|
||||
mockLoadedSettings.setValue as MockedFunction<
|
||||
typeof mockLoadedSettings.setValue
|
||||
>
|
||||
).mockImplementation(() => {
|
||||
throw new Error(errorMessage);
|
||||
});
|
||||
|
||||
const editorType: EditorType = 'vscode';
|
||||
const scope = SettingScope.User;
|
||||
|
||||
act(() => {
|
||||
result.current.openEditorDialog();
|
||||
result.current.handleEditorSelect(editorType, scope);
|
||||
});
|
||||
|
||||
expect(mockSetEditorError).toHaveBeenCalledWith(
|
||||
`Failed to set editor preference: Error: ${errorMessage}`,
|
||||
);
|
||||
expect(mockAddItem).not.toHaveBeenCalled();
|
||||
expect(result.current.isEditorDialogOpen).toBe(true);
|
||||
});
|
||||
});
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
/**
|
||||
* @license
|
||||
* Copyright 2025 Google LLC
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
import { useState, useCallback } from 'react';
|
||||
import { LoadedSettings, SettingScope } from '../../config/settings.js';
|
||||
import { type HistoryItem, MessageType } from '../types.js';
|
||||
import {
|
||||
allowEditorTypeInSandbox,
|
||||
checkHasEditorType,
|
||||
EditorType,
|
||||
} from '@gemini-cli/core';
|
||||
|
||||
interface UseEditorSettingsReturn {
|
||||
isEditorDialogOpen: boolean;
|
||||
openEditorDialog: () => void;
|
||||
handleEditorSelect: (
|
||||
editorType: EditorType | undefined,
|
||||
scope: SettingScope,
|
||||
) => void;
|
||||
exitEditorDialog: () => void;
|
||||
}
|
||||
|
||||
export const useEditorSettings = (
|
||||
loadedSettings: LoadedSettings,
|
||||
setEditorError: (error: string | null) => void,
|
||||
addItem: (item: Omit<HistoryItem, 'id'>, timestamp: number) => void,
|
||||
): UseEditorSettingsReturn => {
|
||||
const [isEditorDialogOpen, setIsEditorDialogOpen] = useState(false);
|
||||
|
||||
const openEditorDialog = useCallback(() => {
|
||||
setIsEditorDialogOpen(true);
|
||||
}, []);
|
||||
|
||||
const handleEditorSelect = useCallback(
|
||||
(editorType: EditorType | undefined, scope: SettingScope) => {
|
||||
if (
|
||||
editorType &&
|
||||
(!checkHasEditorType(editorType) ||
|
||||
!allowEditorTypeInSandbox(editorType))
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
loadedSettings.setValue(scope, 'preferredEditor', editorType);
|
||||
addItem(
|
||||
{
|
||||
type: MessageType.INFO,
|
||||
text: `Editor preference ${editorType ? `set to "${editorType}"` : 'cleared'} in ${scope} settings.`,
|
||||
},
|
||||
Date.now(),
|
||||
);
|
||||
setEditorError(null);
|
||||
setIsEditorDialogOpen(false);
|
||||
} catch (error) {
|
||||
setEditorError(`Failed to set editor preference: ${error}`);
|
||||
}
|
||||
},
|
||||
[loadedSettings, setEditorError, addItem],
|
||||
);
|
||||
|
||||
const exitEditorDialog = useCallback(() => {
|
||||
setIsEditorDialogOpen(false);
|
||||
}, []);
|
||||
|
||||
return {
|
||||
isEditorDialogOpen,
|
||||
openEditorDialog,
|
||||
handleEditorSelect,
|
||||
exitEditorDialog,
|
||||
};
|
||||
};
|
||||
|
|
@ -15,11 +15,12 @@ import {
|
|||
TrackedExecutingToolCall,
|
||||
TrackedCancelledToolCall,
|
||||
} from './useReactToolScheduler.js';
|
||||
import { Config } from '@gemini-cli/core';
|
||||
import { Config, EditorType } from '@gemini-cli/core';
|
||||
import { Part, PartListUnion } from '@google/genai';
|
||||
import { UseHistoryManagerReturn } from './useHistoryManager.js';
|
||||
import { HistoryItem } from '../types.js';
|
||||
import { Dispatch, SetStateAction } from 'react';
|
||||
import { LoadedSettings } from '../../config/settings.js';
|
||||
|
||||
// --- MOCKS ---
|
||||
const mockSendMessageStream = vi
|
||||
|
|
@ -309,6 +310,15 @@ describe('useGeminiStream', () => {
|
|||
.mockReturnValue((async function* () {})());
|
||||
});
|
||||
|
||||
const mockLoadedSettings: LoadedSettings = {
|
||||
merged: { preferredEditor: 'vscode' },
|
||||
user: { path: '/user/settings.json', settings: {} },
|
||||
workspace: { path: '/workspace/.gemini/settings.json', settings: {} },
|
||||
errors: [],
|
||||
forScope: vi.fn(),
|
||||
setValue: vi.fn(),
|
||||
} as unknown as LoadedSettings;
|
||||
|
||||
const renderTestHook = (
|
||||
initialToolCalls: TrackedToolCall[] = [],
|
||||
geminiClient?: any,
|
||||
|
|
@ -337,6 +347,7 @@ describe('useGeminiStream', () => {
|
|||
| boolean
|
||||
>;
|
||||
shellModeActive: boolean;
|
||||
loadedSettings: LoadedSettings;
|
||||
}) =>
|
||||
useGeminiStream(
|
||||
props.client,
|
||||
|
|
@ -347,6 +358,7 @@ describe('useGeminiStream', () => {
|
|||
props.onDebugMessage,
|
||||
props.handleSlashCommand,
|
||||
props.shellModeActive,
|
||||
() => 'vscode' as EditorType,
|
||||
),
|
||||
{
|
||||
initialProps: {
|
||||
|
|
@ -363,6 +375,7 @@ describe('useGeminiStream', () => {
|
|||
| boolean
|
||||
>,
|
||||
shellModeActive: false,
|
||||
loadedSettings: mockLoadedSettings,
|
||||
},
|
||||
},
|
||||
);
|
||||
|
|
@ -486,6 +499,7 @@ describe('useGeminiStream', () => {
|
|||
handleSlashCommand:
|
||||
mockHandleSlashCommand as unknown as typeof mockHandleSlashCommand,
|
||||
shellModeActive: false,
|
||||
loadedSettings: mockLoadedSettings,
|
||||
});
|
||||
});
|
||||
|
||||
|
|
@ -541,6 +555,7 @@ describe('useGeminiStream', () => {
|
|||
handleSlashCommand:
|
||||
mockHandleSlashCommand as unknown as typeof mockHandleSlashCommand,
|
||||
shellModeActive: false,
|
||||
loadedSettings: mockLoadedSettings,
|
||||
});
|
||||
});
|
||||
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@ import {
|
|||
ToolCallRequestInfo,
|
||||
logUserPrompt,
|
||||
GitService,
|
||||
EditorType,
|
||||
} from '@gemini-cli/core';
|
||||
import { type Part, type PartListUnion } from '@google/genai';
|
||||
import {
|
||||
|
|
@ -83,6 +84,7 @@ export const useGeminiStream = (
|
|||
import('./slashCommandProcessor.js').SlashCommandActionReturn | boolean
|
||||
>,
|
||||
shellModeActive: boolean,
|
||||
getPreferredEditor: () => EditorType | undefined,
|
||||
) => {
|
||||
const [initError, setInitError] = useState<string | null>(null);
|
||||
const abortControllerRef = useRef<AbortController | null>(null);
|
||||
|
|
@ -115,6 +117,7 @@ export const useGeminiStream = (
|
|||
},
|
||||
config,
|
||||
setPendingHistoryItem,
|
||||
getPreferredEditor,
|
||||
);
|
||||
|
||||
const pendingToolCallGroupDisplay = useMemo(
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ import {
|
|||
ToolCall,
|
||||
Status as CoreStatus,
|
||||
logToolCall,
|
||||
EditorType,
|
||||
} from '@gemini-cli/core';
|
||||
import { useCallback, useState, useMemo } from 'react';
|
||||
import {
|
||||
|
|
@ -69,6 +70,7 @@ export function useReactToolScheduler(
|
|||
setPendingHistoryItem: React.Dispatch<
|
||||
React.SetStateAction<HistoryItemWithoutId | null>
|
||||
>,
|
||||
getPreferredEditor: () => EditorType | undefined,
|
||||
): [TrackedToolCall[], ScheduleFn, MarkToolsAsSubmittedFn] {
|
||||
const [toolCallsForDisplay, setToolCallsForDisplay] = useState<
|
||||
TrackedToolCall[]
|
||||
|
|
@ -162,12 +164,14 @@ export function useReactToolScheduler(
|
|||
onAllToolCallsComplete: allToolCallsCompleteHandler,
|
||||
onToolCallsUpdate: toolCallsUpdateHandler,
|
||||
approvalMode: config.getApprovalMode(),
|
||||
getPreferredEditor,
|
||||
}),
|
||||
[
|
||||
config,
|
||||
outputUpdateHandler,
|
||||
allToolCallsCompleteHandler,
|
||||
toolCallsUpdateHandler,
|
||||
getPreferredEditor,
|
||||
],
|
||||
);
|
||||
|
||||
|
|
|
|||
|
|
@ -62,7 +62,6 @@ describe('CoreToolScheduler', () => {
|
|||
getFunctionDeclarations: () => [],
|
||||
tools: new Map(),
|
||||
discovery: {} as any,
|
||||
config: {} as any,
|
||||
registerTool: () => {},
|
||||
getToolByName: () => mockTool,
|
||||
getToolByDisplayName: () => mockTool,
|
||||
|
|
@ -79,6 +78,7 @@ describe('CoreToolScheduler', () => {
|
|||
toolRegistry: Promise.resolve(toolRegistry as any),
|
||||
onAllToolCallsComplete,
|
||||
onToolCallsUpdate,
|
||||
getPreferredEditor: () => 'vscode',
|
||||
});
|
||||
|
||||
const abortController = new AbortController();
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@ import {
|
|||
ApprovalMode,
|
||||
EditTool,
|
||||
EditToolParams,
|
||||
EditorType,
|
||||
} from '../index.js';
|
||||
import { Part, PartListUnion } from '@google/genai';
|
||||
import { getResponseTextFromParts } from '../utils/generateContentResponseUtilities.js';
|
||||
|
|
@ -203,6 +204,7 @@ interface CoreToolSchedulerOptions {
|
|||
onAllToolCallsComplete?: AllToolCallsCompleteHandler;
|
||||
onToolCallsUpdate?: ToolCallsUpdateHandler;
|
||||
approvalMode?: ApprovalMode;
|
||||
getPreferredEditor: () => EditorType | undefined;
|
||||
}
|
||||
|
||||
export class CoreToolScheduler {
|
||||
|
|
@ -212,6 +214,7 @@ export class CoreToolScheduler {
|
|||
private onAllToolCallsComplete?: AllToolCallsCompleteHandler;
|
||||
private onToolCallsUpdate?: ToolCallsUpdateHandler;
|
||||
private approvalMode: ApprovalMode;
|
||||
private getPreferredEditor: () => EditorType | undefined;
|
||||
|
||||
constructor(options: CoreToolSchedulerOptions) {
|
||||
this.toolRegistry = options.toolRegistry;
|
||||
|
|
@ -219,6 +222,7 @@ export class CoreToolScheduler {
|
|||
this.onAllToolCallsComplete = options.onAllToolCallsComplete;
|
||||
this.onToolCallsUpdate = options.onToolCallsUpdate;
|
||||
this.approvalMode = options.approvalMode ?? ApprovalMode.DEFAULT;
|
||||
this.getPreferredEditor = options.getPreferredEditor;
|
||||
}
|
||||
|
||||
private setStatusInternal(
|
||||
|
|
@ -484,15 +488,15 @@ export class CoreToolScheduler {
|
|||
'cancelled',
|
||||
'User did not allow tool call',
|
||||
);
|
||||
} else if (
|
||||
outcome === ToolConfirmationOutcome.ModifyVSCode ||
|
||||
outcome === ToolConfirmationOutcome.ModifyWindsurf ||
|
||||
outcome === ToolConfirmationOutcome.ModifyCursor ||
|
||||
outcome === ToolConfirmationOutcome.ModifyVim
|
||||
) {
|
||||
} else if (outcome === ToolConfirmationOutcome.ModifyWithEditor) {
|
||||
const waitingToolCall = toolCall as WaitingToolCall;
|
||||
if (waitingToolCall?.confirmationDetails?.type === 'edit') {
|
||||
const editTool = waitingToolCall.tool as EditTool;
|
||||
const editorType = this.getPreferredEditor();
|
||||
if (!editorType) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.setStatusInternal(callId, 'awaiting_approval', {
|
||||
...waitingToolCall.confirmationDetails,
|
||||
isModifying: true,
|
||||
|
|
@ -501,7 +505,7 @@ export class CoreToolScheduler {
|
|||
const modifyResults = await editTool.onModify(
|
||||
waitingToolCall.request.args as unknown as EditToolParams,
|
||||
signal,
|
||||
outcome,
|
||||
editorType,
|
||||
);
|
||||
|
||||
if (modifyResults) {
|
||||
|
|
|
|||
|
|
@ -32,7 +32,6 @@ import fs from 'fs';
|
|||
import os from 'os';
|
||||
import { ApprovalMode, Config } from '../config/config.js';
|
||||
import { Content, Part, SchemaUnion } from '@google/genai';
|
||||
import { ToolConfirmationOutcome } from './tools.js';
|
||||
|
||||
describe('EditTool', () => {
|
||||
let tool: EditTool;
|
||||
|
|
@ -634,7 +633,7 @@ describe('EditTool', () => {
|
|||
const result = await tool.onModify(
|
||||
params,
|
||||
new AbortController().signal,
|
||||
ToolConfirmationOutcome.ModifyVSCode,
|
||||
'vscode',
|
||||
);
|
||||
|
||||
expect(mockOpenDiff).toHaveBeenCalledTimes(1);
|
||||
|
|
@ -678,7 +677,7 @@ describe('EditTool', () => {
|
|||
const result = await tool.onModify(
|
||||
params,
|
||||
new AbortController().signal,
|
||||
ToolConfirmationOutcome.ModifyVSCode,
|
||||
'vscode',
|
||||
);
|
||||
|
||||
expect(mockOpenDiff).toHaveBeenCalledTimes(1);
|
||||
|
|
@ -711,7 +710,7 @@ describe('EditTool', () => {
|
|||
const result1 = await tool.onModify(
|
||||
params,
|
||||
new AbortController().signal,
|
||||
ToolConfirmationOutcome.ModifyVSCode,
|
||||
'vscode',
|
||||
);
|
||||
const firstCall = mockOpenDiff.mock.calls[0];
|
||||
const firstOldPath = firstCall[0];
|
||||
|
|
@ -727,7 +726,7 @@ describe('EditTool', () => {
|
|||
const result2 = await tool.onModify(
|
||||
params,
|
||||
new AbortController().signal,
|
||||
ToolConfirmationOutcome.ModifyVSCode,
|
||||
'vscode',
|
||||
);
|
||||
const secondCall = mockOpenDiff.mock.calls[1];
|
||||
const secondOldPath = secondCall[0];
|
||||
|
|
|
|||
|
|
@ -432,19 +432,6 @@ Expectation for required parameters:
|
|||
}
|
||||
}
|
||||
|
||||
async getEditor(outcome: ToolConfirmationOutcome): Promise<EditorType> {
|
||||
switch (outcome) {
|
||||
case ToolConfirmationOutcome.ModifyVSCode:
|
||||
return 'vscode';
|
||||
case ToolConfirmationOutcome.ModifyWindsurf:
|
||||
return 'windsurf';
|
||||
case ToolConfirmationOutcome.ModifyCursor:
|
||||
return 'cursor';
|
||||
default:
|
||||
return 'vim';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates temp files for the current and proposed file contents and opens a diff tool.
|
||||
* When the diff tool is closed, the tool will check if the file has been modified and provide the updated params.
|
||||
|
|
@ -453,7 +440,7 @@ Expectation for required parameters:
|
|||
async onModify(
|
||||
params: EditToolParams,
|
||||
_abortSignal: AbortSignal,
|
||||
outcome: ToolConfirmationOutcome,
|
||||
editorType: EditorType,
|
||||
): Promise<
|
||||
{ updatedParams: EditToolParams; updatedDiff: string } | undefined
|
||||
> {
|
||||
|
|
@ -461,9 +448,7 @@ Expectation for required parameters:
|
|||
this.tempOldDiffPath = oldPath;
|
||||
this.tempNewDiffPath = newPath;
|
||||
|
||||
const editor = await this.getEditor(outcome);
|
||||
|
||||
await openDiff(this.tempOldDiffPath, this.tempNewDiffPath, editor);
|
||||
await openDiff(this.tempOldDiffPath, this.tempNewDiffPath, editorType);
|
||||
return await this.getUpdatedParamsIfModified(params, _abortSignal);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -232,9 +232,6 @@ export enum ToolConfirmationOutcome {
|
|||
ProceedAlways = 'proceed_always',
|
||||
ProceedAlwaysServer = 'proceed_always_server',
|
||||
ProceedAlwaysTool = 'proceed_always_tool',
|
||||
ModifyVSCode = 'modify_vscode',
|
||||
ModifyWindsurf = 'modify_windsurf',
|
||||
ModifyCursor = 'modify_cursor',
|
||||
ModifyVim = 'modify_vim',
|
||||
ModifyWithEditor = 'modify_with_editor',
|
||||
Cancel = 'cancel',
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,8 +4,22 @@
|
|||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
import { vi, describe, it, expect, beforeEach, type Mock } from 'vitest';
|
||||
import { checkHasEditor, getDiffCommand, openDiff } from './editor.js';
|
||||
import {
|
||||
vi,
|
||||
describe,
|
||||
it,
|
||||
expect,
|
||||
beforeEach,
|
||||
afterEach,
|
||||
type Mock,
|
||||
} from 'vitest';
|
||||
import {
|
||||
checkHasEditorType,
|
||||
getDiffCommand,
|
||||
openDiff,
|
||||
allowEditorTypeInSandbox,
|
||||
isEditorAvailable,
|
||||
} from './editor.js';
|
||||
import { execSync, spawn } from 'child_process';
|
||||
|
||||
vi.mock('child_process', () => ({
|
||||
|
|
@ -13,14 +27,14 @@ vi.mock('child_process', () => ({
|
|||
spawn: vi.fn(),
|
||||
}));
|
||||
|
||||
describe('checkHasEditor', () => {
|
||||
describe('checkHasEditorType', () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
});
|
||||
|
||||
it('should return true for vscode if "code" command exists', () => {
|
||||
(execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/code'));
|
||||
expect(checkHasEditor('vscode')).toBe(true);
|
||||
expect(checkHasEditorType('vscode')).toBe(true);
|
||||
const expectedCommand =
|
||||
process.platform === 'win32' ? 'where.exe code.cmd' : 'command -v code';
|
||||
expect(execSync).toHaveBeenCalledWith(expectedCommand, {
|
||||
|
|
@ -32,12 +46,12 @@ describe('checkHasEditor', () => {
|
|||
(execSync as Mock).mockImplementation(() => {
|
||||
throw new Error();
|
||||
});
|
||||
expect(checkHasEditor('vscode')).toBe(false);
|
||||
expect(checkHasEditorType('vscode')).toBe(false);
|
||||
});
|
||||
|
||||
it('should return true for windsurf if "windsurf" command exists', () => {
|
||||
(execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/windsurf'));
|
||||
expect(checkHasEditor('windsurf')).toBe(true);
|
||||
expect(checkHasEditorType('windsurf')).toBe(true);
|
||||
expect(execSync).toHaveBeenCalledWith('command -v windsurf', {
|
||||
stdio: 'ignore',
|
||||
});
|
||||
|
|
@ -47,12 +61,12 @@ describe('checkHasEditor', () => {
|
|||
(execSync as Mock).mockImplementation(() => {
|
||||
throw new Error();
|
||||
});
|
||||
expect(checkHasEditor('windsurf')).toBe(false);
|
||||
expect(checkHasEditorType('windsurf')).toBe(false);
|
||||
});
|
||||
|
||||
it('should return true for cursor if "cursor" command exists', () => {
|
||||
(execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/cursor'));
|
||||
expect(checkHasEditor('cursor')).toBe(true);
|
||||
expect(checkHasEditorType('cursor')).toBe(true);
|
||||
expect(execSync).toHaveBeenCalledWith('command -v cursor', {
|
||||
stdio: 'ignore',
|
||||
});
|
||||
|
|
@ -62,12 +76,12 @@ describe('checkHasEditor', () => {
|
|||
(execSync as Mock).mockImplementation(() => {
|
||||
throw new Error();
|
||||
});
|
||||
expect(checkHasEditor('cursor')).toBe(false);
|
||||
expect(checkHasEditorType('cursor')).toBe(false);
|
||||
});
|
||||
|
||||
it('should return true for vim if "vim" command exists', () => {
|
||||
(execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/vim'));
|
||||
expect(checkHasEditor('vim')).toBe(true);
|
||||
expect(checkHasEditorType('vim')).toBe(true);
|
||||
const expectedCommand =
|
||||
process.platform === 'win32' ? 'where.exe vim' : 'command -v vim';
|
||||
expect(execSync).toHaveBeenCalledWith(expectedCommand, {
|
||||
|
|
@ -79,7 +93,7 @@ describe('checkHasEditor', () => {
|
|||
(execSync as Mock).mockImplementation(() => {
|
||||
throw new Error();
|
||||
});
|
||||
expect(checkHasEditor('vim')).toBe(false);
|
||||
expect(checkHasEditorType('vim')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
|
|
@ -153,3 +167,85 @@ describe('openDiff', () => {
|
|||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('allowEditorTypeInSandbox', () => {
|
||||
afterEach(() => {
|
||||
delete process.env.SANDBOX;
|
||||
});
|
||||
|
||||
it('should allow vim in sandbox mode', () => {
|
||||
process.env.SANDBOX = 'sandbox';
|
||||
expect(allowEditorTypeInSandbox('vim')).toBe(true);
|
||||
});
|
||||
|
||||
it('should allow vim when not in sandbox mode', () => {
|
||||
delete process.env.SANDBOX;
|
||||
expect(allowEditorTypeInSandbox('vim')).toBe(true);
|
||||
});
|
||||
|
||||
it('should not allow vscode in sandbox mode', () => {
|
||||
process.env.SANDBOX = 'sandbox';
|
||||
expect(allowEditorTypeInSandbox('vscode')).toBe(false);
|
||||
});
|
||||
|
||||
it('should allow vscode when not in sandbox mode', () => {
|
||||
delete process.env.SANDBOX;
|
||||
expect(allowEditorTypeInSandbox('vscode')).toBe(true);
|
||||
});
|
||||
|
||||
it('should not allow windsurf in sandbox mode', () => {
|
||||
process.env.SANDBOX = 'sandbox';
|
||||
expect(allowEditorTypeInSandbox('windsurf')).toBe(false);
|
||||
});
|
||||
|
||||
it('should allow windsurf when not in sandbox mode', () => {
|
||||
delete process.env.SANDBOX;
|
||||
expect(allowEditorTypeInSandbox('windsurf')).toBe(true);
|
||||
});
|
||||
|
||||
it('should not allow cursor in sandbox mode', () => {
|
||||
process.env.SANDBOX = 'sandbox';
|
||||
expect(allowEditorTypeInSandbox('cursor')).toBe(false);
|
||||
});
|
||||
|
||||
it('should allow cursor when not in sandbox mode', () => {
|
||||
delete process.env.SANDBOX;
|
||||
expect(allowEditorTypeInSandbox('cursor')).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('isEditorAvailable', () => {
|
||||
afterEach(() => {
|
||||
delete process.env.SANDBOX;
|
||||
});
|
||||
|
||||
it('should return false for undefined editor', () => {
|
||||
expect(isEditorAvailable(undefined)).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for empty string editor', () => {
|
||||
expect(isEditorAvailable('')).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for invalid editor type', () => {
|
||||
expect(isEditorAvailable('invalid-editor')).toBe(false);
|
||||
});
|
||||
|
||||
it('should return true for vscode when installed and not in sandbox mode', () => {
|
||||
(execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/code'));
|
||||
expect(isEditorAvailable('vscode')).toBe(true);
|
||||
});
|
||||
|
||||
it('should return false for vscode when not installed and not in sandbox mode', () => {
|
||||
(execSync as Mock).mockImplementation(() => {
|
||||
throw new Error();
|
||||
});
|
||||
expect(isEditorAvailable('vscode')).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for vscode when installed and in sandbox mode', () => {
|
||||
(execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/code'));
|
||||
process.env.SANDBOX = 'sandbox';
|
||||
expect(isEditorAvailable('vscode')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -8,6 +8,10 @@ import { execSync, spawn } from 'child_process';
|
|||
|
||||
export type EditorType = 'vscode' | 'windsurf' | 'cursor' | 'vim';
|
||||
|
||||
function isValidEditorType(editor: string): editor is EditorType {
|
||||
return ['vscode', 'windsurf', 'cursor', 'vim'].includes(editor);
|
||||
}
|
||||
|
||||
interface DiffCommand {
|
||||
command: string;
|
||||
args: string[];
|
||||
|
|
@ -32,13 +36,35 @@ const editorCommands: Record<EditorType, { win32: string; default: string }> = {
|
|||
vim: { win32: 'vim', default: 'vim' },
|
||||
};
|
||||
|
||||
export function checkHasEditor(editor: EditorType): boolean {
|
||||
export function checkHasEditorType(editor: EditorType): boolean {
|
||||
const commandConfig = editorCommands[editor];
|
||||
const command =
|
||||
process.platform === 'win32' ? commandConfig.win32 : commandConfig.default;
|
||||
return commandExists(command);
|
||||
}
|
||||
|
||||
export function allowEditorTypeInSandbox(editor: EditorType): boolean {
|
||||
const notUsingSandbox = !process.env.SANDBOX;
|
||||
if (['vscode', 'windsurf', 'cursor'].includes(editor)) {
|
||||
return notUsingSandbox;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the editor is valid and can be used.
|
||||
* Returns false if preferred editor is not set / invalid / not available / not allowed in sandbox.
|
||||
*/
|
||||
export function isEditorAvailable(editor: string | undefined): boolean {
|
||||
if (editor && isValidEditorType(editor)) {
|
||||
return (
|
||||
checkHasEditorType(editor as EditorType) &&
|
||||
allowEditorTypeInSandbox(editor as EditorType)
|
||||
);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the diff command for a specific editor.
|
||||
*/
|
||||
|
|
|
|||
Loading…
Reference in New Issue