wogiflow 1.0.12 → 1.0.13

package/scripts/{flow-transcript-stories.js → flow-long-input-stories.js}

@@ -15,6 +15,14 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 
+// Import safe utilities
+const { safeJsonParse, writeJson } = require('./flow-utils');
+
+// Utility: ISO timestamp
+function now() {
+  return new Date().toISOString();
+}
+
 // Core functions are injected via init() to avoid circular dependencies
 let digestCore = null;
 
@@ -44,8 +52,9 @@ function isRequirement(s) { requireInit(); return digestCore.isRequirement(s); }
 function isVagueStatement(s) { requireInit(); return digestCore.isVagueStatement(s); }
 function analyzeComplexity() { requireInit(); return digestCore.analyzeComplexity(); }
 
-// State directory
-const STATE_DIR = path.join(process.cwd(), '.workflow', 'state', 'digests');
+// Temp directory for processing (cleaned up after completion)
+const TMP_DIR = path.join(process.cwd(), '.workflow', 'tmp', 'long-input');
+const STATE_DIR = TMP_DIR; // Alias for backward compatibility
 
 // ==========================================================================
 // E3-S2: Story Generation with Source Tracing
@@ -579,11 +588,7 @@ function loadStory(storyId) {
   }
 
   const storyPath = path.join(activeDigest.session.digest_path, 'stories', `${storyId}.json`);
-  try {
-    return JSON.parse(fs.readFileSync(storyPath, 'utf8'));
-  } catch (err) {
-    return null;
-  }
+  return safeJsonParse(storyPath, null);
 }
 
 /**
@@ -598,13 +603,7 @@ function loadAllStories() {
   const storiesPath = path.join(activeDigest.session.digest_path, 'stories');
   try {
     const files = fs.readdirSync(storiesPath).filter(f => f.endsWith('.json'));
-    return files.map(f => {
-      try {
-        return JSON.parse(fs.readFileSync(path.join(storiesPath, f), 'utf8'));
-      } catch (err) {
-        return null;
-      }
-    }).filter(Boolean);
+    return files.map(f => safeJsonParse(path.join(storiesPath, f), null)).filter(Boolean);
   } catch (err) {
     return [];
   }
@@ -698,11 +697,7 @@ function loadQueue() {
   }
 
   const queuePath = path.join(activeDigest.session.digest_path, 'presentation-queue.json');
-  try {
-    return JSON.parse(fs.readFileSync(queuePath, 'utf8'));
-  } catch (err) {
-    return null;
-  }
+  return safeJsonParse(queuePath, null);
 }
 
 /**
@@ -1088,11 +1083,7 @@ function loadEditSessions() {
   }
 
   const sessionsPath = path.join(activeDigest.session.digest_path, 'edit-sessions.json');
-  try {
-    return JSON.parse(fs.readFileSync(sessionsPath, 'utf8'));
-  } catch (err) {
-    return { active_session: null, sessions: [] };
-  }
+  return safeJsonParse(sessionsPath, { active_session: null, sessions: [] });
 }
 
 /**
@@ -1928,18 +1919,14 @@ function createFeatureTask(stories, featureName) {
 function addTasksToReadyJson(tasks, options = {}) {
   const readyPath = path.join(process.cwd(), '.workflow', 'state', 'ready.json');
 
-  let readyData;
-  try {
-    readyData = JSON.parse(fs.readFileSync(readyPath, 'utf8'));
-  } catch (err) {
-    readyData = {
-      lastUpdated: now(),
-      ready: [],
-      inProgress: [],
-      blocked: [],
-      recentlyCompleted: []
-    };
-  }
+  const defaultReady = {
+    lastUpdated: now(),
+    ready: [],
+    inProgress: [],
+    blocked: [],
+    recentlyCompleted: []
+  };
+  const readyData = safeJsonParse(readyPath, defaultReady);
 
   // Check for duplicates by source story_id
   const existingStoryIds = new Set(
@@ -2099,6 +2086,12 @@ function finalizeDigestion(options = {}) {
   };
   saveActiveDigest(activeDigest);
 
+  // 6. Cleanup temp files (processing artifacts no longer needed)
+  let cleanupResult = { cleaned: false };
+  if (!options.keepTempFiles) {
+    cleanupResult = cleanupTempFiles(activeDigest.session.digest_id);
+  }
+
   return {
     success: true,
     approved_count: exportResult.summary.total_approved,
@@ -2106,10 +2099,62 @@ function finalizeDigestion(options = {}) {
     tasks_skipped: addResult.skipped || 0,
     files_exported: fileExport?.exported.length || 0,
     validation: exportResult.validation,
-    digest_status: 'completed'
+    digest_status: 'completed',
+    temp_cleanup: cleanupResult.cleaned ? 'cleaned' : 'kept'
   };
 }
 
+/**
+ * Cleanup temp processing files after successful completion
+ * Removes the digest-specific directory from .workflow/tmp/long-input/
+ */
+function cleanupTempFiles(digestId) {
+  if (!digestId) {
+    return { cleaned: false, error: 'No digest ID provided' };
+  }
+
+  // Path traversal validation - digestId must be a valid digest format
+  // Format: digest-[8 hex chars]
+  if (!/^digest-[a-f0-9]{8}$/.test(digestId)) {
+    return { cleaned: false, error: 'Invalid digest ID format' };
+  }
+
+  const digestPath = path.join(TMP_DIR, digestId);
+
+  // Additional safety: ensure resolved path is within TMP_DIR
+  const resolvedPath = path.resolve(digestPath);
+  const resolvedTmpDir = path.resolve(TMP_DIR);
+  if (!resolvedPath.startsWith(resolvedTmpDir + path.sep)) {
+    return { cleaned: false, error: 'Path traversal attempt detected' };
+  }
+
+  if (!fs.existsSync(digestPath)) {
+    return { cleaned: false, error: 'Digest directory not found' };
+  }
+
+  try {
+    // Remove the digest directory and all its contents
+    fs.rmSync(digestPath, { recursive: true, force: true });
+
+    // Also remove active-digest.json if it points to this digest
+    const activeFile = path.join(TMP_DIR, 'active-digest.json');
+    if (fs.existsSync(activeFile)) {
+      const active = safeJsonParse(activeFile, null);
+      if (active && active.session?.digest_id === digestId) {
+        try {
+          fs.unlinkSync(activeFile);
+        } catch (unlinkErr) {
+          // Ignore errors unlinking active file - main cleanup succeeded
+        }
+      }
+    }
+
+    return { cleaned: true, path: digestPath };
+  } catch (err) {
+    return { cleaned: false, error: err.message };
+  }
+}
+
 // ============================================================================
 // Module Exports
 // ============================================================================
@@ -2190,5 +2235,8 @@ module.exports = {
   formatTaskAsMarkdown,
   exportStoryFiles,
   previewExport,
-  finalizeDigestion
+  finalizeDigestion,
+
+  // Temp File Cleanup
+  cleanupTempFiles
 };

package/scripts/{flow-transcript-digest.js → flow-long-input.js}

@@ -1,11 +1,16 @@
 #!/usr/bin/env node
 
 /**
- * Transcript Digestion - Multi-pass extraction system
+ * Long Input Processing - Multi-pass extraction system
  *
- * This script manages digest sessions and provides utilities for the
- * multi-pass extraction process. The actual extraction is done by Claude
- * following the rules in .claude/skills/transcript-digestion/rules/
+ * Ensures nothing is missed from long/complex inputs (transcripts, prompts,
+ * specs, documents). Uses a 4-pass extraction system:
+ *   Pass 1: Topic extraction
+ *   Pass 2: Statement association
+ *   Pass 3: Orphan check
+ *   Pass 4: Contradiction resolution
+ *
+ * Renamed from flow-transcript-digest.js in v1.8.0
  */
 
 const fs = require('fs');
@@ -13,15 +18,94 @@ const path = require('path');
 const crypto = require('crypto');
 const { writeJson } = require('./flow-utils');
 
-// Import extracted modules
-const transcriptParsing = require('./flow-transcript-parsing');
-const transcriptLanguage = require('./flow-transcript-language');
-const transcriptStories = require('./flow-transcript-stories');
-const transcriptChunking = require('./flow-transcript-chunking');
-
-// Paths
-const STATE_DIR = path.join(process.cwd(), '.workflow', 'state', 'digests');
-const ACTIVE_DIGEST_FILE = path.join(STATE_DIR, 'active-digest.json');
+// Import extracted modules (renamed from transcript-* to long-input-*)
+const transcriptParsing = require('./flow-long-input-parsing');
+const transcriptLanguage = require('./flow-long-input-language');
+const transcriptStories = require('./flow-long-input-stories');
+const transcriptChunking = require('./flow-long-input-chunking');
+
+// Destructure commonly used language functions
+const {
+  detectLanguage,
+  detectMultipleLanguages,
+  getLanguageInfo,
+  LANGUAGE_INFO
+} = transcriptLanguage;
+
+// Destructure commonly used parsing functions
+const {
+  parseVTT,
+  parseSRT,
+  parseSubtitle,
+  mergeCues,
+  formatCuesAsText,
+  getSubtitleStats,
+  parseZoom,
+  parseTeams,
+  parseMeeting,
+  mergeMeetingEntries,
+  formatMeetingAsText,
+  getMeetingStats
+} = transcriptParsing;
+
+// Destructure commonly used chunking functions
+const {
+  loadDurableSessions,
+  listDurableSessions,
+  getDurableSession,
+  switchDurableSession,
+  archiveDurableSession,
+  deleteDurableSession,
+  generateRecoverySummaryForSession,
+  getTimeSince,
+  needsChunking,
+  planChunks,
+  getChunkingStatus
+} = transcriptChunking;
+
+// Destructure additional language utilities
+const { listSupportedLanguages } = transcriptLanguage;
+
+// Destructure commonly used story functions
+const {
+  generateStoryFromTopic,
+  generateAllStories,
+  saveStory,
+  loadStory,
+  loadAllStories,
+  formatStoryAsMarkdown,
+  initializePresentation,
+  getPresentationStatus,
+  getNextStory,
+  getCurrentStory,
+  approveCurrentStory,
+  rejectCurrentStory,
+  skipCurrentStory,
+  formatStorySummary,
+  formatActionsPrompt,
+  getCompletionSummary,
+  resetPresentation,
+  // Edit session functions
+  startEditSession,
+  editUserStory,
+  editCriterion,
+  addCriterion,
+  removeCriterion,
+  getEditChanges,
+  commitEditSession,
+  cancelEditSession,
+  getEditHistory,
+  listEditableStories,
+  // Export functions
+  previewExport,
+  exportApprovedStories,
+  finalizeDigestion
+} = transcriptStories;
+
+// Paths - temp processing files go to .workflow/tmp/, cleaned up after completion
+const TMP_DIR = path.join(process.cwd(), '.workflow', 'tmp', 'long-input');
+const STATE_DIR = TMP_DIR; // Alias for backward compatibility during migration
+const ACTIVE_DIGEST_FILE = path.join(TMP_DIR, 'active-digest.json');
 const CONFIG_FILE = path.join(process.cwd(), '.workflow', 'config.json');
 
 // Colors for CLI output
@@ -7373,7 +7457,7 @@ function main() {
       if (previewResult.validation.errors.length > 0) {
         console.log(`${c.red}Errors:${c.reset}`);
         for (const e of previewResult.validation.errors) {
-          console.log(`  ${e.story_id}: ${err.message}`);
+          console.log(`  ${e.story_id}: ${e.message}`);
         }
         console.log();
       }
@@ -7641,8 +7725,137 @@ ${c.dim}Examples:${c.reset}
   }
 }
 
+// ==========================================================================
+// Quick Processing Mode
+// ==========================================================================
+
+/**
+ * Quick process mode - single-pass extraction without interactive clarification.
+ * Used by the long input gate for fast feedback.
+ *
+ * @param {string} input - The input text to process
+ * @param {Object} options - Processing options
+ * @returns {Object} Quick scan results
+ */
+function quickProcess(input, options = {}) {
+  if (!input || typeof input !== 'string') {
+    return { error: 'No input provided' };
+  }
+
+  const startTime = Date.now();
+
+  // 1. Split into statements (returns objects with .text property)
+  const statements = splitIntoStatements(input);
+  // isMeaningfulStatement returns {meaningful: bool, reason: string}, filter on .meaningful
+  const meaningfulStatements = statements.filter(s => isMeaningfulStatement(s.text).meaningful);
+
+  // 2. Quick topic extraction (keyword-based, no full analysis)
+  const topicKeywords = new Set();
+  const topicPatterns = [
+    /\b(add|create|build|implement)\s+(?:a\s+)?(\w+(?:\s+\w+)?)/gi,
+    /\b(\w+)\s+(feature|component|page|button|form|table|list)/gi,
+    /\b(user|admin|guest)\s+(?:can|should|must|wants?)\s+(\w+)/gi
+  ];
+
+  for (const statement of meaningfulStatements) {
+    const text = statement.text;
+    for (const pattern of topicPatterns) {
+      const matches = text.matchAll(pattern);
+      for (const match of matches) {
+        const keyword = (match[2] || match[1]).toLowerCase();
+        if (keyword.length > 2) {
+          topicKeywords.add(keyword);
+        }
+      }
+    }
+  }
+
+  // 3. Quick contradiction detection
+  const contradictions = [];
+  const seenValues = new Map(); // attribute -> { value, text }
+
+  const valuePatterns = [
+    { pattern: /(\d+)\s*(columns?|rows?|items?|pages?)/gi, attr: 'count' },
+    { pattern: /(primary|secondary|danger|success)\s*(?:color|button)/gi, attr: 'style' },
+    { pattern: /(left|right|center|top|bottom)/gi, attr: 'position' }
+  ];
+
+  for (const statement of meaningfulStatements) {
+    const text = statement.text;
+    for (const { pattern, attr } of valuePatterns) {
+      const match = text.match(pattern);
+      if (match && match[1]) {
+        const value = match[1].toLowerCase();
+        const key = `${attr}`;
+
+        if (seenValues.has(key) && seenValues.get(key).value !== value) {
+          // Check for correction phrase
+          const isCorrection = detectCorrectionPhrase(text);
+
+          contradictions.push({
+            attribute: attr,
+            value1: seenValues.get(key).value,
+            value2: value,
+            statement1: seenValues.get(key).text.slice(0, 50),
+            statement2: text.slice(0, 50),
+            autoResolved: isCorrection,
+            resolution: isCorrection ? `Later statement (${value}) supersedes` : 'needs_review'
+          });
+        }
+
+        seenValues.set(key, { value, text });
+      }
+    }
+  }
+
+  const elapsed = Date.now() - startTime;
+
+  return {
+    mode: 'quick',
+    success: true,
+    metrics: {
+      totalStatements: statements.length,
+      meaningfulStatements: meaningfulStatements.length,
+      topicsDetected: topicKeywords.size,
+      contradictionsFound: contradictions.length,
+      autoResolved: contradictions.filter(c => c.autoResolved).length,
+      processingTimeMs: elapsed
+    },
+    topics: Array.from(topicKeywords),
+    contradictions: contradictions.filter(c => !c.autoResolved),
+    summary: generateQuickSummary(meaningfulStatements.length, topicKeywords.size, contradictions)
+  };
+}
+
+/**
+ * Generate human-readable summary for quick scan
+ */
+function generateQuickSummary(statementCount, topicCount, contradictions) {
+  const unresolvedCount = contradictions.filter(c => !c.autoResolved).length;
+
+  let summary = `Quick scan complete: ${statementCount} statements, ${topicCount} topics detected.`;
+
+  if (contradictions.length > 0) {
+    const autoResolved = contradictions.filter(c => c.autoResolved).length;
+    summary += `\n${contradictions.length} potential contradictions found`;
+    if (autoResolved > 0) {
+      summary += ` (${autoResolved} auto-resolved as corrections)`;
+    }
+    if (unresolvedCount > 0) {
+      summary += `.\n${unresolvedCount} need review.`;
+    }
+  } else {
+    summary += '\nNo obvious contradictions detected.';
+  }
+
+  return summary;
+}
+
 // Export for use as module
 module.exports = {
+  // Utilities
+  now,
+  // Core session management
   createSession,
   loadActiveDigest,
   saveActiveDigest,
@@ -7909,7 +8122,10 @@ module.exports = {
   saveChunkingState: transcriptChunking.saveChunkingState,
   updateChunkStatus: transcriptChunking.updateChunkStatus,
   getChunkContent: transcriptChunking.getChunkContent,
-  getChunkingStatus: transcriptChunking.getChunkingStatus
+  getChunkingStatus: transcriptChunking.getChunkingStatus,
+  // Quick Processing Mode (for gate integration)
+  quickProcess,
+  generateQuickSummary
 };
 
 // Run CLI if called directly