fss-link 1.0.49 → 1.0.51

package/dist/ui/hooks/useAtCompletion.ts

@@ -1,244 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { useEffect, useReducer, useRef } from 'react';
-import {
-  Config,
-  FileSearch,
-  FileSearchFactory,
-  escapePath,
-} from 'fss-link-core';
-import {
-  Suggestion,
-  MAX_SUGGESTIONS_TO_SHOW,
-} from '../components/SuggestionsDisplay.js';
-
-export enum AtCompletionStatus {
-  IDLE = 'idle',
-  INITIALIZING = 'initializing',
-  READY = 'ready',
-  SEARCHING = 'searching',
-  ERROR = 'error',
-}
-
-interface AtCompletionState {
-  status: AtCompletionStatus;
-  suggestions: Suggestion[];
-  isLoading: boolean;
-  pattern: string | null;
-}
-
-type AtCompletionAction =
-  | { type: 'INITIALIZE' }
-  | { type: 'INITIALIZE_SUCCESS' }
-  | { type: 'SEARCH'; payload: string }
-  | { type: 'SEARCH_SUCCESS'; payload: Suggestion[] }
-  | { type: 'SET_LOADING'; payload: boolean }
-  | { type: 'ERROR' }
-  | { type: 'RESET' };
-
-const initialState: AtCompletionState = {
-  status: AtCompletionStatus.IDLE,
-  suggestions: [],
-  isLoading: false,
-  pattern: null,
-};
-
-function atCompletionReducer(
-  state: AtCompletionState,
-  action: AtCompletionAction,
-): AtCompletionState {
-  switch (action.type) {
-    case 'INITIALIZE':
-      return {
-        ...state,
-        status: AtCompletionStatus.INITIALIZING,
-        isLoading: true,
-      };
-    case 'INITIALIZE_SUCCESS':
-      return { ...state, status: AtCompletionStatus.READY, isLoading: false };
-    case 'SEARCH':
-      // Keep old suggestions, don't set loading immediately
-      return {
-        ...state,
-        status: AtCompletionStatus.SEARCHING,
-        pattern: action.payload,
-      };
-    case 'SEARCH_SUCCESS':
-      return {
-        ...state,
-        status: AtCompletionStatus.READY,
-        suggestions: action.payload,
-        isLoading: false,
-      };
-    case 'SET_LOADING':
-      // Only show loading if we are still in a searching state
-      if (state.status === AtCompletionStatus.SEARCHING) {
-        return { ...state, isLoading: action.payload, suggestions: [] };
-      }
-      return state;
-    case 'ERROR':
-      return {
-        ...state,
-        status: AtCompletionStatus.ERROR,
-        isLoading: false,
-        suggestions: [],
-      };
-    case 'RESET':
-      return initialState;
-    default:
-      return state;
-  }
-}
-
-export interface UseAtCompletionProps {
-  enabled: boolean;
-  pattern: string;
-  config: Config | undefined;
-  cwd: string;
-  setSuggestions: (suggestions: Suggestion[]) => void;
-  setIsLoadingSuggestions: (isLoading: boolean) => void;
-}
-
-export function useAtCompletion(props: UseAtCompletionProps): void {
-  const {
-    enabled,
-    pattern,
-    config,
-    cwd,
-    setSuggestions,
-    setIsLoadingSuggestions,
-  } = props;
-  const [state, dispatch] = useReducer(atCompletionReducer, initialState);
-  const fileSearch = useRef<FileSearch | null>(null);
-  const searchAbortController = useRef<AbortController | null>(null);
-  const slowSearchTimer = useRef<NodeJS.Timeout | null>(null);
-
-  useEffect(() => {
-    setSuggestions(state.suggestions);
-  }, [state.suggestions, setSuggestions]);
-
-  useEffect(() => {
-    setIsLoadingSuggestions(state.isLoading);
-  }, [state.isLoading, setIsLoadingSuggestions]);
-
-  useEffect(() => {
-    dispatch({ type: 'RESET' });
-  }, [cwd, config]);
-
-  // Reacts to user input (`pattern`) ONLY.
-  useEffect(() => {
-    if (!enabled) {
-      // reset when first getting out of completion suggestions
-      if (
-        state.status === AtCompletionStatus.READY ||
-        state.status === AtCompletionStatus.ERROR
-      ) {
-        dispatch({ type: 'RESET' });
-      }
-      return;
-    }
-    if (pattern === null) {
-      dispatch({ type: 'RESET' });
-      return;
-    }
-
-    if (state.status === AtCompletionStatus.IDLE) {
-      dispatch({ type: 'INITIALIZE' });
-    } else if (
-      (state.status === AtCompletionStatus.READY ||
-        state.status === AtCompletionStatus.SEARCHING) &&
-      pattern !== state.pattern // Only search if the pattern has changed
-    ) {
-      dispatch({ type: 'SEARCH', payload: pattern });
-    }
-  }, [enabled, pattern, state.status, state.pattern]);
-
-  // The "Worker" that performs async operations based on status.
-  useEffect(() => {
-    const initialize = async () => {
-      try {
-        const searcher = FileSearchFactory.create({
-          projectRoot: cwd,
-          ignoreDirs: [],
-          useGitignore:
-            config?.getFileFilteringOptions()?.respectGitIgnore ?? true,
-          useGeminiignore:
-            config?.getFileFilteringOptions()?.respectGeminiIgnore ?? true,
-          useFssLinkignore:
-            config?.getFileFilteringOptions()?.respectFssLinkIgnore ?? true,
-          cache: true,
-          cacheTtl: 30, // 30 seconds
-          enableRecursiveFileSearch:
-            config?.getEnableRecursiveFileSearch() ?? true,
-        });
-        await searcher.initialize();
-        fileSearch.current = searcher;
-        dispatch({ type: 'INITIALIZE_SUCCESS' });
-        if (state.pattern !== null) {
-          dispatch({ type: 'SEARCH', payload: state.pattern });
-        }
-      } catch (_) {
-        dispatch({ type: 'ERROR' });
-      }
-    };
-
-    const search = async () => {
-      if (!fileSearch.current || state.pattern === null) {
-        return;
-      }
-
-      if (slowSearchTimer.current) {
-        clearTimeout(slowSearchTimer.current);
-      }
-
-      const controller = new AbortController();
-      searchAbortController.current = controller;
-
-      slowSearchTimer.current = setTimeout(() => {
-        dispatch({ type: 'SET_LOADING', payload: true });
-      }, 200);
-
-      try {
-        const results = await fileSearch.current.search(state.pattern, {
-          signal: controller.signal,
-          maxResults: MAX_SUGGESTIONS_TO_SHOW * 3,
-        });
-
-        if (slowSearchTimer.current) {
-          clearTimeout(slowSearchTimer.current);
-        }
-
-        if (controller.signal.aborted) {
-          return;
-        }
-
-        const suggestions = results.map((p) => ({
-          label: p,
-          value: escapePath(p),
-        }));
-        dispatch({ type: 'SEARCH_SUCCESS', payload: suggestions });
-      } catch (error) {
-        if (!(error instanceof Error && error.name === 'AbortError')) {
-          dispatch({ type: 'ERROR' });
-        }
-      }
-    };
-
-    if (state.status === AtCompletionStatus.INITIALIZING) {
-      initialize();
-    } else if (state.status === AtCompletionStatus.SEARCHING) {
-      search();
-    }
-
-    return () => {
-      searchAbortController.current?.abort();
-      if (slowSearchTimer.current) {
-        clearTimeout(slowSearchTimer.current);
-      }
-    };
-  }, [state.status, state.pattern, config, cwd]);
-}

package/dist/ui/hooks/useAuthCommand.ts

@@ -1,129 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { useState, useCallback, useEffect } from 'react';
-import { LoadedSettings, SettingScope } from '../../config/settings.js';
-import {
-  AuthType,
-  Config,
-  clearCachedCredentialFile,
-  getErrorMessage,
-} from 'fss-link-core';
-import { runExitCleanup } from '../../utils/cleanup.js';
-import { getModelManager } from '../../config/modelManager.js';
-
-export const useAuthCommand = (
-  settings: LoadedSettings,
-  setAuthError: (error: string | null) => void,
-  config: Config,
-) => {
-  // Check database first - if we have an active model, don't show auth dialog
-  const modelManager = getModelManager();
-  const [hasActiveModel, setHasActiveModel] = useState(false);
-  
-  // Initialize hasActiveModel state asynchronously
-  useEffect(() => {
-    const checkActiveModel = async () => {
-      const result = await modelManager.hasValidConfiguration();
-      setHasActiveModel(result);
-    };
-    void checkActiveModel();
-  }, [modelManager]);
-  
-  const [isAuthDialogOpen, setIsAuthDialogOpen] = useState(
-    !hasActiveModel && settings.merged.selectedAuthType === undefined,
-  );
-
-  const openAuthDialog = useCallback(() => {
-    setIsAuthDialogOpen(true);
-  }, []);
-
-  const [isAuthenticating, setIsAuthenticating] = useState(false);
-
-  useEffect(() => {
-    const authFlow = async () => {
-      if (isAuthDialogOpen) {
-        return;
-      }
-
-      // First, try to initialize from database
-      if (hasActiveModel) {
-        const currentAuthType = await modelManager.getCurrentAuthType();
-        if (currentAuthType) {
-          try {
-            setIsAuthenticating(true);
-            await config.refreshAuth(currentAuthType as AuthType);
-            console.log(`Authenticated via "${currentAuthType}" (from database).`);
-            return;
-          } catch (e) {
-            console.warn(`Database auth failed: ${getErrorMessage(e)}`);
-            // Fall through to settings-based auth
-          } finally {
-            setIsAuthenticating(false);
-          }
-        }
-      }
-
-      // Fallback to settings-based auth
-      const authType = settings.merged.selectedAuthType;
-      if (!authType) {
-        return;
-      }
-
-      try {
-        setIsAuthenticating(true);
-        await config.refreshAuth(authType);
-        console.log(`Authenticated via "${authType}".`);
-      } catch (e) {
-        setAuthError(`Failed to login. Message: ${getErrorMessage(e)}`);
-        openAuthDialog();
-      } finally {
-        setIsAuthenticating(false);
-      }
-    };
-
-    void authFlow();
-  }, [isAuthDialogOpen, hasActiveModel, settings, config, setAuthError, openAuthDialog, modelManager]);
-
-  const handleAuthSelect = useCallback(
-    async (authType: AuthType | undefined, scope: SettingScope) => {
-      if (authType) {
-        await clearCachedCredentialFile();
-
-        settings.setValue(scope, 'selectedAuthType', authType);
-        if (
-          authType === AuthType.LOGIN_WITH_GOOGLE &&
-          config.isBrowserLaunchSuppressed()
-        ) {
-          runExitCleanup();
-          console.log(
-            `
-----------------------------------------------------------------
-Logging in with Google... Please restart Gemini CLI to continue.
-----------------------------------------------------------------
-            `,
-          );
-          process.exit(0);
-        }
-      }
-      setIsAuthDialogOpen(false);
-      setAuthError(null);
-    },
-    [settings, setAuthError, config],
-  );
-
-  const cancelAuthentication = useCallback(() => {
-    setIsAuthenticating(false);
-  }, []);
-
-  return {
-    isAuthDialogOpen,
-    openAuthDialog,
-    handleAuthSelect,
-    isAuthenticating,
-    cancelAuthentication,
-  };
-};

package/dist/ui/hooks/useAutoAcceptIndicator.test.ts

@@ -1,300 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {
-  describe,
-  it,
-  expect,
-  vi,
-  beforeEach,
-  type MockedFunction,
-  type Mock,
-} from 'vitest';
-import { renderHook, act } from '@testing-library/react';
-import { useAutoAcceptIndicator } from './useAutoAcceptIndicator.js';
-
-import {
-  Config,
-  Config as ActualConfigType,
-  ApprovalMode,
-} from 'fss-link-core';
-import { useKeypress, Key } from './useKeypress.js';
-
-vi.mock('./useKeypress.js');
-
-vi.mock('fss-link-core', async () => {
-  const actualServerModule = (await vi.importActual(
-    'fss-link-core',
-  )) as Record<string, unknown>;
-  return {
-    ...actualServerModule,
-    Config: vi.fn(),
-  };
-});
-
-interface MockConfigInstanceShape {
-  getApprovalMode: Mock<() => ApprovalMode>;
-  setApprovalMode: Mock<(value: ApprovalMode) => void>;
-  getCoreTools: Mock<() => string[]>;
-  getToolDiscoveryCommand: Mock<() => string | undefined>;
-  getTargetDir: Mock<() => string>;
-  getApiKey: Mock<() => string>;
-  getModel: Mock<() => string>;
-  getSandbox: Mock<() => boolean | string>;
-  getDebugMode: Mock<() => boolean>;
-  getQuestion: Mock<() => string | undefined>;
-  getFullContext: Mock<() => boolean>;
-  getUserAgent: Mock<() => string>;
-  getUserMemory: Mock<() => string>;
-  getGeminiMdFileCount: Mock<() => number>;
-  getToolRegistry: Mock<() => { discoverTools: Mock<() => void> }>;
-}
-
-type UseKeypressHandler = (key: Key) => void;
-
-describe('useAutoAcceptIndicator', () => {
-  let mockConfigInstance: MockConfigInstanceShape;
-  let capturedUseKeypressHandler: UseKeypressHandler;
-  let mockedUseKeypress: MockedFunction<typeof useKeypress>;
-
-  beforeEach(() => {
-    vi.resetAllMocks();
-
-    (
-      Config as unknown as MockedFunction<() => MockConfigInstanceShape>
-    ).mockImplementation(() => {
-      const instanceGetApprovalModeMock = vi.fn();
-      const instanceSetApprovalModeMock = vi.fn();
-
-      const instance: MockConfigInstanceShape = {
-        getApprovalMode: instanceGetApprovalModeMock as Mock<
-          () => ApprovalMode
-        >,
-        setApprovalMode: instanceSetApprovalModeMock as Mock<
-          (value: ApprovalMode) => void
-        >,
-        getCoreTools: vi.fn().mockReturnValue([]) as Mock<() => string[]>,
-        getToolDiscoveryCommand: vi.fn().mockReturnValue(undefined) as Mock<
-          () => string | undefined
-        >,
-        getTargetDir: vi.fn().mockReturnValue('.') as Mock<() => string>,
-        getApiKey: vi.fn().mockReturnValue('test-api-key') as Mock<
-          () => string
-        >,
-        getModel: vi.fn().mockReturnValue('test-model') as Mock<() => string>,
-        getSandbox: vi.fn().mockReturnValue(false) as Mock<
-          () => boolean | string
-        >,
-        getDebugMode: vi.fn().mockReturnValue(false) as Mock<() => boolean>,
-        getQuestion: vi.fn().mockReturnValue(undefined) as Mock<
-          () => string | undefined
-        >,
-        getFullContext: vi.fn().mockReturnValue(false) as Mock<() => boolean>,
-        getUserAgent: vi.fn().mockReturnValue('test-user-agent') as Mock<
-          () => string
-        >,
-        getUserMemory: vi.fn().mockReturnValue('') as Mock<() => string>,
-        getGeminiMdFileCount: vi.fn().mockReturnValue(0) as Mock<() => number>,
-        getToolRegistry: vi
-          .fn()
-          .mockReturnValue({ discoverTools: vi.fn() }) as Mock<
-          () => { discoverTools: Mock<() => void> }
-        >,
-      };
-      instanceSetApprovalModeMock.mockImplementation((value: ApprovalMode) => {
-        instanceGetApprovalModeMock.mockReturnValue(value);
-      });
-      return instance;
-    });
-
-    mockedUseKeypress = useKeypress as MockedFunction<typeof useKeypress>;
-    mockedUseKeypress.mockImplementation(
-      (handler: UseKeypressHandler, _options) => {
-        capturedUseKeypressHandler = handler;
-      },
-    );
-
-     
-    mockConfigInstance = new (Config as any)() as MockConfigInstanceShape;
-  });
-
-  it('should initialize with ApprovalMode.AUTO_EDIT if config.getApprovalMode returns ApprovalMode.AUTO_EDIT', () => {
-    mockConfigInstance.getApprovalMode.mockReturnValue(ApprovalMode.AUTO_EDIT);
-    const { result } = renderHook(() =>
-      useAutoAcceptIndicator({
-        config: mockConfigInstance as unknown as ActualConfigType,
-      }),
-    );
-    expect(result.current).toBe(ApprovalMode.AUTO_EDIT);
-    expect(mockConfigInstance.getApprovalMode).toHaveBeenCalledTimes(1);
-  });
-
-  it('should initialize with ApprovalMode.DEFAULT if config.getApprovalMode returns ApprovalMode.DEFAULT', () => {
-    mockConfigInstance.getApprovalMode.mockReturnValue(ApprovalMode.DEFAULT);
-    const { result } = renderHook(() =>
-      useAutoAcceptIndicator({
-        config: mockConfigInstance as unknown as ActualConfigType,
-      }),
-    );
-    expect(result.current).toBe(ApprovalMode.DEFAULT);
-    expect(mockConfigInstance.getApprovalMode).toHaveBeenCalledTimes(1);
-  });
-
-  it('should initialize with ApprovalMode.YOLO if config.getApprovalMode returns ApprovalMode.YOLO', () => {
-    mockConfigInstance.getApprovalMode.mockReturnValue(ApprovalMode.YOLO);
-    const { result } = renderHook(() =>
-      useAutoAcceptIndicator({
-        config: mockConfigInstance as unknown as ActualConfigType,
-      }),
-    );
-    expect(result.current).toBe(ApprovalMode.YOLO);
-    expect(mockConfigInstance.getApprovalMode).toHaveBeenCalledTimes(1);
-  });
-
-  it('should toggle the indicator and update config when Shift+Tab or Ctrl+Y is pressed', () => {
-    mockConfigInstance.getApprovalMode.mockReturnValue(ApprovalMode.DEFAULT);
-    const { result } = renderHook(() =>
-      useAutoAcceptIndicator({
-        config: mockConfigInstance as unknown as ActualConfigType,
-      }),
-    );
-    expect(result.current).toBe(ApprovalMode.DEFAULT);
-
-    act(() => {
-      capturedUseKeypressHandler({
-        name: 'tab',
-        shift: true,
-      } as Key);
-    });
-    expect(mockConfigInstance.setApprovalMode).toHaveBeenCalledWith(
-      ApprovalMode.AUTO_EDIT,
-    );
-    expect(result.current).toBe(ApprovalMode.AUTO_EDIT);
-
-    act(() => {
-      capturedUseKeypressHandler({ name: 'y', ctrl: true } as Key);
-    });
-    expect(mockConfigInstance.setApprovalMode).toHaveBeenCalledWith(
-      ApprovalMode.YOLO,
-    );
-    expect(result.current).toBe(ApprovalMode.YOLO);
-
-    act(() => {
-      capturedUseKeypressHandler({ name: 'y', ctrl: true } as Key);
-    });
-    expect(mockConfigInstance.setApprovalMode).toHaveBeenCalledWith(
-      ApprovalMode.DEFAULT,
-    );
-    expect(result.current).toBe(ApprovalMode.DEFAULT);
-
-    act(() => {
-      capturedUseKeypressHandler({ name: 'y', ctrl: true } as Key);
-    });
-    expect(mockConfigInstance.setApprovalMode).toHaveBeenCalledWith(
-      ApprovalMode.YOLO,
-    );
-    expect(result.current).toBe(ApprovalMode.YOLO);
-
-    act(() => {
-      capturedUseKeypressHandler({
-        name: 'tab',
-        shift: true,
-      } as Key);
-    });
-    expect(mockConfigInstance.setApprovalMode).toHaveBeenCalledWith(
-      ApprovalMode.AUTO_EDIT,
-    );
-    expect(result.current).toBe(ApprovalMode.AUTO_EDIT);
-
-    act(() => {
-      capturedUseKeypressHandler({
-        name: 'tab',
-        shift: true,
-      } as Key);
-    });
-    expect(mockConfigInstance.setApprovalMode).toHaveBeenCalledWith(
-      ApprovalMode.DEFAULT,
-    );
-    expect(result.current).toBe(ApprovalMode.DEFAULT);
-  });
-
-  it('should not toggle if only one key or other keys combinations are pressed', () => {
-    mockConfigInstance.getApprovalMode.mockReturnValue(ApprovalMode.DEFAULT);
-    renderHook(() =>
-      useAutoAcceptIndicator({
-        config: mockConfigInstance as unknown as ActualConfigType,
-      }),
-    );
-
-    act(() => {
-      capturedUseKeypressHandler({
-        name: 'tab',
-        shift: false,
-      } as Key);
-    });
-    expect(mockConfigInstance.setApprovalMode).not.toHaveBeenCalled();
-
-    act(() => {
-      capturedUseKeypressHandler({
-        name: 'unknown',
-        shift: true,
-      } as Key);
-    });
-    expect(mockConfigInstance.setApprovalMode).not.toHaveBeenCalled();
-
-    act(() => {
-      capturedUseKeypressHandler({
-        name: 'a',
-        shift: false,
-        ctrl: false,
-      } as Key);
-    });
-    expect(mockConfigInstance.setApprovalMode).not.toHaveBeenCalled();
-
-    act(() => {
-      capturedUseKeypressHandler({ name: 'y', ctrl: false } as Key);
-    });
-    expect(mockConfigInstance.setApprovalMode).not.toHaveBeenCalled();
-
-    act(() => {
-      capturedUseKeypressHandler({ name: 'a', ctrl: true } as Key);
-    });
-    expect(mockConfigInstance.setApprovalMode).not.toHaveBeenCalled();
-
-    act(() => {
-      capturedUseKeypressHandler({ name: 'y', shift: true } as Key);
-    });
-    expect(mockConfigInstance.setApprovalMode).not.toHaveBeenCalled();
-
-    act(() => {
-      capturedUseKeypressHandler({
-        name: 'a',
-        ctrl: true,
-        shift: true,
-      } as Key);
-    });
-    expect(mockConfigInstance.setApprovalMode).not.toHaveBeenCalled();
-  });
-
-  it('should update indicator when config value changes externally (useEffect dependency)', () => {
-    mockConfigInstance.getApprovalMode.mockReturnValue(ApprovalMode.DEFAULT);
-    const { result, rerender } = renderHook(
-      (props: { config: ActualConfigType }) => useAutoAcceptIndicator(props),
-      {
-        initialProps: {
-          config: mockConfigInstance as unknown as ActualConfigType,
-        },
-      },
-    );
-    expect(result.current).toBe(ApprovalMode.DEFAULT);
-
-    mockConfigInstance.getApprovalMode.mockReturnValue(ApprovalMode.AUTO_EDIT);
-
-    rerender({ config: mockConfigInstance as unknown as ActualConfigType });
-    expect(result.current).toBe(ApprovalMode.AUTO_EDIT);
-    expect(mockConfigInstance.getApprovalMode).toHaveBeenCalledTimes(3);
-  });
-});