yg-team-cli 2.6.5 → 2.7.1

package/dist/cli.js

@@ -4217,9 +4217,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
@@ -4234,6 +4255,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) {
@@ -4688,10 +4710,366 @@ Temporary solution: ${answers.solution}`
   }
 });
 
+// src/lib/bdd-parser.ts
+var BDDParser;
+var init_bdd_parser = __esm({
+  "src/lib/bdd-parser.ts"() {
+    "use strict";
+    init_esm_shims();
+    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
 import { Command as Command7 } from "commander";
 import inquirer6 from "inquirer";
 import path12 from "path";
+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();
@@ -5238,6 +5616,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`);
+  }
+}
 var acceptCommand;
 var init_accept = __esm({
   "src/commands/accept.ts"() {
@@ -5245,7 +5994,8 @@ var init_accept = __esm({
     init_esm_shims();
     init_utils();
     init_logger();
-    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) => {
+    init_bdd_parser();
+    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();
@@ -5256,14 +6006,11 @@ var init_accept = __esm({
           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) {