@adaptic/maestro 1.0.0

package/scripts/media-generation/generate-assets.mjs

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+
+/**
+ * Visual Asset Generator for Adaptic.ai CEO Brain
+ *
+ * Generates branded illustrations, diagrams, and videos for
+ * board materials, investor presentations, and corporate communications.
+ *
+ * Ported from ~/adapticai/app/scripts/media-generation/generate-visual-assets.mjs
+ *
+ * Usage:
+ *   node scripts/media-generation/generate-assets.mjs --illustration <slug>
+ *   node scripts/media-generation/generate-assets.mjs --video <slug>
+ *   node scripts/media-generation/generate-assets.mjs --all-missing
+ *   node scripts/media-generation/generate-assets.mjs --all-missing-videos
+ */
+
+import "dotenv/config";
+
+import fs from "fs/promises";
+import path from "path";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+
+import { generateImageGemini } from "./gemini-image-client.mjs";
+import { createText2Video, downloadVideo } from "./veo-video-client.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const ROOT = path.resolve(__dirname, "../..");
+
+const PROMPTS_DIR = path.join(__dirname, "prompts");
+const ILLUSTRATION_OUTPUT = path.join(ROOT, "public/generated/illustrations");
+const DIAGRAM_OUTPUT = path.join(ROOT, "public/generated/diagrams");
+const VIDEO_OUTPUT = path.join(ROOT, "public/generated/videos");
+const LOG_FILE = path.join(__dirname, "generation-log.json");
+
+const RATE_LIMIT_DELAY = 15000; // 15s between requests
+
+// ─── Helpers ───
+
+async function loadPromptSpec(type, slug) {
+  const specPath = path.join(PROMPTS_DIR, type, `${slug}.ts`);
+  if (!existsSync(specPath)) {
+    // Try .mjs extension
+    const mjsPath = path.join(PROMPTS_DIR, type, `${slug}.mjs`);
+    if (!existsSync(mjsPath)) {
+      throw new Error(`Prompt spec not found: ${specPath} or ${mjsPath}`);
+    }
+    return (await import(mjsPath)).default;
+  }
+  // Use tsx to import TypeScript
+  const { execaCommand } = await import("execa");
+  const result = await execaCommand(
+    `npx tsx -e "import spec from '${specPath}'; console.log(JSON.stringify(spec))"`,
+    { cwd: ROOT },
+  );
+  return JSON.parse(result.stdout);
+}
+
+async function listPromptSlugs(type) {
+  const dir = path.join(PROMPTS_DIR, type);
+  if (!existsSync(dir)) return [];
+  const files = await fs.readdir(dir);
+  return files
+    .filter((f) => f.endsWith(".ts") || f.endsWith(".mjs"))
+    .map((f) => f.replace(/\.(ts|mjs)$/, ""));
+}
+
+async function readLog() {
+  if (!existsSync(LOG_FILE)) return [];
+  const content = await fs.readFile(LOG_FILE, "utf-8");
+  return JSON.parse(content);
+}
+
+async function appendLog(entry) {
+  const log = await readLog();
+  log.push({ ...entry, generatedAt: new Date().toISOString() });
+  await fs.writeFile(LOG_FILE, JSON.stringify(log, null, 2));
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// ─── Illustration Generation ───
+
+async function generateIllustration(slug) {
+  console.log(`\n  Generating illustration: ${slug}`);
+
+  const spec = await loadPromptSpec("illustrations", slug);
+  const outputDir =
+    spec.imageCategory === "diagram" ? DIAGRAM_OUTPUT : ILLUSTRATION_OUTPUT;
+  const outputPath = path.join(outputDir, `${slug}.png`);
+
+  await fs.mkdir(outputDir, { recursive: true });
+
+  const prompt = spec.prompt || buildDefaultPrompt(spec);
+  const aspectRatio = spec.aspectRatio || "16:9";
+
+  const result = await generateImageGemini(prompt, { aspectRatio });
+
+  const buffer = Buffer.from(result.imageBase64, "base64");
+  await fs.writeFile(outputPath, buffer);
+
+  console.log(
+    `  Saved: ${outputPath} (${Math.round(buffer.length / 1024)} KB)`,
+  );
+
+  await appendLog({
+    slug,
+    title: spec.title,
+    type: "illustration",
+    outputPath: path.relative(ROOT, outputPath),
+    aspectRatio,
+    responseId: result.responseId,
+    promptLength: prompt.length,
+    fileSizeKB: Math.round(buffer.length / 1024),
+  });
+
+  return outputPath;
+}
+
+function buildDefaultPrompt(spec) {
+  const parts = [
+    `Create an illustration for: ${spec.title}`,
+    `Purpose: ${spec.purpose}`,
+    `Style: ${spec.style || "Monochromatic NYT-style hand-drawn editorial illustration. Pen-and-ink with cross-hatching and stippling."}`,
+    `Mood: ${(spec.mood || ["institutional", "sophisticated"]).join(", ")}`,
+    `Color palette: ${(spec.colorPalette || ["#1C1917", "#FAFAF9", "#78716C", "#D6D3D1"]).join(", ")}`,
+  ];
+
+  if (spec.elements) {
+    parts.push(
+      `Key elements:\n${spec.elements.map((e) => `- ${e}`).join("\n")}`,
+    );
+  }
+
+  parts.push(
+    "IMPORTANT: This is for Adaptic.ai, an institutional-grade AI asset management platform. The illustration must feel premium, restrained, and sophisticated. Avoid cartoon, isometric, or generic SaaS illustration styles.",
+  );
+
+  return parts.join("\n\n");
+}
+
+// ─── Video Generation ───
+
+async function generateVideo(slug) {
+  console.log(`\n  Generating video: ${slug}`);
+
+  const spec = await loadPromptSpec("videos", slug);
+  const outputPath = path.join(VIDEO_OUTPUT, `${slug}.mp4`);
+
+  await fs.mkdir(VIDEO_OUTPUT, { recursive: true });
+
+  const prompt = spec.prompt || `${spec.title}. ${spec.purpose}`;
+  const options = {
+    duration: spec.duration || "8",
+    aspectRatio: spec.aspectRatio || "16:9",
+    resolution: spec.resolution || "720p",
+  };
+
+  if (spec.negativePrompt) {
+    options.negativePrompt = spec.negativePrompt;
+  }
+
+  let operation;
+  if (spec.sourceImage) {
+    const { createImage2Video } = await import("./veo-video-client.mjs");
+    operation = await createImage2Video(spec.sourceImage, prompt, options);
+  } else {
+    operation = await createText2Video(prompt, options);
+  }
+
+  await downloadVideo(operation, outputPath);
+
+  await appendLog({
+    slug,
+    title: spec.title,
+    type: "video",
+    outputPath: path.relative(ROOT, outputPath),
+    duration: options.duration,
+    aspectRatio: options.aspectRatio,
+    resolution: options.resolution,
+  });
+
+  return outputPath;
+}
+
+// ─── Batch Operations ───
+
+async function generateAllMissing(type) {
+  const slugs = await listPromptSlugs(type);
+  const outputDir =
+    type === "videos"
+      ? VIDEO_OUTPUT
+      : type === "diagrams"
+        ? DIAGRAM_OUTPUT
+        : ILLUSTRATION_OUTPUT;
+  const ext = type === "videos" ? ".mp4" : ".png";
+
+  const missing = slugs.filter(
+    (slug) => !existsSync(path.join(outputDir, `${slug}${ext}`)),
+  );
+
+  console.log(
+    `\n  Found ${missing.length} missing ${type} (of ${slugs.length} total)`,
+  );
+
+  for (const slug of missing) {
+    try {
+      if (type === "videos") {
+        await generateVideo(slug);
+      } else {
+        await generateIllustration(slug);
+      }
+      await sleep(RATE_LIMIT_DELAY);
+    } catch (error) {
+      console.error(`  Error generating ${slug}: ${error.message}`);
+    }
+  }
+}
+
+// ─── CLI ───
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes("--help")) {
+    console.log(`
+  Adaptic.ai Visual Asset Generator
+
+  Usage:
+    --illustration <slug>    Generate a single illustration
+    --video <slug>           Generate a single video
+    --all-missing            Generate all missing illustrations
+    --all-missing-videos     Generate all missing videos
+    --list                   List available prompt slugs
+    --help                   Show this help
+    `);
+    return;
+  }
+
+  if (args.includes("--list")) {
+    const illustrations = await listPromptSlugs("illustrations");
+    const diagrams = await listPromptSlugs("diagrams");
+    const videos = await listPromptSlugs("videos");
+    console.log(
+      `\n  Illustrations (${illustrations.length}):`,
+      illustrations.join(", ") || "none",
+    );
+    console.log(
+      `  Diagrams (${diagrams.length}):`,
+      diagrams.join(", ") || "none",
+    );
+    console.log(`  Videos (${videos.length}):`, videos.join(", ") || "none");
+    return;
+  }
+
+  const illustrationIdx = args.indexOf("--illustration");
+  if (illustrationIdx !== -1) {
+    await generateIllustration(args[illustrationIdx + 1]);
+    return;
+  }
+
+  const videoIdx = args.indexOf("--video");
+  if (videoIdx !== -1) {
+    await generateVideo(args[videoIdx + 1]);
+    return;
+  }
+
+  if (args.includes("--all-missing")) {
+    await generateAllMissing("illustrations");
+    await generateAllMissing("diagrams");
+    return;
+  }
+
+  if (args.includes("--all-missing-videos")) {
+    await generateAllMissing("videos");
+    return;
+  }
+
+  console.error("Unknown arguments. Use --help for usage.");
+}
+
+main().catch((err) => {
+  console.error(`\n  Fatal error: ${err.message}`);
+  process.exit(1);
+});

package/scripts/media-generation/veo-video-client.mjs

@@ -0,0 +1,219 @@
+/**
+ * Veo 3.1 Video Generation Client for Adaptic.ai CEO Brain
+ *
+ * Generates branded video assets for presentations, social media,
+ * and corporate communications.
+ *
+ * Ported from ~/adapticai/app/scripts/media-generation/veo-video-client.mjs
+ *
+ * Usage:
+ *   import { createText2Video, createImage2Video, downloadVideo } from './veo-video-client.mjs';
+ *
+ *   const result = await createText2Video('A professional...', { duration: '8' });
+ *   await downloadVideo(result, 'output.mp4');
+ */
+
+import "dotenv/config";
+
+import fs from "fs/promises";
+import path from "path";
+import { GoogleGenAI } from "@google/genai";
+
+const DEFAULT_MODEL = "veo-3.1-generate-preview";
+const DEFAULT_DURATION = "8";
+const DEFAULT_RESOLUTION = "720p";
+const POLL_INTERVAL = 10000;
+const POLL_TIMEOUT = 600000;
+
+let client = null;
+
+function getClient() {
+  if (client) return client;
+
+  const apiKey = process.env.GEMINI_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "GEMINI_API_KEY environment variable is required.\n" +
+        "Add it to config/environment.yaml or .env file.\n" +
+        "Get your key from: https://aistudio.google.com/apikey",
+    );
+  }
+
+  client = new GoogleGenAI({ apiKey });
+  return client;
+}
+
+async function pollOperation(operation, options = {}) {
+  const ai = getClient();
+  const interval = options.interval || POLL_INTERVAL;
+  const timeout = options.timeout || POLL_TIMEOUT;
+  const startTime = Date.now();
+
+  console.log(
+    `   [Veo] Polling operation (interval: ${interval / 1000}s, timeout: ${timeout / 1000}s)`,
+  );
+
+  while (!operation.done) {
+    const elapsed = Date.now() - startTime;
+    if (elapsed > timeout) {
+      throw new Error(`Veo operation timed out after ${timeout / 1000}s`);
+    }
+
+    console.log(
+      `   [Veo] Status: processing (${Math.round(elapsed / 1000)}s elapsed)`,
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, interval));
+    operation = await ai.operations.getVideosOperation({ operation });
+  }
+
+  console.log(`   [Veo] Operation completed successfully`);
+  return operation;
+}
+
+/**
+ * Create a text-to-video generation task.
+ *
+ * @param {string} prompt - Text description of the video
+ * @param {object} options
+ * @param {string} options.model - Model name (default: veo-3.1-generate-preview)
+ * @param {string} options.duration - '4', '6', or '8' seconds (default: '8')
+ * @param {string} options.aspectRatio - '16:9' or '9:16' (default: '16:9')
+ * @param {string} options.resolution - '720p', '1080p', '4k' (default: '720p')
+ * @param {string} options.negativePrompt - Content to exclude
+ */
+export async function createText2Video(prompt, options = {}) {
+  const ai = getClient();
+  const model = options.model || DEFAULT_MODEL;
+  const duration = options.duration || DEFAULT_DURATION;
+  const aspectRatio = options.aspectRatio || "16:9";
+  const resolution = options.resolution || DEFAULT_RESOLUTION;
+
+  console.log(`   [Veo] Creating text2video task...`);
+  console.log(`   [Veo] Model: ${model}`);
+  console.log(
+    `   [Veo] Duration: ${duration}s, Aspect: ${aspectRatio}, Resolution: ${resolution}`,
+  );
+
+  const config = {
+    aspectRatio,
+    durationSeconds: parseInt(duration, 10),
+    resolution,
+  };
+
+  if (options.negativePrompt) {
+    config.negativePrompt = options.negativePrompt;
+  }
+
+  let operation = await ai.models.generateVideos({
+    model,
+    prompt,
+    config,
+  });
+
+  console.log(`   [Veo] Task submitted, polling for completion...`);
+  operation = await pollOperation(operation);
+
+  return operation;
+}
+
+/**
+ * Create an image-to-video generation task.
+ *
+ * @param {string} imagePathOrUrl - Local PNG path or URL
+ * @param {string} prompt - Motion description
+ * @param {object} options - Same as createText2Video
+ */
+export async function createImage2Video(imagePathOrUrl, prompt, options = {}) {
+  const ai = getClient();
+  const model = options.model || DEFAULT_MODEL;
+  const duration = options.duration || DEFAULT_DURATION;
+  const aspectRatio = options.aspectRatio || "16:9";
+  const resolution = options.resolution || DEFAULT_RESOLUTION;
+
+  let image;
+
+  if (
+    imagePathOrUrl.startsWith("http://") ||
+    imagePathOrUrl.startsWith("https://")
+  ) {
+    console.log(`   [Veo] Fetching source image from URL...`);
+    const response = await fetch(imagePathOrUrl);
+    const buffer = Buffer.from(await response.arrayBuffer());
+    image = { imageBytes: buffer.toString("base64"), mimeType: "image/png" };
+  } else {
+    const imageBuffer = await fs.readFile(imagePathOrUrl);
+    console.log(
+      `   [Veo] Read source image: ${imagePathOrUrl} (${Math.round(imageBuffer.length / 1024)} KB)`,
+    );
+    image = {
+      imageBytes: imageBuffer.toString("base64"),
+      mimeType: "image/png",
+    };
+  }
+
+  console.log(`   [Veo] Creating image2video task...`);
+  console.log(`   [Veo] Model: ${model}`);
+
+  const config = {
+    aspectRatio,
+    durationSeconds: parseInt(duration, 10),
+    resolution,
+  };
+
+  if (options.negativePrompt) {
+    config.negativePrompt = options.negativePrompt;
+  }
+
+  let operation = await ai.models.generateVideos({
+    model,
+    prompt: prompt || "",
+    image,
+    config,
+  });
+
+  console.log(`   [Veo] Task submitted, polling for completion...`);
+  operation = await pollOperation(operation);
+
+  return operation;
+}
+
+/**
+ * Download a video from a completed Veo operation.
+ */
+export async function downloadVideo(operation, outputPath) {
+  const ai = getClient();
+
+  const generatedVideos = operation.response?.generatedVideos;
+  if (!generatedVideos || generatedVideos.length === 0) {
+    throw new Error("Operation completed but no video was returned");
+  }
+
+  const video = generatedVideos[0].video;
+
+  console.log(`   [Veo] Downloading video to: ${outputPath}`);
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+
+  const maxRetries = 3;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      await ai.files.download({ file: video, downloadPath: outputPath });
+      break;
+    } catch (err) {
+      if (attempt === maxRetries) throw err;
+      console.log(
+        `   [Veo] Download attempt ${attempt} failed (${err.message}), retrying in 5s...`,
+      );
+      await new Promise((r) => setTimeout(r, 5000));
+    }
+  }
+
+  const stats = await fs.stat(outputPath);
+  console.log(`   [Veo] Downloaded: ${Math.round(stats.size / 1024)} KB`);
+}
+
+export default {
+  createText2Video,
+  createImage2Video,
+  downloadVideo,
+};