@hasna/skills 0.1.26 → 0.1.29

package/skills/sound-effects/src/index.ts

@@ -1,172 +0,0 @@
-#!/usr/bin/env bun
-
-import { writeFile, mkdir } from 'fs/promises';
-import { resolve, dirname } from 'path';
-import { handleInstallCommand } from '../../_common';
-
-const SKILL_META = {
-  name: 'sound-effects',
-  description: 'Generate sound effects using AI (Minimax)',
-  version: '1.0.0',
-  commands: `Use: sound-effects --help`,
-  requiredEnvVars: ['MINIMAX_API_KEY'],
-};
-
-if (await handleInstallCommand(SKILL_META, process.argv.slice(2))) {
-  process.exit(0);
-}
-
-type Provider = 'minimax';
-
-interface GenerateOptions {
-  provider: Provider;
-  prompt: string;
-  output: string;
-  duration?: number;
-}
-
-function parseArgs(): GenerateOptions | null {
-  const args = process.argv.slice(2);
-
-  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
-    printHelp();
-    return null;
-  }
-
-  if (args[0] !== 'generate') {
-    console.error(`Unknown command: ${args[0]}`);
-    process.exit(1);
-  }
-
-  const options: Partial<GenerateOptions> = { provider: 'minimax' };
-
-  for (let i = 1; i < args.length; i++) {
-    switch (args[i]) {
-      case '--provider': case '-p': options.provider = args[++i] as Provider; break;
-      case '--prompt': options.prompt = args[++i]; break;
-      case '--output': case '-o': options.output = args[++i]; break;
-      case '--duration': options.duration = parseInt(args[++i]); break;
-      default: console.error(`Unknown option: ${args[i]}`); process.exit(1);
-    }
-  }
-
-  if (!options.prompt) { console.error('Error: --prompt is required'); process.exit(1); }
-  if (!options.output) { console.error('Error: --output is required'); process.exit(1); }
-
-  return options as GenerateOptions;
-}
-
-function printHelp() {
-  console.log(`
-Sound Effects Generation Skill
-
-Generate sound effects using AI models (Minimax)
-
-USAGE:
-  sound-effects generate [OPTIONS]
-
-OPTIONS:
-  --provider, -p <provider>   Provider (minimax) [default: minimax]
-  --prompt <text>             Description of the sound effect [required]
-  --output, -o <path>         Output file path [required]
-  --duration <seconds>        Duration in seconds
-
-EXAMPLES:
-  sound-effects generate --prompt "thunder rolling" --output ./thunder.mp3
-  sound-effects generate --prompt "footsteps on gravel" --duration 5 --output ./steps.mp3
-  sound-effects generate --prompt "rain on a tin roof" --output ./rain.mp3
-
-ENVIRONMENT VARIABLES:
-  MINIMAX_API_KEY             API key for Minimax
-`);
-}
-
-async function generateMinimax(options: GenerateOptions): Promise<Buffer> {
-  const apiKey = process.env.MINIMAX_API_KEY;
-  if (!apiKey) throw new Error('MINIMAX_API_KEY environment variable is required');
-
-  const baseUrl = 'https://api.minimax.chat/v1';
-
-  console.log(`Generating sound effect with Minimax...`);
-  console.log(`Prompt: ${options.prompt}`);
-
-  const body: Record<string, unknown> = {
-    model: 'sound-effects-01',
-    prompt: options.prompt,
-  };
-  if (options.duration) body.duration = options.duration;
-
-  const headers: Record<string, string> = {
-    'Content-Type': 'application/json',
-    'Authorization': `Bearer ${apiKey}`,
-  };
-
-  const response = await fetch(`${baseUrl}/sound_generation`, {
-    method: 'POST',
-    headers,
-    body: JSON.stringify(body),
-  });
-
-  if (!response.ok) {
-    const err = await response.text();
-    throw new Error(`Minimax API error: ${response.status} - ${err}`);
-  }
-
-  const data = await response.json() as { task_id: string };
-  console.log(`Task started: ${data.task_id}`);
-  console.log('Polling for completion...');
-
-  for (let i = 0; i < 60; i++) {
-    await new Promise(r => setTimeout(r, 3000));
-
-    const statusRes = await fetch(`${baseUrl}/query/sound_generation?task_id=${data.task_id}`, {
-      headers: { 'Authorization': `Bearer ${apiKey}` },
-    });
-    const status = await statusRes.json() as {
-      status: string;
-      extra_info?: { audio_url?: string };
-      audio_file?: string;
-      base_resp?: { status_msg: string };
-    };
-
-    if (status.status === 'Success') {
-      const audioUrl = status.extra_info?.audio_url || status.audio_file;
-      if (!audioUrl) throw new Error('No audio URL in response');
-
-      console.log('Sound effect generated. Downloading...');
-      const audioRes = await fetch(audioUrl);
-      if (!audioRes.ok) throw new Error(`Download failed: ${audioRes.status}`);
-      return Buffer.from(await audioRes.arrayBuffer());
-    }
-
-    if (status.status === 'Fail') {
-      throw new Error(`Sound effect generation failed: ${status.base_resp?.status_msg || 'Unknown error'}`);
-    }
-  }
-
-  throw new Error('Sound effect generation timed out');
-}
-
-async function main() {
-  const options = parseArgs();
-  if (!options) return;
-
-  try {
-    console.log('\n=== Sound Effect Generation ===\n');
-
-    const buffer = await generateMinimax(options);
-
-    const outputPath = resolve(options.output);
-    await mkdir(dirname(outputPath), { recursive: true });
-    await writeFile(outputPath, buffer);
-
-    console.log(`\nSound effect saved to: ${outputPath}`);
-    console.log(`Size: ${(buffer.length / 1024).toFixed(1)} KB`);
-    console.log('\nDone!\n');
-  } catch (error) {
-    console.error('\nError:', error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-}
-
-main();

package/skills/sound-effects/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": ["src"]
-}

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