@mevdragon/vidfarm-devcli 0.7.1 → 0.8.0

package/dist/src/frontend/homepage-view.js

@@ -11,6 +11,9 @@ function LibraryIcon() {
 function CalendarIcon() {
     return _jsxs("svg", { viewBox: "0 0 20 20", fill: "none", stroke: "currentColor", strokeWidth: "1.7", strokeLinecap: "round", strokeLinejoin: "round", children: [_jsx("circle", { cx: "10", cy: "10", r: "7.2" }), _jsx("path", { d: "M10 6.3v4.1l2.8 1.7" })] });
 }
+function ClipsIcon() {
+    return _jsxs("svg", { viewBox: "0 0 20 20", fill: "none", stroke: "currentColor", strokeWidth: "1.7", strokeLinecap: "round", strokeLinejoin: "round", children: [_jsx("rect", { x: "3", y: "4.5", width: "14", height: "11", rx: "1.5" }), _jsx("path", { d: "M3 8h14" }), _jsx("path", { d: "M6.2 4.7 4.6 8" }), _jsx("path", { d: "M9.6 4.7 8 8" }), _jsx("path", { d: "M13 4.7 11.4 8" })] });
+}
 function ChatIcon() {
     return _jsxs("svg", { viewBox: "0 0 20 20", fill: "none", stroke: "currentColor", strokeWidth: "1.7", strokeLinecap: "round", strokeLinejoin: "round", children: [_jsx("path", { d: "M4.2 5.2a2 2 0 0 1 2-2h7.6a2 2 0 0 1 2 2v5.6a2 2 0 0 1-2 2H9.2l-4.1 3.1v-3.1a2 2 0 0 1-.9-1.7Z" }), _jsx("path", { d: "M7.3 7.1h5.4" }), _jsx("path", { d: "M7.3 9.6h3.7" })] });
 }
@@ -55,11 +58,13 @@ function PrimaryNav({ account }) {
         ? [
             { id: "discover", href: withAccountQuery("/discover", account.userId), label: "Discover", icon: _jsx(DiscoverIcon, {}) },
             { id: "library", href: withAccountQuery("/library", account.userId), label: "Library", icon: _jsx(LibraryIcon, {}) },
+            { id: "clips", href: "/clips", label: "Clips", icon: _jsx(ClipsIcon, {}) },
             { id: "calendar", href: withAccountQuery("/calendar", account.userId), label: "Calendar", icon: _jsx(CalendarIcon, {}) },
             { id: "settings", href: withAccountQuery("/settings", account.userId), label: "Settings", icon: _jsx(SettingsIcon, {}) }
         ]
         : [
             { id: "discover", href: "/discover", label: "Discover", icon: _jsx(DiscoverIcon, {}) },
+            { id: "clips", href: "/clips", label: "Clips", icon: _jsx(ClipsIcon, {}) },
             { id: "login", href: "/login", label: "Login", icon: _jsx(SettingsIcon, {}) }
         ];
     const menuItems = account.isLoggedIn

package/dist/src/services/clip-curation/cost.js

@@ -0,0 +1,112 @@
+// Cost estimation for a scan — surfaced BEFORE every scan (success criterion #6)
+// and used by the devcli --dry-run gate. Provider/model-aware: prices the
+// resolved tagging model (gemini / openai gpt-5.4-nano / openrouter gemini) plus
+// the embedding model. BYOK: this is the LLM spend the user pays directly.
+function envPrice(envKey, fallback) {
+    const v = Number(process.env[envKey]);
+    return Number.isFinite(v) && v > 0 ? v : fallback;
+}
+// Approximate list prices, USD per 1M tokens (overridable via env). Estimates —
+// the real bill comes from the user's provider account.
+const MODEL_PRICING = {
+    "gemini-2.5-flash-lite": { input: envPrice("VIDFARM_PRICE_FLASH_LITE_INPUT", 0.1), output: envPrice("VIDFARM_PRICE_FLASH_LITE_OUTPUT", 0.4) },
+    "gemini-2.5-flash": { input: envPrice("VIDFARM_PRICE_FLASH_INPUT", 0.3), output: envPrice("VIDFARM_PRICE_FLASH_OUTPUT", 2.5) },
+    // OpenRouter adds a small markup over Google's list price.
+    "google/gemini-2.5-flash": { input: envPrice("VIDFARM_PRICE_OR_FLASH_INPUT", 0.315), output: envPrice("VIDFARM_PRICE_OR_FLASH_OUTPUT", 2.625) },
+    "gpt-5.4-nano": { input: envPrice("VIDFARM_PRICE_GPT5_NANO_INPUT", 0.05), output: envPrice("VIDFARM_PRICE_GPT5_NANO_OUTPUT", 0.4) }
+};
+const DEFAULT_TAG_PRICING = { input: 0.15, output: 0.6 };
+const EMBED_PRICING = {
+    "gemini-embedding-001": envPrice("VIDFARM_PRICE_EMBEDDING_INPUT", 0.15),
+    "text-embedding-3-small": envPrice("VIDFARM_PRICE_OPENAI_EMBEDDING_INPUT", 0.02)
+};
+// Low-res image tokens: Gemini media_resolution LOW = 66/frame; OpenAI
+// low-detail ≈ 85/frame. Audio ~32 tok/sec (Gemini only — OpenAI/OpenRouter
+// chat models don't take the raw audio clip, so those skip it).
+function imageTokensPerFrame(provider) {
+    return provider === "openai" ? 85 : 66;
+}
+const PROMPT_OVERHEAD_TOKENS = 280;
+const AUDIO_TOKENS_PER_SEC = 32;
+// OpenAI's nano reasoning model emits more output tokens than Gemini's terse JSON.
+function outputTokensPerScene(provider) {
+    return provider === "openai" ? 350 : 150;
+}
+const EMBEDDING_TOKENS_PER_SCENE = 60;
+const DEFAULT_AVG_SCENE_SEC = 4;
+export function estimateScanCostFromScenes(scenes, opts) {
+    const durationSec = scenes.reduce((acc, s) => acc + s.duration_sec, 0);
+    const avgSceneSec = scenes.length ? durationSec / scenes.length : DEFAULT_AVG_SCENE_SEC;
+    return compute({ ...normalize(opts), durationSec, scenes: scenes.length, avgSceneSec });
+}
+export function estimateScanCostFromDuration(durationSec, opts) {
+    const avgSceneSec = opts.avgSceneSec ?? DEFAULT_AVG_SCENE_SEC;
+    const scenes = Math.max(1, Math.ceil(durationSec / avgSceneSec));
+    return compute({ ...normalize(opts), durationSec, scenes, avgSceneSec });
+}
+function normalize(opts) {
+    const provider = opts.provider ?? "gemini";
+    const tagModelId = opts.tagModelId ?? defaultTagModel(provider, opts.tier);
+    return {
+        tier: opts.tier,
+        provider,
+        tagModelId,
+        embedModelId: opts.embedModelId ?? null,
+        framesPerScene: opts.framesPerScene ?? 2,
+        includeAudio: opts.includeAudio ?? true
+    };
+}
+function defaultTagModel(provider, tier) {
+    if (provider === "openai")
+        return "gpt-5.4-nano";
+    if (provider === "openrouter")
+        return "google/gemini-2.5-flash";
+    return tier === "flash" ? "gemini-2.5-flash" : "gemini-2.5-flash-lite";
+}
+function compute(input) {
+    const { provider, tagModelId, embedModelId, framesPerScene, includeAudio, durationSec, scenes, avgSceneSec } = input;
+    // Audio is only sent to Gemini (native audio input).
+    const audioTokensPerScene = includeAudio && provider === "gemini" ? Math.round(avgSceneSec * AUDIO_TOKENS_PER_SEC) : 0;
+    const taggingInputPerScene = framesPerScene * imageTokensPerFrame(provider) + PROMPT_OVERHEAD_TOKENS + audioTokensPerScene;
+    const taggingInputTokens = taggingInputPerScene * scenes;
+    const taggingOutputTokens = outputTokensPerScene(provider) * scenes;
+    const embeddingTokens = embedModelId ? EMBEDDING_TOKENS_PER_SCENE * scenes : 0;
+    const tagPrice = MODEL_PRICING[tagModelId] ?? DEFAULT_TAG_PRICING;
+    const embedPrice = embedModelId ? EMBED_PRICING[embedModelId] ?? 0.15 : 0;
+    const usd = (taggingInputTokens / 1_000_000) * tagPrice.input +
+        (taggingOutputTokens / 1_000_000) * tagPrice.output +
+        (embeddingTokens / 1_000_000) * embedPrice;
+    const hours = durationSec / 3600;
+    const usdPerHour = hours > 0 ? usd / hours : usd;
+    return {
+        tier: input.tier,
+        provider,
+        tag_model: tagModelId,
+        embed_model: embedModelId,
+        duration_sec: round2(durationSec),
+        estimated_scenes: scenes,
+        frames_per_scene: framesPerScene,
+        tagging_input_tokens: taggingInputTokens,
+        tagging_output_tokens: taggingOutputTokens,
+        embedding_tokens: embeddingTokens,
+        usd: round4(usd),
+        usd_per_source_hour: round4(usdPerHour)
+    };
+}
+/** Human-readable one-liner for the CLI / API. */
+export function formatCostEstimate(est) {
+    const mins = (est.duration_sec / 60).toFixed(1);
+    return [
+        `~$${est.usd.toFixed(3)} for ${mins} min`,
+        `(${est.estimated_scenes} scenes · ${est.tag_model}${est.embed_model ? ` + ${est.embed_model}` : " · no embeddings"})`,
+        `≈ $${est.usd_per_source_hour.toFixed(3)}/source-hour`,
+        `| tokens: ${est.tagging_input_tokens.toLocaleString()} in + ${est.tagging_output_tokens.toLocaleString()} out + ${est.embedding_tokens.toLocaleString()} embed`
+    ].join(" ");
+}
+function round2(n) {
+    return Math.round(n * 100) / 100;
+}
+function round4(n) {
+    return Math.round(n * 10000) / 10000;
+}
+//# sourceMappingURL=cost.js.map

package/dist/src/services/clip-curation/ffmpeg.js

@@ -0,0 +1,258 @@
+// ffmpeg/ffprobe helpers for clip curation — scene detection, keyframe/clip/
+// thumbnail extraction, per-scene audio for ASR. Same flags on devcli (local
+// ffmpeg-static) and cloud (bundled ffmpeg-static in the scan Lambda), so both
+// targets cut identical clips. Resolution order matches the rest of the repo:
+// HYPERFRAMES_FFMPEG_PATH/FFPROBE env → ffmpeg-static/ffprobe-static → PATH.
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
+import path from "node:path";
+let cachedFfmpeg;
+let cachedFfprobe;
+export async function resolveFfmpeg() {
+    if (cachedFfmpeg !== undefined)
+        return cachedFfmpeg ?? "ffmpeg";
+    const envPath = process.env.HYPERFRAMES_FFMPEG_PATH?.trim();
+    if (envPath && existsSync(envPath))
+        return (cachedFfmpeg = envPath);
+    try {
+        const mod = (await import("ffmpeg-static"));
+        const resolved = typeof mod === "string" ? mod : mod.default;
+        if (typeof resolved === "string" && resolved && existsSync(resolved))
+            return (cachedFfmpeg = resolved);
+    }
+    catch {
+        /* fall through to PATH */
+    }
+    cachedFfmpeg = null;
+    return "ffmpeg";
+}
+export async function resolveFfprobe() {
+    if (cachedFfprobe !== undefined)
+        return cachedFfprobe ?? "ffprobe";
+    const envPath = process.env.HYPERFRAMES_FFPROBE_PATH?.trim() ?? process.env.FFPROBE_PATH?.trim();
+    if (envPath && existsSync(envPath))
+        return (cachedFfprobe = envPath);
+    try {
+        const mod = (await import("ffprobe-static"));
+        const p = (mod.path ?? mod.default?.path);
+        if (typeof p === "string" && p && existsSync(p))
+            return (cachedFfprobe = p);
+    }
+    catch {
+        /* fall through to PATH */
+    }
+    cachedFfprobe = null;
+    return "ffprobe";
+}
+/** True if a usable ffmpeg is available (bundled or on PATH). */
+export async function hasFfmpeg() {
+    const bin = await resolveFfmpeg();
+    const { code } = await run(bin, ["-version"]).catch(() => ({ code: 1, stdout: "", stderr: "" }));
+    return code === 0;
+}
+function run(bin, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => (stdout += d.toString()));
+        child.stderr.on("data", (d) => (stderr += d.toString()));
+        child.on("error", reject);
+        child.on("close", (code) => resolve({ code: code ?? 0, stdout, stderr }));
+    });
+}
+/** Probe a source video for duration/dimensions/codec/size/fps. */
+export async function probeVideo(videoPath) {
+    const ffprobe = await resolveFfprobe();
+    const { stdout } = await run(ffprobe, [
+        "-v", "error",
+        "-print_format", "json",
+        "-show_format",
+        "-show_streams",
+        videoPath
+    ]);
+    let parsed = {};
+    try {
+        parsed = JSON.parse(stdout || "{}");
+    }
+    catch {
+        parsed = {};
+    }
+    const streams = Array.isArray(parsed.streams) ? parsed.streams : [];
+    const video = streams.find((s) => s.codec_type === "video");
+    const format = parsed.format ?? {};
+    const duration = Number(format.duration ?? video?.duration ?? 0) || 0;
+    let fps = null;
+    if (video?.avg_frame_rate && typeof video.avg_frame_rate === "string") {
+        const [num, den] = video.avg_frame_rate.split("/").map(Number);
+        if (num && den)
+            fps = num / den;
+    }
+    return {
+        duration_sec: duration,
+        width: video?.width ?? null,
+        height: video?.height ?? null,
+        codec: video?.codec_name ?? null,
+        size_bytes: format.size ? Number(format.size) : null,
+        fps
+    };
+}
+/**
+ * Detect scene boundaries with the portable `select='gt(scene,T)',showinfo`
+ * pass, parsing pts_time from ffmpeg's stderr. Falls back to fixed-interval
+ * chunking when nothing is detected (e.g. a single continuous take), so a scan
+ * always yields clips. Same command shape on devcli and cloud.
+ */
+export async function detectScenes(videoPath, opts = {}) {
+    const threshold = opts.threshold ?? 0.3;
+    const minScene = opts.minSceneSec ?? 0.6;
+    const maxScene = opts.maxSceneSec ?? 8;
+    const duration = opts.durationSec ?? (await probeVideo(videoPath)).duration_sec;
+    if (!Number.isFinite(duration) || duration <= 0)
+        return [];
+    const ffmpeg = await resolveFfmpeg();
+    const { stderr } = await run(ffmpeg, [
+        "-hide_banner",
+        "-i", videoPath,
+        "-filter:v", `select='gt(scene,${threshold})',showinfo`,
+        "-f", "null",
+        "-"
+    ]);
+    const cuts = [];
+    const re = /pts_time:([0-9.]+)/g;
+    let m;
+    while ((m = re.exec(stderr)) !== null) {
+        const t = Number(m[1]);
+        if (Number.isFinite(t) && t > 0 && t < duration)
+            cuts.push(t);
+    }
+    cuts.sort((a, b) => a - b);
+    // Build [0, cut1, cut2, …, duration] boundaries.
+    let bounds = [0, ...cuts, duration];
+    // If nothing detected, chunk at maxScene.
+    if (cuts.length === 0) {
+        bounds = [0];
+        for (let t = maxScene; t < duration; t += maxScene)
+            bounds.push(t);
+        bounds.push(duration);
+    }
+    // Merge boundaries closer than minScene.
+    const merged = [bounds[0]];
+    for (let i = 1; i < bounds.length; i++) {
+        if (bounds[i] - merged[merged.length - 1] >= minScene || i === bounds.length - 1) {
+            merged.push(bounds[i]);
+        }
+    }
+    const scenes = [];
+    for (let i = 0; i < merged.length - 1; i++) {
+        let start = merged[i];
+        const end = merged[i + 1];
+        // Split over-long scenes so clips stay usable and tagging stays cheap.
+        const span = end - start;
+        if (span > maxScene) {
+            const chunks = Math.ceil(span / maxScene);
+            const step = span / chunks;
+            for (let c = 0; c < chunks; c++) {
+                const s = start + c * step;
+                const e = c === chunks - 1 ? end : s + step;
+                scenes.push(makeScene(scenes.length, s, e));
+            }
+        }
+        else {
+            scenes.push(makeScene(scenes.length, start, end));
+        }
+    }
+    return scenes;
+}
+function makeScene(index, start, end) {
+    const s = Math.max(0, start);
+    const e = Math.max(s + 0.01, end);
+    return { index, start_time_sec: round3(s), end_time_sec: round3(e), duration_sec: round3(e - s) };
+}
+/** Extract up to `count` small keyframe JPEGs across a scene (for low-cost tagging). */
+export async function extractKeyframes(input) {
+    const count = Math.max(1, Math.min(3, input.count ?? 2));
+    const width = input.width ?? 384;
+    mkdirSync(input.outDir, { recursive: true });
+    const ffmpeg = await resolveFfmpeg();
+    const { start_time_sec: start, duration_sec: dur } = input.scene;
+    // Sample points inside the clip, avoiding the very edges.
+    const points = count === 1
+        ? [start + dur / 2]
+        : Array.from({ length: count }, (_, i) => start + dur * ((i + 1) / (count + 1)));
+    const outPaths = [];
+    for (let i = 0; i < points.length; i++) {
+        const out = path.join(input.outDir, `scene-${input.scene.index}-kf${i}.jpg`);
+        const { code } = await run(ffmpeg, [
+            "-y",
+            "-ss", points[i].toFixed(3),
+            "-i", input.videoPath,
+            "-frames:v", "1",
+            "-vf", `scale=${width}:-2`,
+            "-q:v", "5",
+            out
+        ]);
+        if (code === 0 && existsSync(out))
+            outPaths.push(out);
+    }
+    return outPaths;
+}
+/** Cut the scene into a standalone mp4 (re-encoded for frame-accurate boundaries). */
+export async function extractClip(input) {
+    mkdirSync(path.dirname(input.outPath), { recursive: true });
+    const ffmpeg = await resolveFfmpeg();
+    const { start_time_sec: start, duration_sec: dur } = input.scene;
+    const args = input.reencode === false
+        ? ["-y", "-ss", start.toFixed(3), "-i", input.videoPath, "-t", dur.toFixed(3), "-c", "copy", "-avoid_negative_ts", "make_zero", input.outPath]
+        : [
+            "-y",
+            "-ss", start.toFixed(3),
+            "-i", input.videoPath,
+            "-t", dur.toFixed(3),
+            "-c:v", "libx264", "-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p",
+            "-c:a", "aac", "-b:a", "128k",
+            "-movflags", "+faststart",
+            input.outPath
+        ];
+    const { code } = await run(ffmpeg, args);
+    return code === 0 && existsSync(input.outPath);
+}
+/** Single representative thumbnail for the scene. */
+export async function extractThumbnail(input) {
+    mkdirSync(path.dirname(input.outPath), { recursive: true });
+    const ffmpeg = await resolveFfmpeg();
+    const mid = input.scene.start_time_sec + input.scene.duration_sec / 2;
+    const { code } = await run(ffmpeg, [
+        "-y",
+        "-ss", mid.toFixed(3),
+        "-i", input.videoPath,
+        "-frames:v", "1",
+        "-vf", `scale=${input.width ?? 320}:-2`,
+        "-q:v", "3",
+        input.outPath
+    ]);
+    return code === 0 && existsSync(input.outPath);
+}
+/** Extract a small mono/16k audio clip for the scene (feeds Gemini ASR). Returns null if no audio track. */
+export async function extractSceneAudio(input) {
+    mkdirSync(path.dirname(input.outPath), { recursive: true });
+    const ffmpeg = await resolveFfmpeg();
+    const { start_time_sec: start, duration_sec: dur } = input.scene;
+    const { code } = await run(ffmpeg, [
+        "-y",
+        "-ss", start.toFixed(3),
+        "-i", input.videoPath,
+        "-t", dur.toFixed(3),
+        "-vn",
+        "-ac", "1",
+        "-ar", "16000",
+        "-c:a", "libmp3lame",
+        "-b:a", "32k",
+        input.outPath
+    ]);
+    return code === 0 && existsSync(input.outPath) ? input.outPath : null;
+}
+function round3(n) {
+    return Math.round(n * 1000) / 1000;
+}
+//# sourceMappingURL=ffmpeg.js.map