@conceptcraft/mindframes 0.1.4 → 0.1.5

package/dist/index.js

@@ -293,6 +293,12 @@ function progressBar(current, total, width = 30, showPercentage = true) {
   const bar = chalk.green("\u2588".repeat(filled)) + chalk.gray("\u2591".repeat(empty));
   return showPercentage ? `[${bar}] ${percentage}%` : `[${bar}]`;
 }
+function formatJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+function printJson(data) {
+  console.log(formatJson(data));
+}
 var init_output = __esm({
   "src/lib/output.ts"() {
     "use strict";
@@ -300,11 +306,19 @@ var init_output = __esm({
   }
 });
 
+// src/types/media.ts
+var init_media = __esm({
+  "src/types/media.ts"() {
+    "use strict";
+  }
+});
+
 // src/types/index.ts
 var EXIT_CODES;
 var init_types = __esm({
   "src/types/index.ts"() {
     "use strict";
+    init_media();
     EXIT_CODES = {
       SUCCESS: 0,
       GENERAL_ERROR: 1,
@@ -889,6 +903,123 @@ async function validateGeneration(mode, slideCount, teamId) {
   }
   return limits;
 }
+async function generateSpeech(ttsRequest) {
+  const apiUrl = getApiUrl();
+  if (!hasAuth()) {
+    throw new ApiError(
+      "Not authenticated. Run 'cc login' or set CC_SLIDES_API_KEY environment variable.",
+      401,
+      2
+    );
+  }
+  const authHeaders = await getAuthHeaders();
+  let response;
+  try {
+    response = await fetch(`${apiUrl}/api/cli/tts`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...authHeaders
+      },
+      body: JSON.stringify(ttsRequest)
+    });
+  } catch (error2) {
+    throw new ApiError(
+      `Network error: ${error2 instanceof Error ? error2.message : "Unknown error"}`,
+      0,
+      5
+    );
+  }
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "Unknown error");
+    let errorMessage;
+    try {
+      const errorJson = JSON.parse(errorText);
+      errorMessage = errorJson.error || errorJson.message || errorText;
+    } catch {
+      errorMessage = errorText;
+    }
+    throw new ApiError(errorMessage, response.status, response.status === 401 ? 2 : 1);
+  }
+  const audioData = Buffer.from(await response.arrayBuffer());
+  const duration = parseFloat(response.headers.get("X-Duration-Seconds") || "0");
+  const cost = parseFloat(response.headers.get("X-Cost-USD") || "0");
+  const provider = response.headers.get("X-Provider") || "unknown";
+  const format = response.headers.get("X-Audio-Format") || "mp3";
+  return {
+    audioData,
+    duration,
+    cost,
+    provider,
+    format
+  };
+}
+async function getVoices() {
+  return request("/api/cli/tts");
+}
+async function generateMusic(musicRequest) {
+  const response = await request("/api/cli/music", {
+    method: "POST",
+    body: musicRequest
+  });
+  if (!response.data) {
+    throw new ApiError(`Invalid API response: ${JSON.stringify(response)}`, 500, 1);
+  }
+  return {
+    requestId: response.data.id,
+    status: response.data.status,
+    audioUrl: response.data.audioUrl,
+    duration: response.data.duration,
+    cost: response.data.cost,
+    error: response.data.error
+  };
+}
+async function checkMusicStatus(requestId) {
+  const response = await request(
+    `/api/cli/music?requestId=${encodeURIComponent(requestId)}`
+  );
+  return {
+    requestId: response.data.id,
+    status: response.data.status,
+    audioUrl: response.data.audioUrl,
+    duration: response.data.duration,
+    cost: response.data.cost,
+    error: response.data.error
+  };
+}
+async function mixAudio(mixRequest) {
+  return request("/api/cli/mix", {
+    method: "POST",
+    body: mixRequest
+  });
+}
+async function checkMixStatus(requestId) {
+  return request(
+    `/api/cli/mix?requestId=${encodeURIComponent(requestId)}`
+  );
+}
+async function searchImages(searchRequest) {
+  return request("/api/cli/images/search", {
+    method: "POST",
+    body: searchRequest
+  });
+}
+async function searchVideos(searchRequest) {
+  return request("/api/cli/videos/search", {
+    method: "POST",
+    body: searchRequest
+  });
+}
+async function pollForCompletion(checkFn, maxAttempts = 60, intervalMs = 2e3) {
+  for (let i = 0; i < maxAttempts; i++) {
+    const result = await checkFn();
+    if (result.status === "completed" || result.status === "failed") {
+      return result;
+    }
+    await new Promise((resolve4) => setTimeout(resolve4, intervalMs));
+  }
+  throw new ApiError("Operation timed out", 408, 1);
+}
 var ApiError;
 var init_api = __esm({
   "src/lib/api.ts"() {
@@ -1054,6 +1185,20 @@ async function exchangeCodeForTokens(tokenEndpoint, code, codeVerifier, redirect
 }
 function startCallbackServer(port, expectedState) {
   return new Promise((resolve4, reject) => {
+    let timeoutId;
+    let settled = false;
+    const cleanup = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutId);
+      process.off("SIGINT", onCancel);
+      process.off("SIGTERM", onCancel);
+      server.close();
+    };
+    const onCancel = () => {
+      cleanup();
+      reject(new Error("Login cancelled"));
+    };
     const server = http.createServer((req, res) => {
       const url = new URL(req.url || "", `http://localhost:${port}`);
       if (url.pathname !== "/callback") {
@@ -1078,7 +1223,7 @@ function startCallbackServer(port, expectedState) {
           </body>
           </html>
         `);
-        server.close();
+        cleanup();
         reject(new Error(errorDescription || errorParam));
         return;
       }
@@ -1094,7 +1239,7 @@ function startCallbackServer(port, expectedState) {
           </body>
           </html>
         `);
-        server.close();
+        cleanup();
         reject(new Error("Missing authorization code or state"));
         return;
       }
@@ -1110,7 +1255,7 @@ function startCallbackServer(port, expectedState) {
           </body>
           </html>
         `);
-        server.close();
+        cleanup();
         reject(new Error("State mismatch"));
         return;
       }
@@ -1124,20 +1269,14 @@ function startCallbackServer(port, expectedState) {
         </body>
         </html>
       `);
-      server.close();
+      cleanup();
       resolve4({ code, state });
     });
     server.listen(port);
-    const cleanup = () => {
-      server.close();
-      reject(new Error("Login cancelled"));
-    };
-    process.once("SIGINT", cleanup);
-    process.once("SIGTERM", cleanup);
-    setTimeout(() => {
-      process.off("SIGINT", cleanup);
-      process.off("SIGTERM", cleanup);
-      server.close();
+    process.once("SIGINT", onCancel);
+    process.once("SIGTERM", onCancel);
+    timeoutId = setTimeout(() => {
+      cleanup();
       reject(new Error("Login timed out - no callback received within 5 minutes"));
     }, 5 * 60 * 1e3);
   });
@@ -1238,6 +1377,7 @@ var init_login = __esm({
       }
       try {
         await runLoginFlow(options);
+        process.exit(0);
       } catch {
         process.exit(1);
       }
@@ -1246,7 +1386,7 @@ var init_login = __esm({
 });
 
 // src/index.ts
-import { Command as Command15 } from "commander";
+import { Command as Command20 } from "commander";
 import chalk13 from "chalk";
 
 // src/lib/brand.ts
@@ -3295,9 +3435,687 @@ function installSkill(skillPath, content, force) {
   writeFileSync(skillFile, content, "utf-8");
 }
 
+// src/commands/tts.ts
+init_api();
+init_output();
+init_types();
+import { Command as Command15 } from "commander";
+import ora8 from "ora";
+import { writeFile as writeFile2 } from "fs/promises";
+var generateCommand = new Command15("generate").description("Generate speech from text").requiredOption("-t, --text <text>", "Text to convert to speech").requiredOption("-o, --output <path>", "Output file path").option("-v, --voice <voice>", "Voice name or ID (e.g., Kore, Rachel, alloy)").option("-p, --provider <provider>", "Provider: gemini, elevenlabs, openai").option("-m, --model <model>", "Model (provider-specific)").option("-s, --speed <speed>", "Speech speed 0.25-4.0 (default: 1.0)").option("-f, --format <format>", "Output format: human, json, quiet", "human").action(async (options) => {
+  const format = options.format;
+  const spinner = format === "human" ? ora8("Generating speech...").start() : null;
+  let speed;
+  if (options.speed) {
+    speed = parseFloat(options.speed);
+    if (isNaN(speed) || speed < 0.25 || speed > 4) {
+      spinner?.stop();
+      error("Speed must be between 0.25 and 4.0");
+      process.exit(EXIT_CODES.INVALID_INPUT);
+    }
+  }
+  try {
+    const result = await generateSpeech({
+      text: options.text,
+      options: {
+        provider: options.provider,
+        voice: options.voice,
+        model: options.model,
+        speed
+      }
+    });
+    spinner?.stop();
+    const outputPath = options.output.endsWith(`.${result.format}`) ? options.output : `${options.output}.${result.format}`;
+    await writeFile2(outputPath, result.audioData);
+    if (format === "json") {
+      printJson({
+        status: "completed",
+        output: outputPath,
+        duration: result.duration,
+        cost: result.cost,
+        provider: result.provider,
+        format: result.format
+      });
+      return;
+    }
+    if (format === "quiet") {
+      console.log(outputPath);
+      return;
+    }
+    success(`Saved to: ${outputPath}`);
+    info(`Duration: ${result.duration.toFixed(2)}s`);
+    info(`Provider: ${result.provider}`);
+    info(`Cost: $${result.cost.toFixed(6)}`);
+  } catch (err) {
+    spinner?.stop();
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(EXIT_CODES.GENERAL_ERROR);
+  }
+});
+var voicesCommand = new Command15("voices").description("List available voices").option("-p, --provider <provider>", "Filter by provider: gemini, elevenlabs, openai").option("-f, --format <format>", "Output format: human, json", "human").action(async (options) => {
+  const spinner = options.format === "human" ? ora8("Fetching voices...").start() : null;
+  try {
+    const result = await getVoices();
+    spinner?.stop();
+    if (options.format === "json") {
+      if (options.provider) {
+        const providerVoices = result.voices[options.provider];
+        printJson(providerVoices || []);
+      } else {
+        printJson(result.voices);
+      }
+      return;
+    }
+    const providers = options.provider ? [options.provider] : ["gemini", "elevenlabs", "openai"];
+    for (const provider of providers) {
+      const voices = result.voices[provider];
+      if (!voices || voices.length === 0) continue;
+      console.log();
+      console.log(`${provider.toUpperCase()} Voices:`);
+      console.log("-".repeat(50));
+      for (const voice of voices) {
+        console.log(`  ${voice.name} (${voice.id})`);
+        console.log(`    ${voice.description}`);
+      }
+    }
+  } catch (err) {
+    spinner?.stop();
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(EXIT_CODES.GENERAL_ERROR);
+  }
+});
+var ttsCommand = new Command15("tts").description("Text-to-speech commands").addCommand(generateCommand).addCommand(voicesCommand);
+
+// src/commands/music.ts
+init_api();
+init_output();
+init_types();
+import { Command as Command16 } from "commander";
+import ora9 from "ora";
+import { writeFile as writeFile3 } from "fs/promises";
+function outputResult(result, format) {
+  if (format === "json") {
+    printJson(result);
+    return;
+  }
+  if (format === "quiet") {
+    if (result.audioUrl) {
+      console.log(result.audioUrl);
+    } else {
+      console.log(result.requestId);
+    }
+    return;
+  }
+  info(`Request ID: ${result.requestId}`);
+  info(`Status: ${result.status}`);
+  if (result.duration) {
+    info(`Duration: ${result.duration}s`);
+  }
+  if (result.audioUrl) {
+    success(`Audio URL: ${result.audioUrl}`);
+  }
+  if (result.cost !== void 0) {
+    info(`Cost: $${result.cost.toFixed(4)}`);
+  }
+  if (result.error) {
+    error(`Error: ${result.error}`);
+  }
+}
+async function downloadFile(url, outputPath) {
+  if (url.startsWith("data:")) {
+    const matches = url.match(/^data:[^;]+;base64,(.+)$/);
+    if (!matches) {
+      throw new Error("Invalid data URL format");
+    }
+    const buffer2 = Buffer.from(matches[1], "base64");
+    await writeFile3(outputPath, buffer2);
+    return;
+  }
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download: ${response.status}`);
+  }
+  const buffer = await response.arrayBuffer();
+  await writeFile3(outputPath, Buffer.from(buffer));
+}
+var generateCommand2 = new Command16("generate").description("Generate music from a text prompt").requiredOption("-p, --prompt <text>", "Music description").option("-d, --duration <seconds>", "Duration in seconds (3-30)", "30").option("-s, --style <style>", "Style preset").option("--provider <provider>", "Provider (elevenlabs, suno)").option("-o, --output <path>", "Output file path").option("--no-wait", "Do not wait for completion").option("-f, --format <format>", "Output format: human, json, quiet", "human").action(async (options) => {
+  const duration = parseInt(options.duration, 10);
+  if (isNaN(duration) || duration < 3 || duration > 30) {
+    error("Duration must be between 3 and 30 seconds");
+    process.exit(EXIT_CODES.INVALID_INPUT);
+  }
+  const format = options.format;
+  const spinner = format === "human" ? ora9("Generating music...").start() : null;
+  try {
+    const result = await generateMusic({
+      prompt: options.prompt,
+      duration,
+      options: {
+        provider: options.provider,
+        style: options.style
+      }
+    });
+    if (!options.wait) {
+      spinner?.stop();
+      outputResult(result, format);
+      return;
+    }
+    let finalResult = result;
+    if (result.status !== "completed" && result.status !== "failed") {
+      if (spinner) spinner.text = `Processing (ID: ${result.requestId})...`;
+      finalResult = await pollForCompletion(
+        () => checkMusicStatus(result.requestId),
+        60,
+        2e3
+      );
+    }
+    spinner?.stop();
+    if (finalResult.status === "failed") {
+      error(finalResult.error || "Music generation failed");
+      process.exit(EXIT_CODES.GENERAL_ERROR);
+    }
+    outputResult(finalResult, format);
+    if (options.output && finalResult.audioUrl) {
+      const downloadSpinner = format === "human" ? ora9("Downloading...").start() : null;
+      try {
+        await downloadFile(finalResult.audioUrl, options.output);
+        downloadSpinner?.stop();
+        if (format === "human") {
+          success(`Saved to: ${options.output}`);
+        }
+      } catch (err) {
+        downloadSpinner?.stop();
+        warn(`Failed to download: ${err instanceof Error ? err.message : "Unknown error"}`);
+      }
+    }
+  } catch (err) {
+    spinner?.stop();
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(EXIT_CODES.GENERAL_ERROR);
+  }
+});
+var statusCommand = new Command16("status").description("Check status of a music generation request").argument("<id>", "Request ID").option("-f, --format <format>", "Output format: human, json, quiet", "human").action(async (id, options) => {
+  const spinner = options.format === "human" ? ora9("Checking status...").start() : null;
+  try {
+    const result = await checkMusicStatus(id);
+    spinner?.stop();
+    outputResult(result, options.format);
+  } catch (err) {
+    spinner?.stop();
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(EXIT_CODES.GENERAL_ERROR);
+  }
+});
+var musicCommand = new Command16("music").description("Music generation commands").addCommand(generateCommand2).addCommand(statusCommand);
+
+// src/commands/mix.ts
+init_api();
+init_output();
+init_types();
+import { Command as Command17 } from "commander";
+import ora10 from "ora";
+import { writeFile as writeFile4 } from "fs/promises";
+function outputResult2(result, format) {
+  if (format === "json") {
+    printJson(result);
+    return;
+  }
+  if (format === "quiet") {
+    if (result.outputUrl) {
+      console.log(result.outputUrl);
+    } else {
+      console.log(result.requestId);
+    }
+    return;
+  }
+  info(`Request ID: ${result.requestId}`);
+  info(`Status: ${result.status}`);
+  if (result.duration) {
+    info(`Duration: ${result.duration}s`);
+  }
+  if (result.outputUrl) {
+    success(`Output URL: ${result.outputUrl}`);
+  }
+  if (result.cost !== void 0) {
+    info(`Cost: $${result.cost.toFixed(4)}`);
+  }
+  if (result.error) {
+    error(`Error: ${result.error}`);
+  }
+}
+async function downloadFile2(url, outputPath) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download: ${response.status}`);
+  }
+  const buffer = await response.arrayBuffer();
+  await writeFile4(outputPath, Buffer.from(buffer));
+}
+var mixCommand = new Command17("create").description("Mix audio tracks into a video").requiredOption("--video <url>", "Input video file/URL").option("--music <url>", "Background music file/URL").option("--voice <url>", "Voiceover file/URL").option("--music-volume <percent>", "Music volume 0-100", "50").option("--voice-volume <percent>", "Voice volume 0-100", "100").option("-o, --output <path>", "Output file path").option("--no-wait", "Do not wait for completion").option("-f, --format <format>", "Output format: human, json, quiet", "human").action(async (options) => {
+  if (!options.music && !options.voice) {
+    error("At least one of --music or --voice must be provided");
+    process.exit(EXIT_CODES.INVALID_INPUT);
+  }
+  const musicVolume = parseInt(options.musicVolume, 10) / 100;
+  const voiceVolume = parseInt(options.voiceVolume, 10) / 100;
+  if (isNaN(musicVolume) || musicVolume < 0 || musicVolume > 1) {
+    error("Music volume must be between 0 and 100");
+    process.exit(EXIT_CODES.INVALID_INPUT);
+  }
+  if (isNaN(voiceVolume) || voiceVolume < 0 || voiceVolume > 2) {
+    error("Voice volume must be between 0 and 200");
+    process.exit(EXIT_CODES.INVALID_INPUT);
+  }
+  const format = options.format;
+  const spinner = format === "human" ? ora10("Mixing audio...").start() : null;
+  const inputs = [{ url: options.video, role: "video" }];
+  if (options.music) {
+    inputs.push({ url: options.music, role: "background", volume: musicVolume * 5 });
+  }
+  if (options.voice) {
+    inputs.push({ url: options.voice, role: "voice", volume: voiceVolume * 2 });
+  }
+  try {
+    const result = await mixAudio({
+      operation: "add-to-video",
+      inputs,
+      options: {
+        musicVolume,
+        voiceVolume
+      }
+    });
+    if (!options.wait) {
+      spinner?.stop();
+      outputResult2(result, format);
+      return;
+    }
+    if (spinner) spinner.text = `Processing (ID: ${result.requestId})...`;
+    const finalResult = await pollForCompletion(
+      () => checkMixStatus(result.requestId),
+      120,
+      3e3
+    );
+    spinner?.stop();
+    if (finalResult.status === "failed") {
+      error(finalResult.error || "Audio mixing failed");
+      process.exit(EXIT_CODES.GENERAL_ERROR);
+    }
+    outputResult2(finalResult, format);
+    if (options.output && finalResult.outputUrl) {
+      const downloadSpinner = format === "human" ? ora10("Downloading...").start() : null;
+      try {
+        await downloadFile2(finalResult.outputUrl, options.output);
+        downloadSpinner?.stop();
+        if (format === "human") {
+          success(`Saved to: ${options.output}`);
+        }
+      } catch (err) {
+        downloadSpinner?.stop();
+        warn(`Failed to download: ${err instanceof Error ? err.message : "Unknown error"}`);
+      }
+    }
+  } catch (err) {
+    spinner?.stop();
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(EXIT_CODES.GENERAL_ERROR);
+  }
+});
+var statusCommand2 = new Command17("status").description("Check status of an audio mix request").argument("<id>", "Request ID").option("-f, --format <format>", "Output format: human, json, quiet", "human").action(async (id, options) => {
+  const spinner = options.format === "human" ? ora10("Checking status...").start() : null;
+  try {
+    const result = await checkMixStatus(id);
+    spinner?.stop();
+    outputResult2(result, options.format);
+  } catch (err) {
+    spinner?.stop();
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(EXIT_CODES.GENERAL_ERROR);
+  }
+});
+var mixAudioCommand = new Command17("mix").description("Audio mixing commands").addCommand(mixCommand).addCommand(statusCommand2);
+
+// src/commands/image.ts
+init_api();
+init_output();
+init_types();
+import { Command as Command18 } from "commander";
+import ora11 from "ora";
+var searchCommand = new Command18("search").description("Search for images").requiredOption("-q, --query <query>", "Search query").option("-n, --max-results <number>", "Maximum number of results (default: 10)").option("-s, --size <size>", "Image size: small, medium, large, any", "large").option("--safe-search", "Enable safe search (default: true)", true).option("--no-safe-search", "Disable safe search").option("-f, --format <format>", "Output format: human, json, quiet", "human").action(async (options) => {
+  const format = options.format;
+  const spinner = format === "human" ? ora11("Searching for images...").start() : null;
+  let maxResults;
+  if (options.maxResults) {
+    maxResults = parseInt(options.maxResults, 10);
+    if (isNaN(maxResults) || maxResults < 1) {
+      spinner?.stop();
+      error("Max results must be a positive number");
+      process.exit(EXIT_CODES.INVALID_INPUT);
+    }
+  }
+  try {
+    const result = await searchImages({
+      query: options.query,
+      options: {
+        maxResults: maxResults || 10,
+        size: options.size,
+        safeSearch: options.safeSearch
+      }
+    });
+    spinner?.stop();
+    if (!result.success) {
+      error("Search failed");
+      process.exit(EXIT_CODES.GENERAL_ERROR);
+    }
+    const allImages = result.data.results.flatMap(
+      (providerResult) => providerResult.results.map((img) => ({
+        ...img,
+        provider: providerResult.providerName
+      }))
+    );
+    if (format === "json") {
+      printJson({
+        success: true,
+        query: options.query,
+        totalResults: allImages.length,
+        totalCost: result.data.totalCost,
+        images: allImages
+      });
+      return;
+    }
+    if (format === "quiet") {
+      for (const img of allImages) {
+        console.log(img.url);
+      }
+      return;
+    }
+    if (allImages.length === 0) {
+      info("No images found");
+      return;
+    }
+    success(`Found ${allImages.length} images for "${options.query}"`);
+    console.log();
+    for (let i = 0; i < allImages.length; i++) {
+      const img = allImages[i];
+      console.log(`[${i + 1}] ${img.title || "Untitled"}`);
+      console.log(`    URL: ${img.url}`);
+      console.log(`    Size: ${img.width}x${img.height}`);
+      if (img.author) {
+        console.log(`    Author: ${img.author}`);
+      }
+      console.log(`    Provider: ${img.provider}`);
+      console.log();
+    }
+    info(`Total cost: $${result.data.totalCost.toFixed(4)}`);
+  } catch (err) {
+    spinner?.stop();
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(EXIT_CODES.GENERAL_ERROR);
+  }
+});
+var imageCommand = new Command18("image").description("Image search commands").addCommand(searchCommand);
+
+// src/commands/video.ts
+init_api();
+init_output();
+init_types();
+import { Command as Command19 } from "commander";
+import ora12 from "ora";
+import { mkdir, writeFile as writeFile5, readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+async function downloadFile3(url, outputPath) {
+  if (url.startsWith("data:")) {
+    const matches = url.match(/^data:[^;]+;base64,(.+)$/);
+    if (!matches) {
+      throw new Error("Invalid data URL format");
+    }
+    const buffer2 = Buffer.from(matches[1], "base64");
+    await writeFile5(outputPath, buffer2);
+    return;
+  }
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download: ${response.status}`);
+  }
+  const buffer = await response.arrayBuffer();
+  await writeFile5(outputPath, Buffer.from(buffer));
+}
+function getExtension(url) {
+  try {
+    const urlObj = new URL(url);
+    const pathname = urlObj.pathname;
+    const ext = pathname.split(".").pop()?.toLowerCase();
+    if (ext && ["jpg", "jpeg", "png", "gif", "webp"].includes(ext)) {
+      return ext;
+    }
+  } catch {
+  }
+  return "jpg";
+}
+var createCommand2 = new Command19("create").description("Create video assets (voiceover, music, images)").option("-s, --script <text>", "Narration script text").option("--script-file <path>", "Path to script file").option("-t, --topic <text>", "Topic for image search (inferred from script if not provided)").option("-d, --duration <seconds>", "Target duration (auto-calculated from script if not set)").option("-v, --voice <name>", "TTS voice (Kore, Puck, Rachel, alloy)", "Kore").option("-m, --music-prompt <text>", "Music description (auto-generated if not provided)").option("-n, --num-images <number>", "Number of images to search/download", "5").option("-o, --output <dir>", "Output directory", "./public").option("-f, --format <format>", "Output format: human, json, quiet", "human").action(async (options) => {
+  const format = options.format;
+  const spinner = format === "human" ? ora12("Initializing...").start() : null;
+  try {
+    let script = options.script;
+    if (options.scriptFile) {
+      try {
+        script = await readFile2(options.scriptFile, "utf-8");
+      } catch (err) {
+        spinner?.stop();
+        error(`Failed to read script file: ${err instanceof Error ? err.message : "Unknown error"}`);
+        process.exit(EXIT_CODES.INVALID_INPUT);
+      }
+    }
+    if (!script || script.trim().length === 0) {
+      spinner?.stop();
+      error("Either --script or --script-file is required");
+      process.exit(EXIT_CODES.INVALID_INPUT);
+    }
+    script = script.trim();
+    const topic = options.topic || script.split(".")[0].slice(0, 50);
+    const numImages = parseInt(options.numImages, 10);
+    if (isNaN(numImages) || numImages < 1 || numImages > 20) {
+      spinner?.stop();
+      error("Number of images must be between 1 and 20");
+      process.exit(EXIT_CODES.INVALID_INPUT);
+    }
+    const audioDir = join2(options.output, "audio");
+    const imagesDir = join2(options.output, "images");
+    if (spinner) spinner.text = "Creating directories...";
+    await mkdir(audioDir, { recursive: true });
+    await mkdir(imagesDir, { recursive: true });
+    let totalCost = 0;
+    if (spinner) spinner.text = "Generating voiceover...";
+    const ttsResult = await generateSpeech({
+      text: script,
+      options: { voice: options.voice }
+    });
+    const voiceoverPath = join2(audioDir, `voiceover.${ttsResult.format}`);
+    await writeFile5(voiceoverPath, ttsResult.audioData);
+    totalCost += ttsResult.cost;
+    const voiceoverInfo = {
+      path: `audio/voiceover.${ttsResult.format}`,
+      duration: ttsResult.duration,
+      voice: options.voice,
+      provider: ttsResult.provider,
+      cost: ttsResult.cost
+    };
+    if (format === "human") {
+      spinner?.stop();
+      success(`Voiceover: ${voiceoverPath} (${ttsResult.duration.toFixed(1)}s)`);
+      spinner?.start();
+    }
+    const musicDuration = Math.min(30, Math.ceil(ttsResult.duration) + 5);
+    const musicPrompt = options.musicPrompt || "uplifting background music, positive energy";
+    if (spinner) spinner.text = "Generating music...";
+    let musicResult = await generateMusic({
+      prompt: musicPrompt,
+      duration: musicDuration
+    });
+    if (musicResult.status !== "completed" && musicResult.status !== "failed") {
+      if (spinner) spinner.text = `Processing music (ID: ${musicResult.requestId})...`;
+      musicResult = await pollForCompletion(
+        () => checkMusicStatus(musicResult.requestId),
+        60,
+        2e3
+      );
+    }
+    if (musicResult.status === "failed") {
+      spinner?.stop();
+      error(`Music generation failed: ${musicResult.error || "Unknown error"}`);
+      process.exit(EXIT_CODES.GENERAL_ERROR);
+    }
+    const musicPath = join2(audioDir, "music.mp3");
+    if (musicResult.audioUrl) {
+      await downloadFile3(musicResult.audioUrl, musicPath);
+    }
+    totalCost += musicResult.cost || 0;
+    const musicInfo = {
+      path: "audio/music.mp3",
+      duration: musicResult.duration || musicDuration,
+      prompt: musicPrompt,
+      cost: musicResult.cost || 0
+    };
+    if (format === "human") {
+      spinner?.stop();
+      success(`Music: ${musicPath} (${musicInfo.duration}s)`);
+      spinner?.start();
+    }
+    if (spinner) spinner.text = "Searching for images...";
+    const imageResults = await searchImages({
+      query: topic,
+      options: {
+        maxResults: numImages,
+        size: "large",
+        safeSearch: true
+      }
+    });
+    const allImages = imageResults.data.results.flatMap(
+      (providerResult) => providerResult.results.map((img) => ({
+        ...img,
+        provider: providerResult.providerName
+      }))
+    );
+    totalCost += imageResults.data.totalCost;
+    const downloadedImages = [];
+    for (let i = 0; i < Math.min(allImages.length, numImages); i++) {
+      const img = allImages[i];
+      const ext = getExtension(img.url);
+      const filename = `scene-${i + 1}.${ext}`;
+      const imagePath = join2(imagesDir, filename);
+      if (spinner) spinner.text = `Downloading image ${i + 1}/${Math.min(allImages.length, numImages)}...`;
+      try {
+        await downloadFile3(img.url, imagePath);
+        downloadedImages.push({
+          path: `images/${filename}`,
+          url: img.url,
+          width: img.width,
+          height: img.height,
+          query: topic
+        });
+      } catch (err) {
+        if (format === "human") {
+          spinner?.stop();
+          warn(`Failed to download image ${i + 1}: ${err instanceof Error ? err.message : "Unknown error"}`);
+          spinner?.start();
+        }
+      }
+    }
+    if (format === "human") {
+      spinner?.stop();
+      success(`Images: Downloaded ${downloadedImages.length} images to ${imagesDir}`);
+      spinner?.start();
+    }
+    if (spinner) spinner.text = "Writing manifest...";
+    const manifest = {
+      topic,
+      script,
+      voiceover: voiceoverInfo,
+      music: musicInfo,
+      images: downloadedImages,
+      totalCost,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const manifestPath = join2(options.output, "video-manifest.json");
+    await writeFile5(manifestPath, JSON.stringify(manifest, null, 2));
+    spinner?.stop();
+    if (format === "json") {
+      printJson(manifest);
+      return;
+    }
+    if (format === "quiet") {
+      console.log(manifestPath);
+      return;
+    }
+    console.log();
+    success("Video assets created successfully!");
+    console.log();
+    info(`Topic: ${topic}`);
+    info(`Voiceover: ${voiceoverInfo.path} (${voiceoverInfo.duration.toFixed(1)}s, ${voiceoverInfo.voice})`);
+    info(`Music: ${musicInfo.path} (${musicInfo.duration}s)`);
+    info(`Images: ${downloadedImages.length} downloaded`);
+    info(`Manifest: ${manifestPath}`);
+    console.log();
+    info(`Total cost: $${totalCost.toFixed(4)}`);
+    console.log();
+    info("Next steps:");
+    info("  1. Create Remotion project (see remotion-best-practices skill)");
+    info("  2. Use manifest data to configure video composition");
+    info("  3. Run: npm start (preview) / npm run render (build)");
+  } catch (err) {
+    spinner?.stop();
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(EXIT_CODES.GENERAL_ERROR);
+  }
+});
+var searchCommand2 = new Command19("search").description("Search for stock videos").argument("<query>", "Search query").option("-n, --max-results <count>", "Maximum number of results", "10").option("-o, --orientation <type>", "Video orientation: landscape, portrait, square, any", "any").option("-l, --license <type>", "License type: free, premium, any", "any").option("-f, --format <format>", "Output format: human, json, quiet", "human").action(async (query, options) => {
+  const { maxResults, orientation, license, format } = options;
+  const spinner = format === "human" ? ora12("Searching for videos...").start() : null;
+  try {
+    const result = await searchVideos({
+      query,
+      options: {
+        maxResults: parseInt(maxResults, 10),
+        orientation,
+        license
+      }
+    });
+    spinner?.stop();
+    const allVideos = result.data.results.flatMap((provider) => provider.results);
+    if (format === "json") {
+      printJson(result);
+      return;
+    }
+    if (format === "quiet") {
+      allVideos.forEach((video) => {
+        console.log(video.previewUrl || video.thumbnailUrl);
+      });
+      return;
+    }
+    if (allVideos.length === 0) {
+      info("No videos found");
+      return;
+    }
+    success(`Found ${allVideos.length} videos for "${query}"`);
+    console.log();
+    allVideos.forEach((video, index) => {
+      console.log(`[${index + 1}] ${video.title}`);
+      console.log(`    URL: ${video.previewUrl || video.thumbnailUrl}`);
+      console.log(`    Duration: ${video.duration}s | Size: ${video.width}x${video.height}`);
+      console.log(`    Provider: ${video.provider}`);
+      console.log();
+    });
+    info(`Total cost: $${result.data.totalCost.toFixed(4)}`);
+  } catch (err) {
+    spinner?.stop();
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(EXIT_CODES.GENERAL_ERROR);
+  }
+});
+var videoCommand = new Command19("video").description("Video asset generation commands").addCommand(createCommand2).addCommand(searchCommand2);
+
 // src/index.ts
-var VERSION = "0.1.4";
-var program = new Command15();
+var VERSION = "0.1.5";
+var program = new Command20();
 var cmdName = brand.commands[0];
 program.name(cmdName).description(brand.description).version(VERSION, "-v, --version", "Show version number").option("--debug", "Enable debug logging").option("--no-color", "Disable colored output").configureOutput({
   outputError: (str, write) => {
@@ -3317,6 +4135,11 @@ program.addCommand(brandingCommand);
 program.addCommand(ideasCommand);
 program.addCommand(whoamiCommand);
 program.addCommand(skillCommand);
+program.addCommand(ttsCommand);
+program.addCommand(musicCommand);
+program.addCommand(mixAudioCommand);
+program.addCommand(imageCommand);
+program.addCommand(videoCommand);
 var deriveCommand = buildDeriveCommand();
 if (deriveCommand.commands.length > 0) {
   program.addCommand(deriveCommand);