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

package/src/react/types.ts

@@ -0,0 +1,232 @@
+import type { ImageModelV3, SpeechModelV3 } from "@ai-sdk/provider";
+import type { MusicModelV3 } from "../ai-sdk/music-model";
+import type {
+  Position,
+  ResizeMode,
+  SizeValue,
+  TransitionOptions,
+} from "../ai-sdk/providers/editly/types";
+import type { VideoModelV3 } from "../ai-sdk/video-model";
+
+export type VargElementType =
+  | "render"
+  | "clip"
+  | "overlay"
+  | "image"
+  | "video"
+  | "animate"
+  | "speech"
+  | "talking-head"
+  | "title"
+  | "subtitle"
+  | "music"
+  | "captions"
+  | "split"
+  | "slider"
+  | "swipe"
+  | "packshot";
+
+export interface VargElement<T extends VargElementType = VargElementType> {
+  type: T;
+  props: Record<string, unknown>;
+  children: VargNode[];
+}
+
+export type VargNode =
+  | VargElement
+  | string
+  | number
+  | null
+  | undefined
+  | VargNode[];
+
+export interface BaseProps {
+  key?: string | number;
+}
+
+export interface PositionProps {
+  left?: SizeValue;
+  top?: SizeValue;
+  width?: SizeValue;
+  height?: SizeValue;
+}
+
+export interface VolumeProps {
+  volume?: number;
+}
+
+export interface AudioProps extends VolumeProps {
+  keepAudio?: boolean;
+}
+
+export type TrimProps =
+  | { cutFrom?: number; cutTo?: number; duration?: never }
+  | { cutFrom?: number; cutTo?: never; duration?: number };
+
+// Root container - sets dimensions, fps, contains clips
+export interface RenderProps extends BaseProps {
+  width?: number;
+  height?: number;
+  fps?: number;
+  normalize?: boolean;
+  children?: VargNode;
+}
+
+export interface ClipProps extends BaseProps {
+  duration?: number | "auto";
+  transition?: TransitionOptions;
+  children?: VargNode;
+}
+
+export interface OverlayProps extends BaseProps, PositionProps, AudioProps {
+  children?: VargNode;
+}
+
+export type ImageInput = Uint8Array | string | VargElement<"image">;
+export type ImagePrompt = string | { text?: string; images: ImageInput[] };
+
+export interface ImageProps extends BaseProps, PositionProps {
+  prompt?: ImagePrompt;
+  src?: string;
+  model?: ImageModelV3;
+  aspectRatio?: `${number}:${number}`;
+  zoom?: "in" | "out" | "left" | "right";
+  resize?: ResizeMode;
+  position?: Position;
+  size?: { width: string; height: string };
+  removeBackground?: boolean;
+}
+
+export type VideoPrompt =
+  | string
+  | {
+      text?: string;
+      images?: ImageInput[];
+      audio?: Uint8Array | string;
+      video?: Uint8Array | string;
+    };
+
+export type VideoProps = BaseProps &
+  PositionProps &
+  AudioProps &
+  TrimProps & {
+    prompt?: VideoPrompt;
+    src?: string;
+    model?: VideoModelV3;
+    resize?: ResizeMode;
+  };
+
+// Image-to-video animation
+export interface AnimateProps extends BaseProps, PositionProps {
+  image?: VargElement<"image">;
+  src?: string;
+  model?: VideoModelV3;
+  motion?: string;
+  duration?: number;
+}
+
+export interface SpeechProps extends BaseProps, VolumeProps {
+  voice?: string;
+  model?: SpeechModelV3;
+  id?: string;
+  children?: string;
+}
+
+export interface TalkingHeadProps extends BaseProps {
+  character?: string;
+  src?: string;
+  voice?: string;
+  model?: VideoModelV3;
+  lipsyncModel?: VideoModelV3;
+  position?:
+    | Position
+    | { left?: string; right?: string; top?: string; bottom?: string };
+  size?: { width: string; height: string };
+  children?: string;
+}
+
+export interface TitleProps extends BaseProps {
+  position?: Position;
+  color?: string;
+  start?: number;
+  end?: number;
+  children?: string;
+}
+
+export interface SubtitleProps extends BaseProps {
+  backgroundColor?: string;
+  children?: string;
+}
+
+export type MusicProps = BaseProps &
+  VolumeProps &
+  TrimProps & {
+    prompt?: string;
+    model?: MusicModelV3;
+    src?: string;
+    loop?: boolean;
+    ducking?: boolean;
+  };
+
+export interface CaptionsProps extends BaseProps {
+  src?: string | VargElement<"speech">;
+  srt?: string;
+  style?: "tiktok" | "karaoke" | "bounce" | "typewriter";
+  color?: string;
+  activeColor?: string;
+  fontSize?: number;
+}
+
+export interface SplitProps extends BaseProps {
+  direction?: "horizontal" | "vertical";
+  children?: VargNode;
+}
+
+export interface SliderProps extends BaseProps {
+  direction?: "horizontal" | "vertical";
+  children?: VargNode;
+}
+
+export interface SwipeProps extends BaseProps {
+  direction?: "left" | "right" | "up" | "down";
+  interval?: number;
+  children?: VargNode;
+}
+
+export interface PackshotProps extends BaseProps {
+  background?: VargElement<"image"> | string;
+  logo?: string;
+  logoPosition?: Position;
+  logoSize?: SizeValue;
+  cta?: string;
+  ctaPosition?: Position;
+  ctaColor?: string;
+  ctaSize?: number;
+  blinkCta?: boolean;
+  duration?: number;
+}
+
+export interface RenderOptions {
+  output?: string;
+  cache?: string;
+  quiet?: boolean;
+}
+
+export interface ElementPropsMap {
+  render: RenderProps;
+  clip: ClipProps;
+  overlay: OverlayProps;
+  image: ImageProps;
+  video: VideoProps;
+  animate: AnimateProps;
+  speech: SpeechProps;
+  "talking-head": TalkingHeadProps;
+  title: TitleProps;
+  subtitle: SubtitleProps;
+  music: MusicProps;
+  captions: CaptionsProps;
+  split: SplitProps;
+  slider: SliderProps;
+  swipe: SwipeProps;
+  packshot: PackshotProps;
+}

package/src/studio/index.ts

@@ -0,0 +1,26 @@
+import { resolve } from "node:path";
+import { createStudioServer } from "./server";
+
+// Parse arguments: bun run studio [file.tsx] [--cache=.cache/ai]
+let initialFile: string | undefined;
+let cacheDir = ".cache/ai";
+
+for (const arg of process.argv.slice(2)) {
+  if (arg.startsWith("--cache=")) {
+    cacheDir = arg.replace("--cache=", "");
+  } else if (arg.endsWith(".tsx") || arg.endsWith(".ts")) {
+    initialFile = resolve(arg);
+  }
+}
+
+console.log("varg studio starting...");
+console.log(`cache folder: ${cacheDir}`);
+if (initialFile) {
+  console.log(`initial file: ${initialFile}`);
+}
+
+const { port } = createStudioServer({ cacheDir, initialFile });
+
+console.log(`\nopen http://localhost:${port}`);
+console.log("  /editor - code editor");
+console.log("  /cache  - cache viewer");

package/src/studio/scanner.ts

@@ -0,0 +1,102 @@
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+import type { CacheEntry, CacheItem, ImageData, VideoData } from "./types";
+
+function extractBase64(data: ImageData | VideoData): string | null {
+  if (
+    "uint8ArrayData" in data &&
+    data.uint8ArrayData?.__type === "Uint8Array"
+  ) {
+    return data.uint8ArrayData.data;
+  }
+  if ("_data" in data && data._data?.__type === "Uint8Array") {
+    return data._data.data;
+  }
+  if ("base64" in data && data.base64) {
+    return data.base64;
+  }
+  return null;
+}
+
+function detectMediaType(
+  filename: string,
+  value: unknown,
+): "image" | "video" | "unknown" {
+  if (filename.startsWith("generateImage")) return "image";
+  if (filename.startsWith("generateVideo")) return "video";
+
+  if (value && typeof value === "object") {
+    const v = value as Record<string, unknown>;
+    if ("images" in v) return "image";
+    if ("video" in v) return "video";
+  }
+
+  return "unknown";
+}
+
+export async function scanCacheFolder(cacheDir: string): Promise<CacheItem[]> {
+  const items: CacheItem[] = [];
+
+  try {
+    const files = await readdir(cacheDir);
+
+    for (const file of files) {
+      if (!file.endsWith(".json") || file === ".gitkeep") continue;
+
+      const filePath = join(cacheDir, file);
+      const fileStat = await stat(filePath);
+
+      try {
+        const content = await Bun.file(filePath).text();
+        const entry = JSON.parse(content) as CacheEntry;
+        const type = detectMediaType(file, entry.value);
+
+        items.push({
+          id: file.replace(".json", ""),
+          filename: file,
+          type,
+          size: fileStat.size,
+          createdAt: fileStat.mtime,
+          metadata: { expires: entry.expires },
+        });
+      } catch {}
+    }
+  } catch (err) {
+    console.error("failed to scan cache folder:", err);
+  }
+
+  return items.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+}
+
+export async function getCacheItemMedia(
+  cacheDir: string,
+  id: string,
+): Promise<{ type: "image" | "video"; data: string; mimeType: string } | null> {
+  const filePath = join(cacheDir, `${id}.json`);
+
+  try {
+    const content = await Bun.file(filePath).text();
+    const entry = JSON.parse(content) as CacheEntry;
+    const value = entry.value as Record<string, unknown>;
+
+    if ("images" in value && Array.isArray(value.images)) {
+      const firstImage = value.images[0] as ImageData;
+      const base64 = extractBase64(firstImage);
+      if (base64) {
+        return { type: "image", data: base64, mimeType: "image/jpeg" };
+      }
+    }
+
+    if ("video" in value && typeof value.video === "object") {
+      const video = value.video as VideoData;
+      const base64 = extractBase64(video);
+      if (base64) {
+        return { type: "video", data: base64, mimeType: "video/mp4" };
+      }
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}