speccrew 0.7.6 → 0.7.8

package/.speccrew/skills/speccrew-knowledge-bizs-dispatch/scripts/batch-orchestrator.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+/**
+ * batch-orchestrator.js - Batch management for Stage 2 feature processing
+ * 
+ * Subcommands:
+ *   get-batch      - Get next batch of pending features
+ *   process-results - Process completed batch results and merge graph data
+ * 
+ * Usage:
+ *   node batch-orchestrator.js get-batch --syncStatePath <path> --batchSize <number>
+ *   node batch-orchestrator.js process-results --syncStatePath <path> --graphRoot <path> --completedDir <path>
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Parse command line arguments
+function parseArgs() {
+  const args = {
+    command: null,
+    syncStatePath: null,
+    batchSize: 5,
+    graphRoot: null,
+    completedDir: null
+  };
+  
+  const argv = process.argv.slice(2);
+  args.command = argv[0];
+  
+  for (let i = 1; i < argv.length; i++) {
+    if (argv[i] === '--syncStatePath' && i + 1 < argv.length) {
+      args.syncStatePath = argv[++i];
+    } else if (argv[i] === '--batchSize' && i + 1 < argv.length) {
+      args.batchSize = parseInt(argv[++i], 10) || 5;
+    } else if (argv[i] === '--graphRoot' && i + 1 < argv.length) {
+      args.graphRoot = argv[++i];
+    } else if (argv[i] === '--completedDir' && i + 1 < argv.length) {
+      args.completedDir = argv[++i];
+    }
+  }
+  
+  return args;
+}
+
+// Ensure directory exists
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+// Read JSON file safely
+function readJsonSafe(filePath) {
+  try {
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, 'utf8');
+      return JSON.parse(content);
+    }
+  } catch (e) {
+    // Skip invalid JSON
+  }
+  return null;
+}
+
+// Get all features from syncStatePath
+function getAllFeatures(syncStatePath) {
+  const features = [];
+  
+  if (!fs.existsSync(syncStatePath)) {
+    return features;
+  }
+  
+  const files = fs.readdirSync(syncStatePath);
+  const featureFiles = files.filter(f => f.startsWith('features-') && f.endsWith('.json'));
+  
+  for (const file of featureFiles) {
+    const filePath = path.join(syncStatePath, file);
+    const data = readJsonSafe(filePath);
+    
+    if (data && Array.isArray(data.features)) {
+      for (const feature of data.features) {
+        // Generate feature ID: {platformId}-{module}-{fileName} (without extension)
+        const fileName = feature.fileName || feature.sourceFile || 'unknown';
+        const fileNameWithoutExt = fileName.replace(/\.[^.]+$/, '');
+        const featureId = `${feature.platformId}-${feature.module}-${fileNameWithoutExt}`;
+        
+        features.push({
+          id: featureId,
+          ...feature
+        });
+      }
+    }
+  }
+  
+  return features;
+}
+
+// Get completed feature IDs from completed directory
+function getCompletedFeatureIds(completedDir) {
+  const completedIds = new Set();
+  
+  if (!fs.existsSync(completedDir)) {
+    return completedIds;
+  }
+  
+  const files = fs.readdirSync(completedDir);
+  const doneFiles = files.filter(f => f.endsWith('.done.json'));
+  
+  for (const file of doneFiles) {
+    // Extract feature ID from filename: {featureId}.done.json
+    const featureId = file.replace('.done.json', '');
+    completedIds.add(featureId);
+  }
+  
+  return completedIds;
+}
+
+// get-batch subcommand
+function getBatch(args) {
+  const { syncStatePath, batchSize } = args;
+  
+  ensureDir(syncStatePath);
+  
+  // Determine completed directory (sibling to syncStatePath)
+  const completedDir = path.join(path.dirname(syncStatePath), 'completed');
+  ensureDir(completedDir);
+  
+  // Get all features and completed IDs
+  const allFeatures = getAllFeatures(syncStatePath);
+  const completedIds = getCompletedFeatureIds(completedDir);
+  
+  // Filter pending features
+  const pendingFeatures = allFeatures.filter(f => !completedIds.has(f.id));
+  const total = allFeatures.length;
+  const completed = completedIds.size;
+  const remaining = pendingFeatures.length;
+  
+  if (remaining === 0) {
+    // All done
+    console.log(JSON.stringify({
+      action: 'done',
+      total,
+      completed
+    }));
+  } else {
+    // Get next batch
+    const batch = pendingFeatures.slice(0, batchSize);
+    
+    console.log(JSON.stringify({
+      action: 'process',
+      batch,
+      remaining,
+      total
+    }));
+  }
+}
+
+// process-results subcommand
+function processResults(args) {
+  const { syncStatePath, graphRoot, completedDir } = args;
+  
+  ensureDir(completedDir);
+  ensureDir(graphRoot);
+  
+  let success = 0;
+  let failed = 0;
+  let graphUpdated = false;
+  
+  if (!fs.existsSync(completedDir)) {
+    console.log(JSON.stringify({ success, failed, graphUpdated }));
+    return;
+  }
+  
+  const files = fs.readdirSync(completedDir);
+  
+  // Count done files
+  const doneFiles = files.filter(f => f.endsWith('.done.json'));
+  for (const file of doneFiles) {
+    const filePath = path.join(completedDir, file);
+    const data = readJsonSafe(filePath);
+    if (data) {
+      if (data.status === 'success' || data.status === 'completed') {
+        success++;
+      } else if (data.status === 'failed' || data.status === 'error') {
+        failed++;
+      } else {
+        // Default to success if no status field
+        success++;
+      }
+    } else {
+      // Invalid JSON, assume success
+      success++;
+    }
+  }
+  
+  // Process graph files and merge
+  const graphFiles = files.filter(f => f.endsWith('.graph.json'));
+  
+  if (graphFiles.length > 0) {
+    const nodesPath = path.join(graphRoot, 'nodes.json');
+    const edgesPath = path.join(graphRoot, 'edges.json');
+    
+    // Load existing graph data
+    let existingNodes = [];
+    let existingEdges = [];
+    
+    if (fs.existsSync(nodesPath)) {
+      const data = readJsonSafe(nodesPath);
+      if (Array.isArray(data)) {
+        existingNodes = data;
+      }
+    }
+    
+    if (fs.existsSync(edgesPath)) {
+      const data = readJsonSafe(edgesPath);
+      if (Array.isArray(data)) {
+        existingEdges = data;
+      }
+    }
+    
+    // Merge graph data with deduplication
+    const nodeIds = new Set(existingNodes.map(n => n.id));
+    const edgeKeys = new Set(existingEdges.map(e => `${e.source}-${e.target}-${e.type}`));
+    
+    for (const file of graphFiles) {
+      const filePath = path.join(completedDir, file);
+      const graphData = readJsonSafe(filePath);
+      
+      if (graphData) {
+        // Add nodes
+        if (Array.isArray(graphData.nodes)) {
+          for (const node of graphData.nodes) {
+            if (node.id && !nodeIds.has(node.id)) {
+              existingNodes.push(node);
+              nodeIds.add(node.id);
+            }
+          }
+        }
+        
+        // Add edges
+        if (Array.isArray(graphData.edges)) {
+          for (const edge of graphData.edges) {
+            const edgeKey = `${edge.source}-${edge.target}-${edge.type}`;
+            if (edge.source && edge.target && !edgeKeys.has(edgeKey)) {
+              existingEdges.push(edge);
+              edgeKeys.add(edgeKey);
+            }
+          }
+        }
+        
+        graphUpdated = true;
+      }
+    }
+    
+    // Write merged graph data
+    fs.writeFileSync(nodesPath, JSON.stringify(existingNodes, null, 2));
+    fs.writeFileSync(edgesPath, JSON.stringify(existingEdges, null, 2));
+  }
+  
+  console.log(JSON.stringify({
+    success,
+    failed,
+    graphUpdated
+  }));
+}
+
+// Main
+function main() {
+  const args = parseArgs();
+  
+  if (!args.command) {
+    console.error(JSON.stringify({ error: 'No command specified' }));
+    process.exit(1);
+  }
+  
+  if (args.command === 'get-batch') {
+    if (!args.syncStatePath) {
+      console.error(JSON.stringify({ error: '--syncStatePath is required' }));
+      process.exit(1);
+    }
+    getBatch(args);
+  } else if (args.command === 'process-results') {
+    if (!args.syncStatePath || !args.graphRoot || !args.completedDir) {
+      console.error(JSON.stringify({ error: '--syncStatePath, --graphRoot, and --completedDir are required' }));
+      process.exit(1);
+    }
+    processResults(args);
+  } else {
+    console.error(JSON.stringify({ error: `Unknown command: ${args.command}` }));
+    process.exit(1);
+  }
+}
+
+main();

package/.speccrew/skills/speccrew-knowledge-bizs-dispatch/workflow.agentflow.xml

@@ -44,6 +44,10 @@
     <field name="text">DO NOT estimate workload and suggest breaking it into phases 鈥?execute ALL phases in sequence</field>
     <field name="text">When many features need analysis, dispatch ALL of them 鈥?do NOT skip or defer any</field>
     <field name="text">Context window management: if approaching limit, save progress to checkpoint file and resume 鈥?do NOT ask user for guidance</field>
+    <field name="text">WHEN batch-orchestrator.js returns action=process, you MUST dispatch ALL workers in the batch and continue to the next iteration 鈥?DO NOT stop to report progress or ask for guidance</field>
+    <field name="text">DO NOT estimate total workload (e.g., "52 batches needed") and present it as a reason to pause 鈥?just execute batch by batch until done</field>
+    <field name="text">DO NOT present "progress reports" with options to continue/skip/defer 鈥?the ONLY acceptable output between batches is a one-line log of completed count</field>
+    <field name="text">If a required script (e.g., batch-orchestrator.js) is missing, report the error and STOP 鈥?DO NOT attempt manual batch management as a workaround</field>
   </block>
 
   <!-- ============================================================

package/.speccrew/skills/speccrew-knowledge-bizs-identify-entries/workflow.agentflow.xml

@@ -63,9 +63,10 @@
         <field name="tech_stack" value="${platform.techStack}"/>
         <field name="logic_module_scan" value="Read tech-stack-mappings.json for the techStack's module_scan configuration. Use module_scan.root as the scan starting point and module_scan.depth as the grouping level (depth=1 means first-level subdirectories = one module each)"/>
         <field name="logic_backend" value="Find all directories containing *Controller.java or *Controller.kt files under module_scan.root. These are API entry directories. Module name = the business package name of the entry directory. Apply module_scan.depth for grouping level"/>
-        <field name="logic_frontend_vue_react" value="Find directories under module_scan.root (e.g., src/views or src/pages). First-level subdirectories under module_scan.root are business modules when depth=1"/>
+        <field name="logic_frontend_vue_react" value="STRICT DEPTH RULE: Read module_scan.depth from tech-stack-mappings.json. When depth=1, ONLY the first-level subdirectories directly under module_scan.root are modules. DO NOT recurse into subdirectories. Example for depth=1 with root=src/views: if directories are src/views/system/, src/views/bpm/, src/views/ai/, src/views/dashboard/ — output modules: system, bpm, ai, dashboard. WRONG: system-config, system-dept, bpm-category, bpm-form. Each module's entryDirs = [&quot;src/views/{module_name}&quot;]."/>
         <field name="logic_mobile_uniapp" value="Find first-level subdirectories under module_scan.root (e.g., src/pages). Plus top-level pages-* directories (module name = directory name without pages- prefix)"/>
         <field name="logic_mobile_miniprogram" value="Find first-level subdirectories under module_scan.root (e.g., pages) as modules"/>
+        <field name="depth_enforcement" value="CRITICAL: When module_scan.depth=1, the module name MUST be exactly the first-level directory name (e.g. 'system', 'bpm', 'monitor'). NEVER concatenate parent-child directory names with hyphens (e.g. NEVER 'system-config', 'bpm-form'). Count directory levels from module_scan.root: root/X is depth=1, root/X/Y is depth=2."/>
         <field name="output" var="identified_entries"/>
       </block>
 
@@ -103,7 +104,8 @@
             "sourcePath": "${platform.sourcePath}",
             "techStack": "${platform.techStack}",
             "modules": [
-              { "name": "module-name", "entryDirs": ["relative/path/to/entry"] }
+              IMPORTANT: When depth=1, each module = one first-level subdirectory.
+              Example: {"name": "system", "entryDirs": ["src/views/system"]}, NOT {"name": "system-config", "entryDirs": ["src/views/system/config"]}
             ]
           }
         </field>
@@ -143,6 +145,8 @@
           - module names are business-meaningful (not technical terms like config, util)
           - entryDirs paths are correct and accessible
           - JSON format is valid
+          - DEPTH CHECK: If module_scan.depth=1, verify NO module name contains a hyphen that corresponds to parent-child directory structure (e.g., "system-config" is invalid if "system" is a first-level directory under module_scan.root)
+          - Module count should roughly match the number of first-level subdirectories under module_scan.root (not second-level)
         </field>
         <field name="output" var="validation_result"/>
       </block>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "speccrew",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "description": "Spec-Driven Development toolkit for AI-powered IDEs",
   "author": "charlesmu99",
   "repository": {