@hasna/skills 0.1.26 → 0.1.29

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);
-});

package/skills/transcript/src/providers/elevenlabs.ts

@@ -1,133 +0,0 @@
-/**
- * ElevenLabs Scribe Provider
- * High-accuracy speech-to-text with speaker diarization
- */
-
-import type {
-  TranscriptionProvider,
-  TranscriptionOptions,
-  TranscriptionResult,
-  TranscriptionSegment,
-  ElevenLabsResponse
-} from '../types';
-
-// ElevenLabs supports up to 3GB files
-const MAX_FILE_SIZE = 3 * 1024 * 1024 * 1024; // 3GB
-
-export class ElevenLabsProvider implements TranscriptionProvider {
-  name = 'ElevenLabs Scribe';
-  maxFileSize = MAX_FILE_SIZE;
-  supportedFormats = ['mp3', 'mp4', 'wav', 'webm', 'm4a', 'ogg', 'flac'];
-
-  private apiKey: string;
-  private baseUrl = 'https://api.elevenlabs.io/v1';
-
-  constructor() {
-    const apiKey = process.env.ELEVENLABS_API_KEY;
-    if (!apiKey) {
-      throw new Error('ELEVENLABS_API_KEY environment variable is required');
-    }
-    this.apiKey = apiKey;
-  }
-
-  async transcribe(options: TranscriptionOptions): Promise<TranscriptionResult> {
-    const {
-      input,
-      language,
-      model = 'scribe_v1',
-      diarize = true,
-      timestamps = true
-    } = options;
-
-    console.log(`[ElevenLabs] Transcribing: ${input}`);
-    console.log(`[ElevenLabs] Model: ${model}`);
-    console.log(`[ElevenLabs] Diarization: ${diarize}`);
-
-    // Read the file
-    const file = Bun.file(input);
-    const fileBuffer = await file.arrayBuffer();
-
-    // Create form data
-    const formData = new FormData();
-    formData.append('audio', new Blob([fileBuffer]), input.split('/').pop());
-    formData.append('model_id', model);
-
-    if (language) {
-      formData.append('language_code', language);
-    }
-
-    if (diarize) {
-      formData.append('diarize', 'true');
-      formData.append('num_speakers', '32'); // Max supported speakers
-    }
-
-    if (timestamps) {
-      formData.append('timestamps_granularity', 'word');
-    }
-
-    const response = await fetch(`${this.baseUrl}/speech-to-text`, {
-      method: 'POST',
-      headers: {
-        'xi-api-key': this.apiKey
-      },
-      body: formData
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`ElevenLabs transcription failed: ${error}`);
-    }
-
-    const data = await response.json() as ElevenLabsResponse;
-    console.log(`[ElevenLabs] Transcription complete`);
-
-    return this.formatResult(data, model);
-  }
-
-  private formatResult(data: ElevenLabsResponse, model: string): TranscriptionResult {
-    const segments: TranscriptionSegment[] = [];
-
-    if (data.words) {
-      let currentSegment: TranscriptionSegment | null = null;
-      let segmentId = 0;
-
-      for (const word of data.words) {
-        if (!currentSegment || word.speaker !== currentSegment.speaker) {
-          if (currentSegment) {
-            segments.push(currentSegment);
-          }
-          currentSegment = {
-            id: segmentId++,
-            start: word.start,
-            end: word.end,
-            text: word.word,
-            speaker: word.speaker
-          };
-        } else {
-          currentSegment.end = word.end;
-          currentSegment.text += ' ' + word.word;
-        }
-      }
-
-      if (currentSegment) {
-        segments.push(currentSegment);
-      }
-    }
-
-    const speakers = data.speakers?.map(s => ({
-      id: s.speaker_id,
-      name: s.name,
-      segments: segments
-        .filter(seg => seg.speaker === s.speaker_id)
-        .map(seg => seg.id)
-    }));
-
-    return {
-      text: data.text,
-      segments: segments.length > 0 ? segments : undefined,
-      speakers,
-      model,
-      provider: 'elevenlabs'
-    };
-  }
-}

package/skills/transcript/src/providers/gemini.ts

@@ -1,192 +0,0 @@
-/**
- * Google Gemini Provider
- * Multimodal transcription with analysis capabilities
- */
-
-import { readFile } from 'fs/promises';
-import type {
-  TranscriptionProvider,
-  TranscriptionOptions,
-  TranscriptionResult,
-  GeminiResponse
-} from '../types';
-import { getFileSize, needsChunking, splitAudioFile, mergeTranscriptions, cleanupChunks } from '../chunker';
-import { dirname, join } from 'path';
-
-// Gemini supports up to 2GB files
-const MAX_FILE_SIZE = 2 * 1024 * 1024 * 1024; // 2GB
-
-const MIME_TYPES: Record<string, string> = {
-  'mp3': 'audio/mpeg',
-  'wav': 'audio/wav',
-  'ogg': 'audio/ogg',
-  'flac': 'audio/flac',
-  'm4a': 'audio/mp4',
-  'aac': 'audio/aac',
-  'mp4': 'video/mp4',
-  'webm': 'video/webm'
-};
-
-export class GeminiProvider implements TranscriptionProvider {
-  name = 'Google Gemini';
-  maxFileSize = MAX_FILE_SIZE;
-  supportedFormats = ['mp3', 'wav', 'ogg', 'flac', 'm4a', 'aac', 'mp4', 'webm'];
-
-  private apiKey: string;
-  private baseUrl = 'https://generativelanguage.googleapis.com/v1beta';
-
-  constructor() {
-    const apiKey = process.env.GOOGLE_API_KEY;
-    if (!apiKey) {
-      throw new Error('GOOGLE_API_KEY environment variable is required');
-    }
-    this.apiKey = apiKey;
-  }
-
-  async transcribe(options: TranscriptionOptions): Promise<TranscriptionResult> {
-    const {
-      input,
-      language,
-      model = 'gemini-2.0-flash',
-      diarize = false,
-      timestamps = false
-    } = options;
-
-    console.log(`[Gemini] Transcribing: ${input}`);
-    console.log(`[Gemini] Model: ${model}`);
-
-    // Check file size
-    const fileSize = await getFileSize(input);
-    console.log(`[Gemini] File size: ${(fileSize / 1024 / 1024).toFixed(2)}MB`);
-
-    // For very large files, use chunking
-    if (fileSize > 100 * 1024 * 1024) { // > 100MB use chunking for efficiency
-      console.log(`[Gemini] Large file detected, using chunking for efficiency`);
-      return this.transcribeWithChunking(options);
-    }
-
-    return this.transcribeSingle(options);
-  }
-
-  private async transcribeSingle(options: TranscriptionOptions): Promise<TranscriptionResult> {
-    const {
-      input,
-      language,
-      model = 'gemini-2.0-flash',
-      diarize = false,
-      timestamps = false
-    } = options;
-
-    // Read and encode file
-    const fileBuffer = await readFile(input);
-    const base64Audio = fileBuffer.toString('base64');
-
-    // Determine MIME type
-    const ext = input.split('.').pop()?.toLowerCase() || 'mp3';
-    const mimeType = MIME_TYPES[ext] || 'audio/mpeg';
-
-    // Build prompt based on options
-    let prompt = 'Transcribe this audio accurately. ';
-
-    if (language) {
-      prompt += `The audio is in ${language}. `;
-    }
-
-    if (diarize) {
-      prompt += 'Identify and label different speakers (Speaker A, Speaker B, etc.). ';
-    }
-
-    if (timestamps) {
-      prompt += 'Include timestamps for each segment in [HH:MM:SS] format. ';
-    }
-
-    prompt += 'Provide only the transcription without any additional commentary.';
-
-    const response = await fetch(
-      `${this.baseUrl}/models/${model}:generateContent?key=${this.apiKey}`,
-      {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify({
-          contents: [
-            {
-              parts: [
-                {
-                  inline_data: {
-                    mime_type: mimeType,
-                    data: base64Audio
-                  }
-                },
-                {
-                  text: prompt
-                }
-              ]
-            }
-          ],
-          generationConfig: {
-            temperature: 0,
-            maxOutputTokens: 8192
-          }
-        })
-      }
-    );
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Gemini transcription failed: ${error}`);
-    }
-
-    const data = await response.json() as GeminiResponse;
-    const text = data.candidates?.[0]?.content?.parts?.[0]?.text || '';
-
-    console.log(`[Gemini] Transcription complete`);
-
-    return {
-      text: text.trim(),
-      model,
-      provider: 'gemini'
-    };
-  }
-
-  private async transcribeWithChunking(options: TranscriptionOptions): Promise<TranscriptionResult> {
-    const { input, model = 'gemini-2.0-flash' } = options;
-    const outputDir = dirname(input);
-
-    // Split into chunks
-    const chunks = await splitAudioFile(input, outputDir);
-    const transcriptions: string[] = [];
-
-    try {
-      // Process chunks in parallel (Gemini can handle concurrent requests)
-      const promises = chunks.map(async (chunk) => {
-        console.log(`[Gemini] Processing chunk ${chunk.index + 1}/${chunks.length}`);
-        const result = await this.transcribeSingle({
-          ...options,
-          input: chunk.path
-        });
-        return { index: chunk.index, text: result.text };
-      });
-
-      const results = await Promise.all(promises);
-
-      // Sort by index and extract texts
-      results.sort((a, b) => a.index - b.index);
-      transcriptions.push(...results.map(r => r.text));
-
-      // Merge transcriptions
-      const mergedText = mergeTranscriptions(transcriptions);
-
-      return {
-        text: mergedText,
-        model,
-        provider: 'gemini'
-      };
-    } finally {
-      // Cleanup chunks
-      const chunkDir = join(outputDir, '.chunks');
-      await cleanupChunks(chunkDir);
-    }
-  }
-}

package/skills/transcript/src/providers/index.ts

@@ -1,54 +0,0 @@
-/**
- * Provider Factory
- * Returns the appropriate transcription provider
- */
-
-import { ElevenLabsProvider } from './elevenlabs';
-import { OpenAIProvider } from './openai';
-import { GeminiProvider } from './gemini';
-import type { TranscriptionProvider, Provider } from '../types';
-
-export function getProvider(providerName: Provider): TranscriptionProvider {
-  switch (providerName) {
-    case 'elevenlabs':
-      return new ElevenLabsProvider();
-    case 'openai':
-      return new OpenAIProvider();
-    case 'gemini':
-      return new GeminiProvider();
-    default:
-      throw new Error(
-        `Unknown provider: ${providerName}. Available: elevenlabs, openai, gemini`
-      );
-  }
-}
-
-export function getProviderInfo(): void {
-  console.log(`
-Available Transcription Providers:
-
-ELEVENLABS (Scribe)
-  - Accuracy: 96.7% for English
-  - Max file size: 3GB / 10 hours
-  - Features: Speaker diarization (up to 32 speakers), word timestamps
-  - Cost: $0.40/hour
-  - Best for: Multi-speaker recordings, highest accuracy needs
-
-OPENAI (Whisper)
-  - Accuracy: Excellent
-  - Max file size: 25MB (auto-chunking for larger files)
-  - Features: Segment timestamps, language detection
-  - Cost: $0.006/min (GPT-4o Mini: $0.003/min)
-  - Best for: Standard transcription, good balance of cost/quality
-
-GEMINI (Flash)
-  - Accuracy: Very good
-  - Max file size: 2GB
-  - Features: Multimodal analysis, summarization
-  - Cost: ~$0.09-0.23/hour (generous free tier)
-  - Best for: Cost-sensitive, multimodal needs, free tier usage
-
-USAGE:
-  transcript transcribe --provider <name> --input <file> [options]
-`);
-}