wogiflow 2.4.2 → 2.4.3

package/scripts/flow-spec-generator.js

@@ -20,8 +20,6 @@ const { success, warn, error: errorMsg, info } = require('./flow-output');
 const { matchSkills, loadSkillContext } = require('./flow-skill-matcher');
 const { getCommand } = require('./flow-script-resolver');
 
-const PROJECT_ROOT = getProjectRoot();
-
 // ============================================================
 // Spec Generation
 // ============================================================
@@ -449,7 +447,7 @@ function generateRollbackPlan(taskContext) {
 function saveSpec(taskId, spec) {
   const config = getConfig();
   const specDir = config.specificationMode?.specDirectory || '.workflow/specs';
-  const fullDir = path.join(PROJECT_ROOT, specDir);
+  const fullDir = path.join(PATHS.root, specDir);
 
   // Ensure directory exists
   if (!fs.existsSync(fullDir)) {
@@ -629,7 +627,7 @@ function formatSpecAsMarkdown(spec) {
 function loadSpec(taskId) {
   const config = getConfig();
   const specDir = config.specificationMode?.specDirectory || '.workflow/specs';
-  const jsonPath = path.join(PROJECT_ROOT, specDir, `${taskId}.json`);
+  const jsonPath = path.join(PATHS.root, specDir, `${taskId}.json`);
 
   if (!fs.existsSync(jsonPath)) {
     return null;

package/scripts/flow-stack-wizard.js

@@ -6,7 +6,7 @@
  * and "Let AI decide" option for intelligent defaults
  */
 
-const readline = require('node:readline');
+const readline = require('node:readline/promises');
 const path = require('node:path');
 const fs = require('node:fs');
 
@@ -852,6 +852,7 @@ class EnhancedStackWizard {
 
     try {
       const generator = require('./flow-skill-generator');
+const { PATHS } = require('./flow-utils');
       await generator.generateSkills(technologies, this.selections);
 
       console.log(c('green', '\n✅ Skills generated successfully!\n'));
@@ -906,12 +907,9 @@ class EnhancedStackWizard {
   // INPUT HELPERS
   // ============================================
 
-  askQuestion(prompt) {
-    return new Promise((resolve) => {
-      this.rl.question(prompt, (answer) => {
-        resolve(answer.trim());
-      });
-    });
+  async askQuestion(prompt) {
+    const answer = await this.rl.question(prompt);
+    return answer.trim();
   }
 
   async askSingleChoice(question, options, defaultValue = null) {

package/scripts/flow-standards-learner.js

@@ -404,9 +404,22 @@ function recordViolationPattern(learning) {
     }
   }
 
-  // Write updated content
+  // Write updated content through orchestrator
   try {
-    fs.writeFileSync(FEEDBACK_PATTERNS_PATH, content, 'utf-8');
+    const { writeToFeedbackPatterns } = require('./flow-learning-orchestrator');
+    const writeResult = writeToFeedbackPatterns({
+      content,
+      entryText: patternKey,
+      caller: 'flow-standards-learner/recordViolationPattern',
+      skipDedup: true // We already handle dedup via patternRegex above
+    });
+    // writeToFeedbackPatterns is async but we handle it fire-and-forget here
+    // since the sync callers can't await. The lock still protects the write.
+    if (writeResult && writeResult.then) {
+      writeResult.catch(err => {
+        if (process.env.DEBUG) console.error(`[DEBUG] recordViolationPattern write: ${err.message}`);
+      });
+    }
   } catch (err) {
     return { recorded: false, reason: err.message };
   }
@@ -508,24 +521,30 @@ ${learning.ruleTemplate}
     content += ruleEntry;
   }
 
-  // Write updated content
+  // Write updated content through orchestrator
   try {
-    fs.writeFileSync(DECISIONS_PATH, content, 'utf-8');
-  } catch (err) {
-    return { promoted: false, reason: err.message };
-  }
+    const { writeToDecisions, modifyFeedbackPatterns } = require('./flow-learning-orchestrator');
+    const writeResult = writeToDecisions({
+      content,
+      entryText: learning.patternName,
+      caller: 'flow-standards-learner/promoteToDecisions'
+    });
+    if (writeResult && writeResult.then) {
+      writeResult.catch(err => {
+        if (process.env.DEBUG) console.error(`[DEBUG] promoteToDecisions write: ${err.message}`);
+      });
+    }
 
-  // Update feedback-patterns.md to mark as promoted
-  try {
-    let patternsContent = readFile(FEEDBACK_PATTERNS_PATH, '');
+    // Update feedback-patterns.md to mark as promoted
     const patternKey = `${learning.violationType}-${learning.patternName}`.replace(/\s+/g, '-').toLowerCase();
-    // escapeRegex prevents ReDoS from patternKey with regex metacharacters
     const escapedPromoteKey = escapeRegex(patternKey);
-    patternsContent = patternsContent.replace(
-      new RegExp(`(\\|\\s*[\\d-]+\\s*\\|\\s*${escapedPromoteKey}\\s*\\|\\s*\\d+\\s*\\|)\\s*-\\s*\\|\\s*Monitor\\s*\\|`, 'i'),
-      `$1 decisions.md | **PROMOTED** |`
-    );
-    fs.writeFileSync(FEEDBACK_PATTERNS_PATH, patternsContent, 'utf-8');
+    modifyFeedbackPatterns((currentContent) => {
+      const updated = currentContent.replace(
+        new RegExp(`(\\|\\s*[\\d-]+\\s*\\|\\s*${escapedPromoteKey}\\s*\\|\\s*\\d+\\s*\\|)\\s*-\\s*\\|\\s*Monitor\\s*\\|`, 'i'),
+        `$1 decisions.md | **PROMOTED** |`
+      );
+      return { content: updated };
+    }, { caller: 'flow-standards-learner/promoteToDecisions-markPromoted', skipDedup: true });
   } catch (err) {
     // Non-fatal, rule was already promoted to decisions
   }

package/scripts/flow-start.js

@@ -55,6 +55,7 @@ const assessTaskComplexity = complexityModule?.assessTaskComplexity || (() => ({
 const { warnIfContextHigh } = require('./flow-context-monitor');
 const { setCurrentTask } = require('./flow-memory-blocks');
 const { trackTaskStart, checkAndDisplayResumeContext } = require('./flow-session-state');
+const { setActiveTask: setHookActiveTask } = require('./flow-hook-status');
 
 // v2.0 durable session support
 const {
@@ -505,6 +506,7 @@ async function main() {
   try {
     trackTaskStart(taskId, taskTitle);
     setCurrentTask(taskId, taskTitle);
+    setHookActiveTask({ id: taskId, title: taskTitle, routedAt: new Date().toISOString() });
   } catch (err) {
     if (process.env.DEBUG) console.error(`[DEBUG] Task tracking: ${err.message}`);
   }

package/scripts/flow-stats-collector.js

@@ -31,8 +31,8 @@ const {
 // Constants
 // ============================================================
 
-const STATS_PATH = path.join(PATHS.root, '.workflow', 'models', 'stats.json');
-const STATS_ARCHIVE_DIR = path.join(PATHS.root, '.workflow', 'models', 'stats-archive');
+const STATS_PATH = PATHS.modelStats;
+const STATS_ARCHIVE_DIR = PATHS.modelStatsArchive;
 const MAX_RECENT_TASKS = 500;
 
 // ============================================================

package/scripts/flow-status.js

@@ -86,8 +86,8 @@ function collectStatus() {
       status.cli.type = config.cli?.type || 'claude-code';
 
       // Check bridge status
-      const bridgesDir = path.join(PROJECT_ROOT, '.workflow', 'bridges');
-      const modelsDir = path.join(PROJECT_ROOT, '.workflow', 'models');
+      const bridgesDir = PATHS.bridges;
+      const modelsDir = PATHS.modelsDir;
 
       if (dirExists(bridgesDir) && dirExists(modelsDir)) {
         status.cli.bridgeStatus = 'configured';
@@ -105,9 +105,9 @@ function collectStatus() {
   if (fileExists(PATHS.config)) {
     const config = getConfig();
     status.config = {
-      mandatoryAfterTask: config.mandatorySteps?.afterTask || [],
-      strictMode: config.enforcement?.strictMode || false,
-      priorities: config.priorities || {}
+      mandatoryAfterTask: config.mandatorySteps?.afterTask ?? [],
+      strictMode: config.enforcement?.strictMode ?? false,
+      priorities: config.priorities ?? {}
     };
   }
 
@@ -188,7 +188,7 @@ function main() {
   if (status.git.isRepo) {
     printSection('Git');
     console.log(`  Branch: ${status.git.branch || 'unknown'}`);
-    console.log(`  Uncommitted: ${status.git.uncommitted || 0} files`);
+    console.log(`  Uncommitted: ${status.git.uncommitted ?? 0} files`);
     console.log('');
   }
 
@@ -229,7 +229,7 @@ function main() {
     }
 
     // Show recent attempts (last 3)
-    const recentAttempts = (status.bypassTracking.attempts || []).slice(-3);
+    const recentAttempts = (status.bypassTracking.attempts ?? []).slice(-3);
     if (recentAttempts.length > 0) {
       console.log(color('dim', '  Recent attempts:'));
       for (const attempt of recentAttempts) {
@@ -278,7 +278,7 @@ function getRecommendation() {
   const data = getReadyData();
 
   // Check in-progress tasks first
-  const inProgress = data.inProgress || [];
+  const inProgress = data.inProgress ?? [];
   if (inProgress.length > 0) {
     const task = inProgress[0];
     const taskId = typeof task === 'string' ? task : task.id;
@@ -290,7 +290,7 @@ function getRecommendation() {
   }
 
   // Check ready tasks
-  const ready = data.ready || [];
+  const ready = data.ready ?? [];
   if (ready.length > 0) {
     // Find highest priority task (P0=critical, P1=high, P2=medium, P3=low, P4=lowest)
     const priorityOrder = { P0: 0, P1: 1, P2: 2, P3: 3, P4: 4 };
@@ -311,7 +311,7 @@ function getRecommendation() {
   }
 
   // Check blocked tasks
-  const blocked = data.blocked || [];
+  const blocked = data.blocked ?? [];
   if (blocked.length > 0) {
     return {
       action: `${blocked.length} task(s) are blocked - resolve dependencies`,

package/scripts/flow-statusline-setup.js

@@ -17,7 +17,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const os = require('node:os');
-const readline = require('node:readline');
+const readline = require('node:readline/promises');
 const { colors, printHeader, safeJsonParse } = require('./flow-utils');
 const { success, error: errorMsg } = require('./flow-output');
 
@@ -105,7 +105,7 @@ async function interactiveSetup() {
     output: process.stdout
   });
 
-  const question = (q) => new Promise(resolve => rl.question(q, resolve));
+  const question = (q) => rl.question(q);
 
   printHeader('Status Line Setup');
   showCurrentConfig();

package/scripts/flow-step-changelog.js

@@ -9,10 +9,9 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { getProjectRoot, colors, getConfig } = require('./flow-utils');
+const { getProjectRoot, colors, getConfig, PATHS } = require('./flow-utils');
 
-const PROJECT_ROOT = getProjectRoot();
-const CHANGELOG_PATH = path.join(PROJECT_ROOT, 'CHANGELOG.md');
+const CHANGELOG_PATH = path.join(PATHS.root, 'CHANGELOG.md');
 
 /**
  * Run update changelog step

package/scripts/flow-step-comments.js

@@ -11,96 +11,80 @@
  * - Missing documentation for public APIs
  */
 
-const fs = require('node:fs');
-const path = require('node:path');
-const { getProjectRoot, colors } = require('./flow-utils');
-
-const PROJECT_ROOT = getProjectRoot();
-
-/**
- * Run comment analysis as a workflow step
- *
- * @param {object} options
- * @param {string[]} options.files - Files modified
- * @param {object} options.stepConfig - Step configuration
- * @param {string} options.mode - Step mode (block/warn/prompt/auto)
- * @returns {object} - { passed: boolean, message: string, details?: object[] }
- */
-async function run(options = {}) {
-  const { files = [], stepConfig = {} } = options;
-  const flagTodo = stepConfig.flagTodo !== false;
-  const flagFixme = stepConfig.flagFixme !== false;
-  const checkJsdoc = stepConfig.checkJsdoc !== false;
-  const flagCommentedCode = stepConfig.flagCommentedCode !== false;
-  const flagStale = stepConfig.flagStale !== false;
-
-  // Filter to analyzable files
-  const analyzableExtensions = ['.js', '.ts', '.jsx', '.tsx'];
-  const analyzableFiles = files.filter(f =>
-    analyzableExtensions.some(ext => f.endsWith(ext)) &&
-    !f.includes('.d.ts')
-  );
-
-  if (analyzableFiles.length === 0) {
-    return { passed: true, message: 'No files to analyze' };
+const { BaseWorkflowStep } = require('./base-workflow-step');
+const { colors } = require('./flow-utils');
+
+class CommentAnalyzerStep extends BaseWorkflowStep {
+  constructor() {
+    super('commentAnalyzer', {
+      extensions: ['.js', '.ts', '.jsx', '.tsx'],
+      excludeTests: false, // Comments step analyzes test files too
+      excludeDts: true,
+    });
   }
 
-  const issues = [];
-
-  for (const file of analyzableFiles) {
-    const filePath = path.join(PROJECT_ROOT, file);
-    if (!fs.existsSync(filePath)) continue;
-
-    try {
-      const content = fs.readFileSync(filePath, 'utf8');
-      const fileIssues = analyzeComments(content, file, {
-        flagTodo,
-        flagFixme,
-        checkJsdoc,
-        flagCommentedCode,
-        flagStale,
-      });
-      issues.push(...fileIssues);
-    } catch (err) {
-      // Skip unreadable files
+  async execute(files, options) {
+    const { stepConfig = {} } = options;
+    const flagTodo = stepConfig.flagTodo !== false;
+    const flagFixme = stepConfig.flagFixme !== false;
+    const checkJsdoc = stepConfig.checkJsdoc !== false;
+    const flagCommentedCode = stepConfig.flagCommentedCode !== false;
+    const flagStale = stepConfig.flagStale !== false;
+
+    const issues = [];
+
+    for (const file of files) {
+      const content = this.readFile(file);
+      if (!content) continue;
+
+      try {
+        const fileIssues = analyzeComments(content, file, {
+          flagTodo,
+          flagFixme,
+          checkJsdoc,
+          flagCommentedCode,
+          flagStale,
+        });
+        issues.push(...fileIssues);
+      } catch (_err) {
+        // Skip unreadable files
+      }
     }
-  }
-
-  if (issues.length === 0) {
-    return {
-      passed: true,
-      message: 'Comment analysis passed',
-    };
-  }
 
-  // Report issues
-  console.log(colors.yellow + '\n  Comment Analysis Issues:' + colors.reset);
+    if (issues.length === 0) {
+      return this.pass('Comment analysis passed');
+    }
 
-  // Group by type
-  const grouped = {};
-  for (const issue of issues) {
-    if (!grouped[issue.type]) grouped[issue.type] = [];
-    grouped[issue.type].push(issue);
-  }
+    // Report issues
+    console.log(colors.yellow + '\n  Comment Analysis Issues:' + colors.reset);
 
-  for (const [type, typeIssues] of Object.entries(grouped)) {
-    console.log(colors.cyan + `  ${type}:` + colors.reset);
-    for (const issue of typeIssues.slice(0, 5)) { // Limit to 5 per type
-      console.log(`    ${issue.file}:${issue.line}`);
-      console.log(`       ${issue.message}`);
+    // Group by type
+    const grouped = {};
+    for (const issue of issues) {
+      if (!grouped[issue.type]) grouped[issue.type] = [];
+      grouped[issue.type].push(issue);
     }
-    if (typeIssues.length > 5) {
-      console.log(colors.dim + `    ... and ${typeIssues.length - 5} more` + colors.reset);
+
+    for (const [type, typeIssues] of Object.entries(grouped)) {
+      console.log(colors.cyan + `  ${type}:` + colors.reset);
+      for (const issue of typeIssues.slice(0, 5)) {
+        console.log(`    ${issue.file}:${issue.line}`);
+        console.log(`       ${issue.message}`);
+      }
+      if (typeIssues.length > 5) {
+        console.log(colors.dim + `    ... and ${typeIssues.length - 5} more` + colors.reset);
+      }
     }
-  }
 
-  const highSeverity = issues.filter(i => i.severity === 'high');
+    const highSeverity = issues.filter(i => i.severity === 'high');
 
-  return {
-    passed: highSeverity.length === 0,
-    message: `${issues.length} comment issue(s) found (${highSeverity.length} high severity)`,
-    details: issues,
-  };
+    return highSeverity.length === 0
+      ? this.pass(`${issues.length} comment issue(s) found (${highSeverity.length} high severity)`)
+      : this.fail(
+          `${issues.length} comment issue(s) found (${highSeverity.length} high severity)`,
+          issues
+        );
+  }
 }
 
 /**
@@ -303,4 +287,5 @@ function checkJsDocAccuracy(jsDocLines, functionLine, startLine, fileName) {
   return issues;
 }
 
-module.exports = { run, analyzeComments };
+const step = new CommentAnalyzerStep();
+module.exports = { run: (opts) => step.run(opts), analyzeComments };

package/scripts/flow-step-complexity.js

@@ -7,83 +7,62 @@
  * Flags functions that exceed the configured threshold.
  */
 
-const fs = require('node:fs');
-const path = require('node:path');
-const { getProjectRoot, colors } = require('./flow-utils');
-
-const PROJECT_ROOT = getProjectRoot();
-
-/**
- * Run code complexity check step
- *
- * @param {object} options
- * @param {string[]} options.files - Files modified
- * @param {object} options.stepConfig - Step configuration
- * @param {string} options.mode - Step mode (block/warn/prompt/auto)
- * @returns {object} - { passed: boolean, message: string, details?: object[] }
- */
-async function run(options = {}) {
-  const { files = [], stepConfig = {}, mode } = options;
-  const threshold = stepConfig.threshold || 10;
-
-  // Filter to analyzable files
-  const analyzableExtensions = ['.js', '.ts', '.jsx', '.tsx'];
-  const analyzableFiles = files.filter(f =>
-    analyzableExtensions.some(ext => f.endsWith(ext)) &&
-    !f.includes('.test.') &&
-    !f.includes('.spec.') &&
-    !f.includes('.d.ts')
-  );
-
-  if (analyzableFiles.length === 0) {
-    return { passed: true, message: 'No analyzable files modified' };
+const { BaseWorkflowStep } = require('./base-workflow-step');
+const { colors } = require('./flow-utils');
+
+class ComplexityStep extends BaseWorkflowStep {
+  constructor() {
+    super('codeComplexityCheck', {
+      extensions: ['.js', '.ts', '.jsx', '.tsx'],
+      excludeTests: true,
+      excludeDts: true,
+    });
   }
 
-  const complexFunctions = [];
-
-  for (const file of analyzableFiles) {
-    const filePath = path.join(PROJECT_ROOT, file);
-    if (!fs.existsSync(filePath)) continue;
-
-    try {
-      const content = fs.readFileSync(filePath, 'utf8');
-      const functions = analyzeComplexity(content, file);
-
-      for (const func of functions) {
-        if (func.complexity > threshold) {
-          complexFunctions.push({
-            file,
-            function: func.name,
-            complexity: func.complexity,
-            line: func.line,
-            suggestion: getSuggestion(func.complexity, threshold),
-          });
+  async execute(files, options) {
+    const { stepConfig = {} } = options;
+    const threshold = stepConfig.threshold || 10;
+    const complexFunctions = [];
+
+    for (const file of files) {
+      const content = this.readFile(file);
+      if (!content) continue;
+
+      try {
+        const functions = analyzeComplexity(content, file);
+
+        for (const func of functions) {
+          if (func.complexity > threshold) {
+            complexFunctions.push({
+              file,
+              function: func.name,
+              complexity: func.complexity,
+              line: func.line,
+              suggestion: getSuggestion(func.complexity, threshold),
+            });
+          }
         }
+      } catch (_err) {
+        // Skip files that can't be analyzed
       }
-    } catch (err) {
-      // Skip files that can't be analyzed
     }
-  }
 
-  if (complexFunctions.length === 0) {
-    return {
-      passed: true,
-      message: `All functions under complexity threshold (${threshold})`,
-    };
-  }
+    if (complexFunctions.length === 0) {
+      return this.pass(`All functions under complexity threshold (${threshold})`);
+    }
 
-  // Report complex functions
-  console.log(colors.yellow + `\n  Functions exceeding complexity threshold (${threshold}):` + colors.reset);
-  for (const func of complexFunctions) {
-    console.log(`    ${func.file}:${func.line} - ${func.function} (${func.complexity})`);
-    console.log(colors.gray + `      ${func.suggestion}` + colors.reset);
-  }
+    // Report complex functions
+    console.log(colors.yellow + `\n  Functions exceeding complexity threshold (${threshold}):` + colors.reset);
+    for (const func of complexFunctions) {
+      console.log(`    ${func.file}:${func.line} - ${func.function} (${func.complexity})`);
+      console.log(colors.gray + `      ${func.suggestion}` + colors.reset);
+    }
 
-  return {
-    passed: false,
-    message: `${complexFunctions.length} function(s) exceed complexity threshold`,
-    details: complexFunctions,
-  };
+    return this.fail(
+      `${complexFunctions.length} function(s) exceed complexity threshold`,
+      complexFunctions
+    );
+  }
 }
 
 /**
@@ -231,4 +210,5 @@ function getSuggestion(complexity, threshold) {
   return 'Consider simplifying conditional logic';
 }
 
-module.exports = { run, analyzeComplexity, calculateComplexity };
+const step = new ComplexityStep();
+module.exports = { run: (opts) => step.run(opts), analyzeComplexity, calculateComplexity };

package/scripts/flow-step-coverage.js

@@ -13,8 +13,6 @@ const { execSync } = require('node:child_process');
 const { getProjectRoot, colors, getConfig, safeJsonParse, readJson, error } = require('./flow-utils');
 const { getCommand, getExec } = require('./flow-script-resolver');
 
-const PROJECT_ROOT = getProjectRoot();
-
 // Common coverage output locations
 const COVERAGE_PATHS = [
   'coverage/coverage-summary.json',   // Jest/Vitest JSON summary
@@ -116,7 +114,7 @@ async function run(options = {}) {
  */
 function findExistingCoverage() {
   for (const coveragePath of COVERAGE_PATHS) {
-    const fullPath = path.join(PROJECT_ROOT, coveragePath);
+    const fullPath = path.join(PATHS.root, coveragePath);
     if (fs.existsSync(fullPath)) {
       try {
         if (coveragePath.endsWith('.json')) {
@@ -142,7 +140,7 @@ function findExistingCoverage() {
  */
 async function runCoverageTests() {
   // Check package.json for test script
-  const packagePath = path.join(PROJECT_ROOT, 'package.json');
+  const packagePath = path.join(PATHS.root, 'package.json');
   if (!fs.existsSync(packagePath)) return null;
 
   try {
@@ -169,7 +167,7 @@ async function runCoverageTests() {
 
     // Run coverage
     execSync(coverageCmd, {
-      cwd: PROJECT_ROOT,
+      cwd: PATHS.root,
       stdio: ['pipe', 'pipe', 'pipe'],
       timeout: 300000, // 5 minute timeout
     });

package/scripts/flow-step-knowledge.js

@@ -9,10 +9,9 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { getProjectRoot, colors, getConfig } = require('./flow-utils');
+const { getProjectRoot, colors, getConfig, PATHS } = require('./flow-utils');
 
-const PROJECT_ROOT = getProjectRoot();
-const KNOWLEDGE_DIR = path.join(PROJECT_ROOT, '.claude', 'docs', 'knowledge-base');
+const KNOWLEDGE_DIR = path.join(PATHS.root, '.claude', 'docs', 'knowledge-base');
 
 /**
  * Run update knowledge base step