speccrew 0.6.5 → 0.6.6

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

@@ -172,61 +172,29 @@ flowchart TB
 
 ---
 
-## Stage 1a: Entry Directory Recognition (LLM-Driven)
+## Stage 1a: Entry Directory Recognition
 
-**Goal**: For each detected platform, use LLM to analyze the source directory tree and identify all entry directories (API controllers for backend, views/pages for frontend), then classify them into business modules.
+**Goal**: For each detected platform, analyze the source directory tree and identify all entry directories (API controllers for backend, views/pages for frontend), then classify them into business modules.
 
-> **IMPORTANT**: This stage is executed **directly by the dispatch agent (Leader)** using LLM analysis capabilities (Read/ListDir/Grep), NOT delegated to a Worker Agent.
+> **IMPORTANT**: This stage is executed **directly by the dispatch agent (Leader)**, NOT delegated to a Worker Agent.
 
 **Prerequisite**: Stage 0 completed. Platform list confirmed with `platformId`, `sourcePath`, `platformType`, `platformSubtype`, and `techIdentifier` for each platform.
 
-**Execution Flow** (for each platform):
-
-### Step 1: Read Directory Tree
-
-Use `ListDir` or `Bash(tree)` to read the platform's `{source_path}` directory structure (3 levels deep):
-
-```bash
-# Windows (PowerShell)
-tree /F /A "{source_path}" | Select-Object -First 100
-
-# Unix/Linux/Mac
-tree -L 3 "{source_path}"
-```
-
-### Step 2: LLM Analysis - Identify Entry Directories
+**Execution**: Follow the `speccrew-knowledge-bizs-identify-entries` skill workflow:
 
-Based on the directory tree and technology stack, analyze and identify entry directories:
+1. For each platform, read the source directory tree (3 levels deep)
+2. Identify entry directories based on platform type:
+   - **Backend (Spring/Java/Kotlin)**: Find directories containing `*Controller.java` or `*Controller.kt` files. Module name = business package name of the entry directory
+   - **Frontend (Vue/React)**: Find `views/` or `pages/` directories. First-level subdirectories = business modules
+   - **Mobile (UniApp)**: Find first-level subdirectories under `pages/` + top-level `pages-*` directories
+   - **Mobile (Mini Program)**: Find first-level subdirectories under `pages/`
+3. Apply exclusion rules from `tech-stack-mappings.json` (technical dirs, build dirs, test dirs, config dirs)
+4. Generate `entry-dirs-{platform_id}.json` files
+5. Validate: modules array non-empty, module names are business-meaningful
 
-**Backend (Spring/Java/Kotlin)**:
-- Find all directories containing `*Controller.java` or `*Controller.kt` files
-- These are API entry directories
-- Module name = the business package name of the entry directory (e.g., `controller/admin/chat` → module `chat`)
+> For detailed entry identification logic, exclusion rules, JSON format, and validation rules, refer to the `speccrew-knowledge-bizs-identify-entries` skill documentation.
 
-**Frontend (Vue/React)**:
-- Find `views/` or `pages/` directories
-- First-level subdirectories under these directories are business modules
-- Each subdirectory is an entry directory (e.g., `views/system/` → module `system`)
-
-**Mobile (UniApp)**:
-- Find first-level subdirectories under `pages/`
-- Plus top-level `pages-*` directories (module name = directory name without `pages-` prefix, e.g., `pages-bpm` → module `bpm`)
-
-**Mobile (Mini Program)**:
-- Find first-level subdirectories under `pages/` as modules
-
-**Exclusion Rules** (directories to ignore):
-- Pure technical directories: `config`, `framework`, `enums`, `exception`, `util`, `utils`, `common`, `constant`, `constants`, `type`, `types`, `dto`, `vo`, `entity`, `model`, `mapper`, `repository`, `dao`, `service`, `impl`
-- Build/output directories: `dist`, `build`, `target`, `out`, `node_modules`
-- Test directories: `test`, `tests`, `spec`, `__tests__`, `e2e`
-- Configuration directories: `.git`, `.idea`, `.vscode`, `.speccrew`
-
-**Root Module Handling**:
-- If an entry file is not under any subdirectory (directly under `{source_path}`), assign it to the `_root` module
-
-### Step 3: Generate entry-dirs JSON
-
-Output file: `{speccrew_workspace}/knowledges/base/sync-state/knowledge-bizs/entry-dirs-{platform_id}.json`
+**Output**: `{speccrew_workspace}/knowledges/base/sync-state/knowledge-bizs/entry-dirs-{platform_id}.json`
 
 **JSON Format**:
 ```json
@@ -239,37 +207,11 @@ Output file: `{speccrew_workspace}/knowledges/base/sync-state/knowledge-bizs/ent
   "techStack": ["spring-boot", "mybatis-plus"],
   "modules": [
     { "name": "chat", "entryDirs": ["controller/admin/chat"] },
-    { "name": "image", "entryDirs": ["controller/admin/image"] },
-    { "name": "knowledge", "entryDirs": ["controller/admin/knowledge"] },
-    { "name": "_root", "entryDirs": ["controller/admin"] }
+    { "name": "image", "entryDirs": ["controller/admin/image"] }
   ]
 }
 ```
 
-**Field Definitions**:
-- `platformId`: Platform identifier (e.g., `backend-ai`, `web-vue`, `mobile-uniapp`)
-- `platformName`: (Optional) Human-readable platform name. Auto-generated as `{platform_type}-{platform_subtype}` if missing
-- `platformType`: (Optional) Platform type: `backend`, `web`, `mobile`, `desktop`. Inferred from platform_id if missing
-- `platformSubtype`: (Optional) Platform subtype (e.g., `ai`, `vue`, `uniapp`). Inferred from platform_id if missing
-- `sourcePath`: Absolute path to the platform source root
-- `techStack`: (Optional) Array of tech stack names (e.g., `["spring-boot", "mybatis-plus"]`). Default inferred from platform_type
-- `modules`: Array of business modules
-  - `name`: Module name (business-meaningful, e.g., `chat`, `system`, `order`)
-  - `entryDirs`: Array of entry directory paths (relative to `{source_path}`)
-
-**Path Rules**:
-- All `entryDirs` paths must be relative to `{source_path}`
-- Use forward slashes `/` as path separators (even on Windows)
-- Do not include leading or trailing slashes
-
-### Step 4: Validation
-
-After generating the entry-dirs JSON:
-1. Verify that `modules` array is not empty
-2. Verify that each module has at least one entry directory
-3. Verify that module names are business-meaningful (not technical terms like `config`, `util`)
-4. If validation fails, re-analyze the directory tree
-
 **Error handling**: If entry directory recognition fails for a platform, STOP and report the error with platform details. Do NOT proceed to Stage 1b for that platform.
 
 ---

package/.speccrew/skills/speccrew-knowledge-bizs-identify-entries/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: speccrew-knowledge-bizs-identify-entries
+description: Analyze source directory structures to identify business module entry directories for each platform. Use when initializing or updating business knowledge base to determine which directories contain user-facing entry points.
+tools: Read, Write, Glob, Grep, Bash
+---
+
+# speccrew-knowledge-bizs-identify-entries
+
+Analyze source directory structures to identify business module entry directories for each platform.
+
+## Input Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `{platforms}` | array | Yes | Platform list from detection phase. Each item: `{platformId, sourcePath, platformType, platformSubtype, techStack}` |
+| `{workspace_path}` | string | Yes | Path to speccrew-workspace directory |
+
+## Output
+
+For each platform, generates:
+- `{workspace_path}/knowledges/base/sync-state/knowledge-bizs/entry-dirs-{platform_id}.json`
+
+## Workflow
+
+### Step 1: Read Directory Tree
+
+Use `Glob` or `Bash(tree)` to read each platform's `{sourcePath}` directory structure (3 levels deep):
+
+```bash
+# Windows (PowerShell)
+tree /F /A "{source_path}" | Select-Object -First 100
+
+# Unix/Linux/Mac
+tree -L 3 "{source_path}"
+```
+
+### Step 2: LLM Analysis - Identify Entry Directories
+
+Based on the directory tree and technology stack, analyze and identify entry directories for each platform type:
+
+**Backend (Spring/Java/Kotlin)**:
+- Find all directories containing `*Controller.java` or `*Controller.kt` files
+- These are API entry directories
+- Module name = the business package name of the entry directory (e.g., `controller/admin/chat` → module `chat`)
+
+**Frontend (Vue/React)**:
+- Find `views/` or `pages/` directories
+- First-level subdirectories under these directories are business modules
+- Each subdirectory is an entry directory (e.g., `views/system/` → module `system`)
+
+**Mobile (UniApp)**:
+- Find first-level subdirectories under `pages/`
+- Plus top-level `pages-*` directories (module name = directory name without `pages-` prefix, e.g., `pages-bpm` → module `bpm`)
+
+**Mobile (Mini Program)**:
+- Find first-level subdirectories under `pages/` as modules
+
+### Step 3: Load Exclusion Rules
+
+Read `{workspace_path}/docs/configs/tech-stack-mappings.json` to load exclusion patterns. Apply the following exclusion rules:
+
+**Pure Technical Directories**:
+`config`, `framework`, `enums`, `exception`, `util`, `utils`, `common`, `constant`, `constants`, `type`, `types`, `dto`, `vo`, `entity`, `model`, `mapper`, `repository`, `dao`, `service`, `impl`
+
+**Build/Output Directories**:
+`dist`, `build`, `target`, `out`, `node_modules`
+
+**Test Directories**:
+`test`, `tests`, `spec`, `__tests__`, `e2e`
+
+**Configuration Directories**:
+`.git`, `.idea`, `.vscode`, `.speccrew`
+
+**Root Module Handling**:
+- If an entry file is not under any subdirectory (directly under `{sourcePath}`), assign it to the `_root` module
+
+### Step 4: Generate entry-dirs JSON
+
+Output file: `{workspace_path}/knowledges/base/sync-state/knowledge-bizs/entry-dirs-{platform_id}.json`
+
+**JSON Format**:
+```json
+{
+  "platformId": "backend-ai",
+  "platformName": "AI Module Backend",
+  "platformType": "backend",
+  "platformSubtype": "ai",
+  "sourcePath": "yudao-module-ai/src/main/java/cn/iocoder/yudao/module/ai",
+  "techStack": ["spring-boot", "mybatis-plus"],
+  "modules": [
+    { "name": "chat", "entryDirs": ["controller/admin/chat"] },
+    { "name": "image", "entryDirs": ["controller/admin/image"] },
+    { "name": "knowledge", "entryDirs": ["controller/admin/knowledge"] },
+    { "name": "_root", "entryDirs": ["controller/admin"] }
+  ]
+}
+```
+
+**Field Definitions**:
+- `platformId`: Platform identifier (e.g., `backend-ai`, `web-vue`, `mobile-uniapp`)
+- `platformName`: (Optional) Human-readable platform name. Auto-generated as `{platform_type}-{platform_subtype}` if missing
+- `platformType`: (Optional) Platform type: `backend`, `web`, `mobile`, `desktop`. Inferred from platform_id if missing
+- `platformSubtype`: (Optional) Platform subtype (e.g., `ai`, `vue`, `uniapp`). Inferred from platform_id if missing
+- `sourcePath`: Absolute path to the platform source root
+- `techStack`: (Optional) Array of tech stack names (e.g., `["spring-boot", "mybatis-plus"]`). Default inferred from platform_type
+- `modules`: Array of business modules
+  - `name`: Module name (business-meaningful, e.g., `chat`, `system`, `order`)
+  - `entryDirs`: Array of entry directory paths (relative to `{source_path}`)
+
+**Path Rules**:
+- All `entryDirs` paths must be relative to `{sourcePath}`
+- Use forward slashes `/` as path separators (even on Windows)
+- Do not include leading or trailing slashes
+
+### Step 5: Validation
+
+After generating the entry-dirs JSON for each platform:
+1. Verify that `modules` array is not empty
+2. Verify that each module has at least one entry directory
+3. Verify that module names are business-meaningful (not technical terms like `config`, `util`)
+4. If validation fails, re-analyze the directory tree
+
+**Error Handling**:
+If entry directory recognition fails for a platform, STOP and report the error with platform details. Do NOT continue processing that platform.
+
+## Checklist
+
+- [ ] All platforms' entry-dirs JSON files have been generated
+- [ ] Each platform's `modules` array is non-empty
+- [ ] Module names have business meaning (not technical terms like config, util)
+- [ ] `entryDirs` paths are correct and accessible
+- [ ] JSON format is valid
+
+## Example Usage
+
+```
+Skill: speccrew-knowledge-bizs-identify-entries
+Args:
+  platforms: [
+    {
+      "platformId": "backend-ai",
+      "sourcePath": "/path/to/yudao-module-ai/src/main/java/cn/iocoder/yudao/module/ai",
+      "platformType": "backend",
+      "platformSubtype": "ai",
+      "techStack": ["spring-boot", "mybatis-plus"]
+    },
+    {
+      "platformId": "web-vue",
+      "sourcePath": "/path/to/yudao-ui-admin/src",
+      "platformType": "web",
+      "platformSubtype": "vue",
+      "techStack": ["vue3", "element-plus"]
+    }
+  ]
+  workspace_path: "/path/to/speccrew-workspace"
+```

package/.speccrew/skills/speccrew-knowledge-bizs-init-features/SKILL.md

@@ -20,7 +20,7 @@ tools: Read, Write, Glob, Grep, SearchCodebase, Skill, Bash
 ```mermaid
 flowchart TD
     Start([Start]) --> Step1[Step 1: Identify Platforms]
-    Step1 --> Step2[Step 2: Configure Platform Parameters]
+    Step1 --> Step2[Step 2: Identify Entry Directories]
     Step2 --> Step3[Step 3: Execute Inventory Scripts]
     Step3 --> Step4[Step 4: Report Results]
     Step4 --> End([End])
@@ -52,26 +52,39 @@ flowchart TD
 - Lookup `platform-mapping.json`: `web` + `vue` → `platform_type=web`, `platform_subtype=vue`
 - Lookup `tech-stack-mappings.json`: vue → extensions=[".vue"], exclude_dirs=["components","utils"]
 
-### Step 2: Configure Platform Parameters
+### Step 2: Identify Entry Directories
 
-For each detected platform, configure the following parameters:
+For each platform detected in Step 1, identify business module entry directories.
 
-| Parameter | Description | Example |
-|-----------|-------------|---------|
-| `SourcePath` | Source directory relative to project root | `frontend-web/src/views` |
-| `OutputFileName` | Output file name | `features-web.json` |
-| `PlatformName` | Human-readable platform name | `Web Frontend` |
-| `PlatformType` | Platform category | `web`, `mobile`, `backend`, `desktop` |
-| `PlatformSubtype` | Technology/framework | `vue`, `react`, `flutter`, `spring` |
-| `TechStack` | Technology stack array | `["vue", "typescript"]` |
-| `FileExtensions` | File extensions to scan | `[".vue", ".ts"]` |
-| `ExcludeDirs` | Directories to exclude | `["components", "utils"]` |
+**Option A: Invoke Skill (Recommended)**
+
+Dispatch Worker with `speccrew-knowledge-bizs-identify-entries` skill:
+
+| Parameter | Value |
+|-----------|-------|
+| `platforms` | Platform list from Step 1 (each with platformId, sourcePath, platformType, platformSubtype, techStack) |
+| `workspace_path` | `speccrew-workspace` |
+
+Worker generates `entry-dirs-{platform_id}.json` files in `{workspace_path}/knowledges/base/sync-state/knowledge-bizs/`.
+
+**Option B: Direct Execution**
+
+If executing directly (without Worker dispatch), follow the same logic as the `speccrew-knowledge-bizs-identify-entries` skill:
+1. Read each platform's directory tree (3 levels deep)
+2. Identify entry directories based on platform type:
+   - **Backend**: Find directories containing `*Controller.*` files, extract business package names
+   - **Frontend**: Find `views/` or `pages/` directories, use first-level subdirectories as modules
+   - **Mobile**: Find `pages/` subdirectories + top-level `pages-*` directories
+3. Apply exclusion rules from `tech-stack-mappings.json`
+4. Generate `entry-dirs-{platform_id}.json` files
+
+**Verification**: Confirm each entry-dirs JSON has non-empty `modules` array with business-meaningful names.
 
 ### Step 3: Execute Inventory Scripts
 
 > **MANDATORY**: You MUST execute the provided scripts via `run_in_terminal`. DO NOT use `read_file`, `search_codebase`, `Glob`, or any other tool to substitute script execution. DO NOT manually scan files and construct JSON output yourself.
 
-Execute the inventory script for each platform:
+Execute the inventory script for each platform using the entry-dirs JSON from Step 2:
 
 **Prerequisites:**
 - Node.js 14.0+
@@ -79,94 +92,26 @@ Execute the inventory script for each platform:
 **Script Location (relative to this skill's directory):**
 - All Platforms: `{skill_path}/scripts/generate-inventory.js`
 
-**Example - Web Platform (Vue):**
+**Execution Command:**
 ```bash
-node "scripts/generate-inventory.js" \
-  --sourcePath "frontend-web/src/views" \
-  --outputFileName "features-web.json" \
-  --platformName "Web Frontend" \
-  --platformType "web" \
-  --platformSubtype "vue" \
-  --techStack "vue,typescript" \
-  --fileExtensions ".vue" \
-  --excludeDirs "components,composables,hooks,utils"
+node "{skill_path}/scripts/generate-inventory.js" --entryDirsFile "{entry_dirs_file_path}"
 ```
 
-**Example - Mobile Platform (UniApp):**
-```bash
-node "scripts/generate-inventory.js" \
-  --sourcePath "frontend-mobile/pages" \
-  --outputFileName "features-mobile.json" \
-  --platformName "Mobile App" \
-  --platformType "mobile" \
-  --platformSubtype "uniapp" \
-  --techStack "uniapp,vue" \
-  --fileExtensions ".vue" \
-  --excludeDirs "components,utils"
-```
+Where `{entry_dirs_file_path}` is the full path to the `entry-dirs-{platform_id}.json` file generated in Step 2.
 
-**Example - Backend Platform (Spring Single Module):**
+**Example:**
 ```bash
-node "scripts/generate-inventory.js" \
-  --sourcePath "backend/src/main/java/com/example/controller" \
-  --outputFileName "features-backend.json" \
-  --platformName "Backend API" \
-  --platformType "backend" \
-  --platformSubtype "spring" \
-  --techStack "spring-boot,java" \
-  --fileExtensions ".java" \
-  --excludeDirs ""
-```
-
-**Example - Backend Platform (Spring Multi-Module):**
+# Execute for each platform's entry-dirs file
+node "scripts/generate-inventory.js" --entryDirsFile "d:/project/speccrew-workspace/knowledges/base/sync-state/knowledge-bizs/entry-dirs-backend-system.json"
 
-> **IMPORTANT for Java/Kotlin backends**: Set `sourcePath` to the Java package root directory (e.g., `yudao-module-system/src/main/java/cn/iocoder/yudao/module/system`), NOT the module root. This ensures the `getModuleName` function extracts business module names (like `dept`, `auth`) instead of Java package segments (like `src`, `cn`).
-
-For projects with multiple backend modules (e.g., ruoyi-vue-pro), execute the script once per module:
-
-```bash
-# Module 1: AI
-node "scripts/generate-inventory.js" \
-  --sourcePath "yudao-module-ai/src/main/java/cn/iocoder/yudao/module/ai" \
-  --outputFileName "features-backend-ai.json" \
-  --platformName "Backend API - AI Module" \
-  --platformType "backend" \
-  --platformSubtype "ai" \
-  --techIdentifier "spring" \
-  --techStack "spring-boot,java" \
-  --fileExtensions ".java" \
-  --excludeDirs ""
-
-# Module 2: System
-node "scripts/generate-inventory.js" \
-  --sourcePath "yudao-module-system/src/main/java/cn/iocoder/yudao/module/system" \
-  --outputFileName "features-backend-system.json" \
-  --platformName "Backend API - System Module" \
-  --platformType "backend" \
-  --platformSubtype "system" \
-  --techIdentifier "spring" \
-  --techStack "spring-boot,java" \
-  --fileExtensions ".java" \
-  --excludeDirs ""
+node "scripts/generate-inventory.js" --entryDirsFile "d:/project/speccrew-workspace/knowledges/base/sync-state/knowledge-bizs/entry-dirs-web-vue.json"
 ```
 
-> **Note**: For multi-module backend projects, prefer per-module execution (above) over scan-all to get proper module-level directory isolation (e.g., `backend-ai/`, `backend-system/`).
-
-**Alternative: Scan All Modules at Once**
-
-If all modules share the same parent directory structure, you can scan from the project root:
-
-```bash
-node "scripts/generate-inventory.js" \
-  --sourcePath "." \
-  --outputFileName "features-backend-all.json" \
-  --platformName "Backend API - All Modules" \
-  --platformType "backend" \
-  --platformSubtype "spring" \
-  --techStack "spring-boot,java" \
-  --fileExtensions ".java" \
-  --excludeDirs "test,target,.git"
-```
+**Script Parameters**:
+- `--entryDirsFile`: (Required) Path to the `entry-dirs-{platform_id}.json` file generated in Step 2
+- `--techIdentifier`: (Optional) Technology identifier for tech-stack lookup (auto-detected from platform mapping if omitted)
+- `--fileExtensions`: (Optional) Comma-separated list of file extensions to include
+- `--excludeDirs`: (Optional) Additional directories to exclude
 
 **Output: `features-{platform}.json` Structure:**
 ```json
@@ -175,7 +120,10 @@ node "scripts/generate-inventory.js" \
   "platformType": "web",
   "sourcePath": "frontend-web/src/views",
   "techStack": ["vue", "typescript"],
-  "modules": ["system", "trade", "infra"],
+  "modules": [
+    { "name": "chat", "featureCount": 12 },
+    { "name": "image", "featureCount": 8 }
+  ],
   "totalFiles": 25,
   "analyzedCount": 0,
   "pendingCount": 25,
@@ -196,12 +144,10 @@ node "scripts/generate-inventory.js" \
 ```
 
 **Module Detection Rule:**
-- The `module` field is automatically extracted from each file's relative directory path
-- It uses the **first non-excluded directory level** as the module name
-- Example: `system/user/index.vue` → module = `system`
-- Example: `components/Table.vue` (excluded dir) → skipped by ExcludeDirs
-- Files at root level (no subdirectory) → module = `_root`
-- The top-level `modules` array lists all unique module names found
+- When using `--entryDirsFile` mode (recommended), the `module` field for each feature is determined by matching the file's path against the entry directories defined in the entry-dirs JSON
+- Each file is assigned to the module whose `entryDirs` path matches the file's relative directory
+- The top-level `modules` array lists all modules with their feature counts
+- Files not matching any entry directory → module = `_root`
 
 **sourcePath Format:**
 - In both full-scan mode and entry-dirs mode, `sourcePath` is always a **project-root-relative path**
@@ -251,6 +197,12 @@ Final Output:
 - [ ] Each platform has correct `platformName`, `platformType`, `techStack` configuration
 - [ ] Source directories located for all platforms
 
+### Entry Directory Identification
+- [ ] Entry-dirs JSON files generated for all platforms
+- [ ] Each platform has non-empty modules array
+- [ ] Module names are business-meaningful (not technical terms like `config`, `util`, `controller`)
+- [ ] Entry directory paths are correct and accessible
+
 ### Inventory Generation
 - [ ] **Inventory scripts executed**: Node.js script generated `features-{platform}.json` files
 - [ ] **Inventory files valid**: JSON structure correct, all features listed

package/package.json

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