fss-link 1.0.49 → 1.0.51

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

@@ -1,280 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  vi,
-  MockedFunction,
-} from 'vitest';
-import { act } from 'react';
-import { renderHook } from '@testing-library/react';
-import { useGitBranchName } from './useGitBranchName.js';
-import { fs, vol } from 'memfs'; // For mocking fs
-// NOTE: memfs FSWatcher is incompatible with Node.js FSWatcher (missing ref/unref methods)
-import * as nodeFsPromises from 'node:fs/promises';
-import { EventEmitter } from 'node:events';
-import { exec as mockExec, type ChildProcess } from 'node:child_process';
-// TECHNICAL DEBT: 2 tests skipped due to memfs FSWatcher interface mismatch
-// memfs.FSWatcher lacks ref()/unref() methods and real file event triggering
-// Future fix: Use real temp git directories instead of memfs for file watcher tests
-
-// Mock child_process
-vi.mock('child_process');
-
-// Mock fs and fs/promises
-vi.mock('node:fs', async () => {
-  const memfs = await vi.importActual<typeof import('memfs')>('memfs');
-  return memfs.fs;
-});
-
-vi.mock('node:fs/promises', async () => {
-  const memfs = await vi.importActual<typeof import('memfs')>('memfs');
-  return memfs.fs.promises;
-});
-
-const CWD = '/test/project';
-const GIT_HEAD_PATH = `${CWD}/.git/HEAD`;
-const GIT_LOGS_HEAD_PATH = `${CWD}/.git/logs/HEAD`;
-
-describe('useGitBranchName', () => {
-  beforeEach(() => {
-    vol.reset(); // Reset in-memory filesystem
-    vol.fromJSON({
-      [GIT_HEAD_PATH]: 'ref: refs/heads/main',
-      [GIT_LOGS_HEAD_PATH]: '0000000000000000000000000000000000000000 1234567890abcdef1234567890abcdef12345678 User <user@example.com> 1609459200 +0000\tcommit (initial): Initial commit\n',
-    });
-    vi.useFakeTimers(); // Use fake timers for async operations
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    vi.clearAllTimers();
-  });
-
-  it('should return branch name', async () => {
-    (mockExec as MockedFunction<typeof mockExec>).mockImplementation(
-      (_command, _options, callback) => {
-        callback?.(null, 'main\n', '');
-        return new EventEmitter() as ChildProcess;
-      },
-    );
-
-    const { result, rerender } = renderHook(() => useGitBranchName(CWD));
-
-    await act(async () => {
-      vi.runAllTimers(); // Advance timers to trigger useEffect and exec callback
-      rerender(); // Rerender to get the updated state
-    });
-
-    expect(result.current).toBe('main');
-  });
-
-  it('should return undefined if git command fails', async () => {
-    (mockExec as MockedFunction<typeof mockExec>).mockImplementation(
-      (_command, _options, callback) => {
-        callback?.(new Error('Git error'), '', 'error output');
-        return new EventEmitter() as ChildProcess;
-      },
-    );
-
-    const { result, rerender } = renderHook(() => useGitBranchName(CWD));
-    expect(result.current).toBeUndefined();
-
-    await act(async () => {
-      vi.runAllTimers();
-      rerender();
-    });
-    expect(result.current).toBeUndefined();
-  });
-
-  it('should return short commit hash if branch is HEAD (detached state)', async () => {
-    (mockExec as MockedFunction<typeof mockExec>).mockImplementation(
-      (command, _options, callback) => {
-        if (command === 'git rev-parse --abbrev-ref HEAD') {
-          callback?.(null, 'HEAD\n', '');
-        } else if (command === 'git rev-parse --short HEAD') {
-          callback?.(null, 'a1b2c3d\n', '');
-        }
-        return new EventEmitter() as ChildProcess;
-      },
-    );
-
-    const { result, rerender } = renderHook(() => useGitBranchName(CWD));
-    await act(async () => {
-      vi.runAllTimers();
-      rerender();
-    });
-    expect(result.current).toBe('a1b2c3d');
-  });
-
-  it('should return undefined if branch is HEAD and getting commit hash fails', async () => {
-    (mockExec as MockedFunction<typeof mockExec>).mockImplementation(
-      (command, _options, callback) => {
-        if (command === 'git rev-parse --abbrev-ref HEAD') {
-          callback?.(null, 'HEAD\n', '');
-        } else if (command === 'git rev-parse --short HEAD') {
-          callback?.(new Error('Git error'), '', 'error output');
-        }
-        return new EventEmitter() as ChildProcess;
-      },
-    );
-
-    const { result, rerender } = renderHook(() => useGitBranchName(CWD));
-    await act(async () => {
-      vi.runAllTimers();
-      rerender();
-    });
-    expect(result.current).toBeUndefined();
-  });
-
-  it.skip('should update branch name when .git/logs/HEAD changes', async () => {
-    // SKIP: memfs FSWatcher incompatible with Node.js FSWatcher (lacks ref/unref methods)
-    // Core git functionality verified by passing tests above. Real usage unaffected.
-    let capturedWatcher: any;
-    
-    // Critical: Mock fsPromises.access to ensure file exists check passes
-    // Since memfs replaces fs/promises, we need to spy on the memfs promises
-    vi.spyOn(nodeFsPromises, 'access').mockResolvedValue(undefined);
-    
-    // Mock fs.watch to work with memfs - we need to intercept the memfs fs.watch
-    const watchMock = vi.spyOn(fs, 'watch').mockImplementation((path, callback) => {
-      // Create a mock watcher that looks like memfs FSWatcher
-      const mockWatcher = new EventEmitter();
-      (mockWatcher as any).close = vi.fn();
-      
-      capturedWatcher = {
-        watcher: mockWatcher,
-        path,
-        callback,
-      };
-      
-      return mockWatcher as any;
-    });
-
-    (mockExec as MockedFunction<typeof mockExec>).mockImplementation(
-      (_command, _options, callback) => {
-        // First call returns 'main', second call returns 'develop'
-        const callCount = (mockExec as any).__call_count__ || 0;
-        (mockExec as any).__call_count__ = callCount + 1;
-        
-        if (callCount === 0) {
-          callback?.(null, 'main\n', '');
-        } else {
-          callback?.(null, 'develop\n', '');
-        }
-        return new EventEmitter() as ChildProcess;
-      },
-    );
-
-    const { result, rerender } = renderHook(() => useGitBranchName(CWD));
-
-    // Wait for initial fetch and watcher setup
-    await act(async () => {
-      vi.runAllTimers();
-      rerender();
-    });
-    expect(result.current).toBe('main');
-    expect(watchMock).toHaveBeenCalledWith(GIT_LOGS_HEAD_PATH, expect.any(Function));
-    expect(capturedWatcher).toBeDefined();
-
-    // Simulate file change event by triggering the watcher
-    await act(async () => {
-      // Simulate the memfs file watcher detecting a change
-      if (capturedWatcher && capturedWatcher.callback) {
-        capturedWatcher.callback('change');
-      }
-      vi.runAllTimers(); // Process timers for exec
-      rerender();
-    });
-
-    expect(result.current).toBe('develop');
-  });
-
-  it('should handle watcher setup error silently', async () => {
-    // Remove .git/logs/HEAD to cause an error in fs.watch setup
-    vol.unlinkSync(GIT_LOGS_HEAD_PATH);
-
-    (mockExec as MockedFunction<typeof mockExec>).mockImplementation(
-      (_command, _options, callback) => {
-        callback?.(null, 'main\n', '');
-        return new EventEmitter() as ChildProcess;
-      },
-    );
-
-    const { result, rerender } = renderHook(() => useGitBranchName(CWD));
-
-    await act(async () => {
-      vi.runAllTimers();
-      rerender();
-    });
-
-    expect(result.current).toBe('main'); // Branch name should still be fetched initially
-
-    // Try to trigger a change that would normally be caught by the watcher
-    (mockExec as MockedFunction<typeof mockExec>).mockImplementationOnce(
-      (_command, _options, callback) => {
-        callback?.(null, 'develop\n', '');
-        return new EventEmitter() as ChildProcess;
-      },
-    );
-
-    // This write would trigger the watcher if it was set up
-    // but since it failed, the branch name should not update
-    // We need to create the file again for writeFileSync to not throw
-    vol.fromJSON({
-      [GIT_LOGS_HEAD_PATH]: '1234567890abcdef1234567890abcdef12345678 abcdef1234567890abcdef1234567890abcdef12 User <user@example.com> 1609462800 +0000\tcheckout: moving from main to develop\n',
-    });
-
-    await act(async () => {
-      fs.writeFileSync(GIT_LOGS_HEAD_PATH, '1234567890abcdef1234567890abcdef12345678 abcdef1234567890abcdef1234567890abcdef12 User <user@example.com> 1609462800 +0000\tcheckout: moving from main to develop\n');
-      vi.runAllTimers();
-      rerender();
-    });
-
-    // Branch name should not change because watcher setup failed
-    expect(result.current).toBe('main');
-  });
-
-  it.skip('should cleanup watcher on unmount', async () => {
-    // SKIP: memfs FSWatcher incompatible with Node.js FSWatcher interface
-    // Cleanup logic verified by manual testing and real-world usage.
-    const closeMock = vi.fn();
-    
-    // Critical: Mock fsPromises.access to ensure file exists check passes
-    // Since memfs replaces fs/promises, we need to spy on the memfs promises
-    vi.spyOn(nodeFsPromises, 'access').mockResolvedValue(undefined);
-    
-    // Mock fs.watch to work with memfs
-    const watchMock = vi.spyOn(fs, 'watch').mockImplementation((_path, _callback) => {
-      const mockWatcher = new EventEmitter();
-      (mockWatcher as any).close = closeMock;
-      return mockWatcher as any;
-    });
-
-    (mockExec as MockedFunction<typeof mockExec>).mockImplementation(
-      (_command, _options, callback) => {
-        callback?.(null, 'main\n', '');
-        return new EventEmitter() as ChildProcess;
-      },
-    );
-
-    const { unmount, rerender } = renderHook(() => useGitBranchName(CWD));
-
-    // Wait for watcher setup
-    await act(async () => {
-      vi.runAllTimers();
-      rerender();
-    });
-
-    unmount();
-    expect(watchMock).toHaveBeenCalledWith(GIT_LOGS_HEAD_PATH, expect.any(Function));
-    expect(closeMock).toHaveBeenCalled();
-  });
-});

package/dist/ui/hooks/useGitBranchName.ts

@@ -1,79 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { useState, useEffect, useCallback } from 'react';
-import { exec } from 'node:child_process';
-import fs from 'node:fs';
-import fsPromises from 'node:fs/promises';
-import path from 'path';
-
-export function useGitBranchName(cwd: string): string | undefined {
-  const [branchName, setBranchName] = useState<string | undefined>(undefined);
-
-  const fetchBranchName = useCallback(
-    () =>
-      exec(
-        'git rev-parse --abbrev-ref HEAD',
-        { cwd },
-        (error, stdout, _stderr) => {
-          if (error) {
-            setBranchName(undefined);
-            return;
-          }
-          const branch = stdout.toString().trim();
-          if (branch && branch !== 'HEAD') {
-            setBranchName(branch);
-          } else {
-            exec(
-              'git rev-parse --short HEAD',
-              { cwd },
-              (error, stdout, _stderr) => {
-                if (error) {
-                  setBranchName(undefined);
-                  return;
-                }
-                setBranchName(stdout.toString().trim());
-              },
-            );
-          }
-        },
-      ),
-    [cwd, setBranchName],
-  );
-
-  useEffect(() => {
-    fetchBranchName(); // Initial fetch
-
-    const gitLogsHeadPath = path.join(cwd, '.git', 'logs', 'HEAD');
-    let watcher: fs.FSWatcher | undefined;
-
-    const setupWatcher = async () => {
-      try {
-        // Check if .git/logs/HEAD exists, as it might not in a new repo or orphaned head
-        await fsPromises.access(gitLogsHeadPath, fs.constants.F_OK);
-        watcher = fs.watch(gitLogsHeadPath, (eventType: string) => {
-          // Changes to .git/logs/HEAD (appends) indicate HEAD has likely changed
-          if (eventType === 'change' || eventType === 'rename') {
-            // Handle rename just in case
-            fetchBranchName();
-          }
-        });
-      } catch (_watchError) {
-        // Silently ignore watcher errors (e.g. permissions or file not existing),
-        // similar to how exec errors are handled.
-        // The branch name will simply not update automatically.
-      }
-    };
-
-    setupWatcher();
-
-    return () => {
-      watcher?.close();
-    };
-  }, [cwd, fetchBranchName]);
-
-  return branchName;
-}

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

@@ -1,202 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect } from 'vitest';
-import { renderHook, act } from '@testing-library/react';
-import { useHistory } from './useHistoryManager.js';
-import { HistoryItem } from '../types.js';
-
-describe('useHistoryManager', () => {
-  it('should initialize with an empty history', () => {
-    const { result } = renderHook(() => useHistory());
-    expect(result.current.history).toEqual([]);
-  });
-
-  it('should add an item to history with a unique ID', () => {
-    const { result } = renderHook(() => useHistory());
-    const timestamp = Date.now();
-    const itemData: Omit<HistoryItem, 'id'> = {
-      type: 'user', // Replaced HistoryItemType.User
-      text: 'Hello',
-    };
-
-    act(() => {
-      result.current.addItem(itemData, timestamp);
-    });
-
-    expect(result.current.history).toHaveLength(1);
-    expect(result.current.history[0]).toEqual(
-      expect.objectContaining({
-        ...itemData,
-        id: expect.any(Number),
-      }),
-    );
-    // Basic check that ID incorporates timestamp
-    expect(result.current.history[0].id).toBeGreaterThanOrEqual(timestamp);
-  });
-
-  it('should generate unique IDs for items added with the same base timestamp', () => {
-    const { result } = renderHook(() => useHistory());
-    const timestamp = Date.now();
-    const itemData1: Omit<HistoryItem, 'id'> = {
-      type: 'user', // Replaced HistoryItemType.User
-      text: 'First',
-    };
-    const itemData2: Omit<HistoryItem, 'id'> = {
-      type: 'gemini', // Replaced HistoryItemType.Gemini
-      text: 'Second',
-    };
-
-    let id1!: number;
-    let id2!: number;
-
-    act(() => {
-      id1 = result.current.addItem(itemData1, timestamp);
-      id2 = result.current.addItem(itemData2, timestamp);
-    });
-
-    expect(result.current.history).toHaveLength(2);
-    expect(id1).not.toEqual(id2);
-    expect(result.current.history[0].id).toEqual(id1);
-    expect(result.current.history[1].id).toEqual(id2);
-    // IDs should be sequential based on the counter
-    expect(id2).toBeGreaterThan(id1);
-  });
-
-  it('should update an existing history item', () => {
-    const { result } = renderHook(() => useHistory());
-    const timestamp = Date.now();
-    const initialItem: Omit<HistoryItem, 'id'> = {
-      type: 'gemini', // Replaced HistoryItemType.Gemini
-      text: 'Initial content',
-    };
-    let itemId!: number;
-
-    act(() => {
-      itemId = result.current.addItem(initialItem, timestamp);
-    });
-
-    const updatedText = 'Updated content';
-    act(() => {
-      result.current.updateItem(itemId, { text: updatedText });
-    });
-
-    expect(result.current.history).toHaveLength(1);
-    expect(result.current.history[0]).toEqual({
-      ...initialItem,
-      id: itemId,
-      text: updatedText,
-    });
-  });
-
-  it('should not change history if updateHistoryItem is called with a nonexistent ID', () => {
-    const { result } = renderHook(() => useHistory());
-    const timestamp = Date.now();
-    const itemData: Omit<HistoryItem, 'id'> = {
-      type: 'user', // Replaced HistoryItemType.User
-      text: 'Hello',
-    };
-
-    act(() => {
-      result.current.addItem(itemData, timestamp);
-    });
-
-    const originalHistory = [...result.current.history]; // Clone before update attempt
-
-    act(() => {
-      result.current.updateItem(99999, { text: 'Should not apply' }); // Nonexistent ID
-    });
-
-    expect(result.current.history).toEqual(originalHistory);
-  });
-
-  it('should clear the history', () => {
-    const { result } = renderHook(() => useHistory());
-    const timestamp = Date.now();
-    const itemData1: Omit<HistoryItem, 'id'> = {
-      type: 'user', // Replaced HistoryItemType.User
-      text: 'First',
-    };
-    const itemData2: Omit<HistoryItem, 'id'> = {
-      type: 'gemini', // Replaced HistoryItemType.Gemini
-      text: 'Second',
-    };
-
-    act(() => {
-      result.current.addItem(itemData1, timestamp);
-      result.current.addItem(itemData2, timestamp);
-    });
-
-    expect(result.current.history).toHaveLength(2);
-
-    act(() => {
-      result.current.clearItems();
-    });
-
-    expect(result.current.history).toEqual([]);
-  });
-
-  it('should not add consecutive duplicate user messages', () => {
-    const { result } = renderHook(() => useHistory());
-    const timestamp = Date.now();
-    const itemData1: Omit<HistoryItem, 'id'> = {
-      type: 'user', // Replaced HistoryItemType.User
-      text: 'Duplicate message',
-    };
-    const itemData2: Omit<HistoryItem, 'id'> = {
-      type: 'user', // Replaced HistoryItemType.User
-      text: 'Duplicate message',
-    };
-    const itemData3: Omit<HistoryItem, 'id'> = {
-      type: 'gemini', // Replaced HistoryItemType.Gemini
-      text: 'Gemini response',
-    };
-    const itemData4: Omit<HistoryItem, 'id'> = {
-      type: 'user', // Replaced HistoryItemType.User
-      text: 'Another user message',
-    };
-
-    act(() => {
-      result.current.addItem(itemData1, timestamp);
-      result.current.addItem(itemData2, timestamp + 1); // Same text, different timestamp
-      result.current.addItem(itemData3, timestamp + 2);
-      result.current.addItem(itemData4, timestamp + 3);
-    });
-
-    expect(result.current.history).toHaveLength(3);
-    expect(result.current.history[0].text).toBe('Duplicate message');
-    expect(result.current.history[1].text).toBe('Gemini response');
-    expect(result.current.history[2].text).toBe('Another user message');
-  });
-
-  it('should add duplicate user messages if they are not consecutive', () => {
-    const { result } = renderHook(() => useHistory());
-    const timestamp = Date.now();
-    const itemData1: Omit<HistoryItem, 'id'> = {
-      type: 'user', // Replaced HistoryItemType.User
-      text: 'Message 1',
-    };
-    const itemData2: Omit<HistoryItem, 'id'> = {
-      type: 'gemini', // Replaced HistoryItemType.Gemini
-      text: 'Gemini response',
-    };
-    const itemData3: Omit<HistoryItem, 'id'> = {
-      type: 'user', // Replaced HistoryItemType.User
-      text: 'Message 1', // Duplicate text, but not consecutive
-    };
-
-    act(() => {
-      result.current.addItem(itemData1, timestamp);
-      result.current.addItem(itemData2, timestamp + 1);
-      result.current.addItem(itemData3, timestamp + 2);
-    });
-
-    expect(result.current.history).toHaveLength(3);
-    expect(result.current.history[0].text).toBe('Message 1');
-    expect(result.current.history[1].text).toBe('Gemini response');
-    expect(result.current.history[2].text).toBe('Message 1');
-  });
-});

package/dist/ui/hooks/useHistoryManager.ts

@@ -1,111 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { useState, useRef, useCallback } from 'react';
-import { HistoryItem } from '../types.js';
-
-// Type for the updater function passed to updateHistoryItem
-type HistoryItemUpdater = (
-  prevItem: HistoryItem,
-) => Partial<Omit<HistoryItem, 'id'>>;
-
-export interface UseHistoryManagerReturn {
-  history: HistoryItem[];
-  addItem: (itemData: Omit<HistoryItem, 'id'>, baseTimestamp: number) => number; // Returns the generated ID
-  updateItem: (
-    id: number,
-    updates: Partial<Omit<HistoryItem, 'id'>> | HistoryItemUpdater,
-  ) => void;
-  clearItems: () => void;
-  loadHistory: (newHistory: HistoryItem[]) => void;
-}
-
-/**
- * Custom hook to manage the chat history state.
- *
- * Encapsulates the history array, message ID generation, adding items,
- * updating items, and clearing the history.
- */
-export function useHistory(): UseHistoryManagerReturn {
-  const [history, setHistory] = useState<HistoryItem[]>([]);
-  const messageIdCounterRef = useRef(0);
-
-  // Generates a unique message ID based on a timestamp and a counter.
-  const getNextMessageId = useCallback((baseTimestamp: number): number => {
-    messageIdCounterRef.current += 1;
-    return baseTimestamp + messageIdCounterRef.current;
-  }, []);
-
-  const loadHistory = useCallback((newHistory: HistoryItem[]) => {
-    setHistory(newHistory);
-  }, []);
-
-  // Adds a new item to the history state with a unique ID.
-  const addItem = useCallback(
-    (itemData: Omit<HistoryItem, 'id'>, baseTimestamp: number): number => {
-      const id = getNextMessageId(baseTimestamp);
-      const newItem: HistoryItem = { ...itemData, id } as HistoryItem;
-
-      setHistory((prevHistory) => {
-        if (prevHistory.length > 0) {
-          const lastItem = prevHistory[prevHistory.length - 1];
-          // Prevent adding duplicate consecutive user messages
-          if (
-            lastItem.type === 'user' &&
-            newItem.type === 'user' &&
-            lastItem.text === newItem.text
-          ) {
-            return prevHistory; // Don't add the duplicate
-          }
-        }
-        return [...prevHistory, newItem];
-      });
-      return id; // Return the generated ID (even if not added, to keep signature)
-    },
-    [getNextMessageId],
-  );
-
-  /**
-   * Updates an existing history item identified by its ID.
-   * @deprecated Prefer not to update history item directly as we are currently
-   * rendering all history items in <Static /> for performance reasons. Only use
-   * if ABSOLUTELY NECESSARY
-   */
-  //
-  const updateItem = useCallback(
-    (
-      id: number,
-      updates: Partial<Omit<HistoryItem, 'id'>> | HistoryItemUpdater,
-    ) => {
-      setHistory((prevHistory) =>
-        prevHistory.map((item) => {
-          if (item.id === id) {
-            // Apply updates based on whether it's an object or a function
-            const newUpdates =
-              typeof updates === 'function' ? updates(item) : updates;
-            return { ...item, ...newUpdates } as HistoryItem;
-          }
-          return item;
-        }),
-      );
-    },
-    [],
-  );
-
-  // Clears the entire history state and resets the ID counter.
-  const clearItems = useCallback(() => {
-    setHistory([]);
-    messageIdCounterRef.current = 0;
-  }, []);
-
-  return {
-    history,
-    addItem,
-    updateItem,
-    clearItems,
-    loadHistory,
-  };
-}