yg-team-cli 2.6.4 → 2.7.1

package/dist/index.js

@@ -212,6 +212,12 @@ var init_utils = __esm({
       static async read(file) {
         return await fs.readFile(file, "utf-8");
       }
+      /**
+       * 同步读取文件内容
+       */
+      static readSync(file) {
+        return fs.readFileSync(file, "utf-8");
+      }
       /**
        * 写入文件内容（自动创建父目录）
        */
@@ -1772,27 +1778,164 @@ var ModuleManager = class {
       } else if (module.type === "remote") {
         await this.generateRemoteSpecPlaceholder(targetPath, module);
         addedFiles.push(path5.relative(projectPath, targetPath));
+      } else {
+        await this.generateLocalSpecPlaceholder(targetPath, module);
+        addedFiles.push(path5.relative(projectPath, targetPath));
       }
     }
-    if (module.type === "local" && module.backendFragments) {
+    if (module.backendFragments) {
       const backendJavaDir = path5.join(projectPath, "backend/src/main/java");
-      const commonBasePath = path5.join(backendJavaDir, "org/yungu/common");
+      const useTemplates = await FileUtils.exists(path5.join(templatesDir, "modules"));
       for (const fragment of module.backendFragments) {
+        let sourcePath = null;
+        let targetPath;
+        let content;
+        if (useTemplates) {
+          sourcePath = path5.join(templatesDir, "modules", fragment.source);
+          if (await FileUtils.exists(sourcePath)) {
+            content = await FileUtils.read(sourcePath);
+          }
+        }
+        if (!content) {
+          content = this.generatePlaceholderCode(module, fragment);
+        }
+        if (fragment.target.startsWith("common/")) {
+          const relativePath = fragment.target.replace(/^common\//, "org/yungu/common/");
+          targetPath = path5.join(backendJavaDir, relativePath);
+        } else if (fragment.target.startsWith("config/")) {
+          const mainModule = this.findMainModule(projectPath);
+          if (mainModule) {
+            const relativePath = fragment.target.replace(/^config\//, `${mainModule}/config/`);
+            targetPath = path5.join(backendJavaDir, relativePath);
+          } else {
+            targetPath = path5.join(backendJavaDir, fragment.target);
+          }
+        } else {
+          targetPath = path5.join(backendJavaDir, fragment.target);
+        }
+        await FileUtils.ensureDir(path5.dirname(targetPath));
+        await FileUtils.write(targetPath, content);
+        addedFiles.push(path5.relative(projectPath, targetPath));
+      }
+    }
+    if (module.frontendFragments) {
+      const frontendSrcDir = path5.join(projectPath, "frontend/src");
+      for (const fragment of module.frontendFragments) {
         const sourcePath = path5.join(templatesDir, "modules", fragment.source);
-        const targetPath = path5.join(commonBasePath, fragment.target);
+        const targetPath = path5.join(frontendSrcDir, fragment.target);
         if (await FileUtils.exists(sourcePath)) {
-          await FileUtils.ensureDir(path5.dirname(targetPath));
-          let content = await FileUtils.read(sourcePath);
-          const targetPackage = "org.yungu.common." + path5.dirname(fragment.target).replace(/\//g, ".");
-          content = content.replace(/^package\s+[^;]+;/m, `package ${targetPackage};`);
-          await FileUtils.write(targetPath, content);
+          await FileUtils.copy(sourcePath, targetPath);
           addedFiles.push(path5.relative(projectPath, targetPath));
         }
       }
-    } else if (module.type === "remote") {
     }
     return addedFiles;
   }
+  /**
+   * 查找主模块名 (第一个 service 类型的模块)
+   */
+  static findMainModule(projectPath) {
+    const settingsPath = path5.join(projectPath, "backend/settings.gradle");
+    const content = FileUtils.readSync(settingsPath);
+    const matches = content.match(/include\s+'([^']+)'/g);
+    if (matches) {
+      for (const match of matches) {
+        const moduleName = match.replace(/include\s+'/, "").replace(/'/, "");
+        if (moduleName !== "common") {
+          return moduleName;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * 生成占位符代码
+   */
+  static generatePlaceholderCode(module, fragment) {
+    const targetPackage = path5.dirname(fragment.target).replace(/\//g, ".");
+    const className = path5.basename(fragment.target, ".java");
+    const moduleName = module.name;
+    const moduleId = module.id;
+    return `package ${targetPackage};
+
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * ${moduleName} - \u5360\u4F4D\u7B26
+ *
+ * \u6B64\u6587\u4EF6\u7531 team-cli \u81EA\u52A8\u751F\u6210\u3002
+ * \u6A21\u5757 ID: ${moduleId}
+ *
+ * \u4F7F\u7528\u8BF4\u660E:
+ * 1. \u8BF7\u6839\u636E\u9879\u76EE\u5B9E\u9645\u9700\u6C42\u5B8C\u5584\u6B64\u6587\u4EF6
+ * 2. \u6216\u53C2\u8003 docs/specs/${moduleId}/spec.md \u83B7\u53D6\u8BE6\u7EC6\u9700\u6C42
+ */
+@Slf4j
+public class ${className} {
+
+    /**
+     * TODO: \u5B9E\u73B0 ${moduleName} \u529F\u80FD
+     */
+    public void execute() {
+        log.info("${className} - \u6267\u884C\u4E2D...");
+        // \u5728\u6B64\u5B9E\u73B0\u5177\u4F53\u903B\u8F91
+    }
+}
+`;
+  }
+  /**
+   * 生成本地模块的 Spec 占位符
+   */
+  static async generateLocalSpecPlaceholder(targetPath, module) {
+    const content = `# ${module.name}
+
+## \u529F\u80FD\u6982\u8FF0
+${module.description}
+
+## \u4F7F\u7528\u8BF4\u660E
+
+\u6B64\u6A21\u5757\u4E3A\u4E91\u8C37\u901A\u7528\u6A21\u5757\u7684\u5360\u4F4D\u7B26\u914D\u7F6E\u3002
+
+### \u914D\u7F6E\u6B65\u9AA4
+
+1. **\u6DFB\u52A0\u4F9D\u8D56**
+
+\u5728 \`backend/build.gradle\` \u4E2D\u6DFB\u52A0:
+
+\`\`\`groovy
+${module.dependencies ? module.dependencies.map((d) => `implementation '${d}'`).join("\n") : ""}
+\`\`\`
+
+2. **\u914D\u7F6E\u6587\u4EF6**
+
+\u6839\u636E\u9700\u6C42\u914D\u7F6E application.yml:
+
+\`\`\`yaml
+# ${module.name} \u914D\u7F6E
+\`\`\`
+
+3. **\u5BFC\u5165\u914D\u7F6E\u7C7B**
+
+\u5728\u4E3B Application \u7C7B\u4E0A\u6DFB\u52A0\u6CE8\u89E3:
+
+\`\`\`java
+@SpringBootApplication
+@ComponentScan("${module.id}")
+public class Application {
+    // ...
+}
+\`\`\`
+
+4. **\u53C2\u8003\u6587\u6863**
+
+\u67E5\u770B docs/specs/${module.id}/spec.md \u83B7\u53D6\u8BE6\u7EC6\u5B9E\u73B0\u8BF4\u660E\u3002
+
+## \u4F9D\u8D56\u5173\u7CFB
+
+${module.requires ? `\u9700\u8981\u5148\u542F\u7528: ${module.requires.join(", ")}` : "\u65E0\u524D\u7F6E\u4F9D\u8D56"}
+`;
+    await FileUtils.write(targetPath, content);
+  }
   /**
    * 生成远程模块的 Spec 占位符
    */
@@ -4510,9 +4653,30 @@ Generate a complete Spec document with the following sections:
 \u5217\u51FA\u9700\u8981\u7684\u540E\u7AEF\u6A21\u5757\u7ED3\u6784
 
 ## \u9A8C\u6536\u6807\u51C6
-- [ ] \u9A8C\u6536\u6807\u51C6 1
-- [ ] \u9A8C\u6536\u6807\u51C6 2
-- [ ] \u9A8C\u6536\u6807\u51C6 3
+
+### BDD \u573A\u666F\uFF08\u884C\u4E3A\u9A71\u52A8\u89C6\u89D2\uFF09
+
+\u8BF7\u4E3A\u6BCF\u4E2A\u4E3B\u8981\u529F\u80FD\u70B9\u751F\u6210 2-4 \u4E2A BDD \u573A\u666F\uFF0C\u683C\u5F0F\u5982\u4E0B\uFF1A
+
+\`\`\`markdown
+#### \u573A\u666F 1: [\u573A\u666F\u540D\u79F0]
+**\u4F5C\u4E3A** [\u7528\u6237\u89D2\u8272]
+**\u6211\u5E0C\u671B** [\u5B8C\u6210\u7684\u52A8\u4F5C]
+**\u4EE5\u4FBF** [\u5B9E\u73B0\u7684\u4EF7\u503C]
+
+- [GIVEN] \u524D\u7F6E\u6761\u4EF6\u63CF\u8FF0
+- [WHEN] \u7528\u6237\u52A8\u4F5C\u6216 API \u8C03\u7528
+- [THEN] \u9884\u671F\u7ED3\u679C
+
+**\u72B6\u6001\u6D41\u8F6C**:
+- \`\u672A\u767B\u5F55\` \u2192 \`\u767B\u5F55\u4E2D\` \u2192 \`\u5DF2\u767B\u5F55\`
+\`\`\`
+
+\u8981\u6C42\uFF1A
+1. \u6BCF\u4E2A\u573A\u666F\u8986\u76D6\u4E00\u4E2A\u5B8C\u6574\u7684\u7528\u6237\u6D41\u7A0B
+2. Given/When/Then \u7ED3\u6784\u6E05\u6670
+3. \u72B6\u6001\u6D41\u8F6C\u6807\u6CE8\u660E\u786E
+4. \u573A\u666F\u6570\u91CF\u6839\u636E\u529F\u80FD\u590D\u6742\u5EA6\u51B3\u5B9A\uFF08\u7B80\u5355\u529F\u80FD 2-3 \u4E2A\uFF0C\u590D\u6742\u529F\u80FD 4-6 \u4E2A\uFF09
 
 ## \u91CC\u7A0B\u7891 (Milestones)
 > \u6CE8: \u4F7F\u7528 \`team-cli breakdown ${featureSlug}.md\` \u62C6\u5206\u6B64 spec \u4E3A milestones \u548C todos
@@ -4527,6 +4691,7 @@ IMPORTANT:
 3. Priority should be justified based on feature importance
 4. Work estimation should be realistic
 5. Extract key requirements from the PRD accurately
+6. BDD scenarios should cover all user flows and edge cases
 `;
 }
 function buildSplitPrdPrompt(prdContent, screenshots, demoRepos) {
@@ -4938,7 +5103,322 @@ init_logger();
 import { Command as Command7 } from "commander";
 import inquirer6 from "inquirer";
 import path12 from "path";
-var acceptCommand = new Command7("accept").argument("[spec-file]", "Spec \u6587\u4EF6\u8DEF\u5F84").description("\u9A8C\u6536\u529F\u80FD - \u8D70\u67E5\u6240\u6709\u9700\u6C42\uFF0C\u9A8C\u8BC1\u8054\u8C03\u662F\u5426\u5B8C\u6210").action(async (specFile) => {
+
+// src/lib/bdd-parser.ts
+init_esm_shims();
+var BDDParser = class {
+  static SCENARIO_PATTERN = /^####?\s*场景\s*(\d+)[:：]?\s*(.+)$/;
+  static GIVEN_PATTERN = /^\*?\s*-\s*\[GIVEN\]\s*(.+)$/;
+  static WHEN_PATTERN = /^\*?\s*-\s*\[WHEN\]\s*(.+)$/;
+  static THEN_PATTERN = /^\*?\s*-\s*\[THEN\]\s*(.+)$/;
+  static STATE_PATTERN = /^\*?\s*-\s*\[STATE\]\s*(.+)$/;
+  static ROLE_PATTERN = /^\*\*作为\*\*[:：]?\s*(.+)$/i;
+  static WANT_PATTERN = /^\*\*我希望\*\*[:：]?\s*(.+)$/i;
+  static SO_THAT_PATTERN = /^\*\*以便\*\*[:：]?\s*(.+)$/i;
+  static TRANSITION_PATTERN = /`([^`]+)`\s*→\s*`([^`]+)`/;
+  /**
+   * 解析 BDD 场景
+   */
+  static parseScenarios(content) {
+    const scenarios = [];
+    const lines = content.split("\n");
+    let currentScenario = null;
+    let section = null;
+    let scenarioOrder = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      const lineNum = i + 1;
+      const scenarioMatch = line.match(this.SCENARIO_PATTERN);
+      if (scenarioMatch) {
+        if (currentScenario && currentScenario.title) {
+          scenarios.push(this.finalizeScenario(currentScenario, scenarioOrder));
+        }
+        scenarioOrder++;
+        currentScenario = {
+          id: `scenario-${scenarioOrder}`,
+          title: scenarioMatch[2].trim(),
+          order: scenarioOrder,
+          given: [],
+          when: [],
+          then: [],
+          stateTransitions: [],
+          relatedApis: [],
+          relatedFeatures: []
+        };
+        section = "title";
+        continue;
+      }
+      if (line.match(/^\*\*作为\*\*[:：]?/i)) {
+        const match = line.match(this.ROLE_PATTERN);
+        if (match && currentScenario) {
+          currentScenario.asA = match[1].trim();
+        }
+        continue;
+      }
+      if (line.match(/^\*\*我希望\*\*[:：]?/i)) {
+        const match = line.match(this.WANT_PATTERN);
+        if (match && currentScenario) {
+          currentScenario.iWant = match[1].trim();
+        }
+        continue;
+      }
+      if (line.match(/^\*\*以便\*\*[:：]?/i)) {
+        const match = line.match(this.SO_THAT_PATTERN);
+        if (match && currentScenario) {
+          currentScenario.soThat = match[1].trim();
+        }
+        continue;
+      }
+      const givenMatch = line.match(this.GIVEN_PATTERN);
+      const whenMatch = line.match(this.WHEN_PATTERN);
+      const thenMatch = line.match(this.THEN_PATTERN);
+      const stateMatch = line.match(this.STATE_PATTERN);
+      if (givenMatch && currentScenario) {
+        currentScenario.given.push({
+          description: givenMatch[1].trim(),
+          type: this.detectConditionType(givenMatch[1]),
+          validation: this.extractValidation(givenMatch[1])
+        });
+        section = "given";
+        continue;
+      }
+      if (whenMatch && currentScenario) {
+        const action = this.parseAction(whenMatch[1].trim());
+        currentScenario.when.push(action);
+        if (action.api) {
+          currentScenario.relatedApis.push(action.api);
+        }
+        section = "when";
+        continue;
+      }
+      if (thenMatch && currentScenario) {
+        currentScenario.then.push({
+          description: thenMatch[1].trim(),
+          type: this.detectResultType(thenMatch[1]),
+          expectedBehavior: this.extractExpectedBehavior(thenMatch[1])
+        });
+        section = "then";
+        continue;
+      }
+      if (stateMatch && currentScenario) {
+        const transition = this.parseStateTransition(stateMatch[1].trim());
+        if (transition) {
+          currentScenario.stateTransitions.push(transition);
+        }
+        section = "state";
+        continue;
+      }
+      if (line && !line.startsWith("#") && !line.startsWith("---") && currentScenario) {
+        const trimmed = line.replace(/^[\s-]*/, "");
+        if (trimmed && section === "given" && currentScenario.given.length > 0) {
+          currentScenario.given[currentScenario.given.length - 1].description += " " + trimmed;
+        } else if (trimmed && section === "when" && currentScenario.when.length > 0) {
+          currentScenario.when[currentScenario.when.length - 1].description += " " + trimmed;
+        } else if (trimmed && section === "then" && currentScenario.then.length > 0) {
+          currentScenario.then[currentScenario.then.length - 1].description += " " + trimmed;
+        }
+      }
+    }
+    if (currentScenario && currentScenario.title) {
+      scenarios.push(this.finalizeScenario(currentScenario, scenarioOrder));
+    }
+    return scenarios;
+  }
+  /**
+   * 从验收标准部分提取 BDD 场景
+   */
+  static parseFromAcceptanceSection(acceptanceSection) {
+    const bddSectionMatch = acceptanceSection.match(
+      /(?:###\s*BDD[^\n]*|###\s*场景|###\s*行为驱动)[^]*(?=##|$)/i
+    );
+    if (bddSectionMatch) {
+      return this.parseScenarios(bddSectionMatch[0]);
+    }
+    return this.convertFromLegacyCriteria(acceptanceSection);
+  }
+  /**
+   * 从传统验收标准转换
+   */
+  static convertFromLegacyCriteria(criteria) {
+    const scenarios = [];
+    const lines = criteria.split("\n");
+    let scenarioId = 0;
+    let currentScenario = null;
+    for (const line of lines) {
+      const criteriaMatch = line.match(/^-\s*\[\s*\]\s*(.+)$/);
+      if (criteriaMatch) {
+        if (!currentScenario) {
+          scenarioId++;
+          currentScenario = {
+            id: `scenario-${scenarioId}`,
+            title: `\u573A\u666F ${scenarioId}`,
+            order: scenarioId,
+            given: [],
+            when: [],
+            then: [],
+            stateTransitions: []
+          };
+        }
+        const text = criteriaMatch[1];
+        const normalized = text.toLowerCase();
+        if (normalized.includes("\u5DF2") || normalized.includes("\u6709") || normalized.includes("\u5B58\u5728")) {
+          currentScenario.given.push({
+            description: text,
+            type: "data",
+            validation: "\u68C0\u67E5\u6570\u636E\u5B58\u5728"
+          });
+        } else if (normalized.includes("\u5F53") || normalized.includes("\u63D0\u4EA4") || normalized.includes("\u70B9\u51FB")) {
+          currentScenario.when.push({
+            description: text,
+            trigger: "user"
+          });
+        } else if (normalized.includes("\u5E94") || normalized.includes("\u8FD4\u56DE") || normalized.includes("\u663E\u793A")) {
+          currentScenario.then.push({
+            description: text,
+            type: "response",
+            expectedBehavior: text
+          });
+        }
+      } else if (line.trim() === "" && currentScenario) {
+        scenarios.push(this.finalizeScenario(currentScenario, scenarioId));
+        currentScenario = null;
+      }
+    }
+    if (currentScenario && currentScenario.title) {
+      scenarios.push(this.finalizeScenario(currentScenario, scenarioId));
+    }
+    return scenarios;
+  }
+  /**
+   * 检测条件类型
+   */
+  static detectConditionType(description) {
+    const lower = description.toLowerCase();
+    if (lower.includes("\u6570\u636E") || lower.includes("\u8BB0\u5F55") || lower.includes("\u8868")) return "data";
+    if (lower.includes("\u72B6\u6001") || lower.includes("\u5DF2") || lower.includes("\u672A")) return "state";
+    return "user";
+  }
+  /**
+   * 检测结果类型
+   */
+  static detectResultType(description) {
+    const lower = description.toLowerCase();
+    if (lower.includes("\u8FD4\u56DE") || lower.includes("\u54CD\u5E94") || lower.includes("\u72B6\u6001\u7801")) return "response";
+    if (lower.includes("\u72B6\u6001") || lower.includes("\u53D8\u6210") || lower.includes("\u66F4\u65B0")) return "state";
+    if (lower.includes("\u663E\u793A") || lower.includes("\u9875\u9762") || lower.includes("\u754C\u9762")) return "ui";
+    return "data";
+  }
+  /**
+   * 提取验证方式
+   */
+  static extractValidation(description) {
+    const match = description.match(/\(([^)]+)\)/);
+    return match ? match[1] : "\u68C0\u67E5\u6761\u4EF6\u6EE1\u8DB3";
+  }
+  /**
+   * 提取预期行为
+   */
+  static extractExpectedBehavior(description) {
+    return description.replace(/^(应该|应|应当|应该会|会)/, "").trim();
+  }
+  /**
+   * 解析动作
+   */
+  static parseAction(description) {
+    const apiMatch = description.match(/(?:API|POST|GET|PUT|DELETE|PATCH)\s*[:：]?\s*`([^`]+)`/i);
+    const uiMatch = description.match(/(?:点击|输入|选择|提交|拖拽)[:：]?\s*(.+)/);
+    return {
+      description,
+      api: apiMatch?.[1],
+      uiAction: uiMatch?.[1],
+      trigger: apiMatch ? "api" : "user"
+    };
+  }
+  /**
+   * 解析状态流转
+   */
+  static parseStateTransition(description) {
+    const arrowMatch = description.match(/`([^`]+)`\s*(?:→|->)\s*`([^`]+)`/);
+    if (arrowMatch) {
+      return {
+        from: arrowMatch[1],
+        trigger: description.split(/→|->/)[1]?.trim() || "\u5B8C\u6210",
+        to: arrowMatch[2]
+      };
+    }
+    const fromMatch = description.match(/(?:从|起始于|开始于)\s*`([^`]+)`/);
+    const toMatch = description.match(/(?:到|变为|结束于)\s*`([^`]+)`/);
+    const triggerMatch = description.match(/通过|当|使用\s*[:：]?\s*(.+?)(?:，|$)/);
+    if (fromMatch && toMatch) {
+      return {
+        from: fromMatch[1],
+        trigger: triggerMatch?.[1] || "\u5B8C\u6210",
+        to: toMatch[1]
+      };
+    }
+    return null;
+  }
+  /**
+   * 完成场景构建
+   */
+  static finalizeScenario(scenario, order) {
+    return {
+      id: scenario.id || `scenario-${order}`,
+      title: scenario.title || `\u573A\u666F ${order}`,
+      order: scenario.order || order,
+      asA: scenario.asA || "\u7528\u6237",
+      iWant: scenario.iWant || "",
+      soThat: scenario.soThat || "",
+      given: scenario.given || [],
+      when: scenario.when || [],
+      then: scenario.then || [],
+      stateTransitions: scenario.stateTransitions || [],
+      relatedApis: scenario.relatedApis || [],
+      relatedFeatures: scenario.relatedFeatures || []
+    };
+  }
+  /**
+   * 生成场景的 Markdown
+   */
+  static generateMarkdown(scenario) {
+    const lines = [];
+    lines.push(`#### \u573A\u666F ${scenario.order}: ${scenario.title}`);
+    lines.push("");
+    if (scenario.asA) {
+      lines.push(`**\u4F5C\u4E3A** ${scenario.asA}`);
+    }
+    if (scenario.iWant) {
+      lines.push(`**\u6211\u5E0C\u671B** ${scenario.iWant}`);
+    }
+    if (scenario.soThat) {
+      lines.push(`**\u4EE5\u4FBF** ${scenario.soThat}`);
+    }
+    lines.push("");
+    for (const given of scenario.given) {
+      lines.push(`- [GIVEN] ${given.description}`);
+    }
+    lines.push("");
+    for (const when of scenario.when) {
+      lines.push(`- [WHEN] ${when.description}`);
+    }
+    lines.push("");
+    for (const then of scenario.then) {
+      lines.push(`- [THEN] ${then.description}`);
+    }
+    lines.push("");
+    if (scenario.stateTransitions.length > 0) {
+      lines.push("**\u72B6\u6001\u6D41\u8F6C**:");
+      for (const trans of scenario.stateTransitions) {
+        lines.push(`- \`${trans.from}\` \u2192 \`${trans.to}\` (\u89E6\u53D1: ${trans.trigger})`);
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/commands/accept.ts
+var acceptCommand = new Command7("accept").argument("[spec-file]", "Spec \u6587\u4EF6\u8DEF\u5F84").description("\u9A8C\u6536\u529F\u80FD - \u8D70\u67E5\u6240\u6709\u9700\u6C42\uFF0C\u9A8C\u8BC1\u8054\u8C03\u662F\u5426\u5B8C\u6210").option("--mode <mode>", "\u9A8C\u6536\u6A21\u5F0F: traditional (\u4F20\u7EDF) \u6216 bdd (\u884C\u4E3A\u9A71\u52A8)", "traditional").option("--scenario <id>", "\u6307\u5B9A\u9A8C\u6536\u7684 BDD \u573A\u666F ID").action(async (specFile, options) => {
   try {
     logger.header("\u9A8C\u6536\u6A21\u5F0F");
     logger.newLine();
@@ -4949,14 +5429,11 @@ var acceptCommand = new Command7("accept").argument("[spec-file]", "Spec \u6587\
       process.exit(1);
     }
     logger.success("\u68C0\u6D4B\u5230\u9879\u76EE\u4E0A\u4E0B\u6587");
-    const selectedSpec = await selectSpec2(specFile);
-    const selectedMilestone = await selectMilestone2(selectedSpec);
-    const result = await runAcceptanceCheck(selectedSpec, selectedMilestone);
-    await generateAcceptanceReport(result);
-    if (result.issues.length > 0) {
-      await handleIssues(result);
-    }
-    await syncSpecStatus(selectedSpec, result);
+    if (options.mode === "bdd") {
+      await runBDDAcceptance(specFile, options.scenario);
+    } else {
+      await runTraditionalAcceptance(specFile);
+    }
     logger.header("\u9A8C\u6536\u5B8C\u6210!");
     logger.newLine();
   } catch (error) {
@@ -4967,6 +5444,43 @@ var acceptCommand = new Command7("accept").argument("[spec-file]", "Spec \u6587\
     process.exit(1);
   }
 });
+async function runTraditionalAcceptance(defaultSpec) {
+  const selectedSpec = await selectSpec2(defaultSpec);
+  const selectedMilestone = await selectMilestone2(selectedSpec);
+  const result = await runAcceptanceCheck(selectedSpec, selectedMilestone);
+  await generateAcceptanceReport(result);
+  if (result.issues.length > 0) {
+    await handleIssues(result);
+  }
+  await syncSpecStatus(selectedSpec, result);
+}
+async function runBDDAcceptance(defaultSpec, scenarioId) {
+  const selectedSpec = await selectSpec2(defaultSpec);
+  const specContent = await FileUtils.read(selectedSpec);
+  const scenarios = BDDParser.parseFromAcceptanceSection(specContent);
+  if (scenarios.length === 0) {
+    logger.warn("\u672A\u627E\u5230 BDD \u573A\u666F\uFF0C\u4F7F\u7528\u4F20\u7EDF\u9A8C\u6536\u6A21\u5F0F");
+    logger.info('\u8BF7\u5148\u8FD0\u884C "team-cli split-prd" \u751F\u6210\u5305\u542B BDD \u573A\u666F\u7684 spec');
+    await runTraditionalAcceptance(selectedSpec);
+    return;
+  }
+  const targetScenarios = scenarioId ? scenarios.filter((s) => s.id === scenarioId || s.title.toLowerCase().includes(scenarioId.toLowerCase())) : scenarios;
+  if (targetScenarios.length === 0) {
+    throw new Error(`\u672A\u627E\u5230\u573A\u666F: ${scenarioId}`);
+  }
+  logger.newLine();
+  logger.info(`\u627E\u5230 ${scenarios.length} \u4E2A BDD \u573A\u666F\uFF0C\u5C06\u9A8C\u6536 ${targetScenarios.length} \u4E2A`);
+  const results = [];
+  for (const scenario of targetScenarios) {
+    logger.newLine();
+    logger.info(`\u9A8C\u6536\u573A\u666F: ${scenario.title}`);
+    const result = await checkBDDScenario(scenario, selectedSpec);
+    results.push(result);
+    printScenarioResult(result);
+  }
+  await generateBDDReport(selectedSpec, results);
+  await syncBDDStatus(selectedSpec, results);
+}
 async function selectSpec2(defaultSpec) {
   logger.step("\u6B65\u9AA4 1/4: \u9009\u62E9 spec \u6587\u4EF6...");
   logger.newLine();
@@ -5513,6 +6027,377 @@ async function syncSpecStatus(specFile, result) {
     }
   }
 }
+async function checkBDDScenario(scenario, specFile) {
+  const result = {
+    scenarioId: scenario.id,
+    scenarioTitle: scenario.title,
+    overallStatus: "pending",
+    givenResults: [],
+    whenResults: [],
+    thenResults: [],
+    stateTransitionResults: []
+  };
+  for (const given of scenario.given) {
+    const checkResult = await verifyGivenCondition(given, specFile);
+    result.givenResults.push(checkResult);
+  }
+  for (const when of scenario.when) {
+    const checkResult = await verifyWhenAction(when, specFile);
+    result.whenResults.push(checkResult);
+  }
+  for (const then of scenario.then) {
+    const checkResult = await verifyThenResult(then, specFile);
+    result.thenResults.push(checkResult);
+  }
+  for (const transition of scenario.stateTransitions) {
+    const checkResult = await verifyStateTransition(transition, specFile);
+    result.stateTransitionResults.push(checkResult);
+  }
+  const allResults = [
+    ...result.givenResults,
+    ...result.whenResults,
+    ...result.thenResults,
+    ...result.stateTransitionResults
+  ];
+  if (allResults.every((r) => r.status === "pass")) {
+    result.overallStatus = "pass";
+  } else if (allResults.some((r) => r.status === "fail")) {
+    result.overallStatus = "fail";
+  } else {
+    result.overallStatus = "pending";
+  }
+  return result;
+}
+async function verifyGivenCondition(given, specFile) {
+  switch (given.type) {
+    case "data":
+      return verifyDataCondition(given);
+    case "state":
+      return verifyStateCondition(given);
+    case "user":
+      return verifyUserCondition(given);
+    default:
+      return { condition: given.description, status: "pending" };
+  }
+}
+async function verifyDataCondition(given) {
+  const tableMatch = given.description.match(/`?([a-z_]+)`?表/);
+  const fieldMatch = given.description.match(/`?([a-z_]+)`?字段/);
+  if (tableMatch) {
+    const tableName = tableMatch[1];
+    const tableFiles = await FileUtils.findFiles(`**/${tableName}.sql`, "database");
+    const entityFiles = await FileUtils.findFiles(`**/${StringUtils.toPascalCase(tableName)}.java`, "backend/src");
+    if (tableFiles.length > 0 || entityFiles.length > 0) {
+      return {
+        condition: given.description,
+        status: "pass",
+        evidence: tableFiles[0] || entityFiles[0]
+      };
+    }
+    return {
+      condition: given.description,
+      status: "fail",
+      evidence: `\u8868 ${tableName} \u672A\u627E\u5230`
+    };
+  }
+  return { condition: given.description, status: "pending" };
+}
+async function verifyStateCondition(given) {
+  const statusMatch = given.description.match(/`([^`]+)`状态/);
+  const stateMatch = given.description.match(/`([^`]+)`/);
+  const statusName = statusMatch?.[1] || stateMatch?.[1];
+  if (statusName) {
+    const enumFiles = [
+      ...await FileUtils.findFiles("**/*Status*.java", "backend/src"),
+      ...await FileUtils.findFiles("**/*Status*.ts", "frontend/src")
+    ];
+    for (const ef of enumFiles) {
+      const content = await FileUtils.read(ef);
+      if (content.includes(statusName)) {
+        return {
+          condition: given.description,
+          status: "pass",
+          evidence: ef
+        };
+      }
+    }
+    return {
+      condition: given.description,
+      status: "fail",
+      evidence: `\u72B6\u6001 ${statusName} \u672A\u627E\u5230`
+    };
+  }
+  return { condition: given.description, status: "pending" };
+}
+async function verifyUserCondition(given) {
+  const userMatch = given.description.match(/用户.*?`([^`]+)`/);
+  if (userMatch) {
+    return {
+      condition: given.description,
+      status: "pending",
+      evidence: "\u9700\u8981\u4EBA\u5DE5\u9A8C\u8BC1\u7528\u6237\u72B6\u6001"
+    };
+  }
+  return { condition: given.description, status: "pending" };
+}
+async function verifyWhenAction(when, specFile) {
+  if (when.api) {
+    const apiCheck = await verifyApiImplementationByPath(when.api);
+    return {
+      action: when.description,
+      status: apiCheck.status,
+      apiCalled: when.api,
+      responseCode: apiCheck.responseCode
+    };
+  }
+  if (when.uiAction) {
+    const uiCheck = await verifyUIComponent(when.uiAction);
+    return {
+      action: when.description,
+      status: uiCheck.status
+    };
+  }
+  return { action: when.description, status: "pending" };
+}
+async function verifyApiImplementationByPath(apiPath) {
+  const apiMatch = apiPath.match(/(GET|POST|PUT|DELETE|PATCH)\s+\/?(.+)/i);
+  if (!apiMatch) {
+    return { status: "pending" };
+  }
+  const method = apiMatch[1].toUpperCase();
+  const path22 = "/" + apiMatch[2];
+  const controllerFiles = await FileUtils.findFiles("**/*Controller.java", "backend/src");
+  for (const cf of controllerFiles) {
+    const content = await FileUtils.read(cf);
+    if (content.includes(`"${path22}"`) || content.includes(`"${path22}/"`)) {
+      const annotationMap = {
+        GET: ["@GetMapping", "@RequestMapping(method = RequestMethod.GET)"],
+        POST: ["@PostMapping", "@RequestMapping(method = RequestMethod.POST)"],
+        PUT: ["@PutMapping", "@RequestMapping(method = RequestMethod.PUT)"],
+        DELETE: ["@DeleteMapping", "@RequestMapping(method = RequestMethod.DELETE)"]
+      };
+      for (const annotation of annotationMap[method] || []) {
+        if (content.includes(annotation)) {
+          return { status: "pass", responseCode: 200 };
+        }
+      }
+    }
+  }
+  return { status: "fail" };
+}
+async function verifyUIComponent(uiAction) {
+  const componentFiles = await FileUtils.findFiles("**/*.tsx", "frontend/src");
+  const viewFiles = await FileUtils.findFiles("**/*.vue", "frontend/src");
+  const allFiles = [...componentFiles, ...viewFiles];
+  for (const cf of allFiles) {
+    const content = await FileUtils.read(cf);
+    if (content.includes(uiAction) || content.toLowerCase().includes(uiAction.toLowerCase())) {
+      return { status: "pass" };
+    }
+  }
+  return { status: "pending" };
+}
+async function verifyThenResult(then, specFile) {
+  switch (then.type) {
+    case "response":
+      return verifyResponseResult(then);
+    case "state":
+      return verifyStateResult(then);
+    case "data":
+      return verifyDataResult(then);
+    case "ui":
+      return verifyUIResult(then);
+    default:
+      return { result: then.description, status: "pending" };
+  }
+}
+async function verifyResponseResult(then) {
+  const codeMatch = then.description.match(/状态码\s*(\d+)/);
+  const tokenMatch = then.description.match(/token/i);
+  if (tokenMatch) {
+    const tokenFiles = await FileUtils.findFiles("**/*Token*.java", "backend/src");
+    if (tokenFiles.length > 0) {
+      return { result: then.description, status: "pass", expectedValue: "JWT Token" };
+    }
+    return { result: then.description, status: "pending" };
+  }
+  if (codeMatch) {
+    return { result: then.description, status: "pending", expectedValue: `HTTP ${codeMatch[1]}` };
+  }
+  return { result: then.description, status: "pending" };
+}
+async function verifyStateResult(then) {
+  const stateMatch = then.description.match(/`([^`]+)`/);
+  if (stateMatch) {
+    const stateName = stateMatch[1];
+    const enumFiles = [
+      ...await FileUtils.findFiles("**/*Status*.java", "backend/src"),
+      ...await FileUtils.findFiles("**/*Status*.ts", "frontend/src")
+    ];
+    for (const ef of enumFiles) {
+      const content = await FileUtils.read(ef);
+      if (content.includes(stateName)) {
+        return { result: then.description, status: "pass", expectedValue: stateName };
+      }
+    }
+    return { result: then.description, status: "fail", expectedValue: stateName };
+  }
+  return { result: then.description, status: "pending" };
+}
+async function verifyDataResult(then) {
+  return { result: then.description, status: "pending" };
+}
+async function verifyUIResult(then) {
+  return { result: then.description, status: "pending" };
+}
+async function verifyStateTransition(transition, specFile) {
+  const { from, trigger, to } = transition;
+  const enumFiles = [
+    ...await FileUtils.findFiles("**/*Status*.java", "backend/src"),
+    ...await FileUtils.findFiles("**/*Status*.ts", "frontend/src"),
+    ...await FileUtils.findFiles("**/*State*.ts", "frontend/src")
+  ];
+  const fromExists = await checkStateExists(from, enumFiles);
+  const toExists = await checkStateExists(to, enumFiles);
+  if (!fromExists || !toExists) {
+    return {
+      transition: `\`${from}\` \u2192 \`${to}\``,
+      status: "fail",
+      fromState: fromExists ? "\u2713" : "\u2717",
+      toState: toExists ? "\u2713" : "\u2717"
+    };
+  }
+  const serviceFiles = await FileUtils.findFiles("**/*Service*.java", "backend/src");
+  for (const sf of serviceFiles) {
+    const content = await FileUtils.read(sf);
+    const methodPatterns = [
+      new RegExp(`${from}\\s*\u2192\\s*${to}`, "i"),
+      new RegExp(`from\\s*${from}\\s*to\\s*${to}`, "i")
+    ];
+    for (const pattern of methodPatterns) {
+      if (pattern.test(content)) {
+        return {
+          transition: `\`${from}\` \u2192 \`${to}\` (${trigger})`,
+          status: "pass",
+          fromState: from,
+          toState: to
+        };
+      }
+    }
+  }
+  return {
+    transition: `\`${from}\` \u2192 \`${to}\` (${trigger})`,
+    status: "pending",
+    fromState: from,
+    toState: to
+  };
+}
+async function checkStateExists(state, files) {
+  for (const file of files) {
+    try {
+      const content = await FileUtils.read(file);
+      if (content.includes(state) || content.includes(`"${state}"`)) {
+        return true;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+function printScenarioResult(result) {
+  const icon = result.overallStatus === "pass" ? "\u2713" : result.overallStatus === "fail" ? "\u2717" : "\u25CB";
+  console.log("");
+  console.log(`  ${icon} \u573A\u666F: ${result.scenarioTitle}`);
+  const passGiven = result.givenResults.filter((r) => r.status === "pass").length;
+  const passWhen = result.whenResults.filter((r) => r.status === "pass").length;
+  const passThen = result.thenResults.filter((r) => r.status === "pass").length;
+  const passTrans = result.stateTransitionResults.filter((r) => r.status === "pass").length;
+  console.log(`    Given: ${passGiven}/${result.givenResults.length}`);
+  console.log(`    When:  ${passWhen}/${result.whenResults.length}`);
+  console.log(`    Then:  ${passThen}/${result.thenResults.length}`);
+  console.log(`    State: ${passTrans}/${result.stateTransitionResults.length}`);
+}
+async function generateBDDReport(specFile, results) {
+  const reportDir = "docs/bdd-reports";
+  await FileUtils.ensureDir(reportDir);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const specName = path12.basename(specFile, ".md");
+  const reportFile = path12.join(reportDir, `${timestamp}_${specName}_bdd.md`);
+  const lines = [];
+  lines.push("# BDD \u9A8C\u6536\u62A5\u544A");
+  lines.push("");
+  lines.push(`**Spec \u6587\u4EF6**: ${specFile}`);
+  lines.push(`**\u9A8C\u6536\u65F6\u95F4**: ${(/* @__PURE__ */ new Date()).toLocaleString("zh-CN")}`);
+  lines.push(`**\u573A\u666F\u6570\u91CF**: ${results.length}`);
+  lines.push("");
+  lines.push("## \u9A8C\u6536\u6C47\u603B");
+  lines.push("");
+  let totalPass = 0;
+  let totalFail = 0;
+  for (const r of results) {
+    const statusIcon = r.overallStatus === "pass" ? "\u2713" : r.overallStatus === "fail" ? "\u2717" : "\u25CB";
+    const givenIcon = r.givenResults.every((g) => g.status === "pass") ? "\u2713" : r.givenResults.some((g) => g.status === "fail") ? "\u2717" : "\u25CB";
+    const whenIcon = r.whenResults.every((w) => w.status === "pass") ? "\u2713" : r.whenResults.some((w) => w.status === "fail") ? "\u2717" : "\u25CB";
+    const thenIcon = r.thenResults.every((t) => t.status === "pass") ? "\u2713" : r.thenResults.some((t) => t.status === "fail") ? "\u2717" : "\u25CB";
+    const transIcon = r.stateTransitionResults.every((t) => t.status === "pass") ? "\u2713" : r.stateTransitionResults.some((t) => t.status === "fail") ? "\u2717" : "\u25CB";
+    lines.push(`- ${statusIcon} ${r.scenarioTitle} | Given:${givenIcon} When:${whenIcon} Then:${thenIcon} State:${transIcon}`);
+    if (r.overallStatus === "pass") totalPass++;
+    if (r.overallStatus === "fail") totalFail++;
+  }
+  lines.push("");
+  lines.push(`**\u603B\u8BA1**: ${totalPass} \u4E2A\u901A\u8FC7, ${totalFail} \u4E2A\u5931\u8D25, ${results.length - totalPass - totalFail} \u4E2A\u5F85\u9A8C\u8BC1`);
+  lines.push("");
+  lines.push("## \u8BE6\u7EC6\u9A8C\u6536\u7ED3\u679C");
+  lines.push("");
+  for (const r of results) {
+    lines.push(`### \u573A\u666F: ${r.scenarioTitle}`);
+    lines.push("");
+    lines.push("#### GIVEN (\u524D\u7F6E\u6761\u4EF6)");
+    for (const g of r.givenResults) {
+      const icon = g.status === "pass" ? "\u2713" : g.status === "fail" ? "\u2717" : "\u25CB";
+      lines.push(`- ${icon} ${g.condition}`);
+      if (g.evidence) {
+        lines.push(`  - \u8BC1\u636E: ${g.evidence}`);
+      }
+    }
+    lines.push("");
+    lines.push("#### WHEN (\u89E6\u53D1\u52A8\u4F5C)");
+    for (const w of r.whenResults) {
+      const icon = w.status === "pass" ? "\u2713" : w.status === "fail" ? "\u2717" : "\u25CB";
+      lines.push(`- ${icon} ${w.action}`);
+      if (w.apiCalled) {
+        lines.push(`  - API: ${w.apiCalled}`);
+      }
+    }
+    lines.push("");
+    lines.push("#### THEN (\u9884\u671F\u7ED3\u679C)");
+    for (const t of r.thenResults) {
+      const icon = t.status === "pass" ? "\u2713" : t.status === "fail" ? "\u2717" : "\u25CB";
+      lines.push(`- ${icon} ${t.result}`);
+    }
+    lines.push("");
+    lines.push("#### \u72B6\u6001\u6D41\u8F6C");
+    for (const s of r.stateTransitionResults) {
+      const icon = s.status === "pass" ? "\u2713" : s.status === "fail" ? "\u2717" : "\u25CB";
+      lines.push(`- ${icon} ${s.transition}`);
+    }
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+  await FileUtils.write(reportFile, lines.join("\n"));
+  logger.success(`BDD \u9A8C\u6536\u62A5\u544A\u5DF2\u751F\u6210: ${reportFile}`);
+}
+async function syncBDDStatus(specFile, results) {
+  const allPassed = results.every((r) => r.overallStatus === "pass");
+  if (allPassed) {
+    logger.success("\u6240\u6709 BDD \u573A\u666F\u9A8C\u6536\u901A\u8FC7");
+  } else {
+    const failedCount = results.filter((r) => r.overallStatus === "fail").length;
+    logger.warn(`${failedCount} \u4E2A\u573A\u666F\u9A8C\u6536\u672A\u901A\u8FC7\uFF0C\u9700\u8981\u4FEE\u590D`);
+  }
+}
 
 // src/commands/add-module.ts
 init_esm_shims();