varg.ai-sdk 0.1.0 → 0.1.1

package/action/transcribe/index.ts

@@ -6,14 +6,55 @@
  */
 
 import { writeFileSync } from "node:fs";
-import { join } from "node:path";
 import { toFile } from "groq-sdk/uploads";
+import type { ActionMeta } from "../../cli/types";
 import {
   convertFireworksToSRT,
   transcribeWithFireworks as fireworksTranscribe,
 } from "../../lib/fireworks";
 import { GROQ_MODELS, transcribeAudio as groqTranscribe } from "../../lib/groq";
 
+export const meta: ActionMeta = {
+  name: "transcribe",
+  type: "action",
+  description: "speech to text transcription",
+  inputType: "audio",
+  outputType: "text",
+  schema: {
+    input: {
+      type: "object",
+      required: ["audio"],
+      properties: {
+        audio: {
+          type: "string",
+          format: "file-path",
+          description: "audio/video file to transcribe",
+        },
+        provider: {
+          type: "string",
+          enum: ["groq", "fireworks"],
+          default: "groq",
+          description: "transcription provider",
+        },
+        output: {
+          type: "string",
+          format: "file-path",
+          description: "output file path",
+        },
+      },
+    },
+    output: { type: "string", description: "transcribed text" },
+  },
+  async run(options) {
+    const { audio, provider, output } = options as {
+      audio: string;
+      provider?: "groq" | "fireworks";
+      output?: string;
+    };
+    return transcribe({ audioUrl: audio, provider, outputPath: output });
+  },
+};
+
 // types
 export interface TranscribeOptions {
   audioUrl: string; // url or local file path
@@ -163,65 +204,7 @@ export async function transcribe(
 }
 
 // cli
-async function cli() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  if (!command || command === "help") {
-    console.log(`
-usage:
-  bun run service/transcribe.ts <audioPath> [provider] [outputPath]
-
-arguments:
-  audioPath      - url or local path to audio file
-  provider       - groq (default) | fireworks
-  outputPath     - optional path to save transcription
-
-examples:
-  bun run service/transcribe.ts https://example.com/audio.mp3
-  bun run service/transcribe.ts media/dora.ogg groq
-  bun run service/transcribe.ts https://example.com/audio.mp3 fireworks output.srt
-  bun run service/transcribe.ts media/audio.mp3 groq output.txt
-
-providers:
-  groq        - ultra-fast whisper (text only, free tier available)
-  fireworks   - slower but includes srt timestamps (uses reels-srt api)
-
-environment:
-  GROQ_API_KEY - your groq api key (for groq provider)
-    `);
-    process.exit(0);
-  }
-
-  try {
-    const audioUrl = args[0];
-    const provider = (args[1] || "groq") as "groq" | "fireworks";
-    const outputPath = args[2];
-
-    if (!audioUrl) {
-      throw new Error("audioUrl is required");
-    }
-
-    const result = await transcribe({
-      audioUrl,
-      provider,
-      outputFormat: provider === "fireworks" ? "srt" : "text",
-      outputPath: outputPath || join(process.cwd(), "output.txt"),
-    });
-
-    if (result.success) {
-      console.log("\ntranscription:");
-      console.log(result.srt || result.text);
-    } else {
-      console.error(`\nerror: ${result.error}`);
-      process.exit(1);
-    }
-  } catch (error) {
-    console.error("[transcribe] error:", error);
-    process.exit(1);
-  }
-}
-
 if (import.meta.main) {
-  cli();
+  const { runCli } = await import("../../cli/runner");
+  runCli(meta);
 }

package/action/video/index.ts

@@ -4,9 +4,50 @@
  * usage: bun run service/video.ts <command> <args>
  */
 
+import type { ActionMeta } from "../../cli/types";
 import { imageToVideo, textToVideo } from "../../lib/fal";
 import { uploadFromUrl } from "../../utilities/s3";
 
+export const meta: ActionMeta = {
+  name: "video",
+  type: "action",
+  description: "generate video from text or image",
+  inputType: "text/image",
+  outputType: "video",
+  schema: {
+    input: {
+      type: "object",
+      required: ["prompt"],
+      properties: {
+        prompt: { type: "string", description: "what to generate" },
+        image: {
+          type: "string",
+          format: "file-path",
+          description: "input image (enables image-to-video)",
+        },
+        duration: {
+          type: "integer",
+          enum: [5, 10],
+          default: 5,
+          description: "video duration in seconds",
+        },
+      },
+    },
+    output: { type: "string", format: "file-path", description: "video path" },
+  },
+  async run(options) {
+    const { prompt, image, duration } = options as {
+      prompt: string;
+      image?: string;
+      duration?: 5 | 10;
+    };
+    if (image) {
+      return generateVideoFromImage(prompt, image, { duration });
+    }
+    return generateVideoFromText(prompt, { duration });
+  },
+};
+
 export interface VideoGenerationResult {
   videoUrl: string;
   duration?: number;
@@ -77,59 +118,8 @@ export async function generateVideoFromText(
   };
 }
 
-// cli runner
+// cli
 if (import.meta.main) {
-  const [command, ...args] = process.argv.slice(2);
-
-  switch (command) {
-    case "from_image": {
-      if (!args[0] || !args[1]) {
-        console.log(`
-usage:
-  bun run service/video.ts from_image <prompt> <imageUrl> [duration] [upload]
-        `);
-        process.exit(1);
-      }
-      const duration = args[2];
-      if (duration && duration !== "5" && duration !== "10") {
-        console.error("duration must be 5 or 10");
-        process.exit(1);
-      }
-      const imgResult = await generateVideoFromImage(args[0], args[1], {
-        duration: duration === "10" ? 10 : 5,
-        upload: args[3] === "true",
-      });
-      console.log(JSON.stringify(imgResult, null, 2));
-      break;
-    }
-
-    case "from_text": {
-      if (!args[0]) {
-        console.log(`
-usage:
-  bun run service/video.ts from_text <prompt> [duration] [upload]
-        `);
-        process.exit(1);
-      }
-      const duration = args[1];
-      if (duration && duration !== "5" && duration !== "10") {
-        console.error("duration must be 5 or 10");
-        process.exit(1);
-      }
-      const txtResult = await generateVideoFromText(args[0], {
-        duration: duration === "10" ? 10 : 5,
-        upload: args[2] === "true",
-      });
-      console.log(JSON.stringify(txtResult, null, 2));
-      break;
-    }
-
-    default:
-      console.log(`
-usage:
-  bun run service/video.ts from_image <prompt> <imageUrl> [duration] [upload]
-  bun run service/video.ts from_text <prompt> [duration] [upload]
-      `);
-      process.exit(1);
-  }
+  const { runCli } = await import("../../cli/runner");
+  runCli(meta);
 }

package/action/voice/index.ts

@@ -5,9 +5,47 @@
  * supports elevenlabs and future providers
  */
 
+import type { ActionMeta } from "../../cli/types";
 import { textToSpeech, VOICES } from "../../lib/elevenlabs";
 import { uploadFile } from "../../utilities/s3";
 
+export const meta: ActionMeta = {
+  name: "voice",
+  type: "action",
+  description: "text to speech generation",
+  inputType: "text",
+  outputType: "audio",
+  schema: {
+    input: {
+      type: "object",
+      required: ["text"],
+      properties: {
+        text: { type: "string", description: "text to convert to speech" },
+        voice: {
+          type: "string",
+          enum: ["rachel", "domi", "bella", "antoni", "josh", "adam", "sam"],
+          default: "rachel",
+          description: "voice to use",
+        },
+        output: {
+          type: "string",
+          format: "file-path",
+          description: "output file path",
+        },
+      },
+    },
+    output: { type: "string", format: "file-path", description: "audio path" },
+  },
+  async run(options) {
+    const { text, voice, output } = options as {
+      text: string;
+      voice?: string;
+      output?: string;
+    };
+    return generateVoice({ text, voice, outputPath: output });
+  },
+};
+
 // types
 export interface GenerateVoiceOptions {
   text: string;
@@ -92,110 +130,7 @@ export async function generateVoice(
 }
 
 // cli
-async function cli() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  if (!command || command === "help") {
-    console.log(`
-usage:
-  bun run service/voice.ts <command> [args]
-
-commands:
-  generate <text> [voice] [provider] [upload]    generate voice from text
-  elevenlabs <text> [voice] [upload]             generate with elevenlabs
-  help                                           show this help
-
-examples:
-  bun run service/voice.ts generate "hello world" rachel elevenlabs false
-  bun run service/voice.ts elevenlabs "hello world" josh true
-  bun run service/voice.ts generate "welcome to ai" bella
-
-available voices:
-  rachel, domi, bella, antoni, elli, josh, arnold, adam, sam
-
-providers:
-  elevenlabs (default)
-
-environment:
-  ELEVENLABS_API_KEY - required for elevenlabs
-  CLOUDFLARE_* - required for upload
-    `);
-    process.exit(0);
-  }
-
-  try {
-    switch (command) {
-      case "generate": {
-        const text = args[1];
-        const voice = args[2];
-        const provider = (args[3] || "elevenlabs") as "elevenlabs";
-        const upload = args[4] === "true";
-
-        if (!text) {
-          throw new Error("text is required");
-        }
-
-        const outputPath = `media/voice-${Date.now()}.mp3`;
-
-        const result = await generateVoice({
-          text,
-          voice,
-          provider,
-          upload,
-          outputPath,
-        });
-
-        console.log(`[voice] result:`, {
-          provider: result.provider,
-          voiceId: result.voiceId,
-          audioSize: result.audio.length,
-          outputPath,
-          uploadUrl: result.uploadUrl,
-        });
-        break;
-      }
-
-      case "elevenlabs": {
-        const text = args[1];
-        const voice = args[2];
-        const upload = args[3] === "true";
-
-        if (!text) {
-          throw new Error("text is required");
-        }
-
-        const outputPath = `media/voice-${Date.now()}.mp3`;
-
-        const result = await generateVoice({
-          text,
-          voice,
-          provider: "elevenlabs",
-          upload,
-          outputPath,
-        });
-
-        console.log(`[voice] result:`, {
-          provider: result.provider,
-          voiceId: result.voiceId,
-          audioSize: result.audio.length,
-          outputPath,
-          uploadUrl: result.uploadUrl,
-        });
-        break;
-      }
-
-      default:
-        console.error(`unknown command: ${command}`);
-        console.log(`run 'bun run service/voice.ts help' for usage`);
-        process.exit(1);
-    }
-  } catch (error) {
-    console.error(`[voice] error:`, error);
-    process.exit(1);
-  }
-}
-
 if (import.meta.main) {
-  cli();
+  const { runCli } = await import("../../cli/runner");
+  runCli(meta);
 }

package/cli/commands/find.ts

@@ -0,0 +1,58 @@
+/**
+ * varg find command
+ * fuzzy search by scanning filesystem
+ */
+
+import { defineCommand } from "citty";
+import { search } from "../discover";
+import { box, c, header, separator } from "../ui";
+
+export const findCmd = defineCommand({
+  meta: {
+    name: "find",
+    description: "fuzzy search for models/actions",
+  },
+  args: {
+    query: {
+      type: "positional",
+      description: "search query",
+      required: true,
+    },
+  },
+  async run({ args }) {
+    const query = args.query;
+
+    if (!query) {
+      console.error(`${c.red("error:")} search query required`);
+      console.log(`\nusage: ${c.cyan("varg find <query>")}`);
+      process.exit(1);
+    }
+
+    const results = await search(query);
+
+    if (results.length === 0) {
+      console.log(`\nno matches for "${query}"`);
+      console.log(`\ntry ${c.cyan("varg list")} to see all available actions`);
+      return;
+    }
+
+    const content: string[] = [];
+    content.push("");
+    content.push(header("MATCHES"));
+    content.push("");
+
+    for (const action of results) {
+      content.push(
+        `  ${c.cyan(action.name.padEnd(16))}${action.inputType} → ${action.outputType}`,
+      );
+    }
+
+    content.push("");
+    content.push(separator());
+    content.push("");
+    content.push(`  run ${c.cyan("varg run <name> --help")} for usage`);
+    content.push("");
+
+    console.log(box(`search: "${query}"`, content));
+  },
+});

package/cli/commands/help.ts

@@ -0,0 +1,70 @@
+/**
+ * varg help command
+ */
+
+import { defineCommand } from "citty";
+import { box, c, header, separator } from "../ui";
+
+export const helpCmd = defineCommand({
+  meta: {
+    name: "help",
+    description: "show help",
+  },
+  run() {
+    const content: string[] = [];
+    content.push("");
+    content.push("  AI video infrastructure from your terminal.");
+    content.push("");
+    content.push(separator());
+    content.push("");
+    content.push(header("USAGE"));
+    content.push("");
+    content.push(`  varg ${c.cyan("<command>")} [target] [options]`);
+    content.push("");
+    content.push(separator());
+    content.push("");
+    content.push(header("COMMANDS"));
+    content.push("");
+    content.push(`  ${c.cyan("run".padEnd(12))}run a model or action`);
+    content.push(`  ${c.cyan("list".padEnd(12))}discover what's available`);
+    content.push(
+      `  ${c.cyan("find".padEnd(12))}fuzzy search for models/actions`,
+    );
+    content.push(
+      `  ${c.cyan("which".padEnd(12))}inspect what's behind an action`,
+    );
+    content.push(`  ${c.cyan("help".padEnd(12))}show this help`);
+    content.push("");
+    content.push(separator());
+    content.push("");
+    content.push(header("EXAMPLES"));
+    content.push("");
+    content.push(`  ${c.dim("# generate video from text")}`);
+    content.push(`  varg run kling --prompt "a cat dancing"`);
+    content.push("");
+    content.push(`  ${c.dim("# animate an image")}`);
+    content.push(`  varg run image-to-video --image ./cat.png`);
+    content.push("");
+    content.push(`  ${c.dim("# transcribe audio")}`);
+    content.push(`  varg run transcribe ./video.mp4`);
+    content.push("");
+    content.push(`  ${c.dim("# see what's available")}`);
+    content.push(`  varg list`);
+    content.push("");
+    content.push(separator());
+    content.push("");
+    content.push(header("ENVIRONMENT"));
+    content.push("");
+    content.push(`  ${c.dim("FAL_KEY".padEnd(24))}fal.ai api key`);
+    content.push(
+      `  ${c.dim("REPLICATE_API_TOKEN".padEnd(24))}replicate api key`,
+    );
+    content.push(
+      `  ${c.dim("ELEVENLABS_API_KEY".padEnd(24))}elevenlabs api key`,
+    );
+    content.push(`  ${c.dim("GROQ_API_KEY".padEnd(24))}groq api key`);
+    content.push("");
+
+    console.log(box("varg", content));
+  },
+});

package/cli/commands/list.ts

@@ -0,0 +1,49 @@
+/**
+ * varg list command
+ * discover what's available by scanning filesystem
+ */
+
+import { defineCommand } from "citty";
+import { discoverActions } from "../discover";
+import { box, c, header, separator, table } from "../ui";
+
+export const listCmd = defineCommand({
+  meta: {
+    name: "list",
+    description: "discover what's available",
+  },
+  args: {
+    filter: {
+      type: "positional",
+      description: "filter by type",
+      required: false,
+    },
+  },
+  async run() {
+    const actions = await discoverActions();
+
+    const content: string[] = [];
+    content.push("");
+
+    content.push(header("ACTIONS"));
+    content.push("");
+
+    const rows = actions.map((a) => ({
+      name: a.name,
+      description:
+        `${a.inputType} → ${a.outputType}`.padEnd(20) + a.description,
+    }));
+
+    content.push(...table(rows));
+    content.push("");
+
+    content.push(separator());
+    content.push("");
+    content.push(
+      `  ${actions.length} actions · run ${c.cyan("varg run <action> --info")} for details`,
+    );
+    content.push("");
+
+    console.log(box("varg", content));
+  },
+});