fss-link 1.0.49 → 1.0.51

package/dist/ui/utils/kittyProtocolDetector.ts

@@ -1,105 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-let detectionComplete = false;
-let protocolSupported = false;
-let protocolEnabled = false;
-
-/**
- * Detects Kitty keyboard protocol support.
- * Definitive document about this protocol lives at https://sw.kovidgoyal.net/kitty/keyboard-protocol/
- * This function should be called once at app startup.
- */
-export async function detectAndEnableKittyProtocol(): Promise<boolean> {
-  if (detectionComplete) {
-    return protocolSupported;
-  }
-
-  return new Promise((resolve) => {
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
-      detectionComplete = true;
-      resolve(false);
-      return;
-    }
-
-    const originalRawMode = process.stdin.isRaw;
-    if (!originalRawMode) {
-      process.stdin.setRawMode(true);
-    }
-
-    let responseBuffer = '';
-    let progressiveEnhancementReceived = false;
-    let checkFinished = false;
-
-    const handleData = (data: Buffer) => {
-      responseBuffer += data.toString();
-
-      // Check for progressive enhancement response (CSI ? <flags> u)
-      if (responseBuffer.includes('\x1b[?') && responseBuffer.includes('u')) {
-        progressiveEnhancementReceived = true;
-      }
-
-      // Check for device attributes response (CSI ? <attrs> c)
-      if (responseBuffer.includes('\x1b[?') && responseBuffer.includes('c')) {
-        if (!checkFinished) {
-          checkFinished = true;
-          process.stdin.removeListener('data', handleData);
-
-          if (!originalRawMode) {
-            process.stdin.setRawMode(false);
-          }
-
-          if (progressiveEnhancementReceived) {
-            // Enable the protocol
-            process.stdout.write('\x1b[>1u');
-            protocolSupported = true;
-            protocolEnabled = true;
-
-            // Set up cleanup on exit
-            process.on('exit', disableProtocol);
-            process.on('SIGTERM', disableProtocol);
-          }
-
-          detectionComplete = true;
-          resolve(protocolSupported);
-        }
-      }
-    };
-
-    process.stdin.on('data', handleData);
-
-    // Send queries
-    process.stdout.write('\x1b[?u'); // Query progressive enhancement
-    process.stdout.write('\x1b[c'); // Query device attributes
-
-    // Timeout after 50ms
-    setTimeout(() => {
-      if (!checkFinished) {
-        process.stdin.removeListener('data', handleData);
-        if (!originalRawMode) {
-          process.stdin.setRawMode(false);
-        }
-        detectionComplete = true;
-        resolve(false);
-      }
-    }, 50);
-  });
-}
-
-function disableProtocol() {
-  if (protocolEnabled) {
-    process.stdout.write('\x1b[<u');
-    protocolEnabled = false;
-  }
-}
-
-export function isKittyProtocolEnabled(): boolean {
-  return protocolEnabled;
-}
-
-export function isKittyProtocolSupported(): boolean {
-  return protocolSupported;
-}

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

@@ -1,50 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect } from 'vitest';
-import { findLastSafeSplitPoint } from './markdownUtilities.js';
-
-describe('markdownUtilities', () => {
-  describe('findLastSafeSplitPoint', () => {
-    it('should split at the last double newline if not in a code block', () => {
-      const content = 'paragraph1\n\nparagraph2\n\nparagraph3';
-      expect(findLastSafeSplitPoint(content)).toBe(24); // After the second \n\n
-    });
-
-    it('should return content.length if no safe split point is found', () => {
-      const content = 'longstringwithoutanysafesplitpoint';
-      expect(findLastSafeSplitPoint(content)).toBe(content.length);
-    });
-
-    it('should prioritize splitting at \n\n over being at the very end of the string if the end is not in a code block', () => {
-      const content = 'Some text here.\n\nAnd more text here.';
-      expect(findLastSafeSplitPoint(content)).toBe(17); // after the \n\n
-    });
-
-    it('should return content.length if the only \n\n is inside a code block and the end of content is not', () => {
-      const content = '```\nignore this\n\nnewline\n```KeepThis';
-      expect(findLastSafeSplitPoint(content)).toBe(content.length);
-    });
-
-    it('should correctly identify the last \n\n even if it is followed by text not in a code block', () => {
-      const content =
-        'First part.\n\nSecond part.\n\nThird part, then some more text.';
-      // Split should be after "Second part.\n\n"
-      // "First part.\n\n" is 13 chars. "Second part.\n\n" is 14 chars. Total 27.
-      expect(findLastSafeSplitPoint(content)).toBe(27);
-    });
-
-    it('should return content.length if content is empty', () => {
-      const content = '';
-      expect(findLastSafeSplitPoint(content)).toBe(0);
-    });
-
-    it('should return content.length if content has no newlines and no code blocks', () => {
-      const content = 'Single line of text';
-      expect(findLastSafeSplitPoint(content)).toBe(content.length);
-    });
-  });
-});

package/dist/ui/utils/markdownUtilities.ts

@@ -1,125 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/*
-**Background & Purpose:**
-
-The `findSafeSplitPoint` function is designed to address the challenge of displaying or processing large, potentially streaming, pieces of Markdown text. When content (e.g., from an LLM like Gemini) arrives in chunks or grows too large for a single display unit (like a message bubble), it needs to be split. A naive split (e.g., just at a character limit) can break Markdown formatting, especially critical for multi-line elements like code blocks, lists, or blockquotes, leading to incorrect rendering.
-
-This function aims to find an *intelligent* or "safe" index within the provided `content` string at which to make such a split, prioritizing the preservation of Markdown integrity.
-
-**Key Expectations & Behavior (Prioritized):**
-
-1.  **No Split if Short Enough:**
-    * If `content.length` is less than or equal to `idealMaxLength`, the function should return `content.length` (indicating no split is necessary for length reasons).
-
-2.  **Code Block Integrity (Highest Priority for Safety):**
-    * The function must try to avoid splitting *inside* a fenced code block (i.e., between ` ``` ` and ` ``` `).
-    * If `idealMaxLength` falls within a code block:
-        * The function will attempt to return an index that splits the content *before* the start of that code block.
-        * If a code block starts at the very beginning of the `content` and `idealMaxLength` falls within it (meaning the block itself is too long for the first chunk), the function might return `0`. This effectively makes the first chunk empty, pushing the entire oversized code block to the second part of the split.
-    * When considering splits near code blocks, the function prefers to keep the entire code block intact in one of the resulting chunks.
-
-3.  **Markdown-Aware Newline Splitting (If Not Governed by Code Block Logic):**
-    * If `idealMaxLength` does not fall within a code block (or after code block considerations have been made), the function will look for natural break points by scanning backwards from `idealMaxLength`:
-        * **Paragraph Breaks:** It prioritizes splitting after a double newline (`\n\n`), as this typically signifies the end of a paragraph or a block-level element.
-        * **Single Line Breaks:** If no double newline is found in a suitable range, it will look for a single newline (`\n`).
-    * Any newline chosen as a split point must also not be inside a code block.
-
-4.  **Fall back to `idealMaxLength`:**
-    * If no "safer" split point (respecting code blocks or finding suitable newlines) is identified before or at `idealMaxLength`, and `idealMaxLength` itself is not determined to be an unsafe split point (e.g., inside a code block), the function may return a length larger than `idealMaxLength`, again it CANNOT break markdown formatting. This could happen with very long lines of text without Markdown block structures or newlines.
-
-**In essence, `findSafeSplitPoint` tries to be a good Markdown citizen when forced to divide content, preferring structural boundaries over arbitrary character limits, with a strong emphasis on not corrupting code blocks.**
-*/
-
-/**
- * Checks if a given character index within a string is inside a fenced (```) code block.
- * @param content The full string content.
- * @param indexToTest The character index to test.
- * @returns True if the index is inside a code block's content, false otherwise.
- */
-const isIndexInsideCodeBlock = (
-  content: string,
-  indexToTest: number,
-): boolean => {
-  let fenceCount = 0;
-  let searchPos = 0;
-  while (searchPos < content.length) {
-    const nextFence = content.indexOf('```', searchPos);
-    if (nextFence === -1 || nextFence >= indexToTest) {
-      break;
-    }
-    fenceCount++;
-    searchPos = nextFence + 3;
-  }
-  return fenceCount % 2 === 1;
-};
-
-/**
- * Finds the starting index of the code block that encloses the given index.
- * Returns -1 if the index is not inside a code block.
- * @param content The markdown content.
- * @param index The index to check.
- * @returns Start index of the enclosing code block or -1.
- */
-const findEnclosingCodeBlockStart = (
-  content: string,
-  index: number,
-): number => {
-  if (!isIndexInsideCodeBlock(content, index)) {
-    return -1;
-  }
-  let currentSearchPos = 0;
-  while (currentSearchPos < index) {
-    const blockStartIndex = content.indexOf('```', currentSearchPos);
-    if (blockStartIndex === -1 || blockStartIndex >= index) {
-      break;
-    }
-    const blockEndIndex = content.indexOf('```', blockStartIndex + 3);
-    if (blockStartIndex < index) {
-      if (blockEndIndex === -1 || index < blockEndIndex + 3) {
-        return blockStartIndex;
-      }
-    }
-    if (blockEndIndex === -1) break;
-    currentSearchPos = blockEndIndex + 3;
-  }
-  return -1;
-};
-
-export const findLastSafeSplitPoint = (content: string) => {
-  const enclosingBlockStart = findEnclosingCodeBlockStart(
-    content,
-    content.length,
-  );
-  if (enclosingBlockStart !== -1) {
-    // The end of the content is contained in a code block. Split right before.
-    return enclosingBlockStart;
-  }
-
-  // Search for the last double newline (\n\n) not in a code block.
-  let searchStartIndex = content.length;
-  while (searchStartIndex >= 0) {
-    const dnlIndex = content.lastIndexOf('\n\n', searchStartIndex);
-    if (dnlIndex === -1) {
-      // No more double newlines found.
-      break;
-    }
-
-    const potentialSplitPoint = dnlIndex + 2;
-    if (!isIndexInsideCodeBlock(content, potentialSplitPoint)) {
-      return potentialSplitPoint;
-    }
-
-    // If potentialSplitPoint was inside a code block,
-    // the next search should start *before* the \n\n we just found to ensure progress.
-    searchStartIndex = dnlIndex - 1;
-  }
-
-  // If no safe double newline is found, return content.length
-  // to keep the entire content as one piece.
-  return content.length;
-};

package/dist/ui/utils/platformConstants.ts

@@ -1,52 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Terminal Platform Constants
- *
- * This file contains terminal-related constants used throughout the application,
- * specifically for handling keyboard inputs and terminal protocols.
- */
-
-/**
- * Kitty keyboard protocol sequences for enhanced keyboard input.
- * @see https://sw.kovidgoyal.net/kitty/keyboard-protocol/
- */
-export const KITTY_CTRL_C = '[99;5u';
-
-/**
- * Kitty keyboard protocol keycodes
- */
-export const KITTY_KEYCODE_ENTER = 13;
-export const KITTY_KEYCODE_NUMPAD_ENTER = 57414;
-export const KITTY_KEYCODE_TAB = 9;
-export const KITTY_KEYCODE_BACKSPACE = 127;
-
-/**
- * Timing constants for terminal interactions
- */
-export const CTRL_EXIT_PROMPT_DURATION_MS = 1000;
-
-/**
- * VS Code terminal integration constants
- */
-export const VSCODE_SHIFT_ENTER_SEQUENCE = '\\\r\n';
-
-/**
- * Backslash + Enter detection window in milliseconds.
- * Used to detect Shift+Enter pattern where backslash
- * is followed by Enter within this timeframe.
- */
-export const BACKSLASH_ENTER_DETECTION_WINDOW_MS = 5;
-
-/**
- * Maximum expected length of a Kitty keyboard protocol sequence.
- * Format: ESC [ <keycode> ; <modifiers> u/~
- * Example: \x1b[13;2u (Shift+Enter) = 8 chars
- * Longest reasonable: \x1b[127;15~ = 11 chars (Del with all modifiers)
- * We use 12 to provide a small buffer.
- */
-export const MAX_KITTY_SEQUENCE_LENGTH = 12;

package/dist/ui/utils/terminalSetup.ts

@@ -1,342 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Terminal setup utility for configuring Shift+Enter and Ctrl+Enter support.
- *
- * This module provides automatic detection and configuration of various terminal
- * emulators to support multiline input through modified Enter keys.
- *
- * Supported terminals:
- * - VS Code: Configures keybindings.json to send \\\r\n
- * - Cursor: Configures keybindings.json to send \\\r\n (VS Code fork)
- * - Windsurf: Configures keybindings.json to send \\\r\n (VS Code fork)
- *
- * For VS Code and its forks:
- * - Shift+Enter: Sends \\\r\n (backslash followed by CRLF)
- * - Ctrl+Enter: Sends \\\r\n (backslash followed by CRLF)
- *
- * The module will not modify existing shift+enter or ctrl+enter keybindings
- * to avoid conflicts with user customizations.
- */
-
-import { promises as fs } from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { isKittyProtocolEnabled } from './kittyProtocolDetector.js';
-import { VSCODE_SHIFT_ENTER_SEQUENCE } from './platformConstants.js';
-
-const execAsync = promisify(exec);
-
-/**
- * Removes single-line JSON comments (// ...) from a string to allow parsing
- * VS Code style JSON files that may contain comments.
- */
-function stripJsonComments(content: string): string {
-  // Remove single-line comments (// ...)
-  return content.replace(/^\s*\/\/.*$/gm, '');
-}
-
-export interface TerminalSetupResult {
-  success: boolean;
-  message: string;
-  requiresRestart?: boolean;
-}
-
-type SupportedTerminal = 'vscode' | 'cursor' | 'windsurf';
-
-// Terminal detection
-async function detectTerminal(): Promise<SupportedTerminal | null> {
-  const termProgram = process.env['TERM_PROGRAM'];
-
-  // Check VS Code and its forks - check forks first to avoid false positives
-  // Check for Cursor-specific indicators
-  if (
-    process.env['CURSOR_TRACE_ID'] ||
-    process.env['VSCODE_GIT_ASKPASS_MAIN']?.toLowerCase().includes('cursor')
-  ) {
-    return 'cursor';
-  }
-  // Check for Windsurf-specific indicators
-  if (
-    process.env['VSCODE_GIT_ASKPASS_MAIN']?.toLowerCase().includes('windsurf')
-  ) {
-    return 'windsurf';
-  }
-  // Check VS Code last since forks may also set VSCODE env vars
-  if (termProgram === 'vscode' || process.env['VSCODE_GIT_IPC_HANDLE']) {
-    return 'vscode';
-  }
-
-  // Check parent process name
-  if (os.platform() !== 'win32') {
-    try {
-      const { stdout } = await execAsync('ps -o comm= -p $PPID');
-      const parentName = stdout.trim();
-
-      // Check forks before VS Code to avoid false positives
-      if (parentName.includes('windsurf') || parentName.includes('Windsurf'))
-        return 'windsurf';
-      if (parentName.includes('cursor') || parentName.includes('Cursor'))
-        return 'cursor';
-      if (parentName.includes('code') || parentName.includes('Code'))
-        return 'vscode';
-    } catch (error) {
-      // Continue detection even if process check fails
-      console.debug('Parent process detection failed:', error);
-    }
-  }
-
-  return null;
-}
-
-// Backup file helper
-async function backupFile(filePath: string): Promise<void> {
-  try {
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const backupPath = `${filePath}.backup.${timestamp}`;
-    await fs.copyFile(filePath, backupPath);
-  } catch (error) {
-    // Log backup errors but continue with operation
-    console.warn(`Failed to create backup of ${filePath}:`, error);
-  }
-}
-
-// Helper function to get VS Code-style config directory
-function getVSCodeStyleConfigDir(appName: string): string | null {
-  const platform = os.platform();
-
-  if (platform === 'darwin') {
-    return path.join(
-      os.homedir(),
-      'Library',
-      'Application Support',
-      appName,
-      'User',
-    );
-  } else if (platform === 'win32') {
-    if (!process.env['APPDATA']) {
-      return null;
-    }
-    return path.join(process.env['APPDATA'], appName, 'User');
-  } else {
-    return path.join(os.homedir(), '.config', appName, 'User');
-  }
-}
-
-// Generic VS Code-style terminal configuration
-async function configureVSCodeStyle(
-  terminalName: string,
-  appName: string,
-): Promise<TerminalSetupResult> {
-  const configDir = getVSCodeStyleConfigDir(appName);
-
-  if (!configDir) {
-    return {
-      success: false,
-      message: `Could not determine ${terminalName} config path on Windows: APPDATA environment variable is not set.`,
-    };
-  }
-
-  const keybindingsFile = path.join(configDir, 'keybindings.json');
-
-  try {
-    await fs.mkdir(configDir, { recursive: true });
-
-    let keybindings: unknown[] = [];
-    try {
-      const content = await fs.readFile(keybindingsFile, 'utf8');
-      await backupFile(keybindingsFile);
-      try {
-        const cleanContent = stripJsonComments(content);
-        const parsedContent = JSON.parse(cleanContent);
-        if (!Array.isArray(parsedContent)) {
-          return {
-            success: false,
-            message:
-              `${terminalName} keybindings.json exists but is not a valid JSON array. ` +
-              `Please fix the file manually or delete it to allow automatic configuration.\n` +
-              `File: ${keybindingsFile}`,
-          };
-        }
-        keybindings = parsedContent;
-      } catch (parseError) {
-        return {
-          success: false,
-          message:
-            `Failed to parse ${terminalName} keybindings.json. The file contains invalid JSON.\n` +
-            `Please fix the file manually or delete it to allow automatic configuration.\n` +
-            `File: ${keybindingsFile}\n` +
-            `Error: ${parseError}`,
-        };
-      }
-    } catch {
-      // File doesn't exist, will create new one
-    }
-
-    const shiftEnterBinding = {
-      key: 'shift+enter',
-      command: 'workbench.action.terminal.sendSequence',
-      when: 'terminalFocus',
-      args: { text: VSCODE_SHIFT_ENTER_SEQUENCE },
-    };
-
-    const ctrlEnterBinding = {
-      key: 'ctrl+enter',
-      command: 'workbench.action.terminal.sendSequence',
-      when: 'terminalFocus',
-      args: { text: VSCODE_SHIFT_ENTER_SEQUENCE },
-    };
-
-    // Check if ANY shift+enter or ctrl+enter bindings already exist
-    const existingShiftEnter = keybindings.find((kb) => {
-      const binding = kb as { key?: string };
-      return binding.key === 'shift+enter';
-    });
-
-    const existingCtrlEnter = keybindings.find((kb) => {
-      const binding = kb as { key?: string };
-      return binding.key === 'ctrl+enter';
-    });
-
-    if (existingShiftEnter || existingCtrlEnter) {
-      const messages: string[] = [];
-      if (existingShiftEnter) {
-        messages.push(`- Shift+Enter binding already exists`);
-      }
-      if (existingCtrlEnter) {
-        messages.push(`- Ctrl+Enter binding already exists`);
-      }
-      return {
-        success: false,
-        message:
-          `Existing keybindings detected. Will not modify to avoid conflicts.\n` +
-          messages.join('\n') +
-          '\n' +
-          `Please check and modify manually if needed: ${keybindingsFile}`,
-      };
-    }
-
-    // Check if our specific bindings already exist
-    const hasOurShiftEnter = keybindings.some((kb) => {
-      const binding = kb as {
-        command?: string;
-        args?: { text?: string };
-        key?: string;
-      };
-      return (
-        binding.key === 'shift+enter' &&
-        binding.command === 'workbench.action.terminal.sendSequence' &&
-        binding.args?.text === '\\\r\n'
-      );
-    });
-
-    const hasOurCtrlEnter = keybindings.some((kb) => {
-      const binding = kb as {
-        command?: string;
-        args?: { text?: string };
-        key?: string;
-      };
-      return (
-        binding.key === 'ctrl+enter' &&
-        binding.command === 'workbench.action.terminal.sendSequence' &&
-        binding.args?.text === '\\\r\n'
-      );
-    });
-
-    if (!hasOurShiftEnter || !hasOurCtrlEnter) {
-      if (!hasOurShiftEnter) keybindings.unshift(shiftEnterBinding);
-      if (!hasOurCtrlEnter) keybindings.unshift(ctrlEnterBinding);
-
-      await fs.writeFile(keybindingsFile, JSON.stringify(keybindings, null, 4));
-      return {
-        success: true,
-        message: `Added Shift+Enter and Ctrl+Enter keybindings to ${terminalName}.\nModified: ${keybindingsFile}`,
-        requiresRestart: true,
-      };
-    } else {
-      return {
-        success: true,
-        message: `${terminalName} keybindings already configured.`,
-      };
-    }
-  } catch (error) {
-    return {
-      success: false,
-      message: `Failed to configure ${terminalName}.\nFile: ${keybindingsFile}\nError: ${error}`,
-    };
-  }
-}
-
-// Terminal-specific configuration functions
-
-async function configureVSCode(): Promise<TerminalSetupResult> {
-  return configureVSCodeStyle('VS Code', 'Code');
-}
-
-async function configureCursor(): Promise<TerminalSetupResult> {
-  return configureVSCodeStyle('Cursor', 'Cursor');
-}
-
-async function configureWindsurf(): Promise<TerminalSetupResult> {
-  return configureVSCodeStyle('Windsurf', 'Windsurf');
-}
-
-/**
- * Main terminal setup function that detects and configures the current terminal.
- *
- * This function:
- * 1. Detects the current terminal emulator
- * 2. Applies appropriate configuration for Shift+Enter and Ctrl+Enter support
- * 3. Creates backups of configuration files before modifying them
- *
- * @returns Promise<TerminalSetupResult> Result object with success status and message
- *
- * @example
- * const result = await terminalSetup();
- * if (result.success) {
- *   console.log(result.message);
- *   if (result.requiresRestart) {
- *     console.log('Please restart your terminal');
- *   }
- * }
- */
-export async function terminalSetup(): Promise<TerminalSetupResult> {
-  // Check if terminal already has optimal keyboard support
-  if (isKittyProtocolEnabled()) {
-    return {
-      success: true,
-      message:
-        'Your terminal is already configured for an optimal experience with multiline input (Shift+Enter and Ctrl+Enter).',
-    };
-  }
-
-  const terminal = await detectTerminal();
-
-  if (!terminal) {
-    return {
-      success: false,
-      message:
-        'Could not detect terminal type. Supported terminals: VS Code, Cursor, and Windsurf.',
-    };
-  }
-
-  switch (terminal) {
-    case 'vscode':
-      return configureVSCode();
-    case 'cursor':
-      return configureCursor();
-    case 'windsurf':
-      return configureWindsurf();
-    default:
-      return {
-        success: false,
-        message: `Terminal "${terminal}" is not supported yet.`,
-      };
-  }
-}