speccrew 0.7.10 → 0.7.11

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

@@ -155,6 +155,78 @@ function getBatch(args) {
   }
 }
 
+// Parse featureId to extract platformId, module, and fileName
+// featureId format: {platformId}-{module}-{fileNameWithoutExt}
+function parseFeatureId(featureId) {
+  const parts = featureId.split('-');
+  if (parts.length >= 3) {
+    const platformId = parts[0];
+    const module = parts[1];
+    const fileNameWithoutExt = parts.slice(2).join('-'); // Handle fileName with hyphens
+    return { platformId, module, fileNameWithoutExt };
+  }
+  return null;
+}
+
+// Update features JSON file with analysis results
+function updateFeaturesJson(syncStatePath, featureId, doneData) {
+  const parsed = parseFeatureId(featureId);
+  if (!parsed) {
+    console.error(JSON.stringify({ warning: `Cannot parse featureId: ${featureId}` }));
+    return false;
+  }
+  
+  const { platformId, module, fileNameWithoutExt } = parsed;
+  const featuresFilePath = path.join(syncStatePath, `features-${platformId}.json`);
+  
+  if (!fs.existsSync(featuresFilePath)) {
+    console.error(JSON.stringify({ warning: `Features file not found: ${featuresFilePath}` }));
+    return false;
+  }
+  
+  const featuresData = readJsonSafe(featuresFilePath);
+  if (!featuresData || !Array.isArray(featuresData.features)) {
+    console.error(JSON.stringify({ warning: `Invalid features data in: ${featuresFilePath}` }));
+    return false;
+  }
+  
+  // Find matching feature
+  let found = false;
+  for (const feature of featuresData.features) {
+    const featureFileName = feature.fileName || feature.sourceFile || 'unknown';
+    const featureFileNameWithoutExt = featureFileName.replace(/\.[^.]+$/, '');
+    
+    // Match by module and fileName (platformId already matched by filename)
+    if (feature.module === module && featureFileNameWithoutExt === fileNameWithoutExt) {
+      // Skip if already analyzed (idempotency)
+      if (feature.analyzed === true) {
+        found = true;
+        continue;
+      }
+      
+      // Update feature fields
+      feature.analyzed = true;
+      feature.startedAt = doneData.startedAt || doneData.timestamp || null;
+      feature.completedAt = doneData.completedAt || doneData.timestamp || null;
+      feature.analysisNotes = doneData.notes || 'completed';
+      found = true;
+    }
+  }
+  
+  if (!found) {
+    console.error(JSON.stringify({ warning: `Feature not found in ${featuresFilePath}: ${featureId}` }));
+    return false;
+  }
+  
+  // Update top-level counts
+  featuresData.analyzedCount = featuresData.features.filter(f => f.analyzed).length;
+  featuresData.pendingCount = featuresData.features.filter(f => !f.analyzed).length;
+  
+  // Write back to file (atomic write)
+  fs.writeFileSync(featuresFilePath, JSON.stringify(featuresData, null, 2));
+  return true;
+}
+
 // process-results subcommand
 function processResults(args) {
   const { syncStatePath, graphRoot, completedDir } = args;
@@ -165,9 +237,10 @@ function processResults(args) {
   let success = 0;
   let failed = 0;
   let graphUpdated = false;
+  let featuresUpdated = 0;
   
   if (!fs.existsSync(completedDir)) {
-    console.log(JSON.stringify({ success, failed, graphUpdated }));
+    console.log(JSON.stringify({ success, failed, graphUpdated, featuresUpdated }));
     return;
   }
   
@@ -178,14 +251,26 @@ function processResults(args) {
   for (const file of doneFiles) {
     const filePath = path.join(completedDir, file);
     const data = readJsonSafe(filePath);
+    
+    // Extract featureId from filename: {featureId}.done.json
+    const featureId = file.replace('.done.json', '');
+    
     if (data) {
       if (data.status === 'success' || data.status === 'completed') {
         success++;
+        // Update features JSON for successful analysis
+        if (updateFeaturesJson(syncStatePath, featureId, data)) {
+          featuresUpdated++;
+        }
       } else if (data.status === 'failed' || data.status === 'error') {
         failed++;
       } else {
         // Default to success if no status field
         success++;
+        // Update features JSON for successful analysis
+        if (updateFeaturesJson(syncStatePath, featureId, data)) {
+          featuresUpdated++;
+        }
       }
     } else {
       // Invalid JSON, assume success
@@ -260,7 +345,8 @@ function processResults(args) {
   console.log(JSON.stringify({
     success,
     failed,
-    graphUpdated
+    graphUpdated,
+    featuresUpdated
   }));
 }
 

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

@@ -63,13 +63,25 @@ function toRelativePath(absolutePath, projectRoot) {
   return normalizedAbs;
 }
 
+// Generate unique feature ID from source path
+// Converts path separators to hyphens, removes extension
+// e.g., 'src/views/bpm/form/data.ts' -> 'src-views-bpm-form-data'
+// e.g., 'ruoyi-fastapi-app/src/pages/common/agreement/index.vue' -> 'ruoyi-fastapi-app-src-pages-common-agreement-index'
+function generateFeatureId(relativeSourcePath) {
+  // Remove file extension
+  const pathWithoutExt = relativeSourcePath.replace(/\.[^.]+$/, '');
+  
+  // Replace path separators with hyphens
+  const id = pathWithoutExt.replace(/\//g, '-').replace(/\\/g, '-');
+  
+  return id;
+}
+
 // Generate document path for a feature
-// Format: speccrew-workspace/knowledges/bizs/{platformId}/{module}/{subpath}/{filename}.md
+// Format: speccrew-workspace/knowledges/bizs/{platformId}/{module}/{subpath}/{uniqueName}.md
+// The documentPath must be unique to avoid overwriting
 function generateDocumentPath(platformId, module, sourcePath, projectRoot) {
-  // Extract filename without extension
-  const basename = path.basename(sourcePath, path.extname(sourcePath));
-  
-  // Get directory relative to module root
+  // Get the relative path from project root
   const relativePath = toRelativePath(sourcePath, projectRoot);
   
   // Parse the source path to extract module and subpath
@@ -92,6 +104,22 @@ function generateDocumentPath(platformId, module, sourcePath, projectRoot) {
     subpath = pathParts.slice(moduleIndex + 1, pathParts.length - 1).join('/');
   }
   
+  // Extract filename without extension
+  const basename = path.basename(sourcePath, path.extname(sourcePath));
+  
+  // Generate unique document name to avoid collisions
+  // Use the path after module to create a unique name
+  let uniqueDocName;
+  if (moduleIndex >= 0 && moduleIndex < pathParts.length - 1) {
+    // Get all path parts after module (excluding extension)
+    const pathAfterModule = pathParts.slice(moduleIndex + 1);
+    // Join with hyphens to create unique name
+    uniqueDocName = pathAfterModule.join('-').replace(/\.[^.]+$/, '');
+  } else {
+    // Fallback: use basename
+    uniqueDocName = basename;
+  }
+  
   // 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];
@@ -100,7 +128,7 @@ function generateDocumentPath(platformId, module, sourcePath, projectRoot) {
     docPathParts.push(subpath);
   }
   
-  docPathParts.push(`${basename}.md`);
+  docPathParts.push(`${uniqueDocName}.md`);
   
   return docPathParts.join('/');
 }
@@ -203,10 +231,14 @@ function main() {
         const relativeSourcePath = toRelativePath(sourceFile, projectRoot);
         const fileName = path.basename(sourceFile, path.extname(sourceFile));
         
-        // Generate document path using platformId
+        // Generate unique feature ID based on full relative path
+        const featureId = generateFeatureId(relativeSourcePath);
+        
+        // Generate document path using platformId (now with unique filename)
         const documentPath = generateDocumentPath(platformId, moduleName, sourceFile, projectRoot);
         
         features.push({
+          id: featureId,
           fileName: fileName,
           sourcePath: relativeSourcePath,
           documentPath: documentPath,
@@ -227,6 +259,9 @@ function main() {
     });
   }
   
+  // Determine analysis method based on platform type
+  const analysisMethod = platformType === 'backend' ? 'api-based' : 'ui-based';
+  
   // Build output JSON
   const outputData = {
     platformName: platformName,
@@ -235,6 +270,7 @@ function main() {
     platformId: platformId,
     sourcePath: sourceRoot,
     techStack: techStack,
+    analysisMethod: analysisMethod,
     modules: modules,
     totalFiles: features.length,
     analyzedCount: 0,

package/package.json

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