task-summary-extractor 8.1.0

package/src/services/git.js

@@ -0,0 +1,329 @@
+/**
+ * Git Service — wraps git CLI for change detection.
+ *
+ * Provides structured access to git log, diff, and status information
+ * for correlating code changes with call analysis items.
+ *
+ * All commands use execFileSync for safety (no shell injection).
+ * Windows-compatible: uses forward-slash path normalization.
+ */
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// ======================== HELPERS ========================
+
+/**
+ * Execute a git command and return stdout.
+ * Returns null on error instead of throwing.
+ *
+ * @param {string[]} args - Git arguments
+ * @param {string} cwd - Working directory
+ * @returns {string|null}
+ */
+function execGit(args, cwd) {
+  try {
+    return execFileSync('git', args, {
+      cwd,
+      encoding: 'utf8',
+      maxBuffer: 10 * 1024 * 1024, // 10 MB
+      timeout: 30000,
+      windowsHide: true,
+    }).trim();
+  } catch (err) {
+    // Common failures: not a repo, detached HEAD, no commits
+    return null;
+  }
+}
+
+/** Normalize path separators to forward slashes for cross-platform comparison */
+function normPath(p) {
+  return (p || '').replace(/\\/g, '/');
+}
+
+// ======================== AVAILABILITY ========================
+
+/**
+ * Check if git CLI is available on this system.
+ * @returns {boolean}
+ */
+function isGitAvailable() {
+  try {
+    execFileSync('git', ['--version'], {
+      encoding: 'utf8',
+      timeout: 5000,
+      windowsHide: true,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Find the git repository root by walking up from startDir.
+ *
+ * @param {string} startDir - Directory to start searching from
+ * @returns {string|null} Absolute path to git root, or null
+ */
+function findGitRoot(startDir) {
+  const root = execGit(['rev-parse', '--show-toplevel'], startDir);
+  return root ? path.resolve(root) : null;
+}
+
+/**
+ * Check if a directory is inside a git repository.
+ * @param {string} dir
+ * @returns {boolean}
+ */
+function isGitRepo(dir) {
+  return findGitRoot(dir) !== null;
+}
+
+/**
+ * Initialize a new git repository in the given directory.
+ *
+ * Creates the repo, stages all existing files, and makes an initial commit.
+ * If the directory is already a git repo, does nothing and returns the existing root.
+ *
+ * @param {string} dir - Directory to initialize
+ * @returns {{ root: string, created: boolean }} Repo root path and whether it was newly created
+ * @throws {Error} If git is not available or init fails
+ */
+function initRepo(dir) {
+  if (!isGitAvailable()) {
+    throw new Error('git is not installed. Install git to use progress tracking.');
+  }
+
+  // Already a repo — return existing root
+  const existing = findGitRoot(dir);
+  if (existing) return { root: existing, created: false };
+
+  // Initialize
+  const initResult = execGit(['init'], dir);
+  if (initResult === null) {
+    throw new Error(`Failed to initialize git repository in "${dir}". Check directory permissions.`);
+  }
+
+  // Stage all existing files and create initial commit
+  execGit(['add', '-A'], dir);
+  execGit(['commit', '-m', 'Initial commit — baseline for progress tracking', '--allow-empty'], dir);
+
+  const root = findGitRoot(dir);
+  if (!root) {
+    throw new Error(`git init succeeded but repository root could not be resolved in "${dir}".`);
+  }
+  return { root, created: true };
+}
+
+// ======================== COMMIT LOG ========================
+
+/**
+ * Get commits since a given ISO timestamp.
+ *
+ * @param {string} repoPath - Repository root
+ * @param {string} sinceISO - ISO 8601 timestamp (e.g. "2026-02-24T16:22:28")
+ * @param {number} [maxCount=100] - Max commits to return
+ * @returns {Array<{hash: string, author: string, date: string, message: string}>}
+ */
+function getCommitsSince(repoPath, sinceISO, maxCount = 100) {
+  const SEP = '\x00'; // null byte separator — won't appear in messages
+  const format = `%H${SEP}%an${SEP}%aI${SEP}%s`;
+
+  const output = execGit(
+    ['log', `--since=${sinceISO}`, `--format=${format}`, `--max-count=${maxCount}`],
+    repoPath,
+  );
+  if (!output) return [];
+
+  return output.split('\n').filter(Boolean).map(line => {
+    const parts = line.split(SEP);
+    if (parts.length < 4) return null;
+    return {
+      hash: parts[0].slice(0, 12),
+      author: parts[1],
+      date: parts[2],
+      message: parts.slice(3).join(SEP), // message may contain SEP (unlikely)
+    };
+  }).filter(Boolean);
+}
+
+/**
+ * Get commit messages with their changed file lists.
+ * More expensive than getCommitsSince but gives per-commit file info.
+ *
+ * @param {string} repoPath
+ * @param {string} sinceISO
+ * @param {number} [maxCount=50]
+ * @returns {Array<{hash: string, author: string, date: string, message: string, files: string[]}>}
+ */
+function getCommitsWithFiles(repoPath, sinceISO, maxCount = 50) {
+  const output = execGit(
+    ['log', `--since=${sinceISO}`, '--name-only', '--format=COMMIT:%H|%an|%aI|%s', `--max-count=${maxCount}`],
+    repoPath,
+  );
+  if (!output) return [];
+
+  const commits = [];
+  let current = null;
+
+  for (const line of output.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    if (trimmed.startsWith('COMMIT:')) {
+      if (current) commits.push(current);
+      const parts = trimmed.slice(7).split('|');
+      current = {
+        hash: (parts[0] || '').slice(0, 12),
+        author: parts[1] || '',
+        date: parts[2] || '',
+        message: parts.slice(3).join('|'),
+        files: [],
+      };
+    } else if (current) {
+      current.files.push(normPath(trimmed));
+    }
+  }
+  if (current) commits.push(current);
+
+  return commits;
+}
+
+// ======================== CHANGED FILES ========================
+
+/**
+ * Get a deduplicated list of all files changed since a timestamp.
+ * Aggregates across all commits — each file appears once with its last status.
+ *
+ * @param {string} repoPath
+ * @param {string} sinceISO
+ * @returns {Array<{path: string, status: string, changes: number}>}
+ */
+function getChangedFilesSince(repoPath, sinceISO) {
+  const output = execGit(
+    ['log', `--since=${sinceISO}`, '--name-status', '--format='],
+    repoPath,
+  );
+  if (!output) return [];
+
+  const fileMap = new Map();
+  for (const line of output.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const match = trimmed.match(/^([AMDRC])\t(.+)$/);
+    if (match) {
+      const status = match[1];
+      const filePath = normPath(match[2]);
+      const existing = fileMap.get(filePath);
+      if (existing) {
+        existing.changes++;
+        existing.status = status; // latest status wins
+      } else {
+        fileMap.set(filePath, { path: filePath, status, changes: 1 });
+      }
+    }
+  }
+
+  return Array.from(fileMap.values());
+}
+
+// ======================== DIFF CONTENT ========================
+
+/**
+ * Get a summary of changes since a timestamp (insertions/deletions).
+ *
+ * @param {string} repoPath
+ * @param {string} sinceISO
+ * @returns {string} Human-readable diff summary
+ */
+function getDiffSummary(repoPath, sinceISO) {
+  const commits = getCommitsSince(repoPath, sinceISO);
+  if (commits.length === 0) return 'No changes';
+
+  const oldestHash = commits[commits.length - 1].hash;
+  // Try parent..HEAD first
+  let output = execGit(['diff', '--shortstat', `${oldestHash}~1`, 'HEAD'], repoPath);
+  if (!output) {
+    output = execGit(['diff', '--shortstat', oldestHash, 'HEAD'], repoPath);
+  }
+  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 ========================
+
+/**
+ * Get uncommitted working tree changes (staged + unstaged).
+ *
+ * @param {string} repoPath
+ * @returns {Array<{path: string, status: string}>}
+ */
+function getWorkingTreeChanges(repoPath) {
+  const output = execGit(['status', '--porcelain', '-u'], repoPath);
+  if (!output) return [];
+
+  return output.split('\n').filter(Boolean).map(line => {
+    const status = line.slice(0, 2).trim();
+    const filePath = normPath(line.slice(3));
+    return { path: filePath, status };
+  });
+}
+
+/**
+ * Get the current branch name.
+ *
+ * @param {string} repoPath
+ * @returns {string|null}
+ */
+function getCurrentBranch(repoPath) {
+  return execGit(['rev-parse', '--abbrev-ref', 'HEAD'], repoPath);
+}
+
+// ======================== EXPORTS ========================
+
+module.exports = {
+  isGitAvailable,
+  findGitRoot,
+  isGitRepo,
+  initRepo,
+  getCommitsSince,
+  getCommitsWithFiles,
+  getChangedFilesSince,
+  getDiffSummary,
+  getDiffContent,
+  getWorkingTreeChanges,
+  getCurrentBranch,
+  normPath,
+};

package/src/services/video.js

@@ -0,0 +1,305 @@
+/**
+ * Video processing — compression, segmentation, ffmpeg/ffprobe wrappers.
+ *
+ * Improvements:
+ *  - No process.exit() — throws descriptive errors instead
+ *  - Lazy binary detection (not at module load time)
+ *  - Better error messages
+ */
+
+'use strict';
+
+const { execSync, spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const { SPEED, SEG_TIME, PRESET } = require('../config');
+const { fmtDuration } = require('../utils/format');
+
+// ======================== BINARY DETECTION ========================
+
+let _ffmpeg = null;
+let _ffprobe = null;
+
+/** Auto-detect a binary from PATH or common locations. Throws if not found. */
+function findBin(name) {
+  // Cross-platform PATH lookup: 'where' on Windows, 'which' on Linux/Mac
+  const lookupCmd = process.platform === 'win32' ? 'where' : 'which';
+  const suppressStderr = process.platform === 'win32' ? '2>nul' : '2>/dev/null';
+  try {
+    const found = execSync(`${lookupCmd} ${name} ${suppressStderr}`, { encoding: 'utf8' }).trim().split('\n')[0];
+    if (found) return found.trim();
+  } catch { /* ignore */ }
+
+  // Windows-specific fallback location
+  if (process.platform === 'win32') {
+    const common = `C:\\ffmpeg\\bin\\${name}.exe`;
+    if (fs.existsSync(common)) return common;
+  }
+
+  const installHint = process.platform === 'win32'
+    ? `Install ffmpeg from https://www.gyan.dev/ffmpeg/builds/ and add to PATH, or place in C:\\ffmpeg\\bin\\`
+    : `Install ffmpeg: brew install ffmpeg (macOS) or apt install ffmpeg (Linux)`;
+  throw new Error(
+    `${name} not found in PATH. ${installHint}`
+  );
+}
+
+/** Get ffmpeg path (lazy, cached). */
+function getFFmpeg() {
+  if (!_ffmpeg) _ffmpeg = findBin('ffmpeg');
+  return _ffmpeg;
+}
+
+/** Get ffprobe path (lazy, cached). */
+function getFFprobe() {
+  if (!_ffprobe) _ffprobe = findBin('ffprobe');
+  return _ffprobe;
+}
+
+// ======================== PROBING ========================
+
+/** Run ffprobe and return a single value from a stream (safe: no shell interpolation) */
+function probe(filePath, streamSelect, entry) {
+  try {
+    const result = spawnSync(getFFprobe(), [
+      '-v', 'error',
+      '-select_streams', streamSelect,
+      '-show_entries', `stream=${entry}`,
+      '-of', 'csv=p=0',
+      filePath,
+    ], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+    return result.status === 0 ? (result.stdout || '').trim() || null : null;
+  } catch { return null; }
+}
+
+/** Run ffprobe for format-level entries (safe: no shell interpolation) */
+function probeFormat(filePath, entry) {
+  try {
+    const result = spawnSync(getFFprobe(), [
+      '-v', 'error',
+      '-show_entries', `format=${entry}`,
+      '-of', 'csv=p=0',
+      filePath,
+    ], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+    return result.status === 0 ? (result.stdout || '').trim() || null : null;
+  } catch { return null; }
+}
+
+// ======================== COMPRESSION ========================
+
+/**
+ * Verify a segment file is a valid MP4 (has moov atom, readable by ffprobe).
+ * Returns true if valid, false if corrupt.
+ */
+function verifySegment(segPath) {
+  try {
+    const dur = probeFormat(segPath, 'duration');
+    return dur !== null && parseFloat(dur) > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Build the common ffmpeg encoding args (video + audio filters/codecs).
+ * Returns { encodingArgs, effectiveDuration }.
+ */
+function buildEncodingArgs(inputFile) {
+  const width = parseInt(probe(inputFile, 'v:0', 'width') || '0');
+  const channels = parseInt(probe(inputFile, 'a:0', 'channels') || '1');
+  const sampleRate = probe(inputFile, 'a:0', 'sample_rate') || '16000';
+  const duration = probeFormat(inputFile, 'duration');
+  const durationSec = duration ? parseFloat(duration) : null;
+  const effectiveDuration = durationSec ? durationSec / SPEED : null;
+
+  let vf = `setpts=PTS/${SPEED}`;
+  let crf = 24;
+  let tune = ['-tune', 'stillimage'];
+  let profile = ['-profile:v', 'main'];
+  let audioBr = '64k';
+  let x264p = 'aq-mode=3:deblock=-1,-1:psy-rd=1.0,0.0';
+
+  if (width > 1920) {
+    // 4K+ → scale to 1080p
+    vf = `scale=1920:1080,unsharp=3:3:0.3,setpts=PTS/${SPEED}`;
+    crf = 20;
+    tune = [];
+    profile = ['-profile:v', 'high'];
+    audioBr = '128k';
+  } else if (width > 0) {
+    // Meeting / screenshare
+    vf = `unsharp=3:3:0.3,setpts=PTS/${SPEED}`;
+  }
+
+  if (channels === 2) audioBr = '128k';
+
+  const encodingArgs = [
+    '-vf', vf,
+    '-af', `atempo=${SPEED}`,
+    '-c:v', 'libx264', '-crf', String(crf), '-preset', PRESET,
+    ...tune,
+    '-x264-params', x264p,
+    ...profile,
+    '-pix_fmt', 'yuv420p',
+    '-c:a', 'aac', '-b:a', audioBr, '-ar', sampleRate, '-ac', String(channels),
+    '-movflags', '+faststart',
+  ];
+
+  return { encodingArgs, effectiveDuration, width, crf, audioBr, duration };
+}
+
+/**
+ * Compress and segment a video file using ffmpeg.
+ * - Short videos (effective duration ≤ SEG_TIME) → single MP4 output (avoids segment muxer issues).
+ * - Long videos → segment muxer for splitting.
+ * - Post-compression validation: verifies each output has a valid moov atom.
+ *   Corrupt segments are re-encoded individually with the regular MP4 muxer.
+ * Returns sorted array of segment file paths.
+ */
+function compressAndSegment(inputFile, outputDir) {
+  const { encodingArgs, effectiveDuration, width, crf, audioBr, duration } = buildEncodingArgs(inputFile);
+
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  console.log(`  Resolution : ${width > 0 ? width + 'p' : 'unknown'}`);
+  console.log(`  Duration   : ${duration ? fmtDuration(parseFloat(duration)) : 'unknown'}${effectiveDuration ? ` (${fmtDuration(effectiveDuration)} at ${SPEED}x)` : ''}`);
+  console.log(`  CRF ${crf} | ${audioBr} audio | ${SPEED}x speed`);
+
+  // Decide: single output vs segmented
+  const needsSegmentation = effectiveDuration === null || effectiveDuration > SEG_TIME;
+
+  if (needsSegmentation) {
+    console.log(`  Compressing (segmented, ${SEG_TIME}s chunks)...`);
+    const args = [
+      '-y', '-err_detect', 'ignore_err', '-fflags', '+genpts+discardcorrupt',
+      '-i', inputFile,
+      ...encodingArgs,
+      '-f', 'segment', '-segment_time', String(SEG_TIME), '-reset_timestamps', '1',
+      '-map', '0:v:0', '-map', '0:a:0',
+      path.join(outputDir, 'segment_%02d.mp4'),
+    ];
+
+    const result = spawnSync(getFFmpeg(), args, { stdio: 'inherit' });
+    if (result.status !== 0) {
+      console.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.mp4');
+    const args = [
+      '-y', '-err_detect', 'ignore_err', '-fflags', '+genpts+discardcorrupt',
+      '-i', inputFile,
+      ...encodingArgs,
+      '-map', '0:v:0', '-map', '0:a:0',
+      outPath,
+    ];
+
+    const result = spawnSync(getFFmpeg(), args, { stdio: 'inherit' });
+    if (result.status !== 0) {
+      console.warn(`  ⚠ ffmpeg exited with code ${result.status}`);
+    }
+  }
+
+  // Collect segments
+  let segments = fs.readdirSync(outputDir)
+    .filter(f => f.startsWith('segment_') && f.endsWith('.mp4'))
+    .sort()
+    .map(f => path.join(outputDir, f));
+
+  // Post-compression integrity check — verify each segment
+  const valid = [];
+  const corrupt = [];
+  for (const seg of segments) {
+    if (verifySegment(seg)) {
+      valid.push(seg);
+    } else {
+      corrupt.push(seg);
+      console.warn(`  ⚠ Corrupt segment detected: ${path.basename(seg)} (missing moov atom)`);
+    }
+  }
+
+  // Attempt to re-encode corrupt segments from original source
+  if (corrupt.length > 0 && needsSegmentation) {
+    console.log(`  Retrying ${corrupt.length} corrupt segment(s) with regular MP4 muxer...`);
+    // Fallback: re-compress the entire video as a single file, then re-segment if needed
+    const fallbackPath = path.join(outputDir, '_fallback_full.mp4');
+    const fbArgs = [
+      '-y', '-err_detect', 'ignore_err', '-fflags', '+genpts+discardcorrupt',
+      '-i', inputFile,
+      ...encodingArgs,
+      '-map', '0:v:0', '-map', '0:a:0',
+      fallbackPath,
+    ];
+    const fbResult = spawnSync(getFFmpeg(), fbArgs, { stdio: 'inherit' });
+    if (fbResult.status === 0 && verifySegment(fallbackPath)) {
+      // Remove all corrupt segments and replace with the fallback
+      for (const seg of corrupt) { try { fs.unlinkSync(seg); } catch {} }
+      // If this was the only segment, just rename it
+      if (segments.length === 1) {
+        const dest = path.join(outputDir, 'segment_00.mp4');
+        fs.renameSync(fallbackPath, dest);
+        segments = [dest];
+        console.log(`  ✓ Re-encoded successfully as single segment`);
+      } else {
+        // Re-segment the fallback
+        const reSegDir = path.join(outputDir, '_reseg');
+        fs.mkdirSync(reSegDir, { recursive: true });
+        const rsArgs = [
+          '-y', '-i', fallbackPath,
+          '-c', 'copy',
+          '-f', 'segment', '-segment_time', String(SEG_TIME), '-reset_timestamps', '1',
+          '-movflags', '+faststart',
+          path.join(reSegDir, 'segment_%02d.mp4'),
+        ];
+        spawnSync(getFFmpeg(), rsArgs, { stdio: 'inherit' });
+        // Move re-segmented files back, overwriting corrupt ones
+        const reSegs = fs.readdirSync(reSegDir).filter(f => f.endsWith('.mp4')).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 {}
+        // Re-collect
+        segments = fs.readdirSync(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)`);
+      }
+    } else {
+      console.error(`  ✗ Fallback re-encode also failed`);
+      try { fs.unlinkSync(fallbackPath); } catch {}
+    }
+  } else if (corrupt.length > 0 && !needsSegmentation) {
+    // Single-output mode also failed — try once more without segment muxer flags
+    console.log(`  Retrying single-output compression...`);
+    const retryPath = path.join(outputDir, 'segment_00.mp4');
+    try { fs.unlinkSync(retryPath); } catch {}
+    const retryArgs = [
+      '-y',
+      '-i', inputFile,
+      ...encodingArgs,
+      '-map', '0:v:0', '-map', '0:a:0',
+      retryPath,
+    ];
+    const retryResult = spawnSync(getFFmpeg(), retryArgs, { stdio: 'inherit' });
+    if (retryResult.status === 0 && verifySegment(retryPath)) {
+      segments = [retryPath];
+      console.log(`  ✓ Retry succeeded`);
+    } else {
+      console.error(`  ✗ Retry also produced invalid output`);
+    }
+  }
+
+  return segments;
+}
+
+module.exports = {
+  findBin,
+  probe,
+  probeFormat,
+  compressAndSegment,
+  verifySegment,
+  getFFmpeg,
+  getFFprobe,
+};