wogiflow 2.4.2 → 2.4.4

package/scripts/flow-io.js

@@ -1,5 +1,3 @@
-'use strict';
-
 /**
  * Wogi Flow - File I/O Operations
  *
@@ -510,7 +508,7 @@ async function acquireLock(filePath, options = {}) {
             if (process.env.DEBUG) {
               console.warn(`[DEBUG] Stale lock cleanup failed: ${err.message}`);
             }
-            await new Promise(resolve => setTimeout(resolve, retryDelay));
+            await require('node:timers/promises').setTimeout(retryDelay);
           }
           // Try again
           continue;
@@ -521,7 +519,7 @@ async function acquireLock(filePath, options = {}) {
           const delay = exponentialBackoff
             ? retryDelay * Math.pow(2, attempt)
             : retryDelay * (attempt + 1);
-          await new Promise(resolve => setTimeout(resolve, delay));
+          await require('node:timers/promises').setTimeout(delay);
           continue;
         }
       }
@@ -646,6 +644,22 @@ function cleanupStaleLocks(dirPath, staleMs = CLEANUP_LOCK_STALE_MS) {
   }
 }
 
+// ============================================================
+// String Sanitization (for AI context injection)
+// ============================================================
+
+/**
+ * Sanitize a string value before injecting into AI context.
+ * Strips markdown heading markers and truncates to prevent prompt manipulation.
+ *
+ * @param {string} value - Raw string from state files
+ * @param {number} [maxLen=200] - Maximum length
+ * @returns {string} Sanitized string
+ */
+function sanitizeForContext(value, maxLen = 200) {
+  return String(value).replace(/^#+\s/gm, '').slice(0, maxLen);
+}
+
 // ============================================================
 // Exports
 // ============================================================
@@ -689,4 +703,7 @@ module.exports = {
   withLock,
   withLockSync,
   cleanupStaleLocks,
+
+  // String Sanitization
+  sanitizeForContext,
 };

package/scripts/flow-knowledge-router.js

@@ -303,10 +303,16 @@ ${correction}
 `;
 
   content += entry;
-  fs.writeFileSync(decisionsPath, content);
 
-  // Sync to .claude/rules/ for Claude Code integration
-  syncDecisionsToRules();
+  // Route through orchestrator for locking and dedup
+  try {
+    const { writeToDecisions } = require('./flow-learning-orchestrator');
+    await writeToDecisions({ content, entryText: correction.slice(0, 100), caller: 'flow-knowledge-router', skipDedup: false, syncRules: true });
+  } catch (_err) {
+    // Fallback to direct write if orchestrator unavailable
+    fs.writeFileSync(decisionsPath, content);
+    syncDecisionsToRules();
+  }
 
   return {
     success: true,

package/scripts/flow-learning-orchestrator.js

@@ -1,10 +1,13 @@
-'use strict';
-
 /**
- * Learning Orchestrator Facade
+ * Learning Orchestrator — Centralized Write Mediator
+ *
+ * ALL writes to feedback-patterns.md and decisions.md MUST go through this module.
+ * Direct fs.writeFileSync to these files from learning modules is prohibited.
  *
- * Coordinates all learning pipeline modules with a unified API.
- * Existing direct imports continue working — this facade is additive.
+ * Features:
+ *   - Centralized write API with dedup checking
+ *   - Write locking via acquireLock to prevent race conditions
+ *   - Fuzzy dedup: rejects writes that duplicate existing entries
  *
  * Sub-modules (lazy-loaded to avoid startup cost):
  *   - flow-skill-learn.js          — Skill discovery and learning
@@ -20,6 +23,16 @@
  *   - flow-standards-learner.js    — Standards violation learning
  */
 
+const fs = require('node:fs');
+const { PATHS } = require('./flow-paths');
+const { acquireLock, readFile, writeFile, fileExists } = require('./flow-io');
+
+// ============================================================
+// Constants
+// ============================================================
+
+const DEDUP_SIMILARITY_THRESHOLD = 0.85; // 85% similarity = duplicate
+
 // ============================================================
 // Lazy Loaders
 // ============================================================
@@ -36,6 +49,287 @@ function getFailureLearning() { return require('./flow-failure-learning'); }
 function getAutoLearn() { return require('./flow-auto-learn'); }
 function getStandardsLearner() { return require('./flow-standards-learner'); }
 
+// ============================================================
+// Dedup Utilities
+// ============================================================
+
+/**
+ * Normalize text for dedup comparison: lowercase, strip punctuation, collapse whitespace.
+ * @param {string} text
+ * @returns {string}
+ */
+function normalizeForDedup(text) {
+  if (!text || typeof text !== 'string') return '';
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+/**
+ * Compute bigram similarity between two strings (Dice coefficient).
+ * Returns 0..1 where 1 = identical.
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+function bigramSimilarity(a, b) {
+  const na = normalizeForDedup(a);
+  const nb = normalizeForDedup(b);
+
+  if (na === nb) return 1.0;
+  if (na.length < 2 || nb.length < 2) return 0;
+
+  const bigramsA = new Set();
+  for (let i = 0; i < na.length - 1; i++) bigramsA.add(na.slice(i, i + 2));
+  const bigramsB = new Set();
+  for (let i = 0; i < nb.length - 1; i++) bigramsB.add(nb.slice(i, i + 2));
+
+  let intersection = 0;
+  for (const bg of bigramsA) {
+    if (bigramsB.has(bg)) intersection++;
+  }
+
+  return (2 * intersection) / (bigramsA.size + bigramsB.size);
+}
+
+/**
+ * Check if an entry already exists in file content (fuzzy match).
+ * Checks both exact substring and bigram similarity against existing entries.
+ *
+ * @param {string} content - Current file content
+ * @param {string} entryText - The new entry text to check
+ * @returns {{ isDuplicate: boolean, matchedText?: string, similarity?: number }}
+ */
+function checkDuplicate(content, entryText) {
+  if (!content || !entryText) return { isDuplicate: false };
+
+  const normalizedEntry = normalizeForDedup(entryText);
+  if (!normalizedEntry || normalizedEntry.length < 5) return { isDuplicate: false };
+
+  // Exact substring check (case-insensitive)
+  if (content.toLowerCase().includes(normalizedEntry)) {
+    return { isDuplicate: true, matchedText: entryText, similarity: 1.0 };
+  }
+
+  // Extract existing entries from tables (pipe-delimited rows) and headings
+  const lines = content.split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Skip header rows and separators
+    if (!trimmed || trimmed.startsWith('|---') || trimmed.startsWith('| Date')) continue;
+
+    // Table row: extract content cells
+    if (trimmed.startsWith('|')) {
+      const cells = trimmed.split('|').slice(1, -1).map(c => c.trim());
+      // Check cells 1 and 2 (pattern/correction columns)
+      for (let i = 1; i < Math.min(cells.length, 3); i++) {
+        const sim = bigramSimilarity(cells[i], entryText);
+        if (sim >= DEDUP_SIMILARITY_THRESHOLD) {
+          return { isDuplicate: true, matchedText: cells[i], similarity: sim };
+        }
+      }
+    }
+
+    // Heading: ### Pattern Name
+    if (trimmed.startsWith('###')) {
+      const heading = trimmed.replace(/^###\s*/, '').replace(/\s*\([\d-]+\)$/, '');
+      const sim = bigramSimilarity(heading, entryText);
+      if (sim >= DEDUP_SIMILARITY_THRESHOLD) {
+        return { isDuplicate: true, matchedText: heading, similarity: sim };
+      }
+    }
+  }
+
+  return { isDuplicate: false };
+}
+
+// ============================================================
+// Centralized Write API
+// ============================================================
+
+/**
+ * Write to feedback-patterns.md through the orchestrator.
+ * Acquires a lock, checks for duplicates, then applies the write.
+ *
+ * @param {Object} params
+ * @param {string} params.content - Full new content to write (replaces file)
+ * @param {string} [params.entryText] - Key text of the new entry (for dedup)
+ * @param {string} params.caller - Calling module name (for logging)
+ * @param {boolean} [params.skipDedup=false] - Skip dedup check (for bulk rewrites)
+ * @returns {Promise<{ success: boolean, reason?: string }>}
+ */
+async function writeToFeedbackPatterns({ content, entryText, caller, skipDedup = false }) {
+  const filePath = PATHS.feedbackPatterns;
+
+  const release = await acquireLock(filePath, { retries: 5, retryDelay: 100 });
+  try {
+    // Dedup check
+    if (!skipDedup && entryText) {
+      const currentContent = fileExists(filePath) ? readFile(filePath, '') : '';
+      const dupCheck = checkDuplicate(currentContent, entryText);
+      if (dupCheck.isDuplicate) {
+        if (process.env.DEBUG) {
+          console.log(`[orchestrator] Dedup rejected write from ${caller}: "${entryText}" matches "${dupCheck.matchedText}" (${(dupCheck.similarity * 100).toFixed(0)}%)`);
+        }
+        return { success: false, reason: 'duplicate', matchedText: dupCheck.matchedText, similarity: dupCheck.similarity };
+      }
+    }
+
+    writeFile(filePath, content);
+    if (process.env.DEBUG) {
+      console.log(`[orchestrator] ${caller} wrote to feedback-patterns.md`);
+    }
+    return { success: true };
+  } catch (err) {
+    return { success: false, reason: err.message };
+  } finally {
+    release();
+  }
+}
+
+/**
+ * Write to decisions.md through the orchestrator.
+ * Acquires a lock, checks for duplicates, then applies the write.
+ *
+ * @param {Object} params
+ * @param {string} params.content - Full new content to write (replaces file)
+ * @param {string} [params.entryText] - Key text of the new entry (for dedup)
+ * @param {string} params.caller - Calling module name (for logging)
+ * @param {boolean} [params.skipDedup=false] - Skip dedup check (for bulk rewrites)
+ * @param {boolean} [params.syncRules=false] - Trigger rules sync after write
+ * @returns {Promise<{ success: boolean, reason?: string }>}
+ */
+async function writeToDecisions({ content, entryText, caller, skipDedup = false, syncRules = false }) {
+  const filePath = PATHS.decisions;
+
+  const release = await acquireLock(filePath, { retries: 5, retryDelay: 100 });
+  try {
+    // Dedup check
+    if (!skipDedup && entryText) {
+      const currentContent = fileExists(filePath) ? readFile(filePath, '') : '';
+      const dupCheck = checkDuplicate(currentContent, entryText);
+      if (dupCheck.isDuplicate) {
+        if (process.env.DEBUG) {
+          console.log(`[orchestrator] Dedup rejected write from ${caller}: "${entryText}" matches "${dupCheck.matchedText}" (${(dupCheck.similarity * 100).toFixed(0)}%)`);
+        }
+        return { success: false, reason: 'duplicate', matchedText: dupCheck.matchedText, similarity: dupCheck.similarity };
+      }
+    }
+
+    writeFile(filePath, content);
+    if (process.env.DEBUG) {
+      console.log(`[orchestrator] ${caller} wrote to decisions.md`);
+    }
+
+    // Optionally sync rules after write
+    if (syncRules) {
+      try {
+        require('./flow-rules-sync');
+      } catch (_err) {
+        // Non-fatal — rules sync is optional
+      }
+    }
+
+    return { success: true };
+  } catch (err) {
+    return { success: false, reason: err.message };
+  } finally {
+    release();
+  }
+}
+
+/**
+ * Read-modify-write helper for feedback-patterns.md.
+ * Acquires lock, reads current content, calls modifier, writes result.
+ *
+ * @param {Function} modifier - (currentContent: string) => { content: string, entryText?: string }
+ * @param {Object} opts - { caller: string, skipDedup?: boolean }
+ * @returns {Promise<{ success: boolean, reason?: string }>}
+ */
+async function modifyFeedbackPatterns(modifier, { caller, skipDedup = false } = {}) {
+  const filePath = PATHS.feedbackPatterns;
+
+  const release = await acquireLock(filePath, { retries: 5, retryDelay: 100 });
+  try {
+    const currentContent = fileExists(filePath) ? readFile(filePath, '') : '';
+    const result = modifier(currentContent);
+
+    if (!result || !result.content) {
+      return { success: false, reason: 'modifier returned no content' };
+    }
+
+    // Dedup check
+    if (!skipDedup && result.entryText) {
+      const dupCheck = checkDuplicate(currentContent, result.entryText);
+      if (dupCheck.isDuplicate) {
+        if (process.env.DEBUG) {
+          console.log(`[orchestrator] Dedup rejected modify from ${caller}: "${result.entryText}" matches "${dupCheck.matchedText}"`);
+        }
+        return { success: false, reason: 'duplicate', matchedText: dupCheck.matchedText };
+      }
+    }
+
+    writeFile(filePath, result.content);
+    return { success: true };
+  } catch (err) {
+    return { success: false, reason: err.message };
+  } finally {
+    release();
+  }
+}
+
+/**
+ * Read-modify-write helper for decisions.md.
+ * Acquires lock, reads current content, calls modifier, writes result.
+ *
+ * @param {Function} modifier - (currentContent: string) => { content: string, entryText?: string }
+ * @param {Object} opts - { caller: string, skipDedup?: boolean, syncRules?: boolean }
+ * @returns {Promise<{ success: boolean, reason?: string }>}
+ */
+async function modifyDecisions(modifier, { caller, skipDedup = false, syncRules = false } = {}) {
+  const filePath = PATHS.decisions;
+
+  const release = await acquireLock(filePath, { retries: 5, retryDelay: 100 });
+  try {
+    const currentContent = fileExists(filePath) ? readFile(filePath, '') : '';
+    const result = modifier(currentContent);
+
+    if (!result || !result.content) {
+      return { success: false, reason: 'modifier returned no content' };
+    }
+
+    // Dedup check
+    if (!skipDedup && result.entryText) {
+      const dupCheck = checkDuplicate(currentContent, result.entryText);
+      if (dupCheck.isDuplicate) {
+        if (process.env.DEBUG) {
+          console.log(`[orchestrator] Dedup rejected modify from ${caller}: "${result.entryText}" matches "${dupCheck.matchedText}"`);
+        }
+        return { success: false, reason: 'duplicate', matchedText: dupCheck.matchedText };
+      }
+    }
+
+    writeFile(filePath, result.content);
+
+    if (syncRules) {
+      try {
+        require('./flow-rules-sync');
+      } catch (_err) {
+        // Non-fatal
+      }
+    }
+
+    return { success: true };
+  } catch (err) {
+    return { success: false, reason: err.message };
+  } finally {
+    release();
+  }
+}
+
 // ============================================================
 // Unified API
 // ============================================================
@@ -114,10 +408,10 @@ async function learn(type, context = {}) {
 function getStats() {
   const stats = {};
 
-  try { stats.tiered = getTieredLearning().getLearningStats(); } catch (err) { stats.tiered = null; }
-  try { stats.failure = getFailureLearning().getLearningStats(); } catch (err) { stats.failure = null; }
-  try { stats.loop = getLoopRetryLearning().getLearningStats(); } catch (err) { stats.loop = null; }
-  try { stats.auto = getAutoLearn().showStatus(); } catch (err) { stats.auto = null; }
+  try { stats.tiered = getTieredLearning().getLearningStats(); } catch (_err) { stats.tiered = null; }
+  try { stats.failure = getFailureLearning().getLearningStats(); } catch (_err) { stats.failure = null; }
+  try { stats.loop = getLoopRetryLearning().getLearningStats(); } catch (_err) { stats.loop = null; }
+  try { stats.auto = getAutoLearn().showStatus(); } catch (_err) { stats.auto = null; }
 
   return stats;
 }
@@ -134,19 +428,19 @@ function loadRelevantPatterns(context = {}) {
 
   try {
     patterns.decisions = getPatternEnforcer().loadDecisionPatterns();
-  } catch (err) {
+  } catch (_err) {
     patterns.decisions = [];
   }
 
   try {
     patterns.skills = getPatternEnforcer().loadSkillPatterns(context.skills || []);
-  } catch (err) {
+  } catch (_err) {
     patterns.skills = [];
   }
 
   try {
     patterns.tiered = getTieredLearning().getPatternsByTier(context.tier || 'all');
-  } catch (err) {
+  } catch (_err) {
     patterns.tiered = [];
   }
 
@@ -158,7 +452,18 @@ function loadRelevantPatterns(context = {}) {
 // ============================================================
 
 module.exports = {
-  // Unified API
+  // Centralized write API (MUST be used for all learning file writes)
+  writeToFeedbackPatterns,
+  writeToDecisions,
+  modifyFeedbackPatterns,
+  modifyDecisions,
+
+  // Dedup utilities (exposed for testing)
+  checkDuplicate,
+  bigramSimilarity,
+  normalizeForDedup,
+
+  // Unified learning API
   learn,
   getStats,
   loadRelevantPatterns,

package/scripts/flow-links.js

@@ -25,14 +25,12 @@ const path = require('node:path');
 const https = require('node:https');
 const http = require('node:http');
 const dns = require('dns');
-const { getProjectRoot, colors: c, readJson } = require('./flow-utils');
+const { getProjectRoot, colors: c, readJson, PATHS } = require('./flow-utils');
 const { success: printSuccess } = require('./flow-output');
 
-const PROJECT_ROOT = getProjectRoot();
-const WORKFLOW_DIR = path.join(PROJECT_ROOT, '.workflow');
-const LINKS_PATH = path.join(WORKFLOW_DIR, 'links.yaml');
-const LINKS_JSON_PATH = path.join(WORKFLOW_DIR, 'links.json');
-const CACHE_DIR = path.join(WORKFLOW_DIR, 'cache', 'links');
+const LINKS_PATH = path.join(PATHS.workflow, 'links.yaml');
+const LINKS_JSON_PATH = path.join(PATHS.workflow, 'links.json');
+const CACHE_DIR = path.join(PATHS.workflow, 'cache', 'links');
 
 /**
  * Link types
@@ -357,7 +355,7 @@ async function fetchLink(name, links = null) {
       const filePath = url.startsWith('file://') ? url.slice(7) : url;
       const absPath = path.isAbsolute(filePath)
         ? filePath
-        : path.join(PROJECT_ROOT, filePath);
+        : path.join(PATHS.root, filePath);
 
       if (fs.existsSync(absPath)) {
         content = fs.readFileSync(absPath, 'utf-8');