fss-link 1.0.49 → 1.0.51

package/dist/ui/commands/quitCommand.test.ts

@@ -1,55 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { quitCommand } from './quitCommand.js';
-import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
-import { formatDuration } from '../utils/formatters.js';
-
-vi.mock('../utils/formatters.js');
-
-describe('quitCommand', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date('2025-01-01T01:00:00Z'));
-    vi.mocked(formatDuration).mockReturnValue('1h 0m 0s');
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.clearAllMocks();
-  });
-
-  it('returns a QuitActionReturn object with the correct messages', () => {
-    const mockContext = createMockCommandContext({
-      session: {
-        stats: {
-          sessionStartTime: new Date('2025-01-01T00:00:00Z'),
-        },
-      },
-    });
-
-    if (!quitCommand.action) throw new Error('Action is not defined');
-    const result = quitCommand.action(mockContext, 'quit');
-
-    expect(formatDuration).toHaveBeenCalledWith(3600000); // 1 hour in ms
-    expect(result).toEqual({
-      type: 'quit',
-      messages: [
-        {
-          type: 'user',
-          text: '/quit',
-          id: expect.any(Number),
-        },
-        {
-          type: 'quit',
-          duration: '1h 0m 0s',
-          id: expect.any(Number),
-        },
-      ],
-    });
-  });
-});

package/dist/ui/commands/quitCommand.ts

@@ -1,36 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { formatDuration } from '../utils/formatters.js';
-import { CommandKind, type SlashCommand } from './types.js';
-
-export const quitCommand: SlashCommand = {
-  name: 'quit',
-  altNames: ['exit'],
-  description: 'exit the cli',
-  kind: CommandKind.BUILT_IN,
-  action: (context) => {
-    const now = Date.now();
-    const { sessionStartTime } = context.session.stats;
-    const wallDuration = now - sessionStartTime.getTime();
-
-    return {
-      type: 'quit',
-      messages: [
-        {
-          type: 'user',
-          text: `/quit`, // Keep it consistent, even if /exit was used
-          id: now - 1,
-        },
-        {
-          type: 'quit',
-          duration: formatDuration(wallDuration),
-          id: now,
-        },
-      ],
-    };
-  },
-};

package/dist/ui/commands/restoreCommand.test.ts

@@ -1,250 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs/promises';
-import * as os from 'os';
-import * as path from 'path';
-import { restoreCommand } from './restoreCommand.js';
-import { type CommandContext } from './types.js';
-import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
-import { Config, GitService } from 'fss-link-core';
-
-describe('restoreCommand', () => {
-  let mockContext: CommandContext;
-  let mockConfig: Config;
-  let mockGitService: GitService;
-  let mockSetHistory: ReturnType<typeof vi.fn>;
-  let testRootDir: string;
-  let geminiTempDir: string;
-  let checkpointsDir: string;
-
-  beforeEach(async () => {
-    testRootDir = await fs.mkdtemp(
-      path.join(os.tmpdir(), 'restore-command-test-'),
-    );
-    geminiTempDir = path.join(testRootDir, '.gemini');
-    checkpointsDir = path.join(geminiTempDir, 'checkpoints');
-    // The command itself creates this, but for tests it's easier to have it ready.
-    // Some tests might remove it to test error paths.
-    await fs.mkdir(checkpointsDir, { recursive: true });
-
-    mockSetHistory = vi.fn().mockResolvedValue(undefined);
-    mockGitService = {
-      restoreProjectFromSnapshot: vi.fn().mockResolvedValue(undefined),
-    } as unknown as GitService;
-
-    mockConfig = {
-      getCheckpointingEnabled: vi.fn().mockReturnValue(true),
-      getProjectTempDir: vi.fn().mockReturnValue(geminiTempDir),
-      getGeminiClient: vi.fn().mockReturnValue({
-        setHistory: mockSetHistory,
-      }),
-    } as unknown as Config;
-
-    mockContext = createMockCommandContext({
-      services: {
-        config: mockConfig,
-        git: mockGitService,
-      },
-    });
-  });
-
-  afterEach(async () => {
-    vi.restoreAllMocks();
-    await fs.rm(testRootDir, { recursive: true, force: true });
-  });
-
-  it('should return null if checkpointing is not enabled', () => {
-    vi.mocked(mockConfig.getCheckpointingEnabled).mockReturnValue(false);
-
-    expect(restoreCommand(mockConfig)).toBeNull();
-  });
-
-  it('should return the command if checkpointing is enabled', () => {
-    expect(restoreCommand(mockConfig)).toEqual(
-      expect.objectContaining({
-        name: 'restore',
-        description: expect.any(String),
-        action: expect.any(Function),
-        completion: expect.any(Function),
-      }),
-    );
-  });
-
-  describe('action', () => {
-    it('should return an error if temp dir is not found', async () => {
-      vi.mocked(mockConfig.getProjectTempDir).mockReturnValue('');
-
-      expect(
-        await restoreCommand(mockConfig)?.action?.(mockContext, ''),
-      ).toEqual({
-        type: 'message',
-        messageType: 'error',
-        content: 'Could not determine the .gemini directory path.',
-      });
-    });
-
-    it('should inform when no checkpoints are found if no args are passed', async () => {
-      // Remove the directory to ensure the command creates it.
-      await fs.rm(checkpointsDir, { recursive: true, force: true });
-      const command = restoreCommand(mockConfig);
-
-      expect(await command?.action?.(mockContext, '')).toEqual({
-        type: 'message',
-        messageType: 'info',
-        content: 'No restorable tool calls found.',
-      });
-      // Verify the directory was created by the command.
-      await expect(fs.stat(checkpointsDir)).resolves.toBeDefined();
-    });
-
-    it('should list available checkpoints if no args are passed', async () => {
-      await fs.writeFile(path.join(checkpointsDir, 'test1.json'), '{}');
-      await fs.writeFile(path.join(checkpointsDir, 'test2.json'), '{}');
-      const command = restoreCommand(mockConfig);
-
-      expect(await command?.action?.(mockContext, '')).toEqual({
-        type: 'message',
-        messageType: 'info',
-        content: 'Available tool calls to restore:\n\ntest1\ntest2',
-      });
-    });
-
-    it('should return an error if the specified file is not found', async () => {
-      await fs.writeFile(path.join(checkpointsDir, 'test1.json'), '{}');
-      const command = restoreCommand(mockConfig);
-
-      expect(await command?.action?.(mockContext, 'test2')).toEqual({
-        type: 'message',
-        messageType: 'error',
-        content: 'File not found: test2.json',
-      });
-    });
-
-    it('should handle file read errors gracefully', async () => {
-      const checkpointName = 'test1';
-      const checkpointPath = path.join(
-        checkpointsDir,
-        `${checkpointName}.json`,
-      );
-      // Create a directory instead of a file to cause a read error.
-      await fs.mkdir(checkpointPath);
-      const command = restoreCommand(mockConfig);
-
-      expect(await command?.action?.(mockContext, checkpointName)).toEqual({
-        type: 'message',
-        messageType: 'error',
-        content: expect.stringContaining(
-          'Could not read restorable tool calls.',
-        ),
-      });
-    });
-
-    it('should restore a tool call and project state', async () => {
-      const toolCallData = {
-        history: [{ type: 'user', text: 'do a thing' }],
-        clientHistory: [{ role: 'user', parts: [{ text: 'do a thing' }] }],
-        commitHash: 'abcdef123',
-        toolCall: { name: 'run_shell_command', args: 'ls' },
-      };
-      await fs.writeFile(
-        path.join(checkpointsDir, 'my-checkpoint.json'),
-        JSON.stringify(toolCallData),
-      );
-      const command = restoreCommand(mockConfig);
-
-      expect(await command?.action?.(mockContext, 'my-checkpoint')).toEqual({
-        type: 'tool',
-        toolName: 'run_shell_command',
-        toolArgs: 'ls',
-      });
-      expect(mockContext.ui.loadHistory).toHaveBeenCalledWith(
-        toolCallData.history,
-      );
-      expect(mockSetHistory).toHaveBeenCalledWith(toolCallData.clientHistory);
-      expect(mockGitService.restoreProjectFromSnapshot).toHaveBeenCalledWith(
-        toolCallData.commitHash,
-      );
-      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
-        {
-          type: 'info',
-          text: 'Restored project to the state before the tool call.',
-        },
-        expect.any(Number),
-      );
-    });
-
-    it('should restore even if only toolCall is present', async () => {
-      const toolCallData = {
-        toolCall: { name: 'run_shell_command', args: 'ls' },
-      };
-      await fs.writeFile(
-        path.join(checkpointsDir, 'my-checkpoint.json'),
-        JSON.stringify(toolCallData),
-      );
-
-      const command = restoreCommand(mockConfig);
-
-      expect(await command?.action?.(mockContext, 'my-checkpoint')).toEqual({
-        type: 'tool',
-        toolName: 'run_shell_command',
-        toolArgs: 'ls',
-      });
-
-      expect(mockContext.ui.loadHistory).not.toHaveBeenCalled();
-      expect(mockSetHistory).not.toHaveBeenCalled();
-      expect(mockGitService.restoreProjectFromSnapshot).not.toHaveBeenCalled();
-    });
-  });
-
-  it('should return an error for a checkpoint file missing the toolCall property', async () => {
-    const checkpointName = 'missing-toolcall';
-    await fs.writeFile(
-      path.join(checkpointsDir, `${checkpointName}.json`),
-      JSON.stringify({ history: [] }), // An object that is valid JSON but missing the 'toolCall' property
-    );
-    const command = restoreCommand(mockConfig);
-
-    expect(await command?.action?.(mockContext, checkpointName)).toEqual({
-      type: 'message',
-      messageType: 'error',
-      // A more specific error message would be ideal, but for now, we can assert the current behavior.
-      content: expect.stringContaining('Could not read restorable tool calls.'),
-    });
-  });
-
-  describe('completion', () => {
-    it('should return an empty array if temp dir is not found', async () => {
-      vi.mocked(mockConfig.getProjectTempDir).mockReturnValue('');
-      const command = restoreCommand(mockConfig);
-
-      expect(await command?.completion?.(mockContext, '')).toEqual([]);
-    });
-
-    it('should return an empty array on readdir error', async () => {
-      await fs.rm(checkpointsDir, { recursive: true, force: true });
-      const command = restoreCommand(mockConfig);
-
-      expect(await command?.completion?.(mockContext, '')).toEqual([]);
-    });
-
-    it('should return a list of checkpoint names', async () => {
-      await fs.writeFile(path.join(checkpointsDir, 'test1.json'), '{}');
-      await fs.writeFile(path.join(checkpointsDir, 'test2.json'), '{}');
-      await fs.writeFile(
-        path.join(checkpointsDir, 'not-a-checkpoint.txt'),
-        '{}',
-      );
-      const command = restoreCommand(mockConfig);
-
-      expect(await command?.completion?.(mockContext, '')).toEqual([
-        'test1',
-        'test2',
-      ]);
-    });
-  });
-});

package/dist/ui/commands/restoreCommand.ts

@@ -1,157 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as fs from 'fs/promises';
-import path from 'path';
-import {
-  type CommandContext,
-  type SlashCommand,
-  type SlashCommandActionReturn,
-  CommandKind,
-} from './types.js';
-import { Config } from 'fss-link-core';
-
-async function restoreAction(
-  context: CommandContext,
-  args: string,
-): Promise<void | SlashCommandActionReturn> {
-  const { services, ui } = context;
-  const { config, git: gitService } = services;
-  const { addItem, loadHistory } = ui;
-
-  const checkpointDir = config?.getProjectTempDir()
-    ? path.join(config.getProjectTempDir(), 'checkpoints')
-    : undefined;
-
-  if (!checkpointDir) {
-    return {
-      type: 'message',
-      messageType: 'error',
-      content: 'Could not determine the .gemini directory path.',
-    };
-  }
-
-  try {
-    // Ensure the directory exists before trying to read it.
-    await fs.mkdir(checkpointDir, { recursive: true });
-    const files = await fs.readdir(checkpointDir);
-    const jsonFiles = files.filter((file) => file.endsWith('.json'));
-
-    if (!args) {
-      if (jsonFiles.length === 0) {
-        return {
-          type: 'message',
-          messageType: 'info',
-          content: 'No restorable tool calls found.',
-        };
-      }
-      const truncatedFiles = jsonFiles.map((file) => {
-        const components = file.split('.');
-        if (components.length <= 1) {
-          return file;
-        }
-        components.pop();
-        return components.join('.');
-      });
-      const fileList = truncatedFiles.join('\n');
-      return {
-        type: 'message',
-        messageType: 'info',
-        content: `Available tool calls to restore:\n\n${fileList}`,
-      };
-    }
-
-    const selectedFile = args.endsWith('.json') ? args : `${args}.json`;
-
-    if (!jsonFiles.includes(selectedFile)) {
-      return {
-        type: 'message',
-        messageType: 'error',
-        content: `File not found: ${selectedFile}`,
-      };
-    }
-
-    const filePath = path.join(checkpointDir, selectedFile);
-    const data = await fs.readFile(filePath, 'utf-8');
-    const toolCallData = JSON.parse(data);
-
-    if (toolCallData.history) {
-      if (!loadHistory) {
-        // This should not happen
-        return {
-          type: 'message',
-          messageType: 'error',
-          content: 'loadHistory function is not available.',
-        };
-      }
-      loadHistory(toolCallData.history);
-    }
-
-    if (toolCallData.clientHistory) {
-      await config?.getGeminiClient()?.setHistory(toolCallData.clientHistory);
-    }
-
-    if (toolCallData.commitHash) {
-      await gitService?.restoreProjectFromSnapshot(toolCallData.commitHash);
-      addItem(
-        {
-          type: 'info',
-          text: 'Restored project to the state before the tool call.',
-        },
-        Date.now(),
-      );
-    }
-
-    return {
-      type: 'tool',
-      toolName: toolCallData.toolCall.name,
-      toolArgs: toolCallData.toolCall.args,
-    };
-  } catch (error) {
-    return {
-      type: 'message',
-      messageType: 'error',
-      content: `Could not read restorable tool calls. This is the error: ${error}`,
-    };
-  }
-}
-
-async function completion(
-  context: CommandContext,
-  _partialArg: string,
-): Promise<string[]> {
-  const { services } = context;
-  const { config } = services;
-  const checkpointDir = config?.getProjectTempDir()
-    ? path.join(config.getProjectTempDir(), 'checkpoints')
-    : undefined;
-  if (!checkpointDir) {
-    return [];
-  }
-  try {
-    const files = await fs.readdir(checkpointDir);
-    return files
-      .filter((file) => file.endsWith('.json'))
-      .map((file) => file.replace('.json', ''));
-  } catch (_err) {
-    return [];
-  }
-}
-
-export const restoreCommand = (config: Config | null): SlashCommand | null => {
-  if (!config?.getCheckpointingEnabled()) {
-    return null;
-  }
-
-  return {
-    name: 'restore',
-    description:
-      'Restore a tool call. This will reset the conversation and file history to the state it was in when the tool call was suggested',
-    kind: CommandKind.BUILT_IN,
-    action: restoreAction,
-    completion,
-  };
-};

package/dist/ui/commands/searchEngineSetupCommand.ts

@@ -1,18 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { CommandKind, SlashCommand, OpenDialogActionReturn } from './types.js';
-
-export const searchEngineSetupCommand: SlashCommand = {
-  name: 'setup-search',
-  altNames: ['config-search', 'search-setup'],
-  description: 'Configure search engine API keys for web scraping',
-  kind: CommandKind.BUILT_IN,
-  action: (): OpenDialogActionReturn => ({
-    type: 'dialog',
-    dialog: 'search',
-  }),
-};

package/dist/ui/commands/settingsCommand.test.ts

@@ -1,36 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { settingsCommand } from './settingsCommand.js';
-import { type CommandContext } from './types.js';
-import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
-
-describe('settingsCommand', () => {
-  let mockContext: CommandContext;
-
-  beforeEach(() => {
-    mockContext = createMockCommandContext();
-  });
-
-  it('should return a dialog action to open the settings dialog', () => {
-    if (!settingsCommand.action) {
-      throw new Error('The settings command must have an action.');
-    }
-    const result = settingsCommand.action(mockContext, '');
-    expect(result).toEqual({
-      type: 'dialog',
-      dialog: 'settings',
-    });
-  });
-
-  it('should have the correct name and description', () => {
-    expect(settingsCommand.name).toBe('settings');
-    expect(settingsCommand.description).toBe(
-      'View and edit FSS Link settings',
-    );
-  });
-});

package/dist/ui/commands/settingsCommand.ts

@@ -1,17 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { CommandKind, OpenDialogActionReturn, SlashCommand } from './types.js';
-
-export const settingsCommand: SlashCommand = {
-  name: 'settings',
-  description: 'View and edit FSS Link settings',
-  kind: CommandKind.BUILT_IN,
-  action: (_context, _args): OpenDialogActionReturn => ({
-    type: 'dialog',
-    dialog: 'settings',
-  }),
-};