varg.ai-sdk 0.1.1 → 0.4.0-alpha.1

package/lib/ffmpeg.ts

@@ -1,467 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * ffmpeg wrapper for video editing operations
- * requires ffmpeg to be installed on the system
- */
-
-import { existsSync } from "node:fs";
-import ffmpeg from "fluent-ffmpeg";
-
-// types
-export interface ConcatVideosOptions {
-  inputs: string[];
-  output: string;
-  transition?: boolean;
-}
-
-export interface AddAudioOptions {
-  videoPath: string;
-  audioPath: string;
-  output: string;
-}
-
-export interface ResizeVideoOptions {
-  input: string;
-  output: string;
-  width?: number;
-  height?: number;
-  aspectRatio?: string;
-}
-
-export interface TrimVideoOptions {
-  input: string;
-  output: string;
-  start: number;
-  duration?: number;
-}
-
-export interface ConvertFormatOptions {
-  input: string;
-  output: string;
-  format?: string;
-}
-
-// core functions
-export async function concatVideos(
-  options: ConcatVideosOptions,
-): Promise<string> {
-  const { inputs, output } = options;
-
-  if (!inputs || inputs.length === 0) {
-    throw new Error("inputs are required");
-  }
-  if (!output) {
-    throw new Error("output is required");
-  }
-
-  // validate all inputs exist
-  for (const input of inputs) {
-    if (!existsSync(input)) {
-      throw new Error(`input file not found: ${input}`);
-    }
-  }
-
-  console.log(`[ffmpeg] concatenating ${inputs.length} videos...`);
-
-  return new Promise((resolve, reject) => {
-    const command = ffmpeg();
-
-    // add all inputs
-    for (const input of inputs) {
-      command.input(input);
-    }
-
-    // use concat filter
-    const filterComplex =
-      inputs.map((_, i) => `[${i}:v][${i}:a]`).join("") +
-      `concat=n=${inputs.length}:v=1:a=1[outv][outa]`;
-
-    command
-      .complexFilter(filterComplex)
-      .outputOptions(["-map", "[outv]", "-map", "[outa]"])
-      .output(output)
-      .on("end", () => {
-        console.log(`[ffmpeg] saved to ${output}`);
-        resolve(output);
-      })
-      .on("error", (err) => {
-        console.error(`[ffmpeg] error:`, err);
-        reject(err);
-      })
-      .run();
-  });
-}
-
-export async function addAudio(options: AddAudioOptions): Promise<string> {
-  const { videoPath, audioPath, output } = options;
-
-  if (!videoPath || !audioPath || !output) {
-    throw new Error("videoPath, audioPath, and output are required");
-  }
-
-  console.log(`[ffmpeg] adding audio to video...`);
-
-  return new Promise((resolve, reject) => {
-    ffmpeg()
-      .input(videoPath)
-      .input(audioPath)
-      .outputOptions([
-        "-c:v",
-        "copy",
-        "-c:a",
-        "aac",
-        "-map",
-        "0:v:0",
-        "-map",
-        "1:a:0",
-      ])
-      .output(output)
-      .on("end", () => {
-        console.log(`[ffmpeg] saved to ${output}`);
-        resolve(output);
-      })
-      .on("error", (err) => {
-        console.error(`[ffmpeg] error:`, err);
-        reject(err);
-      })
-      .run();
-  });
-}
-
-export async function resizeVideo(
-  options: ResizeVideoOptions,
-): Promise<string> {
-  const { input, output, width, height, aspectRatio } = options;
-
-  if (!input || !output) {
-    throw new Error("input and output are required");
-  }
-
-  console.log(`[ffmpeg] resizing video...`);
-
-  return new Promise((resolve, reject) => {
-    const command = ffmpeg(input);
-
-    if (width && height) {
-      command.size(`${width}x${height}`);
-    } else if (aspectRatio) {
-      command.aspect(aspectRatio);
-    }
-
-    command
-      .output(output)
-      .on("end", () => {
-        console.log(`[ffmpeg] saved to ${output}`);
-        resolve(output);
-      })
-      .on("error", (err) => {
-        console.error(`[ffmpeg] error:`, err);
-        reject(err);
-      })
-      .run();
-  });
-}
-
-export async function trimVideo(options: TrimVideoOptions): Promise<string> {
-  const { input, output, start, duration } = options;
-
-  if (!input || !output || start === undefined) {
-    throw new Error("input, output, and start are required");
-  }
-
-  console.log(`[ffmpeg] trimming video...`);
-
-  return new Promise((resolve, reject) => {
-    const command = ffmpeg(input).setStartTime(start);
-
-    if (duration) {
-      command.setDuration(duration);
-    }
-
-    command
-      .output(output)
-      .on("end", () => {
-        console.log(`[ffmpeg] saved to ${output}`);
-        resolve(output);
-      })
-      .on("error", (err) => {
-        console.error(`[ffmpeg] error:`, err);
-        reject(err);
-      })
-      .run();
-  });
-}
-
-export async function convertFormat(
-  options: ConvertFormatOptions,
-): Promise<string> {
-  const { input, output, format } = options;
-
-  if (!input || !output) {
-    throw new Error("input and output are required");
-  }
-
-  console.log(`[ffmpeg] converting format...`);
-
-  return new Promise((resolve, reject) => {
-    const command = ffmpeg(input);
-
-    if (format) {
-      command.format(format);
-    }
-
-    command
-      .output(output)
-      .on("end", () => {
-        console.log(`[ffmpeg] saved to ${output}`);
-        resolve(output);
-      })
-      .on("error", (err) => {
-        console.error(`[ffmpeg] error:`, err);
-        reject(err);
-      })
-      .run();
-  });
-}
-
-export async function extractAudio(
-  input: string,
-  output: string,
-): Promise<string> {
-  if (!input || !output) {
-    throw new Error("input and output are required");
-  }
-
-  console.log(`[ffmpeg] extracting audio...`);
-
-  return new Promise((resolve, reject) => {
-    ffmpeg(input)
-      .outputOptions(["-vn", "-acodec", "copy"])
-      .output(output)
-      .on("end", () => {
-        console.log(`[ffmpeg] saved to ${output}`);
-        resolve(output);
-      })
-      .on("error", (err) => {
-        console.error(`[ffmpeg] error:`, err);
-        reject(err);
-      })
-      .run();
-  });
-}
-
-export interface ProbeResult {
-  duration: number;
-  width: number;
-  height: number;
-  fps: number;
-  codec: string;
-  format: string;
-}
-
-export async function probe(input: string): Promise<ProbeResult> {
-  if (!input) {
-    throw new Error("input is required");
-  }
-
-  if (!existsSync(input)) {
-    throw new Error(`input file not found: ${input}`);
-  }
-
-  console.log(`[ffmpeg] probing ${input}...`);
-
-  return new Promise((resolve, reject) => {
-    ffmpeg.ffprobe(input, (err, metadata) => {
-      if (err) {
-        console.error(`[ffmpeg] error:`, err);
-        reject(err);
-        return;
-      }
-
-      const videoStream = metadata.streams.find(
-        (s) => s.codec_type === "video",
-      );
-      if (!videoStream) {
-        reject(new Error("no video stream found"));
-        return;
-      }
-
-      const result: ProbeResult = {
-        duration: metadata.format.duration || 0,
-        width: videoStream.width || 0,
-        height: videoStream.height || 0,
-        fps: Number(videoStream.r_frame_rate || "0") || 0,
-        codec: videoStream.codec_name || "",
-        format: metadata.format.format_name || "",
-      };
-
-      console.log(
-        `[ffmpeg] ${result.width}x${result.height} @ ${result.fps}fps, ${result.duration}s, codec: ${result.codec}`,
-      );
-      resolve(result);
-    });
-  });
-}
-
-// cli
-async function cli() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  if (!command || command === "help") {
-    console.log(`
-usage:
-  bun run lib/ffmpeg.ts <command> [args]
-
-commands:
-  probe <input>                                    get video metadata
-  concat <output> <input1> <input2> [input3...]    concatenate videos
-  add_audio <video> <audio> <output>               add audio to video
-  resize <input> <output> <width> <height>         resize video
-  trim <input> <output> <start> [duration]         trim video
-  convert <input> <output> [format]                convert format
-  extract_audio <input> <output>                   extract audio from video
-  help                                             show this help
-
-examples:
-  bun run lib/ffmpeg.ts probe input.mp4
-  bun run lib/ffmpeg.ts concat output.mp4 video1.mp4 video2.mp4
-  bun run lib/ffmpeg.ts add_audio video.mp4 audio.mp3 output.mp4
-  bun run lib/ffmpeg.ts resize input.mp4 output.mp4 1920 1080
-  bun run lib/ffmpeg.ts trim input.mp4 output.mp4 10 30
-  bun run lib/ffmpeg.ts convert input.mov output.mp4
-  bun run lib/ffmpeg.ts extract_audio input.mp4 output.mp3
-
-requirements:
-  ffmpeg must be installed on your system
-  brew install ffmpeg (macos)
-  apt-get install ffmpeg (linux)
-    `);
-    process.exit(0);
-  }
-
-  try {
-    switch (command) {
-      case "probe": {
-        const input = args[1];
-
-        if (!input) {
-          throw new Error("input is required");
-        }
-
-        const result = await probe(input);
-        console.log("\nmetadata:");
-        console.log(`  duration: ${result.duration}s`);
-        console.log(`  resolution: ${result.width}x${result.height}`);
-        console.log(`  fps: ${result.fps}`);
-        console.log(`  codec: ${result.codec}`);
-        console.log(`  format: ${result.format}`);
-        break;
-      }
-
-      case "concat": {
-        const output = args[1];
-        const inputs = args.slice(2);
-
-        if (!output || inputs.length === 0) {
-          throw new Error("output and at least one input are required");
-        }
-
-        await concatVideos({ inputs, output });
-        break;
-      }
-
-      case "add_audio": {
-        const videoPath = args[1];
-        const audioPath = args[2];
-        const output = args[3];
-
-        if (!videoPath || !audioPath || !output) {
-          throw new Error("videoPath, audioPath, and output are required");
-        }
-
-        await addAudio({ videoPath, audioPath, output });
-        break;
-      }
-
-      case "resize": {
-        const input = args[1];
-        const output = args[2];
-        const widthArg = args[3];
-        const heightArg = args[4];
-
-        if (!input || !output || !widthArg || !heightArg) {
-          throw new Error("input, output, width, and height are required");
-        }
-
-        const width = Number.parseInt(widthArg, 10);
-        const height = Number.parseInt(heightArg, 10);
-
-        if (Number.isNaN(width) || Number.isNaN(height)) {
-          throw new Error("width and height must be valid numbers");
-        }
-
-        await resizeVideo({ input, output, width, height });
-        break;
-      }
-
-      case "trim": {
-        const input = args[1];
-        const output = args[2];
-        const startArg = args[3];
-
-        if (!input || !output || !startArg) {
-          throw new Error("input, output, and start are required");
-        }
-
-        const start = Number.parseFloat(startArg);
-        if (Number.isNaN(start)) {
-          throw new Error("start must be a valid number");
-        }
-
-        const duration = args[4] ? parseFloat(args[4]) : undefined;
-
-        await trimVideo({ input, output, start, duration });
-        break;
-      }
-
-      case "convert": {
-        const input = args[1];
-        const output = args[2];
-        const format = args[3];
-
-        if (!input || !output) {
-          throw new Error("input and output are required");
-        }
-
-        await convertFormat({ input, output, format });
-        break;
-      }
-
-      case "extract_audio": {
-        const input = args[1];
-        const output = args[2];
-
-        if (!input || !output) {
-          throw new Error("input and output are required");
-        }
-
-        await extractAudio(input, output);
-        break;
-      }
-
-      default:
-        console.error(`unknown command: ${command}`);
-        console.log(`run 'bun run lib/ffmpeg.ts help' for usage`);
-        process.exit(1);
-    }
-  } catch (error) {
-    console.error(`[ffmpeg] error:`, error);
-    process.exit(1);
-  }
-}
-
-if (import.meta.main) {
-  cli();
-}

package/lib/fireworks.ts

@@ -1,235 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * fireworks.ai api wrapper for audio transcription with word-level timestamps
- * supports whisper models with advanced features like diarization and vad
- */
-
-import { readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-// types
-export interface FireworksWord {
-  word: string;
-  language: string;
-  probability: number;
-  hallucination_score: number;
-  start: number;
-  end: number;
-  retry_count: number;
-}
-
-export interface FireworksResponse {
-  task: string;
-  language: string;
-  text: string;
-  request_id: string;
-  words: FireworksWord[];
-  duration: number;
-}
-
-export interface FireworksTranscribeOptions {
-  audioPath: string; // local file path or url
-  vadModel?: "whisperx-pyannet" | "silero";
-  alignmentModel?: "tdnn_ffn" | "wav2vec2";
-  responseFormat?: "json" | "verbose_json" | "text" | "srt" | "vtt";
-  preprocessing?: "none" | "denoise";
-  temperature?: string; // comma-separated values like "0,0.2,0.4,0.6,0.8,1"
-  timestampGranularities?: "word" | "segment";
-  diarize?: boolean;
-  language?: string;
-  outputPath?: string;
-}
-
-// srt conversion
-export function convertFireworksToSRT(words: FireworksWord[]): string {
-  let srt = "";
-  let index = 1;
-
-  for (const word of words) {
-    const startTime = formatTime(word.start);
-    const endTime = formatTime(word.end);
-
-    srt += `${index}\n`;
-    srt += `${startTime} --> ${endTime}\n`;
-    srt += `${word.word.trim()}\n\n`;
-    index++;
-  }
-
-  return srt;
-}
-
-function formatTime(seconds: number): string {
-  const hours = Math.floor(seconds / 3600);
-  const minutes = Math.floor((seconds % 3600) / 60);
-  const secs = Math.floor(seconds % 60);
-  const millis = Math.floor((seconds % 1) * 1000);
-
-  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(secs).padStart(2, "0")},${String(millis).padStart(3, "0")}`;
-}
-
-// core function
-export async function transcribeWithFireworks(
-  options: FireworksTranscribeOptions,
-): Promise<FireworksResponse> {
-  const {
-    audioPath,
-    vadModel = "whisperx-pyannet",
-    alignmentModel = "tdnn_ffn",
-    responseFormat = "verbose_json",
-    preprocessing = "none",
-    temperature = "0,0.2,0.4,0.6,0.8,1",
-    timestampGranularities = "word",
-    diarize = false,
-    language,
-    outputPath,
-  } = options;
-
-  if (!audioPath) {
-    throw new Error("audioPath is required");
-  }
-
-  if (!process.env.FIREWORKS_API_KEY) {
-    throw new Error("FIREWORKS_API_KEY environment variable is required");
-  }
-
-  console.log("[fireworks] transcribing audio...");
-
-  try {
-    // load audio file (local or remote)
-    let audioBlob: Blob;
-    let fileName = "audio.mp3";
-
-    if (audioPath.startsWith("http://") || audioPath.startsWith("https://")) {
-      // fetch remote file
-      const audioResponse = await fetch(audioPath);
-      audioBlob = await audioResponse.blob();
-      fileName = audioPath.split("/").pop()?.split("?")[0] || "audio.mp3";
-    } else {
-      // read local file
-      const buffer = readFileSync(audioPath);
-      audioBlob = new Blob([buffer]);
-      fileName = audioPath.split("/").pop() || "audio.mp3";
-    }
-
-    // prepare form data
-    const formData = new FormData();
-    formData.append("file", audioBlob, fileName);
-    formData.append("vad_model", vadModel);
-    formData.append("alignment_model", alignmentModel);
-    formData.append("response_format", responseFormat);
-    formData.append("preprocessing", preprocessing);
-    formData.append("temperature", temperature);
-    formData.append("timestamp_granularities", timestampGranularities);
-    formData.append("diarize", diarize.toString());
-
-    if (language) {
-      formData.append("language", language);
-    }
-
-    // call fireworks api
-    const response = await fetch(
-      "https://audio-prod.us-virginia-1.direct.fireworks.ai/v1/audio/transcriptions",
-      {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${process.env.FIREWORKS_API_KEY}`,
-        },
-        body: formData,
-      },
-    );
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      console.error("[fireworks] api error:", errorText);
-      throw new Error(`fireworks api error: ${response.statusText}`);
-    }
-
-    const data = (await response.json()) as FireworksResponse;
-
-    console.log(
-      `[fireworks] transcription complete (${data.words?.length || 0} words)`,
-    );
-
-    // save to file if requested
-    if (outputPath) {
-      let content: string;
-
-      if (outputPath.endsWith(".srt")) {
-        content = convertFireworksToSRT(data.words || []);
-      } else if (outputPath.endsWith(".json")) {
-        content = JSON.stringify(data, null, 2);
-      } else {
-        content = data.text;
-      }
-
-      writeFileSync(outputPath, content);
-      console.log(`[fireworks] saved to ${outputPath}`);
-    }
-
-    return data;
-  } catch (error) {
-    console.error("[fireworks] error:", error);
-    throw error;
-  }
-}
-
-// cli
-async function cli() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  if (!command || command === "help") {
-    console.log(`
-usage:
-  bun run lib/fireworks.ts <audioPath> [outputPath]
-
-arguments:
-  audioPath      - local file path or url to audio file
-  outputPath     - optional output file (.srt, .json, or .txt)
-
-examples:
-  bun run lib/fireworks.ts media/audio.mp3
-  bun run lib/fireworks.ts media/audio.mp3 output.srt
-  bun run lib/fireworks.ts https://example.com/audio.mp3 output.json
-  bun run lib/fireworks.ts media/dora.ogg transcription.txt
-
-features:
-  - word-level timestamps for precise subtitles
-  - voice activity detection (vad) for better accuracy
-  - speaker diarization support
-  - advanced preprocessing options
-  - multiple output formats (srt, json, text)
-
-environment:
-  FIREWORKS_API_KEY - your fireworks.ai api key
-    `);
-    process.exit(0);
-  }
-
-  try {
-    const audioPath = args[0];
-    const outputPath = args[1];
-
-    if (!audioPath) {
-      throw new Error("audioPath is required");
-    }
-
-    const data = await transcribeWithFireworks({
-      audioPath,
-      outputPath: outputPath || join(process.cwd(), "output.srt"),
-    });
-
-    console.log(`\ntranscription:\n${data.text}\n`);
-    console.log(`words: ${data.words?.length || 0}`);
-    console.log(`language: ${data.language}`);
-    console.log(`duration: ${data.duration}s`);
-  } catch (error) {
-    console.error("[fireworks] error:", error);
-    process.exit(1);
-  }
-}
-
-if (import.meta.main) {
-  cli();
-}