@vibeframe/cli 0.105.1 → 0.105.2

package/dist/commands/_shared/visual-styles.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @module _shared/visual-styles
+ *
+ * Eight named visual identities used to seed `DESIGN.md` when scaffolding a
+ * scene project. The structured data below distils the rules that
+ * Hyperframes' `hyperframes` skill encodes in
+ * `skills/hyperframes/visual-styles.md` (Apache 2.0). VibeFrame vendors the
+ * data — not the prose — so a project scaffolded without an active agent
+ * still gets a credible DESIGN.md as a starting point.
+ *
+ * The agent-driven path (`/hyperframes` skill loaded in Claude Code) remains
+ * the canonical way to author final compositions; this module just ensures
+ * the visual contract exists in the project before any HTML is written.
+ *
+ * Source-of-truth attribution: HeyGen Hyperframes — https://hyperframes.heygen.com
+ * License: Apache 2.0 (see NOTICE)
+ */
+/** One named visual identity. Designed to round-trip into DESIGN.md. */
+export interface VisualStyle {
+    /** Display name, e.g. "Swiss Pulse". */
+    name: string;
+    /** URL/CLI-friendly slug, e.g. "swiss-pulse". */
+    slug: string;
+    /** Designer or movement the style references. */
+    designer: string;
+    /** One-line mood, e.g. "Clinical, precise". */
+    mood: string;
+    /** Content categories the style works best for. */
+    bestFor: string;
+    /** 2–3 hex colours that anchor the palette. */
+    palette: string[];
+    /** Free-form palette description (warm/cold, primary/accent). */
+    paletteNotes: string;
+    /** Typography rules — family, weights, role per weight. */
+    typography: string;
+    /** Composition rules — grid, spacing, framing. */
+    composition: string;
+    /** Motion rules — speed, easing, character. */
+    motion: string;
+    /** Hyperframes shader name(s) that match the energy. */
+    transition: string;
+    /** GSAP signature — easing functions and feel. */
+    gsapSignature: string;
+    /** 3 anti-patterns to avoid for this style. */
+    avoid: string[];
+}
+/** All vendored styles in display order. */
+export declare function listVisualStyles(): readonly VisualStyle[];
+/**
+ * Find a style by name (case-insensitive) or slug. Returns undefined if no
+ * match. Caller is responsible for surfacing a usage error.
+ */
+export declare function getVisualStyle(query: string): VisualStyle | undefined;
+/** Comma-joined list of valid `--visual-style` argument values, for help/error text. */
+export declare function visualStyleNames(): string;

package/dist/commands/_shared/visual-styles.test.d.ts

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

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

@@ -0,0 +1,47 @@
+/**
+ * @module _shared/walkthroughs
+ *
+ * Universal CLI-equivalents of Claude Code's `/vibe-scene` and
+ * `/vibe-pipeline` slash commands. After Plan H, host agents
+ * (Claude Code, Codex, Cursor, Aider, Gemini CLI, OpenCode) all read
+ * SKILL.md from the user's project and can drive `vibe build`
+ * directly — but discoverability of the *workflow* itself was still
+ * Claude-Code-only via the slash menu.
+ *
+ * `vibe guide <topic>` closes that gap: any host (or a human at
+ * a terminal) gets the same step-by-step authoring guide that the
+ * slash commands deliver in Claude Code. The content is vendored as
+ * TS template-literal strings so the CLI binary ships with zero
+ * filesystem dependencies — same approach as `hf-skill-bundle`.
+ *
+ * Source of truth lives here. The Claude Code slash command files
+ * under `.claude/skills/vibe-{scene,pipeline}/SKILL.md` mirror this
+ * content (so the slash command and the CLI command stay in sync) and
+ * add a one-line frontmatter for the slash menu.
+ */
+export type WalkthroughTopic = "motion" | "scene" | "pipeline" | "architecture";
+export interface WalkthroughResult {
+    topic: WalkthroughTopic;
+    /** Short title, e.g. "Scene authoring with vibe". */
+    title: string;
+    /** One-line summary suitable for a `--list` output. */
+    summary: string;
+    /** Numbered action items the host agent walks the user through. */
+    steps: string[];
+    /** Related vibe CLI commands referenced by the walkthrough. */
+    relatedCommands: string[];
+    /** Full markdown body — same content the Claude Code slash command loads. */
+    content: string;
+}
+/** All walkthrough topics this CLI knows. */
+export declare const WALKTHROUGH_TOPICS: readonly WalkthroughTopic[];
+/** Pure data accessor — no I/O. Throws on unknown topic. */
+export declare function loadWalkthrough(topic: WalkthroughTopic): WalkthroughResult;
+/** List all walkthroughs (for `vibe guide --list` / no-arg invocation). */
+export declare function listWalkthroughs(): Array<{
+    topic: WalkthroughTopic;
+    title: string;
+    summary: string;
+}>;
+/** Type guard for runtime topic validation. */
+export declare function isWalkthroughTopic(value: unknown): value is WalkthroughTopic;

package/dist/commands/_shared/walkthroughs/walkthroughs.test.d.ts

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

package/dist/commands/agent.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Agent Command - Interactive AI agent REPL
+ * Provides natural language interface with tool calling
+ */
+import { Command } from "commander";
+export interface StartAgentOptions {
+    provider?: string;
+    model?: string;
+    project?: string;
+    verbose?: boolean;
+    maxTurns?: string;
+    input?: string;
+    confirm?: boolean;
+    /** When true, suppress *all* confirm prompts including the cost gate. */
+    noConfirm?: boolean;
+    /** Cumulative USD ceiling — agent rejects further tool calls past this. */
+    budgetUsd?: number | string;
+}
+/**
+ * Start the AI agent
+ * @param options - Agent options
+ */
+export declare function startAgent(options?: StartAgentOptions): Promise<void>;
+export declare const agentCommand: Command;

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

@@ -0,0 +1,105 @@
+/**
+ * @module ai-analyze
+ *
+ * Media analysis execute functions using Gemini multimodal AI.
+ *
+ * CLI commands: gemini-video, analyze
+ *
+ * Execute functions:
+ *   executeGeminiVideo - Analyze video files or YouTube URLs with Gemini
+ *   executeAnalyze     - Unified analysis for images, videos, and YouTube URLs
+ *
+ * @dependencies Gemini (Google)
+ */
+import { Command } from "commander";
+/** Options for {@link executeGeminiVideo}. */
+export interface GeminiVideoOptions {
+    /** Video file path or YouTube URL */
+    source: string;
+    /** Analysis prompt (e.g. "Summarize this video") */
+    prompt: string;
+    /** Gemini model shorthand (default: "flash") */
+    model?: "flash" | "flash-2.5" | "pro";
+    /** Frames per second for video sampling (default: 1) */
+    fps?: number;
+    /** Start offset in seconds for clipping */
+    start?: number;
+    /** End offset in seconds for clipping */
+    end?: number;
+    /** Use low-resolution mode (fewer tokens, longer videos) */
+    lowRes?: boolean;
+}
+/** Result from {@link executeGeminiVideo}. */
+export interface GeminiVideoResult {
+    /** Whether the analysis succeeded */
+    success: boolean;
+    /** Gemini's text response */
+    response?: string;
+    /** Model used for analysis */
+    model?: string;
+    /** Total tokens consumed */
+    totalTokens?: number;
+    /** Prompt tokens consumed */
+    promptTokens?: number;
+    /** Response tokens generated */
+    responseTokens?: number;
+    /** Error message on failure */
+    error?: string;
+}
+/**
+ * Analyze a video file or YouTube URL using Gemini multimodal AI.
+ *
+ * Supports local video files and YouTube URLs. Provides structured responses
+ * with optional token usage reporting.
+ *
+ * @param options - Video analysis configuration
+ * @returns Result with Gemini's response text and token usage
+ */
+export declare function executeGeminiVideo(options: GeminiVideoOptions): Promise<GeminiVideoResult>;
+/** Options for {@link executeAnalyze}. */
+export interface AnalyzeOptions {
+    /** Image/video file path, image URL, or YouTube URL */
+    source: string;
+    /** Analysis prompt (e.g. "Describe this image") */
+    prompt: string;
+    /** Gemini model shorthand (default: "flash") */
+    model?: "flash" | "flash-2.5" | "pro";
+    /** Frames per second for video sampling (default: 1) */
+    fps?: number;
+    /** Start offset in seconds (video only) */
+    start?: number;
+    /** End offset in seconds (video only) */
+    end?: number;
+    /** Use low-resolution mode (fewer tokens) */
+    lowRes?: boolean;
+}
+/** Result from {@link executeAnalyze}. */
+export interface AnalyzeResult {
+    /** Whether the analysis succeeded */
+    success: boolean;
+    /** Gemini's text response */
+    response?: string;
+    /** Model used for analysis */
+    model?: string;
+    /** Detected source media type */
+    sourceType?: "image" | "video" | "youtube";
+    /** Total tokens consumed */
+    totalTokens?: number;
+    /** Prompt tokens consumed */
+    promptTokens?: number;
+    /** Response tokens generated */
+    responseTokens?: number;
+    /** Error message on failure */
+    error?: string;
+}
+/**
+ * Analyze any media source (image, video, or YouTube URL) using Gemini.
+ *
+ * Auto-detects source type from file extension or URL pattern. Supports
+ * local files, remote URLs, and YouTube links.
+ *
+ * @param options - Unified analysis configuration
+ * @returns Result with Gemini's response, detected source type, and token usage
+ */
+export declare function executeAnalyze(options: AnalyzeOptions): Promise<AnalyzeResult>;
+export declare function registerAnalyzeCommands(aiCommand: Command): void;

package/dist/commands/ai-animated-caption.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @module ai-animated-caption
+ * @description Animated caption pipeline — word-by-word TikTok/Reels-style captions.
+ *
+ * Pipeline: Video → FFmpeg audio extract → Whisper word-level transcribe
+ *   → Word grouping → Style routing (ASS fast tier / Remotion tier) → Output MP4
+ *
+ * ## Commands: vibe pipeline animated-caption
+ * ## Dependencies: Whisper (OpenAI), FFmpeg, Remotion (optional)
+ * @see MODELS.md for AI model configuration
+ */
+export interface WordTiming {
+    word: string;
+    start: number;
+    end: number;
+}
+export interface WordGroup {
+    words: WordTiming[];
+    startTime: number;
+    endTime: number;
+    text: string;
+}
+export type AnimatedCaptionStyle = "highlight" | "bounce" | "pop-in" | "neon" | "karaoke-sweep" | "typewriter";
+export interface AnimatedCaptionOptions {
+    videoPath: string;
+    outputPath: string;
+    style: AnimatedCaptionStyle;
+    highlightColor: string;
+    fontSize?: number;
+    position: "top" | "center" | "bottom";
+    wordsPerGroup?: number;
+    maxChars?: number;
+    language?: string;
+    fast?: boolean;
+}
+export interface AnimatedCaptionResult {
+    success: boolean;
+    outputPath?: string;
+    wordCount?: number;
+    groupCount?: number;
+    style?: string;
+    tier?: "ass" | "remotion";
+    error?: string;
+}
+/**
+ * Group words into display groups for animated captions.
+ * Groups by natural sentence boundaries, pauses, and word/char limits.
+ */
+export declare function groupWords(words: WordTiming[], options?: {
+    wordsPerGroup?: number;
+    maxChars?: number;
+}): WordGroup[];
+/**
+ * Generate ASS subtitle content for fast-tier animated captions.
+ */
+export declare function generateASS(groups: WordGroup[], style: "karaoke-sweep" | "typewriter", options: {
+    highlightColor: string;
+    fontSize: number;
+    position: string;
+    width: number;
+    height: number;
+}): string;
+export declare function executeAnimatedCaption(options: AnimatedCaptionOptions): Promise<AnimatedCaptionResult>;

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

@@ -0,0 +1,92 @@
+/**
+ * @module ai-audio
+ * @description Library functions for transcribe, isolate, voice-clone, dub,
+ * and duck. Powers the manifest tools `audio_transcribe`, `audio_isolate`,
+ * `audio_clone_voice`, `audio_dub`, `audio_duck` (the user reaches these
+ * via `vibe audio *`).
+ *
+ * The legacy `vibe ai transcribe / tts / sfx / isolate / voice-clone / music /
+ * music-status / audio-restore / dub / duck` Commander registrations were
+ * removed alongside the dead `commands/ai.ts` orchestrator (the `vibe ai *`
+ * namespace was never `addCommand`'d to `program`).
+ *
+ * @see MODELS.md for AI model configuration
+ */
+export interface TranscribeOptions {
+    audioPath: string;
+    language?: string;
+    output?: string;
+    format?: string;
+    apiKey?: string;
+}
+export interface TranscribeResult {
+    success: boolean;
+    text?: string;
+    segments?: Array<{
+        startTime: number;
+        endTime: number;
+        text: string;
+    }>;
+    detectedLanguage?: string;
+    outputPath?: string;
+    error?: string;
+}
+export declare function executeTranscribe(options: TranscribeOptions): Promise<TranscribeResult>;
+export interface IsolateOptions {
+    audioPath: string;
+    output?: string;
+    apiKey?: string;
+}
+export interface IsolateResult {
+    success: boolean;
+    outputPath?: string;
+    error?: string;
+}
+export declare function executeIsolate(options: IsolateOptions): Promise<IsolateResult>;
+export interface VoiceCloneOptions {
+    samplePaths: string[];
+    name: string;
+    description?: string;
+    labels?: Record<string, string>;
+    removeNoise?: boolean;
+    apiKey?: string;
+}
+export interface VoiceCloneResult {
+    success: boolean;
+    voiceId?: string;
+    name?: string;
+    error?: string;
+}
+export declare function executeVoiceClone(options: VoiceCloneOptions): Promise<VoiceCloneResult>;
+export interface DubOptions {
+    mediaPath: string;
+    language: string;
+    source?: string;
+    voice?: string;
+    analyzeOnly?: boolean;
+    output?: string;
+}
+export interface DubResult {
+    success: boolean;
+    outputPath?: string;
+    sourceLanguage?: string;
+    targetLanguage?: string;
+    segmentCount?: number;
+    error?: string;
+}
+export declare function executeDub(options: DubOptions): Promise<DubResult>;
+export interface DuckOptions {
+    musicPath: string;
+    voicePath: string;
+    output?: string;
+    threshold?: string;
+    ratio?: string;
+    attack?: string;
+    release?: string;
+}
+export interface DuckResult {
+    success: boolean;
+    outputPath?: string;
+    error?: string;
+}
+export declare function executeDuck(options: DuckOptions): Promise<DuckResult>;

package/dist/commands/ai-edit-cli.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ai-edit-cli.ts — CLI command registrations for video/audio editing commands.
+ *
+ * Commands: silence-cut, caption, noise-reduce, fade, translate-srt, jump-cut
+ *
+ * This file contains only the Commander.js command definitions (UI layer).
+ * All execute functions and types live in ai-edit.ts.
+ *
+ * Extracted from ai-edit.ts as part of modularisation.
+ * ai.ts calls registerEditCommands(aiCommand).
+ */
+import { type Command } from 'commander';
+export declare function registerEditCommands(aiCommand: Command): void;

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

@@ -0,0 +1,29 @@
+/**
+ * @module ai-edit
+ * @description Barrel re-exporting executeXxx functions and types for the
+ * `vibe edit *` subcommands. The real implementations live under
+ * `commands/_shared/edit/<name>.ts` (split out in v0.69 Plan G Phase 3).
+ *
+ * This barrel exists for backward compat: 9 consumer files (demo,
+ * edit-cmd, ai-edit-cli, ai-review, ai-script-pipeline-cli,
+ * ai-animated-caption, ai, ai-script-pipeline, ai.test) already import
+ * from `./ai-edit.js` and continue to work unchanged.
+ *
+ * Adding a new edit operation: create `commands/_shared/edit/<name>.ts`
+ * with `executeXxx` + `XxxOptions/Result`, then add a re-export here.
+ */
+export { executeSilenceCut } from "./_shared/edit/silence-cut.js";
+export type { SilencePeriod, SilenceCutOptions, SilenceCutResult, } from "./_shared/edit/silence-cut.js";
+export { executeJumpCut, transcribeWithWords, detectFillerRanges, DEFAULT_FILLER_WORDS, } from "./_shared/edit/jump-cut.js";
+export type { FillerWord, JumpCutOptions, JumpCutResult, } from "./_shared/edit/jump-cut.js";
+export { executeCaption } from "./_shared/edit/caption.js";
+export type { CaptionStyle, CaptionOptions, CaptionResult, } from "./_shared/edit/caption.js";
+export { executeNoiseReduce } from "./_shared/edit/noise-reduce.js";
+export type { NoiseReduceOptions, NoiseReduceResult, } from "./_shared/edit/noise-reduce.js";
+export { executeFade } from "./_shared/edit/fade.js";
+export type { FadeOptions, FadeResult } from "./_shared/edit/fade.js";
+export { executeTranslateSrt } from "./_shared/edit/translate-srt.js";
+export type { TranslateSrtOptions, TranslateSrtResult, } from "./_shared/edit/translate-srt.js";
+export { applyTextOverlays, executeTextOverlay, } from "./_shared/edit/text-overlay.js";
+export type { TextOverlayStyle, TextOverlayOptions, TextOverlayResult, } from "./_shared/edit/text-overlay.js";
+export type { AutoFix, VideoReviewCategory, VideoReviewFeedback, } from "./_shared/edit/video-review.js";

package/dist/commands/ai-fill-gaps.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @module ai-fill-gaps
+ * @description Fill timeline gaps with AI-generated video (Kling image-to-video).
+ *
+ * ## Commands: vibe edit fill-gaps
+ * ## Dependencies: Kling
+ *
+ * Post-v0.69 Phase 4: the 562-line `.action()` body is extracted into
+ * `executeFillGaps` (commands/_shared/execute-fill-gaps.ts) so the
+ * manifest entry `edit_fill_gaps` can call the same logic. This file
+ * remains the CLI registration site — it wires `onProgress` to ora
+ * spinners and prints `humanLines` on completion.
+ */
+import { type Command } from "commander";
+export declare function registerFillGapsCommand(aiCommand: Command): void;

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

@@ -0,0 +1,26 @@
+/**
+ * ai-helpers.ts — Shared utility functions used across AI commands.
+ *
+ * These were extracted from ai.ts to improve maintainability.
+ * ai.ts imports and re-uses these internally.
+ */
+import type { EditSuggestion } from "@vibeframe/ai-providers";
+import { Project } from "../engine/index.js";
+/**
+ * Minimal shape required by {@link applySuggestion}. Accepts the canonical
+ * {@link EditSuggestion} from the AI provider as well as the CLI's local
+ * `SuggestEditEntry`, which omits the optional `id`/`previewUrl`.
+ */
+export type ApplicableSuggestion = Pick<EditSuggestion, "type" | "clipIds" | "params">;
+/**
+ * Download a video from URL, handling Veo/Google API authentication.
+ * Uses x-goog-api-key header (not query param) for Google API URLs.
+ *
+ * @param url - Video URL to download
+ * @param apiKey - Google API key (caller should resolve from env/config)
+ */
+export declare function downloadVideo(url: string, apiKey?: string): Promise<Buffer>;
+/** Format a duration in seconds to m:ss.s display format */
+export declare function formatTime(seconds: number): string;
+/** Apply a single AI edit suggestion to a project */
+export declare function applySuggestion(project: Project, suggestion: ApplicableSuggestion): boolean;

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

@@ -0,0 +1,126 @@
+/**
+ * @module ai-highlights
+ *
+ * Highlight extraction and auto-shorts generation for long-form content.
+ *
+ * CLI commands: highlights, auto-shorts
+ *
+ * Execute functions:
+ *   executeHighlights  - Extract best moments from video/audio (Whisper+Claude or Gemini)
+ *   executeAutoShorts   - Generate short-form vertical clips from long-form video
+ *
+ * @dependencies Whisper (OpenAI), Claude (Anthropic), Gemini (Google), FFmpeg
+ */
+import { Command } from "commander";
+import { type Highlight } from "@vibeframe/ai-providers";
+/** Options for {@link executeHighlights}. */
+export interface HighlightsOptions {
+    /** Path to the video or audio file */
+    media: string;
+    /** Path for the output JSON with highlight data */
+    output?: string;
+    /** Path for a timeline JSON file with highlight clips */
+    project?: string;
+    /** Target highlight reel duration in seconds */
+    duration?: number;
+    /** Maximum number of highlights to return */
+    count?: number;
+    /** Minimum confidence threshold 0-1 (default: 0.7) */
+    threshold?: number;
+    /** Selection criteria filter */
+    criteria?: "emotional" | "informative" | "funny" | "all";
+    /** Language code for Whisper transcription */
+    language?: string;
+    /** Use Gemini multimodal analysis instead of Whisper+Claude */
+    useGemini?: boolean;
+    /** Use low-resolution mode for Gemini (longer videos) */
+    lowRes?: boolean;
+}
+/** Result from {@link executeHighlights}. */
+export interface HighlightsExtractResult {
+    /** Whether the extraction succeeded */
+    success: boolean;
+    /** Detected and filtered highlights */
+    highlights: Highlight[];
+    /** Total source media duration in seconds */
+    totalDuration: number;
+    /** Combined duration of all returned highlights in seconds */
+    totalHighlightDuration: number;
+    /** Path to the output JSON (if --output specified) */
+    outputPath?: string;
+    /** Path to the generated timeline file (if --project specified) */
+    projectPath?: string;
+    /** Error message on failure */
+    error?: string;
+}
+/**
+ * Extract the best highlights from a video or audio file.
+ *
+ * Supports two analysis backends:
+ * - Whisper + Claude (default): transcribe audio, then analyze text for highlights
+ * - Gemini (--useGemini): multimodal visual+audio analysis for richer detection
+ *
+ * @param options - Highlight extraction configuration
+ * @returns Result with filtered highlights sorted by time
+ */
+export declare function executeHighlights(options: HighlightsOptions): Promise<HighlightsExtractResult>;
+/** Options for {@link executeAutoShorts}. */
+export interface AutoShortsOptions {
+    /** Path to the source video file */
+    video: string;
+    /** Output directory for generated short clips */
+    outputDir?: string;
+    /** Target duration per short in seconds (default: 60) */
+    duration?: number;
+    /** Number of shorts to generate (default: 1) */
+    count?: number;
+    /** Output aspect ratio (default: "9:16") */
+    aspect?: "9:16" | "1:1";
+    /** Add auto-generated captions to shorts */
+    addCaptions?: boolean;
+    /** Caption visual style preset */
+    captionStyle?: "minimal" | "bold" | "animated";
+    /** If true, only analyze without extracting clips */
+    analyzeOnly?: boolean;
+    /** Language code for Whisper transcription */
+    language?: string;
+    /** Use Gemini multimodal analysis instead of Whisper+Claude */
+    useGemini?: boolean;
+    /** Use low-resolution mode for Gemini (longer videos) */
+    lowRes?: boolean;
+}
+/** Result from {@link executeAutoShorts}. */
+export interface AutoShortsResult {
+    /** Whether the operation succeeded */
+    success: boolean;
+    /** Generated short clips with metadata */
+    shorts: Array<{
+        /** 1-based index */
+        index: number;
+        /** Start time in the source video (seconds) */
+        startTime: number;
+        /** End time in the source video (seconds) */
+        endTime: number;
+        /** Duration of the short (seconds) */
+        duration: number;
+        /** Confidence/virality score 0-1 */
+        confidence: number;
+        /** Why this moment was selected */
+        reason: string;
+        /** Path to the extracted clip (undefined in analyze-only mode) */
+        outputPath?: string;
+    }>;
+    /** Error message on failure */
+    error?: string;
+}
+/**
+ * Auto-generate short-form vertical clips from a long-form video.
+ *
+ * Finds the best viral-worthy moments using Whisper+Claude or Gemini analysis,
+ * then extracts and crops them to the target aspect ratio using FFmpeg.
+ *
+ * @param options - Auto-shorts generation configuration
+ * @returns Result with extracted short clips and metadata
+ */
+export declare function executeAutoShorts(options: AutoShortsOptions): Promise<AutoShortsResult>;
+export declare function registerHighlightsCommands(aiCommand: Command): void;

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

@@ -0,0 +1,71 @@
+/**
+ * @module ai-image
+ * @description Library functions for image generation, image editing, and
+ * thumbnail best-frame selection. Powers the manifest tools
+ * `generate_image`, `edit_image`, and `generate_thumbnail` (which the user
+ * actually reaches via `vibe generate image / edit image / generate thumbnail`).
+ *
+ * The legacy `vibe ai image / thumbnail / background / gemini / gemini-edit`
+ * Commander registrations were removed alongside the dead `commands/ai.ts`
+ * orchestrator (the `vibe ai *` namespace was never `addCommand`'d to
+ * `program`).
+ *
+ * @see MODELS.md for AI model configuration
+ */
+export interface ImageGenerateOptions {
+    prompt: string;
+    provider?: string;
+    output?: string;
+    size?: string;
+    ratio?: string;
+    quality?: string;
+    style?: string;
+    count?: number;
+    model?: string;
+    apiKey?: string;
+}
+export interface ImageGenerateResult {
+    success: boolean;
+    outputPath?: string;
+    images?: Array<{
+        url?: string;
+        base64?: string;
+        mimeType?: string;
+        revisedPrompt?: string;
+    }>;
+    provider?: string;
+    model?: string;
+    error?: string;
+}
+export declare function executeImageGenerate(options: ImageGenerateOptions): Promise<ImageGenerateResult>;
+export interface GeminiEditOptions {
+    imagePaths: string[];
+    prompt: string;
+    output?: string;
+    model?: string;
+    ratio?: string;
+    resolution?: string;
+    apiKey?: string;
+}
+export interface GeminiEditResult {
+    success: boolean;
+    outputPath?: string;
+    model?: string;
+    error?: string;
+}
+export declare function executeGeminiEdit(options: GeminiEditOptions): Promise<GeminiEditResult>;
+export interface ThumbnailBestFrameOptions {
+    videoPath: string;
+    outputPath: string;
+    prompt?: string;
+    model?: string;
+    apiKey?: string;
+}
+export interface ThumbnailBestFrameResult {
+    success: boolean;
+    outputPath?: string;
+    timestamp?: number;
+    reason?: string;
+    error?: string;
+}
+export declare function executeThumbnailBestFrame(options: ThumbnailBestFrameOptions): Promise<ThumbnailBestFrameResult>;