varg.ai-sdk 0.1.0 → 0.1.1

package/action/captions/index.ts

@@ -8,8 +8,56 @@
 
 import { existsSync } from "node:fs";
 import ffmpeg from "fluent-ffmpeg";
+import type { ActionMeta } from "../../cli/types";
 import { transcribe } from "../transcribe";
 
+export const meta: ActionMeta = {
+  name: "captions",
+  type: "action",
+  description: "add subtitles to video",
+  inputType: "video",
+  outputType: "video",
+  schema: {
+    input: {
+      type: "object",
+      required: ["video", "output"],
+      properties: {
+        video: {
+          type: "string",
+          format: "file-path",
+          description: "input video file",
+        },
+        output: {
+          type: "string",
+          format: "file-path",
+          description: "output video path",
+        },
+        srt: {
+          type: "string",
+          format: "file-path",
+          description: "existing srt file (auto-generates if not provided)",
+        },
+        provider: {
+          type: "string",
+          enum: ["groq", "fireworks"],
+          default: "fireworks",
+          description: "transcription provider for auto-generation",
+        },
+      },
+    },
+    output: { type: "string", format: "file-path", description: "video path" },
+  },
+  async run(options) {
+    const { video, output, srt, provider } = options as {
+      video: string;
+      output: string;
+      srt?: string;
+      provider?: "groq" | "fireworks";
+    };
+    return addCaptions({ videoPath: video, output, srtPath: srt, provider });
+  },
+};
+
 // types
 export interface AddCaptionsOptions {
   videoPath: string;
@@ -115,113 +163,7 @@ export async function addCaptions(
 }
 
 // cli
-async function cli() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  if (!command || command === "help") {
-    console.log(`
-usage:
-  bun run service/captions.ts <videoPath> [outputPath] [options]
-
-arguments:
-  videoPath      - path to input video file
-  outputPath     - path to output video (default: video-captioned.mp4)
-
-options:
-  --srt <path>       - use existing srt file instead of auto-generating
-  --provider <name>  - groq | fireworks (default: fireworks)
-  --font <name>      - font name (default: Arial)
-  --size <number>    - font size (default: 24)
-  --color <hex>      - primary color in ASS format (default: &HFFFFFF)
-  --outline <hex>    - outline color in ASS format (default: &H000000)
-
-examples:
-  # auto-generate captions with fireworks
-  bun run service/captions.ts media/fitness-demo.mp4
-
-  # auto-generate with groq (faster, plain text)
-  bun run service/captions.ts media/fitness-demo.mp4 output.mp4 --provider groq
-
-  # use existing srt file
-  bun run service/captions.ts media/fitness-demo.mp4 output.mp4 --srt media/fitness-demo.srt
-
-  # customize style
-  bun run service/captions.ts media/video.mp4 output.mp4 --font "Helvetica" --size 28
-
-requirements:
-  ffmpeg must be installed on your system
-  brew install ffmpeg (macos)
-  apt-get install ffmpeg (linux)
-    `);
-    process.exit(0);
-  }
-
-  try {
-    const videoPath = args[0];
-    let outputPath = args[1];
-
-    if (!videoPath) {
-      throw new Error("videoPath is required");
-    }
-
-    // parse options
-    let srtPath: string | undefined;
-    let provider: "groq" | "fireworks" = "fireworks";
-    const style: SubtitleStyle = {};
-
-    for (let i = 1; i < args.length; i++) {
-      const arg = args[i];
-
-      if (arg === "--srt") {
-        srtPath = args[++i];
-      } else if (arg === "--provider") {
-        provider = args[++i] as "groq" | "fireworks";
-      } else if (arg === "--font") {
-        style.fontName = args[++i];
-      } else if (arg === "--size") {
-        const size = args[++i];
-        if (!size) {
-          throw new Error("--size requires a number");
-        }
-        style.fontSize = Number.parseInt(size, 10);
-      } else if (arg === "--color") {
-        const color = args[++i];
-        if (!color) {
-          throw new Error("--color requires a hex color");
-        }
-        style.primaryColor = color;
-      } else if (arg === "--outline") {
-        const outline = args[++i];
-        if (!outline) {
-          throw new Error("--outline requires a hex color");
-        }
-        style.outlineColor = outline;
-      } else if (!arg?.startsWith("--") && !outputPath) {
-        outputPath = arg;
-      }
-    }
-
-    // default output path
-    if (!outputPath) {
-      outputPath = videoPath.replace(/\.[^.]+$/, "-captioned.mp4");
-    }
-
-    await addCaptions({
-      videoPath,
-      srtPath,
-      output: outputPath,
-      provider,
-      style,
-    });
-
-    console.log("\ndone! video with captions saved to:", outputPath);
-  } catch (error) {
-    console.error("[captions] error:", error);
-    process.exit(1);
-  }
-}
-
 if (import.meta.main) {
-  cli();
+  const { runCli } = await import("../../cli/runner");
+  runCli(meta);
 }

package/action/edit/index.ts

@@ -7,6 +7,7 @@
 
 import { existsSync } from "node:fs";
 import { extname } from "node:path";
+import type { ActionMeta } from "../../cli/types";
 import {
   type AddAudioOptions,
   addAudio,
@@ -21,6 +22,67 @@ import {
   trimVideo,
 } from "../../lib/ffmpeg";
 
+export const meta: ActionMeta = {
+  name: "edit",
+  type: "action",
+  description: "trim/resize video",
+  inputType: "video",
+  outputType: "video",
+  schema: {
+    input: {
+      type: "object",
+      required: ["input", "output"],
+      properties: {
+        input: {
+          type: "string",
+          format: "file-path",
+          description: "input video file",
+        },
+        output: {
+          type: "string",
+          format: "file-path",
+          description: "output video path",
+        },
+        start: {
+          type: "number",
+          description: "start time in seconds (for trim)",
+        },
+        duration: {
+          type: "number",
+          description: "duration in seconds (for trim)",
+        },
+        preset: {
+          type: "string",
+          enum: ["vertical", "square", "landscape", "4k"],
+          description: "resize preset",
+        },
+      },
+    },
+    output: { type: "string", format: "file-path", description: "video path" },
+  },
+  async run(options) {
+    const { input, output, start, duration, preset } = options as {
+      input: string;
+      output: string;
+      start?: number;
+      duration?: number;
+      preset?: "vertical" | "square" | "landscape" | "4k";
+    };
+    if (preset) {
+      return quickResize(input, output, preset);
+    }
+    if (start !== undefined) {
+      return quickTrim(
+        input,
+        output,
+        start,
+        duration ? start + duration : undefined,
+      );
+    }
+    throw new Error("specify --start for trim or --preset for resize");
+  },
+};
+
 // types
 export interface EditPipelineStep {
   operation:
@@ -369,125 +431,7 @@ export async function mergeWithAudio(
 }
 
 // cli
-async function cli() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  if (!command || command === "help") {
-    console.log(`
-usage:
-  bun run service/edit.ts <command> [args]
-
-commands:
-  social <input> <output> <platform> [audioPath]   prepare for social media
-  montage <output> <clip1> <clip2> [clip3...]      create montage from clips
-  trim <input> <output> <start> [end]              quick trim
-  resize <input> <output> <preset>                 quick resize
-  merge_audio <audio> <output> <video1> [video2...]  merge videos with audio
-
-platforms:
-  tiktok, instagram, youtube-shorts, youtube, twitter
-
-resize presets:
-  vertical (9:16), square (1:1), landscape (16:9), 4k
-
-examples:
-  bun run service/edit.ts social raw.mp4 tiktok.mp4 tiktok
-  bun run service/edit.ts social raw.mp4 ig.mp4 instagram audio.mp3
-  bun run service/edit.ts montage output.mp4 clip1.mp4 clip2.mp4 clip3.mp4
-  bun run service/edit.ts trim long.mp4 short.mp4 10 30
-  bun run service/edit.ts resize raw.mp4 vertical.mp4 vertical
-  bun run service/edit.ts merge_audio song.mp3 final.mp4 clip1.mp4 clip2.mp4
-    `);
-    process.exit(0);
-  }
-
-  try {
-    switch (command) {
-      case "social": {
-        const input = args[1];
-        const output = args[2];
-        const platform = args[3] as PrepareForSocialOptions["platform"];
-        const withAudio = args[4];
-
-        if (!input || !output || !platform) {
-          throw new Error("input, output, and platform are required");
-        }
-
-        await prepareForSocial({ input, output, platform, withAudio });
-        break;
-      }
-
-      case "montage": {
-        const output = args[1];
-        const clips = args.slice(2);
-
-        if (!output || clips.length === 0) {
-          throw new Error("output and at least one clip are required");
-        }
-
-        await createMontage({ clips, output });
-        break;
-      }
-
-      case "trim": {
-        const input = args[1];
-        const output = args[2];
-        const startArg = args[3];
-        const endArg = args[4];
-
-        if (!input || !output || !startArg) {
-          throw new Error("input, output, and start are required");
-        }
-
-        const start = Number.parseFloat(startArg);
-        const end = endArg ? Number.parseFloat(endArg) : undefined;
-
-        if (Number.isNaN(start) || (endArg && Number.isNaN(end))) {
-          throw new Error("start and end must be valid numbers");
-        }
-
-        await quickTrim(input, output, start, end);
-        break;
-      }
-
-      case "resize": {
-        const input = args[1];
-        const output = args[2];
-        const preset = args[3] as "vertical" | "square" | "landscape" | "4k";
-
-        if (!input || !output || !preset) {
-          throw new Error("input, output, and preset are required");
-        }
-
-        await quickResize(input, output, preset);
-        break;
-      }
-
-      case "merge_audio": {
-        const audio = args[1];
-        const output = args[2];
-        const videos = args.slice(3);
-
-        if (!audio || !output || videos.length === 0) {
-          throw new Error("audio, output, and at least one video are required");
-        }
-
-        await mergeWithAudio(videos, audio, output);
-        break;
-      }
-
-      default:
-        console.error(`unknown command: ${command}`);
-        console.log("run 'bun run service/edit.ts help' for usage");
-        process.exit(1);
-    }
-  } catch (error) {
-    console.error("[edit] error:", error);
-    process.exit(1);
-  }
-}
-
 if (import.meta.main) {
-  cli();
+  const { runCli } = await import("../../cli/runner");
+  runCli(meta);
 }

package/action/image/index.ts

@@ -4,10 +4,44 @@
  * usage: bun run service/image.ts <command> <args>
  */
 
+import type { ActionMeta } from "../../cli/types";
 import { generateImage } from "../../lib/fal";
 import { generateSoul } from "../../lib/higgsfield";
 import { uploadFromUrl } from "../../utilities/s3";
 
+export const meta: ActionMeta = {
+  name: "image",
+  type: "action",
+  description: "generate image from text",
+  inputType: "text",
+  outputType: "image",
+  schema: {
+    input: {
+      type: "object",
+      required: ["prompt"],
+      properties: {
+        prompt: { type: "string", description: "what to generate" },
+        size: {
+          type: "string",
+          enum: [
+            "square_hd",
+            "landscape_4_3",
+            "portrait_4_3",
+            "landscape_16_9",
+          ],
+          default: "landscape_4_3",
+          description: "image size/aspect",
+        },
+      },
+    },
+    output: { type: "string", format: "file-path", description: "image path" },
+  },
+  async run(options) {
+    const { prompt, size } = options as { prompt: string; size?: string };
+    return generateWithFal(prompt, { model: size });
+  },
+};
+
 export interface ImageGenerationResult {
   imageUrl: string;
   uploaded?: string;
@@ -64,49 +98,8 @@ export async function generateWithSoul(
   return { imageUrl, uploaded };
 }
 
-// cli runner
+// cli
 if (import.meta.main) {
-  const [command, ...args] = process.argv.slice(2);
-
-  switch (command) {
-    case "fal": {
-      if (!args[0]) {
-        console.log(`
-usage:
-  bun run service/image.ts fal <prompt> [model] [upload]
-        `);
-        process.exit(1);
-      }
-      const falResult = await generateWithFal(args[0], {
-        model: args[1],
-        upload: args[2] === "true",
-      });
-      console.log(JSON.stringify(falResult, null, 2));
-      break;
-    }
-
-    case "soul": {
-      if (!args[0]) {
-        console.log(`
-usage:
-  bun run service/image.ts soul <prompt> [styleId] [upload]
-        `);
-        process.exit(1);
-      }
-      const soulResult = await generateWithSoul(args[0], {
-        styleId: args[1],
-        upload: args[2] === "true",
-      });
-      console.log(JSON.stringify(soulResult, null, 2));
-      break;
-    }
-
-    default:
-      console.log(`
-usage:
-  bun run service/image.ts fal <prompt> [model] [upload]
-  bun run service/image.ts soul <prompt> [styleId] [upload]
-      `);
-      process.exit(1);
-  }
+  const { runCli } = await import("../../cli/runner");
+  runCli(meta);
 }

package/action/sync/index.ts

@@ -5,9 +5,57 @@
  * supports wav2lip, synclabs, and simple audio overlay
  */
 
+import type { ActionMeta } from "../../cli/types";
 import { addAudio } from "../../lib/ffmpeg";
 import { runModel } from "../../lib/replicate";
 
+export const meta: ActionMeta = {
+  name: "sync",
+  type: "action",
+  description: "sync audio to video (lipsync)",
+  inputType: "video+audio",
+  outputType: "video",
+  schema: {
+    input: {
+      type: "object",
+      required: ["video", "audio"],
+      properties: {
+        video: {
+          type: "string",
+          format: "file-path",
+          description: "input video file or url",
+        },
+        audio: {
+          type: "string",
+          format: "file-path",
+          description: "audio file or url to sync",
+        },
+        method: {
+          type: "string",
+          enum: ["wav2lip", "overlay"],
+          default: "overlay",
+          description: "sync method (wav2lip requires urls)",
+        },
+        output: {
+          type: "string",
+          format: "file-path",
+          description: "output video path",
+        },
+      },
+    },
+    output: { type: "string", format: "file-path", description: "video path" },
+  },
+  async run(options) {
+    const { video, audio, method, output } = options as {
+      video: string;
+      audio: string;
+      method?: "wav2lip" | "overlay";
+      output?: string;
+    };
+    return lipsync({ videoUrl: video, audioUrl: audio, method, output });
+  },
+};
+
 // types
 export interface LipsyncOptions {
   videoUrl: string;
@@ -91,97 +139,7 @@ export async function lipsyncOverlay(
 }
 
 // cli
-async function cli() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  if (!command || command === "help") {
-    console.log(`
-usage:
-  bun run service/sync.ts <command> [args]
-
-commands:
-  sync <videoUrl> <audioUrl> [method] [output]     sync video with audio
-  wav2lip <videoUrl> <audioUrl>                    use wav2lip model
-  overlay <videoPath> <audioPath> [output]         simple audio overlay
-  help                                             show this help
-
-methods:
-  wav2lip    - ai-powered lipsync using replicate (url inputs)
-  overlay    - simple audio overlay using ffmpeg (local files)
-
-examples:
-  bun run service/sync.ts sync video.mp4 audio.mp3 overlay output.mp4
-  bun run service/sync.ts wav2lip https://example.com/video.mp4 https://example.com/audio.mp3
-  bun run service/sync.ts overlay video.mp4 audio.mp3 synced.mp4
-
-environment:
-  REPLICATE_API_TOKEN - required for wav2lip method
-    `);
-    process.exit(0);
-  }
-
-  try {
-    switch (command) {
-      case "sync": {
-        const videoUrl = args[1];
-        const audioUrl = args[2];
-        const method = (args[3] || "overlay") as "wav2lip" | "overlay";
-        const output = args[4];
-
-        if (!videoUrl || !audioUrl) {
-          throw new Error("videoUrl and audioUrl are required");
-        }
-
-        const result = await lipsync({
-          videoUrl,
-          audioUrl,
-          method,
-          output,
-        });
-
-        console.log(`[sync] result:`, result);
-        break;
-      }
-
-      case "wav2lip": {
-        const videoUrl = args[1];
-        const audioUrl = args[2];
-
-        if (!videoUrl || !audioUrl) {
-          throw new Error("videoUrl and audioUrl are required");
-        }
-
-        const result = await lipsyncWav2Lip({ videoUrl, audioUrl });
-        console.log(`[sync] result:`, result);
-        break;
-      }
-
-      case "overlay": {
-        const videoPath = args[1];
-        const audioPath = args[2];
-        const output = args[3];
-
-        if (!videoPath || !audioPath) {
-          throw new Error("videoPath and audioPath are required");
-        }
-
-        const result = await lipsyncOverlay(videoPath, audioPath, output);
-        console.log(`[sync] result:`, result);
-        break;
-      }
-
-      default:
-        console.error(`unknown command: ${command}`);
-        console.log(`run 'bun run service/sync.ts help' for usage`);
-        process.exit(1);
-    }
-  } catch (error) {
-    console.error(`[sync] error:`, error);
-    process.exit(1);
-  }
-}
-
 if (import.meta.main) {
-  cli();
+  const { runCli } = await import("../../cli/runner");
+  runCli(meta);
 }