yg-team-cli 2.0.0 → 2.1.1

package/dist/cli.js

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // node_modules/tsup/assets/esm_shims.js
 import path from "path";
@@ -177,6 +182,238 @@ var init_logger = __esm({
   }
 });
 
+// src/lib/utils.ts
+import fs from "fs-extra";
+import path2 from "path";
+import { glob } from "glob";
+var FileUtils, StringUtils2, DateUtils, GitUtils, SpecUtils;
+var init_utils = __esm({
+  "src/lib/utils.ts"() {
+    "use strict";
+    init_esm_shims();
+    FileUtils = class {
+      /**
+       * 确保目录存在
+       */
+      static async ensureDir(dir) {
+        await fs.ensureDir(dir);
+      }
+      /**
+       * 读取文件内容
+       */
+      static async read(file) {
+        return await fs.readFile(file, "utf-8");
+      }
+      /**
+       * 写入文件内容
+       */
+      static async write(file, content) {
+        await fs.writeFile(file, content, "utf-8");
+      }
+      /**
+       * 检查文件是否存在
+       */
+      static async exists(file) {
+        return await fs.pathExists(file);
+      }
+      /**
+       * 复制文件
+       */
+      static async copy(src, dest) {
+        await fs.copy(src, dest);
+      }
+      /**
+       * 删除文件或目录
+       */
+      static async remove(file) {
+        await fs.remove(file);
+      }
+      /**
+       * 移动文件
+       */
+      static async move(src, dest) {
+        await fs.move(src, dest);
+      }
+      /**
+       * 使用 glob 查找文件
+       */
+      static async findFiles(pattern, cwd) {
+        return await glob(pattern, {
+          cwd,
+          absolute: false,
+          nodir: true
+        });
+      }
+      /**
+       * 读取 JSON 文件
+       */
+      static async readJson(file) {
+        return await fs.readJson(file);
+      }
+      /**
+       * 写入 JSON 文件
+       */
+      static async writeJson(file, data) {
+        await fs.writeJson(file, data, { spaces: 2 });
+      }
+    };
+    StringUtils2 = class {
+      /**
+       * 转换为 kebab-case
+       */
+      static toKebabCase(str) {
+        return str.toLowerCase().replace(/[\s_]+/g, "-").replace(/[^\w\-]/g, "").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+      }
+      /**
+       * 转换为 PascalCase
+       */
+      static toPascalCase(str) {
+        return str.replace(/[-_\s](\w)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toUpperCase());
+      }
+      /**
+       * 转换为 camelCase
+       */
+      static toCamelCase(str) {
+        const pascal = this.toPascalCase(str);
+        return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+      }
+      /**
+       * 转换为 snake_case
+       */
+      static toSnakeCase(str) {
+        return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`).replace(/^_/, "").replace(/-+/g, "_").replace(/[\s]+/g, "_");
+      }
+      /**
+       * 首字母大写
+       */
+      static capitalize(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+      }
+      /**
+       * 截断字符串
+       */
+      static truncate(str, length, suffix = "...") {
+        if (str.length <= length) return str;
+        return str.slice(0, length - suffix.length) + suffix;
+      }
+      /**
+       * 生成 slug
+       */
+      static slugify(str) {
+        return str.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+      }
+    };
+    DateUtils = class _DateUtils {
+      /**
+       * 格式化日期
+       */
+      static format(date = /* @__PURE__ */ new Date(), format = "YYYY-MM-DD HH:mm:ss") {
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, "0");
+        const day = String(date.getDate()).padStart(2, "0");
+        const hours = String(date.getHours()).padStart(2, "0");
+        const minutes = String(date.getMinutes()).padStart(2, "0");
+        const seconds = String(date.getSeconds()).padStart(2, "0");
+        return format.replace("YYYY", String(year)).replace("MM", month).replace("DD", day).replace("HH", hours).replace("mm", minutes).replace("ss", seconds);
+      }
+      /**
+       * 获取相对时间
+       */
+      static relative(date) {
+        const now = /* @__PURE__ */ new Date();
+        const diff = now.getTime() - date.getTime();
+        const seconds = Math.floor(diff / 1e3);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 7) {
+          return _DateUtils.format(date, "YYYY-MM-DD");
+        } else if (days > 0) {
+          return `${days} \u5929\u524D`;
+        } else if (hours > 0) {
+          return `${hours} \u5C0F\u65F6\u524D`;
+        } else if (minutes > 0) {
+          return `${minutes} \u5206\u949F\u524D`;
+        } else {
+          return "\u521A\u521A";
+        }
+      }
+    };
+    GitUtils = class {
+      /**
+       * 检查是否在 Git 仓库中
+       */
+      static async isGitRepo(cwd = process.cwd()) {
+        const gitDir = path2.join(cwd, ".git");
+        return await FileUtils.exists(gitDir);
+      }
+      /**
+       * 获取当前分支名
+       */
+      static async getCurrentBranch(cwd = process.cwd()) {
+        const { execa: execa5 } = await import("execa");
+        const { stdout } = await execa5("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+          cwd
+        });
+        return stdout.trim();
+      }
+      /**
+       * 获取当前 commit hash
+       */
+      static async getCurrentCommit(cwd = process.cwd()) {
+        const { execa: execa5 } = await import("execa");
+        const { stdout } = await execa5("git", ["rev-parse", "HEAD"], { cwd });
+        return stdout.trim().slice(0, 7);
+      }
+    };
+    SpecUtils = class {
+      /**
+       * 解析 spec 文件
+       */
+      static async parseSpec(file) {
+        const content = await FileUtils.read(file);
+        const spec = {};
+        const titleMatch = content.match(/^#\s+(.+)$/m);
+        if (titleMatch) {
+          spec.title = titleMatch[1];
+        }
+        const nameMatch = content.match(/\*\*功能名称\*\*:\s*(.+)$/m);
+        if (nameMatch) {
+          spec.name = nameMatch[1];
+        }
+        const priorityMatch = content.match(/\*\*优先级\*\*:\s*(P[0-2])/);
+        if (priorityMatch) {
+          spec.priority = priorityMatch[1];
+        }
+        const statusMatch = content.match(/\*\*状态\*\*:\s*(.+)$/m);
+        if (statusMatch) {
+          spec.status = statusMatch[1];
+        }
+        const depSection = content.match(/## 依赖关系\s+([\s\S]+?)##/m);
+        if (depSection) {
+          const depMatches = depSection[1].matchAll(/- \[([ x])\]\s*(.+)$/gm);
+          spec.dependencies = Array.from(depMatches).map((m) => ({
+            completed: m[1] === "x",
+            name: m[2]
+          }));
+        }
+        return spec;
+      }
+      /**
+       * 获取 spec 状态
+       */
+      static async getSpecStatus(file) {
+        try {
+          const spec = await this.parseSpec(file);
+          return spec.status || "\u672A\u77E5";
+        } catch {
+          return "\u9519\u8BEF";
+        }
+      }
+    };
+  }
+});
+
 // src/lib/claude.ts
 import { execa } from "execa";
 var ClaudeAI, claudeAI;
@@ -185,6 +422,7 @@ var init_claude = __esm({
     "use strict";
     init_esm_shims();
     init_logger();
+    init_utils();
     ClaudeAI = class {
       verbose;
       constructor(verbose = false) {
@@ -218,25 +456,45 @@ var init_claude = __esm({
       async prompt(promptText, options) {
         const spinner = logger.startLoading("\u6B63\u5728\u8C03\u7528 Claude...");
         try {
-          const args = ["--no-confirm", "-p", promptText];
+          const args = [];
+          const validContextFiles = [];
           if (options?.contextFiles && options.contextFiles.length > 0) {
             for (const file of options.contextFiles) {
-              args.unshift("--context", file);
+              const exists = await FileUtils.exists(file);
+              if (exists) {
+                validContextFiles.push(file);
+              } else {
+                logger.warn(`\u4E0A\u4E0B\u6587\u6587\u4EF6\u4E0D\u5B58\u5728\uFF0C\u5DF2\u8DF3\u8FC7: ${file}`);
+              }
+            }
+            for (const file of validContextFiles) {
+              args.push("--context", file);
             }
           }
-          const { stdout } = await execa("claude", args, {
+          args.push("--no-confirm", "-p", promptText);
+          const result = await execa("claude", args, {
             stdio: this.verbose ? "inherit" : "pipe",
-            timeout: options?.timeout || 3e5
+            timeout: options?.timeout || 3e5,
             // 默认 5 分钟
+            reject: false
+            // 不自动拒绝非零退出码
           });
           spinner.succeed("Claude \u54CD\u5E94\u5B8C\u6210");
-          return stdout;
+          if (result.exitCode !== 0 && !result.stdout) {
+            const stderr = result.stderr || "";
+            throw new Error(`Claude \u547D\u4EE4\u6267\u884C\u5931\u8D25 (\u9000\u51FA\u7801: ${result.exitCode})${stderr ? `
+${stderr}` : ""}`);
+          }
+          return result.stdout || "";
         } catch (error) {
           spinner.fail("Claude \u8C03\u7528\u5931\u8D25");
           if (error.killed && error.signal === "SIGTERM") {
             throw new Error("Claude \u6267\u884C\u8D85\u65F6");
           }
-          throw new Error(`Claude \u8C03\u7528\u5931\u8D25: ${error.message}`);
+          const stderr = error.stderr || "";
+          const exitCode = error.exitCode !== void 0 ? ` (\u9000\u51FA\u7801: ${error.exitCode})` : "";
+          throw new Error(`Claude \u8C03\u7528\u5931\u8D25: ${error.message}${exitCode}${stderr ? `
+${stderr}` : ""}`);
         }
       }
       /**
@@ -260,12 +518,17 @@ var init_claude = __esm({
             const role = msg.role === "system" ? "\u7CFB\u7EDF\u6307\u4EE4" : `${msg.role === "user" ? "\u7528\u6237" : "\u52A9\u624B"}`;
             return `[${role}]: ${msg.content}`;
           }).join("\n\n");
-          const { stdout } = await execa("claude", ["--no-confirm", "-p", fullPrompt], {
+          const args = ["--no-confirm", "-p", fullPrompt];
+          const result = await execa("claude", args, {
             stdio: this.verbose ? "inherit" : "pipe",
-            timeout: options?.timeout || 3e5
+            timeout: options?.timeout || 3e5,
+            reject: false
           });
           spinner.succeed("Claude \u54CD\u5E94\u5B8C\u6210");
-          return stdout;
+          if (result.exitCode !== 0 && !result.stdout) {
+            throw new Error(`Claude \u547D\u4EE4\u6267\u884C\u5931\u8D25 (\u9000\u51FA\u7801: ${result.exitCode})`);
+          }
+          return result.stdout || "";
         } catch (error) {
           spinner.fail("Claude \u8C03\u7528\u5931\u8D25");
           throw error;
@@ -478,232 +741,556 @@ ${projectContext}
   }
 });
 
-// src/lib/utils.ts
-import fs from "fs-extra";
-import path2 from "path";
-import { glob } from "glob";
-var FileUtils, StringUtils2, DateUtils, GitUtils, SpecUtils;
-var init_utils = __esm({
-  "src/lib/utils.ts"() {
+// src/lib/template-version.ts
+import { execa as execa2 } from "execa";
+import path3 from "path";
+function getConfigPath(projectPath) {
+  return path3.join(projectPath, ".team-cli", "template.json");
+}
+async function readTemplateConfig(projectPath) {
+  const configPath = getConfigPath(projectPath);
+  const exists = await FileUtils.exists(configPath);
+  if (!exists) {
+    return null;
+  }
+  try {
+    const content = await FileUtils.read(configPath);
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function saveTemplateConfig(projectPath, config) {
+  const configDir = path3.join(projectPath, ".team-cli");
+  await FileUtils.ensureDir(configDir);
+  const configPath = getConfigPath(projectPath);
+  const content = JSON.stringify(config, null, 2);
+  await FileUtils.write(configPath, content);
+}
+async function initTemplateConfig(projectPath) {
+  const config = await readTemplateConfig(projectPath);
+  if (config) {
+    return;
+  }
+  await saveTemplateConfig(projectPath, DEFAULT_TEMPLATES);
+}
+async function getLatestCommit(repository) {
+  try {
+    const { stdout } = await execa2("git", ["ls-remote", repository, "HEAD"], {
+      stdio: "pipe"
+    });
+    const commit = stdout.split("	")[0];
+    return commit;
+  } catch (error) {
+    logger.debug(`\u83B7\u53D6 ${repository} \u6700\u65B0 commit \u5931\u8D25: ${error}`);
+    return "";
+  }
+}
+async function getLatestTag(repository) {
+  try {
+    const { stdout } = await execa2(
+      "git",
+      ["ls-remote", "--tags", repository],
+      {
+        stdio: "pipe"
+      }
+    );
+    const tags = stdout.split("\n").filter((line) => line.includes("refs/tags/") && !line.includes("^{}")).map((line) => {
+      const [, ref] = line.split("	");
+      return ref.replace("refs/tags/", "");
+    }).filter((tag) => /^v?\d+\.\d+\.\d+/.test(tag)).sort((a, b) => {
+      const va = a.replace(/^v/, "").split(".").map(Number);
+      const vb = b.replace(/^v/, "").split(".").map(Number);
+      for (let i = 0; i < 3; i++) {
+        if ((va[i] || 0) > (vb[i] || 0)) return 1;
+        if ((va[i] || 0) < (vb[i] || 0)) return -1;
+      }
+      return 0;
+    });
+    return tags[tags.length - 1] || "";
+  } catch (error) {
+    logger.debug(`\u83B7\u53D6 ${repository} \u6700\u65B0 tag \u5931\u8D25: ${error}`);
+    return "";
+  }
+}
+async function checkTemplateUpdate(projectPath, type) {
+  const config = await readTemplateConfig(projectPath);
+  if (!config || !config[type]) {
+    return null;
+  }
+  const repository = config[type].repository;
+  const currentCommit = config[type].commit;
+  const currentTag = config[type].tag;
+  const latestCommit = await getLatestCommit(repository);
+  const latestTag = await getLatestTag(repository);
+  if (!latestCommit) {
+    return null;
+  }
+  const needsUpdate = currentCommit && currentCommit !== latestCommit;
+  return {
+    type,
+    repository,
+    currentCommit,
+    currentTag,
+    latestCommit,
+    latestTag,
+    needsUpdate: needsUpdate || false
+  };
+}
+async function updateTemplateVersion(projectPath, type, commit, options) {
+  const config = await readTemplateConfig(projectPath);
+  if (!config) {
+    return;
+  }
+  config[type].commit = commit;
+  if (options?.tag) {
+    config[type].tag = options.tag;
+  }
+  if (options?.branch) {
+    config[type].branch = options.branch;
+  }
+  config[type].lastUpdate = (/* @__PURE__ */ new Date()).toISOString();
+  await saveTemplateConfig(projectPath, config);
+}
+var DEFAULT_TEMPLATES;
+var init_template_version = __esm({
+  "src/lib/template-version.ts"() {
     "use strict";
     init_esm_shims();
-    FileUtils = class {
+    init_utils();
+    init_logger();
+    DEFAULT_TEMPLATES = {
+      frontend: {
+        repository: "https://gitlab.yungu-inc.org/static/fe-tpl-ai"
+      },
+      backend: {
+        repository: "git@gitlab.yungu-inc.org:yungu-app/java-scaffold-template.git"
+      }
+    };
+  }
+});
+
+// src/lib/user-config.ts
+var user_config_exports = {};
+__export(user_config_exports, {
+  UserConfigManager: () => UserConfigManager,
+  userConfigManager: () => userConfigManager
+});
+import path4 from "path";
+import os from "os";
+import crypto from "crypto";
+var UserConfigManager, userConfigManager;
+var init_user_config = __esm({
+  "src/lib/user-config.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    init_logger();
+    UserConfigManager = class {
+      configPath;
+      constructor() {
+        const configDir = path4.join(os.homedir(), ".team-cli");
+        this.configPath = path4.join(configDir, "config.json");
+      }
+      /**
+       * 加载用户配置
+       */
+      async load() {
+        try {
+          const exists = await FileUtils.exists(this.configPath);
+          if (!exists) {
+            return null;
+          }
+          const content = await FileUtils.read(this.configPath);
+          const config = JSON.parse(content);
+          if (config.gitlab?.accessToken) {
+            config.gitlab.accessToken = this.decrypt(config.gitlab.accessToken);
+          }
+          return config;
+        } catch (error) {
+          logger.debug(`\u52A0\u8F7D\u7528\u6237\u914D\u7F6E\u5931\u8D25: ${error}`);
+          return null;
+        }
+      }
       /**
-       * 确保目录存在
+       * 保存用户配置
        */
-      static async ensureDir(dir) {
-        await fs.ensureDir(dir);
+      async save(config) {
+        try {
+          const configDir = path4.dirname(this.configPath);
+          await FileUtils.ensureDir(configDir);
+          const configToSave = { ...config };
+          if (configToSave.gitlab?.accessToken) {
+            configToSave.gitlab.accessToken = this.encrypt(configToSave.gitlab.accessToken);
+          }
+          const content = JSON.stringify(configToSave, null, 2);
+          await FileUtils.write(this.configPath, content);
+        } catch (error) {
+          throw new Error(`\u4FDD\u5B58\u7528\u6237\u914D\u7F6E\u5931\u8D25: ${error}`);
+        }
       }
       /**
-       * 读取文件内容
+       * 更新 GitLab Token
        */
-      static async read(file) {
-        return await fs.readFile(file, "utf-8");
+      async updateGitLabToken(token, baseUrl) {
+        const config = await this.load() || {
+          gitlab: {
+            accessToken: "",
+            baseUrl: "https://gitlab.com",
+            timeout: 3e4
+          }
+        };
+        config.gitlab.accessToken = token;
+        if (baseUrl) {
+          config.gitlab.baseUrl = baseUrl;
+        }
+        await this.save(config);
       }
       /**
-       * 写入文件内容
+       * 获取 GitLab Token
        */
-      static async write(file, content) {
-        await fs.writeFile(file, content, "utf-8");
+      async getGitLabToken() {
+        const config = await this.load();
+        return config?.gitlab?.accessToken || null;
       }
       /**
-       * 检查文件是否存在
+       * 获取 GitLab 配置
        */
-      static async exists(file) {
-        return await fs.pathExists(file);
+      async getGitLabConfig() {
+        const config = await this.load();
+        return config?.gitlab || null;
       }
       /**
-       * 复制文件
+       * 检查是否已有配置
        */
-      static async copy(src, dest) {
-        await fs.copy(src, dest);
+      async hasConfig() {
+        const config = await this.load();
+        return config !== null && config.gitlab?.accessToken !== void 0;
       }
       /**
-       * 删除文件或目录
+       * 删除配置
        */
-      static async remove(file) {
-        await fs.remove(file);
+      async removeConfig() {
+        try {
+          const exists = await FileUtils.exists(this.configPath);
+          if (exists) {
+            await FileUtils.remove(this.configPath);
+          }
+        } catch (error) {
+          throw new Error(`\u5220\u9664\u914D\u7F6E\u5931\u8D25: ${error}`);
+        }
       }
       /**
-       * 移动文件
+       * 简单加密 (使用机器特定密钥)
        */
-      static async move(src, dest) {
-        await fs.move(src, dest);
+      encrypt(text) {
+        const key = this.getMachineKey();
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
+        let encrypted = cipher.update(text, "utf8", "hex");
+        encrypted += cipher.final("hex");
+        return iv.toString("hex") + ":" + encrypted;
       }
       /**
-       * 使用 glob 查找文件
+       * 简单解密
        */
-      static async findFiles(pattern, cwd) {
-        return await glob(pattern, {
-          cwd,
-          absolute: false,
-          nodir: true
-        });
+      decrypt(encryptedText) {
+        try {
+          const key = this.getMachineKey();
+          const parts = encryptedText.split(":");
+          const iv = Buffer.from(parts[0], "hex");
+          const encrypted = parts[1];
+          const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+          let decrypted = decipher.update(encrypted, "hex", "utf8");
+          decrypted += decipher.final("utf8");
+          return decrypted;
+        } catch {
+          return encryptedText;
+        }
       }
       /**
-       * 读取 JSON 文件
+       * 获取机器特定密钥
        */
-      static async readJson(file) {
-        return await fs.readJson(file);
+      getMachineKey() {
+        const hostname = os.hostname();
+        const platform = os.platform();
+        const arch = os.arch();
+        const cpus = os.cpus();
+        const machineInfo = `${hostname}-${platform}-${arch}-${cpus[0]?.model || "unknown"}`;
+        return crypto.createHash("sha256").update(machineInfo).digest();
       }
       /**
-       * 写入 JSON 文件
+       * 获取配置目录
        */
-      static async writeJson(file, data) {
-        await fs.writeJson(file, data, { spaces: 2 });
+      getConfigDir() {
+        return path4.dirname(this.configPath);
       }
-    };
-    StringUtils2 = class {
       /**
-       * 转换为 kebab-case
+       * 获取配置文件路径
        */
-      static toKebabCase(str) {
-        return str.toLowerCase().replace(/[\s_]+/g, "-").replace(/[^\w\-]/g, "").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+      getConfigPath() {
+        return this.configPath;
+      }
+    };
+    userConfigManager = new UserConfigManager();
+  }
+});
+
+// src/lib/gitlab-api.ts
+var gitlab_api_exports = {};
+__export(gitlab_api_exports, {
+  GitLabAPI: () => GitLabAPI
+});
+var GitLabAPI;
+var init_gitlab_api = __esm({
+  "src/lib/gitlab-api.ts"() {
+    "use strict";
+    init_esm_shims();
+    GitLabAPI = class {
+      config;
+      defaultTimeout = 3e4;
+      constructor(config) {
+        this.config = {
+          ...config,
+          timeout: config.timeout || this.defaultTimeout
+        };
       }
       /**
-       * 转换为 PascalCase
+       * 验证 Token 是否有效
        */
-      static toPascalCase(str) {
-        return str.replace(/[-_\s](\w)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toUpperCase());
+      async authenticate() {
+        try {
+          const response = await this.request("/user");
+          return response.ok;
+        } catch (error) {
+          return false;
+        }
       }
       /**
-       * 转换为 camelCase
+       * 列出项目的所有 Tags
        */
-      static toCamelCase(str) {
-        const pascal = this.toPascalCase(str);
-        return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+      async listTags(projectPath) {
+        try {
+          const encodedPath = this.encodeProjectPath(projectPath);
+          const response = await this.request(`/projects/${encodedPath}/repository/tags?per_page=100`);
+          if (!response.ok) {
+            throw new Error(`GitLab API \u8BF7\u6C42\u5931\u8D25: ${response.status}`);
+          }
+          const tags = await response.json();
+          return tags.sort((a, b) => {
+            return this.compareVersionStrings(b.name, a.name);
+          });
+        } catch (error) {
+          throw new Error(`\u83B7\u53D6 Tags \u5931\u8D25: ${error}`);
+        }
       }
       /**
-       * 转换为 snake_case
+       * 列出项目的所有 Branches
        */
-      static toSnakeCase(str) {
-        return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`).replace(/^_/, "").replace(/-+/g, "_").replace(/[\s]+/g, "_");
+      async listBranches(projectPath) {
+        try {
+          const encodedPath = this.encodeProjectPath(projectPath);
+          const response = await this.request(`/projects/${encodedPath}/repository/branches?per_page=100`);
+          if (!response.ok) {
+            throw new Error(`GitLab API \u8BF7\u6C42\u5931\u8D25: ${response.status}`);
+          }
+          const branches = await response.json();
+          return branches.sort((a, b) => {
+            if (a.default) return -1;
+            if (b.default) return 1;
+            return a.name.localeCompare(b.name);
+          });
+        } catch (error) {
+          throw new Error(`\u83B7\u53D6 Branches \u5931\u8D25: ${error}`);
+        }
       }
       /**
-       * 首字母大写
+       * 验证 Tag 是否存在
        */
-      static capitalize(str) {
-        return str.charAt(0).toUpperCase() + str.slice(1);
+      async validateTag(projectPath, tag) {
+        try {
+          const tags = await this.listTags(projectPath);
+          return tags.some((t) => t.name === tag);
+        } catch {
+          return false;
+        }
       }
       /**
-       * 截断字符串
+       * 验证 Branch 是否存在
        */
-      static truncate(str, length, suffix = "...") {
-        if (str.length <= length) return str;
-        return str.slice(0, length - suffix.length) + suffix;
+      async validateBranch(projectPath, branch) {
+        try {
+          const branches = await this.listBranches(projectPath);
+          return branches.some((b) => b.name === branch);
+        } catch {
+          return false;
+        }
       }
       /**
-       * 生成 slug
+       * 获取项目信息
        */
-      static slugify(str) {
-        return str.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+      async getProject(projectPath) {
+        try {
+          const encodedPath = this.encodeProjectPath(projectPath);
+          const response = await this.request(`/projects/${encodedPath}`);
+          if (!response.ok) {
+            return null;
+          }
+          return await response.json();
+        } catch {
+          return null;
+        }
       }
-    };
-    DateUtils = class _DateUtils {
       /**
-       * 格式化日期
+       * 获取指定 Tag 的 commit 信息
        */
-      static format(date = /* @__PURE__ */ new Date(), format = "YYYY-MM-DD HH:mm:ss") {
-        const year = date.getFullYear();
-        const month = String(date.getMonth() + 1).padStart(2, "0");
-        const day = String(date.getDate()).padStart(2, "0");
-        const hours = String(date.getHours()).padStart(2, "0");
-        const minutes = String(date.getMinutes()).padStart(2, "0");
-        const seconds = String(date.getSeconds()).padStart(2, "0");
-        return format.replace("YYYY", String(year)).replace("MM", month).replace("DD", day).replace("HH", hours).replace("mm", minutes).replace("ss", seconds);
+      async getTagCommit(projectPath, tag) {
+        try {
+          const tags = await this.listTags(projectPath);
+          const targetTag = tags.find((t) => t.name === tag);
+          return targetTag?.commit.id || null;
+        } catch {
+          return null;
+        }
       }
       /**
-       * 获取相对时间
+       * 获取指定 Branch 的最新 commit 信息
        */
-      static relative(date) {
-        const now = /* @__PURE__ */ new Date();
-        const diff = now.getTime() - date.getTime();
-        const seconds = Math.floor(diff / 1e3);
-        const minutes = Math.floor(seconds / 60);
-        const hours = Math.floor(minutes / 60);
-        const days = Math.floor(hours / 24);
-        if (days > 7) {
-          return _DateUtils.format(date, "YYYY-MM-DD");
-        } else if (days > 0) {
-          return `${days} \u5929\u524D`;
-        } else if (hours > 0) {
-          return `${hours} \u5C0F\u65F6\u524D`;
-        } else if (minutes > 0) {
-          return `${minutes} \u5206\u949F\u524D`;
-        } else {
-          return "\u521A\u521A";
+      async getBranchCommit(projectPath, branch) {
+        try {
+          const encodedPath = this.encodeProjectPath(projectPath);
+          const response = await this.request(
+            `/projects/${encodedPath}/repository/branches/${encodeURIComponent(branch)}`
+          );
+          if (!response.ok) {
+            return null;
+          }
+          const branchInfo = await response.json();
+          return branchInfo.commit.id;
+        } catch {
+          return null;
         }
       }
-    };
-    GitUtils = class {
       /**
-       * 检查是否在 Git 仓库中
+       * 对比两个版本之间的差异
        */
-      static async isGitRepo(cwd = process.cwd()) {
-        const gitDir = path2.join(cwd, ".git");
-        return await FileUtils.exists(gitDir);
+      async compareVersions(projectPath, from, to) {
+        try {
+          const encodedPath = this.encodeProjectPath(projectPath);
+          const response = await this.request(
+            `/projects/${encodedPath}/repository/compare?from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`
+          );
+          if (!response.ok) {
+            return null;
+          }
+          return await response.json();
+        } catch {
+          return null;
+        }
       }
       /**
-       * 获取当前分支名
+       * 比较两个版本号（用于排序）
+       * 返回值: -1 (v1 < v2), 0 (v1 == v2), 1 (v1 > v2)
        */
-      static async getCurrentBranch(cwd = process.cwd()) {
-        const { execa: execa3 } = await import("execa");
-        const { stdout } = await execa3("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-          cwd
-        });
-        return stdout.trim();
+      compareVersionStrings(v1, v2) {
+        const version1 = v1.replace(/^v/, "");
+        const version2 = v2.replace(/^v/, "");
+        const parts1 = version1.split(".").map((p) => parseInt(p, 10) || 0);
+        const parts2 = version2.split(".").map((p) => parseInt(p, 10) || 0);
+        for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+          const p1 = parts1[i] || 0;
+          const p2 = parts2[i] || 0;
+          if (p1 > p2) return 1;
+          if (p1 < p2) return -1;
+        }
+        return 0;
       }
       /**
-       * 获取当前 commit hash
+       * 获取最新的版本（优先 Tag，否则 latest commit）
        */
-      static async getCurrentCommit(cwd = process.cwd()) {
-        const { execa: execa3 } = await import("execa");
-        const { stdout } = await execa3("git", ["rev-parse", "HEAD"], { cwd });
-        return stdout.trim().slice(0, 7);
+      async getLatestVersion(projectPath) {
+        try {
+          const tags = await this.listTags(projectPath);
+          const branches = await this.listBranches(projectPath);
+          if (tags.length > 0) {
+            const latestTag = tags[0];
+            return {
+              type: "tag",
+              name: latestTag.name,
+              commit: latestTag.commit.id
+            };
+          }
+          const defaultBranch = branches.find((b) => b.default);
+          if (defaultBranch) {
+            return {
+              type: "commit",
+              name: defaultBranch.name,
+              commit: defaultBranch.commit.id
+            };
+          }
+          return null;
+        } catch {
+          return null;
+        }
       }
-    };
-    SpecUtils = class {
       /**
-       * 解析 spec 文件
+       * 解析项目路径
+       * 从 Git URL 中提取项目路径
        */
-      static async parseSpec(file) {
-        const content = await FileUtils.read(file);
-        const spec = {};
-        const titleMatch = content.match(/^#\s+(.+)$/m);
-        if (titleMatch) {
-          spec.title = titleMatch[1];
-        }
-        const nameMatch = content.match(/\*\*功能名称\*\*:\s*(.+)$/m);
-        if (nameMatch) {
-          spec.name = nameMatch[1];
-        }
-        const priorityMatch = content.match(/\*\*优先级\*\*:\s*(P[0-2])/);
-        if (priorityMatch) {
-          spec.priority = priorityMatch[1];
-        }
-        const statusMatch = content.match(/\*\*状态\*\*:\s*(.+)$/m);
-        if (statusMatch) {
-          spec.status = statusMatch[1];
+      static parseProjectPath(repository) {
+        let path17 = repository;
+        path17 = path17.replace(/^https?:\/\//, "");
+        path17 = path17.replace(/^git@/, "");
+        const parts = path17.split("/");
+        if (parts.length > 1) {
+          path17 = parts.slice(1).join("/");
         }
-        const depSection = content.match(/## 依赖关系\s+([\s\S]+?)##/m);
-        if (depSection) {
-          const depMatches = depSection[1].matchAll(/- \[([ x])\]\s*(.+)$/gm);
-          spec.dependencies = Array.from(depMatches).map((m) => ({
-            completed: m[1] === "x",
-            name: m[2]
-          }));
+        path17 = path17.replace(/\.git$/, "");
+        return path17;
+      }
+      /**
+       * 编码项目路径用于 API 请求
+       */
+      encodeProjectPath(projectPath) {
+        return encodeURIComponent(projectPath).replace(/%2F/g, "%2F");
+      }
+      /**
+       * 发送 HTTP 请求
+       */
+      async request(endpoint, options = {}) {
+        const url = `${this.config.baseUrl}/api/v4${endpoint}`;
+        const headers = {
+          "PRIVATE-TOKEN": this.config.accessToken,
+          "Content-Type": "application/json",
+          ...options.headers
+        };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+        try {
+          const response = await fetch(url, {
+            ...options,
+            headers,
+            signal: controller.signal
+          });
+          return response;
+        } catch (error) {
+          if (error.name === "AbortError") {
+            throw new Error("\u8BF7\u6C42\u8D85\u65F6");
+          }
+          throw error;
+        } finally {
+          clearTimeout(timeoutId);
         }
-        return spec;
       }
       /**
-       * 获取 spec 状态
+       * 获取默认分支
        */
-      static async getSpecStatus(file) {
+      async getDefaultBranch(projectPath) {
         try {
-          const spec = await this.parseSpec(file);
-          return spec.status || "\u672A\u77E5";
+          const project = await this.getProject(projectPath);
+          return project?.default_branch || null;
         } catch {
-          return "\u9519\u8BEF";
+          return null;
         }
       }
     };
@@ -713,7 +1300,7 @@ var init_utils = __esm({
 // src/commands/init.ts
 import { Command } from "commander";
 import inquirer from "inquirer";
-import path3 from "path";
+import path5 from "path";
 import fs2 from "fs-extra";
 import { Listr } from "listr2";
 async function generateTechStack(projectPath) {
@@ -812,7 +1399,7 @@ docs/
 \u2514\u2500\u2500 sessions/            # \u5F00\u53D1\u4F1A\u8BDD\u8BB0\u5F55
 \`\`\`
 `;
-  await FileUtils.write(path3.join(projectPath, "TECH_STACK.md"), content);
+  await FileUtils.write(path5.join(projectPath, "TECH_STACK.md"), content);
 }
 async function generateConventions(projectPath) {
   const content = `# \u5F00\u53D1\u89C4\u8303
@@ -1115,7 +1702,7 @@ test('renders user name', () => {
 });
 \`\`\`
 `;
-  await FileUtils.write(path3.join(projectPath, "CONVENTIONS.md"), content);
+  await FileUtils.write(path5.join(projectPath, "CONVENTIONS.md"), content);
 }
 async function generateAIMemory(projectPath, projectName) {
   const content = `# AI Memory - \u9879\u76EE\u72B6\u6001\u8BB0\u5F55
@@ -1126,6 +1713,15 @@ async function generateAIMemory(projectPath, projectName) {
 - **\u5F53\u524D\u9636\u6BB5**: \u521D\u59CB\u5316
 - **\u6700\u540E\u66F4\u65B0**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
 
+## \u6A21\u677F\u7248\u672C\u4FE1\u606F
+
+> \u672C\u90E8\u5206\u7531 team-cli \u81EA\u52A8\u7BA1\u7406\uFF0C\u8BB0\u5F55\u4F7F\u7528\u7684\u524D\u540E\u7AEF\u6A21\u677F\u7248\u672C
+
+| \u7C7B\u578B | \u4ED3\u5E93 | Tag | Branch | Commit | \u66F4\u65B0\u65F6\u95F4 |
+|------|------|-----|--------|--------|----------|
+| \u524D\u7AEF | - | - | - | - | - |
+| \u540E\u7AEF | - | - | - | - | - |
+
 ## \u529F\u80FD\u6E05\u5355 (Feature Inventory)
 
 | \u529F\u80FD | Spec \u6587\u4EF6 | \u72B6\u6001 | \u8FDB\u5EA6 | \u5B8C\u6210\u65E5\u671F | \u5907\u6CE8 |
@@ -1165,7 +1761,7 @@ async function generateAIMemory(projectPath, projectName) {
 | Bug ID | \u65E5\u671F | \u95EE\u9898\u63CF\u8FF0 | \u72B6\u6001 |
 |--------|------|---------|------|
 `;
-  await FileUtils.write(path3.join(projectPath, "AI_MEMORY.md"), content);
+  await FileUtils.write(path5.join(projectPath, "AI_MEMORY.md"), content);
 }
 async function generateSpecTemplate(projectPath) {
   const content = `# [\u529F\u80FD\u6807\u9898]
@@ -1229,35 +1825,78 @@ async function generateSpecTemplate(projectPath) {
 ----
 *\u751F\u6210\u4E8E: {{TIMESTAMP}} by team-cli*
 `;
-  await FileUtils.write(path3.join(projectPath, "docs/specs/template.md"), content);
+  await FileUtils.write(path5.join(projectPath, "docs/specs/template.md"), content);
 }
-async function cloneBackendTemplate(projectPath) {
+async function cloneBackendTemplate(projectPath, versionOptions) {
   const templateRepo = process.env.TEMPLATE_REPO || "git@gitlab.yungu-inc.org:yungu-app/java-scaffold-template.git";
-  const backendPath = path3.join(projectPath, "backend");
+  const backendPath = path5.join(projectPath, "backend");
   try {
     const { execaCommand } = await import("execa");
-    const tempDir = path3.join(projectPath, ".template-temp");
-    await execaCommand(`git clone --depth=1 ${templateRepo} ${tempDir}`, {
+    const tempDir = path5.join(projectPath, ".template-temp");
+    if (versionOptions?.tag || versionOptions?.branch) {
+      const { userConfigManager: userConfigManager2 } = await Promise.resolve().then(() => (init_user_config(), user_config_exports));
+      const { GitLabAPI: GitLabAPI2 } = await Promise.resolve().then(() => (init_gitlab_api(), gitlab_api_exports));
+      const config = await userConfigManager2.getGitLabConfig();
+      if (config) {
+        const gitlabAPI = new GitLabAPI2(config);
+        const projectPathEncoded = GitLabAPI2.parseProjectPath(templateRepo);
+        if (versionOptions.tag) {
+          const isValid = await gitlabAPI.validateTag(projectPathEncoded, versionOptions.tag);
+          if (!isValid) {
+            logger.error(`\u540E\u7AEF\u6A21\u677F tag "${versionOptions.tag}" \u4E0D\u5B58\u5728`);
+            process.exit(1);
+          }
+          logger.info(`\u4F7F\u7528\u540E\u7AEF\u6A21\u677F tag: ${versionOptions.tag}`);
+        }
+        if (versionOptions.branch) {
+          const isValid = await gitlabAPI.validateBranch(projectPathEncoded, versionOptions.branch);
+          if (!isValid) {
+            logger.error(`\u540E\u7AEF\u6A21\u677F\u5206\u652F "${versionOptions.branch}" \u4E0D\u5B58\u5728`);
+            process.exit(1);
+          }
+          logger.info(`\u4F7F\u7528\u540E\u7AEF\u6A21\u677F\u5206\u652F: ${versionOptions.branch}`);
+        }
+      } else {
+        logger.warn("\u672A\u914D\u7F6E GitLab Token\uFF0C\u8DF3\u8FC7\u7248\u672C\u9A8C\u8BC1");
+      }
+    }
+    const ref = versionOptions?.tag || versionOptions?.branch || "HEAD";
+    await execaCommand(`git clone --depth=1 --branch ${ref} ${templateRepo} ${tempDir}`, {
       stdio: "inherit",
       timeout: 6e4
     });
+    const { execa: e } = await import("execa");
+    const { stdout: commit } = await e("git", ["rev-parse", "HEAD"], {
+      cwd: tempDir,
+      stdio: "pipe"
+    });
+    const { stdout: tags } = await e("git", ["tag", "-l", "--sort=-v:refname"], {
+      cwd: tempDir,
+      stdio: "pipe"
+    });
+    const latestTag = tags.split("\n")[0] || void 0;
     await fs2.copy(tempDir, backendPath, {
       filter: (src) => !src.includes(".git")
     });
     await fs2.remove(tempDir);
-    const gitDir = path3.join(backendPath, ".git");
+    const gitDir = path5.join(backendPath, ".git");
     if (await FileUtils.exists(gitDir)) {
       await FileUtils.remove(gitDir);
     }
+    await initTemplateConfig(projectPath);
+    await updateTemplateVersion(projectPath, "backend", commit.trim(), {
+      tag: versionOptions?.tag || latestTag,
+      branch: versionOptions?.branch
+    });
   } catch (error) {
     logger.warn("\u514B\u9686\u540E\u7AEF\u6A21\u677F\u5931\u8D25\uFF0C\u521B\u5EFA\u57FA\u7840\u7ED3\u6784");
-    await FileUtils.ensureDir(path3.join(backendPath, "src/main/java/com/example"));
-    await FileUtils.ensureDir(path3.join(backendPath, "src/main/resources"));
-    await FileUtils.ensureDir(path3.join(backendPath, "src/test/java"));
+    await FileUtils.ensureDir(path5.join(backendPath, "src/main/java/com/example"));
+    await FileUtils.ensureDir(path5.join(backendPath, "src/main/resources"));
+    await FileUtils.ensureDir(path5.join(backendPath, "src/test/java"));
   }
 }
 async function generateFrontendScaffold(projectPath) {
-  const frontendPath = path3.join(projectPath, "frontend");
+  const frontendPath = path5.join(projectPath, "frontend");
   try {
     const prompt = `Read TECH_STACK.md and CONVENTIONS.md.
 Initialize a Next.js 14 frontend in ./frontend with:
@@ -1270,16 +1909,16 @@ Initialize a Next.js 14 frontend in ./frontend with:
 Do not run any servers, just generate the folder structure and configuration files.`;
     await claudeAI.prompt(prompt, {
       contextFiles: [
-        path3.join(projectPath, "TECH_STACK.md"),
-        path3.join(projectPath, "CONVENTIONS.md")
+        path5.join(projectPath, "TECH_STACK.md"),
+        path5.join(projectPath, "CONVENTIONS.md")
       ]
     });
   } catch (error) {
     logger.warn("Claude \u751F\u6210\u524D\u7AEF\u5931\u8D25\uFF0C\u5C06\u521B\u5EFA\u57FA\u7840\u7ED3\u6784");
-    await FileUtils.ensureDir(path3.join(frontendPath, "src/app"));
-    await FileUtils.ensureDir(path3.join(frontendPath, "src/components"));
-    await FileUtils.ensureDir(path3.join(frontendPath, "src/lib"));
-    await FileUtils.ensureDir(path3.join(frontendPath, "public"));
+    await FileUtils.ensureDir(path5.join(frontendPath, "src/app"));
+    await FileUtils.ensureDir(path5.join(frontendPath, "src/components"));
+    await FileUtils.ensureDir(path5.join(frontendPath, "src/lib"));
+    await FileUtils.ensureDir(path5.join(frontendPath, "public"));
   }
 }
 async function generateDockerFiles(projectPath) {
@@ -1307,7 +1946,8 @@ var init_init = __esm({
     init_logger();
     init_claude();
     init_utils();
-    initCommand = new Command("init").argument("[project-name]", "\u9879\u76EE\u540D\u79F0").description("\u521D\u59CB\u5316\u65B0\u9879\u76EE").option("-d, --dir <directory>", "\u9879\u76EE\u76EE\u5F55", ".").option("--no-docker", "\u4E0D\u751F\u6210 Docker \u914D\u7F6E").option("--no-git", "\u4E0D\u521D\u59CB\u5316 Git").action(async (projectName, options) => {
+    init_template_version();
+    initCommand = new Command("init").argument("[project-name]", "\u9879\u76EE\u540D\u79F0").description("\u521D\u59CB\u5316\u65B0\u9879\u76EE").option("-d, --dir <directory>", "\u9879\u76EE\u76EE\u5F55", ".").option("--no-docker", "\u4E0D\u751F\u6210 Docker \u914D\u7F6E").option("--no-git", "\u4E0D\u521D\u59CB\u5316 Git").option("--tag <tag>", "\u6307\u5B9A\u6A21\u677F\u6807\u7B7E (\u524D\u540E\u7AEF\u901A\u7528)").option("--backend-tag <tag>", "\u6307\u5B9A\u540E\u7AEF\u6A21\u677F\u6807\u7B7E").option("--frontend-tag <tag>", "\u6307\u5B9A\u524D\u7AEF\u6A21\u677F\u6807\u7B7E").option("--backend-branch <branch>", "\u6307\u5B9A\u540E\u7AEF\u6A21\u677F\u5206\u652F").option("--frontend-branch <branch>", "\u6307\u5B9A\u524D\u7AEF\u6A21\u677F\u5206\u652F").action(async (projectName, options) => {
       try {
         if (!projectName) {
           const answers = await inquirer.prompt([
@@ -1338,7 +1978,7 @@ var init_init = __esm({
           logger.info("\u8BF7\u5B89\u88C5 Claude CLI: npm install -g @anthropic-ai/claude-code");
           process.exit(1);
         }
-        const projectPath = path3.resolve(options.dir, projectName);
+        const projectPath = path5.resolve(options.dir, projectName);
         if (await FileUtils.exists(projectPath)) {
           logger.error(`\u76EE\u5F55\u5DF2\u5B58\u5728: ${projectPath}`);
           logger.info("\u8BF7\u9009\u62E9\u5176\u4ED6\u9879\u76EE\u540D\u79F0\u6216\u5220\u9664\u73B0\u6709\u76EE\u5F55");
@@ -1357,11 +1997,11 @@ var init_init = __esm({
               title: "\u521B\u5EFA\u9879\u76EE\u76EE\u5F55",
               task: async () => {
                 await FileUtils.ensureDir(projectPath);
-                await FileUtils.ensureDir(path3.join(projectPath, "frontend"));
-                await FileUtils.ensureDir(path3.join(projectPath, "backend"));
-                await FileUtils.ensureDir(path3.join(projectPath, "docs/specs"));
-                await FileUtils.ensureDir(path3.join(projectPath, "docs/api"));
-                await FileUtils.ensureDir(path3.join(projectPath, "docs/sessions"));
+                await FileUtils.ensureDir(path5.join(projectPath, "frontend"));
+                await FileUtils.ensureDir(path5.join(projectPath, "backend"));
+                await FileUtils.ensureDir(path5.join(projectPath, "docs/specs"));
+                await FileUtils.ensureDir(path5.join(projectPath, "docs/api"));
+                await FileUtils.ensureDir(path5.join(projectPath, "docs/sessions"));
               }
             },
             {
@@ -1391,7 +2031,12 @@ var init_init = __esm({
             {
               title: "\u514B\u9686\u540E\u7AEF\u6A21\u677F",
               task: async () => {
-                await cloneBackendTemplate(projectPath);
+                const backendTag = options.backendTag || options.tag;
+                const backendBranch = options.backendBranch;
+                await cloneBackendTemplate(projectPath, {
+                  tag: backendTag,
+                  branch: backendBranch
+                });
               }
             },
             {
@@ -1446,7 +2091,7 @@ var init_init = __esm({
 // src/commands/breakdown.ts
 import { Command as Command2 } from "commander";
 import inquirer2 from "inquirer";
-import path4 from "path";
+import path6 from "path";
 import { Listr as Listr2 } from "listr2";
 function buildBreakdownPrompt(specContent) {
   return `Role: Senior Technical Lead and Agile Coach
@@ -1561,9 +2206,9 @@ var init_breakdown = __esm({
                     choices: ctx.specs
                   }
                 ]);
-                return path4.join("docs/specs", selectedFile);
+                return path6.join("docs/specs", selectedFile);
               }
-              const fullPath = specFile.startsWith("docs/specs/") ? specFile : path4.join("docs/specs", specFile);
+              const fullPath = specFile.startsWith("docs/specs/") ? specFile : path6.join("docs/specs", specFile);
               const exists = await FileUtils.exists(fullPath);
               if (!exists) {
                 throw new Error(`Spec \u6587\u4EF6\u4E0D\u5B58\u5728: ${specFile}`);
@@ -1633,7 +2278,7 @@ var init_breakdown = __esm({
 // src/commands/dev.ts
 import { Command as Command3 } from "commander";
 import inquirer3 from "inquirer";
-import path5 from "path";
+import path7 from "path";
 async function selectSpec() {
   logger.step("\u6B65\u9AA4 1/3: \u9009\u62E9 spec \u6587\u4EF6...");
   logger.newLine();
@@ -1649,7 +2294,7 @@ async function selectSpec() {
   }
   const specs = [];
   for (let i = 0; i < specFiles.length; i++) {
-    const file = path5.join(specDir, specFiles[i]);
+    const file = path7.join(specDir, specFiles[i]);
     const spec = await FileUtils.read(file);
     const status = parseSpecStatus(spec);
     const dependencies = parseDependencies(spec);
@@ -1963,8 +2608,8 @@ async function generateSessionLog(specFile, milestone, todo, taskDescription, re
   const sessionDir = "docs/sessions";
   await FileUtils.ensureDir(sessionDir);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const specName = path5.basename(specFile, ".md");
-  const logFile = path5.join(sessionDir, `${timestamp}_${specName}.md`);
+  const specName = path7.basename(specFile, ".md");
+  const logFile = path7.join(sessionDir, `${timestamp}_${specName}.md`);
   const content = `# \u5F00\u53D1\u4F1A\u8BDD\u8BB0\u5F55
 
 **\u65F6\u95F4**: ${(/* @__PURE__ */ new Date()).toLocaleString("zh-CN")}
@@ -2037,7 +2682,7 @@ var init_dev = __esm({
 // src/commands/add-feature.ts
 import { Command as Command4 } from "commander";
 import inquirer4 from "inquirer";
-import path6 from "path";
+import path8 from "path";
 import { Listr as Listr3 } from "listr2";
 async function addFeatureFromPrd(featureName, featureSlug, specFile) {
   const { prdPath } = await inquirer4.prompt([
@@ -2066,7 +2711,7 @@ async function addFeatureFromPrd(featureName, featureSlug, specFile) {
         const specs = files.filter((f) => !f.includes("template"));
         ctx2.completedSpecs = [];
         for (const file of specs) {
-          const status = await SpecUtils.getSpecStatus(path6.join(specDir, file));
+          const status = await SpecUtils.getSpecStatus(path8.join(specDir, file));
           if (status === "\u5DF2\u5B8C\u6210") {
             ctx2.completedSpecs.push(file.replace(".md", ""));
           }
@@ -2138,7 +2783,7 @@ async function addFeatureSimple(featureName, featureSlug, specFile) {
         const specs = files.filter((f) => !f.includes("template"));
         ctx2.completedSpecs = [];
         for (const file of specs) {
-          const status = await SpecUtils.getSpecStatus(path6.join(specDir, file));
+          const status = await SpecUtils.getSpecStatus(path8.join(specDir, file));
           if (status === "\u5DF2\u5B8C\u6210") {
             ctx2.completedSpecs.push(file.replace(".md", ""));
           }
@@ -2235,7 +2880,7 @@ async function buildProjectContext() {
     const files = await FileUtils.findFiles("*.md", "docs/specs");
     const specs = files.filter((f) => !f.includes("template"));
     for (const file of specs) {
-      const status = await SpecUtils.getSpecStatus(path6.join("docs/specs", file));
+      const status = await SpecUtils.getSpecStatus(path8.join("docs/specs", file));
       context.push(`  - ${file.replace(".md", "")} [${status}]`);
     }
   }
@@ -2498,7 +3143,7 @@ var init_add_feature = __esm({
           process.exit(1);
         }
         const featureSlug = StringUtils2.toKebabCase(featureName);
-        const specFile = path6.join("docs/specs", `${featureSlug}.md`);
+        const specFile = path8.join("docs/specs", `${featureSlug}.md`);
         const specExists = await FileUtils.exists(specFile);
         if (specExists) {
           logger.error(`Spec \u6587\u4EF6\u5DF2\u5B58\u5728: ${specFile}`);
@@ -2535,7 +3180,7 @@ var init_add_feature = __esm({
 
 // src/commands/split-prd.ts
 import { Command as Command5 } from "commander";
-import path7 from "path";
+import path9 from "path";
 import { Listr as Listr4 } from "listr2";
 function buildSplitPrdPrompt(prdContent, screenshots, demoRepos) {
   let prompt = `Role: Senior Product Manager and Technical Architect
@@ -2681,7 +3326,7 @@ var init_split_prd = __esm({
               ctx2.prdFiles = [];
               for (const ext of supportedExtensions) {
                 const files = await FileUtils.findFiles(`*.${ext}`, prdFolder);
-                ctx2.prdFiles.push(...files.map((f) => path7.join(prdFolder, f)));
+                ctx2.prdFiles.push(...files.map((f) => path9.join(prdFolder, f)));
               }
               if (ctx2.prdFiles.length === 0) {
                 throw new Error(
@@ -2699,7 +3344,7 @@ var init_split_prd = __esm({
           {
             title: "\u626B\u63CF\u622A\u56FE\u6587\u4EF6",
             task: async (ctx2) => {
-              const screenshotDir = path7.join(prdFolder, "screenshots");
+              const screenshotDir = path9.join(prdFolder, "screenshots");
               const dirExists = await FileUtils.exists(screenshotDir);
               if (!dirExists) {
                 logger.info("\u672A\u627E\u5230 screenshots \u76EE\u5F55\uFF0C\u8DF3\u8FC7\u622A\u56FE");
@@ -2710,7 +3355,7 @@ var init_split_prd = __esm({
               ctx2.screenshots = [];
               for (const ext of imageExtensions) {
                 const files = await FileUtils.findFiles(`*.${ext}`, screenshotDir);
-                ctx2.screenshots.push(...files.map((f) => path7.join(screenshotDir, f)));
+                ctx2.screenshots.push(...files.map((f) => path9.join(screenshotDir, f)));
               }
               logger.success(`\u627E\u5230 ${ctx2.screenshots.length} \u4E2A\u622A\u56FE\u6587\u4EF6`);
             }
@@ -2721,8 +3366,8 @@ var init_split_prd = __esm({
               const entries = await FileUtils.findFiles("*/", prdFolder);
               ctx2.demoRepos = [];
               for (const entry of entries) {
-                const dirPath = path7.join(prdFolder, entry);
-                const gitDir = path7.join(dirPath, ".git");
+                const dirPath = path9.join(prdFolder, entry);
+                const gitDir = path9.join(dirPath, ".git");
                 const hasGit = await FileUtils.exists(gitDir);
                 if (hasGit) {
                   ctx2.demoRepos.push(dirPath);
@@ -2786,7 +3431,7 @@ var init_split_prd = __esm({
 // src/commands/bugfix.ts
 import { Command as Command6 } from "commander";
 import inquirer5 from "inquirer";
-import path8 from "path";
+import path10 from "path";
 import { Listr as Listr5 } from "listr2";
 function generateBugId() {
   const date = /* @__PURE__ */ new Date();
@@ -2813,7 +3458,7 @@ async function findRelatedSpec(description) {
   }
   const keywords = extractKeywords(description);
   for (const file of specs) {
-    const filePath = path8.join(specDir, file);
+    const filePath = path10.join(specDir, file);
     const content = await FileUtils.read(filePath);
     for (const keyword of keywords) {
       if (content.toLowerCase().includes(keyword.toLowerCase())) {
@@ -2953,7 +3598,7 @@ var init_bugfix = __esm({
         const relatedSpec = await findRelatedSpec(answers.description);
         const bugfixDir = "docs/bugfixes";
         await FileUtils.ensureDir(bugfixDir);
-        const bugfixFile = path8.join(bugfixDir, `${timestamp}_${bugId}.md`);
+        const bugfixFile = path10.join(bugfixDir, `${timestamp}_${bugId}.md`);
         const content = formatBugfixDocument({
           id: bugId,
           severity: answers.severity,
@@ -3019,8 +3664,8 @@ var init_bugfix = __esm({
           {
             title: "\u521B\u5EFA hotfix \u5206\u652F",
             task: async () => {
-              const { execa: execa3 } = await import("execa");
-              await execa3("git", ["checkout", "-b", branchName], { stdio: "inherit" });
+              const { execa: execa5 } = await import("execa");
+              await execa5("git", ["checkout", "-b", branchName], { stdio: "inherit" });
             }
           },
           {
@@ -3029,7 +3674,7 @@ var init_bugfix = __esm({
               const timestamp = DateUtils.format(/* @__PURE__ */ new Date(), "YYYY-MM-DD HH:mm:ss");
               const hotfixDir = "docs/hotfixes";
               await FileUtils.ensureDir(hotfixDir);
-              const hotfixFile = path8.join(hotfixDir, `${timestamp}_${hotfixId}.md`);
+              const hotfixFile = path10.join(hotfixDir, `${timestamp}_${hotfixId}.md`);
               const content = formatHotfixDocument({
                 id: hotfixId,
                 description: answers.description,
@@ -3044,9 +3689,9 @@ var init_bugfix = __esm({
           {
             title: "\u521B\u5EFA\u521D\u59CB commit",
             task: async () => {
-              const { execa: execa3 } = await import("execa");
-              await execa3("git", ["add", "docs/hotfixes"], { stdio: "pipe" });
-              await execa3(
+              const { execa: execa5 } = await import("execa");
+              await execa5("git", ["add", "docs/hotfixes"], { stdio: "pipe" });
+              await execa5(
                 "git",
                 [
                   "commit",
@@ -3084,7 +3729,7 @@ Temporary solution: ${answers.solution}`
 
 // src/commands/lint.ts
 import { Command as Command7 } from "commander";
-import { execa as execa2 } from "execa";
+import { execa as execa3 } from "execa";
 var lintCommand;
 var init_lint = __esm({
   "src/commands/lint.ts"() {
@@ -3112,17 +3757,17 @@ var init_lint = __esm({
           try {
             logger.step("\u68C0\u67E5\u524D\u7AEF\u4EE3\u7801...");
             if (options.fix) {
-              await execa2("npm", ["run", "lint", "--", "--fix"], {
+              await execa3("npm", ["run", "lint", "--", "--fix"], {
                 cwd: "frontend",
                 stdio: "inherit"
               });
             } else {
-              await execa2("npm", ["run", "lint"], {
+              await execa3("npm", ["run", "lint"], {
                 cwd: "frontend",
                 stdio: "inherit"
               });
             }
-            await execa2("npx", ["tsc", "--noEmit"], {
+            await execa3("npx", ["tsc", "--noEmit"], {
               cwd: "frontend",
               stdio: "pipe"
             });
@@ -3145,23 +3790,23 @@ var init_lint = __esm({
             logger.step("\u68C0\u67E5\u540E\u7AEF\u4EE3\u7801...");
             if (hasGradle) {
               if (options.fix) {
-                await execa2("./gradlew", ["spotlessApply"], {
+                await execa3("./gradlew", ["spotlessApply"], {
                   cwd: "backend",
                   stdio: "inherit"
                 });
               }
-              await execa2("./gradlew", ["checkstyleMain", "compileJava"], {
+              await execa3("./gradlew", ["checkstyleMain", "compileJava"], {
                 cwd: "backend",
                 stdio: "inherit"
               });
             } else if (hasMaven) {
               if (options.fix) {
-                await execa2("./mvnw", ["spotless:apply"], {
+                await execa3("./mvnw", ["spotless:apply"], {
                   cwd: "backend",
                   stdio: "inherit"
                 });
               }
-              await execa2("./mvnw", ["checkstyle:check", "compile"], {
+              await execa3("./mvnw", ["checkstyle:check", "compile"], {
                 cwd: "backend",
                 stdio: "inherit"
               });
@@ -3216,7 +3861,7 @@ var init_lint = __esm({
 
 // src/commands/status.ts
 import { Command as Command8 } from "commander";
-import path9 from "path";
+import path11 from "path";
 async function displayProjectInfo() {
   logger.info("\u9879\u76EE\u4FE1\u606F:");
   logger.newLine();
@@ -3252,7 +3897,7 @@ async function displayFeatureInventory() {
   }
   const inventory = [];
   for (const file of specs) {
-    const filePath = path9.join(specDir, file);
+    const filePath = path11.join(specDir, file);
     const content = await FileUtils.read(filePath);
     const status = parseSpecStatus2(content);
     inventory.push({
@@ -3311,7 +3956,7 @@ async function displayRecentActivity() {
   }
   const sorted = files.sort().reverse().slice(0, 5);
   for (const file of sorted) {
-    const filePath = path9.join(sessionDir, file);
+    const filePath = path11.join(sessionDir, file);
     const stat = await FileUtils.read(filePath);
     const specMatch = stat.match(/\*\*Spec\*\*:\s*(.+)/);
     const spec = specMatch ? specMatch[1].trim() : "\u672A\u77E5";
@@ -3381,13 +4026,13 @@ var init_status = __esm({
 
 // src/commands/detect-deps.ts
 import { Command as Command9 } from "commander";
-import path10 from "path";
+import path12 from "path";
 import inquirer6 from "inquirer";
 async function detectDependencies(specFile) {
   logger.step("\u81EA\u52A8\u68C0\u6D4B\u4F9D\u8D56\u5173\u7CFB...");
   const projectDir = ".";
   const allDeps = /* @__PURE__ */ new Set();
-  const backendDir = path10.join(projectDir, "backend");
+  const backendDir = path12.join(projectDir, "backend");
   const backendExists = await FileUtils.exists(backendDir);
   if (backendExists) {
     const apiDeps = await scanBackendApiCalls(backendDir);
@@ -3397,7 +4042,7 @@ async function detectDependencies(specFile) {
     const serviceDeps = await scanBackendServiceRefs(backendDir);
     serviceDeps.forEach((d) => allDeps.add(d));
   }
-  const frontendDir = path10.join(projectDir, "frontend");
+  const frontendDir = path12.join(projectDir, "frontend");
   const frontendExists = await FileUtils.exists(frontendDir);
   if (frontendExists) {
     const frontendDeps = await scanFrontendApiCalls(frontendDir);
@@ -3438,11 +4083,11 @@ async function detectDependencies(specFile) {
 }
 async function scanBackendApiCalls(backendDir) {
   const deps = [];
-  const srcDir = path10.join(backendDir, "src");
+  const srcDir = path12.join(backendDir, "src");
   try {
     const javaFiles = await FileUtils.findFiles("*.java", srcDir);
     for (const file of javaFiles) {
-      const filePath = path10.join(srcDir, file);
+      const filePath = path12.join(srcDir, file);
       const content = await FileUtils.read(filePath);
       const pathRegex = /"(\/api\/[^"]+)"/g;
       let match;
@@ -3460,11 +4105,11 @@ async function scanBackendApiCalls(backendDir) {
 }
 async function scanBackendEntityRelations(backendDir) {
   const deps = [];
-  const srcDir = path10.join(backendDir, "src");
+  const srcDir = path12.join(backendDir, "src");
   try {
     const javaFiles = await FileUtils.findFiles("*.java", srcDir);
     for (const file of javaFiles) {
-      const filePath = path10.join(srcDir, file);
+      const filePath = path12.join(srcDir, file);
       const content = await FileUtils.read(filePath);
       if (content.includes("@JoinColumn") || content.includes("@ManyToOne") || content.includes("@OneToMany")) {
         const typeRegex = /type\s*=\s*(\w+)/g;
@@ -3480,11 +4125,11 @@ async function scanBackendEntityRelations(backendDir) {
 }
 async function scanBackendServiceRefs(backendDir) {
   const deps = [];
-  const srcDir = path10.join(backendDir, "src");
+  const srcDir = path12.join(backendDir, "src");
   try {
     const javaFiles = await FileUtils.findFiles("*.java", srcDir);
     for (const file of javaFiles) {
-      const filePath = path10.join(srcDir, file);
+      const filePath = path12.join(srcDir, file);
       const content = await FileUtils.read(filePath);
       const serviceRegex = /private\s+(\w+)Service/g;
       let match;
@@ -3500,11 +4145,11 @@ async function scanBackendServiceRefs(backendDir) {
 }
 async function scanFrontendApiCalls(frontendDir) {
   const deps = [];
-  const srcDir = path10.join(frontendDir, "src");
+  const srcDir = path12.join(frontendDir, "src");
   try {
     const tsFiles = await FileUtils.findFiles("*.{ts,tsx,js,jsx}", srcDir);
     for (const file of tsFiles) {
-      const filePath = path10.join(srcDir, file);
+      const filePath = path12.join(srcDir, file);
       const content = await FileUtils.read(filePath);
       const pathRegex = /"(\/api\/[^"]+)"/g;
       let match;
@@ -3621,7 +4266,7 @@ var init_detect_deps = __esm({
             process.exit(1);
           }
           for (const spec of specs) {
-            const specPath = path10.join(specsDir, spec);
+            const specPath = path12.join(specsDir, spec);
             logger.step(`\u5904\u7406: ${spec}`);
             await detectDependencies(specPath);
             logger.newLine();
@@ -3648,10 +4293,10 @@ var init_detect_deps = __esm({
 
 // src/commands/sync-memory.ts
 import { Command as Command10 } from "commander";
-import path11 from "path";
+import path13 from "path";
 async function syncFeatureInventory(aiMemoryFile, projectDir) {
   logger.step("\u540C\u6B65\u529F\u80FD\u6E05\u5355...");
-  const specsDir = path11.join(projectDir, "docs/specs");
+  const specsDir = path13.join(projectDir, "docs/specs");
   const exists = await FileUtils.exists(specsDir);
   if (!exists) {
     return;
@@ -3666,7 +4311,7 @@ async function syncFeatureInventory(aiMemoryFile, projectDir) {
   for (const specFile of specs) {
     const name = specFile.replace(".md", "");
     const displayName = name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-    const specPath = path11.join(specsDir, specFile);
+    const specPath = path13.join(specsDir, specFile);
     const content = await FileUtils.read(specPath);
     const status = parseSpecStatus3(content);
     const progress = getSpecProgress(content);
@@ -3684,7 +4329,7 @@ async function syncFeatureInventory(aiMemoryFile, projectDir) {
 }
 async function syncApiInventory(aiMemoryFile, projectDir) {
   logger.step("\u540C\u6B65 API \u5217\u8868...");
-  const backendDir = path11.join(projectDir, "backend");
+  const backendDir = path13.join(projectDir, "backend");
   const exists = await FileUtils.exists(backendDir);
   if (!exists) {
     return;
@@ -3694,13 +4339,13 @@ async function syncApiInventory(aiMemoryFile, projectDir) {
   lines.push("");
   lines.push("> \u672C\u90E8\u5206\u7531 team-cli \u81EA\u52A8\u626B\u63CF\u540E\u7AEF Controller \u751F\u6210");
   lines.push("");
-  const srcDir = path11.join(backendDir, "src");
+  const srcDir = path13.join(backendDir, "src");
   const controllers = await FileUtils.findFiles("*Controller.java", srcDir);
   if (controllers.length === 0) {
     lines.push("\u6682\u65E0 API");
   } else {
     for (const controllerFile of controllers) {
-      const controllerPath = path11.join(srcDir, controllerFile);
+      const controllerPath = path13.join(srcDir, controllerFile);
       const controllerName = controllerFile.replace(".java", "");
       const module = controllerName.replace(/Controller$/, "").toLowerCase();
       lines.push(`### ${module} \u6A21\u5757`);
@@ -3777,7 +4422,7 @@ function extractMethodComment(content, methodName) {
 }
 async function syncDataModels(aiMemoryFile, projectDir) {
   logger.step("\u540C\u6B65\u6570\u636E\u6A21\u578B...");
-  const backendDir = path11.join(projectDir, "backend");
+  const backendDir = path13.join(projectDir, "backend");
   const exists = await FileUtils.exists(backendDir);
   if (!exists) {
     return;
@@ -3787,7 +4432,7 @@ async function syncDataModels(aiMemoryFile, projectDir) {
   lines.push("");
   lines.push("> \u672C\u90E8\u5206\u7531 team-cli \u81EA\u52A8\u626B\u63CF\u540E\u7AEF Entity \u751F\u6210");
   lines.push("");
-  const srcDir = path11.join(backendDir, "src");
+  const srcDir = path13.join(backendDir, "src");
   const entities = await FileUtils.findFiles("*Entity.java", srcDir);
   if (entities.length === 0) {
     lines.push("\u6682\u65E0\u6570\u636E\u6A21\u578B");
@@ -3795,7 +4440,7 @@ async function syncDataModels(aiMemoryFile, projectDir) {
     lines.push("| \u6A21\u578B | \u8BF4\u660E | \u5B57\u6BB5 | \u5173\u8054 |");
     lines.push("|------|------|------|------|");
     for (const entityFile of entities) {
-      const entityPath = path11.join(srcDir, entityFile);
+      const entityPath = path13.join(srcDir, entityFile);
       const entityName = entityFile.replace(".java", "").replace(/Entity$/, "");
       const displayName = entityName.split(/(?=[A-Z])/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
       const content = await FileUtils.read(entityPath);
@@ -3884,6 +4529,49 @@ function getSpecProgress(spec) {
   }
   return `${completedTodos}/${totalTodos}`;
 }
+async function syncTemplateVersions(aiMemoryFile, projectDir) {
+  logger.step("\u540C\u6B65\u6A21\u677F\u7248\u672C\u4FE1\u606F...");
+  const config = await readTemplateConfig(projectDir);
+  if (!config) {
+    return;
+  }
+  const lines = [];
+  lines.push("## \u6A21\u677F\u7248\u672C\u4FE1\u606F");
+  lines.push("");
+  lines.push("> \u672C\u90E8\u5206\u7531 team-cli \u81EA\u52A8\u7BA1\u7406\uFF0C\u8BB0\u5F55\u4F7F\u7528\u7684\u524D\u540E\u7AEF\u6A21\u677F\u7248\u672C");
+  lines.push("");
+  lines.push("| \u7C7B\u578B | \u4ED3\u5E93 | Tag | Branch | Commit | \u66F4\u65B0\u65F6\u95F4 |");
+  lines.push("|------|------|-----|--------|--------|----------|");
+  if (config.frontend) {
+    const repoName = extractRepoName(config.frontend.repository);
+    const commit = config.frontend.commit?.substring(0, 8) || "-";
+    const tag = config.frontend.tag || "-";
+    const branch = config.frontend.branch || "-";
+    const updateDate = config.frontend.lastUpdate ? new Date(config.frontend.lastUpdate).toLocaleDateString("zh-CN") : "-";
+    lines.push(`| \u524D\u7AEF | ${repoName} | ${tag} | ${branch} | ${commit} | ${updateDate} |`);
+  }
+  if (config.backend) {
+    const repoName = extractRepoName(config.backend.repository);
+    const commit = config.backend.commit?.substring(0, 8) || "-";
+    const tag = config.backend.tag || "-";
+    const branch = config.backend.branch || "-";
+    const updateDate = config.backend.lastUpdate ? new Date(config.backend.lastUpdate).toLocaleDateString("zh-CN") : "-";
+    lines.push(`| \u540E\u7AEF | ${repoName} | ${tag} | ${branch} | ${commit} | ${updateDate} |`);
+  }
+  const newContent = lines.join("\n") + "\n";
+  await replaceOrInsertSection(aiMemoryFile, "## \u6A21\u677F\u7248\u672C\u4FE1\u606F", newContent);
+}
+function extractRepoName(repository) {
+  let path17 = repository;
+  path17 = path17.replace(/^https?:\/\//, "");
+  path17 = path17.replace(/^git@/, "");
+  const parts = path17.split("/");
+  if (parts.length > 1) {
+    path17 = parts.slice(1).join("/");
+  }
+  path17 = path17.replace(/\.git$/, "");
+  return path17;
+}
 var syncMemoryCommand;
 var init_sync_memory = __esm({
   "src/commands/sync-memory.ts"() {
@@ -3891,6 +4579,7 @@ var init_sync_memory = __esm({
     init_esm_shims();
     init_utils();
     init_logger();
+    init_template_version();
     syncMemoryCommand = new Command10("sync-memory").description("\u540C\u6B65 AI_MEMORY.md").action(async () => {
       try {
         logger.header("\u540C\u6B65 AI_MEMORY.md");
@@ -3910,6 +4599,7 @@ var init_sync_memory = __esm({
         await syncFeatureInventory(aiMemoryFile, ".");
         await syncApiInventory(aiMemoryFile, ".");
         await syncDataModels(aiMemoryFile, ".");
+        await syncTemplateVersions(aiMemoryFile, ".");
         await updateSyncTime(aiMemoryFile);
         logger.success("AI_MEMORY.md \u5DF2\u540C\u6B65");
       } catch (error) {
@@ -3925,11 +4615,11 @@ var init_sync_memory = __esm({
 
 // src/commands/check-api.ts
 import { Command as Command11 } from "commander";
-import path12 from "path";
+import path14 from "path";
 import inquirer7 from "inquirer";
 import { Listr as Listr6 } from "listr2";
 async function checkApiConflicts(projectDir) {
-  const backendDir = path12.join(projectDir, "backend");
+  const backendDir = path14.join(projectDir, "backend");
   const exists = await FileUtils.exists(backendDir);
   if (!exists) {
     logger.info("\u672A\u627E\u5230\u540E\u7AEF\u9879\u76EE");
@@ -3938,10 +4628,10 @@ async function checkApiConflicts(projectDir) {
   logger.step("\u626B\u63CF\u540E\u7AEF API...");
   logger.newLine();
   const apiMap = /* @__PURE__ */ new Map();
-  const srcDir = path12.join(backendDir, "src");
+  const srcDir = path14.join(backendDir, "src");
   const controllers = await FileUtils.findFiles("*Controller.java", srcDir);
   for (const controllerFile of controllers) {
-    const controllerPath = path12.join(srcDir, controllerFile);
+    const controllerPath = path14.join(srcDir, controllerFile);
     const apis = await extractApisFromController(controllerPath);
     for (const api of apis) {
       const key = `${api.method}:${api.path}`;
@@ -3972,8 +4662,8 @@ async function checkApiConflicts(projectDir) {
   }
 }
 async function detectApiChanges(projectDir) {
-  const backendDir = path12.join(projectDir, "backend");
-  const registryFile = path12.join(projectDir, "docs/api-registry.md");
+  const backendDir = path14.join(projectDir, "backend");
+  const registryFile = path14.join(projectDir, "docs/api-registry.md");
   const registryExists = await FileUtils.exists(registryFile);
   if (!registryExists) {
     logger.info("API Registry \u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u53D8\u66F4\u68C0\u6D4B");
@@ -3985,10 +4675,10 @@ async function detectApiChanges(projectDir) {
   const registryContent = await FileUtils.read(registryFile);
   const existingApis = extractApisFromRegistry(registryContent);
   const currentApis = /* @__PURE__ */ new Map();
-  const srcDir = path12.join(backendDir, "src");
+  const srcDir = path14.join(backendDir, "src");
   const controllers = await FileUtils.findFiles("*Controller.java", srcDir);
   for (const controllerFile of controllers) {
-    const controllerPath = path12.join(srcDir, controllerFile);
+    const controllerPath = path14.join(srcDir, controllerFile);
     const apis = await extractApisFromController(controllerPath);
     for (const api of apis) {
       const key = `${api.method}:${api.path}`;
@@ -4050,9 +4740,9 @@ async function detectApiChanges(projectDir) {
   }
 }
 async function generateApiRegistry(projectDir) {
-  const registryFile = path12.join(projectDir, "docs/api-registry.md");
+  const registryFile = path14.join(projectDir, "docs/api-registry.md");
   logger.step("\u626B\u63CF\u5E76\u751F\u6210 API Registry...");
-  await FileUtils.ensureDir(path12.dirname(registryFile));
+  await FileUtils.ensureDir(path14.dirname(registryFile));
   const header = `# API Registry
 
 > \u672C\u6587\u4EF6\u8BB0\u5F55\u6240\u6709 API \u7684\u5B9A\u4E49\u3001\u7248\u672C\u548C\u53D8\u66F4\u5386\u53F2
@@ -4081,14 +4771,14 @@ async function generateApiRegistry(projectDir) {
 *\u6700\u540E\u66F4\u65B0: ${DateUtils.format(/* @__PURE__ */ new Date(), "YYYY-MM-DD HH:mm:ss")}*
 `;
   let content = header;
-  const backendDir = path12.join(projectDir, "backend");
+  const backendDir = path14.join(projectDir, "backend");
   const exists = await FileUtils.exists(backendDir);
   if (exists) {
-    const srcDir = path12.join(backendDir, "src");
+    const srcDir = path14.join(backendDir, "src");
     const controllers = await FileUtils.findFiles("*Controller.java", srcDir);
     const moduleMap = /* @__PURE__ */ new Map();
     for (const controllerFile of controllers) {
-      const controllerPath = path12.join(srcDir, controllerFile);
+      const controllerPath = path14.join(srcDir, controllerFile);
       const controllerName = controllerFile.replace(".java", "");
       const module = controllerName.replace(/Controller$/, "").toLowerCase();
       if (!moduleMap.has(module)) {
@@ -4172,10 +4862,10 @@ function extractApisFromRegistry(registryContent) {
   let match;
   while ((match = apiRegex.exec(registryContent)) !== null) {
     const method = match[1];
-    const path14 = match[2].trim();
+    const path17 = match[2].trim();
     const description = match[3].trim();
-    const key = `${method}:${path14}`;
-    apis.set(key, { method, path: path14, description });
+    const key = `${method}:${path17}`;
+    apis.set(key, { method, path: path17, description });
   }
   return apis;
 }
@@ -4263,7 +4953,7 @@ var init_check_api = __esm({
 
 // src/commands/logs.ts
 import { Command as Command12 } from "commander";
-import path13 from "path";
+import path15 from "path";
 import inquirer8 from "inquirer";
 async function collectLogFiles(targetDir) {
   const logs = [];
@@ -4271,7 +4961,7 @@ async function collectLogFiles(targetDir) {
     const allFiles = await FileUtils.findFiles("*.md", targetDir);
     const filtered = allFiles.filter((f) => f !== "index.md");
     for (const file of filtered) {
-      const filePath = path13.join(targetDir, file);
+      const filePath = path15.join(targetDir, file);
       const stat = await FileUtils.exists(filePath);
       if (stat) {
         logs.push(filePath);
@@ -4311,7 +5001,7 @@ var init_logs = __esm({
           case "":
           case "today": {
             const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-            targetDir = path13.join(sessionsDir, today);
+            targetDir = path15.join(sessionsDir, today);
             const todayExists = await FileUtils.exists(targetDir);
             if (!todayExists) {
               logger.info("\u4ECA\u65E5\u6682\u65E0\u4F1A\u8BDD\u65E5\u5FD7");
@@ -4327,7 +5017,7 @@ var init_logs = __esm({
             break;
           }
           default: {
-            targetDir = path13.join(sessionsDir, filter);
+            targetDir = path15.join(sessionsDir, filter);
             const dateExists = await FileUtils.exists(targetDir);
             if (!dateExists) {
               logger.error(`\u672A\u627E\u5230\u65E5\u671F '${filter}' \u7684\u65E5\u5FD7`);
@@ -4351,7 +5041,7 @@ var init_logs = __esm({
           process.exit(0);
         }
         for (let i = 0; i < logs.length; i++) {
-          const relPath = path13.relative(sessionsDir, logs[i]);
+          const relPath = path15.relative(sessionsDir, logs[i]);
           logger.step(`${i + 1}) ${relPath}`);
         }
         logger.newLine();
@@ -4389,15 +5079,709 @@ var init_logs = __esm({
   }
 });
 
-// src/index.ts
-var index_exports = {};
+// src/commands/update.ts
 import { Command as Command13 } from "commander";
+import path16 from "path";
+import { execa as execa4 } from "execa";
+import inquirer9 from "inquirer";
+import fs3 from "fs-extra";
+async function performUpdate(projectPath, updates) {
+  logger.newLine();
+  logger.info("\u5F00\u59CB\u66F4\u65B0\u6A21\u677F...");
+  for (const update of updates) {
+    const { type, info, updateOptions } = update;
+    const targetDir = type === "frontend" ? "frontend" : "backend";
+    const targetPath = path16.join(projectPath, targetDir);
+    logger.newLine();
+    logger.step(`\u66F4\u65B0 ${type === "frontend" ? "\u524D\u7AEF" : "\u540E\u7AEF"}\u6A21\u677F...`);
+    if (updateOptions?.tag || updateOptions?.branch) {
+      const { userConfigManager: userConfigManager2 } = await Promise.resolve().then(() => (init_user_config(), user_config_exports));
+      const { GitLabAPI: GitLabAPI2 } = await Promise.resolve().then(() => (init_gitlab_api(), gitlab_api_exports));
+      const config = await userConfigManager2.getGitLabConfig();
+      if (config) {
+        const gitlabAPI = new GitLabAPI2(config);
+        const projectPathEncoded = GitLabAPI2.parseProjectPath(info.repository);
+        if (updateOptions.tag) {
+          const isValid = await gitlabAPI.validateTag(projectPathEncoded, updateOptions.tag);
+          if (!isValid) {
+            logger.error(`${type === "frontend" ? "\u524D\u7AEF" : "\u540E\u7AEF"}\u6A21\u677F tag "${updateOptions.tag}" \u4E0D\u5B58\u5728`);
+            continue;
+          }
+          logger.info(`\u4F7F\u7528 ${type === "frontend" ? "\u524D\u7AEF" : "\u540E\u7AEF"}\u6A21\u677F tag: ${updateOptions.tag}`);
+        }
+        if (updateOptions.branch) {
+          const isValid = await gitlabAPI.validateBranch(projectPathEncoded, updateOptions.branch);
+          if (!isValid) {
+            logger.error(`${type === "frontend" ? "\u524D\u7AEF" : "\u540E\u7AEF"}\u6A21\u677F\u5206\u652F "${updateOptions.branch}" \u4E0D\u5B58\u5728`);
+            continue;
+          }
+          logger.info(`\u4F7F\u7528 ${type === "frontend" ? "\u524D\u7AEF" : "\u540E\u7AEF"}\u6A21\u677F\u5206\u652F: ${updateOptions.branch}`);
+        }
+      } else {
+        logger.warn("\u672A\u914D\u7F6E GitLab Token\uFF0C\u8DF3\u8FC7\u7248\u672C\u9A8C\u8BC1");
+      }
+    }
+    const ref = updateOptions?.tag || updateOptions?.branch || "HEAD";
+    const backupDir = path16.join(projectPath, `.backup-${Date.now()}`);
+    await fs3.copy(targetPath, path16.join(backupDir, targetDir));
+    logger.info(`\u5DF2\u521B\u5EFA\u5907\u4EFD: ${backupDir}`);
+    if (updateOptions?.dryRun) {
+      logger.info("[Dry Run] \u5C06\u4F1A\u66F4\u65B0\u5230\u4EE5\u4E0B\u7248\u672C:");
+      logger.info(`  Ref: ${ref}`);
+      logger.info(`  \u4ED3\u5E93: ${info.repository}`);
+      logger.info("\u5907\u4EFD\u5DF2\u521B\u5EFA\uFF0C\u8DF3\u8FC7\u5B9E\u9645\u66F4\u65B0");
+      continue;
+    }
+    try {
+      const tempDir = path16.join(projectPath, `.template-update-${Date.now()}`);
+      await execa4("git", ["clone", "--depth=1", "--branch", ref, info.repository, tempDir], {
+        stdio: "pipe"
+      });
+      const { stdout: commit } = await execa4("git", ["rev-parse", "HEAD"], {
+        cwd: tempDir,
+        stdio: "pipe"
+      });
+      const { stdout: tags } = await execa4("git", ["tag", "-l", "--sort=-v:refname"], {
+        cwd: tempDir,
+        stdio: "pipe"
+      });
+      const latestTag = tags.split("\n")[0] || void 0;
+      const keepFiles = [".env.local", "package-lock.json", "node_modules"];
+      const currentFiles = await FileUtils.findFiles("*", targetPath);
+      for (const file of currentFiles) {
+        if (!keepFiles.includes(file)) {
+          const filePath = path16.join(targetPath, file);
+          try {
+            await fs3.remove(filePath);
+          } catch {
+          }
+        }
+      }
+      await fs3.copy(tempDir, targetPath, {
+        filter: (src) => !src.includes(".git")
+      });
+      await fs3.remove(tempDir);
+      await updateTemplateVersion(projectPath, type, commit.trim(), {
+        tag: updateOptions?.tag || latestTag,
+        branch: updateOptions?.branch
+      });
+      logger.success(`${type === "frontend" ? "\u524D\u7AEF" : "\u540E\u7AEF"}\u6A21\u677F\u66F4\u65B0\u5B8C\u6210!`);
+      logger.info(`\u65B0\u7248\u672C: ${updateOptions?.tag || updateOptions?.branch || latestTag || commit.substring(0, 8)}`);
+      logger.info(`\u5907\u4EFD\u4F4D\u7F6E: ${backupDir}`);
+    } catch (error) {
+      logger.error(`\u66F4\u65B0\u5931\u8D25: ${error.message}`);
+      logger.info("\u6B63\u5728\u6062\u590D\u5907\u4EFD...");
+      await fs3.remove(targetPath);
+      await fs3.copy(path16.join(backupDir, targetDir), targetPath);
+      await fs3.remove(backupDir);
+      logger.info("\u5DF2\u6062\u590D\u5230\u66F4\u65B0\u524D\u7684\u72B6\u6001");
+    }
+  }
+  logger.newLine();
+  logger.header("\u6A21\u677F\u66F4\u65B0\u5B8C\u6210!");
+  logger.newLine();
+  logger.info("\u4E0B\u4E00\u6B65:");
+  logger.step("1. \u68C0\u67E5\u66F4\u65B0\u540E\u7684\u4EE3\u7801");
+  logger.step("2. \u8FD0\u884C npm install \u5B89\u88C5\u65B0\u4F9D\u8D56");
+  logger.step("3. \u6D4B\u8BD5\u5E94\u7528\u662F\u5426\u6B63\u5E38\u8FD0\u884C");
+  logger.step("4. \u63D0\u4EA4\u4EE3\u7801\u5230 Git");
+  logger.newLine();
+}
+var updateCommand;
+var init_update = __esm({
+  "src/commands/update.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_template_version();
+    init_logger();
+    init_utils();
+    updateCommand = new Command13("update").description("\u68C0\u67E5\u5E76\u66F4\u65B0\u6A21\u677F\u7248\u672C").option("-f, --frontend", "\u68C0\u67E5\u524D\u7AEF\u6A21\u677F\u66F4\u65B0").option("-b, --backend", "\u68C0\u67E5\u540E\u7AEF\u6A21\u677F\u66F4\u65B0").option("-a, --all", "\u68C0\u67E5\u6240\u6709\u6A21\u677F (\u9ED8\u8BA4)").option("-t, --tag <tag>", "\u66F4\u65B0\u5230\u6307\u5B9A\u6807\u7B7E").option("-B, --branch <branch>", "\u66F4\u65B0\u5230\u6307\u5B9A\u5206\u652F").option("--dry-run", "\u9884\u89C8\u66F4\u65B0\uFF0C\u4E0D\u5B9E\u9645\u6267\u884C").action(async (options) => {
+      try {
+        logger.header("\u6A21\u677F\u7248\u672C\u68C0\u67E5");
+        logger.newLine();
+        const hasConfig = await FileUtils.exists("TECH_STACK.md");
+        if (!hasConfig) {
+          logger.error("\u5F53\u524D\u76EE\u5F55\u4E0D\u662F\u4E00\u4E2A\u6709\u6548\u7684 team-cli \u9879\u76EE");
+          logger.info("\u8BF7\u5148\u5207\u6362\u5230\u9879\u76EE\u76EE\u5F55");
+          process.exit(1);
+        }
+        const projectPath = ".";
+        const checkAll = !options.frontend && !options.backend;
+        const checkFrontend = options.frontend || checkAll;
+        const checkBackend = options.backend || checkAll;
+        const forceUpdate = options.tag || options.branch;
+        const updates = [];
+        const updateOptions = {
+          tag: options.tag,
+          branch: options.branch,
+          dryRun: options.dryRun
+        };
+        if (checkFrontend) {
+          logger.step("\u68C0\u67E5\u524D\u7AEF\u6A21\u677F...");
+          const frontendInfo = await checkTemplateUpdate(projectPath, "frontend");
+          if (frontendInfo) {
+            if (frontendInfo.needsUpdate || forceUpdate) {
+              const version = updateOptions.tag || updateOptions.branch || frontendInfo.latestTag || frontendInfo.latestCommit?.substring(0, 8);
+              logger.success(`\u524D\u7AEF\u6A21\u677F${forceUpdate ? "\u5C06\u66F4\u65B0" : "\u6709\u66F4\u65B0"} (${version})`);
+              updates.push({ type: "frontend", info: frontendInfo, updateOptions });
+            } else {
+              logger.info("\u524D\u7AEF\u6A21\u677F\u5DF2\u662F\u6700\u65B0\u7248\u672C");
+            }
+          } else {
+            logger.info("\u524D\u7AEF\u6A21\u677F\u672A\u914D\u7F6E\u6216\u65E0\u6CD5\u68C0\u67E5");
+          }
+          logger.newLine();
+        }
+        if (checkBackend) {
+          logger.step("\u68C0\u67E5\u540E\u7AEF\u6A21\u677F...");
+          const backendInfo = await checkTemplateUpdate(projectPath, "backend");
+          if (backendInfo) {
+            if (backendInfo.needsUpdate || forceUpdate) {
+              const version = updateOptions.tag || updateOptions.branch || backendInfo.latestTag || backendInfo.latestCommit?.substring(0, 8);
+              logger.success(`\u540E\u7AEF\u6A21\u677F${forceUpdate ? "\u5C06\u66F4\u65B0" : "\u6709\u66F4\u65B0"} (${version})`);
+              updates.push({ type: "backend", info: backendInfo, updateOptions });
+            } else {
+              logger.info("\u540E\u7AEF\u6A21\u677F\u5DF2\u662F\u6700\u65B0\u7248\u672C");
+            }
+          } else {
+            logger.info("\u540E\u7AEF\u6A21\u677F\u672A\u914D\u7F6E\u6216\u65E0\u6CD5\u68C0\u67E5");
+          }
+          logger.newLine();
+        }
+        if (updates.length === 0) {
+          logger.success("\u6240\u6709\u6A21\u677F\u5DF2\u662F\u6700\u65B0\u7248\u672C!");
+          return;
+        }
+        if (options.dryRun) {
+          logger.header(`[Dry Run] \u53D1\u73B0 ${updates.length} \u4E2A\u6A21\u677F`);
+        } else {
+          logger.header(`\u53D1\u73B0 ${updates.length} \u4E2A\u6A21\u677F\u66F4\u65B0`);
+        }
+        logger.newLine();
+        for (const update of updates) {
+          const version = update.updateOptions?.tag || update.updateOptions?.branch || update.info.latestTag || update.info.latestCommit?.substring(0, 8);
+          logger.step(`${update.type === "frontend" ? "\u524D\u7AEF" : "\u540E\u7AEF"}\u6A21\u677F: ${version}`);
+        }
+        logger.newLine();
+        if (options.dryRun) {
+          logger.info("Dry run \u6A21\u5F0F\uFF0C\u4E0D\u6267\u884C\u5B9E\u9645\u66F4\u65B0");
+          return;
+        }
+        const answers = await inquirer9.prompt([
+          {
+            type: "confirm",
+            name: "shouldUpdate",
+            message: "\u662F\u5426\u66F4\u65B0\u6A21\u677F?",
+            default: false
+          }
+        ]);
+        if (answers.shouldUpdate) {
+          await performUpdate(projectPath, updates);
+        } else {
+          logger.info("\u5DF2\u53D6\u6D88\u66F4\u65B0");
+        }
+      } catch (error) {
+        logger.error(`\u66F4\u65B0\u68C0\u67E5\u5931\u8D25: ${error.message}`);
+        if (process.env.DEBUG) {
+          console.error(error);
+        }
+        process.exit(1);
+      }
+    });
+  }
+});
+
+// src/commands/config.ts
+import { Command as Command14 } from "commander";
+import inquirer10 from "inquirer";
 import chalk2 from "chalk";
+var setTokenCommand, showConfigCommand, removeConfigCommand, validateTokenCommand, configCommand;
+var init_config = __esm({
+  "src/commands/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_user_config();
+    init_gitlab_api();
+    init_logger();
+    setTokenCommand = new Command14("set-token").description("\u8BBE\u7F6E GitLab Access Token").option("-t, --token <token>", "Access Token").option("-u, --url <url>", "GitLab Base URL", "https://gitlab.com").action(async (options) => {
+      try {
+        logger.header("GitLab Access Token \u914D\u7F6E");
+        logger.newLine();
+        let { token, url } = options;
+        if (!token) {
+          const answers = await inquirer10.prompt([
+            {
+              type: "password",
+              name: "token",
+              message: "\u8BF7\u8F93\u5165 GitLab Access Token:",
+              mask: "*",
+              validate: (input) => {
+                if (!input || input.trim().length === 0) {
+                  return "Token \u4E0D\u80FD\u4E3A\u7A7A";
+                }
+                return true;
+              }
+            },
+            {
+              type: "input",
+              name: "url",
+              message: "\u8BF7\u8F93\u5165 GitLab Base URL:",
+              default: "https://gitlab.com",
+              validate: (input) => {
+                try {
+                  new URL(input);
+                  return true;
+                } catch {
+                  return "\u8BF7\u8F93\u5165\u6709\u6548\u7684 URL";
+                }
+              }
+            }
+          ]);
+          token = answers.token;
+          url = answers.url;
+        }
+        try {
+          new URL(url);
+        } catch {
+          logger.error("\u65E0\u6548\u7684 GitLab URL");
+          process.exit(1);
+        }
+        url = url.replace(/\/+$/, "");
+        logger.info("\u9A8C\u8BC1 Token...");
+        const gitlabAPI = new GitLabAPI({ accessToken: token, baseUrl: url });
+        const isValid = await gitlabAPI.authenticate();
+        if (!isValid) {
+          logger.error("Token \u9A8C\u8BC1\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5:");
+          logger.info("1. Token \u662F\u5426\u6B63\u786E");
+          logger.info("2. Token \u662F\u5426\u6709 api \u6743\u9650");
+          logger.info("3. GitLab URL \u662F\u5426\u6B63\u786E");
+          process.exit(1);
+        }
+        logger.success("Token \u9A8C\u8BC1\u6210\u529F!");
+        await userConfigManager.updateGitLabToken(token, url);
+        logger.success("\u914D\u7F6E\u5DF2\u4FDD\u5B58!");
+        logger.newLine();
+        logger.info(`GitLab URL: ${chalk2.cyan(url)}`);
+        logger.info(`\u914D\u7F6E\u6587\u4EF6: ${chalk2.gray(userConfigManager.getConfigPath())}`);
+      } catch (error) {
+        logger.error(`\u914D\u7F6E\u5931\u8D25: ${error.message}`);
+        if (process.env.DEBUG) {
+          console.error(error);
+        }
+        process.exit(1);
+      }
+    });
+    showConfigCommand = new Command14("show").description("\u663E\u793A\u5F53\u524D\u914D\u7F6E").action(async () => {
+      try {
+        logger.header("GitLab \u914D\u7F6E");
+        logger.newLine();
+        const hasConfig = await userConfigManager.hasConfig();
+        if (!hasConfig) {
+          logger.warn("\u672A\u914D\u7F6E GitLab Access Token");
+          logger.info("\u8BF7\u4F7F\u7528 'team-cli config set-token' \u8FDB\u884C\u914D\u7F6E");
+        } else {
+          const config = await userConfigManager.load();
+          if (config?.gitlab) {
+            const token = config.gitlab.accessToken;
+            const maskedToken = token ? `${token.substring(0, 8)}${"*".repeat(Math.min(16, token.length - 8))}` : "";
+            logger.info(`GitLab URL: ${chalk2.cyan(config.gitlab.baseUrl)}`);
+            logger.info(`Access Token: ${chalk2.yellow(maskedToken)}`);
+            logger.info(`Timeout: ${chalk2.gray(config.gitlab.timeout || 3e4)}ms`);
+            if (config.preferences) {
+              logger.newLine();
+              logger.info("\u504F\u597D\u8BBE\u7F6E:");
+              if (config.preferences.defaultBackendBranch) {
+                logger.info(`  \u9ED8\u8BA4\u540E\u7AEF\u5206\u652F: ${chalk2.cyan(config.preferences.defaultBackendBranch)}`);
+              }
+              if (config.preferences.defaultFrontendBranch) {
+                logger.info(`  \u9ED8\u8BA4\u524D\u7AEF\u5206\u652F: ${chalk2.cyan(config.preferences.defaultFrontendBranch)}`);
+              }
+            }
+            logger.newLine();
+            logger.info("\u914D\u7F6E\u6587\u4EF6\u4F4D\u7F6E:");
+            logger.info(`  ${chalk2.gray(userConfigManager.getConfigPath())}`);
+          }
+        }
+      } catch (error) {
+        logger.error(`\u8BFB\u53D6\u914D\u7F6E\u5931\u8D25: ${error.message}`);
+        if (process.env.DEBUG) {
+          console.error(error);
+        }
+        process.exit(1);
+      }
+    });
+    removeConfigCommand = new Command14("remove").alias("rm").description("\u5220\u9664 GitLab \u914D\u7F6E").action(async () => {
+      try {
+        const hasConfig = await userConfigManager.hasConfig();
+        if (!hasConfig) {
+          logger.warn("\u672A\u914D\u7F6E GitLab Access Token");
+          return;
+        }
+        const answers = await inquirer10.prompt([
+          {
+            type: "confirm",
+            name: "confirm",
+            message: "\u786E\u5B9A\u8981\u5220\u9664 GitLab \u914D\u7F6E\u5417?",
+            default: false
+          }
+        ]);
+        if (!answers.confirm) {
+          logger.info("\u5DF2\u53D6\u6D88");
+          return;
+        }
+        await userConfigManager.removeConfig();
+        logger.success("\u914D\u7F6E\u5DF2\u5220\u9664");
+      } catch (error) {
+        logger.error(`\u5220\u9664\u914D\u7F6E\u5931\u8D25: ${error.message}`);
+        if (process.env.DEBUG) {
+          console.error(error);
+        }
+        process.exit(1);
+      }
+    });
+    validateTokenCommand = new Command14("validate").alias("test").description("\u9A8C\u8BC1\u5F53\u524D Token \u662F\u5426\u6709\u6548").action(async () => {
+      try {
+        logger.header("\u9A8C\u8BC1 GitLab Token");
+        logger.newLine();
+        const config = await userConfigManager.getGitLabConfig();
+        if (!config) {
+          logger.warn("\u672A\u914D\u7F6E GitLab Access Token");
+          logger.info("\u8BF7\u4F7F\u7528 'team-cli config set-token' \u8FDB\u884C\u914D\u7F6E");
+          process.exit(1);
+        }
+        logger.info("\u6B63\u5728\u9A8C\u8BC1...");
+        const gitlabAPI = new GitLabAPI(config);
+        const isValid = await gitlabAPI.authenticate();
+        if (isValid) {
+          logger.success("Token \u6709\u6548!");
+          logger.newLine();
+          logger.info(`GitLab URL: ${chalk2.cyan(config.baseUrl)}`);
+        } else {
+          logger.error("Token \u9A8C\u8BC1\u5931\u8D25");
+          logger.info("\u8BF7\u68C0\u67E5 Token \u662F\u5426\u6B63\u786E\u6216\u5DF2\u8FC7\u671F");
+          process.exit(1);
+        }
+      } catch (error) {
+        logger.error(`\u9A8C\u8BC1\u5931\u8D25: ${error.message}`);
+        if (process.env.DEBUG) {
+          console.error(error);
+        }
+        process.exit(1);
+      }
+    });
+    configCommand = new Command14("config").description("\u7BA1\u7406 GitLab \u914D\u7F6E").addCommand(setTokenCommand).addCommand(showConfigCommand).addCommand(removeConfigCommand).addCommand(validateTokenCommand);
+  }
+});
+
+// src/commands/diff.ts
+import { Command as Command15 } from "commander";
+import chalk3 from "chalk";
+async function compareTemplate(projectPath, type, localConfig, remoteTag, remoteBranch, gitlabConfig) {
+  try {
+    logger.step(`\u5BF9\u6BD4${type === "frontend" ? "\u524D\u7AEF" : "\u540E\u7AEF"}\u6A21\u677F...`);
+    const repository = localConfig.repository;
+    const localCommit = localConfig.commit;
+    const localTag = localConfig.tag;
+    const localBranch = localConfig.branch;
+    let remoteCommit = null;
+    let remoteTagName;
+    let remoteBranchName;
+    if (gitlabConfig) {
+      const gitlabAPI = new GitLabAPI(gitlabConfig);
+      const projectPathEncoded = GitLabAPI.parseProjectPath(repository);
+      if (remoteTag) {
+        remoteCommit = await gitlabAPI.getTagCommit(projectPathEncoded, remoteTag);
+        remoteTagName = remoteTag;
+      } else if (remoteBranch) {
+        remoteCommit = await gitlabAPI.getBranchCommit(projectPathEncoded, remoteBranch);
+        remoteBranchName = remoteBranch;
+      } else {
+        const latest = await gitlabAPI.getLatestVersion(projectPathEncoded);
+        if (latest) {
+          remoteCommit = latest.commit;
+          if (latest.type === "tag") {
+            remoteTagName = latest.name;
+          } else {
+            remoteBranchName = latest.name;
+          }
+        }
+      }
+      if (remoteCommit && localCommit && remoteCommit !== localCommit) {
+        const from = localTag || localBranch || localCommit;
+        const to = remoteTagName || remoteBranchName || remoteCommit;
+        const diff = await gitlabAPI.compareVersions(projectPathEncoded, from, to);
+        return {
+          type,
+          local: {
+            commit: localCommit,
+            tag: localTag,
+            branch: localBranch
+          },
+          remote: {
+            commit: remoteCommit,
+            tag: remoteTagName,
+            branch: remoteBranchName
+          },
+          diff: diff || void 0
+        };
+      }
+    }
+    if (!remoteCommit) {
+      const { execa: execa5 } = await import("execa");
+      const ref = remoteTag || remoteBranch || "HEAD";
+      const { stdout } = await execa5("git", ["ls-remote", repository, ref], {
+        stdio: "pipe"
+      });
+      remoteCommit = stdout.split("	")[0];
+      remoteTagName = remoteTag;
+      remoteBranchName = remoteBranch;
+    }
+    const needsUpdate = localCommit !== remoteCommit;
+    logger.info(
+      `${type === "frontend" ? "\u524D\u7AEF" : "\u540E\u7AEF"}\u6A21\u677F: ${needsUpdate ? chalk3.yellow("\u6709\u66F4\u65B0") : chalk3.green("\u5DF2\u662F\u6700\u65B0")}`
+    );
+    return {
+      type,
+      local: {
+        commit: localCommit,
+        tag: localTag,
+        branch: localBranch
+      },
+      remote: {
+        commit: remoteCommit || void 0,
+        tag: remoteTagName,
+        branch: remoteBranchName
+      }
+    };
+  } catch (error) {
+    logger.error(`\u5BF9\u6BD4${type === "frontend" ? "\u524D\u7AEF" : "\u540E\u7AEF"}\u6A21\u677F\u5931\u8D25: ${error}`);
+    return null;
+  }
+}
+function outputTable(results) {
+  logger.newLine();
+  for (const result of results) {
+    const typeName = result.type === "frontend" ? "\u524D\u7AEF" : "\u540E\u7AEF";
+    console.log(chalk3.bold(`${typeName}\u6A21\u677F:`));
+    console.log("");
+    const t = new Table({
+      head: [chalk3.cyan("\u9879\u76EE"), chalk3.cyan("\u7248\u672C")],
+      colWidths: [20, 50]
+    });
+    const localVersion = result.local.tag || result.local.branch || result.local.commit?.substring(0, 8) || "-";
+    const localInfo = `Commit: ${result.local.commit?.substring(0, 8) || "-"}${result.local.tag ? `
+Tag: ${result.local.tag}` : ""}${result.local.branch ? `
+Branch: ${result.local.branch}` : ""}`;
+    t.push(["\u672C\u5730", localInfo]);
+    const remoteVersion = result.remote.tag || result.remote.branch || result.remote.commit?.substring(0, 8) || "-";
+    const remoteInfo = `Commit: ${result.remote.commit?.substring(0, 8) || "-"}${result.remote.tag ? `
+Tag: ${result.remote.tag}` : ""}${result.remote.branch ? `
+Branch: ${result.remote.branch}` : ""}`;
+    t.push(["\u8FDC\u7A0B", remoteInfo]);
+    console.log(t.toString());
+    if (result.diff && result.diff.commits.length > 0) {
+      console.log("");
+      console.log(chalk3.bold("\u65B0\u589E\u63D0\u4EA4:"));
+      const commitsTable = new Table({
+        head: [chalk3.cyan("Commit"), chalk3.cyan("\u4F5C\u8005"), chalk3.cyan("\u65F6\u95F4"), chalk3.cyan("\u63CF\u8FF0")],
+        colWidths: [10, 15, 20, 50],
+        wordWrap: true
+      });
+      for (const commit of result.diff.commits.slice(0, 10)) {
+        commitsTable.push([
+          commit.short_id,
+          commit.author_name,
+          new Date(commit.created_at).toLocaleDateString("zh-CN"),
+          commit.title
+        ]);
+      }
+      console.log(commitsTable.toString());
+      if (result.diff.commits.length > 10) {
+        console.log(chalk3.gray(`... \u8FD8\u6709 ${result.diff.commits.length - 10} \u4E2A\u63D0\u4EA4`));
+      }
+      const files = result.diff.diffs;
+      const added = files.filter((f) => f.new_file).length;
+      const deleted = files.filter((f) => f.deleted_file).length;
+      const modified = files.length - added - deleted;
+      console.log("");
+      console.log(chalk3.bold("\u6587\u4EF6\u53D8\u66F4:"));
+      console.log(`  ${chalk3.green("+")} \u65B0\u589E: ${added}`);
+      console.log(`  ${chalk3.red("-")} \u5220\u9664: ${deleted}`);
+      console.log(`  ${chalk3.yellow("~")} \u4FEE\u6539: ${modified}`);
+    }
+    console.log("");
+  }
+}
+function outputJson(results) {
+  console.log(JSON.stringify(results, null, 2));
+}
+function outputDiff(results) {
+  logger.newLine();
+  for (const result of results) {
+    const typeName = result.type === "frontend" ? "\u524D\u7AEF" : "\u540E\u7AEF";
+    console.log(chalk3.bold(`${typeName}\u6A21\u677F:`));
+    console.log("");
+    const from = result.local.tag || result.local.branch || result.local.commit?.substring(0, 8) || "unknown";
+    const to = result.remote.tag || result.remote.branch || result.remote.commit?.substring(0, 8) || "unknown";
+    console.log(`\u672C\u5730\u7248\u672C: ${chalk3.cyan(from)}`);
+    console.log(`\u8FDC\u7A0B\u7248\u672C: ${chalk3.cyan(to)}`);
+    if (result.diff && result.diff.commits.length > 0) {
+      console.log("");
+      console.log(chalk3.bold("\u63D0\u4EA4\u5386\u53F2:"));
+      for (const commit of result.diff.commits) {
+        console.log("");
+        console.log(chalk3.yellow(`commit ${commit.id}`));
+        console.log(`Author: ${commit.author_name} <${commit.author_email}>`);
+        console.log(`Date: ${new Date(commit.created_at).toLocaleString("zh-CN")}`);
+        console.log("");
+        console.log(`    ${commit.title}`);
+        if (commit.message) {
+          console.log(`    ${commit.message.split("\n").join("\n    ")}`);
+        }
+      }
+    }
+    console.log("");
+  }
+}
+var diffCommand, Table;
+var init_diff = __esm({
+  "src/commands/diff.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_template_version();
+    init_logger();
+    init_utils();
+    init_user_config();
+    init_gitlab_api();
+    diffCommand = new Command15("diff").description("\u5BF9\u6BD4\u672C\u5730\u4E0E\u8FDC\u7A0B\u6A21\u677F\u5DEE\u5F02").option("-f, --frontend", "\u5BF9\u6BD4\u524D\u7AEF\u6A21\u677F").option("-b, --backend", "\u5BF9\u6BD4\u540E\u7AEF\u6A21\u677F").option("-t, --tag <tag>", "\u6307\u5B9A\u8FDC\u7A0B\u6807\u7B7E").option("-B, --branch <branch>", "\u6307\u5B9A\u8FDC\u7A0B\u5206\u652F").option("-o, --output <format>", "\u8F93\u51FA\u683C\u5F0F (table|json|diff)", "table").action(async (options) => {
+      try {
+        logger.header("\u6A21\u677F\u7248\u672C\u5BF9\u6BD4");
+        logger.newLine();
+        const hasConfig = await FileUtils.exists("TECH_STACK.md");
+        if (!hasConfig) {
+          logger.error("\u5F53\u524D\u76EE\u5F55\u4E0D\u662F\u4E00\u4E2A\u6709\u6548\u7684 team-cli \u9879\u76EE");
+          logger.info("\u8BF7\u5148\u5207\u6362\u5230\u9879\u76EE\u76EE\u5F55");
+          process.exit(1);
+        }
+        const projectPath = ".";
+        const checkAll = !options.frontend && !options.backend;
+        const checkFrontend = options.frontend || checkAll;
+        const checkBackend = options.backend || checkAll;
+        const config = await readTemplateConfig(projectPath);
+        if (!config) {
+          logger.error("\u672A\u627E\u5230\u6A21\u677F\u914D\u7F6E");
+          process.exit(1);
+        }
+        const gitlabConfig = await userConfigManager.getGitLabConfig();
+        if (!gitlabConfig) {
+          logger.warn("\u672A\u914D\u7F6E GitLab Token");
+          logger.info("\u8BF7\u4F7F\u7528 'team-cli config set-token' \u8FDB\u884C\u914D\u7F6E");
+          logger.info("\u5C06\u4F7F\u7528\u57FA\u672C git \u547D\u4EE4\u8FDB\u884C\u5BF9\u6BD4");
+        }
+        const results = [];
+        if (checkFrontend && config.frontend) {
+          const result = await compareTemplate(
+            projectPath,
+            "frontend",
+            config.frontend,
+            options.tag,
+            options.branch,
+            gitlabConfig || void 0
+          );
+          if (result) {
+            results.push(result);
+          }
+        }
+        if (checkBackend && config.backend) {
+          const result = await compareTemplate(
+            projectPath,
+            "backend",
+            config.backend,
+            options.tag,
+            options.branch,
+            gitlabConfig || void 0
+          );
+          if (result) {
+            results.push(result);
+          }
+        }
+        if (results.length === 0) {
+          logger.info("\u6CA1\u6709\u53EF\u5BF9\u6BD4\u7684\u6A21\u677F");
+          return;
+        }
+        switch (options.output) {
+          case "json":
+            outputJson(results);
+            break;
+          case "diff":
+            outputDiff(results);
+            break;
+          case "table":
+          default:
+            outputTable(results);
+            break;
+        }
+      } catch (error) {
+        logger.error(`\u5BF9\u6BD4\u5931\u8D25: ${error.message}`);
+        if (process.env.DEBUG) {
+          console.error(error);
+        }
+        process.exit(1);
+      }
+    });
+    Table = class {
+      options;
+      rows = [];
+      constructor(options) {
+        this.options = options;
+      }
+      push(row) {
+        this.rows.push(row);
+      }
+      toString() {
+        if (this.rows.length === 0) return "";
+        let result = "";
+        const colWidths = this.options.colWidths || [];
+        if (this.options.head) {
+          result += "| ";
+          for (let i = 0; i < this.options.head.length; i++) {
+            const width = colWidths[i] || 20;
+            const cell = this.options.head[i] || "";
+            result += cell.padEnd(width) + " | ";
+          }
+          result += "\n";
+          result += "|";
+          for (let i = 0; i < this.options.head.length; i++) {
+            const width = colWidths[i] || 20;
+            result += "-".repeat(width + 2) + "|";
+          }
+          result += "\n";
+        }
+        for (const row of this.rows) {
+          result += "| ";
+          for (let i = 0; i < row.length; i++) {
+            const width = colWidths[i] || 20;
+            const cell = String(row[i] || "");
+            const displayCell = this.options.wordWrap && cell.length > width ? cell.substring(0, width - 3) + "..." : cell;
+            result += displayCell.padEnd(width) + " | ";
+          }
+          result += "\n";
+        }
+        return result;
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+import { Command as Command16 } from "commander";
+import chalk4 from "chalk";
 function showHelp() {
   console.log("");
   logger.header("team-cli - AI-Native \u56E2\u961F\u7814\u53D1\u811A\u624B\u67B6");
   console.log("");
-  console.log(chalk2.bold("\u4F7F\u7528\u65B9\u6CD5:"));
+  console.log(chalk4.bold("\u4F7F\u7528\u65B9\u6CD5:"));
   console.log("  team-cli init [project-name]       \u521D\u59CB\u5316\u65B0\u9879\u76EE");
   console.log("  team-cli split-prd <prd-folder>    \u5C06 PRD \u62C6\u5206\u6210\u591A\u4E2A specs");
   console.log("  team-cli breakdown [spec-file]     \u5C06 spec \u62C6\u5206\u4E3A milestones \u548C todos");
@@ -4411,21 +5795,24 @@ function showHelp() {
   console.log("  team-cli status                    \u67E5\u770B\u9879\u76EE\u72B6\u6001");
   console.log("  team-cli lint                      \u4EE3\u7801\u8D28\u91CF\u68C0\u67E5 (\u524D\u7AEF+\u540E\u7AEF)");
   console.log("  team-cli logs [date]               \u67E5\u770B\u4F1A\u8BDD\u65E5\u5FD7");
+  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("  team-cli --help                    \u663E\u793A\u5E2E\u52A9\u4FE1\u606F");
   console.log("");
-  console.log(chalk2.bold("\u793A\u4F8B:"));
+  console.log(chalk4.bold("\u793A\u4F8B:"));
   console.log("  team-cli init my-project");
   console.log("  cd my-project");
   console.log("  team-cli add-feature payment-system");
   console.log("  team-cli breakdown docs/specs/xxx.md");
   console.log("  team-cli dev");
   console.log("");
-  console.log(chalk2.bold("\u5F00\u53D1\u6D41\u7A0B:"));
+  console.log(chalk4.bold("\u5F00\u53D1\u6D41\u7A0B:"));
   console.log("  1. PRD \u2192 specs (split-prd)");
   console.log("  2. spec \u2192 milestones + todos (breakdown)");
   console.log("  3. \u9009\u62E9 milestone/todo \u2192 \u5B9E\u73B0 (dev)");
   console.log("");
-  console.log(chalk2.bold("\u8FED\u4EE3\u6D41\u7A0B:"));
+  console.log(chalk4.bold("\u8FED\u4EE3\u6D41\u7A0B:"));
   console.log("  team-cli add-feature <name>     # \u6DFB\u52A0\u65B0\u529F\u80FD");
   console.log("  team-cli detect-deps [spec]     # \u68C0\u6D4B\u4F9D\u8D56\u5173\u7CFB");
   console.log("  team-cli sync-memory            # \u540C\u6B65 AI_MEMORY");
@@ -4434,7 +5821,14 @@ function showHelp() {
   console.log("  team-cli hotfix                 # \u7D27\u6025\u4FEE\u590D");
   console.log("  team-cli status                 # \u67E5\u770B\u9879\u76EE\u72B6\u6001");
   console.log("");
-  console.log(chalk2.gray("\u66F4\u591A\u4FE1\u606F: https://github.com/yungu/team-cli"));
+  console.log(chalk4.bold("\u6A21\u677F\u7BA1\u7406:"));
+  console.log("  team-cli config set-token       # \u8BBE\u7F6E GitLab Access Token");
+  console.log("  team-cli config show            # \u663E\u793A\u5F53\u524D\u914D\u7F6E");
+  console.log("  team-cli init --tag v1.0.0      # \u4F7F\u7528\u6307\u5B9A tag \u521D\u59CB\u5316");
+  console.log("  team-cli update --tag v1.1.0    # \u66F4\u65B0\u5230\u6307\u5B9A\u7248\u672C");
+  console.log("  team-cli diff                   # \u5BF9\u6BD4\u6A21\u677F\u5DEE\u5F02");
+  console.log("");
+  console.log(chalk4.gray("\u66F4\u591A\u4FE1\u606F: https://github.com/yungu/team-cli"));
   console.log("");
 }
 var program;
@@ -4456,8 +5850,11 @@ var init_index = __esm({
     init_sync_memory();
     init_check_api();
     init_logs();
-    program = new Command13();
-    program.name("team-cli").description("AI-Native \u56E2\u961F\u7814\u53D1\u811A\u624B\u67B6").version("2.0.0");
+    init_update();
+    init_config();
+    init_diff();
+    program = new Command16();
+    program.name("team-cli").description("AI-Native \u56E2\u961F\u7814\u53D1\u811A\u624B\u67B6").version("2.1.1");
     program.option("-v, --verbose", "\u8BE6\u7EC6\u8F93\u51FA\u6A21\u5F0F").option("--debug", "\u8C03\u8BD5\u6A21\u5F0F");
     program.addCommand(initCommand);
     program.addCommand(splitPrdCommand);
@@ -4472,6 +5869,9 @@ var init_index = __esm({
     program.addCommand(syncMemoryCommand);
     program.addCommand(checkApiCommand);
     program.addCommand(logsCommand);
+    program.addCommand(updateCommand);
+    program.addCommand(configCommand);
+    program.addCommand(diffCommand);
     program.action(() => {
       showHelp();
     });