task-summary-extractor 9.2.0 → 9.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-summary-extractor",
-  "version": "9.2.0",
+  "version": "9.2.2",
   "description": "AI-powered meeting analysis & document generation CLI — video + document processing, deep dive docs, dynamic mode, interactive CLI with model selection, confidence scoring, learning loop, git progress tracking",
   "main": "process_and_upload.js",
   "bin": {

package/src/logger.js

@@ -321,16 +321,17 @@ class Logger {
   /** Flush buffers and close the logger. Safe to call multiple times. */
   close() {
     if (this.closed) return;
-    this.closed = true;
     clearInterval(this._flushInterval);
     this.unpatchConsole();
 
-    // End active phase if any
+    // End active phase if any (must happen BEFORE setting closed flag
+    // so _writeStructured inside phaseEnd is not blocked)
     if (this._activePhase) {
       this.phaseEnd();
     }
 
-    // Write footer
+    // Write footer and session_end BEFORE setting closed flag
+    // so _writeStructured is not blocked by the guard
     const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(1);
     const footer = `\n=== CLOSED | elapsed: ${elapsed}s | ${new Date().toISOString()} ===\n`;
     this._detailedBuffer.push(footer);
@@ -342,6 +343,8 @@ class Logger {
       timestamp: new Date().toISOString(),
       level: 'info',
     });
+
+    this.closed = true;
     this._flush(true); // sync flush on close to ensure data is written before process exits
   }
 

package/src/phases/compile.js

@@ -8,7 +8,7 @@ const { compileFinalResult } = require('../services/gemini');
 
 // --- Utils ---
 const { calculateCompilationBudget } = require('../utils/adaptive-budget');
-const { validateAnalysis, formatSchemaLine } = require('../utils/schema-validator');
+const { validateAnalysis, formatSchemaLine, normalizeAnalysis } = require('../utils/schema-validator');
 const { c } = require('../utils/colors');
 
 // --- Shared state ---
@@ -41,7 +41,7 @@ async function phaseCompile(ctx, allSegmentAnalyses) {
         { thinkingBudget: compBudget.budget }
       );
 
-      compiledAnalysis = compilationResult.compiled;
+      compiledAnalysis = normalizeAnalysis(compilationResult.compiled);
       compilationRun = compilationResult.run;
 
       // Track compilation cost

package/src/phases/process-media.js

@@ -17,7 +17,7 @@ const { fmtDuration, fmtBytes } = require('../utils/format');
 const { promptUser } = require('../utils/cli');
 const { parallelMap } = require('../utils/retry');
 const { assessQuality, formatQualityLine, getConfidenceStats, THRESHOLDS } = require('../utils/quality-gate');
-const { validateAnalysis, formatSchemaLine, schemaScore } = require('../utils/schema-validator');
+const { validateAnalysis, formatSchemaLine, schemaScore, normalizeAnalysis } = require('../utils/schema-validator');
 const { calculateThinkingBudget } = require('../utils/adaptive-budget');
 const { detectBoundaryContext, sliceVttForSegment } = require('../utils/context-manager');
 
@@ -264,7 +264,7 @@ async function phaseProcessVideo(ctx, videoPath, videoIndex) {
       try {
         const existingRun = JSON.parse(fs.readFileSync(latestRunPath, 'utf8'));
         geminiRunFile = path.relative(PROJECT_ROOT, path.join(geminiRunsDir, latestRunFile));
-        analysis = existingRun.output.parsed || { rawResponse: existingRun.output.raw };
+        analysis = normalizeAnalysis(existingRun.output.parsed || { rawResponse: existingRun.output.raw });
         analysis._geminiMeta = {
           model: existingRun.run.model,
           processedAt: existingRun.run.timestamp,
@@ -396,7 +396,7 @@ async function phaseProcessVideo(ctx, videoPath, videoIndex) {
         geminiFileName = geminiRun.input.videoFile.geminiFileName || null;
         const usedExternalUrl = geminiRun.input.videoFile.usedExternalUrl || false;
 
-        analysis = geminiRun.output.parsed || { rawResponse: geminiRun.output.raw };
+        analysis = normalizeAnalysis(geminiRun.output.parsed || { rawResponse: geminiRun.output.raw });
         analysis._geminiMeta = {
           model: geminiRun.run.model,
           processedAt: geminiRun.run.timestamp,
@@ -474,7 +474,7 @@ async function phaseProcessVideo(ctx, videoPath, videoIndex) {
             const retryRunFilePath = path.join(geminiRunsDir, retryRunFileName);
             fs.writeFileSync(retryRunFilePath, JSON.stringify(retryRun, null, 2), 'utf8');
 
-            const retryAnalysis = retryRun.output.parsed || { rawResponse: retryRun.output.raw };
+            const retryAnalysis = normalizeAnalysis(retryRun.output.parsed || { rawResponse: retryRun.output.raw });
             const retryQuality = assessQuality(retryAnalysis, {
               parseSuccess: retryRun.output.parseSuccess,
               rawLength: (retryRun.output.raw || '').length,
@@ -492,7 +492,7 @@ async function phaseProcessVideo(ctx, videoPath, videoIndex) {
             // Use retry result if better
             if (retryQuality.score > qualityReport.score) {
               retryImproved = true;
-              analysis = retryAnalysis;
+              analysis = normalizeAnalysis(retryAnalysis);
               analysis._geminiMeta = {
                 model: retryRun.run.model,
                 processedAt: retryRun.run.timestamp,

package/src/pipeline.js

@@ -231,7 +231,7 @@ async function run() {
 async function runDocOnly(ctx) {
   // Lazy imports for doc-only mode
   const { compileFinalResult } = require('./services/gemini');
-  const { validateAnalysis, formatSchemaLine } = require('./utils/schema-validator');
+  const { validateAnalysis, formatSchemaLine, normalizeAnalysis } = require('./utils/schema-validator');
   const { renderResultsMarkdown } = require('./renderers/markdown');
   const { renderResultsHtml } = require('./renderers/html');
   const { renderResultsPdf } = require('./renderers/pdf');
@@ -297,7 +297,7 @@ async function runDocOnly(ctx) {
       }
     );
 
-    compiledAnalysis = compilationResult.compiled;
+    compiledAnalysis = normalizeAnalysis(compilationResult.compiled);
     compilationRun = compilationResult.run;
 
     if (compilationRun?.tokenUsage) {

package/src/schemas/analysis-segment.schema.json

@@ -5,7 +5,7 @@
   "description": "JSON Schema for a single segment's AI analysis output. Uses additionalProperties:true to allow extra fields without failing.",
   "type": "object",
   "additionalProperties": true,
-  "required": ["tickets", "action_items", "change_requests", "summary"],
+  "required": ["summary"],
   "properties": {
     "tickets": {
       "type": "array",

package/src/utils/json-parser.js

@@ -195,6 +195,9 @@ function repairDoubledClosers(text) {
  * Returns parsed object or null.
  */
 function extractJson(rawText) {
+  // Guard: null/undefined input (e.g. Gemini returns no text)
+  if (!rawText || typeof rawText !== 'string') return null;
+
   // Strategy 1: Strip all markdown fences and try to parse
   const cleaned = rawText.replace(/```json\s*/gi, '').replace(/```\s*/g, '').trim();
   let parsed = tryParseWithSanitize(cleaned);

package/src/utils/quality-gate.js

@@ -29,14 +29,16 @@ const THRESHOLDS = {
 
 // Required top-level fields in a valid analysis
 const REQUIRED_FIELDS = [
-  'tickets',
-  'action_items',
-  'change_requests',
   'summary',
 ];
 
 // Optional but valuable fields (boost score when present)
+// tickets, action_items, change_requests are here because a segment may
+// legitimately contain none of these (e.g. a segment that is only chit-chat).
 const VALUED_FIELDS = [
+  'tickets',
+  'action_items',
+  'change_requests',
   'blockers',
   'scope_changes',
   'file_references',
@@ -70,11 +72,11 @@ function scoreStructure(analysis) {
   let bonus = 0;
   for (const field of VALUED_FIELDS) {
     if (analysis[field] !== undefined && analysis[field] !== null) {
-      bonus += 3; // up to 12 bonus points
+      bonus += 2; // up to 14 bonus points (7 valued fields)
     }
   }
 
-  const baseScore = (present / REQUIRED_FIELDS.length) * 80;
+  const baseScore = (present / REQUIRED_FIELDS.length) * 70;
   return { score: Math.min(100, baseScore + bonus), issues };
 }
 
@@ -335,7 +337,7 @@ function buildRetryHints(analysis, issues) {
   const hints = [];
 
   if (issues.some(i => i.includes('Missing required field'))) {
-    hints.push('CRITICAL: Your previous response was missing required fields. You MUST include ALL of: tickets, action_items, change_requests, summary. Use empty arrays [] if no items exist.');
+    hints.push('CRITICAL: Your previous response was missing the required "summary" field. You MUST include a "summary" string. Include tickets, action_items, and change_requests arrays if relevant — omit them or use empty arrays [] if none exist in this segment.');
   }
 
   if (issues.some(i => i.includes('JSON parse failed'))) {

package/src/utils/schema-validator.js

@@ -306,9 +306,38 @@ function formatSchemaLine(report) {
   return `    ${c.warn(`Schema: ${report.errorCount} error(s) — ${report.errors.slice(0, 2).map(e => e.message).join('; ')}`)}`;
 }
 
+// ======================== POST-PARSE NORMALIZATION ========================
+
+/** Array fields that should default to [] when missing from analysis output. */
+const ARRAY_DEFAULTS = [
+  'tickets', 'action_items', 'change_requests',
+  'blockers', 'scope_changes', 'file_references',
+];
+
+/**
+ * Normalize a parsed analysis object by filling in missing array fields
+ * with empty arrays. This prevents downstream code from crashing when
+ * a segment legitimately has no tickets/action_items/etc.
+ *
+ * Mutates `data` in-place and returns it for convenience.
+ *
+ * @param {object} data - Parsed analysis (may have missing fields)
+ * @returns {object} The same object with defaults applied
+ */
+function normalizeAnalysis(data) {
+  if (!data || typeof data !== 'object') return data;
+  for (const field of ARRAY_DEFAULTS) {
+    if (data[field] === undefined || data[field] === null) {
+      data[field] = [];
+    }
+  }
+  return data;
+}
+
 module.exports = {
   validateAnalysis,
   buildSchemaRetryHints,
   schemaScore,
   formatSchemaLine,
+  normalizeAnalysis,
 };