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

package/src/definitions/actions/captions.ts

@@ -0,0 +1,261 @@
+/**
+ * Captions/subtitles action
+ * Add captions to video from transcription
+ */
+
+import { writeFileSync } from "node:fs";
+import { z } from "zod";
+import { captionStyleSchema, filePathSchema } from "../../core/schema/shared";
+import type { ActionDefinition, ZodSchema } from "../../core/schema/types";
+import { ffmpegProvider } from "../../providers/ffmpeg";
+import { transcribe } from "./transcribe";
+
+// Input schema with Zod
+const captionsInputSchema = z.object({
+  video: filePathSchema.describe("Input video"),
+  output: filePathSchema.describe("Output path"),
+  srt: filePathSchema.optional().describe("SRT file (optional)"),
+  style: captionStyleSchema.default("default").describe("Caption style"),
+});
+
+// Output schema with Zod - returns the output path
+const captionsOutputSchema = z.string().describe("Captioned video path");
+
+// Schema object for the definition
+const schema: ZodSchema<
+  typeof captionsInputSchema,
+  typeof captionsOutputSchema
+> = {
+  input: captionsInputSchema,
+  output: captionsOutputSchema,
+};
+
+export const definition: ActionDefinition<typeof schema> = {
+  type: "action",
+  name: "captions",
+  description: "Add captions/subtitles to video",
+  schema,
+  routes: [],
+  execute: async (inputs) => {
+    const { video, output, srt, style } = inputs;
+    return addCaptions({ video, output, srt, style });
+  },
+};
+
+// Types
+export interface SubtitleStyle {
+  fontName?: string;
+  fontSize?: number;
+  primaryColor?: string;
+  outlineColor?: string;
+  backColor?: string;
+  bold?: boolean;
+  outline?: number;
+  shadow?: number;
+  marginV?: number;
+  alignment?: number;
+}
+
+export interface AddCaptionsOptions {
+  video: string;
+  output: string;
+  srt?: string;
+  style?: "default" | "tiktok" | "youtube";
+}
+
+// Style presets
+const STYLE_PRESETS: Record<string, SubtitleStyle> = {
+  default: {
+    fontName: "Arial",
+    fontSize: 24,
+    primaryColor: "&HFFFFFF",
+    outlineColor: "&H000000",
+    outline: 2,
+    shadow: 1,
+    marginV: 30,
+    alignment: 2, // Bottom center
+  },
+  tiktok: {
+    fontName: "Montserrat",
+    fontSize: 32,
+    primaryColor: "&HFFFFFF",
+    outlineColor: "&H000000",
+    backColor: "&H80000000",
+    bold: true,
+    outline: 3,
+    shadow: 0,
+    marginV: 50,
+    alignment: 2,
+  },
+  youtube: {
+    fontName: "Roboto",
+    fontSize: 28,
+    primaryColor: "&HFFFFFF",
+    outlineColor: "&H000000",
+    backColor: "&H40000000",
+    outline: 2,
+    shadow: 1,
+    marginV: 40,
+    alignment: 2,
+  },
+};
+
+/**
+ * Add captions to video
+ */
+export async function addCaptions(
+  options: AddCaptionsOptions,
+): Promise<string> {
+  const { video, output, srt: srtPath, style = "default" } = options;
+
+  console.log(`[captions] adding captions to ${video}...`);
+
+  // Generate SRT if not provided
+  let srtFile = srtPath;
+  if (!srtFile) {
+    console.log("[captions] generating transcription...");
+
+    // Extract audio first
+    const audioPath = video.replace(/\.[^.]+$/, "_audio.mp3");
+    await ffmpegProvider.extractAudio(video, audioPath);
+
+    // Transcribe
+    const result = await transcribe({
+      audioUrl: audioPath,
+      provider: "fireworks",
+      outputFormat: "srt",
+    });
+
+    if (!result.success || !result.srt) {
+      throw new Error("Transcription failed");
+    }
+
+    // Save SRT
+    srtFile = video.replace(/\.[^.]+$/, ".srt");
+    writeFileSync(srtFile, result.srt);
+    console.log(`[captions] saved srt to ${srtFile}`);
+  }
+
+  // Get style preset (default is always defined)
+  const styleConfig = STYLE_PRESETS[style] ??
+    STYLE_PRESETS.default ?? {
+      fontName: "Arial",
+      fontSize: 24,
+      primaryColor: "&HFFFFFF",
+      outlineColor: "&H000000",
+      outline: 2,
+      shadow: 1,
+      marginV: 30,
+      alignment: 2,
+    };
+
+  // Convert SRT to ASS for styling (simplified - in production use a proper ASS library)
+  const assFile = srtFile.replace(".srt", ".ass");
+  await convertSrtToAss(srtFile, assFile, styleConfig);
+
+  // Burn subtitles into video using ffmpeg
+  // This is a simplified implementation - full implementation would use subtitles filter
+  console.log(`[captions] burning subtitles...`);
+
+  // For now, just copy the video (proper implementation would use subtitles filter)
+  await ffmpegProvider.convertFormat({ input: video, output });
+
+  console.log(`[captions] saved to ${output}`);
+  return output;
+}
+
+/**
+ * Convert SRT to ASS format with styling
+ */
+async function convertSrtToAss(
+  srtPath: string,
+  assPath: string,
+  style: SubtitleStyle,
+): Promise<void> {
+  const srtContent = await Bun.file(srtPath).text();
+
+  // Parse SRT and convert to ASS
+  const assHeader = `[Script Info]
+Title: Generated Subtitles
+ScriptType: v4.00+
+WrapStyle: 0
+ScaledBorderAndShadow: yes
+YCbCr Matrix: TV.601
+
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Default,${style.fontName || "Arial"},${style.fontSize || 24},${style.primaryColor || "&HFFFFFF"},&H000000FF,${style.outlineColor || "&H000000"},${style.backColor || "&H00000000"},${style.bold ? -1 : 0},0,0,0,100,100,0,0,1,${style.outline || 2},${style.shadow || 1},${style.alignment || 2},10,10,${style.marginV || 30},1
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+`;
+
+  // Convert SRT entries to ASS dialogue lines
+  const entries = parseSrt(srtContent);
+  const assDialogues = entries
+    .map((entry) => {
+      const start = formatAssTime(entry.start);
+      const end = formatAssTime(entry.end);
+      const text = entry.text.replace(/\n/g, "\\N");
+      return `Dialogue: 0,${start},${end},Default,,0,0,0,,${text}`;
+    })
+    .join("\n");
+
+  writeFileSync(assPath, assHeader + assDialogues);
+}
+
+interface SrtEntry {
+  index: number;
+  start: number;
+  end: number;
+  text: string;
+}
+
+function parseSrt(content: string): SrtEntry[] {
+  const entries: SrtEntry[] = [];
+  const blocks = content.trim().split(/\n\n+/);
+
+  for (const block of blocks) {
+    const lines = block.split("\n");
+    if (lines.length < 3) continue;
+
+    const index = Number.parseInt(lines[0] || "0", 10);
+    const timeLine = lines[1] || "";
+    const timeMatch = timeLine.match(
+      /(\d{2}):(\d{2}):(\d{2})[,.](\d{3})\s*-->\s*(\d{2}):(\d{2}):(\d{2})[,.](\d{3})/,
+    );
+
+    if (!timeMatch) continue;
+
+    const [, h1, m1, s1, ms1, h2, m2, s2, ms2] = timeMatch;
+    if (!h1 || !m1 || !s1 || !ms1 || !h2 || !m2 || !s2 || !ms2) continue;
+
+    const start = parseTime(h1, m1, s1, ms1);
+    const end = parseTime(h2, m2, s2, ms2);
+    const text = lines.slice(2).join("\n");
+
+    entries.push({ index, start, end, text });
+  }
+
+  return entries;
+}
+
+function parseTime(h: string, m: string, s: string, ms: string): number {
+  return (
+    Number.parseInt(h, 10) * 3600 +
+    Number.parseInt(m, 10) * 60 +
+    Number.parseInt(s, 10) +
+    Number.parseInt(ms, 10) / 1000
+  );
+}
+
+function formatAssTime(seconds: number): string {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = Math.floor(seconds % 60);
+  const cs = Math.floor((seconds % 1) * 100);
+
+  return `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}.${String(cs).padStart(2, "0")}`;
+}
+
+export default definition;

package/src/definitions/actions/edit.ts

@@ -0,0 +1,298 @@
+/**
+ * Video editing actions
+ * FFmpeg-based local video processing
+ */
+
+import { z } from "zod";
+import { filePathSchema } from "../../core/schema/shared";
+import type { ActionDefinition, ZodSchema } from "../../core/schema/types";
+import { ffmpegProvider } from "../../providers/ffmpeg";
+
+// ============================================================================
+// Trim action
+// ============================================================================
+
+const trimInputSchema = z.object({
+  input: filePathSchema.describe("Input video"),
+  output: filePathSchema.describe("Output path"),
+  start: z.number().describe("Start time in seconds"),
+  duration: z.number().optional().describe("Duration in seconds"),
+});
+
+const trimOutputSchema = z.string().describe("Trimmed video path");
+
+const trimSchema: ZodSchema<typeof trimInputSchema, typeof trimOutputSchema> = {
+  input: trimInputSchema,
+  output: trimOutputSchema,
+};
+
+export const trimDefinition: ActionDefinition<typeof trimSchema> = {
+  type: "action",
+  name: "trim",
+  description: "Trim video to specific time range",
+  schema: trimSchema,
+  routes: [],
+  execute: async (inputs) => {
+    const { input, output, start, duration } = inputs;
+    return ffmpegProvider.trimVideo({ input, output, start, duration });
+  },
+};
+
+// ============================================================================
+// Cut action (alias for trim)
+// ============================================================================
+
+export const cutDefinition: ActionDefinition<typeof trimSchema> = {
+  type: "action",
+  name: "cut",
+  description: "Cut video at specific point",
+  schema: trimSchema,
+  routes: [{ target: "trim" }],
+};
+
+// ============================================================================
+// Merge action
+// ============================================================================
+
+const mergeInputSchema = z.object({
+  inputs: z.array(z.string()).describe("Input video paths"),
+  output: filePathSchema.describe("Output path"),
+});
+
+const mergeOutputSchema = z.string().describe("Merged video path");
+
+const mergeSchema: ZodSchema<
+  typeof mergeInputSchema,
+  typeof mergeOutputSchema
+> = {
+  input: mergeInputSchema,
+  output: mergeOutputSchema,
+};
+
+export const mergeDefinition: ActionDefinition<typeof mergeSchema> = {
+  type: "action",
+  name: "merge",
+  description: "Merge multiple videos together",
+  schema: mergeSchema,
+  routes: [],
+  execute: async (inputs) => {
+    const { inputs: videoInputs, output } = inputs;
+    return ffmpegProvider.concatVideos({ inputs: videoInputs, output });
+  },
+};
+
+// ============================================================================
+// Split action
+// ============================================================================
+
+const splitInputSchema = z.object({
+  input: filePathSchema.describe("Input video"),
+  timestamps: z.array(z.number()).describe("Split points in seconds"),
+  outputPrefix: z.string().describe("Output filename prefix"),
+});
+
+// Output is an array of output paths
+const splitOutputSchema = z.array(z.string());
+
+const splitSchema: ZodSchema<
+  typeof splitInputSchema,
+  typeof splitOutputSchema
+> = {
+  input: splitInputSchema,
+  output: splitOutputSchema,
+};
+
+export const splitDefinition: ActionDefinition<typeof splitSchema> = {
+  type: "action",
+  name: "split",
+  description: "Split video at timestamps",
+  schema: splitSchema,
+  routes: [],
+  execute: async (inputs) => {
+    const { input, timestamps, outputPrefix } = inputs;
+    return ffmpegProvider.splitAtTimestamps({
+      input,
+      timestamps,
+      outputPrefix,
+    });
+  },
+};
+
+// ============================================================================
+// Fade action
+// ============================================================================
+
+const fadeInputSchema = z.object({
+  input: filePathSchema.describe("Input video"),
+  output: filePathSchema.describe("Output path"),
+  type: z.enum(["in", "out", "both"]).describe("Fade type"),
+  duration: z.number().describe("Fade duration in seconds"),
+});
+
+const fadeOutputSchema = z.string().describe("Faded video path");
+
+const fadeSchema: ZodSchema<typeof fadeInputSchema, typeof fadeOutputSchema> = {
+  input: fadeInputSchema,
+  output: fadeOutputSchema,
+};
+
+export const fadeDefinition: ActionDefinition<typeof fadeSchema> = {
+  type: "action",
+  name: "fade",
+  description: "Apply fade in/out effects",
+  schema: fadeSchema,
+  routes: [],
+  execute: async (inputs) => {
+    const { input, output, type, duration } = inputs;
+    return ffmpegProvider.fadeVideo({ input, output, type, duration });
+  },
+};
+
+// ============================================================================
+// Transition action
+// ============================================================================
+
+const transitionInputSchema = z.object({
+  input1: filePathSchema.describe("First video"),
+  input2: filePathSchema.describe("Second video"),
+  output: filePathSchema.describe("Output path"),
+  transition: z
+    .enum([
+      "crossfade",
+      "dissolve",
+      "wipeleft",
+      "wiperight",
+      "slideup",
+      "slidedown",
+    ])
+    .describe("Transition type"),
+  duration: z.number().describe("Transition duration"),
+  fit: z
+    .enum(["pad", "crop", "blur", "stretch"])
+    .default("pad")
+    .describe("How to handle different resolutions"),
+});
+
+const transitionOutputSchema = z.string().describe("Output path");
+
+const transitionSchema: ZodSchema<
+  typeof transitionInputSchema,
+  typeof transitionOutputSchema
+> = {
+  input: transitionInputSchema,
+  output: transitionOutputSchema,
+};
+
+export const transitionDefinition: ActionDefinition<typeof transitionSchema> = {
+  type: "action",
+  name: "transition",
+  description: "Apply transition between two videos",
+  schema: transitionSchema,
+  routes: [],
+  execute: async (inputs) => {
+    const { input1, input2, output, transition, duration, fit } = inputs;
+    return ffmpegProvider.xfadeVideos({
+      input1,
+      input2,
+      output,
+      transition,
+      duration,
+      fit,
+    });
+  },
+};
+
+// ============================================================================
+// Remove (audio) action
+// ============================================================================
+
+const removeInputSchema = z.object({
+  input: filePathSchema.describe("Input video"),
+  output: filePathSchema.describe("Output path"),
+  what: z
+    .enum(["audio", "video"])
+    .default("audio")
+    .describe("What to extract/remove"),
+});
+
+const removeOutputSchema = z.string().describe("Output path");
+
+const removeSchema: ZodSchema<
+  typeof removeInputSchema,
+  typeof removeOutputSchema
+> = {
+  input: removeInputSchema,
+  output: removeOutputSchema,
+};
+
+export const removeDefinition: ActionDefinition<typeof removeSchema> = {
+  type: "action",
+  name: "remove",
+  description: "Remove audio from video or extract audio",
+  schema: removeSchema,
+  routes: [],
+  execute: async (inputs) => {
+    const { input, output, what } = inputs;
+
+    if (what === "audio") {
+      return ffmpegProvider.extractAudio(input, output);
+    }
+
+    // Extract video (remove audio)
+    return ffmpegProvider.convertFormat({ input, output });
+  },
+};
+
+// Export all definitions
+export const definitions = [
+  trimDefinition,
+  cutDefinition,
+  mergeDefinition,
+  splitDefinition,
+  fadeDefinition,
+  transitionDefinition,
+  removeDefinition,
+];
+
+// Re-export types for backward compatibility
+export type TrimOptions = Parameters<typeof ffmpegProvider.trimVideo>[0];
+export type TrimResult = Awaited<ReturnType<typeof ffmpegProvider.trimVideo>>;
+export type CutOptions = TrimOptions;
+export type CutResult = TrimResult;
+export type MergeOptions = Parameters<typeof ffmpegProvider.concatVideos>[0];
+export type MergeResult = Awaited<
+  ReturnType<typeof ffmpegProvider.concatVideos>
+>;
+export type SplitOptions = Parameters<
+  typeof ffmpegProvider.splitAtTimestamps
+>[0];
+export type SplitResult = Awaited<
+  ReturnType<typeof ffmpegProvider.splitAtTimestamps>
+>;
+export type FadeOptions = Parameters<typeof ffmpegProvider.fadeVideo>[0];
+export type FadeResult = Awaited<ReturnType<typeof ffmpegProvider.fadeVideo>>;
+export type TransitionOptions = Parameters<
+  typeof ffmpegProvider.xfadeVideos
+>[0];
+export type TransitionResult = Awaited<
+  ReturnType<typeof ffmpegProvider.xfadeVideos>
+>;
+export type RemoveOptions = {
+  input: string;
+  output: string;
+  what?: "audio" | "video";
+};
+export type RemoveResult = string;
+
+// Convenience exports
+export const trim = (opts: TrimOptions) => ffmpegProvider.trimVideo(opts);
+export const cut = trim;
+export const merge = (opts: MergeOptions) => ffmpegProvider.concatVideos(opts);
+export const split = (opts: SplitOptions) =>
+  ffmpegProvider.splitAtTimestamps(opts);
+export const fade = (opts: FadeOptions) => ffmpegProvider.fadeVideo(opts);
+export const transition = (opts: TransitionOptions) =>
+  ffmpegProvider.xfadeVideos(opts);
+export const remove = removeDefinition.execute;
+
+export default trimDefinition;

package/src/definitions/actions/image.ts

@@ -0,0 +1,125 @@
+/**
+ * Image generation action
+ * Routes to Fal or Higgsfield based on options
+ */
+
+import { z } from "zod";
+import { imageSizeSchema } from "../../core/schema/shared";
+import type { ActionDefinition, ZodSchema } from "../../core/schema/types";
+import { falProvider } from "../../providers/fal";
+import { higgsfieldProvider } from "../../providers/higgsfield";
+import { storageProvider } from "../../providers/storage";
+
+// Input schema with Zod
+const imageInputSchema = z.object({
+  prompt: z.string().describe("What to generate"),
+  size: imageSizeSchema
+    .default("landscape_4_3")
+    .describe("Image size/aspect ratio"),
+  provider: z
+    .enum(["fal", "higgsfield"])
+    .default("fal")
+    .describe("Generation provider"),
+});
+
+// Output schema with Zod
+const imageOutputSchema = z.object({
+  imageUrl: z.string(),
+  uploaded: z.string().optional(),
+});
+
+// Schema object for the definition
+const schema: ZodSchema<typeof imageInputSchema, typeof imageOutputSchema> = {
+  input: imageInputSchema,
+  output: imageOutputSchema,
+};
+
+export const definition: ActionDefinition<typeof schema> = {
+  type: "action",
+  name: "image",
+  description: "Generate image from text",
+  schema,
+  routes: [
+    {
+      target: "flux",
+      when: { provider: "fal" },
+      priority: 5,
+    },
+    {
+      target: "soul",
+      when: { provider: "higgsfield" },
+      priority: 10,
+    },
+  ],
+  execute: async (inputs) => {
+    const { prompt, size, provider } = inputs;
+
+    if (provider === "higgsfield") {
+      return generateWithSoul(prompt);
+    }
+
+    return generateWithFal(prompt, { imageSize: size });
+  },
+};
+
+export interface ImageGenerationResult {
+  imageUrl: string;
+  uploaded?: string;
+}
+
+export async function generateWithFal(
+  prompt: string,
+  options: { imageSize?: string; upload?: boolean } = {},
+): Promise<ImageGenerationResult> {
+  console.log("[image] generating with fal");
+
+  const result = await falProvider.generateImage({
+    prompt,
+    imageSize: options.imageSize,
+  });
+
+  const imageUrl = (result.data as { images?: Array<{ url?: string }> })
+    ?.images?.[0]?.url;
+  if (!imageUrl) {
+    throw new Error("No image URL in result");
+  }
+
+  let uploaded: string | undefined;
+  if (options.upload) {
+    const timestamp = Date.now();
+    const objectKey = `images/fal/${timestamp}.png`;
+    uploaded = await storageProvider.uploadFromUrl(imageUrl, objectKey);
+    console.log(`[image] uploaded to ${uploaded}`);
+  }
+
+  return { imageUrl, uploaded };
+}
+
+export async function generateWithSoul(
+  prompt: string,
+  options: { styleId?: string; upload?: boolean } = {},
+): Promise<ImageGenerationResult> {
+  console.log("[image] generating with higgsfield soul");
+
+  const result = await higgsfieldProvider.generateSoul({
+    prompt,
+    styleId: options.styleId,
+  });
+
+  const imageUrl = result.jobs?.[0]?.results?.raw?.url;
+  if (!imageUrl) {
+    throw new Error("No image URL in result");
+  }
+
+  let uploaded: string | undefined;
+  if (options.upload) {
+    const timestamp = Date.now();
+    const objectKey = `images/soul/${timestamp}.png`;
+    uploaded = await storageProvider.uploadFromUrl(imageUrl, objectKey);
+    console.log(`[image] uploaded to ${uploaded}`);
+  }
+
+  return { imageUrl, uploaded };
+}
+
+export default definition;