@vibeframe/cli 0.115.6 → 0.115.7

package/dist/commands/_shared/edit/jump-cut.d.ts

@@ -52,8 +52,8 @@ export interface JumpCutResult {
 /** Default set of filler words detected by jump-cut. */
 export declare const DEFAULT_FILLER_WORDS: string[];
 /**
- * Transcribe audio with word-level timestamps using Whisper API directly.
- * Uses timestamp_granularities[]=word for filler detection.
+ * Transcribe audio with word-level timestamps (Whisper through the
+ * transcription contract) for filler detection. Throws on failure.
  */
 export declare function transcribeWithWords(audioPath: string, apiKey: string, language?: string): Promise<{
     words: {

package/dist/commands/_shared/image-jobs.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The CLI side of the image contract: open an image provider by name with
+ * the user's key, read input images, and save results. Image commands,
+ * tools, scenes, and builds go through here instead of branching on
+ * provider names.
+ */
+import { type ImageGenerator, type ImageInput } from "@vibeframe/ai-providers";
+/** Env var holding each image provider's key. */
+export declare const IMAGE_PROVIDER_ENV: Readonly<Record<string, string>>;
+/** Display names for spinners and messages. */
+export declare const IMAGE_PROVIDER_LABELS: Readonly<Record<string, string>>;
+/** An image generator for `provider`, with the given key or the configured one. */
+export declare function openImageGenerator(provider: string, apiKey?: string): Promise<ImageGenerator>;
+/** A local image file as contract input. */
+export declare function readImageInput(path: string): Promise<ImageInput>;
+/** Save image bytes to `output` (relative to cwd), converting to the extension's format. */
+export declare function saveImage(output: string, bytes: Uint8Array): Promise<string>;
+/** The catalog label for a model ID, for human output. */
+export declare function imageModelLabel(provider: string, modelId: string): string;
+/** CLI quality words to the contract's: `standard`/`hd` are the old OpenAI names. */
+export declare function contractQuality(quality?: string): "low" | "medium" | "high" | undefined;

package/dist/commands/_shared/openai-image.d.ts

@@ -1,36 +1,10 @@
 /**
  * @module _shared/openai-image
  *
- * Shared OpenAI `generateImage` helper for `vibe ai image` and
- * `vibe generate image`. Both commands had their own near-identical
- * provider initialisation + model-alias parsing + result construction.
- * v0.52.0 added gpt-image-2 wiring to `ai-image.ts` only and
- * `vibe generate image -m 2` silently fell back to gpt-image-1.5 — the
- * duplication guarantees a recurrence next time the OpenAI image flow
- * is touched.
- *
- * Each top-level command keeps its own CLI wiring and output formatting;
- * this helper owns just the API call + label derivation.
- *
- * See issue #58.
+ * OpenAI image model alias resolution, used by image cost estimates.
+ * Generation itself goes through the image contract (`executeImageGenerate`).
  */
-import type { GPTImageModel, ImageResult } from "@vibeframe/ai-providers";
-/** Subset of CLI options consumed by the helper. */
-export interface OpenAIImageHelperOptions {
-    model?: string;
-    size?: string;
-    quality?: string;
-    style?: string;
-    /** Stringified count from commander; parsed inside the helper. */
-    count?: string;
-}
-export interface OpenAIImageHelperResult {
-    result: ImageResult;
-    /** Resolved model id passed to the API. */
-    openaiModel: GPTImageModel;
-    /** Human-friendly label for spinner / success output. */
-    modelLabel: string;
-}
+import type { GPTImageModel } from "@vibeframe/ai-providers";
 /**
  * Resolve the user-supplied model alias to the API id + display label, from
  * the model catalog. Unknown or empty aliases resolve to the default model.
@@ -41,10 +15,3 @@ export declare function resolveOpenAIImageModel(modelAlias?: string): {
     openaiModel: GPTImageModel;
     modelLabel: string;
 };
-/**
- * Run an OpenAI image generation. Caller owns: api-key acquisition,
- * spinner lifecycle, output formatting (JSON vs human), and file save.
- */
-export declare function executeOpenAIImageGenerate(prompt: string, options: OpenAIImageHelperOptions, ctx: {
-    apiKey: string;
-}): Promise<OpenAIImageHelperResult>;

package/dist/commands/_shared/transcription.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The CLI side of the transcription contract: transcribe an audio file on
+ * disk and get the result shape the commands already use. Every command
+ * that needs a transcript (audio, captions, highlights, jump-cut, scene
+ * narration) goes through here.
+ */
+import { type ProviderErrorKind, type TranscriptGranularity, type TranscriptResult } from "@vibeframe/ai-providers";
+export interface TranscribeFileOptions {
+    apiKey: string;
+    language?: string;
+    granularity?: TranscriptGranularity;
+}
+/** Transcribe `path` with Whisper. Failures come back as `status: "failed"` with an error kind. */
+export declare function transcribeAudioFile(path: string, options: TranscribeFileOptions): Promise<TranscriptResult & {
+    errorKind?: ProviderErrorKind;
+}>;

package/dist/commands/_shared/translate-texts.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Translate a list of short texts (subtitle cues, dub segments) with Claude
+ * or OpenAI, in batches, keeping each text's position. Lines come back
+ * tagged `[N]` and are matched by that index, so a skipped or merged line
+ * cannot shift every later translation; anything missing keeps its source
+ * text.
+ */
+import { type ProviderErrorKind } from "@vibeframe/ai-providers";
+export interface TranslateTextsOptions {
+    /** Target language name or code ("Korean", "ko"). */
+    targetLanguage: string;
+    sourceLanguage?: string;
+    /** Default: Claude when ANTHROPIC_API_KEY is set, else OpenAI. */
+    provider?: "claude" | "openai";
+    apiKey?: string;
+    /** Texts per request. Default 30. */
+    batchSize?: number;
+}
+export type TranslateTextsResult = {
+    success: true;
+    texts: string[];
+    provider: "claude" | "openai";
+} | {
+    success: false;
+    error: string;
+    errorKind?: ProviderErrorKind;
+};
+/** "ko" → "Korean"; names pass through. */
+export declare function languageName(code: string): string;
+export declare function translateTexts(texts: string[], options: TranslateTextsOptions): Promise<TranslateTextsResult>;

package/dist/commands/_shared/translate-texts.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/_shared/tts-resolve.d.ts

@@ -18,7 +18,7 @@
  * to branch on provider id. All providers already return the same
  * `{ success, audioBuffer, error?, characterCount? }` result.
  */
-import type { KokoroLoadEvent } from "@vibeframe/ai-providers";
+import type { KokoroLoadEvent, ProviderErrorKind } from "@vibeframe/ai-providers";
 /** TTS providers VibeFrame can route to. `"auto"` picks based on key availability. */
 export type TtsProviderName = "auto" | "elevenlabs" | "openai" | "kokoro";
 /** Concrete provider id surfaced in result metadata. Never `"auto"`. */
@@ -33,6 +33,8 @@ export interface TtsCallOptions {
     voice?: string;
     /** Speaking speed multiplier (Kokoro: 0.5–2; ElevenLabs: 0.7–1.2). */
     speed?: number;
+    /** Catalog model ID or alias for the resolved provider. */
+    model?: string;
     /** Cold-start progress callback (Kokoro only — fires on first ~330MB load). */
     onProgress?: (event: KokoroLoadEvent) => void;
 }
@@ -41,7 +43,11 @@ export interface TtsCallResult {
     success: boolean;
     audioBuffer?: Buffer;
     error?: string;
+    /** Why the provider failed (`auth`, `quota`, `invalid-request`, ...). */
+    errorKind?: ProviderErrorKind;
     characterCount?: number;
+    /** The catalog model that spoke it. */
+    model?: string;
 }
 /** Synthesise speech from text. Provider-specific implementation lives behind this. */
 export type TtsCallable = (text: string, options?: TtsCallOptions) => Promise<TtsCallResult>;

package/dist/commands/ai-audio.d.ts

@@ -12,6 +12,7 @@
  *
  * @see MODELS.md for AI model configuration
  */
+import type { ProviderErrorKind } from "@vibeframe/ai-providers";
 export interface TranscribeOptions {
     audioPath: string;
     language?: string;
@@ -29,7 +30,10 @@ export interface TranscribeResult {
     }>;
     detectedLanguage?: string;
     outputPath?: string;
+    /** Subtitle format written to `outputPath` (json, srt, vtt). */
+    format?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeTranscribe(options: TranscribeOptions): Promise<TranscribeResult>;
 export interface IsolateOptions {
@@ -41,6 +45,7 @@ export interface IsolateResult {
     success: boolean;
     outputPath?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeIsolate(options: IsolateOptions): Promise<IsolateResult>;
 export interface VoiceCloneOptions {
@@ -56,13 +61,18 @@ export interface VoiceCloneResult {
     voiceId?: string;
     name?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeVoiceClone(options: VoiceCloneOptions): Promise<VoiceCloneResult>;
 export interface DubOptions {
     mediaPath: string;
+    /** Target language code or name ("ko", "Spanish"). */
     language: string;
     source?: string;
+    /** Voice for the chosen TTS provider. */
     voice?: string;
+    /** TTS provider: auto (default), elevenlabs, openai, kokoro. */
+    tts?: string;
     analyzeOnly?: boolean;
     output?: string;
 }
@@ -72,8 +82,22 @@ export interface DubResult {
     sourceLanguage?: string;
     targetLanguage?: string;
     segmentCount?: number;
+    /** Each segment's timing with its original and translated text. */
+    segments?: Array<{
+        startTime: number;
+        endTime: number;
+        original: string;
+        translated: string;
+    }>;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
+/**
+ * Dub speech to another language: transcribe (Whisper), translate (Claude,
+ * or OpenAI without an Anthropic key), speak each segment (any TTS
+ * provider), and place each line at its segment's start time, speeding up
+ * lines that would overrun their slot.
+ */
 export declare function executeDub(options: DubOptions): Promise<DubResult>;
 export interface DuckOptions {
     musicPath: string;

package/dist/commands/ai-image.d.ts

@@ -12,48 +12,66 @@
  *
  * @see MODELS.md for AI model configuration
  */
+import { type ProviderErrorKind } from "@vibeframe/ai-providers";
 export interface ImageGenerateOptions {
     prompt: string;
+    /** Default: the configured or first available image provider. */
     provider?: string;
     output?: string;
+    /** Explicit OpenAI size; otherwise the ratio picks one. */
     size?: string;
     ratio?: string;
     quality?: string;
-    style?: string;
+    /** Gemini "1K"/"2K"/"4K", Grok "1k"/"2k". */
+    resolution?: string;
     count?: number;
     model?: string;
     apiKey?: string;
 }
 export interface ImageGenerateResult {
     success: boolean;
+    /** Where the first image was saved. */
     outputPath?: string;
+    /** Every saved image: `out.png`, then `out-2.png`, `out-3.png`, ... */
+    outputPaths?: string[];
     images?: Array<{
-        url?: string;
-        base64?: string;
-        mimeType?: string;
+        base64: string;
+        mimeType: string;
         revisedPrompt?: string;
     }>;
     provider?: string;
     model?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeImageGenerate(options: ImageGenerateOptions): Promise<ImageGenerateResult>;
-export interface GeminiEditOptions {
+export interface ImageEditOptions {
     imagePaths: string[];
     prompt: string;
+    /** Default: gemini. */
+    provider?: string;
     output?: string;
     model?: string;
     ratio?: string;
     resolution?: string;
+    quality?: string;
     apiKey?: string;
 }
-export interface GeminiEditResult {
+export interface ImageEditResult {
     success: boolean;
     outputPath?: string;
+    provider?: string;
     model?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
-export declare function executeGeminiEdit(options: GeminiEditOptions): Promise<GeminiEditResult>;
+export declare function executeImageEdit(options: ImageEditOptions): Promise<ImageEditResult>;
+/** @deprecated Use `executeImageEdit`; kept for callers that predate other edit providers. */
+export type GeminiEditOptions = Omit<ImageEditOptions, "provider">;
+/** @deprecated Use `executeImageEdit`. */
+export type GeminiEditResult = ImageEditResult;
+/** @deprecated Use `executeImageEdit`. */
+export declare function executeGeminiEdit(options: GeminiEditOptions): Promise<ImageEditResult>;
 export interface ThumbnailBestFrameOptions {
     videoPath: string;
     outputPath: string;

package/dist/commands/generate/image.d.ts

@@ -1,8 +1,9 @@
 /**
  * @module generate/image
- * @description `vibe generate image` (alias `img`) — multi-provider image
- * generation. OpenAI gpt-image-2.5, Gemini Nano Banana, Grok, Runway. Split
- * out of `generate.ts` in v0.69 (Plan G Phase 2).
+ * @description `vibe generate image` (alias `img`) — image generation on
+ * OpenAI GPT Image, Gemini Nano Banana, or Grok Imagine. Validation,
+ * provider choice, and the dry run live here; generation is
+ * `executeImageGenerate`, the same executor the MCP tool and pipelines use.
  */
 import type { Command } from "commander";
 export declare function registerImageCommand(parent: Command): void;

package/dist/commands/generate/music.d.ts

@@ -5,6 +5,7 @@
  * conditioning). Split out of `generate.ts` in v0.69 (Plan G Phase 2).
  */
 import type { Command } from "commander";
+import { type ProviderErrorKind } from "@vibeframe/ai-providers";
 export interface ExecuteMusicOptions {
     prompt: string;
     output?: string;
@@ -12,6 +13,9 @@ export interface ExecuteMusicOptions {
     provider?: "elevenlabs" | "replicate";
     instrumental?: boolean;
     wait?: boolean;
+    /** Replicate MusicGen variant: large, stereo-large, melody-large, stereo-melody-large. */
+    model?: string;
+    apiKey?: string;
 }
 export interface ExecuteMusicResult {
     success: boolean;
@@ -22,6 +26,7 @@ export interface ExecuteMusicResult {
     status?: string;
     audioUrl?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeMusic(options: ExecuteMusicOptions): Promise<ExecuteMusicResult>;
 export declare function registerMusicCommand(parent: Command): void;

package/dist/commands/generate/sound-effect.d.ts

@@ -1,19 +1,25 @@
 /**
  * @module generate/sound-effect
  * @description `vibe generate sound-effect` — ElevenLabs SFX generation.
- * Split out of `generate.ts` in v0.69 (Plan G Phase 2).
+ * The command validates and formats; `executeSoundEffect` (also used by
+ * pipelines and the MCP tool) does the work.
  */
 import type { Command } from "commander";
+import { type ProviderErrorKind } from "@vibeframe/ai-providers";
 export interface ExecuteSoundEffectOptions {
     prompt: string;
     output?: string;
+    /** Seconds (0.5-30); the model picks when omitted. */
     duration?: number;
+    /** 0-1, default 0.3. */
     promptInfluence?: number;
+    apiKey?: string;
 }
 export interface ExecuteSoundEffectResult {
     success: boolean;
     outputPath?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeSoundEffect(options: ExecuteSoundEffectOptions): Promise<ExecuteSoundEffectResult>;
 export declare function registerSoundEffectCommand(parent: Command): void;

package/dist/commands/generate/speech.d.ts

@@ -1,20 +1,29 @@
 /**
  * @module generate/speech
- * @description `vibe generate speech` (alias `tts`) — ElevenLabs text-to-
- * speech with optional duration-fit post-processing. Split out of
- * `generate.ts` in v0.69 (Plan G Phase 2).
+ * @description `vibe generate narration` (alias `voiceover`) — text to
+ * speech on ElevenLabs, OpenAI, or local Kokoro, through the same TTS
+ * resolver scenes and builds use.
  */
 import type { Command } from "commander";
+import type { ProviderErrorKind } from "@vibeframe/ai-providers";
 export interface ExecuteSpeechOptions {
     text: string;
     output?: string;
     voice?: string;
+    /** auto (default): ElevenLabs if its key is set, else OpenAI, else local Kokoro. */
+    provider?: string;
+    /** Catalog model ID or alias for the chosen provider. */
+    model?: string;
+    speed?: number;
 }
 export interface ExecuteSpeechResult {
     success: boolean;
     outputPath?: string;
     characterCount?: number;
+    provider?: string;
+    model?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeSpeech(options: ExecuteSpeechOptions): Promise<ExecuteSpeechResult>;
 export declare function registerNarrationCommand(parent: Command): void;