wogiflow 1.0.12 → 1.0.13

package/scripts/flow-model-router.js

@@ -28,12 +28,23 @@ const {
   safeJsonParse,
   getConfig,
   printHeader,
-  printSection
+  printSection,
+  estimateTokens
 } = require('./flow-utils');
 
 const { analyzeTask } = require('./flow-task-analyzer');
 const { loadRegistry, loadStats } = require('./flow-models');
 
+// Smart Context System integration
+let contextGatherer = null;
+let instructionRichness = null;
+try {
+  contextGatherer = require('./flow-context-gatherer');
+  instructionRichness = require('./flow-instruction-richness');
+} catch (err) {
+  // Smart Context modules not available
+}
+
 // Phase 3: Import cascade fallback (cached singleton)
 let cascadeModule = null;
 try {
@@ -654,6 +665,236 @@ function getRoutingConfig() {
   };
 }
 
+// ============================================================
+// Phase 4: Single Model Evaluation (Smart Context Integration)
+// ============================================================
+
+/**
+ * Evaluate if a single model can handle a task.
+ * Used when user has only one additional model configured.
+ *
+ * @param {Object} params - Evaluation parameters
+ * @param {string} params.modelId - Model identifier
+ * @param {Object} params.analysis - Task analysis
+ * @param {string} params.taskDescription - Task description for context estimation
+ * @returns {Promise<Object>} Evaluation result
+ */
+async function evaluateSingleModel(params) {
+  const { modelId, analysis, taskDescription = '' } = params;
+
+  // Load registry
+  const registry = loadRegistry();
+  if (!registry) {
+    return { canHandle: false, reason: 'Model registry not found' };
+  }
+
+  // Find model
+  const model = registry.models?.[modelId];
+  if (!model) {
+    return { canHandle: false, reason: `Model not found: ${modelId}` };
+  }
+
+  // 1. Check capabilities
+  const requiredCaps = new Set(analysis.capabilities || []);
+  const modelCaps = new Set(model.capabilities || []);
+  const missingCaps = [];
+
+  for (const cap of requiredCaps) {
+    if (!modelCaps.has(cap)) {
+      missingCaps.push(cap);
+    }
+  }
+
+  if (missingCaps.length > 0) {
+    return {
+      canHandle: false,
+      reason: 'Missing capabilities',
+      missing: missingCaps,
+      modelCapabilities: model.capabilities,
+      requiredCapabilities: [...requiredCaps]
+    };
+  }
+
+  // 2. Check language proficiency
+  const primaryLang = analysis.languages?.primary;
+  if (primaryLang) {
+    const langCheck = checkLanguageProficiency(model, primaryLang);
+    if (!langCheck.meets) {
+      return {
+        canHandle: false,
+        reason: langCheck.reason,
+        proficiency: langCheck.proficiency,
+        required: langCheck.required
+      };
+    }
+  }
+
+  // 3. Estimate context requirements
+  let contextRequirements = null;
+  let estimatedTaskTokens = 0;
+
+  if (contextGatherer && taskDescription) {
+    // Use Smart Context to estimate what context this task needs
+    const contextResult = await contextGatherer.gatherContext({
+      task: taskDescription,
+      model: modelId,
+      format: 'summary'  // Use summary for estimation
+    });
+
+    contextRequirements = {
+      sectionsNeeded: contextResult.stats?.sectionsIncluded || 0,
+      tokensEstimated: contextResult.stats?.totalTokens || 0,
+      budgetUsed: contextResult.stats?.budgetUsed || '0%',
+      modelDensity: contextResult.stats?.modelPrefs?.density || 'standard'
+    };
+
+    // Estimate total task tokens (context + task + buffer for output)
+    const taskTextTokens = estimateTokens?.(taskDescription) || Math.ceil(taskDescription.length / 4);
+    const outputBuffer = model.maxOutputTokens ? model.maxOutputTokens * 0.5 : 4000;
+
+    estimatedTaskTokens = contextRequirements.tokensEstimated + taskTextTokens + outputBuffer;
+  } else {
+    // Fallback estimation without Smart Context
+    const taskTextTokens = estimateTokens?.(taskDescription) || Math.ceil(taskDescription.length / 4);
+    const baseContextEstimate = 5000;  // Conservative base estimate
+    const outputBuffer = model.maxOutputTokens ? model.maxOutputTokens * 0.5 : 4000;
+
+    estimatedTaskTokens = taskTextTokens + baseContextEstimate + outputBuffer;
+
+    contextRequirements = {
+      sectionsNeeded: 'unknown',
+      tokensEstimated: baseContextEstimate,
+      budgetUsed: 'estimated',
+      modelDensity: 'standard'
+    };
+  }
+
+  // 4. Check if task fits in context window
+  const contextWindow = model.contextWindow || 128000;
+  const usableContext = contextWindow * 0.7;  // Reserve 30% buffer
+
+  if (estimatedTaskTokens > usableContext) {
+    return {
+      canHandle: false,
+      reason: 'Context too large for model',
+      estimatedTokens: estimatedTaskTokens,
+      contextWindow,
+      usableContext: Math.floor(usableContext),
+      overflow: estimatedTaskTokens - usableContext
+    };
+  }
+
+  // 5. Calculate estimated cost
+  let estimatedCost = null;
+  if (model.pricing) {
+    const inputCost = (estimatedTaskTokens / 1000) * (model.pricing.inputPer1kTokens || 0);
+    const outputCost = ((model.maxOutputTokens || 4000) / 1000) * (model.pricing.outputPer1kTokens || 0);
+    estimatedCost = {
+      input: inputCost.toFixed(4),
+      output: outputCost.toFixed(4),
+      total: (inputCost + outputCost).toFixed(4),
+      currency: model.pricing.currency || 'USD'
+    };
+  }
+
+  // Model can handle the task
+  return {
+    canHandle: true,
+    modelId,
+    displayName: model.displayName,
+    costTier: model.costTier,
+    contextRequirements,
+    estimatedTokens: estimatedTaskTokens,
+    contextWindow,
+    contextUsage: `${((estimatedTaskTokens / contextWindow) * 100).toFixed(1)}%`,
+    estimatedCost,
+    // Include model preferences for caller
+    modelPreferences: model.contextPreferences || {
+      density: 'standard',
+      explicitExamples: true,
+      patternHints: true,
+      minContextForQuality: 0.5
+    }
+  };
+}
+
+/**
+ * Evaluate multiple models for a task and recommend the best one.
+ * Useful when user wants to compare options.
+ *
+ * @param {Object} params - Evaluation parameters
+ * @param {Object} params.analysis - Task analysis
+ * @param {string} params.taskDescription - Task description
+ * @param {string[]} params.modelIds - Models to evaluate (if not provided, evaluates all)
+ * @returns {Promise<Object>} Comparison result
+ */
+async function evaluateModelsForTask(params) {
+  const { analysis, taskDescription, modelIds = null } = params;
+
+  const registry = loadRegistry();
+  if (!registry) {
+    return { success: false, error: 'Model registry not found' };
+  }
+
+  // Get models to evaluate
+  let models;
+  if (modelIds && modelIds.length > 0) {
+    models = modelIds.filter(id => registry.models?.[id]);
+  } else {
+    models = Object.keys(registry.models || {});
+  }
+
+  if (models.length === 0) {
+    return { success: false, error: 'No models to evaluate' };
+  }
+
+  // Evaluate each model
+  const evaluations = await Promise.all(
+    models.map(async modelId => {
+      const result = await evaluateSingleModel({
+        modelId,
+        analysis,
+        taskDescription
+      });
+      return { modelId, ...result };
+    })
+  );
+
+  // Separate capable and incapable models
+  const capable = evaluations.filter(e => e.canHandle);
+  const incapable = evaluations.filter(e => !e.canHandle);
+
+  // Rank capable models by quality (capability + cost efficiency)
+  const ranked = capable.sort((a, b) => {
+    // Prefer models with better context efficiency
+    const efficiencyA = parseFloat(a.contextUsage) || 100;
+    const efficiencyB = parseFloat(b.contextUsage) || 100;
+
+    // Lower context usage is better
+    if (Math.abs(efficiencyA - efficiencyB) > 10) {
+      return efficiencyA - efficiencyB;
+    }
+
+    // Then by cost tier (quality-first)
+    const tierOrder = { premium: 0, standard: 1, economy: 2 };
+    return (tierOrder[a.costTier] || 1) - (tierOrder[b.costTier] || 1);
+  });
+
+  return {
+    success: true,
+    taskDescription,
+    totalEvaluated: models.length,
+    capableCount: capable.length,
+    recommended: ranked[0] || null,
+    alternatives: ranked.slice(1),
+    incapable: incapable.map(e => ({
+      modelId: e.modelId,
+      reason: e.reason,
+      details: e.missing || e.overflow || null
+    }))
+  };
+}
+
 // ============================================================
 // Main Router
 // ============================================================
@@ -864,6 +1105,10 @@ module.exports = {
   checkCascadeFallback,
   getRoutingConfig,
 
+  // Phase 4: Single model evaluation (Smart Context integration)
+  evaluateSingleModel,
+  evaluateModelsForTask,
+
   // Registry/stats access
   loadRegistry,
   loadStats,

package/scripts/flow-morning.js

@@ -16,6 +16,7 @@ const path = require('path');
 const { execSync } = require('child_process');
 const {
   PATHS,
+  PROJECT_ROOT,
   fileExists,
   readJson,
   readFile,
@@ -421,6 +422,99 @@ function printBriefing(briefing) {
     console.log('');
   }
 
+  // Knowledge Sync Check
+  if (morningConfig.checkKnowledgeSync !== false) {
+    try {
+      const { checkAllDrift, markAsSynced } = require('./flow-knowledge-sync');
+      const driftStatus = checkAllDrift();
+
+      if (driftStatus.anyDrift) {
+        printSection('KNOWLEDGE SYNC');
+
+        // Show what drifted
+        const driftedCategories = [];
+        for (const [category, status] of Object.entries(driftStatus.categories)) {
+          if (status.status === 'drifted') {
+            console.log(`  ${color('yellow', '\u26a0')} ${category}.md out of sync (${status.reason})`);
+            driftedCategories.push(category);
+          }
+        }
+
+        // Auto-regenerate if enabled
+        if (morningConfig.autoRegenerateKnowledge !== false) {
+          try {
+            const { spawnSync } = require('child_process');
+            const scriptPath = path.join(PROJECT_ROOT, 'scripts', 'flow-onboard');
+            const result = spawnSync('node', [scriptPath, '--update-knowledge'], {
+              cwd: PROJECT_ROOT,
+              stdio: 'pipe',
+              timeout: 30000
+            });
+
+            if (result.status === 0) {
+              markAsSynced();
+              console.log(`  ${color('green', '\u2713')} Auto-regenerated knowledge files`);
+            } else {
+              console.log(`  ${color('yellow', '!')} Could not auto-regenerate`);
+              console.log(`    Run: ${color('cyan', 'flow knowledge-sync regenerate')}`);
+            }
+          } catch (err) {
+            console.log(`  ${color('yellow', '!')} Could not auto-regenerate: ${err.message}`);
+            console.log(`    Run: ${color('cyan', 'flow knowledge-sync regenerate')}`);
+          }
+        } else {
+          console.log(`  ${color('dim', 'Run:')} ${color('cyan', 'flow knowledge-sync regenerate')}`);
+        }
+
+        console.log('');
+      }
+    } catch {
+      // Knowledge sync not available - skip silently
+    }
+  }
+
+  // Technical Debt Summary
+  if (morningConfig.showTechDebt !== false) {
+    try {
+      const { TechDebtManager } = require('./flow-tech-debt');
+      const debtManager = new TechDebtManager();
+      const stats = debtManager.getStats();
+
+      if (stats.totalOpen > 0) {
+        printSection('TECHNICAL DEBT');
+
+        // Summary line
+        const severityParts = [];
+        if (stats.bySeverity.critical > 0) severityParts.push(color('red', `${stats.bySeverity.critical} critical`));
+        if (stats.bySeverity.high > 0) severityParts.push(color('yellow', `${stats.bySeverity.high} high`));
+        if (stats.bySeverity.medium > 0) severityParts.push(color('blue', `${stats.bySeverity.medium} medium`));
+        if (stats.bySeverity.low > 0) severityParts.push(color('dim', `${stats.bySeverity.low} low`));
+
+        console.log(`  Open issues: ${stats.totalOpen} (${severityParts.join(', ')})`);
+
+        // Aging warning
+        if (stats.agingCount > 0) {
+          console.log(`  ${color('yellow', '\u26a0')} ${stats.agingCount} item${stats.agingCount !== 1 ? 's' : ''} aging (seen 3+ sessions)`);
+
+          // Auto-promote aging items to tasks
+          const promoted = debtManager.promoteAgingToTasks();
+          if (promoted.length > 0) {
+            console.log(`  ${color('green', '\u2713')} ${promoted.length} aging item${promoted.length !== 1 ? 's' : ''} added to task queue`);
+          }
+        }
+
+        // Auto-fixable hint
+        if (stats.autoFixable > 0) {
+          console.log(`  ${color('green', '\u2713')} ${stats.autoFixable} auto-fixable - run ${color('cyan', '/wogi-debt fix')}`);
+        }
+
+        console.log('');
+      }
+    } catch {
+      // Tech debt manager not available - skip silently
+    }
+  }
+
   // Changes since last session
   if (morningConfig.showChanges !== false) {
     const changes = briefing.changesSinceLastSession;

package/scripts/flow-onboard

@@ -940,9 +940,176 @@ print_summary() {
     echo ""
 }
 
+ask_onboard_mode() {
+    echo -e "${BOLD}How would you like to set up this project?${NC}"
+    echo ""
+    echo "  ${CYAN}[1]${NC} Fresh start - Analyze this project only"
+    echo "      Scan project structure, detect patterns, generate workflow files"
+    echo ""
+    echo "  ${CYAN}[2]${NC} Import profile - Load patterns from exported profile"
+    echo "      Import from a .zip profile exported from another project"
+    echo ""
+    echo "  ${CYAN}[3]${NC} Learn from project - Copy patterns from another folder"
+    echo "      Point to another project folder to extract and apply its patterns"
+    echo ""
+    read -p "Choice [1]: " onboard_choice
+
+    case "$onboard_choice" in
+        2) ONBOARD_MODE="import" ;;
+        3) ONBOARD_MODE="learn" ;;
+        *) ONBOARD_MODE="fresh" ;;
+    esac
+}
+
+handle_import_profile() {
+    echo ""
+    echo -e "${BOLD}Import from Profile${NC}"
+    echo ""
+    read -p "Path to profile ZIP: " profile_path
+
+    if [ -z "$profile_path" ] || [ ! -f "$profile_path" ]; then
+        echo -e "${RED}Error: Profile not found: $profile_path${NC}"
+        return 1
+    fi
+
+    echo ""
+    echo -e "${CYAN}Importing profile...${NC}"
+    "$SCRIPT_DIR/flow-import-profile" "$profile_path" --force
+
+    echo ""
+    echo -e "${GREEN}✓${NC} Profile imported. Continuing with project scan..."
+    echo ""
+}
+
+handle_learn_from_project() {
+    echo ""
+    echo -e "${BOLD}Learn from Another Project${NC}"
+    echo ""
+    read -p "Path to reference project: " reference_path
+
+    if [ -z "$reference_path" ] || [ ! -d "$reference_path" ]; then
+        echo -e "${RED}Error: Project folder not found: $reference_path${NC}"
+        return 1
+    fi
+
+    echo ""
+    echo -e "${CYAN}Scanning reference project for patterns...${NC}"
+
+    # Check for conflicts
+    echo -e "${DIM}Do you want to resolve any pattern conflicts interactively?${NC}"
+    echo "  [Y] Yes - I'll choose which patterns to adopt"
+    echo "  [n] No - Auto-accept the recommended patterns"
+    echo ""
+    read -p "Resolve conflicts? [Y/n]: " resolve_conflicts
+
+    local resolve_flag=""
+    if [[ ! "$resolve_conflicts" =~ ^[Nn]$ ]]; then
+        resolve_flag="--resolve-conflicts"
+    fi
+
+    "$SCRIPT_DIR/flow-import-profile" --scan "$reference_path" $resolve_flag --force
+
+    echo ""
+    echo -e "${GREEN}✓${NC} Patterns imported. Continuing with project scan..."
+    echo ""
+}
+
+run_pattern_extraction() {
+    # Run pattern extraction on current project to detect conflicts
+    echo -e "${CYAN}Scanning for patterns in current project...${NC}"
+
+    local temp_patterns=$(mktemp)
+    if node "$SCRIPT_DIR/flow-pattern-extractor.js" --format json --with-conflicts --output "$temp_patterns" 2>/dev/null; then
+        local conflict_count=$(node -e "const p = require('$temp_patterns'); console.log(p.conflicts ? p.conflicts.length : 0)" 2>/dev/null || echo "0")
+
+        if [ "$conflict_count" -gt 0 ]; then
+            echo -e "${YELLOW}!${NC} Found $conflict_count conflicting patterns in this codebase"
+            echo ""
+            echo "Some patterns in your codebase are inconsistent (e.g., old vs new code)."
+            echo "Would you like to resolve these conflicts now?"
+            echo ""
+            read -p "Resolve conflicts? [y/N]: " resolve_now
+
+            if [[ "$resolve_now" =~ ^[Yy]$ ]]; then
+                local conflicts_temp=$(mktemp)
+                node -e "const p = require('$temp_patterns'); console.log(JSON.stringify(p.conflicts, null, 2))" > "$conflicts_temp" 2>/dev/null
+
+                local resolved_file=$(mktemp)
+                if node "$SCRIPT_DIR/flow-conflict-resolver.js" --input "$conflicts_temp" --output "$resolved_file"; then
+                    # Apply resolved patterns to decisions.md
+                    local decisions_content=$(node "$SCRIPT_DIR/flow-conflict-resolver.js" --input "$resolved_file" --format decisions 2>/dev/null)
+                    if [ -n "$decisions_content" ]; then
+                        echo "" >> "$WORKFLOW_DIR/state/decisions.md"
+                        echo "---" >> "$WORKFLOW_DIR/state/decisions.md"
+                        echo "" >> "$WORKFLOW_DIR/state/decisions.md"
+                        echo "$decisions_content" >> "$WORKFLOW_DIR/state/decisions.md"
+                        echo -e "${GREEN}✓${NC} Pattern decisions saved to decisions.md"
+                    fi
+                fi
+                rm -f "$conflicts_temp" "$resolved_file"
+            fi
+        else
+            echo -e "${GREEN}✓${NC} No conflicting patterns detected"
+        fi
+
+        # Save patterns for reference
+        mkdir -p "$WORKFLOW_DIR/extracted"
+        mv "$temp_patterns" "$WORKFLOW_DIR/extracted/project-patterns.json"
+        echo -e "${GREEN}✓${NC} Patterns saved to .workflow/extracted/project-patterns.json"
+    else
+        rm -f "$temp_patterns"
+    fi
+    echo ""
+}
+
+ask_additional_docs() {
+    echo ""
+    echo -e "${BOLD}Additional Documentation${NC}"
+    echo ""
+    echo "Do you have any additional documentation to process?"
+    echo "(PRD, roadmap, specs, architecture docs, etc.)"
+    echo ""
+    echo "  ${CYAN}[1]${NC} Enter file path"
+    echo "  ${CYAN}[2]${NC} Paste content directly"
+    echo "  ${CYAN}[3]${NC} Skip"
+    echo ""
+    read -p "Choice [3]: " doc_choice
+
+    case "$doc_choice" in
+        1)
+            read -p "Path to document: " doc_path
+            if [ -f "$doc_path" ]; then
+                # Check size
+                local size=$(wc -c < "$doc_path")
+                if [ "$size" -gt 50000 ]; then
+                    echo -e "${CYAN}Processing large document through long-input pipeline...${NC}"
+                    if [ -f "$SCRIPT_DIR/flow-long-input.js" ]; then
+                        node "$SCRIPT_DIR/flow-long-input.js" process "$doc_path" 2>/dev/null || true
+                    fi
+                else
+                    ADDITIONAL_DOCS=$(cat "$doc_path" 2>/dev/null)
+                    echo -e "${GREEN}✓${NC} Document loaded"
+                fi
+            else
+                echo -e "${YELLOW}File not found${NC}"
+            fi
+            ;;
+        2)
+            echo "Paste your content (end with a line containing just 'END'):"
+            local pasted=""
+            while IFS= read -r line; do
+                [[ "$line" == "END" ]] && break
+                pasted+="$line"$'\n'
+            done
+            ADDITIONAL_DOCS="$pasted"
+            echo -e "${GREEN}✓${NC} Content captured"
+            ;;
+    esac
+}
+
 main() {
     print_header
-    
+
     # Check if already onboarded
     if [ -f "$WORKFLOW_DIR/specs/project.md" ] && grep -q "Tech Stack" "$WORKFLOW_DIR/specs/project.md" 2>/dev/null; then
         echo -e "${YELLOW}⚠ This project appears to be already onboarded.${NC}"
@@ -954,14 +1121,30 @@ main() {
         fi
         echo ""
     fi
-    
+
     # Ensure workflow exists
     if [ ! -d "$WORKFLOW_DIR" ]; then
         echo -e "${YELLOW}Workflow not initialized. Running install first...${NC}"
         "$SCRIPT_DIR/flow-install" --quick "$(basename "$(pwd)")"
         echo ""
     fi
-    
+
+    # Ask how user wants to set up the project
+    echo -e "${BOLD}━━━ Setup Mode ━━━${NC}"
+    echo ""
+    ask_onboard_mode
+    echo ""
+
+    # Handle import/learn modes
+    case "$ONBOARD_MODE" in
+        import)
+            handle_import_profile || exit 1
+            ;;
+        learn)
+            handle_learn_from_project || exit 1
+            ;;
+    esac
+
     # Detection phase
     echo -e "${BOLD}━━━ Analyzing Project ━━━${NC}"
     echo ""
@@ -986,7 +1169,29 @@ main() {
     ask_current_state
     ask_known_issues
     ask_coding_preferences
-    
+
+    # Pattern extraction - scan current project for patterns and conflicts
+    # For fresh mode: detect internal conflicts in the codebase
+    # For import/learn modes: detect conflicts between imported and local patterns
+    echo ""
+    echo -e "${BOLD}━━━ Pattern Analysis ━━━${NC}"
+    echo ""
+
+    # Only run if there are enough files to analyze
+    local file_count=$(find . -type f \( -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.jsx" -o -name "*.py" \) \
+        -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/dist/*" 2>/dev/null | wc -l | tr -d ' ')
+
+    if [ "$file_count" -gt 5 ]; then
+        echo -e "${DIM}Found $file_count source files to analyze${NC}"
+        run_pattern_extraction
+    else
+        echo -e "${DIM}Skipping pattern analysis (less than 5 source files)${NC}"
+    fi
+
+    # Ask for additional documentation
+    ask_additional_docs
+
+    echo ""
     echo -e "${BOLD}━━━ Generating Workflow Files ━━━${NC}"
     echo ""
     
@@ -1031,13 +1236,21 @@ if [ "${1:-}" = "--help" ] || [ "${1:-}" = "-h" ]; then
     echo ""
     echo "Usage: flow onboard"
     echo ""
+    echo "Setup Options:"
+    echo "  1. Fresh start   - Analyze this project only"
+    echo "  2. Import profile - Load patterns from exported .zip profile"
+    echo "  3. Learn from project - Extract patterns from another folder"
+    echo ""
     echo "This will:"
-    echo "  1. Detect your tech stack (language, framework, database)"
-    echo "  2. Scan for components, pages, modules"
-    echo "  3. Ask about your project (PRD, goals, issues)"
-    echo "  4. Generate project.md, app-map.md, decisions.md"
-    echo "  5. Create initial tasks from known issues"
-    echo "  6. Suggest relevant skills to install"
+    echo "  1. Ask how you want to set up (fresh/import/learn)"
+    echo "  2. Detect your tech stack (language, framework, database)"
+    echo "  3. Scan for components, pages, modules"
+    echo "  4. Extract patterns and detect conflicts"
+    echo "  5. Ask about your project (PRD, goals, issues)"
+    echo "  6. Ask for additional documentation (PRD, roadmap)"
+    echo "  7. Generate project.md, app-map.md, decisions.md"
+    echo "  8. Create initial tasks from known issues"
+    echo "  9. Suggest relevant skills to install"
     exit 0
 fi