fss-link 1.0.40 → 1.0.45

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

@@ -0,0 +1,238 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+import { vi, describe, expect, it, afterEach, beforeEach } from 'vitest';
+import * as gitUtils from '../../utils/gitUtils.js';
+import {
+  setupGithubCommand,
+  updateGitignore,
+  GITHUB_WORKFLOW_PATHS,
+} from './setupGithubCommand.js';
+import { CommandContext, ToolActionReturn } from './types.js';
+import * as commandUtils from '../utils/commandUtils.js';
+
+vi.mock('child_process');
+
+// Mock fetch globally
+global.fetch = vi.fn();
+
+vi.mock('../../utils/gitUtils.js', () => ({
+  isGitHubRepository: vi.fn(),
+  getGitRepoRoot: vi.fn(),
+  getLatestGitHubRelease: vi.fn(),
+  getGitHubRepoInfo: vi.fn(),
+}));
+
+vi.mock('../utils/commandUtils.js', () => ({
+  getUrlOpenCommand: vi.fn(),
+}));
+
+describe('setupGithubCommand', async () => {
+  let scratchDir = '';
+
+  beforeEach(async () => {
+    vi.resetAllMocks();
+    scratchDir = await fs.mkdtemp(
+      path.join(os.tmpdir(), 'setup-github-command-'),
+    );
+  });
+
+  afterEach(async () => {
+    vi.restoreAllMocks();
+    if (scratchDir) await fs.rm(scratchDir, { recursive: true });
+  });
+
+  it('returns a tool action to download github workflows and handles paths', async () => {
+    const fakeRepoOwner = 'fake';
+    const fakeRepoName = 'repo';
+    const fakeRepoRoot = scratchDir;
+    const fakeReleaseVersion = 'v1.2.3';
+
+    const workflows = GITHUB_WORKFLOW_PATHS.map((p) => path.basename(p));
+    for (const workflow of workflows) {
+      vi.mocked(global.fetch).mockReturnValueOnce(
+        Promise.resolve(new Response(workflow)),
+      );
+    }
+
+    vi.mocked(gitUtils.isGitHubRepository).mockReturnValueOnce(true);
+    vi.mocked(gitUtils.getGitRepoRoot).mockReturnValueOnce(fakeRepoRoot);
+    vi.mocked(gitUtils.getLatestGitHubRelease).mockResolvedValueOnce(
+      fakeReleaseVersion,
+    );
+    vi.mocked(gitUtils.getGitHubRepoInfo).mockReturnValue({
+      owner: fakeRepoOwner,
+      repo: fakeRepoName,
+    });
+    vi.mocked(commandUtils.getUrlOpenCommand).mockReturnValueOnce(
+      'fakeOpenCommand',
+    );
+
+    const result = (await setupGithubCommand.action?.(
+      {} as CommandContext,
+      '',
+    )) as ToolActionReturn;
+
+    const { command } = result.toolArgs;
+
+    const expectedSubstrings = [
+      `set -eEuo pipefail`,
+      `fakeOpenCommand "https://github.com/google-github-actions/run-gemini-cli`,
+    ];
+
+    for (const substring of expectedSubstrings) {
+      expect(command).toContain(substring);
+    }
+
+    for (const workflow of workflows) {
+      const workflowFile = path.join(
+        scratchDir,
+        '.github',
+        'workflows',
+        workflow,
+      );
+      const contents = await fs.readFile(workflowFile, 'utf8');
+      expect(contents).toContain(workflow);
+    }
+
+    // Verify that .gitignore was created with the expected entries
+    const gitignorePath = path.join(scratchDir, '.gitignore');
+    const gitignoreExists = await fs
+      .access(gitignorePath)
+      .then(() => true)
+      .catch(() => false);
+    expect(gitignoreExists).toBe(true);
+
+    if (gitignoreExists) {
+      const gitignoreContent = await fs.readFile(gitignorePath, 'utf8');
+      expect(gitignoreContent).toContain('.gemini/');
+      expect(gitignoreContent).toContain('gha-creds-*.json');
+    }
+  });
+});
+
+describe('updateGitignore', () => {
+  let scratchDir = '';
+
+  beforeEach(async () => {
+    scratchDir = await fs.mkdtemp(path.join(os.tmpdir(), 'update-gitignore-'));
+  });
+
+  afterEach(async () => {
+    if (scratchDir) await fs.rm(scratchDir, { recursive: true });
+  });
+
+  it('creates a new .gitignore file when none exists', async () => {
+    await updateGitignore(scratchDir);
+
+    const gitignorePath = path.join(scratchDir, '.gitignore');
+    const content = await fs.readFile(gitignorePath, 'utf8');
+
+    expect(content).toBe('.gemini/\ngha-creds-*.json\n');
+  });
+
+  it('appends entries to existing .gitignore file', async () => {
+    const gitignorePath = path.join(scratchDir, '.gitignore');
+    const existingContent = '# Existing content\nnode_modules/\n';
+    await fs.writeFile(gitignorePath, existingContent);
+
+    await updateGitignore(scratchDir);
+
+    const content = await fs.readFile(gitignorePath, 'utf8');
+
+    expect(content).toBe(
+      '# Existing content\nnode_modules/\n\n.gemini/\ngha-creds-*.json\n',
+    );
+  });
+
+  it('does not add duplicate entries', async () => {
+    const gitignorePath = path.join(scratchDir, '.gitignore');
+    const existingContent = '.gemini/\nsome-other-file\ngha-creds-*.json\n';
+    await fs.writeFile(gitignorePath, existingContent);
+
+    await updateGitignore(scratchDir);
+
+    const content = await fs.readFile(gitignorePath, 'utf8');
+
+    expect(content).toBe(existingContent);
+  });
+
+  it('adds only missing entries when some already exist', async () => {
+    const gitignorePath = path.join(scratchDir, '.gitignore');
+    const existingContent = '.gemini/\nsome-other-file\n';
+    await fs.writeFile(gitignorePath, existingContent);
+
+    await updateGitignore(scratchDir);
+
+    const content = await fs.readFile(gitignorePath, 'utf8');
+
+    // Should add only the missing gha-creds-*.json entry
+    expect(content).toBe('.gemini/\nsome-other-file\n\ngha-creds-*.json\n');
+    expect(content).toContain('gha-creds-*.json');
+    // Should not duplicate .gemini/ entry
+    expect((content.match(/\.gemini\//g) || []).length).toBe(1);
+  });
+
+  it('does not get confused by entries in comments or as substrings', async () => {
+    const gitignorePath = path.join(scratchDir, '.gitignore');
+    const existingContent = [
+      '# This is a comment mentioning .gemini/ folder',
+      'my-app.gemini/config',
+      '# Another comment with gha-creds-*.json pattern',
+      'some-other-gha-creds-file.json',
+      '',
+    ].join('\n');
+    await fs.writeFile(gitignorePath, existingContent);
+
+    await updateGitignore(scratchDir);
+
+    const content = await fs.readFile(gitignorePath, 'utf8');
+
+    // Should add both entries since they don't actually exist as gitignore rules
+    expect(content).toContain('.gemini/');
+    expect(content).toContain('gha-creds-*.json');
+
+    // Verify the entries were added (not just mentioned in comments)
+    const lines = content
+      .split('\n')
+      .map((line) => line.split('#')[0].trim())
+      .filter((line) => line);
+    expect(lines).toContain('.gemini/');
+    expect(lines).toContain('gha-creds-*.json');
+    expect(lines).toContain('my-app.gemini/config');
+    expect(lines).toContain('some-other-gha-creds-file.json');
+  });
+
+  it('handles file system errors gracefully', async () => {
+    // Try to update gitignore in a non-existent directory
+    const nonExistentDir = path.join(scratchDir, 'non-existent');
+
+    // This should not throw an error
+    await expect(updateGitignore(nonExistentDir)).resolves.toBeUndefined();
+  });
+
+  it('handles permission errors gracefully', async () => {
+    const consoleSpy = vi.spyOn(console, 'debug').mockImplementation(() => {});
+
+    const fsModule = await import('node:fs');
+    const writeFileSpy = vi
+      .spyOn(fsModule.promises, 'writeFile')
+      .mockRejectedValue(new Error('Permission denied'));
+
+    await expect(updateGitignore(scratchDir)).resolves.toBeUndefined();
+    expect(consoleSpy).toHaveBeenCalledWith(
+      'Failed to update .gitignore:',
+      expect.any(Error),
+    );
+
+    writeFileSpy.mockRestore();
+    consoleSpy.mockRestore();
+  });
+});

package/dist/ui/commands/setupGithubCommand.ts

@@ -0,0 +1,212 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import path from 'node:path';
+import * as fs from 'node:fs';
+import { Writable } from 'node:stream';
+import { ProxyAgent } from 'undici';
+
+import { CommandContext } from '../../ui/commands/types.js';
+import {
+  getGitRepoRoot,
+  getLatestGitHubRelease,
+  isGitHubRepository,
+  getGitHubRepoInfo,
+} from '../../utils/gitUtils.js';
+
+import {
+  CommandKind,
+  SlashCommand,
+  SlashCommandActionReturn,
+} from './types.js';
+import { getUrlOpenCommand } from '../../ui/utils/commandUtils.js';
+
+export const GITHUB_WORKFLOW_PATHS = [
+  'gemini-dispatch/gemini-dispatch.yml',
+  'gemini-assistant/gemini-invoke.yml',
+  'issue-triage/gemini-triage.yml',
+  'issue-triage/gemini-scheduled-triage.yml',
+  'pr-review/gemini-review.yml',
+];
+
+// Generate OS-specific commands to open the GitHub pages needed for setup.
+function getOpenUrlsCommands(readmeUrl: string): string[] {
+  // Determine the OS-specific command to open URLs, ex: 'open', 'xdg-open', etc
+  const openCmd = getUrlOpenCommand();
+
+  // Build a list of URLs to open
+  const urlsToOpen = [readmeUrl];
+
+  const repoInfo = getGitHubRepoInfo();
+  if (repoInfo) {
+    urlsToOpen.push(
+      `https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/secrets/actions`,
+    );
+  }
+
+  // Create and join the individual commands
+  const commands = urlsToOpen.map((url) => `${openCmd} "${url}"`);
+  return commands;
+}
+
+// Add Gemini CLI specific entries to .gitignore file
+export async function updateGitignore(gitRepoRoot: string): Promise<void> {
+  const gitignoreEntries = ['.gemini/', 'gha-creds-*.json'];
+
+  const gitignorePath = path.join(gitRepoRoot, '.gitignore');
+  try {
+    // Check if .gitignore exists and read its content
+    let existingContent = '';
+    let fileExists = true;
+    try {
+      existingContent = await fs.promises.readFile(gitignorePath, 'utf8');
+    } catch (_error) {
+      // File doesn't exist
+      fileExists = false;
+    }
+
+    if (!fileExists) {
+      // Create new .gitignore file with the entries
+      const contentToWrite = gitignoreEntries.join('\n') + '\n';
+      await fs.promises.writeFile(gitignorePath, contentToWrite);
+    } else {
+      // Check which entries are missing
+      const missingEntries = gitignoreEntries.filter(
+        (entry) =>
+          !existingContent
+            .split(/\r?\n/)
+            .some((line) => line.split('#')[0].trim() === entry),
+      );
+
+      if (missingEntries.length > 0) {
+        const contentToAdd = '\n' + missingEntries.join('\n') + '\n';
+        await fs.promises.appendFile(gitignorePath, contentToAdd);
+      }
+    }
+  } catch (error) {
+    console.debug('Failed to update .gitignore:', error);
+    // Continue without failing the whole command
+  }
+}
+
+export const setupGithubCommand: SlashCommand = {
+  name: 'setup-github',
+  description: 'Set up GitHub Actions',
+  kind: CommandKind.BUILT_IN,
+  action: async (
+    context: CommandContext,
+  ): Promise<SlashCommandActionReturn> => {
+    const abortController = new AbortController();
+
+    if (!isGitHubRepository()) {
+      throw new Error(
+        'Unable to determine the GitHub repository. /setup-github must be run from a git repository.',
+      );
+    }
+
+    // Find the root directory of the repo
+    let gitRepoRoot: string;
+    try {
+      gitRepoRoot = getGitRepoRoot();
+    } catch (_error) {
+      console.debug(`Failed to get git repo root:`, _error);
+      throw new Error(
+        'Unable to determine the GitHub repository. /setup-github must be run from a git repository.',
+      );
+    }
+
+    // Get the latest release tag from GitHub
+    const proxy = context?.services?.config?.getProxy();
+    const releaseTag = await getLatestGitHubRelease(proxy);
+    const readmeUrl = `https://github.com/google-github-actions/run-gemini-cli/blob/${releaseTag}/README.md#quick-start`;
+
+    // Create the .github/workflows directory to download the files into
+    const githubWorkflowsDir = path.join(gitRepoRoot, '.github', 'workflows');
+    try {
+      await fs.promises.mkdir(githubWorkflowsDir, { recursive: true });
+    } catch (_error) {
+      console.debug(
+        `Failed to create ${githubWorkflowsDir} directory:`,
+        _error,
+      );
+      throw new Error(
+        `Unable to create ${githubWorkflowsDir} directory. Do you have file permissions in the current directory?`,
+      );
+    }
+
+    // Download each workflow in parallel - there aren't enough files to warrant
+    // a full workerpool model here.
+    const downloads = [];
+    for (const workflow of GITHUB_WORKFLOW_PATHS) {
+      downloads.push(
+        (async () => {
+          const endpoint = `https://raw.githubusercontent.com/google-github-actions/run-gemini-cli/refs/tags/${releaseTag}/examples/workflows/${workflow}`;
+          const response = await fetch(endpoint, {
+            method: 'GET',
+            dispatcher: proxy ? new ProxyAgent(proxy) : undefined,
+            signal: AbortSignal.any([
+              AbortSignal.timeout(30_000),
+              abortController.signal,
+            ]),
+          } as RequestInit);
+
+          if (!response.ok) {
+            throw new Error(
+              `Invalid response code downloading ${endpoint}: ${response.status} - ${response.statusText}`,
+            );
+          }
+          const body = response.body;
+          if (!body) {
+            throw new Error(
+              `Empty body while downloading ${endpoint}: ${response.status} - ${response.statusText}`,
+            );
+          }
+
+          const destination = path.resolve(
+            githubWorkflowsDir,
+            path.basename(workflow),
+          );
+
+          const fileStream = fs.createWriteStream(destination, {
+            mode: 0o644, // -rw-r--r--, user(rw), group(r), other(r)
+            flags: 'w', // write and overwrite
+            flush: true,
+          });
+
+          await body.pipeTo(Writable.toWeb(fileStream));
+        })(),
+      );
+    }
+
+    // Wait for all downloads to complete
+    await Promise.all(downloads).finally(() => {
+      // Stop existing downloads
+      abortController.abort();
+    });
+
+    // Add entries to .gitignore file
+    await updateGitignore(gitRepoRoot);
+
+    // Print out a message
+    const commands = [];
+    commands.push('set -eEuo pipefail');
+    commands.push(
+      `echo "Successfully downloaded ${GITHUB_WORKFLOW_PATHS.length} workflows and updated .gitignore. Follow the steps in ${readmeUrl} (skipping the /setup-github step) to complete setup."`,
+    );
+    commands.push(...getOpenUrlsCommands(readmeUrl));
+
+    const command = `(${commands.join(' && ')})`;
+    return {
+      type: 'tool',
+      toolName: 'run_shell_command',
+      toolArgs: {
+        description:
+          'Setting up GitHub Actions to triage issues and review PRs with Gemini.',
+        command,
+      },
+    };
+  },
+};

package/dist/ui/commands/speakCommand.ts

@@ -0,0 +1,175 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { CommandKind, SlashCommand } from './types.js';
+import { MessageType } from '../types.js';
+
+// Simple text cleaning for speech synthesis
+function cleanTextForSpeech(text: string): string {
+  let cleaned = text.trim();
+  
+  // Conservative approach - only remove obvious machine-generated garbage
+  cleaned = cleaned.replace(/\b[a-f0-9]{16,}\b/gi, 'hash'); // Only very long hashes
+  cleaned = cleaned.replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, 'UUID'); // UUIDs
+  
+  // Clean up markdown formatting for speech
+  cleaned = cleaned.replace(/```[\s\S]*?```/g, 'code block');
+  cleaned = cleaned.replace(/`([^`]+)`/g, '$1');
+  cleaned = cleaned.replace(/\*\*([^*]+)\*\*/g, '$1');
+  cleaned = cleaned.replace(/\*([^*]+)\*/g, '$1');
+  
+  // Clean excessive whitespace
+  cleaned = cleaned.replace(/\s+/g, ' ').trim();
+  
+  return cleaned;
+}
+
+interface TTSProgress {
+  setPhase: (phase: 'cleaning' | 'sending' | 'processing' | 'speaking' | 'completed' | 'error') => void;
+  setError: (error: string) => void;
+}
+
+async function executeSpeech(text: string, voice?: string, progress?: TTSProgress): Promise<void> {
+  try {
+    // Phase 1: Text cleaning
+    progress?.setPhase('cleaning');
+    await new Promise(resolve => setTimeout(resolve, 300)); // Brief delay to show animation
+    const cleanedText = cleanTextForSpeech(text);
+    
+    // Phase 2: Sending to server
+    progress?.setPhase('sending');
+    await new Promise(resolve => setTimeout(resolve, 200));
+    
+    const response = await fetch('http://192.168.1.5:11450/api/v1/synthesize', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        text: cleanedText,
+        voice: voice || 'Bella',
+        format: 'wav',
+        output_mode: 'computer'
+      }),
+    });
+    
+    if (!response.ok) {
+      progress?.setError(`Server returned ${response.status}: ${response.statusText}`);
+      progress?.setPhase('error');
+      return;
+    }
+    
+    // Phase 3: Processing response
+    progress?.setPhase('processing');
+    await response.json(); // Process the response
+    await new Promise(resolve => setTimeout(resolve, 400));
+    
+    // Phase 4: Speaking (simulate audio duration)
+    progress?.setPhase('speaking');
+    const estimatedDuration = Math.max(1000, Math.min(text.length * 50, 5000));
+    await new Promise(resolve => setTimeout(resolve, estimatedDuration));
+    
+    // Phase 5: Completed
+    progress?.setPhase('completed');
+    
+  } catch (error) {
+    progress?.setError(error instanceof Error ? error.message : 'Unknown error');
+    progress?.setPhase('error');
+  }
+}
+
+// Voice personality emojis
+const VOICE_EMOJIS: Record<string, string> = {
+  'Bella': '👩‍💼',
+  'Emma': '👩‍🎨', 
+  'George': '👨‍🔧',
+  'Lewis': '👨‍💻',
+  'Sarah': '👩‍🏫',
+  'Michael': '👨‍⚖️'
+};
+
+export const speakCommand: SlashCommand = {
+  name: 'speak',
+  description: 'speak text using text-to-speech',
+  kind: CommandKind.BUILT_IN,
+  action: async (context, args) => {
+    const text = args.trim();
+    
+    // Basic validation
+    if (!text) {
+      context.ui.addItem(
+        {
+          type: MessageType.ERROR,
+          text: '❌ Usage: /speak "your message here"',
+        },
+        Date.now()
+      );
+      return;
+    }
+    
+    if (text.length > 1000) {
+      context.ui.addItem(
+        {
+          type: MessageType.INFO,
+          text: '⚠️ Text too long (max 1000 chars), will be truncated',
+        },
+        Date.now()
+      );
+    }
+    
+    const voice = context.session.ttsVoice || 'Bella';
+    const voiceEmoji = VOICE_EMOJIS[voice] || '🗣️';
+    const truncatedText = text.length > 1000 ? text.substring(0, 1000) : text;
+    
+    // Create progress tracker
+    let errorMessage = '';
+    
+    // Simple progress indicators - just loading bar and icons
+    const updateProgress = (phase: string, error?: string) => {
+      const phaseConfig: Record<string, {icon: string, bar: string}> = {
+        cleaning: { icon: '🧹', bar: '▓░░░░' },
+        sending: { icon: '📡', bar: '▓▓░░░' },
+        processing: { icon: '⚙️', bar: '▓▓▓░░' },
+        speaking: { icon: '🎵', bar: '▓▓▓▓░' },
+        completed: { icon: '✅', bar: '▓▓▓▓▓' },
+        error: { icon: '❌', bar: '░░░░░' }
+      };
+      
+      const config = phaseConfig[phase] || phaseConfig['cleaning'];
+      let statusText = `${config.icon} ${config.bar} ${voiceEmoji}`;
+      
+      if (error && phase === 'error') {
+        statusText += ` ${error}`;
+      }
+      
+      context.ui.addItem(
+        {
+          type: phase === 'error' ? MessageType.ERROR : MessageType.INFO,
+          text: statusText,
+        },
+        Date.now()
+      );
+    };
+    
+    // Initial progress display
+    updateProgress('cleaning');
+    
+    // Execute speech with rich progress tracking
+    const progress: TTSProgress = {
+      setPhase: (phase) => {
+        updateProgress(phase, errorMessage);
+      },
+      setError: (error) => {
+        errorMessage = error;
+      }
+    };
+    
+    // Execute in background with progress updates
+    executeSpeech(truncatedText, voice, progress).catch(() => {
+      // Error handling is done through progress callbacks
+    });
+  },
+};

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

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { statsCommand } from './statsCommand.js';
+import { type CommandContext } from './types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import { MessageType } from '../types.js';
+import { formatDuration } from '../utils/formatters.js';
+
+describe('statsCommand', () => {
+  let mockContext: CommandContext;
+  const startTime = new Date('2025-07-14T10:00:00.000Z');
+  const endTime = new Date('2025-07-14T10:00:30.000Z');
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(endTime);
+
+    // 1. Create the mock context with all default values
+    mockContext = createMockCommandContext();
+
+    // 2. Directly set the property on the created mock context
+    mockContext.session.stats.sessionStartTime = startTime;
+  });
+
+  it('should display general session stats when run with no subcommand', () => {
+    if (!statsCommand.action) throw new Error('Command has no action');
+
+    statsCommand.action(mockContext, '');
+
+    const expectedDuration = formatDuration(
+      endTime.getTime() - startTime.getTime(),
+    );
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      {
+        type: MessageType.STATS,
+        duration: expectedDuration,
+      },
+      expect.any(Number),
+    );
+  });
+
+  it('should display model stats when using the "model" subcommand', () => {
+    const modelSubCommand = statsCommand.subCommands?.find(
+      (sc) => sc.name === 'model',
+    );
+    if (!modelSubCommand?.action) throw new Error('Subcommand has no action');
+
+    modelSubCommand.action(mockContext, '');
+
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      {
+        type: MessageType.MODEL_STATS,
+      },
+      expect.any(Number),
+    );
+  });
+
+  it('should display tool stats when using the "tools" subcommand', () => {
+    const toolsSubCommand = statsCommand.subCommands?.find(
+      (sc) => sc.name === 'tools',
+    );
+    if (!toolsSubCommand?.action) throw new Error('Subcommand has no action');
+
+    toolsSubCommand.action(mockContext, '');
+
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      {
+        type: MessageType.TOOL_STATS,
+      },
+      expect.any(Number),
+    );
+  });
+});