yg-team-cli 2.7.1 → 2.8.1

package/dist/cli.js

@@ -4217,30 +4217,9 @@ Generate a complete Spec document with the following sections:
 \u5217\u51FA\u9700\u8981\u7684\u540E\u7AEF\u6A21\u5757\u7ED3\u6784
 
 ## \u9A8C\u6536\u6807\u51C6
-
-### 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
+- [ ] \u9A8C\u6536\u6807\u51C6 1
+- [ ] \u9A8C\u6536\u6807\u51C6 2
+- [ ] \u9A8C\u6536\u6807\u51C6 3
 
 ## \u91CC\u7A0B\u7891 (Milestones)
 > \u6CE8: \u4F7F\u7528 \`team-cli breakdown ${featureSlug}.md\` \u62C6\u5206\u6B64 spec \u4E3A milestones \u548C todos
@@ -4255,7 +4234,6 @@ 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) {
@@ -4710,366 +4688,10 @@ 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();
@@ -5616,377 +5238,6 @@ 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"() {
@@ -5994,8 +5245,7 @@ var init_accept = __esm({
     init_esm_shims();
     init_utils();
     init_logger();
-    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) => {
+    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) => {
       try {
         logger.header("\u9A8C\u6536\u6A21\u5F0F");
         logger.newLine();
@@ -6006,11 +5256,14 @@ var init_accept = __esm({
           process.exit(1);
         }
         logger.success("\u68C0\u6D4B\u5230\u9879\u76EE\u4E0A\u4E0B\u6587");
-        if (options.mode === "bdd") {
-          await runBDDAcceptance(specFile, options.scenario);
-        } else {
-          await runTraditionalAcceptance(specFile);
-        }
+        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);
         logger.header("\u9A8C\u6536\u5B8C\u6210!");
         logger.newLine();
       } catch (error) {
@@ -8850,9 +8103,479 @@ var init_diff = __esm({
   }
 });
 
+// src/lib/fe-git.ts
+async function ensureGitRepo() {
+  const isRepo = await GitUtils.isGitRepo();
+  if (!isRepo) {
+    logger.error("\u5F53\u524D\u76EE\u5F55\u4E0D\u662F\u4E00\u4E2A Git \u4ED3\u5E93");
+    process.exit(1);
+  }
+}
+async function ensureCleanWorkingTree() {
+  const { execa: execa5 } = await import("execa");
+  const { stdout } = await execa5("git", ["status", "--porcelain"]);
+  if (stdout.trim()) {
+    logger.error("\u5DE5\u4F5C\u533A\u6709\u672A\u63D0\u4EA4\u7684\u66F4\u6539\uFF1A");
+    stdout.trim().split("\n").forEach((line) => logger.info(`  ${line.trim()}`));
+    process.exit(1);
+  }
+}
+async function ensureOnBranch(prefixes = [...VALID_BRANCH_PREFIXES]) {
+  const branch = await getCurrentBranch();
+  const prefix = getBranchPrefix(branch);
+  if (!prefix || !prefixes.includes(prefix)) {
+    logger.error(`\u5F53\u524D\u5206\u652F "${branch}" \u4E0D\u662F\u5408\u6CD5\u7684\u5DE5\u4F5C\u5206\u652F`);
+    logger.info(`\u5408\u6CD5\u524D\u7F00: ${prefixes.join(", ")}`);
+    process.exit(1);
+  }
+  return branch;
+}
+async function ensureBranchExists(branch) {
+  if (await branchExistsLocal(branch)) {
+    return;
+  }
+  const { execa: execa5 } = await import("execa");
+  if (await branchExistsRemote(branch)) {
+    try {
+      await execa5("git", ["checkout", "-b", branch, `origin/${branch}`]);
+      const current = await getCurrentBranch();
+      if (current === branch) {
+        await execa5("git", ["checkout", "-"]).catch(() => {
+        });
+      }
+      return;
+    } catch {
+    }
+  }
+  if (branch === "develop") {
+    logger.warn("develop \u5206\u652F\u4E0D\u5B58\u5728\uFF0C\u5C06\u4ECE master \u81EA\u52A8\u521B\u5EFA");
+    try {
+      await execa5("git", ["checkout", "-b", "develop", "master"]);
+      await execa5("git", ["push", "-u", "origin", "develop"]);
+      await execa5("git", ["checkout", "-"]).catch(() => {
+      });
+      return;
+    } catch (err) {
+      logger.error(`\u521B\u5EFA develop \u5206\u652F\u5931\u8D25: ${err.message}`);
+      process.exit(1);
+    }
+  }
+  logger.error(`\u5206\u652F "${branch}" \u4E0D\u5B58\u5728\uFF08\u672C\u5730\u548C\u8FDC\u7AEF\u5747\u672A\u627E\u5230\uFF09`);
+  process.exit(1);
+}
+async function getCurrentBranch() {
+  return GitUtils.getCurrentBranch();
+}
+function getBranchPrefix(branch) {
+  const match = branch.match(/^(feat|fix|hotfix|refactor)\//);
+  return match ? match[1] : null;
+}
+async function branchExistsLocal(branch) {
+  const { execa: execa5 } = await import("execa");
+  try {
+    const { stdout } = await execa5("git", ["branch", "--list", branch]);
+    return stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+async function branchExistsRemote(branch) {
+  const { execa: execa5 } = await import("execa");
+  try {
+    const { stdout } = await execa5("git", ["ls-remote", "--heads", "origin", branch]);
+    return stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+async function scanBranchDiffForDangerousFiles(baseBranch, targetBranch) {
+  const { execa: execa5 } = await import("execa");
+  let diffFiles;
+  try {
+    const { stdout } = await execa5("git", [
+      "diff",
+      "--name-only",
+      `${baseBranch}...${targetBranch}`
+    ]);
+    diffFiles = stdout.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+  const result = [];
+  for (const rule of DANGEROUS_FILE_RULES) {
+    const matched = diffFiles.filter(
+      (file) => rule.patterns.some((pattern) => pattern.test(file))
+    );
+    if (matched.length > 0) {
+      result.push({ category: rule.category, files: matched });
+    }
+  }
+  return result;
+}
+function reportDangerousFilesAndExit(dangerous) {
+  logger.error("\u68C0\u6D4B\u5230\u5371\u9669\u6587\u4EF6\uFF0C\u5DF2\u62E6\u622A\u64CD\u4F5C\uFF1A");
+  for (const group of dangerous) {
+    logger.warn(`  [${group.category}]`);
+    group.files.forEach((f) => logger.info(`    ${f}`));
+  }
+  logger.info("\u8BF7\u4ECE\u5206\u652F\u4E2D\u79FB\u9664\u4EE5\u4E0A\u6587\u4EF6\u540E\u91CD\u8BD5");
+  process.exit(1);
+}
+async function checkUnstableDependencies() {
+  const pkgPath = "package.json";
+  if (!await FileUtils.exists(pkgPath)) {
+    return [];
+  }
+  const pkg2 = JSON.parse(await FileUtils.read(pkgPath));
+  const allDeps = {
+    ...pkg2.dependencies || {},
+    ...pkg2.devDependencies || {}
+  };
+  const unstable = [];
+  for (const [name, version] of Object.entries(allDeps)) {
+    if (UNSTABLE_SUFFIXES.some((suffix) => version.includes(suffix))) {
+      unstable.push({ name, version });
+    }
+  }
+  return unstable;
+}
+async function readVersion(pkgPath = "package.json") {
+  if (!await FileUtils.exists(pkgPath)) {
+    logger.error("package.json \u4E0D\u5B58\u5728");
+    process.exit(1);
+  }
+  const pkg2 = JSON.parse(await FileUtils.read(pkgPath));
+  return pkg2.version || "0.0.0";
+}
+function bumpVersion(currentVersion, type) {
+  const parts = currentVersion.split(".").map(Number);
+  if (parts.length !== 3 || parts.some(isNaN)) {
+    logger.error(`\u65E0\u6548\u7684\u7248\u672C\u53F7: ${currentVersion}`);
+    process.exit(1);
+  }
+  switch (type) {
+    case "major":
+      return `${parts[0] + 1}.0.0`;
+    case "minor":
+      return `${parts[0]}.${parts[1] + 1}.0`;
+    case "patch":
+      return `${parts[0]}.${parts[1]}.${parts[2] + 1}`;
+  }
+}
+async function setVersion(version, pkgPath = "package.json") {
+  const content = await FileUtils.read(pkgPath);
+  const pkg2 = JSON.parse(content);
+  pkg2.version = version;
+  await FileUtils.write(pkgPath, JSON.stringify(pkg2, null, 2) + "\n");
+}
+var VALID_BRANCH_PREFIXES, DANGEROUS_FILE_RULES, UNSTABLE_SUFFIXES;
+var init_fe_git = __esm({
+  "src/lib/fe-git.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    init_logger();
+    VALID_BRANCH_PREFIXES = ["feat", "fix", "hotfix", "refactor"];
+    DANGEROUS_FILE_RULES = [
+      {
+        category: "\u6784\u5EFA\u4EA7\u7269",
+        patterns: [/^dist\//, /^build\//, /^\.output\//]
+      },
+      {
+        category: "\u73AF\u5883\u53D8\u91CF",
+        patterns: [/^\.env$/, /^\.env\./]
+      },
+      {
+        category: "\u4F9D\u8D56\u76EE\u5F55",
+        patterns: [/^node_modules\//]
+      },
+      {
+        category: "\u79D8\u94A5/\u8BC1\u4E66",
+        patterns: [
+          /\.pem$/,
+          /\.key$/,
+          /\.p12$/,
+          /\.pfx$/,
+          /\.cert$/,
+          /credentials\.json$/,
+          /_rsa$/,
+          /id_ed25519$/
+        ]
+      },
+      {
+        category: "\u654F\u611F\u914D\u7F6E",
+        patterns: [/^\.npmrc$/, /^\.docker\/config\.json$/]
+      }
+    ];
+    UNSTABLE_SUFFIXES = ["-alpha", "-beta", "-dev", "-rc", "-canary", "-next"];
+  }
+});
+
+// src/commands/fe-start.ts
+import { Command as Command18 } from "commander";
+import inquirer13 from "inquirer";
+var feStartCommand;
+var init_fe_start = __esm({
+  "src/commands/fe-start.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_fe_git();
+    feStartCommand = new Command18("fe-start").description("\u521B\u5EFA\u524D\u7AEF\u5DE5\u4F5C\u5206\u652F (\u4ECE master \u5207\u51FA)").argument("<name>", "\u5206\u652F\u540D\u79F0").option("--type <type>", "\u5206\u652F\u7C7B\u578B (feat|fix|hotfix|refactor)").action(async (name, opts) => {
+      try {
+        const { execa: execa5 } = await import("execa");
+        await ensureGitRepo();
+        let branchType = opts.type;
+        if (!branchType) {
+          const answer = await inquirer13.prompt([
+            {
+              type: "list",
+              name: "type",
+              message: "\u8BF7\u9009\u62E9\u5206\u652F\u7C7B\u578B:",
+              choices: [...VALID_BRANCH_PREFIXES]
+            }
+          ]);
+          branchType = answer.type;
+        }
+        const branchFullName = `${branchType}/${name}`;
+        let didStash = false;
+        const { stdout: statusOutput } = await execa5("git", ["status", "--porcelain"]);
+        if (statusOutput.trim()) {
+          logger.warn("\u68C0\u6D4B\u5230\u672A\u63D0\u4EA4\u7684\u66F4\u6539\uFF0C\u6682\u5B58\u5230 stash...");
+          await execa5("git", ["stash"]);
+          didStash = true;
+        }
+        await ensureBranchExists("master");
+        await execa5("git", ["checkout", "master"]);
+        logger.step("\u62C9\u53D6 master \u6700\u65B0\u4EE3\u7801...");
+        await execa5("git", ["pull", "origin", "master"]);
+        const localExists = await branchExistsLocal(branchFullName);
+        const remoteExists = await branchExistsRemote(branchFullName);
+        if (localExists || remoteExists) {
+          const { overwrite } = await inquirer13.prompt([
+            {
+              type: "confirm",
+              name: "overwrite",
+              message: `\u5206\u652F "${branchFullName}" \u5DF2\u5B58\u5728\uFF0C\u662F\u5426\u8986\u76D6?`,
+              default: false
+            }
+          ]);
+          if (!overwrite) {
+            logger.warn("\u5DF2\u53D6\u6D88\u64CD\u4F5C");
+            if (didStash) {
+              await execa5("git", ["stash", "pop"]);
+            }
+            return;
+          }
+          if (localExists) {
+            await execa5("git", ["branch", "-D", branchFullName]);
+          }
+        }
+        await execa5("git", ["checkout", "-b", branchFullName]);
+        if (didStash) {
+          try {
+            await execa5("git", ["stash", "pop"]);
+          } catch (e) {
+            logger.warn(`\u6062\u590D stash \u65F6\u51FA\u73B0\u51B2\u7A81\uFF0C\u8BF7\u624B\u52A8\u5904\u7406: ${e.message}`);
+          }
+        }
+        logger.success(`\u5DE5\u4F5C\u5206\u652F "${branchFullName}" \u521B\u5EFA\u6210\u529F (\u57FA\u4E8E master)`);
+      } catch (error) {
+        logger.error(`\u521B\u5EFA\u5DE5\u4F5C\u5206\u652F\u5931\u8D25: ${error.message}`);
+        process.exit(1);
+      }
+    });
+  }
+});
+
+// src/commands/fe-dev.ts
+import { Command as Command19 } from "commander";
+var feDevCommand;
+var init_fe_dev = __esm({
+  "src/commands/fe-dev.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_fe_git();
+    feDevCommand = new Command19("fe-dev").description("\u5408\u5165 develop \u5206\u652F\u63D0\u6D4B").action(async () => {
+      try {
+        const { execa: execa5 } = await import("execa");
+        await ensureGitRepo();
+        await ensureCleanWorkingTree();
+        const currentBranch = await ensureOnBranch();
+        logger.step("\u626B\u63CF\u5371\u9669\u6587\u4EF6...");
+        const dangerous = await scanBranchDiffForDangerousFiles("develop", currentBranch);
+        if (dangerous.length > 0) {
+          reportDangerousFilesAndExit(dangerous);
+        }
+        await ensureBranchExists("develop");
+        logger.step("\u5207\u6362\u5230 develop \u5206\u652F...");
+        await execa5("git", ["checkout", "develop"]);
+        logger.step("\u62C9\u53D6\u6700\u65B0 develop...");
+        await execa5("git", ["pull", "origin", "develop"]);
+        logger.step(`\u5408\u5E76 ${currentBranch} \u5230 develop...`);
+        try {
+          await execa5("git", ["merge", currentBranch, "--no-ff"]);
+        } catch (mergeErr) {
+          await execa5("git", ["merge", "--abort"]).catch(() => {
+          });
+          await execa5("git", ["checkout", currentBranch]);
+          logger.error(`\u5408\u5E76 ${currentBranch} \u5230 develop \u5931\u8D25: ${mergeErr.stderr || mergeErr.message}`);
+          logger.info("\u8BF7\u624B\u52A8\u89E3\u51B3\u540E\u91CD\u8BD5");
+          process.exit(1);
+        }
+        logger.step("\u63A8\u9001 develop \u5230\u8FDC\u7AEF...");
+        await execa5("git", ["push", "origin", "develop"]);
+        logger.step(`\u5207\u56DE ${currentBranch}...`);
+        await execa5("git", ["checkout", currentBranch]);
+        logger.success(`\u5DF2\u5408\u5165 develop \u5E76\u63A8\u9001\uFF0C\u5DF2\u5207\u56DE ${currentBranch}`);
+      } catch (error) {
+        logger.error(`fe-dev \u6267\u884C\u5931\u8D25: ${error.message}`);
+        process.exit(1);
+      }
+    });
+  }
+});
+
+// src/commands/fe-release.ts
+import { Command as Command20 } from "commander";
+import inquirer14 from "inquirer";
+var feReleaseCommand;
+var init_fe_release = __esm({
+  "src/commands/fe-release.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_fe_git();
+    feReleaseCommand = new Command20("fe-release").argument("[version]", "\u6307\u5B9A\u7248\u672C\u53F7").option("--minor", "\u9012\u589E minor \u7248\u672C").option("--major", "\u9012\u589E major \u7248\u672C").description("\u521B\u5EFA release \u5206\u652F (\u4ECE master \u5207\u51FA\u5E76\u5408\u5165\u5F53\u524D\u7279\u6027)").action(async (versionArg, opts) => {
+      try {
+        const { execa: execa5 } = await import("execa");
+        logger.step("\u68C0\u67E5 Git \u4ED3\u5E93\u72B6\u6001...");
+        await ensureGitRepo();
+        await ensureCleanWorkingTree();
+        const currentBranch = await ensureOnBranch();
+        logger.step("\u68C0\u67E5\u4E0D\u7A33\u5B9A\u4F9D\u8D56...");
+        const unstable = await checkUnstableDependencies();
+        if (unstable.length > 0) {
+          unstable.forEach((dep) => {
+            logger.warn(`  ${dep.name}: ${dep.version}`);
+          });
+          const { shouldContinue } = await inquirer14.prompt([
+            {
+              type: "confirm",
+              name: "shouldContinue",
+              message: "\u68C0\u6D4B\u5230\u4E0D\u7A33\u5B9A\u4F9D\u8D56\uFF0C\u662F\u5426\u7EE7\u7EED\uFF1F",
+              default: false
+            }
+          ]);
+          if (!shouldContinue) {
+            process.exit(1);
+          }
+        }
+        logger.step("\u626B\u63CF\u5371\u9669\u6587\u4EF6...");
+        const dangerous = await scanBranchDiffForDangerousFiles("master", currentBranch);
+        if (dangerous.length > 0) {
+          reportDangerousFilesAndExit(dangerous);
+        }
+        logger.step("\u786E\u4FDD master \u5206\u652F\u5B58\u5728...");
+        await ensureBranchExists("master");
+        logger.step("\u5207\u6362\u5230 master \u5E76\u62C9\u53D6\u6700\u65B0\u4EE3\u7801...");
+        await execa5("git", ["checkout", "master"]);
+        await execa5("git", ["pull", "origin", "master"]);
+        let version;
+        if (versionArg) {
+          version = versionArg;
+        } else {
+          const currentVersion = await readVersion();
+          if (opts.major) {
+            version = bumpVersion(currentVersion, "major");
+          } else if (opts.minor) {
+            version = bumpVersion(currentVersion, "minor");
+          } else {
+            version = bumpVersion(currentVersion, "patch");
+          }
+        }
+        const releaseBranch = `release/${version}`;
+        logger.step(`\u68C0\u67E5\u8FDC\u7AEF\u662F\u5426\u5DF2\u5B58\u5728 ${releaseBranch}...`);
+        if (await branchExistsRemote(releaseBranch)) {
+          logger.error(`\u8FDC\u7AEF\u5DF2\u5B58\u5728 ${releaseBranch} \u5206\u652F`);
+          await execa5("git", ["checkout", currentBranch]);
+          process.exit(1);
+        }
+        logger.step(`\u521B\u5EFA\u5206\u652F ${releaseBranch}...`);
+        await execa5("git", ["checkout", "-b", releaseBranch]);
+        logger.step(`\u5408\u5E76 ${currentBranch} \u5230 ${releaseBranch}...`);
+        try {
+          await execa5("git", ["merge", currentBranch, "--no-ff"]);
+        } catch (mergeErr) {
+          logger.error(`\u5408\u5E76 ${currentBranch} \u5931\u8D25: ${mergeErr.stderr || mergeErr.message}`);
+          await execa5("git", ["merge", "--abort"]).catch(() => {
+          });
+          await execa5("git", ["checkout", currentBranch]);
+          await execa5("git", ["branch", "-D", releaseBranch]).catch(() => {
+          });
+          process.exit(1);
+        }
+        logger.step(`\u5199\u5165\u7248\u672C\u53F7 ${version}...`);
+        await setVersion(version);
+        await execa5("git", ["add", "package.json"]);
+        await execa5("git", ["commit", "-m", `chore: bump version to ${version}`]);
+        logger.step(`\u63A8\u9001 ${releaseBranch} \u5230\u8FDC\u7AEF...`);
+        await execa5("git", ["push", "origin", releaseBranch]);
+        logger.success(`${releaseBranch} \u521B\u5EFA\u5E76\u63A8\u9001\u6210\u529F`);
+      } catch (error) {
+        logger.error(`\u521B\u5EFA release \u5206\u652F\u5931\u8D25: ${error.message}`);
+        if (process.env.DEBUG) {
+          console.error(error);
+        }
+        process.exit(1);
+      }
+    });
+  }
+});
+
+// src/commands/fe-sync.ts
+import { Command as Command21 } from "commander";
+var feSyncCommand;
+var init_fe_sync = __esm({
+  "src/commands/fe-sync.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_fe_git();
+    feSyncCommand = new Command21("fe-sync").description("\u540C\u6B65 master \u6700\u65B0\u4EE3\u7801\u5230\u5F53\u524D\u5206\u652F").action(async () => {
+      try {
+        await ensureGitRepo();
+        await ensureCleanWorkingTree();
+        const currentBranch = await ensureOnBranch();
+        const { execa: execa5 } = await import("execa");
+        logger.step("\u6B63\u5728\u62C9\u53D6 origin/master \u6700\u65B0\u4EE3\u7801...");
+        await execa5("git", ["fetch", "origin", "master"]);
+        logger.step("\u6B63\u5728\u5408\u5E76 origin/master \u5230\u5F53\u524D\u5206\u652F...");
+        try {
+          await execa5("git", ["merge", "origin/master", "--no-ff"]);
+        } catch (mergeErr) {
+          await execa5("git", ["merge", "--abort"]).catch(() => {
+          });
+          logger.error(`\u5408\u5E76\u5931\u8D25: ${mergeErr.stderr || mergeErr.message}`);
+          logger.info("\u8BF7\u624B\u52A8\u89E3\u51B3\u540E\u91CD\u8BD5");
+          process.exit(1);
+        }
+        logger.success("\u5DF2\u540C\u6B65 master \u6700\u65B0\u4EE3\u7801\u5230 " + currentBranch);
+      } catch (error) {
+        logger.error(`\u540C\u6B65\u5931\u8D25: ${error.message}`);
+        if (process.env.DEBUG) {
+          console.error(error);
+        }
+        process.exit(1);
+      }
+    });
+  }
+});
+
 // src/index.ts
 var index_exports = {};
-import { Command as Command18 } from "commander";
+import { Command as Command22 } from "commander";
 import chalk4 from "chalk";
 import fs6 from "fs-extra";
 import path21 from "path";
@@ -8880,6 +8603,12 @@ function showHelp() {
   console.log("  team-cli update                    \u68C0\u67E5\u5E76\u66F4\u65B0\u6A21\u677F\u7248\u672C");
   console.log("  team-cli config                    \u7BA1\u7406 GitLab \u914D\u7F6E");
   console.log("  team-cli diff                      \u5BF9\u6BD4\u672C\u5730\u4E0E\u8FDC\u7A0B\u6A21\u677F\u5DEE\u5F02");
+  console.log("");
+  console.log(chalk4.bold("\u524D\u7AEF Git \u5DE5\u4F5C\u6D41:"));
+  console.log("  team-cli fe-start <name>           \u521B\u5EFA\u524D\u7AEF\u5DE5\u4F5C\u5206\u652F (\u4ECE master \u5207\u51FA)");
+  console.log("  team-cli fe-dev                    \u5408\u5165 develop \u5206\u652F\u63D0\u6D4B");
+  console.log("  team-cli fe-release [version]      \u521B\u5EFA release \u5206\u652F");
+  console.log("  team-cli fe-sync                   \u540C\u6B65 master \u6700\u65B0\u4EE3\u7801\u5230\u5F53\u524D\u5206\u652F");
   console.log("  team-cli --help                    \u663E\u793A\u5E2E\u52A9\u4FE1\u606F");
   console.log("");
   console.log(chalk4.bold("\u793A\u4F8B:"));
@@ -8938,9 +8667,13 @@ var init_index = __esm({
     init_update();
     init_config();
     init_diff();
+    init_fe_start();
+    init_fe_dev();
+    init_fe_release();
+    init_fe_sync();
     __dirname2 = path21.dirname(fileURLToPath2(import.meta.url));
     pkg = fs6.readJsonSync(path21.join(__dirname2, "../package.json"));
-    program = new Command18();
+    program = new Command22();
     program.name("team-cli").description("AI-Native \u56E2\u961F\u7814\u53D1\u811A\u624B\u67B6").version(pkg.version);
     program.option("-v, --verbose", "\u8BE6\u7EC6\u8F93\u51FA\u6A21\u5F0F").option("--debug", "\u8C03\u8BD5\u6A21\u5F0F");
     program.addCommand(initCommand);
@@ -8961,6 +8694,10 @@ var init_index = __esm({
     program.addCommand(updateCommand);
     program.addCommand(configCommand);
     program.addCommand(diffCommand);
+    program.addCommand(feStartCommand);
+    program.addCommand(feDevCommand);
+    program.addCommand(feReleaseCommand);
+    program.addCommand(feSyncCommand);
     program.action(() => {
       showHelp();
     });