@vibeframe/cli 0.27.0

package/src/commands/media.ts

@@ -0,0 +1,177 @@
+import { Command } from "commander";
+import { stat } from "node:fs/promises";
+import { resolve, extname, basename } from "node:path";
+import chalk from "chalk";
+import ora from "ora";
+import * as musicMetadata from "music-metadata";
+
+export const mediaCommand = new Command("media")
+  .description("Media file utilities");
+
+mediaCommand
+  .command("info")
+  .description("Get media file information")
+  .argument("<file>", "Media file path")
+  .action(async (file: string) => {
+    const spinner = ora("Analyzing media...").start();
+
+    try {
+      const filePath = resolve(process.cwd(), file);
+      const ext = extname(filePath).toLowerCase();
+      const fileName = basename(filePath);
+      const fileStat = await stat(filePath);
+
+      const mediaType = detectMediaType(ext);
+
+      spinner.stop();
+
+      console.log();
+      console.log(chalk.bold.cyan("Media Info"));
+      console.log(chalk.dim("─".repeat(50)));
+      console.log(chalk.dim("  File:"), fileName);
+      console.log(chalk.dim("  Path:"), filePath);
+      console.log(chalk.dim("  Size:"), formatFileSize(fileStat.size));
+      console.log(chalk.dim("  Type:"), mediaType);
+
+      if (mediaType === "audio" || mediaType === "video") {
+        try {
+          const metadata = await musicMetadata.parseFile(filePath);
+
+          console.log();
+          console.log(chalk.bold.cyan("Format"));
+          console.log(chalk.dim("─".repeat(50)));
+
+          if (metadata.format.container) {
+            console.log(chalk.dim("  Container:"), metadata.format.container);
+          }
+          if (metadata.format.codec) {
+            console.log(chalk.dim("  Codec:"), metadata.format.codec);
+          }
+          if (metadata.format.duration) {
+            console.log(chalk.dim("  Duration:"), formatDuration(metadata.format.duration));
+          }
+          if (metadata.format.bitrate) {
+            console.log(chalk.dim("  Bitrate:"), formatBitrate(metadata.format.bitrate));
+          }
+          if (metadata.format.sampleRate) {
+            console.log(chalk.dim("  Sample Rate:"), `${metadata.format.sampleRate} Hz`);
+          }
+          if (metadata.format.numberOfChannels) {
+            console.log(chalk.dim("  Channels:"), metadata.format.numberOfChannels);
+          }
+
+          // Video-specific info (if available)
+          if (metadata.format.trackInfo && metadata.format.trackInfo.length > 0) {
+            const videoTrack = metadata.format.trackInfo.find(
+              (t) => (t as Record<string, unknown>).type === "video"
+            ) as Record<string, unknown> | undefined;
+            if (videoTrack) {
+              console.log();
+              console.log(chalk.bold.cyan("Video"));
+              console.log(chalk.dim("─".repeat(50)));
+              if (videoTrack.width && videoTrack.height) {
+                console.log(chalk.dim("  Resolution:"), `${videoTrack.width}x${videoTrack.height}`);
+              }
+              if (videoTrack.frameRate) {
+                console.log(chalk.dim("  Frame Rate:"), `${videoTrack.frameRate} fps`);
+              }
+            }
+          }
+
+          // Audio tags
+          if (metadata.common && Object.keys(metadata.common).length > 0) {
+            const { title, artist, album, year, genre } = metadata.common;
+            if (title || artist || album) {
+              console.log();
+              console.log(chalk.bold.cyan("Tags"));
+              console.log(chalk.dim("─".repeat(50)));
+              if (title) console.log(chalk.dim("  Title:"), title);
+              if (artist) console.log(chalk.dim("  Artist:"), artist);
+              if (album) console.log(chalk.dim("  Album:"), album);
+              if (year) console.log(chalk.dim("  Year:"), year);
+              if (genre && genre.length > 0) console.log(chalk.dim("  Genre:"), genre.join(", "));
+            }
+          }
+        } catch (metadataError) {
+          console.log();
+          console.log(chalk.yellow("  Could not parse detailed metadata"));
+        }
+      }
+
+      if (mediaType === "image") {
+        console.log();
+        console.log(chalk.dim("  (Image metadata parsing not yet supported)"));
+      }
+
+      console.log();
+    } catch (error) {
+      spinner.fail(chalk.red("Failed to analyze media"));
+      if (error instanceof Error) {
+        console.error(chalk.red(error.message));
+      }
+      process.exit(1);
+    }
+  });
+
+mediaCommand
+  .command("duration")
+  .description("Get media duration in seconds (for scripting)")
+  .argument("<file>", "Media file path")
+  .action(async (file: string) => {
+    try {
+      const filePath = resolve(process.cwd(), file);
+      const metadata = await musicMetadata.parseFile(filePath);
+
+      if (metadata.format.duration) {
+        console.log(metadata.format.duration.toFixed(3));
+      } else {
+        console.error("Could not determine duration");
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error("Failed to get duration");
+      process.exit(1);
+    }
+  });
+
+function detectMediaType(ext: string): "video" | "audio" | "image" | "unknown" {
+  const videoExts = [".mp4", ".mov", ".webm", ".avi", ".mkv", ".m4v", ".flv", ".wmv"];
+  const audioExts = [".mp3", ".wav", ".ogg", ".m4a", ".aac", ".flac", ".wma", ".aiff"];
+  const imageExts = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".svg", ".tiff"];
+
+  if (videoExts.includes(ext)) return "video";
+  if (audioExts.includes(ext)) return "audio";
+  if (imageExts.includes(ext)) return "image";
+  return "unknown";
+}
+
+function formatFileSize(bytes: number): string {
+  const units = ["B", "KB", "MB", "GB"];
+  let size = bytes;
+  let unitIndex = 0;
+
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+
+  return `${size.toFixed(2)} ${units[unitIndex]}`;
+}
+
+function formatDuration(seconds: number): string {
+  const hrs = Math.floor(seconds / 3600);
+  const mins = Math.floor((seconds % 3600) / 60);
+  const secs = (seconds % 60).toFixed(2);
+
+  if (hrs > 0) {
+    return `${hrs}:${mins.toString().padStart(2, "0")}:${secs.padStart(5, "0")}`;
+  }
+  return `${mins}:${secs.padStart(5, "0")}`;
+}
+
+function formatBitrate(bps: number): string {
+  if (bps >= 1000000) {
+    return `${(bps / 1000000).toFixed(2)} Mbps`;
+  }
+  return `${(bps / 1000).toFixed(0)} kbps`;
+}

package/src/commands/output.ts

@@ -0,0 +1,142 @@
+/**
+ * @module output
+ * @description Shared output helper for --json structured output support.
+ */
+
+import chalk from "chalk";
+import ora from "ora";
+
+// ── Exit Codes ───────────────────────────────────────────────────────────
+
+export enum ExitCode {
+  SUCCESS = 0,
+  GENERAL = 1,
+  USAGE = 2,
+  NOT_FOUND = 3,
+  AUTH = 4,
+  API_ERROR = 5,
+  NETWORK = 6,
+}
+
+// ── Structured Errors ────────────────────────────────────────────────────
+
+export interface StructuredError {
+  success: false;
+  error: string;
+  code: string;
+  exitCode: ExitCode;
+  suggestion?: string;
+  retryable: boolean;
+}
+
+export function usageError(msg: string, suggestion?: string): StructuredError {
+  return { success: false, error: msg, code: "USAGE_ERROR", exitCode: ExitCode.USAGE, suggestion, retryable: false };
+}
+
+export function authError(envVar: string, provider: string): StructuredError {
+  return {
+    success: false,
+    error: `${provider} API key required.`,
+    code: "API_KEY_MISSING",
+    exitCode: ExitCode.AUTH,
+    suggestion: `Set ${envVar} in .env, or run: vibe setup`,
+    retryable: false,
+  };
+}
+
+export function apiError(msg: string, retryable = false): StructuredError {
+  return { success: false, error: msg, code: "API_ERROR", exitCode: ExitCode.API_ERROR, suggestion: retryable ? "Retry the command." : undefined, retryable };
+}
+
+export function notFoundError(path: string): StructuredError {
+  return { success: false, error: `File not found: ${path}`, code: "NOT_FOUND", exitCode: ExitCode.NOT_FOUND, retryable: false };
+}
+
+export function networkError(msg: string): StructuredError {
+  return { success: false, error: msg, code: "NETWORK_ERROR", exitCode: ExitCode.NETWORK, suggestion: "Check your internet connection and retry.", retryable: true };
+}
+
+export function generalError(msg: string, suggestion?: string): StructuredError {
+  return { success: false, error: msg, code: "ERROR", exitCode: ExitCode.GENERAL, suggestion, retryable: false };
+}
+
+/** Output structured error then exit */
+export function exitWithError(err: StructuredError): never {
+  if (isJsonMode()) {
+    console.log(JSON.stringify(err, null, 2));
+  } else {
+    console.error(chalk.red(`\n  ${err.error}`));
+    if (err.suggestion) {
+      console.error(chalk.dim(`  ${err.suggestion}`));
+    }
+    console.error();
+  }
+  process.exit(err.exitCode);
+}
+
+// ── Output Modes ─────────────────────────────────────────────────────────
+
+/** Check if --json flag is active */
+export function isJsonMode(): boolean {
+  return process.env.VIBE_JSON_OUTPUT === "1";
+}
+
+/** Check if --quiet flag is active */
+export function isQuietMode(): boolean {
+  return process.env.VIBE_QUIET_OUTPUT === "1";
+}
+
+/** Output result - JSON mode outputs JSON, quiet mode outputs primary value only */
+export function outputResult(result: Record<string, unknown>): void {
+  if (isJsonMode()) {
+    // Apply --fields filtering if specified
+    const fields = process.env.VIBE_OUTPUT_FIELDS;
+    if (fields) {
+      const keys = fields.split(",").map((k) => k.trim());
+      const filtered: Record<string, unknown> = {};
+      for (const key of keys) {
+        if (key in result) filtered[key] = result[key];
+      }
+      // Always include success
+      if ("success" in result) filtered.success = result.success;
+      console.log(JSON.stringify(filtered, null, 2));
+    } else {
+      console.log(JSON.stringify(result, null, 2));
+    }
+  } else if (isQuietMode()) {
+    // In quiet mode, output the primary value only (path, url, or id)
+    const primary = result.output ?? result.path ?? result.url ?? result.id ?? result.result;
+    if (primary !== undefined) console.log(String(primary));
+  }
+}
+
+/** Wrap console output - suppressed in JSON/quiet mode */
+export function log(...args: unknown[]): void {
+  if (!isJsonMode() && !isQuietMode()) {
+    console.log(...args);
+  }
+}
+
+/** Create a spinner that is silent in JSON/quiet mode */
+export function spinner(text: string): ReturnType<typeof ora> {
+  if (isJsonMode() || isQuietMode()) {
+    return ora({ text, isSilent: true });
+  }
+  return ora(text);
+}
+
+/** Suggest next steps - only in human interactive mode */
+export function suggestNext(tip: string): void {
+  if (!isJsonMode() && !isQuietMode() && process.stdout.isTTY) {
+    console.log(chalk.dim(`\n  Tip: ${tip}`));
+  }
+}
+
+/** Output an error - always outputs (JSON mode writes to stdout as JSON) */
+export function outputError(error: string, details?: Record<string, unknown>): void {
+  if (isJsonMode()) {
+    console.log(JSON.stringify({ success: false, error, ...details }, null, 2));
+  } else {
+    console.error(error);
+  }
+}