@sylphx/flow 1.7.0 → 1.8.1

package/src/utils/audio-player.ts

@@ -1,345 +0,0 @@
-/**
- * Cross-Platform Audio Player
- * Detects and uses available audio players across different platforms
- *
- * Supported players (in priority order):
- * - macOS: afplay (built-in)
- * - Linux: mpg123, mpg321, play (sox), aplay, mplayer, cvlc
- * - Windows: powershell (built-in), cmdmp3
- * - Universal: mplayer, omxplayer (Raspberry Pi)
- */
-
-import { spawn } from 'child_process';
-import { existsSync } from 'fs';
-import { join } from 'path';
-
-/**
- * Audio player configuration
- */
-interface AudioPlayer {
-  name: string;
-  command: string;
-  args: (filePath: string) => string[];
-  platforms: NodeJS.Platform[];
-  checkAvailability?: () => Promise<boolean>;
-}
-
-/**
- * Available audio players in priority order
- */
-const AUDIO_PLAYERS: AudioPlayer[] = [
-  // macOS built-in
-  {
-    name: 'afplay',
-    command: 'afplay',
-    args: (file) => [file],
-    platforms: ['darwin'],
-  },
-
-  // Linux players (in priority order)
-  {
-    name: 'mpg123',
-    command: 'mpg123',
-    args: (file) => ['-q', file], // quiet mode
-    platforms: ['linux', 'freebsd', 'openbsd'],
-  },
-  {
-    name: 'mpg321',
-    command: 'mpg321',
-    args: (file) => ['-q', file], // quiet mode
-    platforms: ['linux', 'freebsd', 'openbsd'],
-  },
-  {
-    name: 'play',
-    command: 'play',
-    args: (file) => ['-q', file], // sox play command
-    platforms: ['linux', 'freebsd', 'openbsd', 'darwin'],
-  },
-  {
-    name: 'aplay',
-    command: 'aplay',
-    args: (file) => ['-q', file], // ALSA player
-    platforms: ['linux'],
-  },
-  {
-    name: 'mplayer',
-    command: 'mplayer',
-    args: (file) => ['-really-quiet', file],
-    platforms: ['linux', 'freebsd', 'openbsd', 'darwin', 'win32'],
-  },
-  {
-    name: 'cvlc',
-    command: 'cvlc',
-    args: (file) => ['--play-and-exit', '--quiet', file], // VLC command-line
-    platforms: ['linux', 'freebsd', 'openbsd', 'darwin', 'win32'],
-  },
-  {
-    name: 'omxplayer',
-    command: 'omxplayer',
-    args: (file) => ['-o', 'local', file], // Raspberry Pi
-    platforms: ['linux'],
-  },
-
-  // Windows players
-  {
-    name: 'powershell',
-    command: 'powershell',
-    args: (file) => [
-      '-NoProfile',
-      '-NonInteractive',
-      '-Command',
-      `(New-Object Media.SoundPlayer "${file}").PlaySync()`
-    ],
-    platforms: ['win32'],
-    // PowerShell Media.SoundPlayer only supports WAV files
-    checkAvailability: async () => {
-      // Check if we're on Windows and file is WAV
-      return process.platform === 'win32';
-    }
-  },
-  {
-    name: 'cmdmp3',
-    command: 'cmdmp3',
-    args: (file) => [file],
-    platforms: ['win32'],
-  },
-];
-
-/**
- * Cached available player to avoid repeated checks
- */
-let cachedPlayer: AudioPlayer | null = null;
-let cacheChecked = false;
-
-/**
- * Check if a command is available in PATH
- */
-async function isCommandAvailable(command: string): Promise<boolean> {
-  return new Promise((resolve) => {
-    // Try to execute the command with --version or --help
-    const proc = spawn(command, ['--version'], {
-      stdio: 'ignore',
-      shell: true
-    });
-
-    proc.on('error', () => resolve(false));
-    proc.on('exit', (code) => {
-      // Some commands return non-zero for --version, so just check if they exist
-      resolve(true);
-    });
-
-    // Timeout after 1 second
-    setTimeout(() => {
-      proc.kill();
-      resolve(false);
-    }, 1000);
-  });
-}
-
-/**
- * Detect the first available audio player for current platform
- */
-export async function detectAudioPlayer(): Promise<AudioPlayer | null> {
-  if (cacheChecked && cachedPlayer) {
-    return cachedPlayer;
-  }
-
-  const currentPlatform = process.platform;
-
-  // Filter players for current platform
-  const compatiblePlayers = AUDIO_PLAYERS.filter(
-    (player) => player.platforms.includes(currentPlatform)
-  );
-
-  // Check each player in priority order
-  for (const player of compatiblePlayers) {
-    // Custom availability check if provided
-    if (player.checkAvailability) {
-      const isAvailable = await player.checkAvailability();
-      if (!isAvailable) continue;
-    }
-
-    // Check if command is available
-    const isAvailable = await isCommandAvailable(player.command);
-    if (isAvailable) {
-      cachedPlayer = player;
-      cacheChecked = true;
-      return player;
-    }
-  }
-
-  cacheChecked = true;
-  return null;
-}
-
-/**
- * Play audio file using the best available player
- * @param filePath Absolute path to audio file
- * @param options Playback options
- * @returns Promise that resolves when playback completes or rejects on error
- */
-export async function playSound(
-  filePath: string,
-  options?: {
-    volume?: number; // 0-100 (not supported by all players)
-    background?: boolean; // Play in background (default: true)
-    timeout?: number; // Max playback duration in ms (default: 5000)
-  }
-): Promise<void> {
-  const {
-    background = true,
-    timeout = 5000
-  } = options || {};
-
-  // Check if file exists
-  if (!existsSync(filePath)) {
-    throw new Error(`Audio file not found: ${filePath}`);
-  }
-
-  // Detect available player
-  const player = await detectAudioPlayer();
-  if (!player) {
-    throw new Error('No audio player available on this system');
-  }
-
-  return new Promise((resolve, reject) => {
-    const args = player.args(filePath);
-    const proc = spawn(player.command, args, {
-      stdio: 'ignore',
-      detached: background,
-    });
-
-    // If background mode, unref and resolve immediately
-    if (background) {
-      proc.unref();
-      resolve();
-      return;
-    }
-
-    // Otherwise wait for completion
-    let timeoutId: NodeJS.Timeout | null = null;
-
-    proc.on('error', (error) => {
-      if (timeoutId) clearTimeout(timeoutId);
-      reject(new Error(`Audio player error: ${error.message}`));
-    });
-
-    proc.on('exit', (code) => {
-      if (timeoutId) clearTimeout(timeoutId);
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`Audio player exited with code ${code}`));
-      }
-    });
-
-    // Timeout protection
-    if (timeout > 0) {
-      timeoutId = setTimeout(() => {
-        proc.kill();
-        reject(new Error(`Audio playback timeout after ${timeout}ms`));
-      }, timeout);
-    }
-  });
-}
-
-/**
- * Get information about the detected audio player
- */
-export async function getAudioPlayerInfo(): Promise<{
-  available: boolean;
-  player: string | null;
-  platform: string;
-}> {
-  const player = await detectAudioPlayer();
-
-  return {
-    available: player !== null,
-    player: player?.name || null,
-    platform: process.platform
-  };
-}
-
-/**
- * Built-in system sounds for different platforms
- */
-export const SYSTEM_SOUNDS = {
-  // macOS system sounds
-  darwin: {
-    glass: '/System/Library/Sounds/Glass.aiff',
-    hero: '/System/Library/Sounds/Hero.aiff',
-    pop: '/System/Library/Sounds/Pop.aiff',
-    ping: '/System/Library/Sounds/Ping.aiff',
-    purr: '/System/Library/Sounds/Purr.aiff',
-    submarine: '/System/Library/Sounds/Submarine.aiff',
-    blow: '/System/Library/Sounds/Blow.aiff',
-    bottle: '/System/Library/Sounds/Bottle.aiff',
-    frog: '/System/Library/Sounds/Frog.aiff',
-    funk: '/System/Library/Sounds/Funk.aiff',
-    morse: '/System/Library/Sounds/Morse.aiff',
-  },
-  // Linux typical locations (may vary)
-  linux: {
-    complete: '/usr/share/sounds/freedesktop/stereo/complete.oga',
-    message: '/usr/share/sounds/freedesktop/stereo/message.oga',
-    bell: '/usr/share/sounds/freedesktop/stereo/bell.oga',
-    dialog: '/usr/share/sounds/freedesktop/stereo/dialog-information.oga',
-  },
-  // Windows - would need .wav files
-  win32: {
-    // Windows Media directory sounds
-    notify: 'C:\\Windows\\Media\\Windows Notify.wav',
-    ding: 'C:\\Windows\\Media\\Windows Ding.wav',
-    chord: 'C:\\Windows\\Media\\chord.wav',
-  }
-} as const;
-
-/**
- * Get default system sound for current platform
- */
-export function getDefaultSystemSound(): string | null {
-  const platform = process.platform;
-
-  if (platform === 'darwin') {
-    return SYSTEM_SOUNDS.darwin.glass;
-  } else if (platform === 'linux') {
-    // Check which sound exists
-    const sounds = Object.values(SYSTEM_SOUNDS.linux);
-    for (const sound of sounds) {
-      if (existsSync(sound)) {
-        return sound;
-      }
-    }
-  } else if (platform === 'win32') {
-    // Check which sound exists
-    const sounds = Object.values(SYSTEM_SOUNDS.win32);
-    for (const sound of sounds) {
-      if (existsSync(sound)) {
-        return sound;
-      }
-    }
-  }
-
-  return null;
-}
-
-/**
- * Play system notification sound
- */
-export async function playNotificationSound(): Promise<void> {
-  const soundPath = getDefaultSystemSound();
-
-  if (!soundPath) {
-    // No system sound available, just return silently
-    return;
-  }
-
-  try {
-    await playSound(soundPath, { background: true, timeout: 3000 });
-  } catch (error) {
-    // Fail silently - don't crash on sound playback errors
-    if (process.env.DEBUG) {
-      console.error('[Audio] Failed to play notification sound:', error);
-    }
-  }
-}

package/src/utils/codebase-helpers.ts

@@ -1,211 +0,0 @@
-/**
- * Codebase indexing helper functions
- * Utility functions for file scanning and language detection
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import ignore, { type Ignore } from 'ignore';
-
-/**
- * Detect programming language from file extension
- */
-export function detectLanguage(filePath: string): string | undefined {
-  const ext = path.extname(filePath).toLowerCase();
-  const languageMap: Record<string, string> = {
-    '.ts': 'TypeScript',
-    '.tsx': 'TSX',
-    '.js': 'JavaScript',
-    '.jsx': 'JSX',
-    '.py': 'Python',
-    '.java': 'Java',
-    '.go': 'Go',
-    '.rs': 'Rust',
-    '.c': 'C',
-    '.cpp': 'C++',
-    '.cs': 'C#',
-    '.rb': 'Ruby',
-    '.php': 'PHP',
-    '.swift': 'Swift',
-    '.kt': 'Kotlin',
-    '.md': 'Markdown',
-    '.json': 'JSON',
-    '.yaml': 'YAML',
-    '.yml': 'YAML',
-    '.toml': 'TOML',
-    '.sql': 'SQL',
-    '.sh': 'Shell',
-    '.bash': 'Bash',
-  };
-  return languageMap[ext];
-}
-
-/**
- * Check if file is text-based (not binary)
- */
-export function isTextFile(filePath: string): boolean {
-  const textExtensions = new Set([
-    '.ts',
-    '.tsx',
-    '.js',
-    '.jsx',
-    '.py',
-    '.java',
-    '.go',
-    '.rs',
-    '.c',
-    '.cpp',
-    '.h',
-    '.hpp',
-    '.cs',
-    '.rb',
-    '.php',
-    '.swift',
-    '.kt',
-    '.md',
-    '.txt',
-    '.json',
-    '.yaml',
-    '.yml',
-    '.toml',
-    '.xml',
-    '.sql',
-    '.sh',
-    '.bash',
-    '.zsh',
-    '.fish',
-    '.dockerfile',
-    '.gitignore',
-    '.env',
-    '.env.example',
-    '.env.local',
-    '.env.development',
-    '.env.production',
-  ]);
-
-  const ext = path.extname(filePath).toLowerCase();
-  return textExtensions.has(ext) || !ext; // Files without extension might be text
-}
-
-/**
- * Load .gitignore file and create ignore filter
- */
-export function loadGitignore(codebaseRoot: string): Ignore {
-  const ig = ignore();
-
-  // Add default ignore patterns
-  ig.add([
-    'node_modules',
-    '.git',
-    '.svn',
-    '.hg',
-    '.DS_Store',
-    '.idea',
-    '.vscode',
-    '*.suo',
-    '*.ntvs*',
-    '*.njsproj',
-    '*.sln',
-    '*.swp',
-    '.sylphx-flow',
-    '.cache',
-    'dist',
-    'build',
-    'coverage',
-    '.nyc_output',
-  ]);
-
-  const gitignorePath = path.join(codebaseRoot, '.gitignore');
-
-  if (fs.existsSync(gitignorePath)) {
-    try {
-      const content = fs.readFileSync(gitignorePath, 'utf8');
-      ig.add(content);
-    } catch (error) {
-      console.warn(`[WARN] Failed to read .gitignore: ${error}`);
-    }
-  }
-
-  return ig;
-}
-
-/**
- * Scan directory recursively for files
- */
-export interface ScanOptions {
-  ignoreFilter?: Ignore;
-  codebaseRoot?: string;
-}
-
-export interface ScanResult {
-  path: string;
-  absolutePath: string;
-  content: string;
-  size: number;
-  mtime: number;
-}
-
-/**
- * Scan files in directory with .gitignore support
- */
-export function scanFiles(dir: string, options: ScanOptions = {}): ScanResult[] {
-  const results: ScanResult[] = [];
-  const ignoreFilter = options.ignoreFilter;
-  const codebaseRoot = options.codebaseRoot || dir;
-
-  function scan(currentDir: string) {
-    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const fullPath = path.join(currentDir, entry.name);
-      const relativePath = path.relative(codebaseRoot, fullPath);
-
-      // Skip ignored files
-      if (ignoreFilter?.ignores(relativePath)) {
-        continue;
-      }
-
-      if (entry.isDirectory()) {
-        scan(fullPath);
-      } else if (entry.isFile()) {
-        try {
-          const stats = fs.statSync(fullPath);
-          const _ext = path.extname(fullPath);
-
-          // Only process text files
-          if (!isTextFile(fullPath)) {
-            continue;
-          }
-
-          const content = fs.readFileSync(fullPath, 'utf8');
-
-          results.push({
-            path: relativePath,
-            absolutePath: fullPath,
-            content,
-            size: stats.size,
-            mtime: stats.mtimeMs,
-          });
-        } catch (error) {
-          console.warn(`[WARN] Failed to read file: ${relativePath}`, error);
-        }
-      }
-    }
-  }
-
-  scan(dir);
-  return results;
-}
-
-/**
- * Calculate simple hash for file content (for change detection)
- */
-export function simpleHash(content: string): string {
-  let hash = 0;
-  for (let i = 0; i < content.length; i++) {
-    const char = content.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash &= hash; // Convert to 32-bit integer
-  }
-  return hash.toString(36);
-}

package/src/utils/console-ui.ts

@@ -1,79 +0,0 @@
-/**
- * Modern console UI utilities
- * Progressive output with beautiful formatting
- */
-
-import chalk from 'chalk';
-
-export const ui = {
-  // Headers
-  header: (text: string) => {
-    console.log('');
-    console.log(chalk.cyan.bold(`▸ ${text}`));
-  },
-
-  subheader: (text: string) => {
-    console.log(chalk.gray(`  ${text}`));
-  },
-
-  // Status messages
-  success: (text: string) => {
-    console.log(chalk.green(`✓ ${text}`));
-  },
-
-  error: (text: string) => {
-    console.log(chalk.red(`✗ ${text}`));
-  },
-
-  warning: (text: string) => {
-    console.log(chalk.yellow(`⚠ ${text}`));
-  },
-
-  info: (text: string) => {
-    console.log(chalk.cyan(`ℹ ${text}`));
-  },
-
-  // Progress
-  step: (text: string) => {
-    console.log(chalk.gray(`  • ${text}`));
-  },
-
-  loading: (text: string) => {
-    console.log(chalk.cyan(`⏳ ${text}`));
-  },
-
-  // Fields
-  field: (label: string, value: string, secret = false) => {
-    const displayValue = secret ? '•'.repeat(Math.min(8, value.length)) : value;
-    console.log(`  ${chalk.gray(label)}: ${chalk.white(displayValue)}`);
-  },
-
-  // Dividers
-  divider: () => {
-    console.log(chalk.gray('  ─'.repeat(40)));
-  },
-
-  spacer: () => {
-    console.log('');
-  },
-
-  // Lists
-  list: (items: string[]) => {
-    items.forEach((item) => {
-      console.log(chalk.gray(`  • ${item}`));
-    });
-  },
-
-  // Input prompt (for simple inputs)
-  prompt: (label: string, required = false) => {
-    const indicator = required ? chalk.red('*') : '';
-    return `${chalk.cyan('❯')} ${label}${indicator}: `;
-  },
-
-  // Section
-  section: (title: string, content: () => void) => {
-    console.log('');
-    console.log(chalk.cyan.bold(`▸ ${title}`));
-    content();
-  },
-};