feedeas 0.1.0-alpha.17 → 0.1.0-alpha.19

package/dist/cli/index.js

@@ -93,75 +93,141 @@ import { Command } from "commander";
 import { chromium } from "playwright-core";
 import { spawn as spawn4, spawnSync } from "child_process";
 import fs8 from "fs";
-import path8 from "path";
+import path9 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/cli/services/ffprobe.ts
-import { spawn } from "child_process";
 import fs from "fs";
+import path from "path";
+function isNodeRuntime() {
+  return typeof process !== "undefined" && !!process.versions?.node;
+}
+function isImageExt(ext) {
+  return [".jpg", ".jpeg", ".png", ".webp", ".gif"].includes(ext);
+}
+function isAudioExt(ext) {
+  return [".mp3", ".wav", ".m4a", ".ogg"].includes(ext);
+}
+async function getAudioMetadataFallback(filePath) {
+  const musicMetadata = await import("music-metadata");
+  const metadata = await musicMetadata.parseFile(filePath);
+  return {
+    duration: metadata.format.duration,
+    sampleRate: metadata.format.sampleRate,
+    channels: metadata.format.numberOfChannels,
+    codec: metadata.format.codec,
+    bitrate: metadata.format.bitrate ?? void 0
+  };
+}
+async function getImageDimensionsFallback(filePath) {
+  const imageSize = await import("image-size");
+  const buffer = fs.readFileSync(filePath);
+  const dimensions = imageSize.default(buffer);
+  return { width: dimensions.width ?? void 0, height: dimensions.height ?? void 0 };
+}
 var FFprobeService = class {
   static async getMetadata(filePath) {
     if (!fs.existsSync(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
-    return new Promise((resolve, reject) => {
-      const ffprobe = spawn("ffprobe", [
-        "-v",
-        "quiet",
-        "-print_format",
-        "json",
-        "-show_format",
-        "-show_streams",
-        filePath
-      ]);
-      let stdout = "";
-      let stderr = "";
-      ffprobe.stdout.on("data", (data) => {
-        stdout += data;
-      });
-      ffprobe.stderr.on("data", (data) => {
-        stderr += data;
-      });
-      ffprobe.on("close", (code) => {
-        if (code !== 0) {
-          reject(new Error(`ffprobe exited with code ${code}: ${stderr}`));
-          return;
-        }
-        try {
-          const data = JSON.parse(stdout);
-          const format = data.format || {};
-          const streams = data.streams || [];
-          const videoStream = streams.find((s) => s.codec_type === "video");
-          const audioStream = streams.find((s) => s.codec_type === "audio");
-          const metadata = {
-            path: filePath,
-            format: format.format_name || "unknown",
-            duration: parseFloat(format.duration || "0"),
-            size: parseInt(format.size || "0")
-          };
-          if (videoStream) {
-            metadata.width = videoStream.width;
-            metadata.height = videoStream.height;
-          }
-          if (audioStream) {
-            metadata.audioChannels = audioStream.channels;
-            metadata.sampleRate = parseInt(audioStream.sample_rate || "0");
-          }
-          resolve(metadata);
-        } catch (err) {
-          reject(new Error(`Failed to parse ffprobe output: ${err}`));
+    const ext = path.extname(filePath).toLowerCase();
+    const stats = fs.statSync(filePath);
+    if (isNodeRuntime()) {
+      try {
+        const { spawn: spawn5 } = await import("node:child_process");
+        return await new Promise((resolve, reject) => {
+          const ffprobe = spawn5("ffprobe", [
+            "-v",
+            "quiet",
+            "-print_format",
+            "json",
+            "-show_format",
+            "-show_streams",
+            filePath
+          ]);
+          let stdout = "";
+          let stderr = "";
+          ffprobe.stdout.on("data", (data) => {
+            stdout += data;
+          });
+          ffprobe.stderr.on("data", (data) => {
+            stderr += data;
+          });
+          ffprobe.on("close", (code) => {
+            if (code !== 0) {
+              reject(new Error(`ffprobe exited with code ${code}: ${stderr}`));
+              return;
+            }
+            try {
+              const data = JSON.parse(stdout);
+              const format = data.format || {};
+              const streams = data.streams || [];
+              const videoStream = streams.find((s) => s.codec_type === "video");
+              const audioStream = streams.find((s) => s.codec_type === "audio");
+              const metadata = {
+                path: filePath,
+                format: format.format_name || "unknown",
+                duration: parseFloat(format.duration || "0"),
+                size: parseInt(format.size || "0")
+              };
+              if (videoStream) {
+                metadata.width = videoStream.width;
+                metadata.height = videoStream.height;
+              }
+              if (audioStream) {
+                metadata.audioChannels = audioStream.channels;
+                metadata.sampleRate = parseInt(audioStream.sample_rate || "0");
+                metadata.audioCodec = audioStream.codec_name || void 0;
+              }
+              if (format?.bit_rate) {
+                metadata.bitrate = parseInt(format.bit_rate || "0");
+              }
+              resolve(metadata);
+            } catch (err) {
+              reject(new Error(`Failed to parse ffprobe output: ${err}`));
+            }
+          });
+          ffprobe.on("error", (err) => {
+            reject(new Error(`Failed to spawn ffprobe: ${err.message}`));
+          });
+        });
+      } catch (err) {
+        if (err?.code !== "ENOENT") {
+          throw err;
         }
-      });
-      ffprobe.on("error", (err) => {
-        reject(new Error(`Failed to spawn ffprobe: ${err.message}`));
-      });
-    });
+      }
+    }
+    if (isImageExt(ext)) {
+      const dims = await getImageDimensionsFallback(filePath);
+      return {
+        path: filePath,
+        format: ext.replace(".", "") || "image",
+        duration: 0,
+        size: stats.size,
+        width: dims.width,
+        height: dims.height
+      };
+    }
+    if (isAudioExt(ext)) {
+      const audio = await getAudioMetadataFallback(filePath);
+      return {
+        path: filePath,
+        format: ext.replace(".", "") || "audio",
+        duration: audio.duration || 0,
+        size: stats.size,
+        audioChannels: audio.channels,
+        sampleRate: audio.sampleRate,
+        audioCodec: audio.codec,
+        bitrate: audio.bitrate
+      };
+    }
+    throw new Error("ffprobe is required to inspect this file type.");
   }
 };
 
 // src/cli/services/assets/resolver.ts
 import fs2 from "node:fs";
-import path from "node:path";
+import path2 from "node:path";
 function looksLikeScheme(uri) {
   return /^[a-z][a-z0-9+.-]*:/.test(uri);
 }
@@ -177,7 +243,7 @@ var RelativeFsResolver = class {
       const localPath2 = decodeURIComponent(new URL(uri).pathname);
       return { type: "local", uri, localPath: localPath2 };
     }
-    const localPath = path.isAbsolute(uri) ? uri : path.resolve(rootPath, uri);
+    const localPath = path2.isAbsolute(uri) ? uri : path2.resolve(rootPath, uri);
     return { type: "local", uri, localPath };
   }
 };
@@ -337,24 +403,24 @@ import { existsSync } from "node:fs";
 
 // src/cli/server/cli-runner.ts
 import { spawn as spawn2 } from "child_process";
-import path2 from "path";
+import path3 from "path";
 import fs3 from "fs";
 import { fileURLToPath } from "url";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path2.dirname(__filename);
+var __dirname = path3.dirname(__filename);
 async function runCliCommand(args, cwd) {
   const isCompiled = __filename.endsWith(".js");
   let command;
   let spawnArgs;
   if (isCompiled) {
-    const binPath = path2.resolve(__dirname, "../../../bin/feedeas.js");
+    const binPath = path3.resolve(__dirname, "../../../bin/feedeas.js");
     if (!fs3.existsSync(binPath)) {
       throw new Error(`Could not find compiled CLI binary at ${binPath}`);
     }
     command = "node";
     spawnArgs = [binPath, ...args];
   } else {
-    const srcPath = path2.resolve(__dirname, "../index.ts");
+    const srcPath = path3.resolve(__dirname, "../index.ts");
     command = "bun";
     spawnArgs = ["run", srcPath, ...args];
   }
@@ -420,7 +486,7 @@ ${stderrData || stdoutData}`));
 }
 
 // src/cli/services/taste.ts
-import path3 from "node:path";
+import path4 from "node:path";
 var SAMPLE_SCENE_HEADER = "## Sample Scene (Starter)";
 var DEFAULT_SAMPLE_SCENE_JSON = {
   meta: {
@@ -550,12 +616,12 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
 ]);
 function safeResolveFromCwd(relativePath) {
   const cwd = process.cwd();
-  const normalized = path3.normalize(relativePath);
+  const normalized = path4.normalize(relativePath);
   if (normalized.includes("..")) {
     throw new Error("Invalid path");
   }
-  const fullPath = path3.resolve(cwd, normalized);
-  if (fullPath !== cwd && !fullPath.startsWith(`${cwd}${path3.sep}`)) {
+  const fullPath = path4.resolve(cwd, normalized);
+  if (fullPath !== cwd && !fullPath.startsWith(`${cwd}${path4.sep}`)) {
     throw new Error("Invalid path");
   }
   return fullPath;
@@ -1366,7 +1432,7 @@ async function simulateIdeas(params) {
 
 // src/cli/services/taste-store.ts
 import fs4 from "node:fs";
-import path4 from "node:path";
+import path5 from "node:path";
 import { createHash } from "node:crypto";
 var DEFAULT_SUGGESTIONS_FILE_CONTENT = "# Taste Suggestions v1\n";
 function hashContent(content) {
@@ -1489,9 +1555,9 @@ var MarkdownTasteStore = class {
   }
   async ensureWorkspace() {
     const { tastePath, memoryPath, suggestionsPath } = this.resolveAll();
-    fs4.mkdirSync(path4.dirname(tastePath), { recursive: true });
-    fs4.mkdirSync(path4.dirname(memoryPath), { recursive: true });
-    fs4.mkdirSync(path4.dirname(suggestionsPath), { recursive: true });
+    fs4.mkdirSync(path5.dirname(tastePath), { recursive: true });
+    fs4.mkdirSync(path5.dirname(memoryPath), { recursive: true });
+    fs4.mkdirSync(path5.dirname(suggestionsPath), { recursive: true });
     if (!fs4.existsSync(tastePath)) {
       fs4.writeFileSync(tastePath, DEFAULT_TASTE_FILE_CONTENT, "utf-8");
     }
@@ -1648,7 +1714,7 @@ function createTasteStore(params) {
 
 // src/cli/services/scenes/file-store.ts
 import fs5 from "node:fs";
-import path5 from "node:path";
+import path6 from "node:path";
 import { randomUUID } from "node:crypto";
 
 // src/cli/services/scenes/types.ts
@@ -1670,10 +1736,10 @@ function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 function getStorePath(cwd) {
-  return path5.resolve(cwd, ".feedeas/store.json");
+  return path6.resolve(cwd, ".feedeas/store.json");
 }
 function ensureStore(pathname) {
-  const dir = path5.dirname(pathname);
+  const dir = path6.dirname(pathname);
   if (!fs5.existsSync(dir)) {
     fs5.mkdirSync(dir, { recursive: true });
   }
@@ -1900,10 +1966,10 @@ api.get("/v1/files/read", async (c) => {
 });
 api.post("/v1/files/write", async (c) => {
   const body = await c.req.json();
-  const { path: path22, content } = body;
-  if (!path22 || content === void 0) return c.json({ error: "Path and content required" }, 400);
+  const { path: path23, content } = body;
+  if (!path23 || content === void 0) return c.json({ error: "Path and content required" }, 400);
   try {
-    const fullPath = resolveSafePath(path22);
+    const fullPath = resolveSafePath(path23);
     const dir = dirname(fullPath);
     if (!existsSync(dir)) {
       await mkdir(dir, { recursive: true });
@@ -2406,14 +2472,14 @@ api.post("/cli/run", async (c) => {
 var api_default = api;
 
 // src/cli/server/index.ts
-import path6 from "path";
+import path7 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import fs6 from "fs";
 var app = new Hono2();
 app.use("/*", cors());
 app.route("/api", api_default);
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path6.dirname(__filename2);
+var __dirname2 = path7.dirname(__filename2);
 var createServer = (staticRoot) => {
   const app2 = new Hono2();
   app2.use("/*", cors());
@@ -2444,7 +2510,7 @@ var createServer = (staticRoot) => {
   };
   app2.get("/*", async (c) => {
     const requestPath = c.req.path === "/" ? "/index.html" : c.req.path;
-    const filePath = path6.join(staticRoot, requestPath);
+    const filePath = path7.join(staticRoot, requestPath);
     try {
       if (fs6.existsSync(filePath)) {
         const file = await fs6.promises.readFile(filePath);
@@ -2459,7 +2525,7 @@ var createServer = (staticRoot) => {
     }
     if (!requestPath.includes(".")) {
       try {
-        const indexPath = path6.join(staticRoot, "index.html");
+        const indexPath = path7.join(staticRoot, "index.html");
         if (fs6.existsSync(indexPath)) {
           const indexFile = await fs6.promises.readFile(indexPath);
           return new Response(indexFile, {
@@ -2582,12 +2648,12 @@ var SceneApiClient = class {
 
 // src/cli/services/scenes/flow-state.ts
 import fs7 from "node:fs";
-import path7 from "node:path";
+import path8 from "node:path";
 function sessionPath(cwd) {
-  return path7.resolve(cwd, ".feedeas/session.json");
+  return path8.resolve(cwd, ".feedeas/session.json");
 }
 function ensureDir(filePath) {
-  const dir = path7.dirname(filePath);
+  const dir = path8.dirname(filePath);
   if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
 }
 function readFlowState(cwd = process.cwd()) {
@@ -2631,7 +2697,7 @@ function resolveApiUrl(explicit) {
 
 // src/cli/commands/record.ts
 var __filename3 = fileURLToPath3(import.meta.url);
-var __dirname3 = path8.dirname(__filename3);
+var __dirname3 = path9.dirname(__filename3);
 function formatBytes(bytes) {
   if (bytes === 0) return "0 B";
   const k = 1024;
@@ -2640,7 +2706,7 @@ function formatBytes(bytes) {
   return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
 }
 function getMissingUiAssets(staticRoot) {
-  const indexPath = path8.join(staticRoot, "index.html");
+  const indexPath = path9.join(staticRoot, "index.html");
   if (!fs8.existsSync(indexPath)) {
     return {
       missingFiles: [indexPath],
@@ -2653,7 +2719,7 @@ function getMissingUiAssets(staticRoot) {
   const missingFiles = [];
   const expectedUrls = [];
   for (const assetPath of assetPaths) {
-    const localPath = path8.join(staticRoot, assetPath.replace(/^\//, ""));
+    const localPath = path9.join(staticRoot, assetPath.replace(/^\//, ""));
     if (!fs8.existsSync(localPath)) {
       missingFiles.push(localPath);
       expectedUrls.push(assetPath);
@@ -2861,9 +2927,9 @@ Ready to record. Run without --dry-run to start rendering.`);
   ensureFfmpegAvailableOrExit();
   await ensurePlaywrightReadyOrExit();
   console.log("Starting temporary server...");
-  let staticRoot = path8.resolve(__dirname3, "../../dist/ui");
+  let staticRoot = path9.resolve(__dirname3, "../../dist/ui");
   if (!fs8.existsSync(staticRoot)) {
-    staticRoot = path8.resolve(__dirname3, "../ui");
+    staticRoot = path9.resolve(__dirname3, "../ui");
   }
   if (!fs8.existsSync(staticRoot)) {
     console.error(`Error: UI assets not found at ${staticRoot}. Please run 'bun run build' first.`);
@@ -3081,10 +3147,10 @@ Ready to record. Run without --dry-run to start rendering.`);
 // src/cli/commands/inspect.ts
 import { Command as Command2 } from "commander";
 import fs9 from "fs";
-import path9 from "path";
+import path10 from "path";
 var inspectCommand = new Command2("inspect");
 inspectCommand.description("Inspect an asset file to get metadata (duration, format, etc.)").argument("<file>", "Path to the asset file").option("--json", "Output in JSON format").action(async (file, options) => {
-  const filePath = path9.resolve(process.cwd(), file);
+  const filePath = path10.resolve(process.cwd(), file);
   if (!fs9.existsSync(filePath)) {
     console.error(`File not found: ${filePath}`);
     process.exit(1);
@@ -3248,14 +3314,14 @@ validateCommand.description("Validate a scene by project and scene ID").option("
 // src/cli/commands/set-scene.ts
 import { Command as Command4 } from "commander";
 import fs11 from "fs";
-import path10 from "path";
+import path11 from "path";
 var setSceneCommand = new Command4("set-scene");
 setSceneCommand.description("Update an existing scene by project/scene ID").option("--project-id <id>", "Project ID").option("--scene-id <id>", "Scene ID").option("-c, --content <json>", "JSON content string").option("-i, --input <file>", "Input JSON file to copy from").option("--version <number>", "Expected scene version").option("--api-url <url>", "API base URL (e.g. http://localhost:3331)").action(async (options) => {
   let contentStr = "";
   if (options.content) {
     contentStr = options.content;
   } else if (options.input) {
-    const inputPath = path10.resolve(process.cwd(), options.input);
+    const inputPath = path11.resolve(process.cwd(), options.input);
     if (!fs11.existsSync(inputPath)) {
       console.error(`Input file not found: ${inputPath}`);
       process.exit(1);
@@ -3302,29 +3368,29 @@ setSceneCommand.description("Update an existing scene by project/scene ID").opti
 // src/cli/commands/imagine.ts
 import { Command as Command5 } from "commander";
 import fs13 from "fs";
-import path12 from "path";
+import path13 from "path";
 
 // src/cli/utils/path.ts
-import path11 from "path";
+import path12 from "path";
 import fs12 from "fs";
 function resolveAssetOutputPath(outputOption, cwd = process.cwd()) {
-  if (path11.isAbsolute(outputOption)) {
+  if (path12.isAbsolute(outputOption)) {
     return outputOption;
   }
-  const assetsDir = path11.resolve(cwd, "assets");
+  const assetsDir = path12.resolve(cwd, "assets");
   if (!fs12.existsSync(assetsDir)) {
     fs12.mkdirSync(assetsDir, { recursive: true });
   }
-  const normalizedInput = path11.normalize(outputOption);
+  const normalizedInput = path12.normalize(outputOption);
   let cleanRelativePath = normalizedInput;
-  const segments = normalizedInput.split(path11.sep);
+  const segments = normalizedInput.split(path12.sep);
   if (segments[0] === "assets") {
-    cleanRelativePath = segments.slice(1).join(path11.sep);
+    cleanRelativePath = segments.slice(1).join(path12.sep);
   }
   if (!cleanRelativePath) {
     cleanRelativePath = `unnamed-asset-${Date.now()}`;
   }
-  return path11.join(assetsDir, cleanRelativePath);
+  return path12.join(assetsDir, cleanRelativePath);
 }
 
 // src/cli/commands/imagine.ts
@@ -3421,15 +3487,15 @@ Note:
       imageSize
     });
     const outputPath = resolveAssetOutputPath(options.output);
-    const outputDir = path12.dirname(outputPath);
-    const outputExt = path12.extname(outputPath) || ".png";
-    const outputBase = path12.basename(outputPath, outputExt);
+    const outputDir = path13.dirname(outputPath);
+    const outputExt = path13.extname(outputPath) || ".png";
+    const outputBase = path13.basename(outputPath, outputExt);
     if (!fs13.existsSync(outputDir)) {
       fs13.mkdirSync(outputDir, { recursive: true });
     }
     const savedFiles = [];
     for (let i = 0; i < images.length; i++) {
-      const filename = images.length > 1 ? path12.join(outputDir, `${outputBase}_${i + 1}${outputExt}`) : outputPath;
+      const filename = images.length > 1 ? path13.join(outputDir, `${outputBase}_${i + 1}${outputExt}`) : outputPath;
       fs13.writeFileSync(filename, images[i]);
       if (!options.json) console.log(`\u2705 Image saved: ${filename}`);
       savedFiles.push(filename);
@@ -3541,7 +3607,7 @@ function resolveAspectRatio(input, projectFile) {
   return normalizeAspectRatio(input);
 }
 function inferAspectRatioFromProject(projectFile) {
-  const filePath = path12.resolve(process.cwd(), projectFile);
+  const filePath = path13.resolve(process.cwd(), projectFile);
   if (!fs13.existsSync(filePath)) return null;
   try {
     const scene = JSON.parse(fs13.readFileSync(filePath, "utf-8"));
@@ -3585,43 +3651,42 @@ function gcd(a, b) {
 // src/cli/commands/audio.ts
 import { Command as Command6 } from "commander";
 import fs16 from "fs";
-import path15 from "path";
+import path16 from "path";
 
 // src/cli/services/whisper.ts
 import fs14 from "fs";
-import path13 from "path";
+import path14 from "path";
 import os from "os";
-import { spawn as spawn5 } from "child_process";
 import https from "https";
 var WhisperService = class {
   static getHomeDir() {
     return os.homedir();
   }
   static getBaseDir() {
-    return path13.join(this.getHomeDir(), ".feedeas");
+    return path14.join(this.getHomeDir(), ".feedeas");
   }
   static getBinDir() {
-    return path13.join(this.getBaseDir(), "bin");
+    return path14.join(this.getBaseDir(), "bin");
   }
   static getModelsDir() {
-    return path13.join(this.getBaseDir(), "models");
+    return path14.join(this.getBaseDir(), "models");
   }
   static getExecutablePath() {
-    const repoDir = path13.join(this.getBaseDir(), "whisper.cpp-repo");
+    const repoDir = path14.join(this.getBaseDir(), "whisper.cpp-repo");
     const possiblePaths = [
-      path13.join(repoDir, "build", "bin", "whisper-cli"),
-      path13.join(repoDir, "build", "bin", "main"),
-      path13.join(repoDir, "main"),
-      path13.join(this.getBinDir(), "whisper-main")
+      path14.join(repoDir, "build", "bin", "whisper-cli"),
+      path14.join(repoDir, "build", "bin", "main"),
+      path14.join(repoDir, "main"),
+      path14.join(this.getBinDir(), "whisper-main")
       // fallback to copied/downloaded
     ];
     for (const p of possiblePaths) {
       if (fs14.existsSync(p)) return p;
     }
-    return path13.join(this.getBinDir(), "whisper-main");
+    return path14.join(this.getBinDir(), "whisper-main");
   }
   static getModelPath(modelName = "base.en") {
-    return path13.join(this.getModelsDir(), `ggml-${modelName}.bin`);
+    return path14.join(this.getModelsDir(), `ggml-${modelName}.bin`);
   }
   /**
    * Download a file from a URL to a destination path
@@ -3663,7 +3728,7 @@ var WhisperService = class {
     if (!fs14.existsSync(execPath)) {
       console.log("\u2B07\uFE0F  Whisper binary not found. Attempting to build...");
       try {
-        const repoDir = path13.join(this.getBaseDir(), "whisper.cpp-repo");
+        const repoDir = path14.join(this.getBaseDir(), "whisper.cpp-repo");
         if (!fs14.existsSync(repoDir)) {
           console.log("\u{1F4E6}  Cloning whisper.cpp...");
           await runCommand("git", ["clone", "https://github.com/ggerganov/whisper.cpp.git", repoDir]);
@@ -3696,12 +3761,12 @@ Please install manually: 'brew install whisper-cpp'`);
   static async transcribe(audioPath) {
     const execPath = this.getExecutablePath();
     const modelPath = this.getModelPath();
-    const ext = path13.extname(audioPath).toLowerCase();
+    const ext = path14.extname(audioPath).toLowerCase();
     let inputToWhisper = audioPath;
     let isTempFile = false;
     if (ext !== ".wav") {
       console.log("\u{1F504} Converting audio to 16kHz WAV for Whisper...");
-      const tempWav = path13.join(path13.dirname(audioPath), `temp_${Date.now()}.wav`);
+      const tempWav = path14.join(path14.dirname(audioPath), `temp_${Date.now()}.wav`);
       await runCommand("ffmpeg", [
         "-i",
         audioPath,
@@ -3718,7 +3783,7 @@ Please install manually: 'brew install whisper-cpp'`);
       isTempFile = true;
     }
     try {
-      const outputBase = path13.join(path13.dirname(audioPath), path13.basename(audioPath, path13.extname(audioPath)));
+      const outputBase = path14.join(path14.dirname(audioPath), path14.basename(audioPath, path14.extname(audioPath)));
       const baseArgs = [
         "-m",
         modelPath,
@@ -3761,19 +3826,30 @@ Please install manually: 'brew install whisper-cpp'`);
     }
   }
 };
+function isNodeRuntime2() {
+  return typeof process !== "undefined" && !!process.versions?.node;
+}
 function runCommand(command, args, cwd) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn5(command, args, { cwd, stdio: "inherit" });
-    proc.on("close", (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`${command} exited with code ${code}`));
-    });
-    proc.on("error", reject);
+  if (!isNodeRuntime2()) {
+    return Promise.reject(new Error(`"${command}" requires a Node runtime with child_process support.`));
+  }
+  return new Promise(async (resolve, reject) => {
+    try {
+      const { spawn: spawn5 } = await import("node:child_process");
+      const proc = spawn5(command, args, { cwd, stdio: "inherit" });
+      proc.on("close", (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`${command} exited with code ${code}`));
+      });
+      proc.on("error", reject);
+    } catch (err) {
+      reject(err);
+    }
   });
 }
 function runWhisper(execPath, args) {
   return new Promise((resolve, reject) => {
-    const proc = spawn5(execPath, args, { stdio: "inherit" });
+    const proc = spawn(execPath, args, { stdio: "inherit" });
     proc.on("close", (code) => {
       if (code !== 0) {
         reject(new Error(`Whisper process exited with code ${code}`));
@@ -3837,24 +3913,37 @@ function roundTo3(value) {
 
 // src/cli/services/audio-convert.ts
 import fs15 from "fs";
-import path14 from "path";
-import { spawn as spawn6 } from "node:child_process";
+import path15 from "path";
 import { pathToFileURL } from "node:url";
 import { FFmpeg } from "@ffmpeg/ffmpeg";
-function isNodeRuntime() {
+function isNodeRuntime3() {
   return typeof process !== "undefined" && !!process.versions?.node;
 }
-async function convertWithNodeFfmpeg(pcmPath, outputPath) {
+function buildCodecArgs(options) {
+  if (options.format === "wav") {
+    return ["-c:a", "pcm_s16le"];
+  }
+  if (typeof options.mp3Quality === "number") {
+    return ["-c:a", "libmp3lame", "-q:a", String(options.mp3Quality)];
+  }
+  return ["-c:a", "libmp3lame", "-b:a", options.mp3Bitrate || "128k"];
+}
+async function convertWithNodeFfmpeg(options) {
+  const { pcmPath, outputPath, sampleRate, channels, durationSec } = options;
+  const codecArgs = buildCodecArgs(options);
+  const { spawn: spawn5 } = await import("node:child_process");
   await new Promise((resolve, reject) => {
-    const ffmpeg = spawn6("ffmpeg", [
+    const ffmpeg = spawn5("ffmpeg", [
       "-f",
       "s16le",
       "-ar",
-      "24000",
+      String(sampleRate),
       "-ac",
-      "1",
+      String(channels),
       "-i",
       pcmPath,
+      ...typeof durationSec === "number" ? ["-t", String(durationSec)] : [],
+      ...codecArgs,
       "-y",
       outputPath
     ], { stdio: "inherit" });
@@ -3865,41 +3954,42 @@ async function convertWithNodeFfmpeg(pcmPath, outputPath) {
     ffmpeg.on("error", (err) => reject(err));
   });
 }
-async function convertWithWasm(pcmPath, outputPath) {
+async function convertWithWasm(options) {
+  const { pcmPath, outputPath, sampleRate, channels, durationSec } = options;
   const ffmpeg = new FFmpeg();
   const baseDir = typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : ".";
-  const coreDir = path14.resolve(baseDir, "node_modules/@ffmpeg/core/dist");
-  const coreURL = pathToFileURL(path14.join(coreDir, "ffmpeg-core.js")).toString();
-  const wasmURL = pathToFileURL(path14.join(coreDir, "ffmpeg-core.wasm")).toString();
-  const workerURL = pathToFileURL(path14.join(coreDir, "ffmpeg-core.worker.js")).toString();
+  const coreDir = path15.resolve(baseDir, "node_modules/@ffmpeg/core/dist");
+  const coreURL = pathToFileURL(path15.join(coreDir, "ffmpeg-core.js")).toString();
+  const wasmURL = pathToFileURL(path15.join(coreDir, "ffmpeg-core.wasm")).toString();
+  const workerURL = pathToFileURL(path15.join(coreDir, "ffmpeg-core.worker.js")).toString();
   await ffmpeg.load({ coreURL, wasmURL, workerURL });
   const pcmBytes = await fs15.promises.readFile(pcmPath);
   await ffmpeg.writeFile("input.pcm", pcmBytes);
+  const codecArgs = buildCodecArgs(options);
+  const outputName = options.format === "wav" ? "output.wav" : "output.mp3";
   await ffmpeg.exec([
     "-f",
     "s16le",
     "-ar",
-    "24000",
+    String(sampleRate),
     "-ac",
-    "1",
+    String(channels),
     "-i",
     "input.pcm",
-    "-codec:a",
-    "libmp3lame",
-    "-b:a",
-    "128k",
-    "output.mp3"
+    ...typeof durationSec === "number" ? ["-t", String(durationSec)] : [],
+    ...codecArgs,
+    outputName
   ]);
-  const output = await ffmpeg.readFile("output.mp3");
+  const output = await ffmpeg.readFile(outputName);
   await fs15.promises.writeFile(outputPath, output);
 }
-async function convertPcmToMp3(options) {
-  const { pcmPath, outputPath } = options;
-  let useWasm = !isNodeRuntime();
+async function convertPcmToAudio(options) {
+  const { pcmPath } = options;
+  let useWasm = !isNodeRuntime3();
   try {
     try {
       if (!useWasm) {
-        await convertWithNodeFfmpeg(pcmPath, outputPath);
+        await convertWithNodeFfmpeg(options);
         return;
       }
     } catch (err) {
@@ -3910,7 +4000,7 @@ async function convertPcmToMp3(options) {
     }
     if (useWasm) {
       try {
-        await convertWithWasm(pcmPath, outputPath);
+        await convertWithWasm(options);
         return;
       } catch (err) {
         throw new Error(
@@ -3930,6 +4020,15 @@ async function convertPcmToMp3(options) {
     }
   }
 }
+async function convertPcmToMp3(options) {
+  await convertPcmToAudio({
+    ...options,
+    format: "mp3",
+    sampleRate: 24e3,
+    channels: 1,
+    mp3Bitrate: "128k"
+  });
+}
 
 // src/cli/commands/audio.ts
 var audioCommand = new Command6("generate:audio");
@@ -3954,9 +4053,9 @@ audioCommand.alias("audio").description("Generate audio from text using Gemini A
     console.log("\u{1F5E3}\uFE0F  Generating speech with Gemini...");
     const audioBuffer = await generateGeminiAudio(text, apiKey, options.voice);
     const outputPath = resolveAssetOutputPath(options.output);
-    const tempPcmPath = path15.join(path15.dirname(outputPath), `temp_${Date.now()}.pcm`);
+    const tempPcmPath = path16.join(path16.dirname(outputPath), `temp_${Date.now()}.pcm`);
     fs16.writeFileSync(tempPcmPath, audioBuffer);
-    console.log(`\u{1F504} Converting raw PCM to ${path15.extname(outputPath)}...`);
+    console.log(`\u{1F504} Converting raw PCM to ${path16.extname(outputPath)}...`);
     await convertPcmToMp3({
       pcmPath: tempPcmPath,
       outputPath
@@ -3967,7 +4066,7 @@ audioCommand.alias("audio").description("Generate audio from text using Gemini A
         console.log("\u{1F50D} Aligning audio with Whisper...");
         await WhisperService.ensureReady();
         const metadata = await WhisperService.transcribe(outputPath);
-        const metaPath = outputPath.replace(path15.extname(outputPath), ".json");
+        const metaPath = outputPath.replace(path16.extname(outputPath), ".json");
         fs16.writeFileSync(metaPath, JSON.stringify(metadata, null, 2));
         console.log(`\u2705 Metadata saved: ${metaPath}`);
       } catch (wErr) {
@@ -4019,8 +4118,7 @@ async function generateGeminiAudio(text, apiKey, voiceName) {
 // src/cli/commands/bgm.ts
 import { Command as Command7 } from "commander";
 import fs17 from "fs";
-import path16 from "path";
-import { spawn as spawn7 } from "child_process";
+import path17 from "path";
 var bgmCommand = new Command7("generate:bgm");
 bgmCommand.alias("bgm").alias("music").description("Generate background music with Gemini Lyria (Live Music API)").argument("<prompt-or-file>", "Music prompt text or path to a text file").option("-o, --output <filename>", "Output filename (relative to assets/ or absolute path)", "bgm.mp3").option("-k, --api-key <key>", "Gemini API key (or set GEMINI_API_KEY env var)").option("-d, --duration <seconds>", "Target duration in seconds (5-300)", "30").option("--seed <number>", "Optional seed for reproducible output").option("--json", "Emit machine-readable JSON output").action(async (promptOrFile, options) => {
   try {
@@ -4093,7 +4191,7 @@ function parseSeed(input) {
   return value;
 }
 function inferOutputFormat(outputPath) {
-  const ext = path16.extname(outputPath).toLowerCase();
+  const ext = path17.extname(outputPath).toLowerCase();
   if (ext === ".wav") return "wav";
   if (ext === ".mp3" || !ext) return "mp3";
   throw new Error("Invalid output format. Use .mp3 or .wav.");
@@ -4181,54 +4279,35 @@ async function generateGeminiMusicPcm(request) {
   });
 }
 async function convertPcmToOutput(pcmBuffer, outputPath, format, durationSec) {
-  const outputDir = path16.dirname(outputPath);
+  const outputDir = path17.dirname(outputPath);
   if (!fs17.existsSync(outputDir)) fs17.mkdirSync(outputDir, { recursive: true });
-  const tempPcmPath = path16.join(outputDir, `temp_bgm_${Date.now()}.pcm`);
+  const tempPcmPath = path17.join(outputDir, `temp_bgm_${Date.now()}.pcm`);
   fs17.writeFileSync(tempPcmPath, pcmBuffer);
-  const codecArgs = format === "wav" ? ["-c:a", "pcm_s16le"] : ["-c:a", "libmp3lame", "-q:a", "2"];
-  try {
-    await new Promise((resolve, reject) => {
-      const ffmpeg = spawn7("ffmpeg", [
-        "-f",
-        "s16le",
-        "-ar",
-        "48000",
-        "-ac",
-        "2",
-        "-i",
-        tempPcmPath,
-        "-t",
-        String(durationSec),
-        ...codecArgs,
-        "-y",
-        outputPath
-      ], { stdio: "inherit" });
-      ffmpeg.on("close", (code) => {
-        if (code === 0) resolve();
-        else reject(new Error(`FFmpeg exited with code ${code}`));
-      });
-      ffmpeg.on("error", reject);
-    });
-  } finally {
-    if (fs17.existsSync(tempPcmPath)) fs17.unlinkSync(tempPcmPath);
-  }
+  await convertPcmToAudio({
+    pcmPath: tempPcmPath,
+    outputPath,
+    format,
+    sampleRate: 48e3,
+    channels: 2,
+    durationSec,
+    mp3Quality: format === "mp3" ? 2 : void 0
+  });
 }
 
 // src/cli/commands/asset.ts
 import { Command as Command8 } from "commander";
 import fs18 from "fs";
-import path17 from "path";
-import { spawn as spawn8 } from "child_process";
+import path18 from "path";
 var assetCommand = new Command8("asset").description("Asset information and management");
 assetCommand.command("info <file>").description("Show detailed information about an asset").action(async (file) => {
-  const assetPath = path17.resolve(process.cwd(), "assets", file);
+  const assetPath = path18.resolve(process.cwd(), "assets", file);
   if (!fs18.existsSync(assetPath)) {
     console.error(`Asset not found: ${file}`);
     console.error(`Looked in: ${assetPath}`);
     process.exit(1);
   }
   const stats = fs18.statSync(assetPath);
-  const ext = path17.extname(file).toLowerCase();
+  const ext = path18.extname(file).toLowerCase();
   console.log(`
 Asset: ${file}`);
   console.log(`Size: ${formatBytes2(stats.size)}`);
@@ -4251,7 +4330,7 @@ Asset: ${file}`);
       console.log(`Channels: ${audioInfo.channels}`);
       console.log(`Bitrate: ${audioInfo.bitrate}`);
       const metadataFile = file.replace(ext, ".json");
-      const metadataPath = path17.resolve(process.cwd(), "assets", metadataFile);
+      const metadataPath = path18.resolve(process.cwd(), "assets", metadataFile);
       if (fs18.existsSync(metadataPath)) {
         console.log(`
 Metadata: ${metadataFile}`);
@@ -4300,47 +4379,18 @@ async function getImageDimensions(filePath) {
   }
 }
 async function getAudioInfo(filePath) {
-  return new Promise((resolve, reject) => {
-    const ffprobe = spawn8("ffprobe", [
-      "-v",
-      "error",
-      "-show_entries",
-      "format=duration,bit_rate:stream=codec_name,sample_rate,channels",
-      "-of",
-      "json",
-      filePath
-    ]);
-    let output = "";
-    ffprobe.stdout.on("data", (data) => {
-      output += data.toString();
-    });
-    ffprobe.on("close", (code) => {
-      if (code !== 0) {
-        reject(new Error("ffprobe failed"));
-        return;
-      }
-      try {
-        const data = JSON.parse(output);
-        const stream = data.streams?.[0] || {};
-        const format = data.format || {};
-        resolve({
-          duration: format.duration ? parseFloat(format.duration).toFixed(2) : "unknown",
-          codec: stream.codec_name || "unknown",
-          sampleRate: stream.sample_rate ? `${stream.sample_rate} Hz` : "unknown",
-          channels: stream.channels ? stream.channels === 1 ? "mono" : stream.channels === 2 ? "stereo" : `${stream.channels}ch` : "unknown",
-          bitrate: format.bit_rate ? `${Math.round(parseInt(format.bit_rate) / 1e3)} kbps` : "unknown"
-        });
-      } catch (err) {
-        reject(err);
-      }
-    });
-    ffprobe.on("error", reject);
-  });
+  const metadata = await FFprobeService.getMetadata(filePath);
+  const duration = metadata.duration ? metadata.duration.toFixed(2) : "unknown";
+  const codec = metadata.audioCodec || metadata.format || "unknown";
+  const sampleRate = metadata.sampleRate ? `${metadata.sampleRate} Hz` : "unknown";
+  const channels = metadata.audioChannels ? metadata.audioChannels === 1 ? "mono" : metadata.audioChannels === 2 ? "stereo" : `${metadata.audioChannels}ch` : "unknown";
+  const bitrate = metadata.bitrate ? `${Math.round(metadata.bitrate / 1e3)} kbps` : "unknown";
+  return { duration, codec, sampleRate, channels, bitrate };
 }
 
 // src/cli/index.ts
 import open2 from "open";
-import path21 from "path";
+import path22 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import fs21 from "fs";
 
@@ -4759,7 +4809,7 @@ addEntityCommand.description("Add an entity to an existing scene").option("--pro
 
 // src/cli/services/telemetry.ts
 import os2 from "os";
-import path18 from "path";
+import path19 from "path";
 import { createHash as createHash2 } from "crypto";
 var POSTHOG_CAPTURE_URL = "https://us.i.posthog.com/capture/";
 var TELEMETRY_DISABLED_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
@@ -4771,7 +4821,7 @@ var PostHogTelemetryService = class {
     if (!this.enabled) return;
     this.capture("cli_feedback", {
       details: String(details).slice(0, 2e3),
-      cwd_basename: path18.basename(process.cwd())
+      cwd_basename: path19.basename(process.cwd())
     });
   }
   apiKey;
@@ -4794,7 +4844,7 @@ var PostHogTelemetryService = class {
       command_name: this.getCommandPath(actionCommand),
       command_aliases: actionCommand.aliases(),
       options_used: this.getUsedOptionNames(actionCommand),
-      cwd_basename: path18.basename(process.cwd()),
+      cwd_basename: path19.basename(process.cwd()),
       node_version: process.version,
       platform: process.platform,
       arch: process.arch
@@ -4807,7 +4857,7 @@ var PostHogTelemetryService = class {
       status,
       duration_ms: Math.max(0, Math.round(durationMs)),
       error_message: errorMessage ? String(errorMessage).slice(0, 300) : void 0,
-      cwd_basename: path18.basename(process.cwd())
+      cwd_basename: path19.basename(process.cwd())
     });
   }
   getCommandPath(command) {
@@ -4861,25 +4911,25 @@ var PostHogTelemetryService = class {
 // src/cli/commands/taste.ts
 import { Command as Command12 } from "commander";
 import fs19 from "node:fs";
-import path19 from "node:path";
+import path20 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import open from "open";
 var __filename4 = fileURLToPath4(import.meta.url);
-var __dirname4 = path19.dirname(__filename4);
+var __dirname4 = path20.dirname(__filename4);
 function resolveStaticRoot() {
-  let staticRoot = path19.resolve(__dirname4, "../../../dist/ui");
+  let staticRoot = path20.resolve(__dirname4, "../../../dist/ui");
   if (!fs19.existsSync(staticRoot)) {
-    staticRoot = path19.resolve(__dirname4, "../../ui");
+    staticRoot = path20.resolve(__dirname4, "../../ui");
   }
   return staticRoot;
 }
 function prepareWorkingDirectory(pathArg) {
   if (!pathArg) return;
-  const targetPath = path19.resolve(process.cwd(), pathArg);
+  const targetPath = path20.resolve(process.cwd(), pathArg);
   if (fs19.existsSync(targetPath)) {
     const stats = fs19.statSync(targetPath);
     if (stats.isFile()) {
-      process.chdir(path19.dirname(targetPath));
+      process.chdir(path20.dirname(targetPath));
       return;
     }
     if (stats.isDirectory()) {
@@ -4887,8 +4937,8 @@ function prepareWorkingDirectory(pathArg) {
       return;
     }
   }
-  if (path19.extname(pathArg)) {
-    const dir = path19.dirname(targetPath);
+  if (path20.extname(pathArg)) {
+    const dir = path20.dirname(targetPath);
     fs19.mkdirSync(dir, { recursive: true });
     process.chdir(dir);
     return;
@@ -5181,7 +5231,7 @@ projectCommand.command("list").description("List projects").option("--api-url <u
 
 // src/cli/commands/scene.ts
 import fs20 from "node:fs";
-import path20 from "node:path";
+import path21 from "node:path";
 import { Command as Command15 } from "commander";
 var sceneCommand = new Command15("scene").description("Manage scenes");
 sceneCommand.command("list").option("--project-id <id>", "Project ID").option("--api-url <url>", "API base URL (e.g. http://localhost:3331)").action(async (options) => {
@@ -5213,7 +5263,7 @@ sceneCommand.command("create").option("--project-id <id>", "Project ID").option(
 });
 sceneCommand.command("import").option("--project-id <id>", "Project ID").requiredOption("--file <path>", "Scene JSON file path").option("--name <name>", "Scene name").option("--api-url <url>", "API base URL (e.g. http://localhost:3331)").action(async (options) => {
   try {
-    const filePath = path20.resolve(process.cwd(), String(options.file));
+    const filePath = path21.resolve(process.cwd(), String(options.file));
     if (!fs20.existsSync(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
@@ -5224,10 +5274,10 @@ sceneCommand.command("import").option("--project-id <id>", "Project ID").require
     const projectId = resolveProjectId(options.projectId);
     const apiUrl = resolveApiUrl(options.apiUrl);
     const scene = apiUrl ? await new SceneApiClient(apiUrl).createScene(projectId, {
-      name: options.name ? String(options.name) : path20.basename(filePath, path20.extname(filePath)),
+      name: options.name ? String(options.name) : path21.basename(filePath, path21.extname(filePath)),
       scene: { meta: parsed.meta, entities: parsed.entities }
     }) : await createSceneStoreBundle("file").scenes.createScene(projectId, {
-      name: options.name ? String(options.name) : path20.basename(filePath, path20.extname(filePath)),
+      name: options.name ? String(options.name) : path21.basename(filePath, path21.extname(filePath)),
       scene: { meta: parsed.meta, entities: parsed.entities }
     });
     writeFlowState({ projectId, sceneId: scene.id, apiUrl });
@@ -5246,8 +5296,8 @@ sceneCommand.command("export").option("--project-id <id>", "Project ID").option(
     if (!scene) {
       throw new Error(`Scene not found: ${sceneId}`);
     }
-    const out = path20.resolve(process.cwd(), String(options.file));
-    fs20.mkdirSync(path20.dirname(out), { recursive: true });
+    const out = path21.resolve(process.cwd(), String(options.file));
+    fs20.mkdirSync(path21.dirname(out), { recursive: true });
     fs20.writeFileSync(out, JSON.stringify({ meta: scene.meta, entities: scene.entities }, null, 2), "utf-8");
     writeFlowState({ projectId, sceneId, apiUrl });
     console.log(`Scene exported to ${out}`);
@@ -5267,11 +5317,11 @@ sceneCommand.command("use").description("Set current flow state for project/scen
 
 // src/cli/index.ts
 var __filename5 = fileURLToPath5(import.meta.url);
-var __dirname5 = path21.dirname(__filename5);
+var __dirname5 = path22.dirname(__filename5);
 var program = new Command16();
 var telemetry = new PostHogTelemetryService();
 var commandStartTimes = /* @__PURE__ */ new WeakMap();
-program.name("feedeas").description("CLI for Feedeas - AI-native video creation tool").version("0.1.0-alpha.17");
+program.name("feedeas").description("CLI for Feedeas - AI-native video creation tool").version("0.1.0-alpha.19");
 program.hook("preAction", (_thisCommand, actionCommand) => {
   commandStartTimes.set(actionCommand, Date.now());
   telemetry.trackCommandStarted(actionCommand);
@@ -5298,9 +5348,9 @@ program.command("edit").alias("start").alias("init").description("Start the Feed
   })();
   const cwd = process.cwd();
   console.log(`Starting Feedeas in ${cwd}...`);
-  let staticRoot = path21.resolve(__dirname5, "../../dist/ui");
+  let staticRoot = path22.resolve(__dirname5, "../../dist/ui");
   if (!fs21.existsSync(staticRoot)) {
-    staticRoot = path21.resolve(__dirname5, "../ui");
+    staticRoot = path22.resolve(__dirname5, "../ui");
   }
   if (!fs21.existsSync(staticRoot)) {
     console.warn(`Warning: UI assets not found at ${staticRoot}. Did you run 'bun run build'?`);

package/package.json

@@ -2,7 +2,7 @@
   "name": "feedeas",
   "module": "index.ts",
   "type": "module",
-  "version": "0.1.0-alpha.17",
+  "version": "0.1.0-alpha.19",
   "devDependencies": {
     "@tailwindcss/vite": "^4.1.18",
     "@types/bun": "latest",
@@ -28,6 +28,7 @@
     "hono": "^4.11.4",
     "image-size": "^2.0.2",
     "lucide-react": "^0.562.0",
+    "music-metadata": "^8.3.0",
     "open": "^11.0.0",
     "playwright-core": "^1.58.2",
     "react": "^19.2.3",