wogiflow 1.0.11 → 1.0.13

package/scripts/flow-utils.js

@@ -145,6 +145,8 @@ const PATHS = {
   skills: path.join(CLAUDE_DIR, 'skills'),
   rules: path.join(CLAUDE_DIR, 'rules'),
   commands: path.join(CLAUDE_DIR, 'commands'),
+  // Smart Context System (Phase 1)
+  sectionIndex: path.join(STATE_DIR, 'section-index.json'),
   // Knowledge files (Phase 0.4 - synced documentation)
   // NOTE: These are DEPRECATED - use specsStack, specsArchitecture, specsTesting instead
   // Kept for backward compatibility, will be removed in v2.0

package/scripts/hooks/core/long-input-gate.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Long Input Gate (Core Module)
+ *
+ * Detects long/complex inputs and triggers appropriate processing.
+ * Uses smart defaults based on content type:
+ *   - transcript/spec/requirements → full extraction
+ *   - code → skip
+ *   - other → quick scan
+ *
+ * Part of the Long Input Processing pipeline (formerly transcript-digestion).
+ */
+
+const path = require('path');
+
+// Import from parent scripts directory
+const { getConfig, safeJsonParse } = require('../../flow-utils');
+
+// Default configuration
+const DEFAULTS = {
+  enabled: true,
+  charThreshold: 2000,      // Characters to trigger gate
+  lineThreshold: 50,        // Lines to trigger gate
+  smartDefault: true,       // Use content-based defaults
+  contentRules: {
+    transcript: 'full',     // Meeting notes, voice transcripts
+    spec: 'full',           // Specifications, PRDs
+    requirements: 'full',   // Feature requirements
+    code: 'skip',           // Code snippets - no extraction needed
+    default: 'quick'        // Unknown content - quick scan
+  }
+};
+
+/**
+ * Content type patterns for classification
+ */
+const CONTENT_PATTERNS = {
+  transcript: [
+    /\b(meeting|discussion|call|transcript)\b/i,
+    /\b(said|mentioned|asked|replied)\b/i,
+    /\b(speaker|participant)\s*[:\d]/i,
+    /\[\d{1,2}:\d{2}(:\d{2})?\]/,           // Timestamps [00:00:00]
+    /^\s*-?\s*[A-Z][a-z]+:/m                // Speaker: format
+  ],
+  spec: [
+    /\b(specification|spec|prd|requirement|feature)\b/i,
+    /\b(must|shall|should|will)\s+(be|have|support|allow)\b/i,
+    /\b(user story|acceptance criteria|given.+when.+then)\b/i,
+    /\b(functional|non-functional|technical)\s+requirement/i
+  ],
+  requirements: [
+    /\b(feature|functionality|capability)\b/i,
+    /\b(user wants|users need|allow users to)\b/i,
+    /\b(add|implement|create|build)\s+a?\s*(new|the)?\s*(feature|page|component|button)/i,
+    /as a .+, i want .+, so that/i          // User story format
+  ],
+  code: [
+    /^(import|export|const|let|var|function|class|interface|type)\s/m,
+    /\b(async|await|return|throw|try|catch)\b/,
+    /[{}\[\]();=]\s*$/m,                    // Code endings
+    /^\s*(\/\/|\/\*|\*|#)/m,                // Comments
+    /\.(ts|js|tsx|jsx|py|go|rs|java|rb)$/   // File extensions mentioned
+  ]
+};
+
+/**
+ * Get long input gate configuration
+ */
+function getLongInputConfig() {
+  const config = getConfig();
+  return {
+    ...DEFAULTS,
+    ...(config.longInputGate || config.transcriptDigestion || {})
+  };
+}
+
+/**
+ * Check if long input gate is enabled
+ */
+function isLongInputGateEnabled() {
+  const config = getLongInputConfig();
+  return config.enabled !== false;
+}
+
+/**
+ * Check if input exceeds thresholds
+ */
+function exceedsThresholds(input) {
+  if (!input || typeof input !== 'string') {
+    return { exceeds: false };
+  }
+
+  const config = getLongInputConfig();
+  const charCount = input.length;
+  const lineCount = input.split('\n').length;
+
+  const exceedsChars = charCount >= config.charThreshold;
+  const exceedsLines = lineCount >= config.lineThreshold;
+
+  return {
+    exceeds: exceedsChars || exceedsLines,
+    charCount,
+    lineCount,
+    charThreshold: config.charThreshold,
+    lineThreshold: config.lineThreshold,
+    reason: exceedsChars ? 'chars' : (exceedsLines ? 'lines' : null)
+  };
+}
+
+/**
+ * Classify content type based on patterns
+ */
+function classifyContent(input) {
+  if (!input || typeof input !== 'string') {
+    return { type: 'unknown', confidence: 0, matches: [] };
+  }
+
+  const scores = {};
+  const matches = {};
+
+  for (const [type, patterns] of Object.entries(CONTENT_PATTERNS)) {
+    scores[type] = 0;
+    matches[type] = [];
+
+    for (const pattern of patterns) {
+      const match = input.match(pattern);
+      if (match) {
+        scores[type]++;
+        matches[type].push(pattern.source.slice(0, 30) + '...');
+      }
+    }
+  }
+
+  // Find highest scoring type
+  let bestType = 'unknown';
+  let bestScore = 0;
+
+  for (const [type, score] of Object.entries(scores)) {
+    if (score > bestScore) {
+      bestScore = score;
+      bestType = type;
+    }
+  }
+
+  // Calculate confidence (0-1)
+  const maxPossible = CONTENT_PATTERNS[bestType]?.length || 1;
+  const confidence = Math.min(bestScore / maxPossible, 1);
+
+  return {
+    type: bestScore > 0 ? bestType : 'unknown',
+    confidence,
+    scores,
+    matches: matches[bestType] || []
+  };
+}
+
+/**
+ * Get recommended action for content type
+ */
+function getRecommendedAction(contentType) {
+  const config = getLongInputConfig();
+  const rules = config.contentRules || DEFAULTS.contentRules;
+
+  return rules[contentType] || rules.default || 'quick';
+}
+
+/**
+ * Check long input gate for a given input
+ *
+ * @param {Object} options
+ * @param {string} options.input - The input text to check
+ * @param {string} options.source - Source of input ('task', 'story', 'voice', 'paste')
+ * @returns {Object} Gate result
+ */
+function checkLongInputGate(options = {}) {
+  const { input, source = 'unknown' } = options;
+
+  // Check if gate is enabled
+  if (!isLongInputGateEnabled()) {
+    return {
+      triggered: false,
+      action: 'skip',
+      reason: 'gate_disabled'
+    };
+  }
+
+  // Check thresholds
+  const thresholdResult = exceedsThresholds(input);
+
+  if (!thresholdResult.exceeds) {
+    return {
+      triggered: false,
+      action: 'skip',
+      reason: 'below_threshold',
+      metrics: thresholdResult
+    };
+  }
+
+  // Classify content
+  const classification = classifyContent(input);
+
+  // Get recommended action
+  const config = getLongInputConfig();
+  let action;
+
+  if (config.smartDefault) {
+    action = getRecommendedAction(classification.type);
+  } else {
+    action = 'ask'; // Always ask if smart defaults disabled
+  }
+
+  return {
+    triggered: true,
+    action,
+    reason: 'threshold_exceeded',
+    metrics: thresholdResult,
+    classification,
+    source,
+    message: generateGateMessage(thresholdResult, classification, action)
+  };
+}
+
+/**
+ * Generate user-facing message for gate trigger
+ */
+function generateGateMessage(metrics, classification, action) {
+  const sizeInfo = metrics.reason === 'chars'
+    ? `${metrics.charCount.toLocaleString()} characters`
+    : `${metrics.lineCount} lines`;
+
+  const typeInfo = classification.confidence > 0.5
+    ? `Detected as: ${classification.type}`
+    : 'Content type: unknown';
+
+  const actionInfo = {
+    full: 'Running full extraction (4-pass with clarifications)',
+    quick: 'Running quick scan (single-pass, no clarifications)',
+    skip: 'Skipping extraction (code content)',
+    ask: 'Please choose processing mode'
+  };
+
+  return `Long input detected: ${sizeInfo}
+${typeInfo}
+Recommended action: ${actionInfo[action] || action}`;
+}
+
+/**
+ * Format gate result for display
+ */
+function formatGateResult(result) {
+  if (!result.triggered) {
+    return null;
+  }
+
+  const lines = [
+    `Long Input Gate Triggered`,
+    ``,
+    `Size: ${result.metrics.charCount.toLocaleString()} chars, ${result.metrics.lineCount} lines`,
+    `Content Type: ${result.classification.type} (${Math.round(result.classification.confidence * 100)}% confidence)`,
+    `Recommended: ${result.action}`,
+    ``
+  ];
+
+  if (result.action === 'ask') {
+    lines.push(
+      `Options:`,
+      `  1. full  - Complete 4-pass extraction with clarifications`,
+      `  2. quick - Fast single-pass scan`,
+      `  3. skip  - Proceed without extraction`
+    );
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  // Configuration
+  getLongInputConfig,
+  isLongInputGateEnabled,
+  DEFAULTS,
+  CONTENT_PATTERNS,
+
+  // Core functions
+  exceedsThresholds,
+  classifyContent,
+  getRecommendedAction,
+  checkLongInputGate,
+
+  // Display
+  generateGateMessage,
+  formatGateResult
+};

package/scripts/flow-parallel-detector.js

@@ -1,399 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Wogi Flow - Parallel Execution Detector
- *
- * Automatically detects when tasks can run in parallel and suggests/executes
- * parallel execution based on configuration.
- *
- * Features:
- * - Analyzes task dependencies and file overlaps
- * - Suggests parallel execution when beneficial
- * - Auto-executes parallel tasks when configured
- * - Provides clear explanations of parallelization decisions
- */
-
-const fs = require('fs');
-const path = require('path');
-const { getConfig, getProjectRoot } = require('./flow-utils');
-const {
-  detectDependencies,
-  findParallelizable,
-  canRunInParallel,
-  getParallelConfig
-} = require('./flow-parallel');
-
-/**
- * Analyze tasks for parallel execution potential
- */
-function analyzeParallelPotential(tasks) {
-  if (!tasks || tasks.length < 2) {
-    return {
-      canParallelize: false,
-      reason: 'insufficient-tasks',
-      message: 'Need at least 2 tasks to parallelize'
-    };
-  }
-
-  const dependencies = detectDependencies(tasks);
-  const parallelizable = findParallelizable(tasks, new Set(), dependencies);
-  const config = getParallelConfig();
-
-  // Check minimum threshold
-  const minTasks = config.minTasksForParallel || 2;
-  if (parallelizable.length < minTasks) {
-    return {
-      canParallelize: false,
-      reason: 'below-threshold',
-      message: `Only ${parallelizable.length} tasks can run in parallel (minimum: ${minTasks})`,
-      parallelizable: parallelizable.map(t => t.id)
-    };
-  }
-
-  // Analyze file overlap for safety warnings
-  const fileOverlaps = analyzeFileOverlaps(tasks, dependencies);
-
-  // Calculate efficiency gain
-  const efficiencyGain = calculateEfficiencyGain(tasks, parallelizable);
-
-  return {
-    canParallelize: true,
-    parallelizable: parallelizable.map(t => ({
-      id: t.id,
-      title: t.title || t.description,
-      files: t.files || []
-    })),
-    totalTasks: tasks.length,
-    parallelCount: parallelizable.length,
-    dependencies,
-    fileOverlaps,
-    efficiencyGain,
-    waves: calculateWaves(tasks, dependencies),
-    recommendation: generateRecommendation(parallelizable, efficiencyGain, fileOverlaps)
-  };
-}
-
-/**
- * Analyze file overlaps that might cause issues
- */
-function analyzeFileOverlaps(tasks, dependencies) {
-  const overlaps = [];
-  const fileToTasks = {};
-
-  for (const task of tasks) {
-    if (task.files && Array.isArray(task.files)) {
-      for (const file of task.files) {
-        if (!fileToTasks[file]) {
-          fileToTasks[file] = [];
-        }
-        fileToTasks[file].push(task.id);
-      }
-    }
-  }
-
-  for (const [file, taskIds] of Object.entries(fileToTasks)) {
-    if (taskIds.length > 1) {
-      overlaps.push({
-        file,
-        tasks: taskIds,
-        severity: taskIds.length > 2 ? 'high' : 'medium'
-      });
-    }
-  }
-
-  return overlaps;
-}
-
-/**
- * Calculate efficiency gain from parallel execution
- */
-function calculateEfficiencyGain(tasks, parallelizable) {
-  // Simple estimation based on parallelizable ratio
-  const sequentialTime = tasks.length; // 1 unit per task
-  const parallelTime = Math.ceil(tasks.length / parallelizable.length);
-
-  return {
-    sequential: sequentialTime,
-    parallel: parallelTime,
-    savedTime: sequentialTime - parallelTime,
-    percentageGain: Math.round((1 - parallelTime / sequentialTime) * 100)
-  };
-}
-
-/**
- * Calculate execution waves (groups that can run together)
- */
-function calculateWaves(tasks, dependencies) {
-  const waves = [];
-  const completed = new Set();
-
-  while (completed.size < tasks.length) {
-    const wave = [];
-
-    for (const task of tasks) {
-      if (completed.has(task.id)) continue;
-
-      const taskDeps = dependencies[task.id] || [];
-      const allDepsComplete = taskDeps.every(d => completed.has(d));
-
-      if (allDepsComplete) {
-        wave.push(task.id);
-      }
-    }
-
-    if (wave.length === 0) {
-      // Circular dependency or stuck
-      break;
-    }
-
-    waves.push(wave);
-    wave.forEach(id => completed.add(id));
-  }
-
-  return waves;
-}
-
-/**
- * Generate a human-readable recommendation
- */
-function generateRecommendation(parallelizable, efficiencyGain, fileOverlaps) {
-  const lines = [];
-
-  if (parallelizable.length >= 3) {
-    lines.push('✅ RECOMMENDED: High parallelization potential');
-  } else if (parallelizable.length >= 2) {
-    lines.push('⚠️  POSSIBLE: Moderate parallelization potential');
-  }
-
-  lines.push(`   ${parallelizable.length} tasks can run simultaneously`);
-  lines.push(`   ~${efficiencyGain.percentageGain}% time savings expected`);
-
-  if (fileOverlaps.length > 0) {
-    const highSeverity = fileOverlaps.filter(o => o.severity === 'high');
-    if (highSeverity.length > 0) {
-      lines.push(`   ⚠️  ${highSeverity.length} high-risk file overlaps detected`);
-      lines.push(`      Consider enabling worktree isolation`);
-    }
-  }
-
-  return lines.join('\n');
-}
-
-/**
- * Generate suggestion message for user
- */
-function generateSuggestionMessage(analysis) {
-  const lines = [
-    '',
-    '╔══════════════════════════════════════════════════════╗',
-    '║         🔀 PARALLEL EXECUTION AVAILABLE              ║',
-    '╠══════════════════════════════════════════════════════╣'
-  ];
-
-  lines.push(`║  ${analysis.parallelCount} of ${analysis.totalTasks} tasks can run in parallel`.padEnd(55) + '║');
-  lines.push(`║  Estimated time savings: ~${analysis.efficiencyGain.percentageGain}%`.padEnd(55) + '║');
-
-  lines.push('╠══════════════════════════════════════════════════════╣');
-  lines.push('║  Parallelizable tasks:'.padEnd(55) + '║');
-
-  for (const task of analysis.parallelizable.slice(0, 5)) {
-    const title = task.title || task.id;
-    const truncated = title.length > 45 ? title.substring(0, 42) + '...' : title;
-    lines.push(`║    • ${truncated}`.padEnd(55) + '║');
-  }
-
-  if (analysis.parallelizable.length > 5) {
-    lines.push(`║    ... and ${analysis.parallelizable.length - 5} more`.padEnd(55) + '║');
-  }
-
-  if (analysis.fileOverlaps.length > 0) {
-    lines.push('╠══════════════════════════════════════════════════════╣');
-    lines.push('║  ⚠️  File overlap warnings:'.padEnd(55) + '║');
-    for (const overlap of analysis.fileOverlaps.slice(0, 3)) {
-      const msg = `${overlap.file} → ${overlap.tasks.join(', ')}`;
-      const truncated = msg.length > 47 ? msg.substring(0, 44) + '...' : msg;
-      lines.push(`║    ${truncated}`.padEnd(55) + '║');
-    }
-  }
-
-  lines.push('╠══════════════════════════════════════════════════════╣');
-  lines.push('║  Options:'.padEnd(55) + '║');
-  lines.push('║    [P] Run in parallel'.padEnd(55) + '║');
-  lines.push('║    [S] Run sequentially'.padEnd(55) + '║');
-  lines.push('║    [W] Run parallel with worktree isolation'.padEnd(55) + '║');
-  lines.push('╚══════════════════════════════════════════════════════╝');
-
-  return lines.join('\n');
-}
-
-/**
- * Check if parallel execution should be suggested
- */
-function shouldSuggestParallel(tasks) {
-  const config = getConfig();
-  const parallelConfig = config.parallel || {};
-
-  if (!parallelConfig.enabled) {
-    return { suggest: false, reason: 'parallel-disabled' };
-  }
-
-  if (!parallelConfig.autoDetect) {
-    return { suggest: false, reason: 'auto-detect-disabled' };
-  }
-
-  const analysis = analyzeParallelPotential(tasks);
-
-  if (!analysis.canParallelize) {
-    return { suggest: false, reason: analysis.reason };
-  }
-
-  if (parallelConfig.autoSuggest) {
-    return {
-      suggest: true,
-      analysis,
-      message: generateSuggestionMessage(analysis)
-    };
-  }
-
-  return { suggest: false, reason: 'auto-suggest-disabled' };
-}
-
-/**
- * Check if parallel execution should auto-execute
- * Uses autoExecute config option (not autoApprove which is for manual triggers)
- */
-function shouldAutoExecute(tasks) {
-  const config = getConfig();
-  const parallelConfig = config.parallel || {};
-
-  if (!parallelConfig.enabled) return false;
-  if (!parallelConfig.autoExecute) return false; // Use autoExecute, not autoApprove
-  if (!parallelConfig.autoDetect) return false;
-
-  const analysis = analyzeParallelPotential(tasks);
-  return analysis.canParallelize;
-}
-
-/**
- * Load pending tasks from ready.json
- */
-function loadPendingTasks() {
-  const projectRoot = getProjectRoot();
-  const readyPath = path.join(projectRoot, '.workflow', 'state', 'ready.json');
-
-  if (!fs.existsSync(readyPath)) {
-    return [];
-  }
-
-  try {
-    const ready = JSON.parse(fs.readFileSync(readyPath, 'utf-8'));
-    return (ready.tasks || []).filter(t =>
-      t.status === 'pending' || t.status === 'ready'
-    );
-  } catch {
-    return [];
-  }
-}
-
-// ============================================================
-// Exports
-// ============================================================
-
-module.exports = {
-  analyzeParallelPotential,
-  analyzeFileOverlaps,
-  calculateEfficiencyGain,
-  calculateWaves,
-  generateRecommendation,
-  generateSuggestionMessage,
-  shouldSuggestParallel,
-  shouldAutoExecute,
-  loadPendingTasks
-};
-
-// ============================================================
-// CLI
-// ============================================================
-
-if (require.main === module) {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  switch (command) {
-    case 'analyze': {
-      const tasks = loadPendingTasks();
-      if (tasks.length === 0) {
-        console.log('No pending tasks found in ready.json');
-        process.exit(0);
-      }
-
-      const analysis = analyzeParallelPotential(tasks);
-      console.log('\n📊 Parallel Execution Analysis\n');
-      console.log(`Total tasks: ${analysis.totalTasks || tasks.length}`);
-
-      if (analysis.canParallelize) {
-        console.log(`Can parallelize: ${analysis.parallelCount} tasks`);
-        console.log(`\nExecution waves:`);
-        analysis.waves.forEach((wave, i) => {
-          console.log(`  Wave ${i + 1}: ${wave.join(', ')}`);
-        });
-        console.log(`\nEfficiency:`);
-        console.log(`  Sequential time: ${analysis.efficiencyGain.sequential} units`);
-        console.log(`  Parallel time: ${analysis.efficiencyGain.parallel} units`);
-        console.log(`  Savings: ${analysis.efficiencyGain.percentageGain}%`);
-
-        if (analysis.fileOverlaps.length > 0) {
-          console.log(`\n⚠️  File overlaps:`);
-          analysis.fileOverlaps.forEach(o => {
-            console.log(`  ${o.file}: ${o.tasks.join(', ')} (${o.severity})`);
-          });
-        }
-
-        console.log('\n' + analysis.recommendation);
-      } else {
-        console.log(`Cannot parallelize: ${analysis.reason}`);
-        console.log(analysis.message);
-      }
-      break;
-    }
-
-    case 'suggest': {
-      const tasks = loadPendingTasks();
-      const result = shouldSuggestParallel(tasks);
-
-      if (result.suggest) {
-        console.log(result.message);
-      } else {
-        console.log(`Parallel execution not suggested: ${result.reason}`);
-      }
-      break;
-    }
-
-    case 'config': {
-      const config = getParallelConfig();
-      console.log('\n⚙️  Parallel Execution Configuration\n');
-      console.log(JSON.stringify(config, null, 2));
-      break;
-    }
-
-    default:
-      console.log(`
-Wogi Flow - Parallel Execution Detector
-
-Usage:
-  node flow-parallel-detector.js <command>
-
-Commands:
-  analyze     Analyze pending tasks for parallel potential
-  suggest     Check if parallel execution should be suggested
-  config      Show parallel execution configuration
-
-Configuration (config.json):
-  parallel.enabled: true           Enable parallel execution
-  parallel.autoDetect: true        Auto-detect parallel opportunities
-  parallel.autoSuggest: true       Suggest parallel execution to user
-  parallel.autoApprove: false      Auto-execute without approval
-  parallel.minTasksForParallel: 2  Minimum tasks to trigger
-`);
-  }
-}