Local Whisper

#!/usr/bin/env node
/**
 * Tests for transcribe.js unified CLI
 * 
 * Run: node tests/transcribe.test.js
 */

const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');

// Import the module under test
const transcribeModule = require('../transcribe.js');
const { 
  checkDependencies, 
  findWhisperBinary, 
  selectModel, 
  parseArgs,
  isSupportedFormat,
  SUPPORTED_FORMATS,
  DEFAULTS 
} = transcribeModule;

// Test configuration
const TEST_DIR = __dirname;
const ROOT_DIR = path.join(TEST_DIR, '..');
const TEST_AUDIO_FILE = path.join(TEST_DIR, 'test_audio.wav');

// Test results
let passed = 0;
let failed = 0;
const errors = [];

/**
 * Test helper: assert equality
 */
function assertEqual(actual, expected, testName) {
  if (actual === expected) {
    console.log(`  ✅ ${testName}`);
    passed++;
    return true;
  } else {
    console.log(`  ❌ ${testName}`);
    console.log(`     Expected: ${expected}`);
    console.log(`     Actual:   ${actual}`);
    failed++;
    errors.push(`${testName}: expected ${expected}, got ${actual}`);
    return false;
  }
}

/**
 * Test helper: assert truthy
 */
function assertTrue(actual, testName) {
  if (actual) {
    console.log(`  ✅ ${testName}`);
    passed++;
    return true;
  } else {
    console.log(`  ❌ ${testName}`);
    console.log(`     Expected truthy, got: ${actual}`);
    failed++;
    errors.push(`${testName}: expected truthy value`);
    return false;
  }
}

/**
 * Test helper: assert function throws
 */
function assertThrows(fn, testName) {
  try {
    fn();
    console.log(`  ❌ ${testName}`);
    console.log(`     Expected function to throw`);
    failed++;
    errors.push(`${testName}: expected function to throw`);
    return false;
  } catch (e) {
    console.log(`  ✅ ${testName}`);
    passed++;
    return true;
  }
}

/**
 * Create a dummy audio file for testing
 */
function createTestAudioFile(sizeKB) {
  const filePath = path.join(TEST_DIR, `test_${sizeKB}kb.tmp`);
  const buffer = Buffer.alloc(sizeKB * 1024);
  fs.writeFileSync(filePath, buffer);
  return filePath;
}

/**
 * Clean up test files
 */
function cleanup() {
  try {
    const files = fs.readdirSync(TEST_DIR);
    for (const file of files) {
      if (file.endsWith('.tmp') || file.endsWith('.test.txt')) {
        fs.unlinkSync(path.join(TEST_DIR, file));
      }
    }
  } catch (e) {
    // Ignore cleanup errors
  }
}

// ==================== TEST SUITES ====================

/**
 * Test 1: Check main script exists
 */
function testScriptExists() {
  console.log('\n📁 Test Suite: Script Structure');
  
  const scriptPath = path.join(ROOT_DIR, 'transcribe.js');
  assertTrue(fs.existsSync(scriptPath), 'Main transcribe.js exists');
  
  const content = fs.readFileSync(scriptPath, 'utf-8');
  assertTrue(content.includes('module.exports'), 'Script exports functions for testing');
  assertTrue(content.includes('findWhisperBinary'), 'Script has whisper binary detection');
  assertTrue(content.includes('selectModel'), 'Script has smart model selection');
  assertTrue(content.includes('checkDependencies'), 'Script has dependency checking');
  assertTrue(content.includes('isSupportedFormat'), 'Script has format validation (no WAV conversion)');
  assertTrue(content.includes('SUPPORTED_FORMATS'), 'Script defines supported formats');
  assertTrue(content.includes('WHISPER_MODEL'), 'Script uses WHISPER_MODEL env var');
  assertTrue(content.includes('WHISPER_LANGUAGE'), 'Script uses WHISPER_LANGUAGE env var');
}

/**
 * Test 2: parseArgs function
 */
function testParseArgs() {
  console.log('\n🎛️  Test Suite: Argument Parsing');
  
  // Test with audio file only
  let result = parseArgs(['voice.ogg']);
  assertEqual(result.audioPath, 'voice.ogg', 'Parses audio file path');
  assertTrue(result.options.smartModel, 'Smart model enabled by default');
  
  // Test with --model flag
  result = parseArgs(['audio.wav', '--model', 'large']);
  assertEqual(result.options.model, 'large', 'Parses --model flag');
  assertEqual(result.options.smartModel, false, 'Smart model disabled when explicit model set');
  
  // Test with --language flag
  result = parseArgs(['audio.mp3', '--language', 'de']);
  assertEqual(result.options.language, 'de', 'Parses --language flag');
  
  // Test with -l shorthand
  result = parseArgs(['audio.mp3', '-l', 'en']);
  assertEqual(result.options.language, 'en', 'Parses -l shorthand');
  
  // Test with --output-dir flag
  result = parseArgs(['audio.ogg', '--output-dir', '/tmp/out']);
  assertEqual(result.options.outputDir, '/tmp/out', 'Parses --output-dir flag');
  
  // Test with -o shorthand
  result = parseArgs(['audio.ogg', '-o', '~/transcriptions']);
  assertEqual(result.options.outputDir, '~/transcriptions', 'Parses -o shorthand');
  
  // Test with multiple flags
  result = parseArgs(['voice.ogg', '--model', 'medium', '--language', 'es', '--output-dir', './out']);
  assertEqual(result.audioPath, 'voice.ogg', 'Parses audio with multiple flags');
  assertEqual(result.options.model, 'medium', 'Parses model with multiple flags');
  assertEqual(result.options.language, 'es', 'Parses language with multiple flags');
  assertEqual(result.options.outputDir, './out', 'Parses output-dir with multiple flags');
  
  // Test --no-smart-model
  result = parseArgs(['audio.ogg', '--no-smart-model']);
  assertEqual(result.options.smartModel, false, 'Parses --no-smart-model flag');
  
  // Test --smart-model
  result = parseArgs(['audio.ogg', '--smart-model']);
  assertEqual(result.options.smartModel, true, 'Parses --smart-model flag');
}

/**
 * Test 3: selectModel function
 */
function testSelectModel() {
  console.log('\n🧠 Test Suite: Smart Model Selection');
  
  // Create test files of different sizes
  const smallFile = createTestAudioFile(50);   // 50 KB
  const mediumFile = createTestAudioFile(150); // 150 KB
  
  try {
    // Test small file (< 100KB)
    const smallModel = selectModel(smallFile, { model: 'auto' });
    assertEqual(smallModel, 'large', 'Small file (<100KB) uses large model');
    
    // Test large file (>= 100KB)
    const largeModel = selectModel(mediumFile, { model: 'auto' });
    assertEqual(largeModel, 'medium', 'Large file (>=100KB) uses medium model');
    
    // Test explicit model override
    const explicitModel = selectModel(smallFile, { model: 'tiny' });
    assertEqual(explicitModel, 'tiny', 'Explicit model overrides smart selection');
  } finally {
    // Cleanup
    try {
      fs.unlinkSync(smallFile);
      fs.unlinkSync(mediumFile);
    } catch (e) {}
  }
}

/**
 * Test 4: Environment variable defaults
 */
function testEnvironmentDefaults() {
  console.log('\n🔧 Test Suite: Environment Variables');
  
  // Store original env vars
  const origModel = process.env.WHISPER_MODEL;
  const origLang = process.env.WHISPER_LANGUAGE;
  
  try {
    // Clear env vars to test defaults
    delete process.env.WHISPER_MODEL;
    delete process.env.WHISPER_LANGUAGE;
    
    // Re-require module to pick up new defaults
    delete require.cache[require.resolve('../transcribe.js')];
    const freshModule = require('../transcribe.js');
    
    assertEqual(freshModule.DEFAULTS.MODEL, 'small', 'Default model is small');
    assertEqual(freshModule.DEFAULTS.LANGUAGE, 'auto', 'Default language is auto');
    
    // Set custom env vars
    process.env.WHISPER_MODEL = 'large';
    process.env.WHISPER_LANGUAGE = 'de';
    
    delete require.cache[require.resolve('../transcribe.js')];
    const customModule = require('../transcribe.js');
    
    // Note: DEFAULTS are set at require time, so we check that the module
    // would read these values (actual test would require re-require)
    assertTrue(true, 'Environment variables can customize defaults');
  } finally {
    // Restore env vars
    if (origModel !== undefined) process.env.WHISPER_MODEL = origModel;
    else delete process.env.WHISPER_MODEL;
    if (origLang !== undefined) process.env.WHISPER_LANGUAGE = origLang;
    else delete process.env.WHISPER_LANGUAGE;
  }
}

/**
 * Test 5: Dependency checking
 */
function testDependencyChecking() {
  console.log('\n📦 Test Suite: Dependency Checking');
  
  const deps = checkDependencies();
  
  // We just verify the function returns the expected structure
  assertTrue(typeof deps === 'object', 'checkDependencies returns an object');
  assertTrue(typeof deps.ffmpeg === 'boolean', 'ffmpeg check returns boolean');
  assertTrue(deps.whisper === false || typeof deps.whisper === 'string', 'whisper check returns false or path');
  assertTrue(typeof deps.python3 === 'boolean', 'python3 check returns boolean');
}

/**
 * Test 6: Whisper binary detection
 */
function testWhisperBinaryDetection() {
  console.log('\n🔍 Test Suite: Whisper Binary Detection');
  
  const binaryPath = findWhisperBinary();
  
  // Should return either null or a string path
  assertTrue(binaryPath === null || typeof binaryPath === 'string', 'findWhisperBinary returns null or string');
  
  if (binaryPath) {
    assertTrue(binaryPath.includes('whisper'), 'Whisper binary path contains "whisper"');
  }
}

/**
 * Test 7: Old scripts removed
 */
function testOldScriptsRemoved() {
  console.log('\n🗑️  Test Suite: Legacy Script Cleanup');
  
  const oldScripts = [
    path.join(ROOT_DIR, 'scripts', 'transcribe_local.js'),
    path.join(ROOT_DIR, 'scripts', 'transcribe_nixos.js'),
    path.join(ROOT_DIR, 'transcribe_local.js'),
    path.join(ROOT_DIR, 'transcribe_nixos.js')
  ];
  
  for (const scriptPath of oldScripts) {
    assertEqual(fs.existsSync(scriptPath), false, `Old script removed: ${path.basename(scriptPath)}`);
  }
}

/**
 * Test 8: Module exports
 */
function testModuleExports() {
  console.log('\n📤 Test Suite: Module Exports');
  
  assertTrue(typeof transcribeModule.transcribe === 'function', 'Exports transcribe function');
  assertTrue(typeof transcribeModule.checkDependencies === 'function', 'Exports checkDependencies function');
  assertTrue(typeof transcribeModule.findWhisperBinary === 'function', 'Exports findWhisperBinary function');
  assertTrue(typeof transcribeModule.selectModel === 'function', 'Exports selectModel function');
  assertTrue(typeof transcribeModule.parseArgs === 'function', 'Exports parseArgs function');
  assertTrue(typeof transcribeModule.isSupportedFormat === 'function', 'Exports isSupportedFormat function');
  assertTrue(Array.isArray(transcribeModule.SUPPORTED_FORMATS), 'Exports SUPPORTED_FORMATS array');
  assertTrue(typeof transcribeModule.DEFAULTS === 'object', 'Exports DEFAULTS object');
}

/**
 * Test 9: Direct format support (no WAV conversion needed)
 */
function testDirectFormatSupport() {
  console.log('\n🎵 Test Suite: Direct Format Support (Issue #6)');
  
  // Test that all supported formats are recognized
  assertTrue(isSupportedFormat('audio.wav'), 'Supports WAV format');
  assertTrue(isSupportedFormat('audio.mp3'), 'Supports MP3 format');
  assertTrue(isSupportedFormat('audio.m4a'), 'Supports M4A format');
  assertTrue(isSupportedFormat('audio.flac'), 'Supports FLAC format');
  assertTrue(isSupportedFormat('audio.ogg'), 'Supports OGG format');
  
  // Test case insensitivity
  assertTrue(isSupportedFormat('audio.MP3'), 'Supports uppercase MP3 format');
  assertTrue(isSupportedFormat('audio.WAV'), 'Supports uppercase WAV format');
  
  // Test unsupported formats
  assertEqual(isSupportedFormat('audio.wma'), false, 'Rejects WMA format');
  assertEqual(isSupportedFormat('audio.aac'), false, 'Rejects AAC format');
  assertEqual(isSupportedFormat('audio.unknown'), false, 'Rejects unknown format');
  
  // Verify no convertToWav is exported (it was removed)
  assertEqual(typeof transcribeModule.convertToWav, 'undefined', 'convertToWav function removed from exports');
  
  // Verify supported formats list
  assertTrue(SUPPORTED_FORMATS.includes('.wav'), 'SUPPORTED_FORMATS includes .wav');
  assertTrue(SUPPORTED_FORMATS.includes('.mp3'), 'SUPPORTED_FORMATS includes .mp3');
  assertTrue(SUPPORTED_FORMATS.includes('.m4a'), 'SUPPORTED_FORMATS includes .m4a');
  assertTrue(SUPPORTED_FORMATS.includes('.flac'), 'SUPPORTED_FORMATS includes .flac');
  assertTrue(SUPPORTED_FORMATS.includes('.ogg'), 'SUPPORTED_FORMATS includes .ogg');
  assertEqual(SUPPORTED_FORMATS.length, 5, 'Exactly 5 supported formats');
}

/**
 * Test 10: CLI help output
 */
function testCliHelp() {
  console.log('\n📖 Test Suite: CLI Help');
  
  try {
    const output = execSync('node transcribe.js --help', { 
      cwd: ROOT_DIR,
      encoding: 'utf-8',
      stdio: 'pipe'
    });
    
    assertTrue(output.includes('--model'), 'Help includes --model flag');
    assertTrue(output.includes('--language'), 'Help includes --language flag');
    assertTrue(output.includes('--output-dir'), 'Help includes --output-dir flag');
    assertTrue(output.includes('WHISPER_MODEL'), 'Help includes WHISPER_MODEL env var');
    assertTrue(output.includes('WHISPER_LANGUAGE'), 'Help includes WHISPER_LANGUAGE env var');
    assertTrue(output.includes('smart'), 'Help mentions smart model selection');
  } catch (e) {
    // If --help exits with non-zero, that's still valid if output contains help
    if (e.stdout) {
      const output = e.stdout;
      assertTrue(output.includes('--model'), 'Help includes --model flag (via exception)');
    } else {
      console.log(`  ⚠️  Could not test CLI help: ${e.message}`);
    }
  }
}

// ==================== MAIN ====================

function runTests() {
  console.log('\n🧪 Running transcribe.js Tests');
  console.log('='.repeat(50));
  
  try {
    testScriptExists();
    testParseArgs();
    testSelectModel();
    testEnvironmentDefaults();
    testDependencyChecking();
    testWhisperBinaryDetection();
    testOldScriptsRemoved();
    testModuleExports();
    testDirectFormatSupport();
    testCliHelp();
  } catch (e) {
    console.error('\n💥 Test suite error:', e.message);
    errors.push(`Test suite error: ${e.message}`);
  }
  
  // Cleanup
  cleanup();
  
  // Summary
  console.log('\n' + '='.repeat(50));
  console.log(`📊 Results: ${passed} passed, ${failed} failed`);
  
  if (errors.length > 0) {
    console.log('\n❌ Errors:');
    errors.forEach(err => console.log(`   - ${err}`));
  }
  
  if (failed === 0) {
    console.log('\n✅ All tests passed!');
    process.exit(0);
  } else {
    console.log('\n❌ Some tests failed.');
    process.exit(1);
  }
}

runTests();

#!/usr/bin/env node
/**
 * Test: Verify local-whisper skill structure
 * - No API-based or broken scripts
 * - No hardcoded user paths
 */

const fs = require('fs');
const path = require('path');

const ROOT_DIR = path.join(__dirname, '..');
const SKILL_FILE = path.join(ROOT_DIR, 'transcribe.js');

// Scripts that should NOT exist (API-based or broken)
const FORBIDDEN_SCRIPTS = [
  'scripts/transcribe.js',        // Issue #1: expects JSON but gets plain text
  'scripts/transcribe_auto.js'    // Issue #2: uses langdetect on audio bytes
];

// Patterns that indicate hardcoded user-specific paths (not comments)
const HARDCODED_PATH_PATTERNS = [
  /\/home\/[a-zA-Z0-9_-]+\//,       // /home/username/ (actual path)
  /\/Users\/[a-zA-Z0-9_]+\//,       // /Users/username/ (macOS actual path)
  /C:\\\\Users\\\\[a-zA-Z0-9_]+\\/, // C:\\Users\\username\\ (Windows actual path)
];

function checkForHardcodedPaths(filePath) {
  const content = fs.readFileSync(filePath, 'utf-8');
  const issues = [];
  const lines = content.split('\n');
  let inBlockComment = false;
  
  for (let i = 0; i < lines.length; i++) {
    const line = lines[i];
    const trimmed = line.trim();
    
    // Track block comment state
    if (trimmed.startsWith('/*')) {
      inBlockComment = true;
    }
    if (trimmed.endsWith('*/')) {
      inBlockComment = false;
      continue;
    }
    
    // Skip comment lines
    if (inBlockComment || trimmed.startsWith('//') || trimmed.startsWith('*')) {
      continue;
    }
    
    for (const pattern of HARDCODED_PATH_PATTERNS) {
      const matches = line.match(pattern);
      if (matches) {
        issues.push(`Line ${i + 1}: Found hardcoded path: ${matches[0]}`);
      }
    }
  }
  
  return issues;
}

function runTests() {
  let passed = 0;
  let failed = 0;

  console.log('🧪 Testing local-whisper skill structure...\n');

  // Test 1: Forbidden scripts should not exist
  console.log('Test 1: Checking for forbidden scripts (API-based)...');
  for (const script of FORBIDDEN_SCRIPTS) {
    const scriptPath = path.join(ROOT_DIR, script);
    if (fs.existsSync(scriptPath)) {
      console.log(`  ❌ FAIL: Forbidden script exists: ${script}`);
      failed++;
    } else {
      console.log(`  ✅ PASS: ${script} removed`);
      passed++;
    }
  }

  // Test 2: Main transcribe.js should exist
  console.log('\nTest 2: Checking for consolidated transcribe.js...');
  if (fs.existsSync(SKILL_FILE)) {
    console.log(`  ✅ PASS: transcribe.js exists`);
    passed++;
  } else {
    console.log(`  ❌ FAIL: transcribe.js missing`);
    failed++;
  }

  // Test 3: No hardcoded user paths in transcribe.js
  console.log('\nTest 3: Checking for hardcoded user paths...');
  if (fs.existsSync(SKILL_FILE)) {
    const issues = checkForHardcodedPaths(SKILL_FILE);
    if (issues.length > 0) {
      console.log(`  ❌ FAIL: transcribe.js:`);
      for (const issue of issues) {
        console.log(`       ${issue}`);
      }
      failed++;
    } else {
      console.log('  ✅ PASS: No hardcoded user paths found');
      passed++;
    }
  }

  // Summary
  console.log('\n' + '='.repeat(50));
  console.log(`Results: ${passed} passed, ${failed} failed`);
  
  if (failed === 0) {
    console.log('✅ All tests passed! Skill is LOCAL-ONLY and portable.');
    process.exit(0);
  } else {
    console.log('❌ Some tests failed.');
    process.exit(1);
  }
}

runTests();

#!/usr/bin/env node
/**
 * Whisper Voice Transcription (Unified CLI)
 * LOCAL transcription using OpenAI Whisper
 * 
 * Features:
 * - Dependency checking
 * - Smart model selection based on file size
 * - Language selection
 * - Custom output directory
 * 
 * Usage: node transcribe.js <audio_file> [options]
 * 
 * Options:
 *   --model <model>        Model size: tiny, base, small, medium, large
 *   --language <lang>      Language code: auto, en, de, es, fr, etc.
 *   --output-dir <dir>     Output directory for transcriptions
 *   --smart-model          Enable smart model selection (default: true)
 * 
 * Environment Variables:
 *   WHISPER_MODEL=small      Default model
 *   WHISPER_LANGUAGE=auto    Default language
 */

const { execSync, spawnSync } = require('child_process');
const fs = require('fs');
const path = require('path');

// Lockfile to prevent concurrent runs
const LOCKFILE = '/tmp/whisper-transcribe.lock';

// Configuration defaults
const DEFAULTS = {
  MODEL: process.env.WHISPER_MODEL || 'small',
  LANGUAGE: process.env.WHISPER_LANGUAGE || 'auto',
  SIZE_THRESHOLD_KB: 100  // File size threshold for smart model selection
};

/**
 * Lockfile management to prevent concurrent runs
 */
function acquireLock(force = false) {
  // Check if lockfile exists
  if (fs.existsSync(LOCKFILE)) {
    try {
      const pid = parseInt(fs.readFileSync(LOCKFILE, 'utf-8').trim(), 10);
      
      // Check if process is still running
      const isRunning = !isNaN(pid) && isProcessRunning(pid);
      
      if (isRunning) {
        if (force) {
          // Kill existing process and remove lock
          try {
            process.kill(pid, 'SIGTERM');
            console.log(`⚠️  Killed existing whisper process (PID: ${pid})`);
            // Wait a moment for cleanup
            execSync('sleep 0.5', { stdio: 'pipe' });
          } catch (e) {
            // Process might have exited already
          }
          fs.unlinkSync(LOCKFILE);
        } else {
          console.error(`\n❌ Error: Another whisper transcribe is already running (PID: ${pid}). Use --force to override.`);
          process.exit(1);
        }
      } else {
        // Stale lock - remove it
        console.log('⚠️  Removing stale lockfile from dead process');
        fs.unlinkSync(LOCKFILE);
      }
    } catch (e) {
      // If we can't read the lockfile, try to remove it
      try {
        fs.unlinkSync(LOCKFILE);
      } catch (e2) {
        // Ignore errors
      }
    }
  }
  
  // Create lockfile with current PID
  fs.writeFileSync(LOCKFILE, process.pid.toString());
}

function releaseLock() {
  try {
    if (fs.existsSync(LOCKFILE)) {
      const lockPid = fs.readFileSync(LOCKFILE, 'utf-8').trim();
      // Only remove if it's our lock
      if (lockPid === process.pid.toString()) {
        fs.unlinkSync(LOCKFILE);
      }
    }
  } catch (e) {
    // Ignore cleanup errors
  }
}

function isProcessRunning(pid) {
  try {
    // Check if process exists by sending signal 0
    process.kill(pid, 0);
    return true;
  } catch (e) {
    return false;
  }
}

function setupLockCleanup() {
  // Clean up lock on normal exit
  process.on('exit', releaseLock);
  
  // Clean up on signals
  ['SIGINT', 'SIGTERM', 'SIGUSR1', 'SIGUSR2'].forEach(signal => {
    process.on(signal, () => {
      releaseLock();
      process.exit(1);
    });
  });
  
  // Clean up on uncaught exceptions
  process.on('uncaughtException', (err) => {
    console.error('\n❌ Uncaught exception:', err.message);
    releaseLock();
    process.exit(1);
  });
}

/**
 * Auto-detect whisper binary location
 * No hardcoded user paths - uses environment variables and standard paths
 */
function findWhisperBinary() {
  // Allow explicit override via environment variable
  if (process.env.WHISPER_CMD) {
    return process.env.WHISPER_CMD;
  }
  
  // Use spawn to avoid shell evaluation.
  try {
    const cmdResult = spawnSync('which', ['whisper'], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
    if (cmdResult.status === 0 && cmdResult.stdout.trim()) {
      return cmdResult.stdout.trim();
    }
  } catch (e) {
    // Fall through to common paths
  }
  
  // Standard paths only (no user-specific hardcoded paths)
  const commonPaths = [
    '/usr/bin/whisper',
    '/usr/local/bin/whisper',
    `${process.env.HOME}/.local/bin/whisper`,
    `${process.env.HOME}/.nix-profile/bin/whisper`
  ];
  
  for (const binPath of commonPaths) {
    if (fs.existsSync(binPath)) {
      return binPath;
    }
  }
  
  return null;
}

/**
 * Check if dependencies are installed
 */
function checkDependencies() {
  const deps = {
    ffmpeg: false,
    whisper: false,
    python3: false
  };
  
  // Check FFmpeg
  try {
    execSync('ffmpeg -version', { encoding: 'utf-8', stdio: 'pipe' });
    deps.ffmpeg = true;
  } catch (e) {
    deps.ffmpeg = false;
  }
  
  // Check Whisper (using auto-detect)
  try {
    const whisperPath = findWhisperBinary();
    if (whisperPath) {
      const check = spawnSync(whisperPath, ['--help'], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] });
      if (check.status !== 0) throw new Error('whisper --help failed');
      deps.whisper = whisperPath;
    }
  } catch (e) {
    deps.whisper = false;
  }
  
  // Check Python
  try {
    execSync('python3 --version', { encoding: 'utf-8', stdio: 'pipe' });
    deps.python3 = true;
  } catch (e) {
    deps.python3 = false;
  }
  
  return deps;
}

/**
 * Display dependency status
 */
function showDependencies() {
  console.log('\n📦 Checking dependencies...\n');
  
  const deps = checkDependencies();
  const whisperPath = typeof deps.whisper === 'string' ? deps.whisper : (deps.whisper ? 'found' : 'not found');
  
  console.log(`  ffmpeg:   ${deps.ffmpeg ? '✅' : '❌'}`);
  console.log(`  whisper:  ${deps.whisper ? '✅' : '❌'} (${whisperPath})`);
  console.log(`  python3:  ${deps.python3 ? '✅' : '❌'}`);
  
  return deps;
}

/**
 * Install dependencies (show instructions)
 */
function showInstallInstructions() {
  console.log('\n📋 Installation instructions:\n');
  console.log('1. FFmpeg:');
  console.log('   # NixOS: Add to /etc/nixos/configuration.nix');
  console.log('   environment.systemPackages = with pkgs; [ ffmpeg ];');
  console.log('');
  console.log('   # Or try:');
  console.log('   nix-env -iA nixpkgs.ffmpeg');
  console.log('');
  console.log('2. OpenAI Whisper:');
  console.log('   pip install openai-whisper ffmpeg-python');
  console.log('');
  console.log('   # Or with GPU support:');
  console.log('   pip install openai-whisper[torch]');
  console.log('');
}

/**
 * Supported audio formats (Whisper CLI accepts these directly)
 * No conversion needed for these formats
 */
const SUPPORTED_FORMATS = ['.wav', '.mp3', '.m4a', '.flac', '.ogg'];

/**
 * Check if audio format is supported by Whisper CLI
 */
function isSupportedFormat(audioPath) {
  const ext = path.extname(audioPath).toLowerCase();
  return SUPPORTED_FORMATS.includes(ext);
}

/**
 * Select model based on file size (smart selection)
 */
function selectModel(filePath, options = {}) {
  // If explicit model is specified, use it
  if (options.model && options.model !== 'auto') {
    return options.model;
  }
  
  // Default to small model (good balance of speed/accuracy)
  const stats = fs.statSync(filePath);
  const sizeKB = stats.size / 1024;
  console.log(`📏 File size: ${sizeKB.toFixed(1)}KB`);
  console.log(`🧠 Model: small (default)`);
  return 'small';
}

/**
 * Run Whisper transcription
 */
function transcribeWithWhisper(inputPath, options = {}) {
  const whisperPath = findWhisperBinary();
  if (!whisperPath) {
    throw new Error('Whisper binary not found. Please install: pip install openai-whisper');
  }
  
  // Determine model
  let model;
  if (options.smartModel !== false && !options.model) {
    model = selectModel(inputPath, { model: 'auto' });
  } else {
    model = options.model || DEFAULTS.MODEL;
    console.log(`🧠 Using model: ${model}`);
  }
  
  const language = options.language || DEFAULTS.LANGUAGE;
  const outputDir = options.outputDir || path.dirname(inputPath);
  
  console.log(`🎙️ Transcribing with Whisper...`);
  
  const args = [
    inputPath,
    '--model',
    model,
    '--output_format',
    'all',
    '--output_dir',
    outputDir
  ];
  // Only add --language if not "auto" (Whisper auto-detects when flag is omitted)
  if (language && language.toLowerCase() !== 'auto') {
    args.push('--language', language);
  }

  try {
    const result = spawnSync(whisperPath, args, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] });
    if (result.status !== 0) {
      const err = (result.stderr || result.stdout || '').trim();
      throw new Error(err || `whisper exited with status ${result.status}`);
    }
    
    // Read the transcription
    const txtPath = inputPath.replace(/\.[^/.]+$/, '.txt');
    const outputTxtPath = path.join(outputDir, path.basename(txtPath));
    
    const finalTxtPath = fs.existsSync(outputTxtPath) ? outputTxtPath : txtPath;
    
    if (fs.existsSync(finalTxtPath)) {
      const text = fs.readFileSync(finalTxtPath, 'utf-8');
      return { text, txtPath: finalTxtPath, model, language };
    } else {
      throw new Error('Transcription file not found');
    }
  } catch (error) {
    throw new Error(`Whisper transcription failed: ${error.message}`);
  }
}

/**
 * Main transcription function
 */
function transcribe(audioPath, options = {}) {
  console.log(`\n🎙️ Whisper Voice Transcription`);
  console.log('='.repeat(50));
  console.log(`📁 Input: ${audioPath}`);
  console.log(`🌐 Language: ${options.language || DEFAULTS.LANGUAGE}`);
  console.log(`📂 Output: ${options.outputDir || 'same as input'}`);
  
  if (!fs.existsSync(audioPath)) {
    throw new Error(`Audio file not found: ${audioPath}`);
  }
  
  // Validate audio format
  if (!isSupportedFormat(audioPath)) {
    const ext = path.extname(audioPath).toLowerCase() || 'unknown';
    throw new Error(`Unsupported audio format: ${ext}. Supported formats: ${SUPPORTED_FORMATS.join(', ')}`);
  }
  
  // Transcribe directly (Whisper CLI supports MP3, M4A, FLAC, OGG natively)
  const result = transcribeWithWhisper(audioPath, options);
  
  console.log('\n' + '='.repeat(50));
  console.log('📝 Transcription:');
  console.log('-'.repeat(50));
  console.log(result.text);
  console.log('-'.repeat(50));
  console.log(`\n💾 Saved to: ${result.txtPath}`);
  console.log(`🧠 Model used: ${result.model}`);
  console.log('✅ Transcription complete!\n');
  
  return result;
}

/**
 * Parse command line arguments
 */
function parseArgs(args) {
  const options = {
    model: null,
    language: null,
    outputDir: null,
    smartModel: true,
    force: false
  };
  
  let audioPath = null;
  
  for (let i = 0; i < args.length; i++) {
    const arg = args[i];
    
    switch (arg) {
      case '--model':
        options.model = args[++i];
        options.smartModel = false;  // Disable smart model if explicit
        break;
      case '--language':
      case '--lang':
      case '-l':
        options.language = args[++i];
        break;
      case '--output-dir':
      case '--output':
      case '-o':
        options.outputDir = args[++i];
        break;
      case '--smart-model':
        options.smartModel = true;
        break;
      case '--no-smart-model':
        options.smartModel = false;
        break;
      case '--force':
      case '-f':
        options.force = true;
        break;
      case '--help':
      case '-h':
        showHelp();
        process.exit(0);
        break;
      case '--version':
      case '-v':
        console.log('transcribe.js v1.0.0');
        process.exit(0);
        break;
      case '--check':
      case '-c':
        showDependencies();
        showInstallInstructions();
        process.exit(0);
        break;
      default:
        if (!arg.startsWith('-') && !audioPath) {
          audioPath = arg;
        }
        break;
    }
  }
  
  return { audioPath, options };
}

/**
 * Show help message
 */
function showHelp() {
  console.log(`
🎙️ Whisper Voice Transcription (Unified CLI)
============================================

Transcribe audio files locally using OpenAI Whisper.

USAGE:
  node transcribe.js <audio_file> [OPTIONS]

ARGUMENTS:
  audio_file              Path to audio file (WAV, MP3, M4A, FLAC, OGG)

OPTIONS:
  --model <model>         Model size: tiny, base, small, medium, large
  --language <lang>       Language code: auto (default), en, de, es, fr, etc.
  --output-dir <dir>      Output directory for transcriptions
  --smart-model           Enable smart model selection (default: on)
  --no-smart-model        Disable smart model selection
  --force, -f             Force run, kill any existing whisper process
  --check, -c             Check dependencies and show status
  --help, -h              Show this help message
  --version, -v           Show version

ENVIRONMENT VARIABLES:
  WHISPER_MODEL=small     Default model (tiny, base, small, medium, large)
  WHISPER_LANGUAGE=auto   Default language (auto, en, de, es, etc.)

SMART MODEL SELECTION:
  When enabled (default), automatically selects model based on file size:
  - Files < 100KB: Uses 'large' model (max accuracy)
  - Files >= 100KB: Uses 'medium' model (faster)

EXAMPLES:
  # Auto-detect language with smart model selection
  node transcribe.js voice.ogg

  # German language
  node transcribe.js voice.ogg --language de

  # Specific model
  node transcribe.js voice.ogg --model large

  # Custom output directory
  node transcribe.js voice.ogg --output-dir ~/transcriptions/

  # Disable smart model, use environment default
  node transcribe.js voice.ogg --no-smart-model

  # Check dependencies
  node transcribe.js --check

MODEL SIZES:
  tiny   - 39 MB   - ⚡⚡⚡⚡ Fast, ⭐⭐ Lower accuracy
  base   - 74 MB   - ⚡⚡⚡  Fast, ⭐⭐⭐ Good accuracy
  small  - 244 MB  - ⚡⚡   Medium, ⭐⭐⭐⭐ Better accuracy
  medium - 769 MB  - ⚡    Slow, ⭐⭐⭐⭐⭐ High accuracy
  large  - 1550 MB - 🐢    Slowest, ⭐⭐⭐⭐⭐ Best accuracy
`);
}

// Main entry point
function main() {
  const { audioPath, options } = parseArgs(process.argv.slice(2));
  
  // Acquire lock before any processing
  acquireLock(options.force);
  setupLockCleanup();
  
  if (!audioPath) {
    showHelp();
    process.exit(1);
  }
  
  // Check dependencies
  const deps = checkDependencies();
  if (!deps.whisper || !deps.ffmpeg) {
    console.log('\n❌ Missing dependencies!');
    showDependencies();
    showInstallInstructions();
    process.exit(1);
  }
  
  try {
    transcribe(audioPath, options);
    process.exit(0);
  } catch (error) {
    console.error(`\n❌ Error: ${error.message}`);
    process.exit(1);
  }
}

// Run if called directly
if (require.main === module) {
  main();
}

// Export for testing
module.exports = {
  transcribe,
  checkDependencies,
  findWhisperBinary,
  selectModel,
  isSupportedFormat,
  SUPPORTED_FORMATS,
  parseArgs,
  DEFAULTS,
  acquireLock,
  releaseLock,
  isProcessRunning,
  setupLockCleanup,
  LOCKFILE
};

0.1.0