task-summary-extractor 8.3.0 → 9.0.1

package/src/phases/deep-dive.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const path = require('path');
+
+// --- Modes ---
+const { discoverTopics, generateAllDocuments, writeDeepDiveOutput } = require('../modes/deep-dive');
+
+// --- Utils ---
+const { c } = require('../utils/colors');
+
+// --- Shared state ---
+const { getLog, phaseTimer, PROJECT_ROOT } = require('./_shared');
+
+// ======================== PHASE: DEEP DIVE ========================
+
+/**
+ * Generate explanatory documents for topics discussed in the meeting.
+ * Two-phase: discover topics → generate documents in parallel.
+ */
+async function phaseDeepDive(ctx, compiledAnalysis, runDir) {
+  const log = getLog();
+  const timer = phaseTimer('deep_dive');
+  const { ai, callName, userName, costTracker, opts, contextDocs } = ctx;
+
+  console.log('');
+  console.log(c.cyan('══════════════════════════════════════════════'));
+  console.log(c.heading('  DEEP DIVE — Generating Explanatory Documents'));
+  console.log(c.cyan('══════════════════════════════════════════════'));
+  console.log('');
+
+  const thinkingBudget = opts.thinkingBudget ||
+    require('../config').DEEP_DIVE_THINKING_BUDGET;
+
+  // Gather context snippets from inline text docs (for richer AI context)
+  const contextSnippets = [];
+  for (const doc of (contextDocs || [])) {
+    if (doc.type === 'inlineText' && doc.content) {
+      const snippet = doc.content.length > 3000
+        ? doc.content.slice(0, 3000) + '\n... (truncated)'
+        : doc.content;
+      contextSnippets.push(`[${doc.fileName}]\n${snippet}`);
+    }
+  }
+
+  // Phase 1: Discover topics
+  console.log(`  ${c.dim('Phase 1:')} Discovering topics...`);
+  let topicResult;
+  try {
+    topicResult = await discoverTopics(ai, compiledAnalysis, {
+      callName, userName, thinkingBudget, contextSnippets,
+    });
+  } catch (err) {
+    console.error(`  ${c.error(`Topic discovery failed: ${err.message}`)}`);
+    log.error(`Deep dive topic discovery failed: ${err.message}`);
+    timer.end();
+    return;
+  }
+
+  const topics = topicResult.topics;
+  if (!topics || topics.length === 0) {
+    console.log(`  ${c.info('No topics identified for deep dive')}`);
+    log.step('Deep dive: no topics discovered');
+    timer.end();
+    return;
+  }
+
+  console.log(`  ${c.success(`Found ${c.highlight(topics.length)} topic(s):`)}`);
+  topics.forEach(t => console.log(`    ${c.cyan(t.id)} ${c.dim(`[${t.category}]`)} ${t.title}`));
+  console.log('');
+
+  if (topicResult.tokenUsage) {
+    costTracker.addSegment('deep-dive-discovery', topicResult.tokenUsage, topicResult.durationMs, false);
+  }
+  log.step(`Deep dive: ${topics.length} topics discovered in ${(topicResult.durationMs / 1000).toFixed(1)}s`);
+
+  // Phase 2: Generate documents
+  console.log(`  ${c.dim('Phase 2:')} Generating ${c.highlight(topics.length)} document(s)...`);
+  const documents = await generateAllDocuments(ai, topics, compiledAnalysis, {
+    callName,
+    userName,
+    thinkingBudget,
+    contextSnippets,
+    concurrency: Math.min(opts.parallelAnalysis || 2, 3), // match pipeline parallelism
+    onProgress: (done, total, topic) => {
+      console.log(`    ${c.dim(`[${done}/${total}]`)} ${c.success(topic.title)}`);
+    },
+  });
+
+  // Track cost
+  for (const doc of documents) {
+    if (doc.tokenUsage && doc.tokenUsage.totalTokens > 0) {
+      costTracker.addSegment(`deep-dive-${doc.topic.id}`, doc.tokenUsage, doc.durationMs, false);
+    }
+  }
+
+  // Phase 3: Write output
+  const deepDiveDir = path.join(runDir, 'deep-dive');
+  const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const { indexPath, stats } = writeDeepDiveOutput(deepDiveDir, documents, {
+    callName,
+    timestamp: ts,
+  });
+
+  console.log('');
+  console.log(`  ${c.success(`Deep dive complete: ${c.highlight(stats.successful + '/' + stats.total)} documents generated`)}`);
+  console.log(`    Output: ${c.cyan(path.relative(PROJECT_ROOT, deepDiveDir) + '/')}`);
+  console.log(`    Index:  ${c.cyan(path.relative(PROJECT_ROOT, indexPath))}`);
+  if (stats.failed > 0) {
+    console.log(`    ${c.warn(`${stats.failed} document(s) failed`)}`);
+  }
+  console.log(`    Tokens: ${c.yellow(stats.totalTokens.toLocaleString())} | Time: ${c.yellow((stats.totalDurationMs / 1000).toFixed(1) + 's')}`);
+  console.log('');
+
+  log.step(`Deep dive complete: ${stats.successful} docs, ${stats.totalTokens} tokens, ${(stats.totalDurationMs / 1000).toFixed(1)}s`);
+  timer.end();
+}
+
+module.exports = phaseDeepDive;

package/src/phases/discover.js

@@ -0,0 +1,178 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// --- Config ---
+const config = require('../config');
+const { VIDEO_EXTS, AUDIO_EXTS, DOC_EXTS, SPEED, SEG_TIME } = config;
+
+// --- Utils ---
+const { c } = require('../utils/colors');
+const { findDocsRecursive } = require('../utils/fs');
+const { promptUserText } = require('../utils/cli');
+
+// --- Shared state ---
+const { getLog, phaseTimer } = require('./_shared');
+
+// ======================== PHASE: DISCOVER ========================
+
+/**
+ * Discover videos and documents, resolve user name, show banner.
+ * Returns augmented ctx with videoFiles, allDocFiles, userName.
+ */
+async function phaseDiscover(ctx) {
+  const log = getLog();
+  const timer = phaseTimer('discover');
+  const { opts, targetDir, progress } = ctx;
+
+  // --- Find video files ---
+  let videoFiles = fs.readdirSync(targetDir)
+    .filter(f => {
+      const stat = fs.statSync(path.join(targetDir, f));
+      return stat.isFile() && VIDEO_EXTS.includes(path.extname(f).toLowerCase());
+    })
+    .map(f => path.join(targetDir, f));
+
+  // --- Find audio files (if no video) ---
+  let audioFiles = [];
+  if (videoFiles.length === 0) {
+    audioFiles = fs.readdirSync(targetDir)
+      .filter(f => {
+        const stat = fs.statSync(path.join(targetDir, f));
+        return stat.isFile() && AUDIO_EXTS.includes(path.extname(f).toLowerCase());
+      })
+      .map(f => path.join(targetDir, f));
+  }
+
+  // --- Find ALL document files recursively ---
+  const allDocFiles = findDocsRecursive(targetDir, DOC_EXTS);
+
+  // --- Determine input mode ---
+  let inputMode;
+  if (videoFiles.length > 0) {
+    inputMode = 'video';
+  } else if (audioFiles.length > 0) {
+    inputMode = 'audio';
+  } else if (allDocFiles.length > 0) {
+    inputMode = 'document';
+  } else {
+    throw new Error(
+      'No processable files found (video, audio, or documents).\n' +
+      '  Supported: .mp4 .mkv .avi .mov .webm (video) | .mp3 .wav .m4a .ogg .flac .aac .wma (audio) | .vtt .txt .pdf .docx .md (docs)'
+    );
+  }
+
+  // Combine video + audio into mediaFiles for processing
+  const mediaFiles = inputMode === 'video' ? videoFiles : audioFiles;
+
+  const modeBanner = inputMode === 'video'  ? ' Video Compress → Upload → AI Process' :
+                     inputMode === 'audio'  ? ' Audio Compress → Upload → AI Process' :
+                                              ' Document Analysis → AI Process';
+
+  console.log('');
+  console.log(c.cyan('=============================================='));
+  console.log(c.heading(modeBanner));
+  console.log(c.cyan('=============================================='));
+
+  // Show active flags
+  const activeFlags = [];
+  if (opts.skipUpload) activeFlags.push('skip-upload');
+  if (opts.forceUpload) activeFlags.push('force-upload');
+  if (opts.noStorageUrl) activeFlags.push('no-storage-url');
+  if (opts.skipCompression) activeFlags.push('skip-compression');
+  if (opts.skipGemini) activeFlags.push('skip-gemini');
+  if (opts.resume) activeFlags.push('resume');
+  if (opts.reanalyze) activeFlags.push('reanalyze');
+  if (opts.dryRun) activeFlags.push('dry-run');
+  if (activeFlags.length > 0) {
+    console.log(`  Flags: ${c.yellow(activeFlags.join(', '))}`);
+  }
+  console.log('');
+
+  // --- Resume check ---
+  if (opts.resume && progress.hasResumableState()) {
+    progress.printResumeSummary();
+    console.log('');
+  }
+
+  // --- Ask for user's name (or use --name flag) ---
+  let userName = opts.userName;
+  if (!userName) {
+    if (opts.resume && progress.state.userName) {
+      userName = progress.state.userName;
+      console.log(`  Using saved name: ${c.cyan(userName)}`);
+    } else {
+      userName = await promptUserText('  Your name (for task assignment detection): ');
+    }
+  }
+  if (!userName) {
+    throw new Error('Name is required for personalized analysis. Use --name "Your Name" or enter it when prompted.');
+  }
+  log.step(`User identified as: ${userName}`);
+
+  console.log('');
+  console.log(`  User    : ${c.cyan(userName)}`);
+  console.log(`  Source  : ${c.dim(targetDir)}`);
+  console.log(`  Input   : ${c.yellow(inputMode)}`);
+  if (inputMode === 'video') console.log(`  Videos  : ${c.highlight(videoFiles.length)}`);
+  if (inputMode === 'audio') console.log(`  Audio   : ${c.highlight(audioFiles.length)}`);
+  console.log(`  Docs    : ${c.highlight(allDocFiles.length)}`);
+  if (inputMode !== 'document') {
+    console.log(`  Speed   : ${c.yellow(SPEED + 'x')}`);
+    console.log(`  Segments: ${c.dim('< 5 min each')} (${c.yellow(SEG_TIME + 's')})`);
+  }
+  console.log(`  Model   : ${c.cyan(config.GEMINI_MODEL)}`);
+  if (inputMode !== 'document') {
+    console.log(`  Parallel: ${c.yellow(opts.parallel)} concurrent uploads`);
+  }
+  console.log(`  Thinking: ${c.yellow(opts.thinkingBudget)} tokens ${c.dim('(analysis)')} / ${c.yellow(opts.compilationThinkingBudget)} tokens ${c.dim('(compilation)')}`);
+  console.log('');
+
+  // Save progress init
+  progress.init(path.basename(targetDir), userName);
+
+  if (inputMode === 'document') {
+    console.log(`  ${c.info('No video or audio files found \u2014 running in document-only mode.')}`);
+    console.log(`  ${c.dim('Tip: Use --dynamic for custom document generation.')}\n`);
+  } else {
+    const mediaLabel = inputMode === 'video' ? 'video' : 'audio';
+    console.log(`  Found ${c.highlight(mediaFiles.length)} ${mediaLabel} file(s):`);
+    mediaFiles.forEach((f, i) => console.log(`    ${c.dim(`[${i + 1}]`)} ${c.cyan(path.basename(f))}`));
+
+    // If multiple media files found, let user select which to process
+    if (mediaFiles.length > 1) {
+      console.log('');
+      const selectionInput = await promptUserText(`  Which files to process? (comma-separated numbers, or "all", default: all): `);
+      const trimmed = (selectionInput || '').trim().toLowerCase();
+      if (trimmed && trimmed !== 'all') {
+        const indices = trimmed.split(',').map(s => parseInt(s.trim(), 10) - 1).filter(n => !isNaN(n) && n >= 0 && n < mediaFiles.length);
+        if (indices.length > 0) {
+          const selected = indices.map(i => mediaFiles[i]);
+          if (inputMode === 'video') videoFiles = selected;
+          else audioFiles = selected;
+          console.log(`  \u2192 Processing ${c.highlight(selected.length)} selected file(s):`);
+          selected.forEach(f => console.log(`    ${c.dim('-')} ${c.cyan(path.basename(f))}`));
+        } else {
+          console.log(`  \u2192 ${c.dim('Invalid selection, processing all files')}`);
+        }
+      } else {
+        console.log(`  \u2192 Processing all ${c.highlight(mediaLabel)} files`);
+      }
+    }
+    const finalMedia = inputMode === 'video' ? videoFiles : audioFiles;
+    log.step(`Found ${finalMedia.length} ${mediaLabel}(s): ${finalMedia.map(f => path.basename(f)).join(', ')}`);
+    console.log('');
+  }
+
+  if (allDocFiles.length > 0) {
+    console.log(`  Found ${c.highlight(allDocFiles.length)} document(s) for context ${c.dim('(recursive)')}:`);
+    allDocFiles.forEach(f => console.log(`    ${c.dim('-')} ${c.cyan(f.relPath)}`));
+    console.log('');
+  }
+
+  timer.end();
+  return { ...ctx, videoFiles, audioFiles, allDocFiles, userName, inputMode };
+}
+
+module.exports = phaseDiscover;

package/src/phases/init.js

@@ -0,0 +1,199 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// --- Config ---
+const config = require('../config');
+const {
+  LOG_LEVEL, MAX_PARALLEL_UPLOADS, THINKING_BUDGET, COMPILATION_THINKING_BUDGET,
+  validateConfig, GEMINI_MODELS, setActiveModel, getActiveModelPricing,
+} = config;
+
+// --- Utils ---
+const { c } = require('../utils/colors');
+const { parseArgs, showHelp, selectFolder, selectModel } = require('../utils/cli');
+const { promptForKey } = require('../utils/global-config');
+const Logger = require('../logger');
+const Progress = require('../utils/checkpoint');
+const CostTracker = require('../utils/cost-tracker');
+const { createProgressBar } = require('../utils/progress-bar');
+const { loadHistory, analyzeHistory, printLearningInsights } = require('../utils/learning-loop');
+
+// --- Shared state ---
+const { PKG_ROOT, PROJECT_ROOT, setLog, isShuttingDown, setShuttingDown } = require('./_shared');
+
+/** Parse an integer flag, falling back to `defaultVal` only when the input is absent or NaN. */
+function safeInt(raw, defaultVal) {
+  if (raw === undefined || raw === null || raw === true) return defaultVal;
+  const n = parseInt(raw, 10);
+  return Number.isNaN(n) ? defaultVal : n;
+}
+
+// ======================== PHASE: INIT ========================
+
+/**
+ * Parse CLI args, validate config, initialize logger, set up shutdown handlers.
+ * Returns the pipeline context object shared by all phases.
+ */
+async function phaseInit() {
+  const { flags, positional } = parseArgs(process.argv.slice(2));
+
+  if (flags.help || flags.h) showHelp();
+  if (flags.version || flags.v) {
+    const pkg = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, 'package.json'), 'utf8'));
+    process.stdout.write(`v${pkg.version}\n`);
+    throw Object.assign(new Error('VERSION_SHOWN'), { code: 'VERSION_SHOWN' });
+  }
+
+  const opts = {
+    skipUpload: !!flags['skip-upload'],
+    forceUpload: !!flags['force-upload'],
+    noStorageUrl: !!flags['no-storage-url'],
+    skipCompression: !!flags['skip-compression'],
+    skipGemini: !!flags['skip-gemini'],
+    resume: !!flags.resume,
+    reanalyze: !!flags.reanalyze,
+    dryRun: !!flags['dry-run'],
+    userName: flags.name || null,
+    parallel: safeInt(flags.parallel, MAX_PARALLEL_UPLOADS),
+    logLevel: flags['log-level'] || LOG_LEVEL,
+    outputDir: flags.output || null,
+    thinkingBudget: safeInt(flags['thinking-budget'], THINKING_BUDGET),
+    compilationThinkingBudget: safeInt(flags['compilation-thinking-budget'], COMPILATION_THINKING_BUDGET),
+    parallelAnalysis: safeInt(flags['parallel-analysis'], 2), // concurrent segment analysis
+    disableFocusedPass: !!flags['no-focused-pass'],
+    disableLearning: !!flags['no-learning'],
+    disableDiff: !!flags['no-diff'],
+    noHtml: !!flags['no-html'],
+    deepDive: !!flags['deep-dive'],
+    dynamic: !!flags.dynamic,
+    request: typeof flags.request === 'string' ? flags.request : null,
+    updateProgress: !!flags['update-progress'],
+    repoPath: flags.repo || null,
+    model: typeof flags.model === 'string' ? flags.model : null,
+    minConfidence: typeof flags['min-confidence'] === 'string' ? flags['min-confidence'].toLowerCase() : null,
+    format: typeof flags.format === 'string' ? flags.format.toLowerCase() : 'all',
+  };
+
+  // --- Validate min-confidence level ---
+  if (opts.minConfidence) {
+    const { validateConfidenceLevel } = require('../utils/confidence-filter');
+    const check = validateConfidenceLevel(opts.minConfidence);
+    if (!check.valid) {
+      throw new Error(check.error);
+    }
+    opts.minConfidence = check.normalised.toLowerCase();
+  }
+
+  // --- Validate --format flag ---
+  const VALID_FORMATS = new Set(['md', 'html', 'json', 'pdf', 'docx', 'all']);
+  if (!VALID_FORMATS.has(opts.format)) {
+    throw new Error(`Invalid --format "${opts.format}". Must be: md, html, json, pdf, docx, or all`);
+  }
+
+  // --- Resolve folder: positional arg or interactive selection ---
+  let folderArg = positional[0];
+  if (!folderArg) {
+    folderArg = await selectFolder(PROJECT_ROOT);
+    if (!folderArg) {
+      showHelp();
+    }
+  }
+
+  const targetDir = path.resolve(folderArg);
+  if (!fs.existsSync(targetDir) || !fs.statSync(targetDir).isDirectory()) {
+    throw new Error(`"${targetDir}" is not a valid folder. Check the path and try again.`);
+  }
+
+  // --- Validate configuration (with first-run recovery) ---
+  let configCheck = validateConfig({
+    skipFirebase: opts.skipUpload,
+    skipGemini: opts.skipGemini,
+  });
+
+  // First-run experience: if GEMINI_API_KEY is missing, prompt interactively
+  if (!configCheck.valid && !opts.skipGemini && !config.GEMINI_API_KEY) {
+    const key = await promptForKey('GEMINI_API_KEY');
+    if (key) {
+      // Re-validate after user provided the key
+      configCheck = validateConfig({
+        skipFirebase: opts.skipUpload,
+        skipGemini: opts.skipGemini,
+      });
+    }
+  }
+
+  if (!configCheck.valid) {
+    console.error(`\n  ${c.error('Configuration errors:')}`);
+    configCheck.errors.forEach(e => console.error(`    ${c.error(e)}`));
+    console.error(`\n  ${c.dim('Fix these via:')}`);
+    console.error(`    ${c.dim('•')} ${c.cyan('taskex config')}          ${c.dim('(save globally for all projects)')}`);
+    console.error(`    ${c.dim('•')} ${c.cyan('.env file')}              ${c.dim('(project-specific config)')}`);
+    console.error(`    ${c.dim('•')} ${c.cyan('--gemini-key <key>')}     ${c.dim('(one-time inline)')}\n`);
+    throw new Error('Invalid configuration. See errors above.');
+  }
+
+  // --- Initialize logger ---
+  const logsDir = path.join(PROJECT_ROOT, 'logs');
+  const log = new Logger(logsDir, path.basename(targetDir), { level: opts.logLevel });
+  setLog(log);
+  log.patchConsole();
+  log.step(`START processing "${path.basename(targetDir)}"`);
+
+  // --- Learning Loop: load historical insights ---
+  let learningInsights = { hasData: false, budgetAdjustment: 0, compilationBudgetAdjustment: 0 };
+  if (!opts.disableLearning) {
+    const history = loadHistory(PROJECT_ROOT);
+    learningInsights = analyzeHistory(history);
+    if (learningInsights.hasData) {
+      printLearningInsights(learningInsights);
+      // Apply budget adjustments from learning (clamped to model max)
+      if (learningInsights.budgetAdjustment !== 0) {
+        const modelMax = config.getMaxThinkingBudget();
+        opts.thinkingBudget = Math.min(modelMax, Math.max(8192, opts.thinkingBudget + learningInsights.budgetAdjustment));
+        log.step(`Learning: adjusted thinking budget → ${opts.thinkingBudget}`);
+      }
+      if (learningInsights.compilationBudgetAdjustment !== 0) {
+        const modelMax = config.getMaxThinkingBudget();
+        opts.compilationThinkingBudget = Math.min(modelMax, Math.max(8192, opts.compilationThinkingBudget + learningInsights.compilationBudgetAdjustment));
+        log.step(`Learning: adjusted compilation budget → ${opts.compilationThinkingBudget}`);
+      }
+    }
+  }
+
+  // --- Graceful shutdown handler ---
+  const shutdown = (signal) => {
+    if (isShuttingDown()) return;
+    setShuttingDown(true);
+    console.warn(`\n  ${c.warn(`Received ${signal} \u2014 shutting down gracefully...`)}`);
+    log.step(`SHUTDOWN requested (${signal})`);
+    log.close();
+  };
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+
+  // --- Model selection ---
+  if (opts.model) {
+    // CLI flag: --model <id> — validate and activate
+    setActiveModel(opts.model);
+    log.step(`Model set via flag: ${config.GEMINI_MODEL}`);
+  } else {
+    // Interactive model selection
+    const chosenModel = await selectModel(GEMINI_MODELS, config.GEMINI_MODEL);
+    setActiveModel(chosenModel);
+    log.step(`Model selected: ${config.GEMINI_MODEL}`);
+  }
+
+  // --- Initialize progress tracking ---
+  const progress = new Progress(targetDir);
+  const costTracker = new CostTracker(getActiveModelPricing());
+  const progressBar = createProgressBar({
+    costTracker,
+    callName: path.basename(targetDir),
+  });
+
+  return { opts, targetDir, progress, costTracker, progressBar };
+}
+
+module.exports = phaseInit;