@vibeframe/cli 0.27.0 → 0.30.0

package/src/utils/api-key.ts

@@ -1,247 +0,0 @@
-import { createInterface } from "node:readline";
-import { readFile, writeFile, access } from "node:fs/promises";
-import { resolve } from "node:path";
-import { config } from "dotenv";
-import chalk from "chalk";
-import { getApiKeyFromConfig } from "../config/index.js";
-
-/**
- * Load environment variables from .env files.
- * Priority: CWD .env (project-scoped) > monorepo root .env (development)
- * Later loads don't override earlier values, so CWD takes precedence.
- */
-export function loadEnv(): void {
-  // 1. Load from current working directory (project-scoped, highest priority)
-  config({ path: resolve(process.cwd(), ".env"), debug: false });
-
-  // 2. Load from monorepo root if in development (won't override existing vars)
-  const monorepoRoot = findMonorepoRoot();
-  if (monorepoRoot && monorepoRoot !== process.cwd()) {
-    config({ path: resolve(monorepoRoot, ".env"), debug: false });
-  }
-}
-
-// Find monorepo root for development environments
-function findMonorepoRoot(): string | null {
-  let dir = process.cwd();
-  while (dir !== "/") {
-    try {
-      require.resolve(resolve(dir, "pnpm-workspace.yaml"));
-      return dir;
-    } catch {
-      dir = resolve(dir, "..");
-    }
-  }
-  return null;
-}
-
-/**
- * Prompt user for input (hidden for API keys)
- */
-async function prompt(question: string, hidden = false): Promise<string> {
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-
-  return new Promise((resolve) => {
-    // For hidden input, we need to handle it differently
-    if (hidden && process.stdin.isTTY) {
-      process.stdout.write(question);
-
-      let input = "";
-      process.stdin.setRawMode(true);
-      process.stdin.resume();
-      process.stdin.setEncoding("utf8");
-
-      const onData = (char: string) => {
-        if (char === "\n" || char === "\r" || char === "\u0004") {
-          process.stdin.setRawMode(false);
-          process.stdin.pause();
-          process.stdin.removeListener("data", onData);
-          process.stdout.write("\n");
-          rl.close();
-          resolve(input);
-        } else if (char === "\u0003") {
-          // Ctrl+C
-          process.exit(1);
-        } else if (char === "\u007F" || char === "\b") {
-          // Backspace
-          if (input.length > 0) {
-            input = input.slice(0, -1);
-          }
-        } else {
-          input += char;
-        }
-      };
-
-      process.stdin.on("data", onData);
-    } else {
-      rl.question(question, (answer) => {
-        rl.close();
-        resolve(answer);
-      });
-    }
-  });
-}
-
-/**
- * Get API key from config, environment, or prompt
- */
-export async function getApiKey(
-  envVar: string,
-  providerName: string,
-  optionValue?: string
-): Promise<string | null> {
-  // 1. Check command line option
-  if (optionValue) {
-    return optionValue;
-  }
-
-  // 2. Check ~/.vibeframe/config.yaml
-  // Map env var to provider key
-  const providerKeyMap: Record<string, string> = {
-    ANTHROPIC_API_KEY: "anthropic",
-    OPENAI_API_KEY: "openai",
-    GOOGLE_API_KEY: "google",
-    ELEVENLABS_API_KEY: "elevenlabs",
-    RUNWAY_API_SECRET: "runway",
-    KLING_API_KEY: "kling",
-    IMGBB_API_KEY: "imgbb",
-    REPLICATE_API_TOKEN: "replicate",
-  };
-  const providerKey = providerKeyMap[envVar];
-  if (providerKey) {
-    const configKey = await getApiKeyFromConfig(providerKey);
-    if (configKey) {
-      return configKey;
-    }
-  }
-
-  // 3. Load .env and check environment
-  loadEnv();
-  const envValue = process.env[envVar];
-  if (envValue) {
-    return envValue;
-  }
-
-  // 4. Check if running in TTY (interactive terminal)
-  if (!process.stdin.isTTY) {
-    return null;
-  }
-
-  // 5. Prompt for API key
-  console.log();
-  console.log(chalk.yellow(`${providerName} API key not found.`));
-  console.log(chalk.dim(`Set ${envVar} in .env (current directory), run 'vibe setup', or enter below.`));
-  console.log();
-
-  const apiKey = await prompt(chalk.cyan(`Enter ${providerName} API key: `), true);
-
-  if (!apiKey || apiKey.trim() === "") {
-    return null;
-  }
-
-  // 6. Ask if user wants to save to .env
-  const save = await prompt(chalk.cyan("Save to .env for future use? (y/N): "));
-
-  if (save.toLowerCase() === "y" || save.toLowerCase() === "yes") {
-    await saveApiKeyToEnv(envVar, apiKey.trim());
-    console.log(chalk.green("API key saved to .env"));
-  }
-
-  return apiKey.trim();
-}
-
-/**
- * Error thrown when a required API key is missing (non-interactive mode)
- */
-export class ApiKeyError extends Error {
-  public envVar: string;
-  public providerName: string;
-
-  constructor(envVar: string, providerName: string) {
-    super(
-      `${providerName} API key required.\n` +
-        `  Set ${envVar} in .env, or run: vibe setup`
-    );
-    this.name = "ApiKeyError";
-    this.envVar = envVar;
-    this.providerName = providerName;
-  }
-
-  toStructured(): {
-    success: false;
-    error: string;
-    code: string;
-    exitCode: number;
-    suggestion: string;
-    retryable: false;
-  } {
-    return {
-      success: false as const,
-      error: `${this.providerName} API key required.`,
-      code: "API_KEY_MISSING",
-      exitCode: 4,
-      suggestion: `Set ${this.envVar} in .env, or run: vibe setup`,
-      retryable: false as const,
-    };
-  }
-}
-
-/**
- * Check if an API key is available without prompting or side effects.
- */
-export function hasApiKey(envVar: string): boolean {
-  loadEnv();
-  if (process.env[envVar]) return true;
-  const key = getApiKeyFromConfig(envVar);
-  return !!key;
-}
-
-/**
- * Get API key or throw ApiKeyError if not found.
- * Use this instead of getApiKey() + manual null check.
- */
-export async function requireApiKey(
-  envVar: string,
-  providerName: string,
-  cliOverride?: string
-): Promise<string> {
-  const key = await getApiKey(envVar, providerName, cliOverride);
-  if (!key) {
-    throw new ApiKeyError(envVar, providerName);
-  }
-  return key;
-}
-
-/**
- * Save API key to .env file
- */
-async function saveApiKeyToEnv(envVar: string, apiKey: string): Promise<void> {
-  const envPath = resolve(process.cwd(), ".env");
-
-  let content = "";
-
-  try {
-    await access(envPath);
-    content = await readFile(envPath, "utf-8");
-  } catch {
-    // File doesn't exist, will create new
-  }
-
-  // Check if variable already exists
-  const regex = new RegExp(`^${envVar}=.*$`, "m");
-  if (regex.test(content)) {
-    // Replace existing
-    content = content.replace(regex, `${envVar}=${apiKey}`);
-  } else {
-    // Append new
-    if (content && !content.endsWith("\n")) {
-      content += "\n";
-    }
-    content += `${envVar}=${apiKey}\n`;
-  }
-
-  await writeFile(envPath, content, "utf-8");
-}

package/src/utils/audio.ts

@@ -1,83 +0,0 @@
-import { execSafe, ffprobeDuration } from "./exec-safe.js";
-
-/**
- * Get the duration of an audio file using ffprobe
- * @param filePath - Path to the audio file
- * @returns Duration in seconds
- */
-export async function getAudioDuration(filePath: string): Promise<number> {
-  try {
-    return await ffprobeDuration(filePath);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to get audio duration: ${message}`);
-  }
-}
-
-/**
- * Get the duration of a video file using ffprobe
- * @param filePath - Path to the video file
- * @returns Duration in seconds
- */
-export async function getVideoDuration(filePath: string): Promise<number> {
-  try {
-    return await ffprobeDuration(filePath);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to get video duration: ${message}`);
-  }
-}
-
-/**
- * Extend a video naturally to match target duration using progressive techniques.
- * Uses slowdown, frame interpolation, and freeze frames based on extension ratio.
- *
- * @param videoPath - Path to the source video
- * @param targetDuration - Target duration in seconds
- * @param outputPath - Path for the extended video output
- * @returns Promise that resolves when extension is complete
- */
-export async function extendVideoNaturally(
-  videoPath: string,
-  targetDuration: number,
-  outputPath: string
-): Promise<void> {
-  const videoDuration = await getVideoDuration(videoPath);
-  const ratio = targetDuration / videoDuration;
-
-  if (ratio <= 1.0) {
-    // No extension needed, just copy
-    const { copyFile } = await import("node:fs/promises");
-    await copyFile(videoPath, outputPath);
-    return;
-  }
-
-  if (ratio <= 1.15) {
-    // 0-15% extension: Simple slowdown using setpts
-    // setpts factor = 1/ratio to slow down the video
-    const slowFactor = (1 / ratio).toFixed(4);
-    await execSafe("ffmpeg", ["-y", "-i", videoPath, "-filter:v", `setpts=${slowFactor}*PTS`, "-an", outputPath]);
-  } else if (ratio <= 1.4) {
-    // 15-40% extension: Frame interpolation + slowdown
-    // minterpolate creates smooth slow-motion effect
-    const slowFactor = (1 / ratio).toFixed(4);
-    await execSafe("ffmpeg", ["-y", "-i", videoPath, "-filter:v", `minterpolate=fps=60:mi_mode=mci,setpts=${slowFactor}*PTS`, "-an", outputPath]);
-  } else {
-    // 40%+ extension: Slowdown to 0.7x speed + freeze last frame for remainder
-    // First, slow down to get ~43% extension
-    const slowRatio = 0.7;
-    const slowedDuration = videoDuration / slowRatio;
-    const freezeDuration = targetDuration - slowedDuration;
-
-    if (freezeDuration <= 0) {
-      // Can achieve target with slowdown alone
-      const slowFactor = (1 / ratio).toFixed(4);
-      await execSafe("ffmpeg", ["-y", "-i", videoPath, "-filter:v", `minterpolate=fps=60:mi_mode=mci,setpts=${slowFactor}*PTS`, "-an", outputPath]);
-    } else {
-      // Need slowdown + freeze frame
-      // Use tpad to extend the last frame
-      const slowFactor = (1 / slowRatio).toFixed(4); // ~1.43 for 0.7x speed
-      await execSafe("ffmpeg", ["-y", "-i", videoPath, "-filter:v", `setpts=${slowFactor}*PTS,tpad=stop_mode=clone:stop_duration=${freezeDuration.toFixed(2)}`, "-an", outputPath]);
-    }
-  }
-}

package/src/utils/exec-safe.ts

@@ -1,75 +0,0 @@
-import { execFile, execFileSync } from "node:child_process";
-import { promisify } from "node:util";
-
-const execFileAsync = promisify(execFile);
-
-/** Safe async exec — no shell, args as array */
-export async function execSafe(
-  cmd: string,
-  args: string[],
-  options?: { timeout?: number; maxBuffer?: number },
-): Promise<{ stdout: string; stderr: string }> {
-  return execFileAsync(cmd, args, {
-    timeout: options?.timeout,
-    maxBuffer: options?.maxBuffer ?? 50 * 1024 * 1024,
-  });
-}
-
-/** Safe sync exec — no shell, args as array */
-export function execSafeSync(
-  cmd: string,
-  args: string[],
-  options?: { stdio?: "pipe" | "ignore" },
-): string {
-  return execFileSync(cmd, args, {
-    encoding: "utf-8",
-    stdio: options?.stdio ?? "pipe",
-  });
-}
-
-/** Shorthand: ffprobe duration query */
-export async function ffprobeDuration(filePath: string): Promise<number> {
-  const { stdout } = await execSafe("ffprobe", [
-    "-v",
-    "error",
-    "-show_entries",
-    "format=duration",
-    "-of",
-    "default=noprint_wrappers=1:nokey=1",
-    filePath,
-  ]);
-  const duration = parseFloat(stdout.trim());
-  if (isNaN(duration)) throw new Error(`Invalid duration: ${stdout}`);
-  return duration;
-}
-
-/** Shorthand: ffprobe video dimensions */
-export async function ffprobeVideoSize(
-  filePath: string,
-): Promise<{ width: number; height: number }> {
-  const { stdout } = await execSafe("ffprobe", [
-    "-v",
-    "error",
-    "-select_streams",
-    "v:0",
-    "-show_entries",
-    "stream=width,height",
-    "-of",
-    "csv=p=0:s=x",
-    filePath,
-  ]);
-  const [w, h] = stdout.trim().split("x").map(Number);
-  if (isNaN(w) || isNaN(h))
-    throw new Error(`Invalid dimensions: ${stdout.trim()}`);
-  return { width: w, height: h };
-}
-
-/** Shorthand: check if a command exists */
-export function commandExists(cmd: string): boolean {
-  try {
-    execFileSync("which", [cmd], { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}

package/src/utils/first-run.ts

@@ -1,52 +0,0 @@
-/**
- * First-run detection for VibeFrame CLI
- * Shows a welcome banner when user has never configured the tool
- */
-
-import { access } from "node:fs/promises";
-import chalk from "chalk";
-import { CONFIG_PATH } from "../config/index.js";
-import { PROVIDER_ENV_VARS } from "../config/schema.js";
-import { loadEnv } from "./api-key.js";
-
-/**
- * Check if this is the user's first run (no config and no env vars set)
- */
-export async function isFirstRun(): Promise<boolean> {
-  // Check if config file exists
-  try {
-    await access(CONFIG_PATH);
-    return false;
-  } catch {
-    // Config doesn't exist, check env vars
-  }
-
-  // Load .env files
-  loadEnv();
-
-  // Check if any provider API key is set in environment
-  for (const envVar of Object.values(PROVIDER_ENV_VARS)) {
-    if (process.env[envVar]) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/**
- * Show a friendly welcome banner for first-time users
- */
-export function showFirstRunBanner(): void {
-  console.log();
-  console.log(chalk.cyan.bold("  Welcome to VibeFrame!"));
-  console.log();
-  console.log(`  Get started:`);
-  console.log(`    ${chalk.green("vibe setup")}        Configure API keys ${chalk.dim("(1 min)")}`);
-  console.log(`    ${chalk.green("vibe doctor")}       Check what's ready`);
-  console.log(`    ${chalk.green("vibe --help")}       See all commands`);
-  console.log();
-  console.log(chalk.dim("  Tip: some commands work without API keys (silence-cut, fade, noise-reduce)."));
-  console.log(chalk.dim("  Run 'vibe doctor' to see everything available."));
-  console.log();
-}

package/src/utils/provider-resolver.ts

@@ -1,56 +0,0 @@
-/**
- * Smart provider auto-resolution
- * Picks the best available provider based on configured API keys
- */
-
-import { hasApiKey } from "./api-key.js";
-
-interface ProviderCandidate {
-  name: string;
-  envVar: string;
-  label: string;
-}
-
-const IMAGE_PROVIDERS: ProviderCandidate[] = [
-  { name: "gemini", envVar: "GOOGLE_API_KEY", label: "Gemini" },
-  { name: "openai", envVar: "OPENAI_API_KEY", label: "OpenAI" },
-  { name: "grok", envVar: "XAI_API_KEY", label: "Grok" },
-];
-
-const VIDEO_PROVIDERS: ProviderCandidate[] = [
-  { name: "grok", envVar: "XAI_API_KEY", label: "Grok" },
-  { name: "veo", envVar: "GOOGLE_API_KEY", label: "Veo" },
-  { name: "kling", envVar: "KLING_API_KEY", label: "Kling" },
-  { name: "runway", envVar: "RUNWAY_API_SECRET", label: "Runway" },
-];
-
-const SPEECH_PROVIDERS: ProviderCandidate[] = [
-  { name: "elevenlabs", envVar: "ELEVENLABS_API_KEY", label: "ElevenLabs" },
-];
-
-const PROVIDER_MAP: Record<string, ProviderCandidate[]> = {
-  image: IMAGE_PROVIDERS,
-  video: VIDEO_PROVIDERS,
-  speech: SPEECH_PROVIDERS,
-};
-
-/**
- * Resolve the best available provider for a given category.
- * Uses hasApiKey() for side-effect-free checking (no prompts).
- * Returns { name, label } of the first provider with a configured API key,
- * or null if none are available.
- */
-export function resolveProvider(
-  category: "image" | "video" | "speech"
-): { name: string; label: string } | null {
-  const candidates = PROVIDER_MAP[category];
-  if (!candidates) return null;
-
-  for (const candidate of candidates) {
-    if (hasApiKey(candidate.envVar)) {
-      return { name: candidate.name, label: candidate.label };
-    }
-  }
-
-  return null;
-}