task-summary-extractor 8.1.0 → 9.0.0

package/src/services/git.js

@@ -254,34 +254,6 @@ function getDiffSummary(repoPath, sinceISO) {
   return output || 'No stat available';
 }
 
-/**
- * Get actual diff content, truncated to maxBytes.
- * Used for keyword matching, NOT sent to Gemini directly.
- *
- * @param {string} repoPath
- * @param {string} sinceISO
- * @param {number} [maxBytes=100000]
- * @returns {string} Diff content (may be truncated)
- */
-function getDiffContent(repoPath, sinceISO, maxBytes = 100000) {
-  const commits = getCommitsSince(repoPath, sinceISO);
-  if (commits.length === 0) return '';
-
-  const oldestHash = commits[commits.length - 1].hash;
-  let output = execGit(
-    ['diff', '--no-color', '-U2', `${oldestHash}~1`, 'HEAD'],
-    repoPath,
-  );
-  if (!output) {
-    output = execGit(['diff', '--no-color', '-U2', oldestHash, 'HEAD'], repoPath);
-  }
-  if (!output) return '';
-
-  return output.length > maxBytes
-    ? output.slice(0, maxBytes) + '\n... (truncated at ' + Math.round(maxBytes / 1024) + ' KB)'
-    : output;
-}
-
 // ======================== WORKING TREE ========================
 
 /**
@@ -322,7 +294,6 @@ module.exports = {
   getCommitsWithFiles,
   getChangedFilesSince,
   getDiffSummary,
-  getDiffContent,
   getWorkingTreeChanges,
   getCurrentBranch,
   normPath,

package/src/services/video.js

@@ -14,6 +14,7 @@ const fs = require('fs');
 const path = require('path');
 const { SPEED, SEG_TIME, PRESET } = require('../config');
 const { fmtDuration } = require('../utils/format');
+const { c } = require('../utils/colors');
 
 // ======================== BINARY DETECTION ========================
 
@@ -181,7 +182,7 @@ function compressAndSegment(inputFile, outputDir) {
 
     const result = spawnSync(getFFmpeg(), args, { stdio: 'inherit' });
     if (result.status !== 0) {
-      console.warn(`  ⚠ ffmpeg exited with code ${result.status} (output may still be usable)`);
+      console.warn(`  ${c.warn(`ffmpeg exited with code ${result.status} (output may still be usable)`)}`);
     }
   } else {
     console.log(`  Compressing (single output, ${effectiveDuration ? fmtDuration(effectiveDuration) : '?'} effective)...`);
@@ -196,7 +197,7 @@ function compressAndSegment(inputFile, outputDir) {
 
     const result = spawnSync(getFFmpeg(), args, { stdio: 'inherit' });
     if (result.status !== 0) {
-      console.warn(`  ⚠ ffmpeg exited with code ${result.status}`);
+      console.warn(`  ${c.warn(`ffmpeg exited with code ${result.status}`)}`);
     }
   }
 
@@ -214,7 +215,7 @@ function compressAndSegment(inputFile, outputDir) {
       valid.push(seg);
     } else {
       corrupt.push(seg);
-      console.warn(`  ⚠ Corrupt segment detected: ${path.basename(seg)} (missing moov atom)`);
+      console.warn(`  ${c.warn(`Corrupt segment detected: ${path.basename(seg)} (missing moov atom)`)}`);
     }
   }
 
@@ -239,7 +240,7 @@ function compressAndSegment(inputFile, outputDir) {
         const dest = path.join(outputDir, 'segment_00.mp4');
         fs.renameSync(fallbackPath, dest);
         segments = [dest];
-        console.log(`  ✓ Re-encoded successfully as single segment`);
+        console.log(`  ${c.success('Re-encoded successfully as single segment')}`);
       } else {
         // Re-segment the fallback
         const reSegDir = path.join(outputDir, '_reseg');
@@ -264,10 +265,10 @@ function compressAndSegment(inputFile, outputDir) {
           .filter(f => f.startsWith('segment_') && f.endsWith('.mp4'))
           .sort()
           .map(f => path.join(outputDir, f));
-        console.log(`  ✓ Re-segmented from fallback: ${segments.length} segment(s)`);
+        console.log(`  ${c.success(`Re-segmented from fallback: ${segments.length} segment(s)`)}`);
       }
     } else {
-      console.error(`  ✗ Fallback re-encode also failed`);
+      console.error(`  ${c.error('Fallback re-encode also failed')}`);
       try { fs.unlinkSync(fallbackPath); } catch {}
     }
   } else if (corrupt.length > 0 && !needsSegmentation) {
@@ -285,9 +286,122 @@ function compressAndSegment(inputFile, outputDir) {
     const retryResult = spawnSync(getFFmpeg(), retryArgs, { stdio: 'inherit' });
     if (retryResult.status === 0 && verifySegment(retryPath)) {
       segments = [retryPath];
-      console.log(`  ✓ Retry succeeded`);
+      console.log(`  ${c.success('Retry succeeded')}`);
     } else {
-      console.error(`  ✗ Retry also produced invalid output`);
+      console.error(`  ${c.error('Retry also produced invalid output')}`);
+    }
+  }
+
+  return segments;
+}
+
+/**
+ * Compress and segment an audio-only file using ffmpeg.
+ * No video stream — just audio compression + segmentation in MP4/M4A container
+ * (for Gemini File API compatibility).
+ *
+ * Returns sorted array of segment file paths.
+ */
+function compressAndSegmentAudio(inputFile, outputDir) {
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  const duration = probeFormat(inputFile, 'duration');
+  const durationSec = duration ? parseFloat(duration) : null;
+  const effectiveDuration = durationSec ? durationSec / SPEED : null;
+  const channels = parseInt(probe(inputFile, 'a:0', 'channels') || '1', 10);
+  const sampleRate = probe(inputFile, 'a:0', 'sample_rate') || '16000';
+  const audioBr = channels >= 2 ? '128k' : '64k';
+
+  console.log(`  Duration : ${duration ? fmtDuration(parseFloat(duration)) : 'unknown'}${effectiveDuration ? ` (${fmtDuration(effectiveDuration)} at ${SPEED}x)` : ''}`);
+  console.log(`  Audio-only mode | ${SPEED}x speed | ${audioBr} bitrate`);
+
+  const encodingArgs = [
+    '-af', `atempo=${SPEED}`,
+    '-c:a', 'aac', '-b:a', audioBr, '-ar', sampleRate, '-ac', String(channels),
+    '-vn',  // no video
+    '-movflags', '+faststart',
+  ];
+
+  const needsSegmentation = effectiveDuration === null || effectiveDuration > SEG_TIME;
+
+  if (needsSegmentation) {
+    console.log(`  Compressing (segmented, ${SEG_TIME}s chunks)...`);
+    const args = [
+      '-y', '-i', inputFile,
+      ...encodingArgs,
+      '-f', 'segment', '-segment_time', String(SEG_TIME), '-reset_timestamps', '1',
+      path.join(outputDir, 'segment_%02d.m4a'),
+    ];
+    const result = spawnSync(getFFmpeg(), args, { stdio: 'inherit' });
+    if (result.status !== 0) {
+      console.warn(`  ${c.warn(`ffmpeg exited with code ${result.status} (output may still be usable)`)}`);
+    }
+  } else {
+    console.log(`  Compressing (single output, ${effectiveDuration ? fmtDuration(effectiveDuration) : '?'} effective)...`);
+    const outPath = path.join(outputDir, 'segment_00.m4a');
+    const args = ['-y', '-i', inputFile, ...encodingArgs, outPath];
+    const result = spawnSync(getFFmpeg(), args, { stdio: 'inherit' });
+    if (result.status !== 0) {
+      console.warn(`  ${c.warn(`ffmpeg exited with code ${result.status}`)}`);
+    }
+  }
+
+  // Collect segments (both .mp4 and .m4a)
+  let segments = fs.readdirSync(outputDir)
+    .filter(f => f.startsWith('segment_') && (f.endsWith('.m4a') || f.endsWith('.mp4')))
+    .sort()
+    .map(f => path.join(outputDir, f));
+
+  // Validate segments
+  const valid = [];
+  const corrupt = [];
+  for (const seg of segments) {
+    if (verifySegment(seg)) {
+      valid.push(seg);
+    } else {
+      corrupt.push(seg);
+      console.warn(`  ${c.warn(`Corrupt audio segment: ${path.basename(seg)}`)}`);
+    }
+  }
+
+  if (corrupt.length > 0) {
+    console.log(`  Retrying ${corrupt.length} corrupt segment(s)...`);
+    const fallbackPath = path.join(outputDir, '_fallback_full.m4a');
+    const fbArgs = ['-y', '-i', inputFile, ...encodingArgs, fallbackPath];
+    const fbResult = spawnSync(getFFmpeg(), fbArgs, { stdio: 'inherit' });
+    if (fbResult.status === 0 && verifySegment(fallbackPath)) {
+      for (const seg of corrupt) { try { fs.unlinkSync(seg); } catch {} }
+      if (segments.length === 1) {
+        const dest = path.join(outputDir, 'segment_00.m4a');
+        fs.renameSync(fallbackPath, dest);
+        segments = [dest];
+        console.log(`  ${c.success('Re-encoded as single segment')}`);
+      } else {
+        // Re-segment
+        const reSegDir = path.join(outputDir, '_reseg');
+        fs.mkdirSync(reSegDir, { recursive: true });
+        const rsArgs = [
+          '-y', '-i', fallbackPath,
+          '-c', 'copy', '-vn',
+          '-f', 'segment', '-segment_time', String(SEG_TIME), '-reset_timestamps', '1',
+          path.join(reSegDir, 'segment_%02d.m4a'),
+        ];
+        spawnSync(getFFmpeg(), rsArgs, { stdio: 'inherit' });
+        const reSegs = fs.readdirSync(reSegDir).filter(f => f.endsWith('.m4a')).sort();
+        for (const f of reSegs) {
+          fs.renameSync(path.join(reSegDir, f), path.join(outputDir, f));
+        }
+        try { fs.rmSync(reSegDir, { recursive: true }); } catch {}
+        try { fs.unlinkSync(fallbackPath); } catch {}
+        segments = fs.readdirSync(outputDir)
+          .filter(f => f.startsWith('segment_') && (f.endsWith('.m4a') || f.endsWith('.mp4')))
+          .sort()
+          .map(f => path.join(outputDir, f));
+        console.log(`  ${c.success(`Re-segmented from fallback: ${segments.length} segment(s)`)}`);
+      }
+    } else {
+      console.error(`  ${c.error('Fallback audio re-encode failed')}`);
+      try { fs.unlinkSync(fallbackPath); } catch {}
     }
   }
 
@@ -299,6 +413,7 @@ module.exports = {
   probe,
   probeFormat,
   compressAndSegment,
+  compressAndSegmentAudio,
   verifySegment,
   getFFmpeg,
   getFFprobe,

package/src/utils/adaptive-budget.js

@@ -14,6 +14,8 @@
 
 'use strict';
 
+const config = require('../config');
+
 // ======================== BUDGET RANGES ========================
 
 const BUDGET = {
@@ -21,12 +23,12 @@ const BUDGET = {
   MIN: 8192,
   /** Base thinking budget for a simple segment */
   BASE: 16384,
-  /** Maximum thinking budget per segment (avoid eating output token pool) */
-  MAX: 32768,
+  /** Maximum thinking budget per segment — dynamically read from model config */
+  get MAX() { return config.getMaxThinkingBudget(); },
   /** Base compilation thinking budget */
   COMPILATION_BASE: 10240,
-  /** Max compilation thinking budget */
-  COMPILATION_MAX: 24576,
+  /** Max compilation thinking budget — dynamically read from model config */
+  get COMPILATION_MAX() { return config.getMaxThinkingBudget(); },
 };
 
 // ======================== COMPLEXITY ANALYSIS ========================
@@ -259,8 +261,6 @@ function calculateCompilationBudget(allSegmentAnalyses, baseBudget = BUDGET.COMP
 }
 
 module.exports = {
-  analyzeTranscriptComplexity,
   calculateThinkingBudget,
   calculateCompilationBudget,
-  BUDGET,
 };

package/src/utils/{progress.js → checkpoint.js}

@@ -11,6 +11,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { c } = require('./colors');
 
 const STATE_FILE = '.pipeline-state.json';
 
@@ -68,7 +69,7 @@ class Progress {
     try {
       fs.writeFileSync(this.filePath, JSON.stringify(this.state, null, 2), 'utf8');
     } catch (err) {
-      console.warn(`  ⚠ Could not save progress: ${err.message}`);
+      console.warn(`  ${c.warn(`Could not save progress: ${err.message}`)}`);
     }
   }