fss-link 1.0.49 → 1.0.51

package/dist/ui/utils/TableRenderer.tsx

@@ -1,159 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import React from 'react';
-import { Text, Box } from 'ink';
-import { Colors } from '../colors.js';
-import { RenderInline, getPlainTextLength } from './InlineMarkdownRenderer.js';
-
-interface TableRendererProps {
-  headers: string[];
-  rows: string[][];
-  terminalWidth: number;
-}
-
-/**
- * Custom table renderer for markdown tables
- * We implement our own instead of using ink-table due to module compatibility issues
- */
-export const TableRenderer: React.FC<TableRendererProps> = ({
-  headers,
-  rows,
-  terminalWidth,
-}) => {
-  // Calculate column widths using actual display width after markdown processing
-  const columnWidths = headers.map((header, index) => {
-    const headerWidth = getPlainTextLength(header);
-    const maxRowWidth = Math.max(
-      ...rows.map((row) => getPlainTextLength(row[index] || '')),
-    );
-    return Math.max(headerWidth, maxRowWidth) + 2; // Add padding
-  });
-
-  // Ensure table fits within terminal width
-  const totalWidth = columnWidths.reduce((sum, width) => sum + width + 1, 1);
-  const scaleFactor =
-    totalWidth > terminalWidth ? terminalWidth / totalWidth : 1;
-  const adjustedWidths = columnWidths.map((width) =>
-    Math.floor(width * scaleFactor),
-  );
-
-  // Helper function to render a cell with proper width
-  const renderCell = (
-    content: string,
-    width: number,
-    isHeader = false,
-  ): React.ReactNode => {
-    const contentWidth = Math.max(0, width - 2);
-    const displayWidth = getPlainTextLength(content);
-
-    let cellContent = content;
-    if (displayWidth > contentWidth) {
-      if (contentWidth <= 3) {
-        // Just truncate by character count
-        cellContent = content.substring(
-          0,
-          Math.min(content.length, contentWidth),
-        );
-      } else {
-        // Truncate preserving markdown formatting using binary search
-        let left = 0;
-        let right = content.length;
-        let bestTruncated = content;
-
-        // Binary search to find the optimal truncation point
-        while (left <= right) {
-          const mid = Math.floor((left + right) / 2);
-          const candidate = content.substring(0, mid);
-          const candidateWidth = getPlainTextLength(candidate);
-
-          if (candidateWidth <= contentWidth - 3) {
-            bestTruncated = candidate;
-            left = mid + 1;
-          } else {
-            right = mid - 1;
-          }
-        }
-
-        cellContent = bestTruncated + '...';
-      }
-    }
-
-    // Calculate exact padding needed
-    const actualDisplayWidth = getPlainTextLength(cellContent);
-    const paddingNeeded = Math.max(0, contentWidth - actualDisplayWidth);
-
-    return (
-      <Text>
-        {isHeader ? (
-          <Text bold color={Colors.AccentCyan}>
-            <RenderInline text={cellContent} />
-          </Text>
-        ) : (
-          <RenderInline text={cellContent} />
-        )}
-        {' '.repeat(paddingNeeded)}
-      </Text>
-    );
-  };
-
-  // Helper function to render border
-  const renderBorder = (type: 'top' | 'middle' | 'bottom'): React.ReactNode => {
-    const chars = {
-      top: { left: '┌', middle: '┬', right: '┐', horizontal: '─' },
-      middle: { left: '├', middle: '┼', right: '┤', horizontal: '─' },
-      bottom: { left: '└', middle: '┴', right: '┘', horizontal: '─' },
-    };
-
-    const char = chars[type];
-    const borderParts = adjustedWidths.map((w) => char.horizontal.repeat(w));
-    const border = char.left + borderParts.join(char.middle) + char.right;
-
-    return <Text>{border}</Text>;
-  };
-
-  // Helper function to render a table row
-  const renderRow = (cells: string[], isHeader = false): React.ReactNode => {
-    const renderedCells = cells.map((cell, index) => {
-      const width = adjustedWidths[index] || 0;
-      return renderCell(cell || '', width, isHeader);
-    });
-
-    return (
-      <Text>
-        │{' '}
-        {renderedCells.map((cell, index) => (
-          <React.Fragment key={index}>
-            {cell}
-            {index < renderedCells.length - 1 ? ' │ ' : ''}
-          </React.Fragment>
-        ))}{' '}
-        │
-      </Text>
-    );
-  };
-
-  return (
-    <Box flexDirection="column" marginY={1}>
-      {/* Top border */}
-      {renderBorder('top')}
-
-      {/* Header row */}
-      {renderRow(headers, true)}
-
-      {/* Middle border */}
-      {renderBorder('middle')}
-
-      {/* Data rows */}
-      {rows.map((row, index) => (
-        <React.Fragment key={index}>{renderRow(row)}</React.Fragment>
-      ))}
-
-      {/* Bottom border */}
-      {renderBorder('bottom')}
-    </Box>
-  );
-};

package/dist/ui/utils/__snapshots__/MarkdownDisplay.test.tsx.snap

@@ -1,93 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`<MarkdownDisplay /> > correctly parses a mix of markdown elements 1`] = `
-"Main Title
-
-Here is a paragraph.
-
- - List item 1
- - List item 2
-
- 1 some code
-
-Another paragraph.
-"
-`;
-
-exports[`<MarkdownDisplay /> > handles a table at the end of the input 1`] = `
-"Some text before.
-| A | B |
-|---|
-| 1 | 2 |"
-`;
-
-exports[`<MarkdownDisplay /> > handles unclosed (pending) code blocks 1`] = `" 1 let y = 2;"`;
-
-exports[`<MarkdownDisplay /> > hides line numbers in code blocks when showLineNumbers is false 1`] = `" const x = 1;"`;
-
-exports[`<MarkdownDisplay /> > inserts a single space between paragraphs 1`] = `
-"Paragraph 1.
-
-Paragraph 2."
-`;
-
-exports[`<MarkdownDisplay /> > renders a fenced code block with a language 1`] = `
-" 1 const x = 1;
- 2 console.log(x);"
-`;
-
-exports[`<MarkdownDisplay /> > renders a fenced code block without a language 1`] = `" 1 plain text"`;
-
-exports[`<MarkdownDisplay /> > renders a simple paragraph 1`] = `"Hello, world."`;
-
-exports[`<MarkdownDisplay /> > renders headers with correct levels 1`] = `
-"Header 1
-Header 2
-Header 3
-Header 4
-"
-`;
-
-exports[`<MarkdownDisplay /> > renders horizontal rules 1`] = `
-"Hello
----
-World
----
-Test
-"
-`;
-
-exports[`<MarkdownDisplay /> > renders nested unordered lists 1`] = `
-" * Level 1
-   * Level 2
-     * Level 3
-"
-`;
-
-exports[`<MarkdownDisplay /> > renders nothing for empty text 1`] = `""`;
-
-exports[`<MarkdownDisplay /> > renders ordered lists 1`] = `
-" 1. First item
- 2. Second item
-"
-`;
-
-exports[`<MarkdownDisplay /> > renders tables correctly 1`] = `
-"
-┌──────────┬──────────┐
-│ Header 1 │ Header 2 │
-├──────────┼──────────┤
-│ Cell 1   │ Cell 2   │
-│ Cell 3   │ Cell 4   │
-└──────────┴──────────┘
-"
-`;
-
-exports[`<MarkdownDisplay /> > renders unordered lists with different markers 1`] = `
-" - item A
- * item B
- + item C
-"
-`;
-
-exports[`<MarkdownDisplay /> > shows line numbers in code blocks by default 1`] = `" 1 const x = 1;"`;

package/dist/ui/utils/clipboardUtils.test.ts

@@ -1,76 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  clipboardHasImage,
-  saveClipboardImage,
-  cleanupOldClipboardImages,
-} from './clipboardUtils.js';
-
-describe('clipboardUtils', () => {
-  describe('clipboardHasImage', () => {
-    it('should return false on non-macOS platforms', async () => {
-      if (process.platform !== 'darwin') {
-        const result = await clipboardHasImage();
-        expect(result).toBe(false);
-      } else {
-        // Skip on macOS as it would require actual clipboard state
-        expect(true).toBe(true);
-      }
-    });
-
-    it('should return boolean on macOS', async () => {
-      if (process.platform === 'darwin') {
-        const result = await clipboardHasImage();
-        expect(typeof result).toBe('boolean');
-      } else {
-        // Skip on non-macOS
-        expect(true).toBe(true);
-      }
-    });
-  });
-
-  describe('saveClipboardImage', () => {
-    it('should return null on non-macOS platforms', async () => {
-      if (process.platform !== 'darwin') {
-        const result = await saveClipboardImage();
-        expect(result).toBe(null);
-      } else {
-        // Skip on macOS
-        expect(true).toBe(true);
-      }
-    });
-
-    it('should handle errors gracefully', async () => {
-      // Test with invalid directory (should not throw)
-      const result = await saveClipboardImage(
-        '/invalid/path/that/does/not/exist',
-      );
-
-      if (process.platform === 'darwin') {
-        // On macOS, might return null due to various errors
-        expect(result === null || typeof result === 'string').toBe(true);
-      } else {
-        // On other platforms, should always return null
-        expect(result).toBe(null);
-      }
-    });
-  });
-
-  describe('cleanupOldClipboardImages', () => {
-    it('should not throw errors', async () => {
-      // Should handle missing directories gracefully
-      await expect(
-        cleanupOldClipboardImages('/path/that/does/not/exist'),
-      ).resolves.not.toThrow();
-    });
-
-    it('should complete without errors on valid directory', async () => {
-      await expect(cleanupOldClipboardImages('.')).resolves.not.toThrow();
-    });
-  });
-});

package/dist/ui/utils/clipboardUtils.ts

@@ -1,149 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-
-const execAsync = promisify(exec);
-
-/**
- * Checks if the system clipboard contains an image (macOS only for now)
- * @returns true if clipboard contains an image
- */
-export async function clipboardHasImage(): Promise<boolean> {
-  if (process.platform !== 'darwin') {
-    return false;
-  }
-
-  try {
-    // Use osascript to check clipboard type
-    const { stdout } = await execAsync(
-      `osascript -e 'clipboard info' 2>/dev/null | grep -qE "«class PNGf»|TIFF picture|JPEG picture|GIF picture|«class JPEG»|«class TIFF»" && echo "true" || echo "false"`,
-      { shell: '/bin/bash' },
-    );
-    return stdout.trim() === 'true';
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Saves the image from clipboard to a temporary file (macOS only for now)
- * @param targetDir The target directory to create temp files within
- * @returns The path to the saved image file, or null if no image or error
- */
-export async function saveClipboardImage(
-  targetDir?: string,
-): Promise<string | null> {
-  if (process.platform !== 'darwin') {
-    return null;
-  }
-
-  try {
-    // Create a temporary directory for clipboard images within the target directory
-    // This avoids security restrictions on paths outside the target directory
-    const baseDir = targetDir || process.cwd();
-    const tempDir = path.join(baseDir, '.gemini-clipboard');
-    await fs.mkdir(tempDir, { recursive: true });
-
-    // Generate a unique filename with timestamp
-    const timestamp = new Date().getTime();
-
-    // Try different image formats in order of preference
-    const formats = [
-      { class: 'PNGf', extension: 'png' },
-      { class: 'JPEG', extension: 'jpg' },
-      { class: 'TIFF', extension: 'tiff' },
-      { class: 'GIFf', extension: 'gif' },
-    ];
-
-    for (const format of formats) {
-      const tempFilePath = path.join(
-        tempDir,
-        `clipboard-${timestamp}.${format.extension}`,
-      );
-
-      // Try to save clipboard as this format
-      const script = `
-        try
-          set imageData to the clipboard as «class ${format.class}»
-          set fileRef to open for access POSIX file "${tempFilePath}" with write permission
-          write imageData to fileRef
-          close access fileRef
-          return "success"
-        on error errMsg
-          try
-            close access POSIX file "${tempFilePath}"
-          end try
-          return "error"
-        end try
-      `;
-
-      const { stdout } = await execAsync(`osascript -e '${script}'`);
-
-      if (stdout.trim() === 'success') {
-        // Verify the file was created and has content
-        try {
-          const stats = await fs.stat(tempFilePath);
-          if (stats.size > 0) {
-            return tempFilePath;
-          }
-        } catch {
-          // File doesn't exist, continue to next format
-        }
-      }
-
-      // Clean up failed attempt
-      try {
-        await fs.unlink(tempFilePath);
-      } catch {
-        // Ignore cleanup errors
-      }
-    }
-
-    // No format worked
-    return null;
-  } catch (error) {
-    console.error('Error saving clipboard image:', error);
-    return null;
-  }
-}
-
-/**
- * Cleans up old temporary clipboard image files
- * Removes files older than 1 hour
- * @param targetDir The target directory where temp files are stored
- */
-export async function cleanupOldClipboardImages(
-  targetDir?: string,
-): Promise<void> {
-  try {
-    const baseDir = targetDir || process.cwd();
-    const tempDir = path.join(baseDir, '.gemini-clipboard');
-    const files = await fs.readdir(tempDir);
-    const oneHourAgo = Date.now() - 60 * 60 * 1000;
-
-    for (const file of files) {
-      if (
-        file.startsWith('clipboard-') &&
-        (file.endsWith('.png') ||
-          file.endsWith('.jpg') ||
-          file.endsWith('.tiff') ||
-          file.endsWith('.gif'))
-      ) {
-        const filePath = path.join(tempDir, file);
-        const stats = await fs.stat(filePath);
-        if (stats.mtimeMs < oneHourAgo) {
-          await fs.unlink(filePath);
-        }
-      }
-    }
-  } catch {
-    // Ignore errors in cleanup
-  }
-}