wogiflow 1.8.7 → 1.8.9

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

@@ -162,6 +162,15 @@ Launch all in parallel. When `config.hybrid.enabled`, route via `model` paramete
 
 **After agents complete**: Display consolidated research summary covering codebase analysis, best practices, version info, risks, standards, and consumer impact.
 
+**REUSE GATE (MANDATORY)**: After consolidating agent results, check for reuse candidates:
+1. Collect all reuse candidates reported by Agent 1 (domain-keyword search) and Agent 5 (registry scan)
+2. If ANY reuse candidate has purpose overlap with planned new code → **STOP and present to user**:
+   - Show each candidate: name, path, purpose, similarity
+   - Ask: "Use existing / Extend existing / Create new (explain why)"
+   - Implementation BLOCKED until user decides on each candidate
+3. If no reuse candidates found → proceed normally
+4. This gate runs BEFORE spec generation — catching reuse early prevents wasted implementation
+
 **For L1/L0 tasks**: Offer to deepen research (exhaustive search, load all skills, full dependency tree).
 
 **Fallback**: If agents fail, log warning and proceed with remaining. Consumer Impact failure on refactor tasks = HARD BLOCK (require user confirmation). See `.claude/docs/explore-agents.md` for details.

package/.claude/docs/explore-agents.md

@@ -9,23 +9,43 @@ Launch as `Agent(subagent_type=Explore)`:
 ```
 Analyze the codebase for task: "[TASK_TITLE]"
 
-1. Use Glob to find files related to: [TASK_KEYWORDS]
-2. Use Grep to search for patterns, function names, component references
-3. Read app-map.md for existing components that could be reused
-4. Read function-map.md for existing utility functions that could be reused
-5. Read api-map.md for existing API endpoints that could be reused
-6. Read decisions.md for patterns that must be followed
-7. Map dependencies:
-   - Files that REFERENCE the target code
-   - Files REFERENCED BY the target code
-8. Surface assumptions that need verification
+STEP 1 — Domain-keyword search (MANDATORY, do this FIRST):
+  a. Extract 3-5 domain keywords from the task title
+     Example: "AI Policies tab" → ["policy", "policies", "automation", "AI"]
+     Example: "Payment service refactor" → ["payment", "checkout", "billing", "transaction"]
+  b. For EACH keyword, run:
+     - Glob **/*[keyword]* to find files with that keyword in the name
+     - Grep for the keyword in src/ (or project root) to find references in code
+  c. Read EVERY file that matches — these are potential reuse candidates
+  d. Pay special attention to files in shared/, utils/, lib/, common/ directories
+
+STEP 2 — Registry check (read ALL registry maps):
+  a. Read app-map.md for existing components that could be reused
+  b. Read function-map.md for existing utility functions
+  c. Read api-map.md for existing API endpoints
+  d. Read any other *-map.md files in .workflow/state/
+  e. For each planned NEW item, check if something similar already exists
+
+STEP 3 — Pattern & dependency analysis:
+  a. Read decisions.md for patterns that must be followed
+  b. Map dependencies:
+     - Files that REFERENCE the target code
+     - Files REFERENCED BY the target code
+  c. Surface assumptions that need verification
 
 Return a structured summary:
+- **REUSE CANDIDATES** (MUST be first section):
+  List every existing file/component/function/service that overlaps
+  with what this task plans to create. For each: path, purpose, and
+  whether the task should USE it, EXTEND it, or CREATE new.
 - Related files (path + why it's relevant)
-- Existing components to reuse
-- Patterns to follow
+- Patterns to follow (from decisions.md)
 - Dependency map
 - Assumptions to verify
+
+CRITICAL: If domain-keyword search finds existing implementations that
+overlap with the task's goals, this MUST be prominently flagged.
+Do NOT skip Step 1 even if you think you already know the codebase.
 ```
 
 ## Agent 2: Best Practices Researcher

package/.workflow/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/lib/installer.js

@@ -1110,6 +1110,19 @@ function createWorkflowStructure(projectRoot, config) {
     fs.mkdirSync(path.join(workflowDir, dir), { recursive: true });
   }
 
+  // Ensure .workflow/ uses CommonJS — required when project root has "type": "module"
+  // Without this, Node.js inherits ESM from the project root and .workflow/bridges/*.js
+  // (which use require/module.exports) crash with "require is not defined".
+  // Same pattern as scripts/package.json.
+  const workflowPkgPath = path.join(workflowDir, 'package.json');
+  try {
+    fs.writeFileSync(workflowPkgPath, JSON.stringify({ type: 'commonjs' }, null, 2) + '\n', { flag: 'wx' });
+  } catch (err) {
+    if (err.code !== 'EEXIST') {
+      throw err;
+    }
+  }
+
   // Create config.json using shared defaults with project-specific overrides
   const configPath = path.join(workflowDir, 'config.json');
   const configContent = getDefaultConfig({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "1.8.7",
+  "version": "1.8.9",
   "description": "AI-powered development workflow management system with multi-model support",
   "main": "lib/index.js",
   "bin": {
@@ -19,6 +19,7 @@
     "lib/",
     "scripts/",
     "templates/",
+    ".workflow/package.json",
     ".workflow/templates/",
     ".workflow/agents/",
     ".workflow/bridges/",

package/scripts/flow-community.js

@@ -257,18 +257,30 @@ function collectShareableData(config) {
 
 /**
  * Get WogiFlow version from package.json.
+ * Uses require.resolve to find the actual wogiflow package, not the host project.
  * @returns {string}
  */
 let _cachedVersion = null;
 function getWogiFlowVersion() {
   if (_cachedVersion) return _cachedVersion;
   try {
-    const pkgPath = path.join(__dirname, '..', 'package.json');
+    const pkgPath = require.resolve('wogiflow/package.json');
     const pkg = safeJsonParse(pkgPath, {});
     _cachedVersion = pkg.version || 'unknown';
     return _cachedVersion;
   } catch {
-    _cachedVersion = 'unknown';
+    // Fallback: resolve relative to this file (works when running from source repo)
+    try {
+      const fallbackPath = path.join(__dirname, '..', 'package.json');
+      const pkg = safeJsonParse(fallbackPath, {});
+      if (pkg.name === 'wogiflow') {
+        _cachedVersion = pkg.version || 'unknown';
+      } else {
+        _cachedVersion = 'unknown';
+      }
+    } catch {
+      _cachedVersion = 'unknown';
+    }
     return _cachedVersion;
   }
 }

package/scripts/hooks/core/component-check.js

@@ -36,14 +36,66 @@ function isComponentCheckEnabled(config) {
 }
 
 /**
- * Get component patterns to check
+ * Default reusable-code path patterns by project type.
+ * These cover ALL areas where reusable code lives — not just UI components.
+ * Projects can override via config.componentReuse.patterns.
+ */
+const DEFAULT_REUSABLE_PATTERNS = {
+  // Frontend-specific
+  frontend: [
+    '**/components/**', '**/ui/**', '**/src/components/**',
+    '**/pages/**/shared/**', '**/features/**/shared/**',
+    '**/layouts/**', '**/modals/**', '**/widgets/**'
+  ],
+  // Backend-specific
+  backend: [
+    '**/services/**', '**/middleware/**',
+    '**/models/**', '**/schemas/**', '**/validators/**',
+    '**/routes/**', '**/controllers/**',
+    '**/repositories/**', '**/providers/**'
+  ],
+  // Universal (applies to ALL project types)
+  universal: [
+    '**/utils/**', '**/helpers/**', '**/lib/**', '**/shared/**',
+    '**/hooks/**', '**/composables/**',
+    '**/api/**', '**/clients/**',
+    '**/types/**', '**/interfaces/**',
+    '**/constants/**', '**/config/**'
+  ]
+};
+
+/**
+ * Get reusable-code patterns to check.
+ * Combines universal patterns with project-type-specific patterns.
+ * Projects can override entirely via config.componentReuse.patterns.
  * @param {Object} [config] - Pre-loaded config (optional, falls back to getConfig())
- * @returns {string[]} Glob patterns for component directories
+ * @returns {string[]} Glob patterns for reusable code directories
  */
 function getComponentPatterns(config) {
   if (!config) config = getConfig();
-  return config.componentReuse?.patterns ||
-         ['**/components/**', '**/ui/**', '**/src/components/**'];
+
+  // If user explicitly configured patterns, use those
+  if (config.componentReuse?.patterns && Array.isArray(config.componentReuse.patterns)) {
+    return config.componentReuse.patterns;
+  }
+
+  // Build patterns from project type
+  const projectType = config.projectType || 'unknown';
+  const patterns = [...DEFAULT_REUSABLE_PATTERNS.universal];
+
+  if (projectType === 'frontend' || projectType === 'fullstack' || projectType === 'unknown') {
+    patterns.push(...DEFAULT_REUSABLE_PATTERNS.frontend);
+  }
+  if (projectType === 'backend' || projectType === 'fullstack' || projectType === 'unknown') {
+    patterns.push(...DEFAULT_REUSABLE_PATTERNS.backend);
+  }
+
+  // Add any extra patterns from config (additive)
+  if (config.componentReuse?.extraPatterns && Array.isArray(config.componentReuse.extraPatterns)) {
+    patterns.push(...config.componentReuse.extraPatterns);
+  }
+
+  return patterns;
 }
 
 /**
@@ -87,17 +139,53 @@ function isComponentPath(filePath, config) {
 }
 
 /**
- * Load the component index
+ * Load the component index.
+ * Falls back to building a minimal index from all registry maps when
+ * component-index.json doesn't exist.
  * @returns {Object|null} Component index or null
  */
 function loadComponentIndex() {
   try {
     const indexPath = path.join(PATHS.state, 'component-index.json');
-    if (!fs.existsSync(indexPath)) {
-      return null;
+    if (fs.existsSync(indexPath)) {
+      return JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
+    }
+
+    // Fallback: build a minimal index from all *-map.md files in state/
+    const stateDir = PATHS.state;
+    if (!stateDir || !fs.existsSync(stateDir)) return null;
+
+    const components = [];
+    const entries = fs.readdirSync(stateDir);
+    for (const entry of entries) {
+      if (entry.endsWith('-map.md') && /^[a-z0-9-]+\.md$/.test(entry)) {
+        try {
+          const content = fs.readFileSync(path.join(stateDir, entry), 'utf-8');
+          const lines = content.split('\n');
+          for (const line of lines) {
+            // Parse table rows: | Name | description | path |
+            const tableMatch = line.match(/^\|\s*([^|]+)\s*\|\s*([^|]*)\s*\|\s*([^|]*)\s*\|/);
+            if (tableMatch && !tableMatch[1].includes('---')) {
+              const name = tableMatch[1].trim();
+              if (name && name !== 'Component' && name !== 'Name' && name !== 'Function' && name !== 'Endpoint') {
+                components.push({
+                  name,
+                  description: (tableMatch[2] || '').trim(),
+                  path: (tableMatch[3] || '').trim(),
+                  source: entry.replace('.md', '')
+                });
+              }
+            }
+          }
+        } catch (err) {
+          // Skip unreadable map files
+        }
+      }
     }
-    return JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
-  } catch (_err) {
+
+    if (components.length === 0) return null;
+    return { components, source: 'fallback-from-maps' };
+  } catch (err) {
     return null;
   }
 }
@@ -136,7 +224,7 @@ function parseAppMap() {
     }
 
     return components;
-  } catch (_err) {
+  } catch (err) {
     return [];
   }
 }

package/scripts/hooks/core/routing-gate.js

@@ -75,8 +75,10 @@ function hasActiveTask() {
     if (process.env.DEBUG) {
       console.error(`[routing-gate] Ready data read error: ${err.message}`);
     }
-    // Fail-open: if can't read ready.json, assume active task exists
-    return true;
+    // Fail-closed: if can't read ready.json, assume no active task.
+    // Fail-open here was a bypass vector — corrupted ready.json would make
+    // subagent routing think a task exists and skip the routing gate.
+    return false;
   }
 }
 

package/scripts/hooks/entry/claude-code/user-prompt-submit.js

@@ -52,7 +52,7 @@ async function main() {
         process.exit(0);
         return;
       }
-    } catch (_parseErr) {
+    } catch (err) {
       // Parse error - allow through (graceful degradation)
       console.log(JSON.stringify({ continue: true, hookSpecificOutput: { hookEventName: 'UserPromptSubmit' } }));
       process.exit(0);
@@ -118,7 +118,8 @@ async function main() {
 
     // v6.0: Set routing-pending flag for routing gate enforcement
     // This blocks ALL gated tool calls until a /wogi-* skill is invoked
-    // v8.0: Always set, even with active tasks — every turn must route through /wogi-start
+    // v8.0: Always set, even with active tasks — every turn must route through /wogi-start.
+    // Exception: skipped when the prompt IS a /wogi-* command (see isWogiCommand below).
     // v6.1: Also skip when the prompt IS a /wogi-* command — the user is already routing.
     // When users type "/wogi-start ..." directly, Claude Code expands the skill inline
     // (not through the Skill tool), so clearRoutingPending() in PreToolUse never fires.

package/scripts/postinstall.js

@@ -134,7 +134,12 @@ function createMinimalStructure() {
         ? fs.readFileSync(templatePath, 'utf-8')
         : JSON.stringify({ prompts: [], version: 1 }, null, 2);
       // Validate template is valid JSON before writing (with proto check)
-      const parsed = JSON.parse(rawContent);
+      let parsed;
+      try {
+        parsed = JSON.parse(rawContent);
+      } catch (err) {
+        parsed = { prompts: [], version: 1 };
+      }
       if (parsed && typeof parsed === 'object') {
         for (const k of Object.keys(parsed)) {
           if (k === '__proto__' || k === 'constructor' || k === 'prototype') delete parsed[k];
@@ -384,6 +389,19 @@ function copyWorkflowManagedDirs() {
       copyDir(src, dest, false);
     }
   }
+
+  // Ensure .workflow/package.json exists with "type": "commonjs".
+  // Required when the project root has "type": "module" — without it,
+  // Node.js inherits ESM and .workflow/bridges/*.js (CJS) crash.
+  const workflowPkg = path.join(WORKFLOW_DIR, 'package.json');
+  try {
+    fs.writeFileSync(workflowPkg, JSON.stringify({ type: 'commonjs' }, null, 2) + '\n', { flag: 'wx' });
+  } catch (err) {
+    if (err.code !== 'EEXIST') {
+      console.warn(`[postinstall] Warning: Failed to create .workflow/package.json: ${err.message}`);
+      console.warn('[postinstall] ESM projects may have issues with WogiFlow hooks. Create this file manually with: {"type":"commonjs"}');
+    }
+  }
 }
 
 /**