@vibeframe/cli 0.27.0 → 0.30.0

package/src/commands/detect.ts

@@ -1,329 +0,0 @@
-import { Command } from "commander";
-import { readFile, writeFile } from "node:fs/promises";
-import { resolve, basename } from "node:path";
-import chalk from "chalk";
-import ora from "ora";
-import { Project, type ProjectFile } from "../engine/index.js";
-import { execSafe, commandExists, ffprobeDuration } from "../utils/exec-safe.js";
-
-export const detectCommand = new Command("detect")
-  .description("Auto-detect scenes, beats, and silences in media");
-
-/**
- * Scene change detection using FFmpeg
- */
-detectCommand
-  .command("scenes")
-  .description("Detect scene changes in video")
-  .argument("<video>", "Video file path")
-  .option("-t, --threshold <value>", "Scene change threshold (0-1)", "0.3")
-  .option("-o, --output <path>", "Output JSON file with timestamps")
-  .option("-p, --project <path>", "Add scenes as clips to project")
-  .action(async (videoPath: string, options) => {
-    const spinner = ora("Detecting scenes...").start();
-
-    try {
-      // Check if FFmpeg is available
-      if (!commandExists("ffmpeg")) {
-        spinner.fail(chalk.red("FFmpeg not found. Please install FFmpeg."));
-        process.exit(1);
-      }
-
-      const absPath = resolve(process.cwd(), videoPath);
-      const threshold = parseFloat(options.threshold);
-
-      // Use FFmpeg to detect scene changes
-      spinner.text = "Analyzing video...";
-
-      const { stdout: sceneStdout, stderr: sceneStderr } = await execSafe("ffmpeg", [
-        "-i", absPath,
-        "-filter:v", `select='gt(scene,${threshold})',showinfo`,
-        "-f", "null", "-",
-      ], { maxBuffer: 50 * 1024 * 1024 }).catch((err) => {
-        // ffmpeg writes filter output to stderr and exits non-zero with -f null
-        if (err.stdout !== undefined || err.stderr !== undefined) {
-          return { stdout: err.stdout || "", stderr: err.stderr || "" };
-        }
-        throw err;
-      });
-      const output = sceneStdout + sceneStderr;
-
-      // Parse scene change timestamps from showinfo output
-      const scenes: { timestamp: number; score: number }[] = [];
-      const regex = /pts_time:(\d+\.?\d*)/g;
-      let match;
-
-      // Always start with 0
-      scenes.push({ timestamp: 0, score: 1 });
-
-      while ((match = regex.exec(output)) !== null) {
-        const timestamp = parseFloat(match[1]);
-        scenes.push({ timestamp, score: threshold });
-      }
-
-      // Get video duration
-      const totalDuration = await ffprobeDuration(absPath);
-
-      spinner.succeed(chalk.green(`Detected ${scenes.length} scenes`));
-
-      console.log();
-      console.log(chalk.bold.cyan("Scene Timestamps"));
-      console.log(chalk.dim("─".repeat(60)));
-
-      for (let i = 0; i < scenes.length; i++) {
-        const start = scenes[i].timestamp;
-        const end = i < scenes.length - 1 ? scenes[i + 1].timestamp : totalDuration;
-        const duration = end - start;
-        console.log(
-          `${chalk.yellow(`[${i + 1}]`)} ${formatTimestamp(start)} - ${formatTimestamp(end)} ${chalk.dim(`(${duration.toFixed(1)}s)`)}`
-        );
-      }
-      console.log();
-
-      // Save to JSON
-      if (options.output) {
-        const outputPath = resolve(process.cwd(), options.output);
-        const result = {
-          source: absPath,
-          totalDuration,
-          threshold,
-          scenes: scenes.map((s, i) => ({
-            index: i,
-            startTime: s.timestamp,
-            endTime: i < scenes.length - 1 ? scenes[i + 1].timestamp : totalDuration,
-            duration:
-              (i < scenes.length - 1 ? scenes[i + 1].timestamp : totalDuration) - s.timestamp,
-          })),
-        };
-        await writeFile(outputPath, JSON.stringify(result, null, 2), "utf-8");
-        console.log(chalk.green(`Saved to: ${outputPath}`));
-      }
-
-      // Add to project
-      if (options.project) {
-        const projectPath = resolve(process.cwd(), options.project);
-        const content = await readFile(projectPath, "utf-8");
-        const data: ProjectFile = JSON.parse(content);
-        const project = Project.fromJSON(data);
-
-        // Add video as source if not exists
-        let source = project.getSources().find((s) => s.url === absPath);
-        if (!source) {
-          source = project.addSource({
-            name: basename(absPath),
-            type: "video",
-            url: absPath,
-            duration: totalDuration,
-          });
-        }
-
-        // Add clips for each scene
-        for (let i = 0; i < scenes.length; i++) {
-          const start = scenes[i].timestamp;
-          const end = i < scenes.length - 1 ? scenes[i + 1].timestamp : totalDuration;
-          const duration = end - start;
-
-          project.addClip({
-            sourceId: source.id,
-            trackId: project.getTracks().find((t) => t.type === "video")?.id || "",
-            startTime: start,
-            duration,
-            sourceStartOffset: start,
-            sourceEndOffset: end,
-          });
-        }
-
-        await writeFile(projectPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
-        console.log(chalk.green(`Added ${scenes.length} clips to project`));
-      }
-    } catch (error) {
-      spinner.fail(chalk.red("Scene detection failed"));
-      console.error(error);
-      process.exit(1);
-    }
-  });
-
-/**
- * Silence detection using FFmpeg
- */
-detectCommand
-  .command("silence")
-  .description("Detect silence in audio/video")
-  .argument("<media>", "Media file path")
-  .option("-n, --noise <dB>", "Noise threshold in dB", "-30")
-  .option("-d, --duration <sec>", "Minimum silence duration", "0.5")
-  .option("-o, --output <path>", "Output JSON file with timestamps")
-  .action(async (mediaPath: string, options) => {
-    const spinner = ora("Detecting silence...").start();
-
-    try {
-      const absPath = resolve(process.cwd(), mediaPath);
-      const noise = options.noise;
-      const duration = options.duration;
-
-      const { stdout: silStdout, stderr: silStderr } = await execSafe("ffmpeg", [
-        "-i", absPath,
-        "-af", `silencedetect=noise=${noise}dB:d=${duration}`,
-        "-f", "null", "-",
-      ], { maxBuffer: 50 * 1024 * 1024 }).catch((err) => {
-        if (err.stdout !== undefined || err.stderr !== undefined) {
-          return { stdout: err.stdout || "", stderr: err.stderr || "" };
-        }
-        throw err;
-      });
-      const output = silStdout + silStderr;
-
-      // Parse silence periods
-      const silences: { start: number; end: number; duration: number }[] = [];
-      const startRegex = /silence_start: (\d+\.?\d*)/g;
-      const endRegex = /silence_end: (\d+\.?\d*) \| silence_duration: (\d+\.?\d*)/g;
-
-      const starts: number[] = [];
-      let match;
-
-      while ((match = startRegex.exec(output)) !== null) {
-        starts.push(parseFloat(match[1]));
-      }
-
-      let i = 0;
-      while ((match = endRegex.exec(output)) !== null) {
-        if (i < starts.length) {
-          silences.push({
-            start: starts[i],
-            end: parseFloat(match[1]),
-            duration: parseFloat(match[2]),
-          });
-          i++;
-        }
-      }
-
-      spinner.succeed(chalk.green(`Detected ${silences.length} silence periods`));
-
-      console.log();
-      console.log(chalk.bold.cyan("Silence Periods"));
-      console.log(chalk.dim("─".repeat(60)));
-
-      for (let i = 0; i < silences.length; i++) {
-        const s = silences[i];
-        console.log(
-          `${chalk.yellow(`[${i + 1}]`)} ${formatTimestamp(s.start)} - ${formatTimestamp(s.end)} ${chalk.dim(`(${s.duration.toFixed(1)}s)`)}`
-        );
-      }
-      console.log();
-
-      if (options.output) {
-        const outputPath = resolve(process.cwd(), options.output);
-        await writeFile(
-          outputPath,
-          JSON.stringify({ source: absPath, silences }, null, 2),
-          "utf-8"
-        );
-        console.log(chalk.green(`Saved to: ${outputPath}`));
-      }
-    } catch (error) {
-      spinner.fail(chalk.red("Silence detection failed"));
-      console.error(error);
-      process.exit(1);
-    }
-  });
-
-/**
- * Beat detection for music sync
- */
-detectCommand
-  .command("beats")
-  .description("Detect beats in audio (for music sync)")
-  .argument("<audio>", "Audio file path")
-  .option("-o, --output <path>", "Output JSON file with timestamps")
-  .action(async (audioPath: string, options) => {
-    const spinner = ora("Detecting beats...").start();
-
-    try {
-      const absPath = resolve(process.cwd(), audioPath);
-
-      // Use FFmpeg's ebur128 filter for loudness analysis
-      // This gives us a rough approximation of beat positions
-      const { stdout: beatStdout, stderr: beatStderr } = await execSafe("ffmpeg", [
-        "-i", absPath,
-        "-af", "aresample=16000,ebur128=peak=true",
-        "-f", "null", "-",
-      ], { maxBuffer: 50 * 1024 * 1024 }).catch((err) => {
-        if (err.stdout !== undefined || err.stderr !== undefined) {
-          return { stdout: err.stdout || "", stderr: err.stderr || "" };
-        }
-        throw err;
-      });
-      const beatOutput = beatStdout + beatStderr;
-
-      // Extract peak moments as approximate beats
-      const beats: number[] = [];
-      const peakRegex = /t:\s*(\d+\.?\d*)\s+M:\s*-?\d+\.?\d*\s+S:\s*-?\d+\.?\d*\s+I:\s*-?\d+\.?\d*\s+LUFS\s+LRA:\s*\d+\.?\d*\s+LU\s+FTPK:\s*(-?\d+\.?\d*)/g;
-
-      let match;
-      let lastBeatTime = -0.5;
-
-      while ((match = peakRegex.exec(beatOutput)) !== null) {
-        const time = parseFloat(match[1]);
-        const peak = parseFloat(match[2]);
-
-        // Consider it a beat if peak is high and enough time has passed
-        if (peak > -10 && time - lastBeatTime > 0.3) {
-          beats.push(time);
-          lastBeatTime = time;
-        }
-      }
-
-      // Fallback: if no beats detected, use simple interval-based detection
-      if (beats.length === 0) {
-        spinner.text = "Using interval-based detection...";
-
-        // Get duration
-        const totalDuration = await ffprobeDuration(absPath);
-
-        // Estimate BPM from audio length (rough approximation)
-        const estimatedBPM = 120;
-        const beatInterval = 60 / estimatedBPM;
-
-        for (let t = 0; t < totalDuration; t += beatInterval) {
-          beats.push(t);
-        }
-      }
-
-      spinner.succeed(chalk.green(`Detected ${beats.length} beats`));
-
-      console.log();
-      console.log(chalk.bold.cyan("Beat Timestamps"));
-      console.log(chalk.dim("─".repeat(60)));
-
-      // Show first 20 beats
-      const displayBeats = beats.slice(0, 20);
-      for (let i = 0; i < displayBeats.length; i++) {
-        console.log(`${chalk.yellow(`[${i + 1}]`)} ${formatTimestamp(displayBeats[i])}`);
-      }
-
-      if (beats.length > 20) {
-        console.log(chalk.dim(`... and ${beats.length - 20} more`));
-      }
-      console.log();
-
-      if (options.output) {
-        const outputPath = resolve(process.cwd(), options.output);
-        await writeFile(
-          outputPath,
-          JSON.stringify({ source: absPath, beatCount: beats.length, beats }, null, 2),
-          "utf-8"
-        );
-        console.log(chalk.green(`Saved to: ${outputPath}`));
-      }
-    } catch (error) {
-      spinner.fail(chalk.red("Beat detection failed"));
-      console.error(error);
-      process.exit(1);
-    }
-  });
-
-function formatTimestamp(seconds: number): string {
-  const mins = Math.floor(seconds / 60);
-  const secs = (seconds % 60).toFixed(2);
-  return `${mins.toString().padStart(2, "0")}:${secs.padStart(5, "0")}`;
-}

package/src/commands/doctor.ts

@@ -1,237 +0,0 @@
-/**
- * Doctor command - System health check and capability report
- */
-
-import { Command } from "commander";
-import chalk from "chalk";
-import { access } from "node:fs/promises";
-import { CONFIG_PATH } from "../config/index.js";
-import { PROVIDER_ENV_VARS } from "../config/schema.js";
-import { commandExists } from "../utils/exec-safe.js";
-import { execSafe } from "../utils/exec-safe.js";
-import { loadEnv } from "../utils/api-key.js";
-
-/** Mapping of env vars to the commands they unlock */
-const COMMAND_KEY_MAP: Record<string, string[]> = {
-  GOOGLE_API_KEY: [
-    "generate image",
-    "generate video -p veo",
-    "edit image",
-    "analyze media",
-    "analyze video",
-    "analyze review",
-  ],
-  OPENAI_API_KEY: [
-    "agent -p openai",
-    "generate image -p openai",
-    "edit image -p openai",
-    "audio transcribe",
-    "edit caption",
-    "edit jump-cut",
-  ],
-  ANTHROPIC_API_KEY: [
-    "agent -p claude",
-    "generate storyboard",
-    "generate motion",
-    "edit grade",
-    "edit reframe",
-    "edit speed-ramp",
-    "pipeline script-to-video",
-  ],
-  XAI_API_KEY: [
-    "agent -p xai",
-    "generate image -p grok",
-    "generate video",
-    "edit image -p grok",
-  ],
-  ELEVENLABS_API_KEY: [
-    "generate speech",
-    "generate sound-effect",
-    "generate music",
-    "audio voices",
-    "audio voice-clone",
-    "audio dub",
-  ],
-  KLING_API_KEY: ["generate video -p kling"],
-  RUNWAY_API_SECRET: ["generate video -p runway"],
-  REPLICATE_API_TOKEN: ["generate music -p replicate"],
-  IMGBB_API_KEY: ["generate video -p kling (image-to-video)"],
-};
-
-/** Commands that need no API key (FFmpeg only) */
-const FREE_COMMANDS = [
-  "edit silence-cut",
-  "edit noise-reduce",
-  "edit fade",
-  "edit text-overlay",
-  "detect scenes",
-  "detect silence",
-  "detect beats",
-  "export",
-  "project create/info",
-  "timeline (all)",
-  "batch import/concat",
-];
-
-export const doctorCommand = new Command("doctor")
-  .description("Check system health and available commands")
-  .option("--json", "Output in JSON format")
-  .addHelpText(
-    "after",
-    `
-Examples:
-  $ vibe doctor              Show system health and capabilities
-  $ vibe doctor --json       Machine-readable output
-`
-  )
-  .action(async (options) => {
-    const isJson = options.json || process.env.VIBE_JSON_OUTPUT === "1";
-    const results = await runDiagnostics();
-
-    if (isJson) {
-      console.log(JSON.stringify(results, null, 2));
-      return;
-    }
-
-    printReport(results);
-  });
-
-interface DiagnosticResults {
-  system: {
-    node: { version: string; ok: boolean };
-    ffmpeg: { version: string | null; ok: boolean };
-    config: { path: string; ok: boolean };
-  };
-  providers: Record<
-    string,
-    { envVar: string; configured: boolean; commands: string[] }
-  >;
-  readyCount: number;
-  totalCount: number;
-}
-
-async function runDiagnostics(): Promise<DiagnosticResults> {
-  loadEnv();
-
-  // System checks
-  const nodeVersion = process.version;
-
-  let ffmpegVersion: string | null = null;
-  const ffmpegExists = commandExists("ffmpeg");
-  if (ffmpegExists) {
-    try {
-      const result = await execSafe("ffmpeg", ["-version"]);
-      const match = result.stdout.match(/ffmpeg version (\S+)/);
-      ffmpegVersion = match ? match[1] : "unknown";
-    } catch {
-      ffmpegVersion = "unknown";
-    }
-  }
-
-  let configExists = false;
-  try {
-    await access(CONFIG_PATH);
-    configExists = true;
-  } catch {
-    // not configured
-  }
-
-  // Provider checks
-  const providers: DiagnosticResults["providers"] = {};
-  let readyCount = FREE_COMMANDS.length;
-  let totalCount = FREE_COMMANDS.length;
-
-  for (const [envVar, commands] of Object.entries(COMMAND_KEY_MAP)) {
-    const configured = !!process.env[envVar];
-    const providerName =
-      Object.entries(PROVIDER_ENV_VARS).find(([, v]) => v === envVar)?.[0] ??
-      envVar;
-    providers[providerName] = { envVar, configured, commands };
-    totalCount += commands.length;
-    if (configured) {
-      readyCount += commands.length;
-    }
-  }
-
-  return {
-    system: {
-      node: { version: nodeVersion, ok: true },
-      ffmpeg: { version: ffmpegVersion, ok: ffmpegExists },
-      config: { path: CONFIG_PATH, ok: configExists },
-    },
-    providers,
-    readyCount,
-    totalCount,
-  };
-}
-
-function printReport(results: DiagnosticResults): void {
-  console.log();
-  console.log(chalk.bold("  System"));
-
-  // Node
-  const nodeIcon = results.system.node.ok ? chalk.green("OK") : chalk.red("MISSING");
-  console.log(`    Node.js    ${results.system.node.version}  ${nodeIcon}`);
-
-  // FFmpeg
-  if (results.system.ffmpeg.ok) {
-    console.log(
-      `    FFmpeg     ${results.system.ffmpeg.version}  ${chalk.green("OK")}`
-    );
-  } else {
-    console.log(`    FFmpeg     ${chalk.red("NOT FOUND")}  ${chalk.dim("Install: brew install ffmpeg")}`);
-  }
-
-  // Config
-  if (results.system.config.ok) {
-    console.log(`    Config     ${chalk.green("OK")}  ${chalk.dim(results.system.config.path)}`);
-  } else {
-    console.log(
-      `    Config     ${chalk.yellow("NOT SET")}  ${chalk.dim("Run: vibe setup")}`
-    );
-  }
-
-  console.log();
-  console.log(chalk.bold("  API Keys"));
-
-  const configured: string[] = [];
-  const missing: string[] = [];
-
-  for (const [name, info] of Object.entries(results.providers)) {
-    if (info.configured) {
-      configured.push(name);
-      console.log(
-        `    ${chalk.green("OK")}  ${info.envVar.padEnd(24)} ${chalk.dim(info.commands.join(", "))}`
-      );
-    } else {
-      missing.push(name);
-    }
-  }
-
-  if (missing.length > 0) {
-    for (const name of missing) {
-      const info = results.providers[name];
-      console.log(
-        `    ${chalk.red("--")}  ${info.envVar.padEnd(24)} ${chalk.dim(info.commands.join(", "))}`
-      );
-    }
-  }
-
-  // Free commands
-  console.log();
-  console.log(chalk.bold("  No API key needed"));
-  console.log(`    ${chalk.dim(FREE_COMMANDS.join(", "))}`);
-
-  // Summary
-  console.log();
-  const pct = Math.round((results.readyCount / results.totalCount) * 100);
-  const readyColor = pct >= 80 ? chalk.green : pct >= 40 ? chalk.yellow : chalk.red;
-  console.log(
-    `  Ready: ${readyColor(`${results.readyCount}/${results.totalCount}`)} commands (${pct}%)`
-  );
-
-  if (missing.length > 0) {
-    console.log(chalk.dim(`  Run 'vibe setup' to configure more providers.`));
-  }
-  console.log();
-}