wogiflow 2.2.0 → 2.3.0

package/.claude/commands/wogi-onboard.md

@@ -530,14 +530,36 @@ Display:
 
     Display: `  Data-fetching hooks... ✓ react-query, 80 useGet* hooks`
 
-15. **Populate app-map.md from component data:**
-    From the pattern extraction result, populate app-map.md with:
-    - Detected UI components -> Components table
-    - Detected pages/screens -> Screens table
-    - Detected modals -> Modals table
-    Include paths and patterns where detected.
-
-    Display: `  app-map.md...         ✓ Found 24 components/modules`
+15. **Run registry-manager scan (comprehensive registry population):**
+
+    **CRITICAL**: This step replaces manual AI-driven app-map population. The registry
+    manager runs ALL active scanners (components, functions, APIs, schemas, services)
+    with recursive directory traversal and glob-based discovery. This ensures no
+    subdirectory components, co-located hooks, or separated-export API functions are missed.
+
+    ```javascript
+    // Run the full registry scan — this handles recursion, glob patterns, and all export patterns
+    const { execSync } = require('child_process');
+    try {
+      execSync('node node_modules/wogiflow/scripts/flow-registry-manager.js scan', {
+        cwd: projectRoot,
+        stdio: 'inherit',
+        timeout: 60000
+      });
+    } catch (err) {
+      console.warn('Registry manager scan failed, falling back to individual scanners:', err.message);
+      // Individual scanners from steps 13-14 already ran as fallback
+    }
+    ```
+
+    The component scanner generates `app-map.md` from scan results (grouped by category/directory).
+    The function scanner discovers co-located hooks via glob patterns (`src/**/hooks`, etc.).
+    The API scanner handles all export patterns including separated `const + export default`.
+
+    Display: `  Registry scan...      ✓ All registries populated (components, functions, APIs)`
+
+    **NOTE**: If the registry manager scan succeeds, it supersedes the individual scanner runs
+    from steps 13-14. The scanners are idempotent — running them twice just refreshes the same data.
 
 16. **Extract file templates:**
     ```javascript

package/.workflow/models/registry.json

@@ -100,7 +100,7 @@
       "displayName": "Claude Sonnet 4.6",
       "contextWindow": 200000,
       "contextWindowBeta": 1000000,
-      "maxOutputTokens": 128000,
+      "maxOutputTokens": 64000,
       "costTier": "standard",
       "pricing": {
         "inputPer1kTokens": 0.003,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "AI-powered development workflow management system with multi-model support",
   "main": "lib/index.js",
   "bin": {

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-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