@hasna/skills 0.1.27 → 0.1.30

package/skills/transcript/src/chunker.ts

@@ -1,215 +0,0 @@
-/**
- * Audio Chunker
- * Splits large audio files into smaller chunks for transcription
- */
-
-import { spawn } from 'child_process';
-import { mkdir, rm, stat, readdir } from 'fs/promises';
-import { join, basename, extname } from 'path';
-import type { ChunkInfo } from './types';
-
-// Default chunk duration in seconds (10 minutes)
-const DEFAULT_CHUNK_DURATION = 600;
-// Overlap in seconds to prevent word cutoff
-const CHUNK_OVERLAP = 10;
-
-export async function getAudioDuration(filePath: string): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const ffprobe = spawn('ffprobe', [
-      '-v', 'error',
-      '-show_entries', 'format=duration',
-      '-of', 'default=noprint_wrappers=1:nokey=1',
-      filePath
-    ]);
-
-    let output = '';
-    let error = '';
-
-    ffprobe.stdout.on('data', (data) => {
-      output += data.toString();
-    });
-
-    ffprobe.stderr.on('data', (data) => {
-      error += data.toString();
-    });
-
-    ffprobe.on('close', (code) => {
-      if (code !== 0) {
-        reject(new Error(`ffprobe failed: ${error}`));
-        return;
-      }
-      const duration = parseFloat(output.trim());
-      if (isNaN(duration)) {
-        reject(new Error('Could not parse audio duration'));
-        return;
-      }
-      resolve(duration);
-    });
-  });
-}
-
-export async function getFileSize(filePath: string): Promise<number> {
-  const stats = await stat(filePath);
-  return stats.size;
-}
-
-export async function needsChunking(filePath: string, maxSize: number): Promise<boolean> {
-  const size = await getFileSize(filePath);
-  return size > maxSize;
-}
-
-export async function splitAudioFile(
-  inputPath: string,
-  outputDir: string,
-  chunkDuration: number = DEFAULT_CHUNK_DURATION
-): Promise<ChunkInfo[]> {
-  console.log(`[Chunker] Splitting audio file: ${inputPath}`);
-
-  // Create output directory
-  const chunkDir = join(outputDir, '.chunks');
-  await mkdir(chunkDir, { recursive: true });
-
-  const duration = await getAudioDuration(inputPath);
-  const baseName = basename(inputPath, extname(inputPath));
-  const ext = extname(inputPath) || '.mp3';
-
-  console.log(`[Chunker] Total duration: ${Math.round(duration)}s`);
-  console.log(`[Chunker] Chunk duration: ${chunkDuration}s with ${CHUNK_OVERLAP}s overlap`);
-
-  const chunks: ChunkInfo[] = [];
-  let startTime = 0;
-  let chunkIndex = 0;
-
-  while (startTime < duration) {
-    const chunkPath = join(chunkDir, `${baseName}_chunk_${String(chunkIndex).padStart(3, '0')}${ext}`);
-    const endTime = Math.min(startTime + chunkDuration, duration);
-
-    await createChunk(inputPath, chunkPath, startTime, chunkDuration + CHUNK_OVERLAP);
-
-    const chunkSize = await getFileSize(chunkPath);
-
-    chunks.push({
-      index: chunkIndex,
-      startTime,
-      endTime,
-      path: chunkPath,
-      size: chunkSize
-    });
-
-    console.log(`[Chunker] Created chunk ${chunkIndex + 1}: ${Math.round(startTime)}s - ${Math.round(endTime)}s (${(chunkSize / 1024 / 1024).toFixed(2)}MB)`);
-
-    startTime += chunkDuration;
-    chunkIndex++;
-  }
-
-  console.log(`[Chunker] Created ${chunks.length} chunks`);
-  return chunks;
-}
-
-async function createChunk(
-  inputPath: string,
-  outputPath: string,
-  startTime: number,
-  duration: number
-): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const ffmpeg = spawn('ffmpeg', [
-      '-y',
-      '-i', inputPath,
-      '-ss', startTime.toString(),
-      '-t', duration.toString(),
-      '-acodec', 'copy',
-      outputPath
-    ]);
-
-    let error = '';
-
-    ffmpeg.stderr.on('data', (data) => {
-      error += data.toString();
-    });
-
-    ffmpeg.on('close', (code) => {
-      if (code !== 0) {
-        reject(new Error(`ffmpeg chunk creation failed: ${error}`));
-        return;
-      }
-      resolve();
-    });
-  });
-}
-
-export async function compressAudio(
-  inputPath: string,
-  outputPath: string,
-  targetBitrate: string = '32k'
-): Promise<string> {
-  console.log(`[Chunker] Compressing audio: ${inputPath}`);
-  console.log(`[Chunker] Target bitrate: ${targetBitrate}`);
-
-  return new Promise((resolve, reject) => {
-    const ffmpeg = spawn('ffmpeg', [
-      '-y',
-      '-i', inputPath,
-      '-vn',                     // No video
-      '-map_metadata', '-1',     // Remove metadata
-      '-ac', '1',                // Mono
-      '-c:a', 'libopus',         // Opus codec (best compression for voice)
-      '-b:a', targetBitrate,     // Target bitrate
-      '-application', 'voip',   // Optimized for voice
-      outputPath
-    ]);
-
-    let error = '';
-
-    ffmpeg.stderr.on('data', (data) => {
-      error += data.toString();
-    });
-
-    ffmpeg.on('close', async (code) => {
-      if (code !== 0) {
-        reject(new Error(`ffmpeg compression failed: ${error}`));
-        return;
-      }
-      const newSize = await getFileSize(outputPath);
-      console.log(`[Chunker] Compressed size: ${(newSize / 1024 / 1024).toFixed(2)}MB`);
-      resolve(outputPath);
-    });
-  });
-}
-
-export async function cleanupChunks(chunkDir: string): Promise<void> {
-  try {
-    await rm(chunkDir, { recursive: true, force: true });
-    console.log('[Chunker] Cleaned up temporary chunks');
-  } catch {
-    // Ignore cleanup errors
-  }
-}
-
-export function mergeTranscriptions(
-  transcriptions: string[],
-  chunkDuration: number = DEFAULT_CHUNK_DURATION,
-  overlap: number = CHUNK_OVERLAP
-): string {
-  if (transcriptions.length === 0) return '';
-  if (transcriptions.length === 1) return transcriptions[0];
-
-  // Simple merge strategy: trim overlap from the beginning of each chunk except the first
-  // This is a basic approach; more sophisticated overlap detection could be added
-  const merged: string[] = [transcriptions[0]];
-
-  for (let i = 1; i < transcriptions.length; i++) {
-    const text = transcriptions[i];
-    // Remove potential duplicate sentences at the beginning
-    // This is a heuristic approach
-    const sentences = text.split(/(?<=[.!?])\s+/);
-    if (sentences.length > 1) {
-      // Skip first sentence as it likely overlaps with previous chunk
-      merged.push(sentences.slice(1).join(' '));
-    } else {
-      merged.push(text);
-    }
-  }
-
-  return merged.join('\n\n');
-}

package/skills/transcript/src/formatter.ts

@@ -1,134 +0,0 @@
-/**
- * Output Formatter
- * Converts transcription results to various output formats
- */
-
-import type { TranscriptionResult, TranscriptionSegment } from './types';
-
-export type OutputFormat = 'text' | 'srt' | 'vtt' | 'json';
-
-export function formatOutput(result: TranscriptionResult, format: OutputFormat): string {
-  switch (format) {
-    case 'text':
-      return formatText(result);
-    case 'srt':
-      return formatSRT(result);
-    case 'vtt':
-      return formatVTT(result);
-    case 'json':
-      return formatJSON(result);
-    default:
-      return formatText(result);
-  }
-}
-
-function formatText(result: TranscriptionResult): string {
-  if (!result.segments || result.segments.length === 0) {
-    return result.text;
-  }
-
-  // Format with speaker labels if available
-  let output = '';
-  let currentSpeaker = '';
-
-  for (const segment of result.segments) {
-    if (segment.speaker && segment.speaker !== currentSpeaker) {
-      currentSpeaker = segment.speaker;
-      output += `\n[${currentSpeaker}]\n`;
-    }
-    output += segment.text + ' ';
-  }
-
-  return output.trim();
-}
-
-function formatSRT(result: TranscriptionResult): string {
-  if (!result.segments || result.segments.length === 0) {
-    // Create a single segment if no segments available
-    return `1\n00:00:00,000 --> 00:00:00,000\n${result.text}\n`;
-  }
-
-  let srt = '';
-
-  for (let i = 0; i < result.segments.length; i++) {
-    const segment = result.segments[i];
-    const startTime = formatTimestamp(segment.start, 'srt');
-    const endTime = formatTimestamp(segment.end, 'srt');
-
-    srt += `${i + 1}\n`;
-    srt += `${startTime} --> ${endTime}\n`;
-
-    if (segment.speaker) {
-      srt += `<v ${segment.speaker}>${segment.text}\n`;
-    } else {
-      srt += `${segment.text}\n`;
-    }
-
-    srt += '\n';
-  }
-
-  return srt.trim();
-}
-
-function formatVTT(result: TranscriptionResult): string {
-  let vtt = 'WEBVTT\n\n';
-
-  if (!result.segments || result.segments.length === 0) {
-    vtt += `00:00:00.000 --> 00:00:00.000\n${result.text}\n`;
-    return vtt;
-  }
-
-  for (const segment of result.segments) {
-    const startTime = formatTimestamp(segment.start, 'vtt');
-    const endTime = formatTimestamp(segment.end, 'vtt');
-
-    vtt += `${startTime} --> ${endTime}\n`;
-
-    if (segment.speaker) {
-      vtt += `<v ${segment.speaker}>${segment.text}\n`;
-    } else {
-      vtt += `${segment.text}\n`;
-    }
-
-    vtt += '\n';
-  }
-
-  return vtt.trim();
-}
-
-function formatJSON(result: TranscriptionResult): string {
-  return JSON.stringify(result, null, 2);
-}
-
-function formatTimestamp(seconds: number, format: 'srt' | 'vtt'): string {
-  const hours = Math.floor(seconds / 3600);
-  const minutes = Math.floor((seconds % 3600) / 60);
-  const secs = Math.floor(seconds % 60);
-  const ms = Math.round((seconds % 1) * 1000);
-
-  const hh = String(hours).padStart(2, '0');
-  const mm = String(minutes).padStart(2, '0');
-  const ss = String(secs).padStart(2, '0');
-  const mmm = String(ms).padStart(3, '0');
-
-  if (format === 'srt') {
-    return `${hh}:${mm}:${ss},${mmm}`;
-  } else {
-    return `${hh}:${mm}:${ss}.${mmm}`;
-  }
-}
-
-export function getOutputExtension(format: OutputFormat): string {
-  switch (format) {
-    case 'text':
-      return '.txt';
-    case 'srt':
-      return '.srt';
-    case 'vtt':
-      return '.vtt';
-    case 'json':
-      return '.json';
-    default:
-      return '.txt';
-  }
-}

package/skills/transcript/src/index-local.ts

@@ -1,226 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * Transcription CLI
- * Speech-to-text using ElevenLabs, OpenAI Whisper, or Google Gemini
- * Supports automatic chunking for large files
- */
-import { handleInstallCommand } from '../../_common';
-
-
-// Handle install/uninstall commands
-const SKILL_META = {
-  name: 'transcript',
-  description: 'Audio/video transcription skill supporting ElevenLabs, OpenAI Whisper, and Google Gemini with automatic chunking for large files',
-  version: '1.0.0',
-  commands: `Use: transcript --help`,
-  requiredEnvVars: ['SKILL_API_KEY'],
-};
-
-if (await handleInstallCommand(SKILL_META, process.argv.slice(2))) {
-  process.exit(0);
-}
-
-import { getProvider, getProviderInfo } from './providers';
-import { formatOutput, getOutputExtension } from './formatter';
-import type { Provider, TranscriptionOptions } from './types';
-import type { OutputFormat } from './formatter';
-import { basename, extname, dirname, join } from 'path';
-
-// Parse command line arguments
-function parseArgs(): {
-  command: string;
-  input?: string;
-  output?: string;
-  provider?: Provider;
-  language?: string;
-  model?: string;
-  diarize?: boolean;
-  timestamps?: boolean;
-  format?: OutputFormat;
-} {
-  const args = process.argv.slice(2);
-  const parsed: any = { command: args[0] || 'help' };
-
-  for (let i = 1; i < args.length; i++) {
-    const arg = args[i];
-    if (arg.startsWith('--')) {
-      const key = arg.replace(/^--/, '');
-
-      if (key === 'diarize' || key === 'timestamps') {
-        parsed[key] = true;
-      } else {
-        parsed[key] = args[++i];
-      }
-    }
-  }
-
-  return parsed;
-}
-
-// Display help information
-function showHelp(): void {
-  console.log(`
-Transcription CLI - Speech-to-text with automatic chunking
-
-USAGE:
-  bun run src/index.ts <command> [options]
-
-COMMANDS:
-  transcribe    Transcribe an audio/video file
-  providers     Show available providers and their capabilities
-  help          Show this help message
-
-TRANSCRIBE OPTIONS:
-  --input <path>        Input audio/video file (required)
-  --output <path>       Output file path (optional, defaults to input name + format extension)
-  --provider <name>     Provider: elevenlabs, openai, gemini (required)
-  --language <code>     Language code, e.g., en, es, fr (optional)
-  --model <name>        Specific model to use (optional)
-  --diarize             Enable speaker diarization (ElevenLabs, Gemini)
-  --timestamps          Include timestamps in output
-  --format <type>       Output format: text, srt, vtt, json (default: text)
-
-SUPPORTED FORMATS:
-  Audio: mp3, wav, m4a, ogg, flac, aac, webm
-  Video: mp4, webm
-
-EXAMPLES:
-  # Basic transcription with OpenAI Whisper
-  bun run src/index.ts transcribe \\
-    --provider openai \\
-    --input ./recording.mp3 \\
-    --output ./transcript.txt
-
-  # Transcription with speaker diarization (ElevenLabs)
-  bun run src/index.ts transcribe \\
-    --provider elevenlabs \\
-    --input ./meeting.mp3 \\
-    --diarize \\
-    --timestamps \\
-    --format srt
-
-  # Cost-effective transcription (Gemini)
-  bun run src/index.ts transcribe \\
-    --provider gemini \\
-    --input ./podcast.mp3 \\
-    --format vtt
-
-  # Transcribe with specific language
-  bun run src/index.ts transcribe \\
-    --provider openai \\
-    --input ./spanish.mp3 \\
-    --language es \\
-    --format json
-
-LARGE FILE HANDLING:
-  - ElevenLabs: Up to 3GB (native support)
-  - Gemini: Up to 2GB (auto-chunking for efficiency)
-  - OpenAI: 25MB limit (automatic compression/chunking for larger files)
-
-ENVIRONMENT VARIABLES:
-  ELEVENLABS_API_KEY    API key for ElevenLabs Scribe
-  OPENAI_API_KEY        API key for OpenAI Whisper
-  GOOGLE_API_KEY        API key for Google Gemini
-
-DEPENDENCIES:
-  - ffmpeg (required for chunking large files with OpenAI)
-  - ffprobe (required for audio duration detection)
-`);
-}
-
-// Main CLI handler
-async function main(): Promise<void> {
-  const args = parseArgs();
-
-  try {
-    switch (args.command) {
-      case 'transcribe': {
-        if (!args.input) {
-          console.error('Error: --input is required');
-          console.error('Use: bun run src/index.ts help');
-          process.exit(1);
-        }
-        if (!args.provider) {
-          console.error('Error: --provider is required');
-          console.error('Available providers: elevenlabs, openai, gemini');
-          process.exit(1);
-        }
-
-        const provider = getProvider(args.provider as Provider);
-        console.log(`\nUsing ${provider.name}`);
-        console.log(`Max file size: ${(provider.maxFileSize / 1024 / 1024 / 1024).toFixed(1)}GB`);
-        console.log('');
-
-        const options: TranscriptionOptions = {
-          input: args.input,
-          output: args.output,
-          provider: args.provider as Provider,
-          language: args.language,
-          model: args.model,
-          diarize: args.diarize,
-          timestamps: args.timestamps,
-          format: (args.format as OutputFormat) || 'text'
-        };
-
-        const result = await provider.transcribe(options);
-
-        // Format output
-        const format = (args.format as OutputFormat) || 'text';
-        const formattedOutput = formatOutput(result, format);
-
-        // Determine output path
-        let outputPath = args.output;
-        if (!outputPath) {
-          const inputDir = dirname(args.input);
-          const inputName = basename(args.input, extname(args.input));
-          outputPath = join(inputDir, `${inputName}${getOutputExtension(format)}`);
-        }
-
-        // Write output
-        await Bun.write(outputPath, formattedOutput);
-
-        console.log(`\nTranscription complete!`);
-        console.log(`Output: ${outputPath}`);
-        console.log(`Format: ${format}`);
-
-        if (result.duration) {
-          console.log(`Duration: ${Math.round(result.duration)}s`);
-        }
-        if (result.language) {
-          console.log(`Detected language: ${result.language}`);
-        }
-        if (result.segments) {
-          console.log(`Segments: ${result.segments.length}`);
-        }
-        if (result.speakers) {
-          console.log(`Speakers: ${result.speakers.length}`);
-        }
-
-        // Show word count
-        const wordCount = result.text.split(/\s+/).length;
-        console.log(`Words: ${wordCount.toLocaleString()}`);
-        break;
-      }
-
-      case 'providers':
-        getProviderInfo();
-        break;
-
-      case 'help':
-        showHelp();
-        break;
-
-      default:
-        console.error(`Unknown command: ${args.command}`);
-        console.error('Use: bun run src/index.ts help');
-        process.exit(1);
-    }
-  } catch (error) {
-    console.error('Error:', error instanceof Error ? error.message : String(error));
-    process.exit(1);
-  }
-}
-
-// Run the CLI
-main();

package/skills/transcript/src/index.ts

@@ -1,110 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * Skill Transcript (HTTP Client)
- * Calls the remote skill API server 
- */
-
-import { executeAndSave, executeSkill, handleInstallCommand } from '../../_common';
-
-// Skill metadata for install command
-const SKILL_META = {
-  name: 'transcript',
-  description: 'Transcript skill - calls remote API',
-  version: '1.0.0',
-  commands: `transcript <command> [options]`,
-  requiredEnvVars: ['SKILL_API_KEY'],
-};
-
-// Handle install/uninstall commands
-if (await handleInstallCommand(SKILL_META, process.argv.slice(2))) {
-  process.exit(0);
-}
-
-// Parse command line arguments
-function parseArgs(): Record<string, string | boolean> {
-  const args = process.argv.slice(2);
-  const parsed: Record<string, string | boolean> = {};
-
-  for (let i = 0; i < args.length; i++) {
-    if (args[i].startsWith('--')) {
-      const key = args[i].slice(2);
-      const value = args[i + 1];
-      if (value && !value.startsWith('--')) {
-        parsed[key] = value;
-        i++;
-      } else {
-        parsed[key] = true;
-      }
-    } else if (!parsed.command) {
-      parsed.command = args[i];
-    }
-  }
-
-  return parsed;
-}
-
-// Main logic
-async function main() {
-  const args = parseArgs();
-  const command = (args.command as string) || 'help';
-
-  if (command === 'help' || args.help) {
-    console.log(`Skill Transcript CLI
-
-USAGE:
-  transcript <command> [options]
-
-COMMANDS:
-  Call with any command and it will be forwarded to the remote API server
-
-EXAMPLES:
-  transcript generate --provider <provider> [options]`);
-    return;
-  }
-
-  // Extract all parameters
-  const { command: cmd, ...params } = args;
-
-  // Check if output file is expected (for file-generating skills)
-  const fileSkills = ['audio', 'image', 'video', 'emoji'];
-  const isFileSkill = fileSkills.includes('transcript');
-
-  if (isFileSkill && params.output) {
-    // Skill that generates files
-    const success = await executeAndSave({
-      skill: 'transcript',
-      command: cmd,
-      ...params,
-    });
-    process.exit(success ? 0 : 1);
-  } else {
-    // Skill that returns JSON/text
-    const result = await executeSkill({
-      skill: 'transcript',
-      command: cmd,
-      ...params,
-    });
-
-    if (result instanceof Blob) {
-      console.error('❌ Unexpected binary response');
-      process.exit(1);
-    }
-
-    if (result.success && result.output) {
-      console.log(result.output);
-    } else {
-      console.error(`❌ Error: ${result.error}`);
-      if (result.details) {
-        console.error(`   ${result.details}`);
-      }
-      process.exit(1);
-    }
-  }
-}
-
-// Run main
-main().catch((error) => {
-  console.error('❌ Fatal error:', error.message);
-  process.exit(1);
-});