speccrew 0.1.0

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

@@ -0,0 +1,26 @@
+const { spawnSync } = require('child_process');
+const path = require('path');
+
+const scriptPath = path.join(__dirname, 'generate-inventory.js');
+const sourcePath = 'd:/dev/speccrew/ruoyi-vue-pro/yudao-ui/yudao-ui-admin-vue3/src/views';
+
+// Build arguments array - avoids shell escaping issues
+const args = [
+  scriptPath,
+  '--sourcePath', sourcePath,
+  '--outputFileName', 'features-vue3.json',
+  '--platformName', 'Vue3 Admin',
+  '--platformType', 'web',
+  '--platformSubtype', 'vue3',
+  '--techStack', '["vue3","typescript"]',
+  '--fileExtensions', '[".vue",".ts"]',
+  '--analysisMethod', 'ui-based',
+  '--excludeDirs', '["components","composables","hooks","utils"]'
+];
+
+console.log('Testing generate-inventory.js...');
+const result = spawnSync(process.execPath, args, { encoding: 'utf8', stdio: 'inherit' });
+console.log('Exit code:', result.status);
+if (result.error) {
+  console.error('Error:', result.error.message);
+}

package/.speccrew/skills/speccrew-knowledge-bizs-module-classify/SKILL.md

@@ -0,0 +1,165 @@
+---
+name: speccrew-knowledge-bizs-module-classify
+description: Classify features into business modules by analyzing source code structure. Overrides directory-based module assignments from init-features with semantically meaningful business module groupings.
+tools: None
+---
+
+# Bizs Module Classify
+
+Reclassify features in `features-{platform}.json` files into proper business modules based on source code analysis.
+
+## Language Adaptation
+
+**CRITICAL**: All generated documents must match the user's language. Detect the language from the user's input and use it consistently.
+
+- User writes in 中文 → Generate Chinese content, use `language: "zh"`
+- User writes in English → Generate English content, use `language: "en"`
+- User writes in other languages → Use appropriate language code
+
+## Input
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `features_file` | Path to features-{platform}.json file (for reference only, Worker should NOT read it) | **REQUIRED** |
+| `source_path` | Source code root path for context | **REQUIRED** |
+| `module_summary` | JSON string containing module names, feature counts, and sample source paths (provided by dispatch via extract-module-summary.js) | **REQUIRED** |
+| `language` | User's language code (e.g., "zh", "en") | **REQUIRED** |
+
+## Output
+
+Worker MUST return a JSON result containing the module mapping (NOT modify the features file directly):
+
+```json
+{
+  "status": "success|failed",
+  "message": "description of reclassification",
+  "mapping": {
+    "old_module_1": "new_module_1",
+    "old_module_2": "new_module_2"
+  },
+  "modules_reclassified": N
+}
+```
+
+**IMPORTANT**: 
+- Only include modules that need to change in the `mapping` object
+- Modules that remain the same should NOT be listed
+- The `mapping` will be passed to `apply-module-mapping.js` by the dispatch agent to batch-update the features file
+- Worker MUST NOT modify the features file directly
+
+## Workflow
+
+> **CRITICAL CONSTRAINT**: This skill is a PURE REASONING task. DO NOT use any tools (Read, Write, Bash, terminal, etc.). DO NOT read files — the module summary is provided as input parameter `module_summary`. DO NOT modify any files — output a mapping JSON only.
+
+### Step 1: Parse Module Summary
+
+- Parse the `module_summary` JSON parameter (pre-processed by dispatch via extract-module-summary.js)
+- Extract: module names, feature counts per module, and sample source paths
+- Note: The summary contains compact data for LLM analysis, not the full features file
+
+### Step 2: Analyze Module Semantics
+
+- Analyze each module's `sampleSourcePaths` to identify business semantics
+- Identify logical business domains based on path patterns:
+
+**Path pattern analysis for web/mobile platforms:**
+- Examine sample paths under views/pages directories
+- Match directory naming patterns to business domains
+- Cross-reference with common business module patterns
+
+**Path pattern analysis for backend platforms:**
+- Examine controller/module directory patterns
+- Identify domain boundaries from package naming
+
+- Build a **business module map**: a list of logical business domains with descriptions
+  - Example: `system` (system management), `trade` (trade/order), `bpm` (business process), `infra` (infrastructure)
+
+### Step 3: Reclassify Modules
+
+- For each module in the `module_summary`:
+  - Analyze sample source paths and directory context
+  - Match to the most appropriate business module from the module map
+  - Determine if the module name needs to change
+
+**Naming rules:**
+- Use lowercase for module names (e.g., `system`, `trade`, `bpm`)
+- Use kebab-case for multi-word names (e.g., `order-management`)
+- Module names must reflect business domains, NOT page types or UI components
+
+**Classification rules:**
+- Modules clearly belonging to a business domain → use that domain name
+  - Example: `system/user` paths → module: `system`
+  - Example: `trade/order` paths → module: `trade`
+- Utility/common modules that don't belong to a specific domain → module: `_common`
+  - Example: `Error` module → module: `_common`
+  - Example: `Home` module → module: `_common`
+  - Example: `Redirect` module → module: `_common`
+- Login/authentication modules → module: `system` (or domain-appropriate)
+  - Example: `Login` module → module: `system`
+
+**Validation:**
+- Every module in the mapping must have a valid business domain name
+- No page-type module names should remain as values (Error, Login, Home, Profile, Redirect)
+- All new module names are lowercase or kebab-case
+
+### Step 4: Output Module Mapping
+
+> **CRITICAL CONSTRAINT**: This skill produces a module mapping as output only. DO NOT modify the features JSON file. DO NOT create any temporary scripts or files. The dispatch agent will apply the mapping using the `apply-module-mapping.js` script.
+
+Based on the reclassification analysis, construct and return the mapping result:
+
+1. **Build the mapping object**: For each module that needs to change:
+   - Key: original module name (directory-based)
+   - Value: new business module name
+   - Example: `{ "Error": "_common", "Login": "system" }`
+
+2. **Count reclassified features**: Calculate total number of features that will be affected by this mapping
+
+3. **Return the JSON result**:
+   ```json
+   {
+     "status": "success",
+     "message": "Reclassified 12 features from 5 directory modules to 4 business modules",
+     "mapping": {
+       "Error": "_common",
+       "Home": "_common",
+       "Login": "system",
+       "Profile": "_common",
+       "Redirect": "_common"
+     },
+     "modules_reclassified": 12
+   }
+   ```
+
+**Validation before returning**:
+- Every mapping key-value pair has non-empty values
+- No page-type module names remain as values (Error, Login, Home, Profile, Redirect should not appear as values)
+- All new module names are lowercase or kebab-case
+- `modules_reclassified` count is accurate
+
+## Return
+
+```json
+{
+  "status": "success",
+  "message": "Reclassified 12 features from 5 directory modules to 4 business modules",
+  "mapping": {
+    "Error": "_common",
+    "Home": "_common",
+    "Login": "system",
+    "Profile": "_common",
+    "Redirect": "_common"
+  },
+  "modules_reclassified": 12
+}
+```
+
+## Checklist
+
+- [ ] All modules from `module_summary` are analyzed
+- [ ] No page-type module names remain in mapping values (Error, Login, Home, Profile, Redirect)
+- [ ] All new module names in mapping are lowercase or kebab-case
+- [ ] Only modules that need to change are included in the `mapping` object
+- [ ] `modules_reclassified` count is accurate
+- [ ] Worker did NOT use any tools (Read, Write, Bash, terminal)
+- [ ] Worker did NOT modify any files directly

package/.speccrew/skills/speccrew-knowledge-bizs-module-classify/scripts/apply-module-mapping.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+
+/**
+ * Apply Module Mapping Script
+ * 
+ * Updates features JSON file based on module mapping.
+ * Supports both JSON and key:value comma-separated format for mapping parameter.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs() {
+  const args = {};
+  const argv = process.argv.slice(2);
+  
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      const value = argv[i + 1] && !argv[i + 1].startsWith('--') ? argv[i + 1] : '';
+      args[key] = value;
+      if (value) i++;
+    }
+  }
+  
+  return args;
+}
+
+/**
+ * Parse mapping parameter - supports both JSON and key:value comma-separated format
+ * JSON: '{"auth":"authentication","util":"_common"}'
+ * Key-value: "auth:authentication,util:_common"  (recommended for PowerShell)
+ */
+function parseMapping(value) {
+  if (!value) return {};
+  
+  const trimmed = value.trim();
+  
+  // Try JSON format first
+  if (trimmed.startsWith('{')) {
+    try {
+      return JSON.parse(trimmed);
+    } catch (e) {
+      // JSON parse failed, fall through to key:value parsing
+    }
+  }
+  
+  // Parse comma-separated key:value pairs
+  const result = {};
+  trimmed.split(',').forEach(pair => {
+    const separatorIndex = pair.indexOf(':');
+    if (separatorIndex > 0) {
+      const key = pair.slice(0, separatorIndex).trim();
+      const val = pair.slice(separatorIndex + 1).trim();
+      if (key && val) {
+        result[key] = val;
+      }
+    }
+  });
+  
+  return result;
+}
+
+/**
+ * Output error and exit
+ */
+function exitError(message) {
+  console.error(JSON.stringify({
+    status: 'error',
+    message: message
+  }, null, 2));
+  process.exit(1);
+}
+
+/**
+ * Main function
+ */
+function main() {
+  const args = parseArgs();
+  
+  // Validate required parameters
+  if (!args.featuresFile) {
+    exitError('Missing required parameter: --featuresFile');
+  }
+  if (!args.mapping) {
+    exitError('Missing required parameter: --mapping');
+  }
+  if (!args.platformId) {
+    exitError('Missing required parameter: --platformId');
+  }
+  
+  const featuresFile = args.featuresFile;
+  const platformId = args.platformId;
+  
+  // Parse mapping
+  const mapping = parseMapping(args.mapping);
+  if (Object.keys(mapping).length === 0) {
+    exitError('Failed to parse mapping parameter. Expected JSON or key:value comma-separated format.');
+  }
+  
+  // Read features file
+  let featuresData;
+  try {
+    const content = fs.readFileSync(featuresFile, 'utf-8');
+    featuresData = JSON.parse(content);
+  } catch (e) {
+    if (e.code === 'ENOENT') {
+      exitError(`Features file not found: ${featuresFile}`);
+    } else if (e instanceof SyntaxError) {
+      exitError(`Invalid JSON in features file: ${e.message}`);
+    } else {
+      exitError(`Failed to read features file: ${e.message}`);
+    }
+  }
+  
+  // Validate features data structure
+  if (!featuresData || typeof featuresData !== 'object') {
+    exitError('Invalid features data: expected object');
+  }
+  if (!Array.isArray(featuresData.features)) {
+    exitError('Invalid features data: missing or invalid features array');
+  }
+  
+  // Store original modules for comparison
+  const modulesBefore = [...(featuresData.modules || [])];
+  
+  // Track reclassification count
+  let reclassifiedCount = 0;
+  const reclassifiedModules = new Set();
+  
+  // Process all features
+  const updatedFeatures = featuresData.features.map(feature => {
+    const oldModule = feature.module;
+    
+    // Check if this feature's module needs to be updated
+    if (oldModule && mapping.hasOwnProperty(oldModule)) {
+      const newModule = mapping[oldModule];
+      reclassifiedCount++;
+      reclassifiedModules.add(oldModule);
+      
+      // Rebuild documentPath（使用 fileName 而非 feature.id，避免文件名过长）
+      const newDocumentPath = `speccrew-workspace/knowledges/bizs/${platformId}/${newModule}/${feature.fileName}.md`;
+      
+      return {
+        ...feature,
+        module: newModule,
+        documentPath: newDocumentPath
+      };
+    }
+    
+    return feature;
+  });
+  
+  // Rebuild modules array (unique and sorted)
+  const allModules = new Set();
+  updatedFeatures.forEach(feature => {
+    if (feature.module) {
+      allModules.add(feature.module);
+    }
+  });
+  const modulesAfter = Array.from(allModules).sort();
+  
+  // Calculate analyzed and pending counts
+  const analyzedCount = updatedFeatures.filter(f => f.analyzed === true).length;
+  const pendingCount = updatedFeatures.length - analyzedCount;
+  
+  // Build updated data
+  const updatedData = {
+    ...featuresData,
+    features: updatedFeatures,
+    modules: modulesAfter,
+    analyzedCount: analyzedCount,
+    pendingCount: pendingCount,
+    updatedAt: new Date().toISOString()
+  };
+  
+  // Preserve createdAt if it exists
+  if (!updatedData.createdAt) {
+    updatedData.createdAt = featuresData.updatedAt || new Date().toISOString();
+  }
+  
+  // Write back to file
+  try {
+    fs.writeFileSync(featuresFile, JSON.stringify(updatedData, null, 2), 'utf-8');
+  } catch (e) {
+    exitError(`Failed to write features file: ${e.message}`);
+  }
+  
+  // Output result
+  const result = {
+    status: 'success',
+    modules_before: modulesBefore,
+    modules_after: modulesAfter,
+    reclassified_count: reclassifiedCount,
+    total_features: updatedFeatures.length,
+    mapping_applied: mapping
+  };
+  
+  console.log(JSON.stringify(result, null, 2));
+  process.exit(0);
+}
+
+// Run main function
+main();

package/.speccrew/skills/speccrew-knowledge-bizs-module-classify/scripts/extract-module-summary.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+
+/**
+ * Extract Module Summary Script
+ * 
+ * Extracts compact module summary from features JSON for LLM inference.
+ * Run by Dispatch before delegating to Worker.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs() {
+  const args = {};
+  const argv = process.argv.slice(2);
+  
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      const value = argv[i + 1] && !argv[i + 1].startsWith('--') ? argv[i + 1] : '';
+      args[key] = value;
+      if (value) i++;
+    }
+  }
+  
+  return args;
+}
+
+/**
+ * Output error to stderr and exit with code 1
+ */
+function exitError(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+/**
+ * Get the technology layer from a source path
+ * Returns: 'controller', 'service', 'dal', 'api', 'manager', 'convert', or 'other'
+ */
+function getTechLayer(sourcePath) {
+  if (!sourcePath) return 'other';
+  
+  const lowerPath = sourcePath.toLowerCase();
+  
+  // Check for common tech layer directories
+  if (lowerPath.includes('/controller/') || lowerPath.includes('\\controller\\')) return 'controller';
+  if (lowerPath.includes('/service/') || lowerPath.includes('\\service\\')) return 'service';
+  if (lowerPath.includes('/dal/') || lowerPath.includes('\\dal\\')) return 'dal';
+  if (lowerPath.includes('/api/') || lowerPath.includes('\\api\\')) return 'api';
+  if (lowerPath.includes('/manager/') || lowerPath.includes('\\manager\\')) return 'manager';
+  if (lowerPath.includes('/convert/') || lowerPath.includes('\\convert\\')) return 'convert';
+  
+  return 'other';
+}
+
+/**
+ * Select representative sample paths for a module
+ * Prioritizes different tech layers (controller, service, dal, etc.)
+ * Returns max 3 paths
+ */
+function selectSamplePaths(features) {
+  // Group paths by tech layer
+  const layers = {
+    controller: [],
+    service: [],
+    dal: [],
+    api: [],
+    manager: [],
+    convert: [],
+    other: []
+  };
+  
+  for (const feature of features) {
+    const sourcePath = feature.sourcePath;
+    if (!sourcePath) continue;
+    
+    const layer = getTechLayer(sourcePath);
+    layers[layer].push(sourcePath);
+  }
+  
+  // Select up to 3 samples, prioritizing different layers
+  // Priority: controller > service > dal > api > manager > convert > other
+  const priorityOrder = ['controller', 'service', 'dal', 'api', 'manager', 'convert', 'other'];
+  const selected = [];
+  
+  for (const layer of priorityOrder) {
+    if (layers[layer].length > 0 && selected.length < 3) {
+      // Take the first path from this layer
+      selected.push(layers[layer][0]);
+    }
+    if (selected.length >= 3) break;
+  }
+  
+  return selected;
+}
+
+/**
+ * Main function
+ */
+function main() {
+  const args = parseArgs();
+  
+  // Validate required parameter
+  if (!args.featuresFile) {
+    exitError('Error: Missing required parameter --featuresFile');
+  }
+  
+  const featuresFile = args.featuresFile;
+  
+  // Read features file
+  let featuresData;
+  try {
+    const content = fs.readFileSync(featuresFile, 'utf-8');
+    featuresData = JSON.parse(content);
+  } catch (e) {
+    if (e.code === 'ENOENT') {
+      exitError(`Error: Features file not found: ${featuresFile}`);
+    } else if (e instanceof SyntaxError) {
+      exitError(`Error: Invalid JSON in features file: ${e.message}`);
+    } else {
+      exitError(`Error: Failed to read features file: ${e.message}`);
+    }
+  }
+  
+  // Validate features data structure
+  if (!featuresData || typeof featuresData !== 'object') {
+    exitError('Error: Invalid features data: expected object');
+  }
+  if (!Array.isArray(featuresData.features)) {
+    exitError('Error: Invalid features data: missing or invalid features array');
+  }
+  
+  // Extract platform info from features data
+  const platformType = featuresData.platformType || 'unknown';
+  const platformSubtype = featuresData.platformSubtype || 'unknown';
+  
+  // Group features by module
+  const moduleGroups = {};
+  for (const feature of featuresData.features) {
+    const moduleName = feature.module || '_unclassified';
+    if (!moduleGroups[moduleName]) {
+      moduleGroups[moduleName] = [];
+    }
+    moduleGroups[moduleName].push(feature);
+  }
+  
+  // Build module summaries
+  const modules = [];
+  for (const [moduleName, features] of Object.entries(moduleGroups)) {
+    const summary = {
+      name: moduleName,
+      featureCount: features.length,
+      sampleSourcePaths: selectSamplePaths(features)
+    };
+    modules.push(summary);
+  }
+  
+  // Sort by featureCount descending
+  modules.sort((a, b) => b.featureCount - a.featureCount);
+  
+  // Build output
+  const output = {
+    platformType: platformType,
+    platformSubtype: platformSubtype,
+    totalFeatures: featuresData.features.length,
+    modules: modules
+  };
+  
+  // Output JSON to stdout
+  console.log(JSON.stringify(output, null, 2));
+  process.exit(0);
+}
+
+// Run main function
+main();