fss-link 1.0.49 → 1.0.51

package/dist/ui/hooks/useReactToolScheduler.ts

@@ -1,309 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {
-  Config,
-  ToolCallRequestInfo,
-  ExecutingToolCall,
-  ScheduledToolCall,
-  ValidatingToolCall,
-  WaitingToolCall,
-  CompletedToolCall,
-  CancelledToolCall,
-  CoreToolScheduler,
-  OutputUpdateHandler,
-  AllToolCallsCompleteHandler,
-  ToolCallsUpdateHandler,
-  ToolCall,
-  Status as CoreStatus,
-  EditorType,
-} from 'fss-link-core';
-import { useCallback, useState, useMemo } from 'react';
-import {
-  HistoryItemToolGroup,
-  IndividualToolCallDisplay,
-  ToolCallStatus,
-  HistoryItemWithoutId,
-} from '../types.js';
-
-export type ScheduleFn = (
-  request: ToolCallRequestInfo | ToolCallRequestInfo[],
-  signal: AbortSignal,
-) => void;
-export type MarkToolsAsSubmittedFn = (callIds: string[]) => void;
-
-export type TrackedScheduledToolCall = ScheduledToolCall & {
-  responseSubmittedToGemini?: boolean;
-};
-export type TrackedValidatingToolCall = ValidatingToolCall & {
-  responseSubmittedToGemini?: boolean;
-};
-export type TrackedWaitingToolCall = WaitingToolCall & {
-  responseSubmittedToGemini?: boolean;
-};
-export type TrackedExecutingToolCall = ExecutingToolCall & {
-  responseSubmittedToGemini?: boolean;
-};
-export type TrackedCompletedToolCall = CompletedToolCall & {
-  responseSubmittedToGemini?: boolean;
-};
-export type TrackedCancelledToolCall = CancelledToolCall & {
-  responseSubmittedToGemini?: boolean;
-};
-
-export type TrackedToolCall =
-  | TrackedScheduledToolCall
-  | TrackedValidatingToolCall
-  | TrackedWaitingToolCall
-  | TrackedExecutingToolCall
-  | TrackedCompletedToolCall
-  | TrackedCancelledToolCall;
-
-export function useReactToolScheduler(
-  onComplete: (tools: CompletedToolCall[]) => Promise<void>,
-  config: Config,
-  setPendingHistoryItem: React.Dispatch<
-    React.SetStateAction<HistoryItemWithoutId | null>
-  >,
-  getPreferredEditor: () => EditorType | undefined,
-  onEditorClose: () => void,
-): [TrackedToolCall[], ScheduleFn, MarkToolsAsSubmittedFn] {
-  const [toolCallsForDisplay, setToolCallsForDisplay] = useState<
-    TrackedToolCall[]
-  >([]);
-
-  const outputUpdateHandler: OutputUpdateHandler = useCallback(
-    (toolCallId, outputChunk) => {
-      setPendingHistoryItem((prevItem) => {
-        if (prevItem?.type === 'tool_group') {
-          return {
-            ...prevItem,
-            tools: prevItem.tools.map((toolDisplay) =>
-              toolDisplay.callId === toolCallId &&
-              toolDisplay.status === ToolCallStatus.Executing
-                ? { ...toolDisplay, resultDisplay: outputChunk }
-                : toolDisplay,
-            ),
-          };
-        }
-        return prevItem;
-      });
-
-      setToolCallsForDisplay((prevCalls) =>
-        prevCalls.map((tc) => {
-          if (tc.request.callId === toolCallId && tc.status === 'executing') {
-            const executingTc = tc as TrackedExecutingToolCall;
-            return { ...executingTc, liveOutput: outputChunk };
-          }
-          return tc;
-        }),
-      );
-    },
-    [setPendingHistoryItem],
-  );
-
-  const allToolCallsCompleteHandler: AllToolCallsCompleteHandler = useCallback(
-    async (completedToolCalls) => {
-      await onComplete(completedToolCalls);
-    },
-    [onComplete],
-  );
-
-  const toolCallsUpdateHandler: ToolCallsUpdateHandler = useCallback(
-    (updatedCoreToolCalls: ToolCall[]) => {
-      setToolCallsForDisplay((prevTrackedCalls) =>
-        updatedCoreToolCalls.map((coreTc) => {
-          const existingTrackedCall = prevTrackedCalls.find(
-            (ptc) => ptc.request.callId === coreTc.request.callId,
-          );
-          const newTrackedCall: TrackedToolCall = {
-            ...coreTc,
-            responseSubmittedToGemini:
-              existingTrackedCall?.responseSubmittedToGemini ?? false,
-          } as TrackedToolCall;
-          return newTrackedCall;
-        }),
-      );
-    },
-    [setToolCallsForDisplay],
-  );
-
-  const scheduler = useMemo(
-    () =>
-      new CoreToolScheduler({
-        toolRegistry: config.getToolRegistry(),
-        outputUpdateHandler,
-        onAllToolCallsComplete: allToolCallsCompleteHandler,
-        onToolCallsUpdate: toolCallsUpdateHandler,
-        getPreferredEditor,
-        config,
-        onEditorClose,
-      }),
-    [
-      config,
-      outputUpdateHandler,
-      allToolCallsCompleteHandler,
-      toolCallsUpdateHandler,
-      getPreferredEditor,
-      onEditorClose,
-    ],
-  );
-
-  const schedule: ScheduleFn = useCallback(
-    (
-      request: ToolCallRequestInfo | ToolCallRequestInfo[],
-      signal: AbortSignal,
-    ) => {
-      void scheduler.schedule(request, signal);
-    },
-    [scheduler],
-  );
-
-  const markToolsAsSubmitted: MarkToolsAsSubmittedFn = useCallback(
-    (callIdsToMark: string[]) => {
-      setToolCallsForDisplay((prevCalls) =>
-        prevCalls.map((tc) =>
-          callIdsToMark.includes(tc.request.callId)
-            ? { ...tc, responseSubmittedToGemini: true }
-            : tc,
-        ),
-      );
-    },
-    [],
-  );
-
-  return [toolCallsForDisplay, schedule, markToolsAsSubmitted];
-}
-
-/**
- * Maps a CoreToolScheduler status to the UI's ToolCallStatus enum.
- */
-function mapCoreStatusToDisplayStatus(coreStatus: CoreStatus): ToolCallStatus {
-  switch (coreStatus) {
-    case 'validating':
-      return ToolCallStatus.Executing;
-    case 'awaiting_approval':
-      return ToolCallStatus.Confirming;
-    case 'executing':
-      return ToolCallStatus.Executing;
-    case 'success':
-      return ToolCallStatus.Success;
-    case 'cancelled':
-      return ToolCallStatus.Canceled;
-    case 'error':
-      return ToolCallStatus.Error;
-    case 'scheduled':
-      return ToolCallStatus.Pending;
-    default: {
-      const exhaustiveCheck: never = coreStatus;
-      console.warn(`Unknown core status encountered: ${exhaustiveCheck}`);
-      return ToolCallStatus.Error;
-    }
-  }
-}
-
-/**
- * Transforms `TrackedToolCall` objects into `HistoryItemToolGroup` objects for UI display.
- */
-export function mapToDisplay(
-  toolOrTools: TrackedToolCall[] | TrackedToolCall,
-): HistoryItemToolGroup {
-  const toolCalls = Array.isArray(toolOrTools) ? toolOrTools : [toolOrTools];
-
-  const toolDisplays = toolCalls.map(
-    (trackedCall): IndividualToolCallDisplay => {
-      let displayName: string;
-      let description: string;
-      let renderOutputAsMarkdown = false;
-
-      if (trackedCall.status === 'error') {
-        displayName =
-          trackedCall.tool === undefined
-            ? trackedCall.request.name
-            : trackedCall.tool.displayName;
-        description = JSON.stringify(trackedCall.request.args);
-      } else {
-        displayName = trackedCall.tool.displayName;
-        description = trackedCall.invocation.getDescription();
-        renderOutputAsMarkdown = trackedCall.tool.isOutputMarkdown;
-      }
-
-      const baseDisplayProperties: Omit<
-        IndividualToolCallDisplay,
-        'status' | 'resultDisplay' | 'confirmationDetails'
-      > = {
-        callId: trackedCall.request.callId,
-        name: displayName,
-        description,
-        renderOutputAsMarkdown,
-      };
-
-      switch (trackedCall.status) {
-        case 'success':
-          return {
-            ...baseDisplayProperties,
-            status: mapCoreStatusToDisplayStatus(trackedCall.status),
-            resultDisplay: trackedCall.response.resultDisplay,
-            confirmationDetails: undefined,
-          };
-        case 'error':
-          return {
-            ...baseDisplayProperties,
-            status: mapCoreStatusToDisplayStatus(trackedCall.status),
-            resultDisplay: trackedCall.response.resultDisplay,
-            confirmationDetails: undefined,
-          };
-        case 'cancelled':
-          return {
-            ...baseDisplayProperties,
-            status: mapCoreStatusToDisplayStatus(trackedCall.status),
-            resultDisplay: trackedCall.response.resultDisplay,
-            confirmationDetails: undefined,
-          };
-        case 'awaiting_approval':
-          return {
-            ...baseDisplayProperties,
-            status: mapCoreStatusToDisplayStatus(trackedCall.status),
-            resultDisplay: undefined,
-            confirmationDetails: trackedCall.confirmationDetails,
-          };
-        case 'executing':
-          return {
-            ...baseDisplayProperties,
-            status: mapCoreStatusToDisplayStatus(trackedCall.status),
-            resultDisplay:
-              (trackedCall as TrackedExecutingToolCall).liveOutput ?? undefined,
-            confirmationDetails: undefined,
-          };
-        case 'validating': // Fallthrough
-        case 'scheduled':
-          return {
-            ...baseDisplayProperties,
-            status: mapCoreStatusToDisplayStatus(trackedCall.status),
-            resultDisplay: undefined,
-            confirmationDetails: undefined,
-          };
-        default: {
-          const exhaustiveCheck: never = trackedCall;
-          return {
-            callId: (exhaustiveCheck as TrackedToolCall).request.callId,
-            name: 'Unknown Tool',
-            description: 'Encountered an unknown tool call state.',
-            status: ToolCallStatus.Error,
-            resultDisplay: 'Unknown tool call state',
-            confirmationDetails: undefined,
-            renderOutputAsMarkdown: false,
-          };
-        }
-      }
-    },
-  );
-
-  return {
-    type: 'tool_group',
-    tools: toolDisplays,
-  };
-}

package/dist/ui/hooks/useRefreshMemoryCommand.ts

@@ -1,7 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-export const REFRESH_MEMORY_COMMAND_NAME = '/refreshmemory';

package/dist/ui/hooks/useReverseSearchCompletion.test.tsx

@@ -1,260 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/** @vitest-environment jsdom */
-
-import { describe, it, expect } from 'vitest';
-import { renderHook, act } from '@testing-library/react';
-import { useReverseSearchCompletion } from './useReverseSearchCompletion.js';
-import { useTextBuffer } from '../components/shared/text-buffer.js';
-
-describe('useReverseSearchCompletion', () => {
-  function useTextBufferForTest(text: string) {
-    return useTextBuffer({
-      initialText: text,
-      initialCursorOffset: text.length,
-      viewport: { width: 80, height: 20 },
-      isValidPath: () => false,
-      onChange: () => {},
-    });
-  }
-
-  describe('Core Hook Behavior', () => {
-    describe('State Management', () => {
-      it('should initialize with default state', () => {
-        const mockShellHistory = ['echo hello'];
-
-        const { result } = renderHook(() =>
-          useReverseSearchCompletion(
-            useTextBufferForTest(''),
-            mockShellHistory,
-            false,
-          ),
-        );
-
-        expect(result.current.suggestions).toEqual([]);
-        expect(result.current.activeSuggestionIndex).toBe(-1);
-        expect(result.current.visibleStartIndex).toBe(0);
-        expect(result.current.showSuggestions).toBe(false);
-        expect(result.current.isLoadingSuggestions).toBe(false);
-      });
-
-      it('should reset state when reverseSearchActive becomes false', () => {
-        const mockShellHistory = ['echo hello'];
-        const { result, rerender } = renderHook(
-          ({ text, active }) => {
-            const textBuffer = useTextBufferForTest(text);
-            return useReverseSearchCompletion(
-              textBuffer,
-              mockShellHistory,
-              active,
-            );
-          },
-          { initialProps: { text: 'echo', active: true } },
-        );
-
-        // Simulate reverseSearchActive becoming false
-        rerender({ text: 'echo', active: false });
-
-        expect(result.current.suggestions).toEqual([]);
-        expect(result.current.activeSuggestionIndex).toBe(-1);
-        expect(result.current.visibleStartIndex).toBe(0);
-        expect(result.current.showSuggestions).toBe(false);
-      });
-
-      describe('Navigation', () => {
-        it('should handle navigateUp with no suggestions', () => {
-          const mockShellHistory = ['echo hello'];
-
-          const { result } = renderHook(() =>
-            useReverseSearchCompletion(
-              useTextBufferForTest('grep'),
-              mockShellHistory,
-              true,
-            ),
-          );
-
-          act(() => {
-            result.current.navigateUp();
-          });
-
-          expect(result.current.activeSuggestionIndex).toBe(-1);
-        });
-
-        it('should handle navigateDown with no suggestions', () => {
-          const mockShellHistory = ['echo hello'];
-          const { result } = renderHook(() =>
-            useReverseSearchCompletion(
-              useTextBufferForTest('grep'),
-              mockShellHistory,
-              true,
-            ),
-          );
-
-          act(() => {
-            result.current.navigateDown();
-          });
-
-          expect(result.current.activeSuggestionIndex).toBe(-1);
-        });
-
-        it('should navigate up through suggestions with wrap-around', () => {
-          const mockShellHistory = [
-            'ls -l',
-            'ls -la',
-            'cd /some/path',
-            'git status',
-            'echo "Hello, World!"',
-            'echo Hi',
-          ];
-
-          const { result } = renderHook(() =>
-            useReverseSearchCompletion(
-              useTextBufferForTest('echo'),
-              mockShellHistory,
-              true,
-            ),
-          );
-
-          expect(result.current.suggestions.length).toBe(2);
-          expect(result.current.activeSuggestionIndex).toBe(0);
-
-          act(() => {
-            result.current.navigateUp();
-          });
-
-          expect(result.current.activeSuggestionIndex).toBe(1);
-        });
-
-        it('should navigate down through suggestions with wrap-around', () => {
-          const mockShellHistory = [
-            'ls -l',
-            'ls -la',
-            'cd /some/path',
-            'git status',
-            'echo "Hello, World!"',
-            'echo Hi',
-          ];
-          const { result } = renderHook(() =>
-            useReverseSearchCompletion(
-              useTextBufferForTest('ls'),
-              mockShellHistory,
-              true,
-            ),
-          );
-
-          expect(result.current.suggestions.length).toBe(2);
-          expect(result.current.activeSuggestionIndex).toBe(0);
-
-          act(() => {
-            result.current.navigateDown();
-          });
-
-          expect(result.current.activeSuggestionIndex).toBe(1);
-        });
-
-        it('should handle navigation with multiple suggestions', () => {
-          const mockShellHistory = [
-            'ls -l',
-            'ls -la',
-            'cd /some/path/l',
-            'git status',
-            'echo "Hello, World!"',
-            'echo "Hi all"',
-          ];
-
-          const { result } = renderHook(() =>
-            useReverseSearchCompletion(
-              useTextBufferForTest('l'),
-              mockShellHistory,
-              true,
-            ),
-          );
-
-          expect(result.current.suggestions.length).toBe(5);
-          expect(result.current.activeSuggestionIndex).toBe(0);
-
-          act(() => {
-            result.current.navigateDown();
-          });
-          expect(result.current.activeSuggestionIndex).toBe(1);
-
-          act(() => {
-            result.current.navigateDown();
-          });
-          expect(result.current.activeSuggestionIndex).toBe(2);
-
-          act(() => {
-            result.current.navigateUp();
-          });
-          expect(result.current.activeSuggestionIndex).toBe(1);
-
-          act(() => {
-            result.current.navigateUp();
-          });
-          expect(result.current.activeSuggestionIndex).toBe(0);
-
-          act(() => {
-            result.current.navigateUp();
-          });
-          expect(result.current.activeSuggestionIndex).toBe(4);
-        });
-
-        it('should handle navigation with large suggestion lists and scrolling', () => {
-          const largeMockCommands = Array.from(
-            { length: 15 },
-            (_, i) => `echo ${i}`,
-          );
-
-          const { result } = renderHook(() =>
-            useReverseSearchCompletion(
-              useTextBufferForTest('echo'),
-              largeMockCommands,
-              true,
-            ),
-          );
-
-          expect(result.current.suggestions.length).toBe(15);
-          expect(result.current.activeSuggestionIndex).toBe(0);
-          expect(result.current.visibleStartIndex).toBe(0);
-
-          act(() => {
-            result.current.navigateUp();
-          });
-
-          expect(result.current.activeSuggestionIndex).toBe(14);
-          expect(result.current.visibleStartIndex).toBe(Math.max(0, 15 - 8));
-        });
-      });
-    });
-  });
-
-  describe('Filtering', () => {
-    it('filters history by buffer.text and sets showSuggestions', () => {
-      const history = ['foo', 'barfoo', 'baz'];
-      const { result } = renderHook(() =>
-        useReverseSearchCompletion(useTextBufferForTest('foo'), history, true),
-      );
-
-      // should only return the two entries containing "foo"
-      expect(result.current.suggestions.map((s) => s.value)).toEqual([
-        'foo',
-        'barfoo',
-      ]);
-      expect(result.current.showSuggestions).toBe(true);
-    });
-
-    it('hides suggestions when there are no matches', () => {
-      const history = ['alpha', 'beta'];
-      const { result } = renderHook(() =>
-        useReverseSearchCompletion(useTextBufferForTest('γ'), history, true),
-      );
-
-      expect(result.current.suggestions).toEqual([]);
-      expect(result.current.showSuggestions).toBe(false);
-    });
-  });
-});

package/dist/ui/hooks/useReverseSearchCompletion.tsx

@@ -1,95 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { useEffect, useCallback } from 'react';
-import { useCompletion } from './useCompletion.js';
-import { TextBuffer } from '../components/shared/text-buffer.js';
-import { Suggestion } from '../components/SuggestionsDisplay.js';
-
-export interface UseReverseSearchCompletionReturn {
-  suggestions: Suggestion[];
-  activeSuggestionIndex: number;
-  visibleStartIndex: number;
-  showSuggestions: boolean;
-  isLoadingSuggestions: boolean;
-  navigateUp: () => void;
-  navigateDown: () => void;
-  handleAutocomplete: (i: number) => void;
-  resetCompletionState: () => void;
-}
-
-export function useReverseSearchCompletion(
-  buffer: TextBuffer,
-  shellHistory: readonly string[],
-  reverseSearchActive: boolean,
-): UseReverseSearchCompletionReturn {
-  const {
-    suggestions,
-    activeSuggestionIndex,
-    visibleStartIndex,
-    showSuggestions,
-    isLoadingSuggestions,
-
-    setSuggestions,
-    setShowSuggestions,
-    setActiveSuggestionIndex,
-    resetCompletionState,
-    navigateUp,
-    navigateDown,
-  } = useCompletion();
-
-  useEffect(() => {
-    if (!reverseSearchActive) {
-      resetCompletionState();
-    }
-  }, [reverseSearchActive, resetCompletionState]);
-
-  useEffect(() => {
-    if (!reverseSearchActive) {
-      return;
-    }
-
-    const q = buffer.text.toLowerCase();
-    const matches = shellHistory.reduce<Suggestion[]>((acc, cmd) => {
-      const idx = cmd.toLowerCase().indexOf(q);
-      if (idx !== -1) {
-        acc.push({ label: cmd, value: cmd, matchedIndex: idx });
-      }
-      return acc;
-    }, []);
-    setSuggestions(matches);
-    setShowSuggestions(matches.length > 0);
-    setActiveSuggestionIndex(matches.length > 0 ? 0 : -1);
-  }, [
-    buffer.text,
-    shellHistory,
-    reverseSearchActive,
-    setActiveSuggestionIndex,
-    setShowSuggestions,
-    setSuggestions,
-  ]);
-
-  const handleAutocomplete = useCallback(
-    (i: number) => {
-      if (i < 0 || i >= suggestions.length) return;
-      buffer.setText(suggestions[i].value);
-      resetCompletionState();
-    },
-    [buffer, suggestions, resetCompletionState],
-  );
-
-  return {
-    suggestions,
-    activeSuggestionIndex,
-    visibleStartIndex,
-    showSuggestions,
-    isLoadingSuggestions,
-    navigateUp,
-    navigateDown,
-    handleAutocomplete,
-    resetCompletionState,
-  };
-}

package/dist/ui/hooks/useSettingsCommand.ts

@@ -1,25 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { useState, useCallback } from 'react';
-
-export function useSettingsCommand() {
-  const [isSettingsDialogOpen, setIsSettingsDialogOpen] = useState(false);
-
-  const openSettingsDialog = useCallback(() => {
-    setIsSettingsDialogOpen(true);
-  }, []);
-
-  const closeSettingsDialog = useCallback(() => {
-    setIsSettingsDialogOpen(false);
-  }, []);
-
-  return {
-    isSettingsDialogOpen,
-    openSettingsDialog,
-    closeSettingsDialog,
-  };
-}