wogiflow 2.2.0 → 2.3.1

package/scripts/flow-scanner-base.js

@@ -36,6 +36,7 @@ class BaseScanner {
 
     this.config = {
       directories: registryConfig.directories || options.directories || [],
+      globPatterns: registryConfig.globPatterns || options.globPatterns || [],
       filePatterns: options.filePatterns || ['**/*.ts', '**/*.js', '**/*.tsx', '**/*.jsx'],
       excludePatterns: options.excludePatterns || [
         '**/*.test.*',
@@ -50,11 +51,13 @@ class BaseScanner {
     };
 
     // Pre-compile exclude patterns to avoid per-file RegExp allocation
+    // Use placeholder to prevent ** and * from interfering during replacement
     this._excludeRegexps = this.config.excludePatterns.map(pattern => {
       const regexPattern = pattern
-        .replace(/\*\*/g, '.*')
-        .replace(/\*/g, '[^/]*')
-        .replace(/\./g, '\\.');
+        .replace(/\*\*/g, '\0GLOBSTAR\0')   // Placeholder for **
+        .replace(/\./g, '\\.')              // Escape dots
+        .replace(/\*/g, '[^/]*')            // Single * → non-slash wildcard
+        .replace(/\0GLOBSTAR\0/g, '.*');    // Restore ** → any path
       return new RegExp('^' + regexPattern + '$');
     });
 
@@ -70,18 +73,96 @@ class BaseScanner {
   }
 
   /**
-   * Find existing directories from config
+   * Find existing directories from config (explicit + glob-discovered)
    * @returns {string[]} Array of full paths to existing directories
    */
   findDirectories() {
-    const found = [];
+    const found = new Set();
+
+    // 1. Explicit directories from config
     for (const dir of this.config.directories) {
       const fullPath = path.join(PROJECT_ROOT, dir);
       if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
-        found.push(fullPath);
+        found.add(fullPath);
+      }
+    }
+
+    // 2. Glob-discovered directories (e.g. "src/**/hooks", "src/**/utils")
+    for (const pattern of this.config.globPatterns) {
+      for (const dir of this._expandGlobPattern(pattern)) {
+        found.add(dir);
       }
     }
-    return found;
+
+    return [...found];
+  }
+
+  /**
+   * Expand a glob pattern like "src/** /hooks" into matching directories.
+   * Supports ** (any depth) and * (single segment). No external dependencies.
+   * @param {string} pattern - Glob pattern relative to project root
+   * @returns {string[]} Array of full paths to matching directories
+   */
+  _expandGlobPattern(pattern) {
+    const results = [];
+    const segments = pattern.split('/');
+    const MAX_DEPTH = 20;
+    const MAX_DIRS = 5000;
+    let dirsVisited = 0;
+    const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.cache', '.yarn', '.pnpm']);
+
+    const walk = (currentPath, segIdx, depth) => {
+      if (depth > MAX_DEPTH || dirsVisited > MAX_DIRS) return;
+      dirsVisited++;
+
+      if (segIdx >= segments.length) {
+        if (fs.existsSync(currentPath) && fs.statSync(currentPath).isDirectory()) {
+          results.push(currentPath);
+        }
+        return;
+      }
+
+      const seg = segments[segIdx];
+
+      if (seg === '**') {
+        // Zero levels: skip this segment
+        walk(currentPath, segIdx + 1, depth);
+
+        // One+ levels: recurse into subdirectories
+        if (!fs.existsSync(currentPath) || !fs.statSync(currentPath).isDirectory()) return;
+        try {
+          const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+          for (const entry of entries) {
+            if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
+            if (SKIP_DIRS.has(entry.name) || entry.name.startsWith('.')) continue;
+            walk(path.join(currentPath, entry.name), segIdx, depth + 1);
+          }
+        } catch (_err) {
+          // Permission error — skip
+        }
+      } else if (seg.includes('*')) {
+        if (!fs.existsSync(currentPath) || !fs.statSync(currentPath).isDirectory()) return;
+        // Escape regex metacharacters except *, then convert * to [^/]*
+        const escaped = seg.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '[^/]*');
+        const segRegex = new RegExp('^' + escaped + '$');
+        try {
+          const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+          for (const entry of entries) {
+            if (!entry.isDirectory()) continue;
+            if (segRegex.test(entry.name)) {
+              walk(path.join(currentPath, entry.name), segIdx + 1, depth + 1);
+            }
+          }
+        } catch (_err) {
+          // Permission error — skip
+        }
+      } else {
+        walk(path.join(currentPath, seg), segIdx + 1, depth + 1);
+      }
+    };
+
+    walk(PROJECT_ROOT, 0, 0);
+    return results;
   }
 
   /**
@@ -268,6 +349,118 @@ class BaseScanner {
     });
   }
 
+  /**
+   * Two-pass AST: collect all top-level declarations and all exported names.
+   * Returns { declarations: Map<name, {node, kind}>, exported: Map<name, {isDefault}> }
+   * Subclasses call this then intersect with their own registration logic.
+   * @param {string} content - File content
+   * @returns {Object|null} { declarations, exported } or null if parse fails
+   */
+  collectExportedDeclarations(content) {
+    if (!this.parser) return null;
+
+    try {
+      const ast = this.parser.parse(content, {
+        sourceType: 'module',
+        plugins: ['typescript', 'jsx', 'decorators-legacy']
+      });
+
+      // Pass 1: Collect all top-level function-like declarations
+      const declarations = new Map();
+
+      this.traverse(ast, {
+        FunctionDeclaration: (nodePath) => {
+          const parent = nodePath.parent.type;
+          if (!nodePath.node.id) return;
+          if (parent === 'Program' || parent === 'ExportNamedDeclaration' || parent === 'ExportDefaultDeclaration') {
+            declarations.set(nodePath.node.id.name, { node: nodePath.node, kind: 'func' });
+          }
+        },
+        VariableDeclaration: (nodePath) => {
+          const parent = nodePath.parent.type;
+          if (parent !== 'Program' && parent !== 'ExportNamedDeclaration') return;
+          for (const decl of nodePath.node.declarations) {
+            if (decl.id?.name && decl.init &&
+                (decl.init.type === 'ArrowFunctionExpression' ||
+                 decl.init.type === 'FunctionExpression')) {
+              declarations.set(decl.id.name, { node: decl, kind: 'var' });
+            }
+          }
+        }
+      });
+
+      // Pass 2: Collect all exported names
+      const exported = new Map();
+
+      this.traverse(ast, {
+        ExportNamedDeclaration: (nodePath) => {
+          const decl = nodePath.node.declaration;
+          if (decl) {
+            if (decl.type === 'FunctionDeclaration' && decl.id) {
+              exported.set(decl.id.name, { isDefault: false });
+            } else if (decl.type === 'VariableDeclaration') {
+              for (const d of decl.declarations) {
+                if (d.id?.name) exported.set(d.id.name, { isDefault: false });
+              }
+            }
+          }
+          for (const spec of nodePath.node.specifiers || []) {
+            if (spec.local?.name) {
+              exported.set(spec.local.name, { isDefault: false });
+            }
+          }
+        },
+        ExportDefaultDeclaration: (nodePath) => {
+          const decl = nodePath.node.declaration;
+          if (decl.type === 'FunctionDeclaration' && decl.id) {
+            exported.set(decl.id.name, { isDefault: true });
+          } else if (decl.type === 'Identifier') {
+            exported.set(decl.name, { isDefault: true });
+          }
+        }
+      });
+
+      return { declarations, exported };
+    } catch (_err) {
+      return null;
+    }
+  }
+
+  /**
+   * Two-pass regex: collect all exported names from file content.
+   * Shared across scanners for consistent export detection.
+   * @param {string} content - File content
+   * @returns {Set<string>} Set of exported names
+   */
+  collectExportedNamesRegex(content) {
+    const exported = new Set();
+    let match;
+
+    // export function / export const / export default function
+    const exportedDeclRegex = /export\s+(?:default\s+)?(?:async\s+)?(?:function|const)\s+(\w+)/g;
+    while ((match = exportedDeclRegex.exec(content)) !== null) {
+      exported.add(match[1]);
+    }
+
+    // export default Name (identifier)
+    const exportDefaultIdRegex = /export\s+default\s+([A-Za-z_$]\w*)\s*;/g;
+    while ((match = exportDefaultIdRegex.exec(content)) !== null) {
+      exported.add(match[1]);
+    }
+
+    // export { Name, Name2 as Alias }
+    const exportSpecRegex = /export\s*\{([^}]+)\}/g;
+    while ((match = exportSpecRegex.exec(content)) !== null) {
+      const specifiers = match[1].split(',');
+      for (const spec of specifiers) {
+        const name = spec.trim().split(/\s+as\s+/)[0].trim();
+        if (name) exported.add(name);
+      }
+    }
+
+    return exported;
+  }
+
   /**
    * Parse params from string (regex fallback)
    * @param {string} paramsStr - Parameter string

package/scripts/flow-skill-generator.js

@@ -8,6 +8,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { ensureDir, getConfig, invalidateConfigCache, writeJson, PATHS, success } = require('./flow-utils');
+const { getTodayDate } = require('./flow-output');
 
 // Import helper functions from tech options
 let _techOptions = null;

package/scripts/flow-template-extractor.js

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

package/scripts/registries/component-registry.js

@@ -290,10 +290,147 @@ class ComponentScanner extends BaseScanner {
   }
 
   generateMap() {
-    // Component registry generates component-index.json only.
-    // It does NOT overwrite app-map.md — that remains human-curated.
-    // The index is complementary: auto-generated for machine use.
-    success(`Component index available at ${path.relative(PROJECT_ROOT, INDEX_PATH)}`);
+    const MAP_PATH = path.join(STATE_DIR, 'app-map.md');
+
+    // Check if app-map.md exists and has content
+    let existing = '';
+    try {
+      existing = fs.readFileSync(MAP_PATH, 'utf-8');
+    } catch (_err) {
+      // File doesn't exist — will create
+    }
+
+    // Use marker to distinguish auto-generated from human-curated
+    const AUTO_MARKER = '<!-- AUTO-GENERATED BY COMPONENT SCANNER -->';
+    const isAutoGenerated = existing.includes(AUTO_MARKER);
+    const hasContent = existing.split('\n').filter(l => l.startsWith('|')).length > 5;
+
+    if (hasContent && !isAutoGenerated) {
+      // Human-curated content — merge without overwriting
+      this._mergeIntoAppMap(MAP_PATH, existing);
+      return;
+    }
+
+    // Generate fresh app-map.md from scan results
+    const lines = [
+      '# App Map',
+      '',
+      AUTO_MARKER,
+      '',
+      'Component and page registry. **Check before creating anything new.**',
+      '',
+      '> Auto-generated by component scanner. Edit to add context.',
+      '',
+      '---',
+      ''
+    ];
+
+    // Group components by category
+    const categories = {};
+    for (const comp of this.registry.components) {
+      const cat = comp.category || 'uncategorized';
+      if (!categories[cat]) categories[cat] = [];
+      categories[cat].push(comp);
+    }
+
+    // Components section
+    if (this.registry.components.length > 0) {
+      lines.push('## Components', '');
+
+      for (const cat of Object.keys(categories).sort()) {
+        const catName = cat.charAt(0).toUpperCase() + cat.slice(1);
+        lines.push(`### ${catName}`, '');
+        lines.push('| Component | File | Description |');
+        lines.push('|-----------|------|-------------|');
+
+        for (const comp of categories[cat].sort((a, b) => a.name.localeCompare(b.name))) {
+          const desc = comp.description || '-';
+          lines.push(`| \`${comp.name}\` | \`${comp.file}\` | ${desc} |`);
+        }
+        lines.push('');
+      }
+    }
+
+    // Hooks section
+    if (this.registry.hooks.length > 0) {
+      lines.push('## Hooks', '');
+      lines.push('| Hook | File | Description |');
+      lines.push('|------|------|-------------|');
+
+      for (const hook of this.registry.hooks.sort((a, b) => a.name.localeCompare(b.name))) {
+        const desc = hook.description || '-';
+        lines.push(`| \`${hook.name}\` | \`${hook.file}\` | ${desc} |`);
+      }
+      lines.push('');
+    }
+
+    lines.push('---', '');
+    lines.push('## Rules', '');
+    lines.push('1. **Before creating** → Search this file');
+    lines.push('2. **If similar exists** → Add variant, don\'t create new');
+    lines.push('3. **After creating** → Run `flow registry-manager scan` to update');
+    lines.push('');
+
+    fs.writeFileSync(MAP_PATH, lines.join('\n'));
+    success(`Generated ${path.relative(PROJECT_ROOT, MAP_PATH)} (${this.registry.components.length} components, ${this.registry.hooks.length} hooks)`);
+  }
+
+  /**
+   * Merge scanner results into existing app-map.md without overwriting curated content.
+   * Adds only components not already present.
+   */
+  _mergeIntoAppMap(mapPath, existing) {
+    // Path containment check (defense-in-depth)
+    if (!mapPath.startsWith(STATE_DIR)) {
+      warn('Write target outside state directory — skipping merge');
+      return;
+    }
+
+    // Extract names already in app-map (with or without backticks)
+    const existingNames = new Set();
+    const nameRegex = /\|\s*`?(\w+)`?\s*\|/g;
+    let m;
+    while ((m = nameRegex.exec(existing)) !== null) {
+      existingNames.add(m[1]);
+    }
+
+    // Find new components not in app-map
+    const newComponents = this.registry.components.filter(c => !existingNames.has(c.name));
+    const newHooks = this.registry.hooks.filter(h => !existingNames.has(h.name));
+
+    if (newComponents.length === 0 && newHooks.length === 0) {
+      info(`app-map.md is up to date (${existingNames.size} entries)`);
+      return;
+    }
+
+    // Remove existing "## Auto-Discovered" section if present (prevent duplicates)
+    const autoDiscoveredIdx = existing.indexOf('\n## Auto-Discovered');
+    const base = autoDiscoveredIdx !== -1 ? existing.substring(0, autoDiscoveredIdx) : existing;
+
+    const additions = ['\n## Auto-Discovered (new entries)', ''];
+
+    if (newComponents.length > 0) {
+      additions.push('### Components', '');
+      additions.push('| Component | File | Description |');
+      additions.push('|-----------|------|-------------|');
+      for (const comp of newComponents.sort((a, b) => a.name.localeCompare(b.name))) {
+        additions.push(`| \`${comp.name}\` | \`${comp.file}\` | ${comp.description || '-'} |`);
+      }
+      additions.push('');
+    }
+
+    if (newHooks.length > 0) {
+      additions.push('### Hooks', '');
+      additions.push('| Hook | File | Description |');
+      additions.push('|------|------|-------------|');
+      for (const hook of newHooks.sort((a, b) => a.name.localeCompare(b.name))) {
+        additions.push(`| \`${hook.name}\` | \`${hook.file}\` | ${hook.description || '-'} |`);
+      }
+      additions.push('');
+    }
+
+    fs.writeFileSync(mapPath, base + additions.join('\n'));
+    success(`Merged ${newComponents.length} components + ${newHooks.length} hooks into app-map.md`);
   }
 }
 

package/.claude/rules/_internal/README.md

@@ -1,64 +0,0 @@
----
-alwaysApply: false
-description: "Meta-documentation about how project rules are organized"
----
-# Project Rules
-
-This directory contains coding rules and patterns for this project, organized by category.
-
-## Structure
-
-```
-.claude/rules/
-├── code-style/           # Naming conventions, formatting
-│   └── naming-conventions.md
-├── security/             # Security patterns and practices
-│   └── security-patterns.md
-├── architecture/         # Design decisions and patterns
-│   ├── component-reuse.md
-│   └── model-management.md
-└── README.md
-```
-
-## How Rules Work
-
-Rules are automatically loaded by Claude Code based on:
-- **alwaysApply: true** - Rule is always loaded
-- **alwaysApply: false** - Rule is loaded based on `globs` or `description` relevance
-- **globs** - File patterns that trigger rule loading
-
-## Adding New Rules
-
-1. Choose the appropriate category subdirectory
-2. Create a `.md` file with frontmatter:
-
-```yaml
----
-alwaysApply: false
-description: "Brief description for relevance matching"
-globs: src/**/*.ts  # Optional: only load for these files
----
-```
-
-3. Write the rule content in markdown
-
-## Categories
-
-| Category | Purpose |
-|----------|---------|
-| code-style | Naming conventions, formatting, file structure |
-| security | Security patterns, input validation, safe practices |
-| architecture | Design decisions, component patterns, system organization |
-
-## Auto-Generation
-
-Some rules can be auto-generated from `.workflow/state/decisions.md`:
-
-```bash
-node scripts/flow-rules-sync.js
-```
-
-The sync script will route rules to appropriate category subdirectories.
-
----
-Last updated: 2026-01-12

package/.claude/rules/_internal/document-structure.md

@@ -1,77 +0,0 @@
----
-alwaysApply: false
-description: "All AI-context documents must use PIN markers for targeted context loading"
-globs: ".workflow/**/*.md"
----
-
-# Document Structure for AI Context
-
-All documents in `.workflow/` that are used as AI context MUST follow the PIN standard.
-
-## Required Structure
-
-### 1. Header with PIN List
-Every document starts with a comment listing all pins in the document:
-```markdown
-<!-- PINS: pin1, pin2, pin3 -->
-```
-
-### 2. Section PIN Markers
-Each major section has a PIN marker comment:
-```markdown
-### Section Title
-<!-- PIN: section-specific-pin -->
-[Content]
-```
-
-### 3. PIN Naming Convention
-- Use kebab-case: `user-authentication`, not `userAuthentication`
-- Use semantic names: `error-handling`, not `eh`
-- Use compound names for specificity: `json-parse-safety`
-
-## Why PINs Matter
-
-The PIN system enables:
-1. **Targeted context loading**: Only load sections relevant to current task
-2. **Cheaper model routing**: Haiku can fetch only relevant sections for Opus
-3. **Change detection**: Hash sections independently for smart invalidation
-4. **Cross-reference**: Link sections by PIN across documents
-
-## Example Document
-
-```markdown
-# Config Reference
-
-<!-- PINS: database, authentication, api-keys, environment -->
-
-## Database Settings
-<!-- PIN: database -->
-| Setting | Default | Description |
-|---------|---------|-------------|
-
-## Authentication
-<!-- PIN: authentication -->
-| Setting | Default | Description |
-|---------|---------|-------------|
-```
-
-## Parsing
-
-The PIN system automatically parses documents with:
-- `flow-section-index.js` - Generates section index with pins
-- `flow-section-resolver.js` - Resolves sections by PIN lookup
-- `getSectionsByPins(['auth', 'security'])` - Fetch only relevant sections
-
-## Files That Must Have PINs
-
-| File | Required PINs |
-|------|---------------|
-| `decisions.md` | Per coding rule/pattern |
-| `app-map.md` | Per component/screen |
-| `product.md` | Per product section |
-| `stack.md` | Per technology |
-
-## Validation
-
-Run `node scripts/flow-section-index.js --force` to regenerate the index.
-Check `.workflow/state/section-index.json` for indexed sections and their pins.