tuna-agent 0.1.136 → 0.1.138

package/dist/daemon/analyze-video-handler.js

@@ -14,6 +14,49 @@ const OPENAI_KEY = process.env.OPENAI_API_KEY || '';
 const YT_DLP = process.env.YT_DLP_BIN || '/home/gatoasang94/.local/bin/yt-dlp';
 const FFMPEG = process.env.FFMPEG_BIN || '/usr/bin/ffmpeg';
 const FFPROBE = process.env.FFPROBE_BIN || '/usr/bin/ffprobe';
+// Downloaded source videos are cached by URL hash so re-analyze doesn't
+// re-download (saves bandwidth + time on long clips). relabs01 shares disk
+// with Demucs + the local media server, so the cache is bounded: drop files
+// older than 7 days, then if the total still exceeds 15 GB evict oldest-first.
+const CACHE_DIR = path.join(os.homedir(), '.tuna-analyze-cache');
+const CACHE_MAX_AGE_MS = 7 * 24 * 3600 * 1000;
+const CACHE_MAX_BYTES = 15 * 1024 * 1024 * 1024;
+async function pruneVideoCache() {
+    try {
+        await fs.mkdir(CACHE_DIR, { recursive: true });
+        const names = await fs.readdir(CACHE_DIR);
+        const now = Date.now();
+        const live = [];
+        for (const name of names) {
+            const p = path.join(CACHE_DIR, name);
+            try {
+                const st = await fs.stat(p);
+                if (!st.isFile())
+                    continue;
+                if (now - st.mtimeMs > CACHE_MAX_AGE_MS) {
+                    await fs.rm(p, { force: true });
+                    continue;
+                }
+                live.push({ p, size: st.size, mtime: st.mtimeMs });
+            }
+            catch { /* race with another run deleting it — ignore */ }
+        }
+        let total = live.reduce((s, f) => s + f.size, 0);
+        if (total > CACHE_MAX_BYTES) {
+            live.sort((a, b) => a.mtime - b.mtime); // oldest first
+            for (const f of live) {
+                if (total <= CACHE_MAX_BYTES)
+                    break;
+                try {
+                    await fs.rm(f.p, { force: true });
+                    total -= f.size;
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+    catch { /* cache pruning is best-effort; never block analysis */ }
+}
 function run(cmd, args, opts = {}) {
     return new Promise((resolve, reject) => {
         const p = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'], ...opts });
@@ -224,14 +267,41 @@ export async function analyzeVideo(url, onProgress) {
     const progress = onProgress || (() => { });
     const tmpDir = path.join(os.tmpdir(), 'tuna-analyze-' + crypto.randomBytes(6).toString('hex'));
     await fs.mkdir(tmpDir, { recursive: true });
-    const videoPath = path.join(tmpDir, 'video.mp4');
+    // Video lives in the persistent URL-keyed cache (NOT tmpDir) so re-analyze
+    // reuses it. Only audio/frames are per-run + cleaned up in `finally`.
+    const urlHash = crypto.createHash('sha1').update(url).digest('hex');
+    const videoPath = path.join(CACHE_DIR, `${urlHash}.mp4`);
     const audioPath = path.join(tmpDir, 'audio.mp3');
     const framesDir = path.join(tmpDir, 'frames');
     await fs.mkdir(framesDir, { recursive: true });
     try {
-        progress('Đang tải video...');
-        console.log('[analyze_video] Downloading:', url);
-        await run(YT_DLP, ['-f', 'best[height<=720]/best', '-o', videoPath, '--no-playlist', '--quiet', url]);
+        await pruneVideoCache();
+        const cached = await fs.stat(videoPath).then(st => st.isFile() && st.size > 0).catch(() => false);
+        if (cached) {
+            progress('Dùng video đã tải (cache)...');
+            console.log('[analyze_video] Cache HIT:', videoPath);
+            // Bump mtime so an actively re-analyzed video isn't evicted by age.
+            try {
+                const now = new Date();
+                await fs.utimes(videoPath, now, now);
+            }
+            catch { /* ignore */ }
+        }
+        else {
+            progress('Đang tải video...');
+            console.log('[analyze_video] Cache MISS, downloading:', url);
+            // Download to a temp name then atomically rename in, so a concurrent
+            // analyze of the same URL never reads a half-written file.
+            const dlTmp = path.join(CACHE_DIR, `${urlHash}.dl-${crypto.randomBytes(4).toString('hex')}.mp4`);
+            try {
+                await run(YT_DLP, ['-f', 'best[height<=720]/best', '-o', dlTmp, '--no-playlist', '--quiet', url]);
+                await fs.rename(dlTmp, videoPath);
+            }
+            catch (e) {
+                await fs.rm(dlTmp, { force: true }).catch(() => { });
+                throw e;
+            }
+        }
         // Grab the original video title (metadata only, no extra download) so the
         // clone idea gets a real name instead of "Clone: www.youtube.com".
         let source_title = '';
@@ -269,56 +339,74 @@ export async function analyzeVideo(url, onProgress) {
         // 90s monologue becomes ~11 scenes instead of one giant clip. A hard
         // ceiling still bounds runaway vision cost on very long videos.
         const TARGET_SCENE_SEC = 8;
-        const HARD_CAP = 600; // ~80 min @ 8s — safety bound on vision API spend
-        const targetScenes = Math.max(1, Math.ceil(durationSec / TARGET_SCENE_SEC));
-        const MAX_SCENES = Math.min(targetScenes + 20, HARD_CAP);
-        // Split a [start,end] span into ≤TARGET_SCENE_SEC sub-slots, preserving
-        // the voiceover on the FIRST sub-slot (the rest are silent continuations
-        // of the same spoken line so lip-sync isn't duplicated downstream).
-        const pushSplit = (start, end, voiceover) => {
-            const span = end - start;
-            if (span <= TARGET_SCENE_SEC * 1.5) {
-                sceneSlots.push({ start, end, voiceover });
-                return;
-            }
-            const n = Math.ceil(span / TARGET_SCENE_SEC);
-            const step = span / n;
-            for (let k = 0; k < n; k++) {
-                sceneSlots.push({
-                    start: start + k * step,
-                    end: k === n - 1 ? end : start + (k + 1) * step,
-                    voiceover: k === 0 ? voiceover : '',
-                });
-            }
-        };
+        // Safety ceiling ONLY (≈80 min @ 8s). It must NOT be derived from
+        // ceil(duration/8): Whisper emits hundreds of 2-4s segments for a talky
+        // video, so a tighter cap + slice() silently dropped the back half of
+        // the video (13-min clip → 118 slots → only first 6:21 kept). The
+        // normalise pass below already collapses tiny segments into ~8s scenes,
+        // so the natural count ≈ ceil(duration/8) and this only guards runaway.
+        const HARD_CAP = 600;
+        const spans = [];
         if (segments.length > 0) {
-            if (segments[0].start > SILENCE_THRESHOLD) {
-                pushSplit(0, segments[0].start, '');
-            }
+            if (segments[0].start > SILENCE_THRESHOLD)
+                spans.push({ start: 0, end: segments[0].start, voiceover: '' });
             for (let i = 0; i < segments.length; i++) {
                 const seg = segments[i];
-                pushSplit(seg.start, seg.end, seg.text?.trim() || '');
+                spans.push({ start: seg.start, end: seg.end, voiceover: seg.text?.trim() || '' });
                 if (i < segments.length - 1) {
                     const gap = segments[i + 1].start - seg.end;
-                    if (gap > SILENCE_THRESHOLD) {
-                        pushSplit(seg.end, segments[i + 1].start, '');
-                    }
+                    if (gap > SILENCE_THRESHOLD)
+                        spans.push({ start: seg.end, end: segments[i + 1].start, voiceover: '' });
                 }
             }
             const lastEnd = segments[segments.length - 1].end;
-            if (durationSec - lastEnd > SILENCE_THRESHOLD) {
-                pushSplit(lastEnd, durationSec, '');
-            }
+            if (durationSec - lastEnd > SILENCE_THRESHOLD)
+                spans.push({ start: lastEnd, end: durationSec, voiceover: '' });
         }
         else {
-            // No transcript — split into scenes every 8s (Veo3 clip length)
             for (let t = 0; t < durationSec; t += TARGET_SCENE_SEC) {
-                sceneSlots.push({ start: t, end: Math.min(t + TARGET_SCENE_SEC, durationSec), voiceover: '' });
+                spans.push({ start: t, end: Math.min(t + TARGET_SCENE_SEC, durationSec), voiceover: '' });
+            }
+        }
+        // 2) Normalise every span to ~TARGET-second scenes covering the FULL
+        // timeline:
+        //   - long span (> 1.5×TARGET): split into ceil(span/TARGET) equal slots
+        //   - short spans: greedily MERGE consecutive ones until ≈TARGET so a
+        //     talky video becomes ~ceil(duration/8) Veo3-length scenes instead
+        //     of hundreds of 2s fragments — crucially WITHOUT dropping the tail.
+        for (let i = 0; i < spans.length;) {
+            const s = spans[i];
+            const span = s.end - s.start;
+            if (span > TARGET_SCENE_SEC * 1.5) {
+                const n = Math.ceil(span / TARGET_SCENE_SEC);
+                const step = span / n;
+                for (let k = 0; k < n; k++) {
+                    sceneSlots.push({
+                        start: s.start + k * step,
+                        end: k === n - 1 ? s.end : s.start + (k + 1) * step,
+                        voiceover: k === 0 ? s.voiceover : '',
+                    });
+                }
+                i++;
+            }
+            else {
+                let end = s.end;
+                const vo = s.voiceover ? [s.voiceover] : [];
+                let j = i + 1;
+                while (j < spans.length &&
+                    (end - s.start) < TARGET_SCENE_SEC &&
+                    (spans[j].end - s.start) <= TARGET_SCENE_SEC * 1.5) {
+                    end = spans[j].end;
+                    if (spans[j].voiceover)
+                        vo.push(spans[j].voiceover);
+                    j++;
+                }
+                sceneSlots.push({ start: s.start, end, voiceover: vo.join(' ') });
+                i = j;
             }
         }
-        // Duration-aware cap (was a flat 30 — that silently truncated any video
-        // longer than ~4 min). Re-number after slicing.
-        const finalSlots = sceneSlots.slice(0, MAX_SCENES);
+        // slice() now only ever trims pathological >80-min inputs.
+        const finalSlots = sceneSlots.slice(0, HARD_CAP);
         progress(`Đang cắt ${finalSlots.length} frames và phân tích...`);
         console.log('[analyze_video] Building', finalSlots.length, 'scenes (segments:', segments.length, ', duration:', durationSec, 's)');
         // Step 1: Extract frames sequentially. Per scene we grab 3 chronological

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuna-agent",
-  "version": "0.1.136",
+  "version": "0.1.138",
   "description": "Tuna Agent - Run AI coding tasks on your machine",
   "bin": {
     "tuna-agent": "dist/cli/index.js"