wogiflow 2.1.3 → 2.3.0

package/scripts/flow-api-index.js

@@ -45,6 +45,13 @@ const DEFAULT_CONFIG = {
     'src/mutations'
   ],
 
+  // Glob patterns discover co-located API files (any project structure)
+  globPatterns: [
+    'src/**/queries',
+    'src/**/mutations',
+    'src/**/api'
+  ],
+
   filePatterns: ['**/*.ts', '**/*.js', '**/*.tsx', '**/*.jsx'],
 
   excludePatterns: [
@@ -75,6 +82,7 @@ class APIScanner extends BaseScanner {
     super({
       configKey: 'apiRegistry',
       directories: DEFAULT_CONFIG.directories,
+      globPatterns: DEFAULT_CONFIG.globPatterns,
       filePatterns: DEFAULT_CONFIG.filePatterns,
       excludePatterns: DEFAULT_CONFIG.excludePatterns,
       ...config
@@ -131,36 +139,27 @@ class APIScanner extends BaseScanner {
   }
 
   /**
-   * Parse file with Babel AST
+   * Parse file with Babel AST using shared two-pass approach from BaseScanner.
+   * Handles every JS/TS export pattern by design.
    */
   parseWithBabel(content, filePath, service) {
-    try {
-      const ast = this.parser.parse(content, {
-        sourceType: 'module',
-        plugins: ['typescript', 'jsx', 'decorators-legacy']
-      });
-
-      this.traverse(ast, {
-        ExportNamedDeclaration: (nodePath) => {
-          const declaration = nodePath.node.declaration;
-          if (!declaration) return;
-
-          if (declaration.type === 'FunctionDeclaration' && declaration.id) {
-            this.extractAPIFunction(declaration, filePath, service, content);
-          } else if (declaration.type === 'VariableDeclaration') {
-            for (const decl of declaration.declarations) {
-              if (decl.init &&
-                  (decl.init.type === 'ArrowFunctionExpression' ||
-                   decl.init.type === 'FunctionExpression')) {
-                this.extractAPIFunctionFromVariable(decl, filePath, service, content);
-              }
-            }
-          }
-        }
-      });
-    } catch (err) {
-      // Fall back to regex if babel fails
+    const result = this.collectExportedDeclarations(content);
+    if (!result) {
       this.parseWithRegex(content, filePath, service);
+      return;
+    }
+
+    const { declarations, exported } = result;
+
+    for (const [name, _exportInfo] of exported) {
+      const declInfo = declarations.get(name);
+      if (!declInfo) continue;
+
+      if (declInfo.kind === 'func') {
+        this.extractAPIFunction(declInfo.node, filePath, service, content);
+      } else {
+        this.extractAPIFunctionFromVariable(declInfo.node, filePath, service, content);
+      }
     }
   }
 
@@ -181,7 +180,7 @@ class APIScanner extends BaseScanner {
       name,
       params,
       method: isAPIFunction.method || this.inferMethodFromName(name),
-      endpoint: isAPIFunction.endpoint,
+      endpoint: isAPIFunction.endpoint || 'dynamic',
       description: jsdoc.description || '',
       file: filePath,
       service,
@@ -210,7 +209,7 @@ class APIScanner extends BaseScanner {
       name,
       params,
       method: isAPIFunction.method || this.inferMethodFromName(name),
-      endpoint: isAPIFunction.endpoint,
+      endpoint: isAPIFunction.endpoint || 'dynamic',
       description: jsdoc.description || '',
       file: filePath,
       service,
@@ -228,13 +227,15 @@ class APIScanner extends BaseScanner {
       /^(post|create|add|save|submit)/i,
       /^(put|update|modify|patch)/i,
       /^(delete|remove|destroy)/i,
+      /^use(Get|Fetch|Load|Create|Update|Delete|Post|Put|Patch|Remove|Query|Mutation)/,
       /(api|endpoint|request|mutation|query)$/i
     ];
 
     const nameMatches = apiNamePatterns.some(p => p.test(name));
 
-    // Check function body for HTTP calls
-    const funcBody = content.substring(startPos, endPos);
+    // Check function body for HTTP calls — use full body including nested scopes
+    // Find the matching closing brace to capture nested arrow functions
+    const funcBody = this._extractFullBody(content, startPos, endPos);
     const httpPatterns = [
       /fetch\s*\(/,
       /axios\./,
@@ -247,7 +248,9 @@ class APIScanner extends BaseScanner {
       /apiClient/i,
       /useSWR/,
       /useQuery/,
-      /useMutation/
+      /useMutation/,
+      /useInfiniteQuery/,
+      /useSuspenseQuery/
     ];
 
     const bodyMatches = httpPatterns.some(p => p.test(funcBody));
@@ -280,6 +283,68 @@ class APIScanner extends BaseScanner {
     };
   }
 
+  /**
+   * Extract the full function body content, including nested scopes.
+   * Falls back to substring if brace matching fails.
+   * @param {string} content - Full file content
+   * @param {number} startPos - Start position of the function
+   * @param {number} endPos - End position from AST (may be too narrow)
+   * @returns {string} Function body content
+   */
+  _extractFullBody(content, startPos, endPos) {
+    const MAX_SCAN = 50000; // Cap at 50KB to avoid stalls on large files
+    const braceStart = content.indexOf('{', startPos);
+    if (braceStart === -1 || braceStart > endPos + 100) {
+      return content.substring(startPos, Math.min(endPos + 500, content.length));
+    }
+
+    // Match braces with string/comment awareness
+    let depth = 0;
+    let i = braceStart;
+    const limit = Math.min(content.length, braceStart + MAX_SCAN);
+    while (i < limit) {
+      const ch = content[i];
+
+      // Skip single-line comments
+      if (ch === '/' && content[i + 1] === '/') {
+        i = content.indexOf('\n', i + 2);
+        if (i === -1) break;
+        i++;
+        continue;
+      }
+      // Skip multi-line comments
+      if (ch === '/' && content[i + 1] === '*') {
+        i = content.indexOf('*/', i + 2);
+        if (i === -1) break;
+        i += 2;
+        continue;
+      }
+      // Skip string literals
+      if (ch === "'" || ch === '"' || ch === '`') {
+        i++;
+        while (i < limit) {
+          if (content[i] === '\\') { i += 2; continue; }
+          if (content[i] === ch) break;
+          i++;
+        }
+        i++;
+        continue;
+      }
+
+      if (ch === '{') depth++;
+      else if (ch === '}') {
+        depth--;
+        if (depth === 0) {
+          return content.substring(startPos, i + 1);
+        }
+      }
+      i++;
+    }
+
+    // Fallback to AST bounds with buffer
+    return content.substring(startPos, Math.min(endPos + 200, content.length));
+  }
+
   /**
    * Infer HTTP method from function name
    */
@@ -294,56 +359,55 @@ class APIScanner extends BaseScanner {
   }
 
   /**
-   * Parse with regex (fallback)
+   * Parse with regex (fallback, two-pass approach)
    */
   parseWithRegex(content, filePath, service) {
-    // Match exported async functions
-    const funcRegex = /export\s+(async\s+)?function\s+(\w+)\s*\(([^)]*)\)/g;
+    // Two-pass regex: find declarations, find exports, intersect
     let match;
 
-    while ((match = funcRegex.exec(content)) !== null) {
-      const [fullMatch, isAsync, name, paramsStr] = match;
+    // Pass 1: Find all function-like declarations
+    const declarations = new Map(); // name -> { line, paramsStr }
 
-      // Check if it looks like an API function
-      if (!this.isLikelyAPIFunctionFromName(name) && !this.hasHTTPCall(content, match.index)) {
-        continue;
-      }
-
-      const jsdoc = this.extractJSDocBefore(content, match.index);
-
-      this.addClientFunction({
-        name,
-        params: this.parseParamsFromString(paramsStr),
-        method: this.inferMethodFromName(name),
-        endpoint: null,
-        description: jsdoc,
-        file: filePath,
-        service,
-        line: this.getLineNumber(content, match.index)
+    const funcRegex = /(?:export\s+(?:default\s+)?)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/g;
+    while ((match = funcRegex.exec(content)) !== null) {
+      declarations.set(match[1], {
+        line: this.getLineNumber(content, match.index),
+        paramsStr: match[2],
+        pos: match.index
       });
     }
 
-    // Match exported const arrow functions
-    const arrowRegex = /export\s+const\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*(?::\s*[^=]+)?\s*=>/g;
-
+    const arrowRegex = /(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*(?::\s*[^=]+)?\s*=>/g;
     while ((match = arrowRegex.exec(content)) !== null) {
-      const [fullMatch, name] = match;
+      if (!declarations.has(match[1])) {
+        declarations.set(match[1], {
+          line: this.getLineNumber(content, match.index),
+          paramsStr: '',
+          pos: match.index
+        });
+      }
+    }
+
+    // Pass 2: Use shared export-collection from BaseScanner
+    const exported = this.collectExportedNamesRegex(content);
 
-      if (!this.isLikelyAPIFunctionFromName(name) && !this.hasHTTPCall(content, match.index)) {
+    // Intersect: register exported declarations that look like API functions
+    for (const [name, info] of declarations) {
+      if (!exported.has(name)) continue;
+      if (!this.isLikelyAPIFunctionFromName(name) && !this.hasHTTPCall(content, info.pos)) {
         continue;
       }
 
-      const jsdoc = this.extractJSDocBefore(content, match.index);
-
+      const jsdoc = this.extractJSDocBefore(content, info.pos);
       this.addClientFunction({
         name,
-        params: [],
+        params: info.paramsStr ? this.parseParamsFromString(info.paramsStr) : [],
         method: this.inferMethodFromName(name),
-        endpoint: null,
+        endpoint: 'dynamic',
         description: jsdoc,
         file: filePath,
         service,
-        line: this.getLineNumber(content, match.index)
+        line: info.line
       });
     }
   }
@@ -353,6 +417,7 @@ class APIScanner extends BaseScanner {
    */
   isLikelyAPIFunctionFromName(name) {
     return /^(get|fetch|load|post|create|put|update|patch|delete|remove|query|mutation)/i.test(name) ||
+           /^use(Get|Fetch|Load|Create|Update|Delete|Post|Put|Patch|Remove|Query|Mutation)/i.test(name) ||
            /(api|endpoint|request)$/i.test(name);
   }
 

package/scripts/flow-audit.js

@@ -254,6 +254,134 @@ function calculateHealthScore(scores) {
   };
 }
 
+// ============================================================
+// Pattern Promotion (Audit → Learning Pipeline)
+// ============================================================
+
+// Severity classification thresholds for audit patterns
+const SYSTEMIC_THRESHOLD = 5;   // 5+ files = HIGH severity / systemic
+const MEDIUM_THRESHOLD = 3;     // 3-4 files = MEDIUM severity
+
+/**
+ * Process AI-clustered audit findings through the learning pipeline.
+ *
+ * For each clustered pattern:
+ * 1. Check if a rule already exists in decisions.md → ENFORCEMENT_GAP
+ * 2. Record/increment in feedback-patterns.md
+ * 3. Check promotion threshold → auto-promote if met
+ * 4. Check last-audit.json → detect RECURRING patterns
+ *
+ * @param {Object[]} clusters - AI-clustered patterns from audit
+ * @param {Object} [previousAudit] - Previous audit data for recurrence detection
+ * @returns {Object} Promotion results per pattern
+ */
+function promoteAuditPatterns(clusters, previousAudit) {
+  const {
+    recordAuditPattern,
+    checkEnforcementGap,
+    promoteToDecisions,
+    syncToRulesDir,
+    mapAuditCategoryToLearnerCategory,
+    buildAuditRuleTemplate
+  } = require('./flow-standards-learner');
+
+  const previousPatternIds = new Set(
+    (previousAudit?.patterns || []).map(p => p.patternId)
+  );
+
+  const results = {
+    patterns: [],
+    summary: {
+      total: clusters.length,
+      promoted: 0,
+      promotionFailed: 0,
+      tracking: 0,
+      enforcementGaps: 0,
+      newPatterns: 0,
+      recurring: 0
+    }
+  };
+
+  for (const cluster of clusters) {
+    const patternResult = {
+      patternId: cluster.patternId,
+      category: cluster.category,
+      description: cluster.description,
+      instanceCount: cluster.instanceCount,
+      severity: cluster.severity || (cluster.instanceCount >= SYSTEMIC_THRESHOLD ? 'HIGH' : cluster.instanceCount >= MEDIUM_THRESHOLD ? 'MEDIUM' : 'LOW'),
+      isSystemic: cluster.isSystemic || cluster.instanceCount >= SYSTEMIC_THRESHOLD,
+      status: 'NEW',
+      count: 0,
+      rootCause: null,
+      recommendation: null
+    };
+
+    // Step 1: Check for enforcement gap
+    const gapCheck = checkEnforcementGap(cluster.patternId, cluster.description);
+    if (gapCheck.exists) {
+      patternResult.status = 'ENFORCEMENT_GAP';
+      patternResult.ruleLocation = gapCheck.section;
+      patternResult.ruleText = gapCheck.ruleText;
+      results.summary.enforcementGaps++;
+    } else {
+      // Step 2: Record/increment in feedback-patterns
+      const recordResult = recordAuditPattern(cluster);
+
+      if (recordResult.recorded) {
+        patternResult.count = recordResult.newCount;
+
+        // Step 3: Check promotion threshold
+        if (recordResult.shouldPromote) {
+          // Build a learning object for promotion (reuse learner functions)
+          const learning = {
+            canLearn: true,
+            violationType: cluster.category,
+            category: mapAuditCategoryToLearnerCategory(cluster.category),
+            patternName: cluster.description.slice(0, 100),
+            message: `${cluster.instanceCount} instances found (audit source, ${recordResult.newCount} occurrences)`,
+            ruleTemplate: buildAuditRuleTemplate(cluster)
+          };
+
+          const promoteResult = promoteToDecisions(learning, recordResult.newCount);
+          if (promoteResult.promoted) {
+            patternResult.status = 'PROMOTED';
+            results.summary.promoted++;
+
+            // Also sync to rules dir
+            const syncLearning = {
+              ...learning,
+              subcategory: cluster.patternId
+            };
+            syncToRulesDir(syncLearning);
+          } else {
+            // Distinguish "not yet at threshold" from "promotion failed"
+            patternResult.status = 'PROMOTION_FAILED';
+            patternResult.failureReason = promoteResult.reason || 'Unknown promotion failure';
+            results.summary.promotionFailed++;
+          }
+        } else {
+          patternResult.status = `TRACKING (${recordResult.newCount}/${recordResult.threshold})`;
+          results.summary.tracking++;
+        }
+      }
+    }
+
+    // Step 4: Check recurrence
+    if (previousPatternIds.has(cluster.patternId)) {
+      if (patternResult.status !== 'ENFORCEMENT_GAP' && patternResult.status !== 'PROMOTED') {
+        patternResult.status = `RECURRING — ${patternResult.status}`;
+      }
+      results.summary.recurring++;
+    } else if (patternResult.status === 'NEW' || patternResult.status.startsWith('TRACKING')) {
+      results.summary.newPatterns++;
+    }
+
+    results.patterns.push(patternResult);
+  }
+
+  return results;
+}
+
 // ============================================================
 // CLI Interface
 // ============================================================
@@ -307,6 +435,30 @@ function main() {
       break;
     }
 
+    case 'promote': {
+      // Process AI-clustered findings through the learning pipeline
+      // Usage: node scripts/flow-audit.js promote '<clusters-json>'
+      const clustersArg = process.argv[3];
+      if (!clustersArg) {
+        console.error('Usage: flow-audit.js promote \'[{patternId, category, description, instanceCount, instances}]\'');
+        process.exit(1);
+      }
+
+      const clusters = safeJsonParseString(clustersArg, null);
+      if (!Array.isArray(clusters)) {
+        console.error('Invalid JSON clusters argument — expected an array');
+        process.exit(1);
+      }
+
+      // Load previous audit for recurrence detection
+      const lastAuditPath = path.join(PATHS.state, 'last-audit.json');
+      const previousAudit = safeJsonParse(lastAuditPath, {});
+
+      const promoteResults = promoteAuditPatterns(clusters, previousAudit);
+      console.log(JSON.stringify(promoteResults, null, 2));
+      break;
+    }
+
     default: {
       console.log(`
 Wogi Flow - Project Audit Helpers
@@ -319,9 +471,13 @@ Commands:
   outdated   Run npm outdated (structured JSON output)
   audit      Run npm audit (structured JSON output)
   score      Calculate weighted health score from agent grades
+  promote    Process AI-clustered findings through learning pipeline
 
 Score usage:
   node scripts/flow-audit.js score '{"architecture":"B+","dependencies":"A-"}'
+
+Promote usage:
+  node scripts/flow-audit.js promote '[{"patternId":"missing-error-handling","category":"security","description":"...","instanceCount":7}]'
 `);
       break;
     }
@@ -333,7 +489,8 @@ module.exports = {
   findTodos,
   getOutdatedDeps,
   getAuditResults,
-  calculateHealthScore
+  calculateHealthScore,
+  promoteAuditPatterns
 };
 
 if (require.main === module) {

package/scripts/flow-function-index.js

@@ -38,6 +38,7 @@ const DEFAULT_CONFIG = {
     'src/utils',
     'src/lib',
     'src/helpers',
+    'src/services',
     'utils',
     'lib',
     'helpers',
@@ -45,6 +46,13 @@ const DEFAULT_CONFIG = {
     'shared'
   ],
 
+  // Glob patterns discover co-located directories (any project structure)
+  globPatterns: [
+    'src/**/hooks',
+    'src/**/helpers',
+    'src/**/utils'
+  ],
+
   filePatterns: ['**/*.ts', '**/*.js', '**/*.tsx', '**/*.jsx'],
 
   excludePatterns: [
@@ -70,6 +78,7 @@ class FunctionScanner extends BaseScanner {
     super({
       configKey: 'functionRegistry',
       directories: DEFAULT_CONFIG.directories,
+      globPatterns: DEFAULT_CONFIG.globPatterns,
       filePatterns: DEFAULT_CONFIG.filePatterns,
       excludePatterns: DEFAULT_CONFIG.excludePatterns,
       ...config
@@ -113,42 +122,27 @@ class FunctionScanner extends BaseScanner {
   }
 
   /**
-   * Parse file with Babel AST
+   * Parse file with Babel AST using shared two-pass approach from BaseScanner.
+   * Handles every JS/TS export pattern by design — no whack-a-mole.
    */
   parseWithBabel(content, filePath, category) {
-    try {
-      const ast = this.parser.parse(content, {
-        sourceType: 'module',
-        plugins: ['typescript', 'jsx', 'decorators-legacy']
-      });
-
-      this.traverse(ast, {
-        ExportNamedDeclaration: (nodePath) => {
-          const declaration = nodePath.node.declaration;
-          if (!declaration) return;
-
-          if (declaration.type === 'FunctionDeclaration' && declaration.id) {
-            this.extractFunction(declaration, filePath, category, content);
-          } else if (declaration.type === 'VariableDeclaration') {
-            for (const decl of declaration.declarations) {
-              if (decl.init &&
-                  (decl.init.type === 'ArrowFunctionExpression' ||
-                   decl.init.type === 'FunctionExpression')) {
-                this.extractFunctionFromVariable(decl, filePath, category, content);
-              }
-            }
-          }
-        },
-        ExportDefaultDeclaration: (nodePath) => {
-          const declaration = nodePath.node.declaration;
-          if (declaration.type === 'FunctionDeclaration' && declaration.id) {
-            this.extractFunction(declaration, filePath, category, content, true);
-          }
-        }
-      });
-    } catch (err) {
-      // Fall back to regex if babel fails
+    const result = this.collectExportedDeclarations(content);
+    if (!result) {
       this.parseWithRegex(content, filePath, category);
+      return;
+    }
+
+    const { declarations, exported } = result;
+
+    for (const [name, exportInfo] of exported) {
+      const declInfo = declarations.get(name);
+      if (!declInfo) continue;
+
+      if (declInfo.kind === 'func') {
+        this.extractFunction(declInfo.node, filePath, category, content, exportInfo.isDefault);
+      } else {
+        this.extractFunctionFromVariable(declInfo.node, filePath, category, content);
+      }
     }
   }
 
@@ -223,44 +217,52 @@ class FunctionScanner extends BaseScanner {
    * Parse file with regex (fallback)
    */
   parseWithRegex(content, filePath, category) {
-    // Match exported function declarations
-    const functionRegex = /export\s+(async\s+)?function\s+(\w+)\s*(<[^>]*>)?\s*\(([^)]*)\)(?:\s*:\s*([^\s{]+))?\s*\{/g;
+    // Pass 1: Find all function-like declarations
+    const declarations = new Map();
     let match;
 
+    const functionRegex = /(?:export\s+(?:default\s+)?)?(?:(async)\s+)?function\s+(\w+)\s*(?:<[^>]*>)?\s*\(([^)]*)\)(?:\s*:\s*([^\s{]+))?\s*\{/g;
     while ((match = functionRegex.exec(content)) !== null) {
-      const [, isAsync, name, generics, paramsStr, returnType] = match;
-      const params = this.parseParamsFromString(paramsStr);
-      const jsdoc = this.extractJSDocBefore(content, match.index);
-
-      this.addFunction({
-        name,
-        params,
+      const [, isAsync, name, paramsStr, returnType] = match;
+      declarations.set(name, {
+        line: this.getLineNumber(content, match.index),
+        params: this.parseParamsFromString(paramsStr),
         returnType: returnType || (isAsync ? 'Promise<any>' : null),
-        description: jsdoc,
-        file: filePath,
-        category,
-        isDefault: false,
-        line: this.getLineNumber(content, match.index)
+        jsdoc: this.extractJSDocBefore(content, match.index)
       });
     }
 
-    // Match exported const arrow functions
-    const arrowRegex = /export\s+const\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s*)?\([^)]*\)\s*(?::\s*([^\s=>]+))?\s*=>/g;
-
+    // Const arrow functions — capture params group (finding-005 fix)
+    const arrowRegex = /(?:export\s+)?const\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s*)?\(([^)]*)\)\s*(?::\s*([^\s=>]+))?\s*=>/g;
     while ((match = arrowRegex.exec(content)) !== null) {
-      const [, name, returnType] = match;
-      const jsdoc = this.extractJSDocBefore(content, match.index);
-
-      this.addFunction({
-        name,
-        params: [],
-        returnType,
-        description: jsdoc,
-        file: filePath,
-        category,
-        isDefault: false,
-        line: this.getLineNumber(content, match.index)
-      });
+      const [, name, paramsStr, returnType] = match;
+      if (!declarations.has(name)) {
+        declarations.set(name, {
+          line: this.getLineNumber(content, match.index),
+          params: paramsStr ? this.parseParamsFromString(paramsStr) : [],
+          returnType,
+          jsdoc: this.extractJSDocBefore(content, match.index)
+        });
+      }
+    }
+
+    // Pass 2: Use shared export-collection from BaseScanner
+    const exported = this.collectExportedNamesRegex(content);
+
+    // Intersect: register all exported declarations
+    for (const [name, info] of declarations) {
+      if (exported.has(name)) {
+        this.addFunction({
+          name,
+          params: info.params,
+          returnType: info.returnType,
+          description: info.jsdoc,
+          file: filePath,
+          category,
+          isDefault: false,
+          line: info.line
+        });
+      }
     }
   }
 

package/scripts/flow-pattern-extractor.js

@@ -92,7 +92,7 @@ const IGNORE_PATTERNS = [
 ];
 
 // Colors for CLI output
-const { colors: c } = require('./flow-output');
+const { colors: c, getTodayDate } = require('./flow-output');
 
 // ============================================================================
 // Utility Functions