speccrew 0.7.5 → 0.7.8

package/.speccrew/skills/speccrew-knowledge-bizs-api-analyze/workflow.agentflow.xml

@@ -15,6 +15,7 @@
     <field name="completed_dir" required="true" type="string" desc="Marker files output directory"/>
     <field name="sourceFile" required="true" type="string" desc="Source features JSON file name"/>
     <field name="language" required="true" type="string" desc="Target language for content"/>
+    <field name="workspace_path" required="true" type="string" desc="Workspace root path"/>
   </block>
   
   <!-- ==================== CONSTRAINT RULES ==================== -->
@@ -248,7 +249,7 @@
     <field name="text">
       The output document file MUST be created at the EXACT path specified by ${documentPath} input parameter.
       DO NOT use the template file name (e.g., FEATURE-DETAIL-TEMPLATE-*.md) as the output file name.
-      The documentPath already contains the correct target path including file name (e.g., speccrew-workspace/knowledges/bizs/backend-system/admin/cache/cache_controller.md).
+      The documentPath already contains the correct target path including file name (e.g., speccrew-workspace/knowledges/bizs/backend-fastapi/admin/cache/cache_controller.md).
       Before creating the file, ensure the parent directory exists (create if necessary).
     </field>
   </block>
@@ -478,17 +479,125 @@
     <field name="verify" value="file.exists(${completed_dir}/${markerName}.done.json)"/>
   </block>
   
-  <!-- Dispatch to Graph Skill for .graph.json -->
-  <block type="task" id="B32" action="dispatch-to-worker" desc="Dispatch graph generation">
-    <field name="skill">speccrew-knowledge-bizs-api-graph</field>
-    <field name="parameters">
-      <field name="controllerFile">${fileName}</field>
-      <field name="sourcePath">${sourcePath}</field>
-      <field name="endpoints">${endpoints}</field>
-      <field name="completed_dir">${completed_dir}</field>
-      <field name="markerName">${markerName}</field>
+  <!-- Step 7b: Construct and Append Graph Data -->
+  <!-- Construct Graph Nodes from API Analysis -->
+  <block type="task" id="B32a" action="analyze" desc="Construct API endpoint nodes">
+    <field name="endpoints" value="${endpoints}"/>
+    <field name="module" value="${module}"/>
+    <field name="sourcePath" value="${sourcePath}"/>
+    <field name="documentPath" value="${documentPath}"/>
+    <field name="output" var="apiNodes"/>
+  </block>
+
+  <block type="task" id="B32b" action="analyze" desc="Construct service nodes">
+    <field name="services" value="${services}"/>
+    <field name="module" value="${module}"/>
+    <field name="sourcePath" value="${sourcePath}"/>
+    <field name="documentPath" value="${documentPath}"/>
+    <field name="output" var="serviceNodes"/>
+  </block>
+
+  <block type="task" id="B32c" action="analyze" desc="Construct table nodes">
+    <field name="tables" value="${databaseTables}"/>
+    <field name="module" value="${module}"/>
+    <field name="output" var="tableNodes"/>
+  </block>
+
+  <!-- Construct Graph Edges -->
+  <block type="task" id="B32d" action="analyze" desc="Construct API-to-Service edges">
+    <field name="endpoints" value="${endpoints}"/>
+    <field name="module" value="${module}"/>
+    <field name="output" var="invokesEdges"/>
+  </block>
+
+  <block type="task" id="B32e" action="analyze" desc="Construct API-to-Table edges">
+    <field name="endpoints" value="${endpoints}"/>
+    <field name="tables" value="${databaseTables}"/>
+    <field name="module" value="${module}"/>
+    <field name="output" var="operatesEdges"/>
+  </block>
+
+  <!-- Append Graph Data to nodes.json and edges.json -->
+  <block type="task" id="B32f" action="run-script" desc="Append graph nodes to nodes.json">
+    <field name="command">node -e "
+const fs = require('fs');
+const path = require('path');
+const graphDir = path.join('${workspace_path}', 'speccrew-workspace', 'knowledges', 'bizs', 'graph');
+const nodesFile = path.join(graphDir, 'nodes.json');
+
+// Ensure directory exists
+if (!fs.existsSync(graphDir)) {
+  fs.mkdirSync(graphDir, { recursive: true });
+}
+
+// Read existing nodes or initialize empty array
+let existingNodes = [];
+if (fs.existsSync(nodesFile)) {
+  try {
+    existingNodes = JSON.parse(fs.readFileSync(nodesFile, 'utf8'));
+    if (!Array.isArray(existingNodes)) existingNodes = [];
+  } catch (e) {
+    existingNodes = [];
+  }
+}
+
+// Parse new nodes from input
+const newNodes = JSON.parse('${apiNodes}' || '[]').concat(JSON.parse('${serviceNodes}' || '[]')).concat(JSON.parse('${tableNodes}' || '[]'));
+
+// Deduplicate by id
+const nodeMap = new Map();
+existingNodes.forEach(n => nodeMap.set(n.id, n));
+newNodes.forEach(n => nodeMap.set(n.id, n));
+
+// Write back
+fs.writeFileSync(nodesFile, JSON.stringify(Array.from(nodeMap.values()), null, 2));
+console.log('Nodes appended:', newNodes.length);
+"
     </field>
   </block>
+
+  <block type="task" id="B32g" action="run-script" desc="Append graph edges to edges.json">
+    <field name="command">node -e "
+const fs = require('fs');
+const path = require('path');
+const graphDir = path.join('${workspace_path}', 'speccrew-workspace', 'knowledges', 'bizs', 'graph');
+const edgesFile = path.join(graphDir, 'edges.json');
+
+// Read existing edges or initialize empty array
+let existingEdges = [];
+if (fs.existsSync(edgesFile)) {
+  try {
+    existingEdges = JSON.parse(fs.readFileSync(edgesFile, 'utf8'));
+    if (!Array.isArray(existingEdges)) existingEdges = [];
+  } catch (e) {
+    existingEdges = [];
+  }
+}
+
+// Parse new edges from input
+const newEdges = JSON.parse('${invokesEdges}' || '[]').concat(JSON.parse('${operatesEdges}' || '[]'));
+
+// Deduplicate by composite key (source+target+type)
+const edgeMap = new Map();
+existingEdges.forEach(e => {
+  const key = e.source + '|' + e.target + '|' + e.type;
+  edgeMap.set(key, e);
+});
+newEdges.forEach(e => {
+  const key = e.source + '|' + e.target + '|' + e.type;
+  edgeMap.set(key, e);
+});
+
+// Write back
+fs.writeFileSync(edgesFile, JSON.stringify(Array.from(edgeMap.values()), null, 2));
+console.log('Edges appended:', newEdges.length);
+"
+    </field>
+  </block>
+
+  <block type="checkpoint" id="CP-graph" name="graph-written" desc="Graph data written">
+    <field name="verify" value="true"/>
+  </block>
   
   <block type="event" id="E10" action="log" level="info" desc="Log marker status">
     <field name="message" value="Step 7 Status: COMPLETED - Marker file written to ${completed_dir}"/>

package/.speccrew/skills/speccrew-knowledge-bizs-dispatch/SKILL.md

@@ -1001,11 +1001,11 @@ Requirements:
       "fileName": "UserController",
       "sourcePath": "controller/admin/user/UserController.java",
       "module": "user",
-      "documentPath": "speccrew-workspace/knowledges/bizs/backend-system/user/UserController.md",
+      "documentPath": "speccrew-workspace/knowledges/bizs/backend-spring/user/UserController.md",
       "platformType": "backend",
       "platformSubtype": "spring",
-      "platformId": "backend-system",
-      "sourceFile": "features-backend-system.json"
+      "platformId": "backend-spring",
+      "sourceFile": "features-backend-spring.json"
     }
   ]
 }

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/.speccrew/skills/speccrew-knowledge-bizs-init-features/SKILL.md

@@ -26,7 +26,7 @@ All generated documents must match the user's language. Detect the language from
 
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
-| `platformId` | string | Yes | Platform identifier (e.g., "backend-system", "frontend-web", "mobile-app") |
+| `platformId` | string | Yes | Platform identifier (e.g., "backend-fastapi", "web-vue3", "mobile-uniapp") |
 | `platformName` | string | Yes | Platform display name |
 | `platformType` | string | Yes | Platform type: backend, web, mobile |
 | `platformSubtype` | string | No | Platform subtype (e.g., vue, react, uniapp) |

package/.speccrew/skills/speccrew-knowledge-bizs-init-features/scripts/generate-inventory.js

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+/**
+ * generate-inventory.js
+ * 
+ * Generate features.json inventory for a single platform.
+ * This script is called by speccrew-knowledge-bizs-init-features workflow.
+ * 
+ * Usage:
+ *   node generate-inventory.js --entryDirsFile <path> --outputDir <path>
+ * 
+ * Arguments:
+ *   --entryDirsFile    Path to entry-dirs JSON file
+ *   --outputDir        Output directory for features.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Parse command line arguments
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const parsed = {};
+  
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      const value = args[i + 1];
+      if (value && !value.startsWith('--')) {
+        parsed[key] = value;
+        i++;
+      } else {
+        parsed[key] = true;
+      }
+    }
+  }
+  
+  return parsed;
+}
+
+// Generate timestamp in format YYYY-MM-DD-HHMMSS
+function generateTimestamp() {
+  const now = new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const day = String(now.getDate()).padStart(2, '0');
+  const hours = String(now.getHours()).padStart(2, '0');
+  const minutes = String(now.getMinutes()).padStart(2, '0');
+  const seconds = String(now.getSeconds()).padStart(2, '0');
+  return `${year}-${month}-${day}-${hours}${minutes}${seconds}`;
+}
+
+// Convert absolute path to project-relative path
+function toRelativePath(absolutePath, projectRoot) {
+  // Normalize paths
+  const normalizedAbs = path.normalize(absolutePath).replace(/\\/g, '/');
+  const normalizedRoot = path.normalize(projectRoot).replace(/\\/g, '/');
+  
+  if (normalizedAbs.startsWith(normalizedRoot)) {
+    const relative = normalizedAbs.slice(normalizedRoot.length).replace(/^\/+/, '');
+    return relative;
+  }
+  return normalizedAbs;
+}
+
+// Generate document path for a feature
+// Format: speccrew-workspace/knowledges/bizs/{platformId}/{module}/{subpath}/{filename}.md
+function generateDocumentPath(platformId, module, sourcePath, projectRoot) {
+  // Extract filename without extension
+  const basename = path.basename(sourcePath, path.extname(sourcePath));
+  
+  // Get directory relative to module root
+  const relativePath = toRelativePath(sourcePath, projectRoot);
+  
+  // Parse the source path to extract module and subpath
+  // Expected format: {platformSourceRoot}/{module}/{subpath}/{file}
+  const pathParts = relativePath.split('/');
+  
+  // Find module index
+  let moduleIndex = -1;
+  for (let i = 0; i < pathParts.length; i++) {
+    if (pathParts[i] === module) {
+      moduleIndex = i;
+      break;
+    }
+  }
+  
+  // Build subpath (everything between module and filename)
+  let subpath = '';
+  if (moduleIndex >= 0 && moduleIndex < pathParts.length - 2) {
+    // There are directories between module and filename
+    subpath = pathParts.slice(moduleIndex + 1, pathParts.length - 1).join('/');
+  }
+  
+  // Construct document path using platformId (which follows {platformType}-{techStack} format)
+  // e.g., backend-fastapi, web-vue3, mobile-uniapp
+  const docPathParts = ['speccrew-workspace', 'knowledges', 'bizs', platformId, module];
+  
+  if (subpath) {
+    docPathParts.push(subpath);
+  }
+  
+  docPathParts.push(`${basename}.md`);
+  
+  return docPathParts.join('/');
+}
+
+// Main function
+function main() {
+  const args = parseArgs();
+  
+  // Validate required arguments
+  if (!args.entryDirsFile) {
+    console.error('Error: --entryDirsFile is required');
+    process.exit(1);
+  }
+  
+  if (!args.outputDir) {
+    console.error('Error: --outputDir is required');
+    process.exit(1);
+  }
+  
+  const entryDirsFile = path.resolve(args.entryDirsFile);
+  const outputDir = path.resolve(args.outputDir);
+  
+  // Check if entry-dirs file exists
+  if (!fs.existsSync(entryDirsFile)) {
+    console.error(`Error: Entry-dirs file not found: ${entryDirsFile}`);
+    process.exit(1);
+  }
+  
+  // Read and parse entry-dirs JSON
+  let entryDirsData;
+  try {
+    const content = fs.readFileSync(entryDirsFile, 'utf-8');
+    entryDirsData = JSON.parse(content);
+  } catch (error) {
+    console.error(`Error: Failed to parse entry-dirs file: ${error.message}`);
+    process.exit(1);
+  }
+  
+  // Validate entry-dirs structure
+  if (!entryDirsData.modules || !Array.isArray(entryDirsData.modules) || entryDirsData.modules.length === 0) {
+    console.error('Error: entry-dirs JSON must have non-empty modules array');
+    process.exit(1);
+  }
+  
+  // Extract platform info from entry-dirs data
+  const platformId = entryDirsData.platformId || 'unknown-platform';
+  const platformName = entryDirsData.platformName || platformId;
+  const platformType = entryDirsData.platformType || 'unknown';
+  const platformSubtype = entryDirsData.platformSubtype || '';
+  const techStack = entryDirsData.techStack || [];
+  const sourceRoot = entryDirsData.sourcePath || '';
+  
+  // Project root is the parent of speccrew-workspace
+  const projectRoot = path.resolve(outputDir, '..', '..', '..');
+  
+  // Generate features for each module
+  const features = [];
+  const modules = [];
+  
+  for (const moduleData of entryDirsData.modules) {
+    const moduleName = moduleData.name;
+    const entryDirs = moduleData.entryDirs || [];
+    
+    let moduleFeatureCount = 0;
+    
+    for (const entryDir of entryDirs) {
+      // Scan files in entry directory
+      const scanDirectory = (dir) => {
+        const files = [];
+        
+        try {
+          const entries = fs.readdirSync(dir, { withFileTypes: true });
+          
+          for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            
+            if (entry.isDirectory()) {
+              // Recursively scan subdirectories
+              files.push(...scanDirectory(fullPath));
+            } else if (entry.isFile()) {
+              // Check if file is a source file based on platform type
+              const ext = path.extname(entry.name).toLowerCase();
+              const isSourceFile = isValidSourceFile(ext, platformType);
+              
+              if (isSourceFile) {
+                files.push(fullPath);
+              }
+            }
+          }
+        } catch (error) {
+          console.warn(`Warning: Failed to scan directory ${dir}: ${error.message}`);
+        }
+        
+        return files;
+      };
+      
+      const sourceFiles = scanDirectory(entryDir);
+      
+      for (const sourceFile of sourceFiles) {
+        const relativeSourcePath = toRelativePath(sourceFile, projectRoot);
+        const fileName = path.basename(sourceFile, path.extname(sourceFile));
+        
+        // Generate document path using platformId
+        const documentPath = generateDocumentPath(platformId, moduleName, sourceFile, projectRoot);
+        
+        features.push({
+          fileName: fileName,
+          sourcePath: relativeSourcePath,
+          documentPath: documentPath,
+          module: moduleName,
+          analyzed: false,
+          startedAt: null,
+          completedAt: null,
+          analysisNotes: null
+        });
+        
+        moduleFeatureCount++;
+      }
+    }
+    
+    modules.push({
+      name: moduleName,
+      featureCount: moduleFeatureCount
+    });
+  }
+  
+  // Build output JSON
+  const outputData = {
+    platformName: platformName,
+    platformType: platformType,
+    platformSubtype: platformSubtype,
+    platformId: platformId,
+    sourcePath: sourceRoot,
+    techStack: techStack,
+    modules: modules,
+    totalFiles: features.length,
+    analyzedCount: 0,
+    pendingCount: features.length,
+    generatedAt: generateTimestamp(),
+    features: features
+  };
+  
+  // Ensure output directory exists
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  
+  // Write output file
+  const outputFile = path.join(outputDir, `features-${platformId}.json`);
+  try {
+    fs.writeFileSync(outputFile, JSON.stringify(outputData, null, 2), 'utf-8');
+    console.log(`Generated: ${outputFile}`);
+    console.log(`  Platform: ${platformName} (${platformId})`);
+    console.log(`  Type: ${platformType}${platformSubtype ? '/' + platformSubtype : ''}`);
+    console.log(`  Features: ${features.length}`);
+    console.log(`  Modules: ${modules.map(m => m.name).join(', ')}`);
+  } catch (error) {
+    console.error(`Error: Failed to write output file: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// Check if file extension is valid for the platform type
+function isValidSourceFile(ext, platformType) {
+  const backendExts = ['.java', '.kt', '.py', '.go', '.rs', '.cs', '.php', '.rb'];
+  const webExts = ['.vue', '.tsx', '.jsx', '.ts', '.js', '.svelte'];
+  const mobileExts = ['.vue', '.tsx', '.jsx', '.ts', '.js', '.dart', '.swift', '.kt', '.java'];
+  const desktopExts = ['.vue', '.tsx', '.jsx', '.ts', '.js', '.cs', '.xaml'];
+  
+  switch (platformType) {
+    case 'backend':
+      return backendExts.includes(ext);
+    case 'web':
+      return webExts.includes(ext);
+    case 'mobile':
+      return mobileExts.includes(ext);
+    case 'desktop':
+      return desktopExts.includes(ext);
+    default:
+      // Accept all common source file extensions
+      return [...backendExts, ...webExts, ...mobileExts, ...desktopExts].includes(ext);
+  }
+}
+
+// Run main function
+main();

package/.speccrew/skills/speccrew-knowledge-bizs-module-classify/scripts/reindex-modules.js

@@ -3,7 +3,7 @@
  * reindex-modules.js - Deterministic script to re-extract module names from existing features JSON with updated exclude_dirs
  * 
  * Usage:
- *   node reindex-modules.js --featuresFile "path/to/features-backend-system.json" --projectRoot "d:\dev\ruoyi-vue-pro"
+ *   node reindex-modules.js --featuresFile "path/to/features-backend-fastapi.json" --projectRoot "d:\dev\ruoyi-vue-pro"
  * 
  * Optional parameters:
  *   --platformType "backend" - If not provided, read from features JSON's platformType field

package/.speccrew/skills/speccrew-knowledge-bizs-ui-analyze/workflow.agentflow.xml

@@ -376,12 +376,179 @@
   <block type="checkpoint" id="CP7" name="marker-written" desc="Marker file written">
     <field name="verify" value="file.exists(${completed_dir}/${markerName}.done.json)"/>
   </block>
-  
+
+  <!-- Step 7b: Construct and Append Graph Data -->
+  <!-- Construct Graph Nodes from UI Analysis -->
+  <block type="task" id="B32a" action="analyze" desc="Construct page node">
+    <field name="type" value="page"/>
+    <field name="id" value="page-${module}-${fileName}"/>
+    <field name="name" value="${fileName}"/>
+    <field name="module" value="${module}"/>
+    <field name="sourcePath" value="${sourcePath}"/>
+    <field name="documentPath" value="${documentPath}"/>
+    <field name="platform" value="${platform_type}-${platform_subtype}"/>
+    <field name="output" var="pageNode"/>
+  </block>
+
+  <block type="task" id="B32b" action="analyze" desc="Construct component nodes">
+    <field name="components" value="${analysisResult.components}"/>
+    <field name="module" value="${module}"/>
+    <field name="documentPath" value="${documentPath}"/>
+    <field name="output" var="componentNodes"/>
+  </block>
+
+  <block type="task" id="B32c" action="analyze" desc="Construct route nodes">
+    <field name="routes" value="${analysisResult.routes}"/>
+    <field name="module" value="${module}"/>
+    <field name="sourcePath" value="${sourcePath}"/>
+    <field name="output" var="routeNodes"/>
+  </block>
+
+  <!-- Construct Graph Edges -->
+  <block type="task" id="B32d" action="analyze" desc="Construct navigates edges">
+    <field name="pageId" value="page-${module}-${fileName}"/>
+    <field name="navigations" value="${analysisResult.navigations}"/>
+    <field name="module" value="${module}"/>
+    <field name="output" var="navigatesEdges"/>
+  </block>
+
+  <block type="task" id="B32e" action="analyze" desc="Construct contains edges">
+    <field name="pageId" value="page-${module}-${fileName}"/>
+    <field name="components" value="${analysisResult.components}"/>
+    <field name="module" value="${module}"/>
+    <field name="output" var="containsEdges"/>
+  </block>
+
+  <block type="task" id="B32f" action="analyze" desc="Construct calls-api edges">
+    <field name="pageId" value="page-${module}-${fileName}"/>
+    <field name="apiCalls" value="${analysisResult.apis}"/>
+    <field name="module" value="${module}"/>
+    <field name="output" var="callsApiEdges"/>
+  </block>
+
+  <!-- Append Graph Data to nodes.json and edges.json -->
+  <block type="task" id="B32g" action="run-script" desc="Append graph nodes to nodes.json">
+    <field name="command">node -e "
+const fs = require('fs');
+const path = require('path');
+const graphDir = path.join('${workspace_path}', 'speccrew-workspace', 'knowledges', 'bizs', 'graph');
+const nodesFile = path.join(graphDir, 'nodes.json');
+
+// Ensure directory exists
+if (!fs.existsSync(graphDir)) {
+  fs.mkdirSync(graphDir, { recursive: true });
+}
+
+// Read existing nodes or initialize empty array
+let existingNodes = [];
+if (fs.existsSync(nodesFile)) {
+  try {
+    existingNodes = JSON.parse(fs.readFileSync(nodesFile, 'utf8'));
+    if (!Array.isArray(existingNodes)) existingNodes = [];
+  } catch (e) {
+    existingNodes = [];
+  }
+}
+
+// Parse new nodes from input
+const newNodes = [];
+if ('${pageNode}') {
+  try {
+    const page = JSON.parse('${pageNode}');
+    if (page && page.id) newNodes.push(page);
+  } catch (e) {}
+}
+if ('${componentNodes}') {
+  try {
+    const comps = JSON.parse('${componentNodes}');
+    if (Array.isArray(comps)) newNodes.push(...comps);
+  } catch (e) {}
+}
+if ('${routeNodes}') {
+  try {
+    const routes = JSON.parse('${routeNodes}');
+    if (Array.isArray(routes)) newNodes.push(...routes);
+  } catch (e) {}
+}
+
+// Deduplicate by id
+const nodeMap = new Map();
+existingNodes.forEach(n => nodeMap.set(n.id, n));
+newNodes.forEach(n => nodeMap.set(n.id, n));
+
+// Write back
+fs.writeFileSync(nodesFile, JSON.stringify(Array.from(nodeMap.values()), null, 2));
+console.log('Nodes appended:', newNodes.length);
+"
+    </field>
+  </block>
+
+  <block type="task" id="B32h" action="run-script" desc="Append graph edges to edges.json">
+    <field name="command">node -e "
+const fs = require('fs');
+const path = require('path');
+const graphDir = path.join('${workspace_path}', 'speccrew-workspace', 'knowledges', 'bizs', 'graph');
+const edgesFile = path.join(graphDir, 'edges.json');
+
+// Read existing edges or initialize empty array
+let existingEdges = [];
+if (fs.existsSync(edgesFile)) {
+  try {
+    existingEdges = JSON.parse(fs.readFileSync(edgesFile, 'utf8'));
+    if (!Array.isArray(existingEdges)) existingEdges = [];
+  } catch (e) {
+    existingEdges = [];
+  }
+}
+
+// Parse new edges from input
+const newEdges = [];
+if ('${navigatesEdges}') {
+  try {
+    const edges = JSON.parse('${navigatesEdges}');
+    if (Array.isArray(edges)) newEdges.push(...edges);
+  } catch (e) {}
+}
+if ('${containsEdges}') {
+  try {
+    const edges = JSON.parse('${containsEdges}');
+    if (Array.isArray(edges)) newEdges.push(...edges);
+  } catch (e) {}
+}
+if ('${callsApiEdges}') {
+  try {
+    const edges = JSON.parse('${callsApiEdges}');
+    if (Array.isArray(edges)) newEdges.push(...edges);
+  } catch (e) {}
+}
+
+// Deduplicate by composite key (source+target+type)
+const edgeMap = new Map();
+existingEdges.forEach(e => {
+  const key = (e.source || '') + '|' + (e.target || '') + '|' + (e.type || '');
+  edgeMap.set(key, e);
+});
+newEdges.forEach(e => {
+  const key = (e.source || '') + '|' + (e.target || '') + '|' + (e.type || '');
+  edgeMap.set(key, e);
+});
+
+// Write back
+fs.writeFileSync(edgesFile, JSON.stringify(Array.from(edgeMap.values()), null, 2));
+console.log('Edges appended:', newEdges.length);
+"
+    </field>
+  </block>
+
+  <block type="checkpoint" id="CP-graph" name="graph-written" desc="Graph data written">
+    <field name="verify" value="true"/>
+  </block>
+
   <block type="event" id="E10" action="log" level="info" desc="Log marker status">
-    <field name="message" value="Step 7 Status: COMPLETED - Done marker file written to ${completed_dir}/${markerName}.done.json"/>
+    <field name="message" value="Step 7 Status: COMPLETED - Done marker and graph data written to ${completed_dir}/${markerName}.done.json"/>
   </block>
 
-  <!-- ==================== FINAL OUTPUT ==================== -->
+  <!-- ==================== FINAL OUTPUT ================= === -->
   <block type="output" id="O1" desc="UI feature analysis output results">
     <field name="status" value="success"/>
     <field name="feature_name" from="${fileName}"/>

package/.speccrew/skills/speccrew-knowledge-graph-write/SKILL.md

@@ -25,7 +25,7 @@ Dispatch Agent (speccrew-knowledge-dispatch)
 | Variable | Type | Description | Example |
 |----------|------|-------------|---------|
 | `{{action}}` | string | Write action to perform | `"batch-write"`, `"init-module"`, `"update-node"`, `"remove-node"` |
-| `{{platformId}}` | string | Platform identifier for directory segregation | `"backend-system"`, `"backend-ai"`, `"web-vue"`, `"mobile-uniapp"` |
+| `{{platformId}}` | string | Platform identifier for directory segregation | `"backend-fastapi"`, `"backend-spring"`, `"web-vue"`, `"mobile-uniapp"` |
 | `{{module}}` | string | Target business module | `"system"`, `"trade"`, `"infra"` |
 | `{{graphData}}` | object | Graph data from skill output (for batch-write) | `{ "nodes": [...], "edges": [...] }` |
 | `{{nodeId}}` | string | Node ID (for update-node / remove-node) | `"api-system-user-list"` |

package/.speccrew/skills/speccrew-pm-module-initializer/SKILL.md

@@ -39,7 +39,7 @@ Generate analyze task plan for a single business module. Reads features-*.json,
 | `features_file` | string | Yes | Path to the platform's features-{platform}.json file |
 | `output_path` | string | Yes | Knowledge base output root path (e.g., speccrew-workspace/knowledges) |
 | `completed_dir` | string | Yes | Marker file output directory for api-analyze .done.json markers. Value from PM Agent: `{sync_state_bizs_dir}/completed` |
-| `sourceFile` | string | Yes | Features JSON filename (e.g., "features-backend-system.json"), used for api-analyze marking |
+| `sourceFile` | string | Yes | Features JSON filename (e.g., "features-backend-fastapi.json"), used for api-analyze marking |
 | `language` | string | Yes | Output language (zh / en) |
 | `workspace_path` | string | Yes | Workspace root path for constructing absolute paths |
 

package/.speccrew/skills/speccrew-pm-module-initializer/workflow.agentflow.xml

@@ -14,7 +14,7 @@
     <field name="features_file" required="true" type="string" desc="Path to the platform's features-{platform}.json file"/>
     <field name="output_path" required="true" type="string" desc="Knowledge base output root path"/>
     <field name="completed_dir" required="true" type="string" desc="Marker file output directory for api-analyze .done.json markers"/>
-    <field name="sourceFile" required="true" type="string" desc="Features JSON filename (e.g., features-backend-system.json)"/>
+    <field name="sourceFile" required="true" type="string" desc="Features JSON filename (e.g., features-backend-fastapi.json)"/>
     <field name="language" required="true" type="string" desc="Output language (zh / en)"/>
     <field name="workspace_path" required="true" type="string" desc="Workspace root path for constructing absolute paths"/>
   </block>

package/package.json

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