yg-team-cli 2.0.0 → 2.1.1

package/dist/index.js

@@ -1,173 +1,864 @@
 #!/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 });
+};
 
-// src/index.ts
-import { Command as Command13 } from "commander";
-import chalk2 from "chalk";
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
 
 // src/lib/logger.ts
 import chalk from "chalk";
 import ora from "ora";
-var Logger = class {
-  spinner = null;
-  /**
-   * 打印标题（加粗）
-   */
-  header(text) {
-    console.log(chalk.bold(text));
-  }
-  /**
-   * 打印成功信息（绿色）
-   */
-  success(text) {
-    console.log(chalk.green("\u2713"), text);
-  }
-  /**
-   * 打印错误信息（红色）
-   */
-  error(text) {
-    console.error(chalk.red("\u2717"), text);
-  }
-  /**
-   * 打印警告信息（黄色）
-   */
-  warn(text) {
-    console.warn(chalk.yellow("\u26A0"), text);
-  }
-  /**
-   * 打印信息（蓝色）
-   */
-  info(text) {
-    console.info(chalk.blue("\u2139"), text);
-  }
-  /**
-   * 打印步骤信息
-   */
-  step(text) {
-    console.log(chalk.cyan("\u2192"), text);
-  }
-  /**
-   * 打印空行
-   */
-  newLine() {
-    console.log("");
-  }
-  /**
-   * 打印分隔线
-   */
-  separator(char = "\u2500", length = 50) {
-    console.log(chalk.gray(char.repeat(length)));
-  }
-  /**
-   * 开始加载动画
-   */
-  startLoading(text) {
-    this.spinner = ora({
-      text,
-      color: "cyan"
-    }).start();
-    return this.spinner;
-  }
-  /**
-   * 更新加载文本
-   */
-  updateLoading(text) {
-    if (this.spinner) {
-      this.spinner.text = text;
-    }
-  }
-  /**
-   * 停止加载并显示成功
-   */
-  succeedLoading(text) {
-    if (this.spinner) {
-      this.spinner.succeed(text);
-      this.spinner = null;
-    }
-  }
-  /**
-   * 停止加载并显示失败
-   */
-  failLoading(text) {
-    if (this.spinner) {
-      this.spinner.fail(text);
-      this.spinner = null;
-    }
-  }
-  /**
-   * 停止加载并显示警告
-   */
-  warnLoading(text) {
-    if (this.spinner) {
-      this.spinner.warn(text);
-      this.spinner = null;
-    }
-  }
-  /**
-   * 停止加载并显示信息
-   */
-  infoLoading(text) {
-    if (this.spinner) {
-      this.spinner.info(text);
-      this.spinner = null;
-    }
-  }
-  /**
-   * 打印表格
-   */
-  table(headers, rows) {
-    const columnWidths = headers.map((h, i) => {
-      const maxWidth = Math.max(
-        h.length,
-        ...rows.map((row) => (row[i] || "").length)
-      );
-      return maxWidth + 2;
-    });
-    const headerRow = headers.map((h, i) => chalk.bold(h.padEnd(columnWidths[i]))).join("");
-    console.log(headerRow);
-    const separator = columnWidths.map((w) => "\u2500".repeat(w)).join("\u253C");
-    console.log(chalk.gray(separator));
-    rows.forEach((row) => {
-      const dataRow = row.map((cell, i) => (cell || "").padEnd(columnWidths[i])).join("");
-      console.log(dataRow);
-    });
+var Logger, logger;
+var init_logger = __esm({
+  "src/lib/logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    Logger = class {
+      spinner = null;
+      /**
+       * 打印标题（加粗）
+       */
+      header(text) {
+        console.log(chalk.bold(text));
+      }
+      /**
+       * 打印成功信息（绿色）
+       */
+      success(text) {
+        console.log(chalk.green("\u2713"), text);
+      }
+      /**
+       * 打印错误信息（红色）
+       */
+      error(text) {
+        console.error(chalk.red("\u2717"), text);
+      }
+      /**
+       * 打印警告信息（黄色）
+       */
+      warn(text) {
+        console.warn(chalk.yellow("\u26A0"), text);
+      }
+      /**
+       * 打印信息（蓝色）
+       */
+      info(text) {
+        console.info(chalk.blue("\u2139"), text);
+      }
+      /**
+       * 打印步骤信息
+       */
+      step(text) {
+        console.log(chalk.cyan("\u2192"), text);
+      }
+      /**
+       * 打印空行
+       */
+      newLine() {
+        console.log("");
+      }
+      /**
+       * 打印分隔线
+       */
+      separator(char = "\u2500", length = 50) {
+        console.log(chalk.gray(char.repeat(length)));
+      }
+      /**
+       * 开始加载动画
+       */
+      startLoading(text) {
+        this.spinner = ora({
+          text,
+          color: "cyan"
+        }).start();
+        return this.spinner;
+      }
+      /**
+       * 更新加载文本
+       */
+      updateLoading(text) {
+        if (this.spinner) {
+          this.spinner.text = text;
+        }
+      }
+      /**
+       * 停止加载并显示成功
+       */
+      succeedLoading(text) {
+        if (this.spinner) {
+          this.spinner.succeed(text);
+          this.spinner = null;
+        }
+      }
+      /**
+       * 停止加载并显示失败
+       */
+      failLoading(text) {
+        if (this.spinner) {
+          this.spinner.fail(text);
+          this.spinner = null;
+        }
+      }
+      /**
+       * 停止加载并显示警告
+       */
+      warnLoading(text) {
+        if (this.spinner) {
+          this.spinner.warn(text);
+          this.spinner = null;
+        }
+      }
+      /**
+       * 停止加载并显示信息
+       */
+      infoLoading(text) {
+        if (this.spinner) {
+          this.spinner.info(text);
+          this.spinner = null;
+        }
+      }
+      /**
+       * 打印表格
+       */
+      table(headers, rows) {
+        const columnWidths = headers.map((h, i) => {
+          const maxWidth = Math.max(
+            h.length,
+            ...rows.map((row) => (row[i] || "").length)
+          );
+          return maxWidth + 2;
+        });
+        const headerRow = headers.map((h, i) => chalk.bold(h.padEnd(columnWidths[i]))).join("");
+        console.log(headerRow);
+        const separator = columnWidths.map((w) => "\u2500".repeat(w)).join("\u253C");
+        console.log(chalk.gray(separator));
+        rows.forEach((row) => {
+          const dataRow = row.map((cell, i) => (cell || "").padEnd(columnWidths[i])).join("");
+          console.log(dataRow);
+        });
+      }
+      /**
+       * 打印代码块
+       */
+      code(code, language = "") {
+        if (language) {
+          console.log(chalk.gray(`\`\`\`${language}`));
+        }
+        console.log(chalk.gray(code));
+        if (language) {
+          console.log(chalk.gray("```"));
+        }
+      }
+      /**
+       * 打印列表
+       */
+      list(items, indent = 2) {
+        items.forEach((item) => {
+          console.log(" ".repeat(indent) + chalk.gray("\u2022") + " " + item);
+        });
+      }
+      /**
+       * 打印带标签的文本
+       */
+      labeled(label, text, labelColor = "blue") {
+        const coloredLabel = chalk[labelColor](`[${label}]`);
+        console.log(`${coloredLabel} ${text}`);
+      }
+    };
+    logger = new Logger();
   }
-  /**
-   * 打印代码块
-   */
-  code(code, language = "") {
-    if (language) {
-      console.log(chalk.gray(`\`\`\`${language}`));
-    }
-    console.log(chalk.gray(code));
-    if (language) {
-      console.log(chalk.gray("```"));
-    }
+});
+
+// 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";
+        }
+      }
+    };
   }
-  /**
-   * 打印列表
-   */
-  list(items, indent = 2) {
-    items.forEach((item) => {
-      console.log(" ".repeat(indent) + chalk.gray("\u2022") + " " + item);
-    });
+});
+
+// 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;
+        }
+      }
+      /**
+       * 保存用户配置
+       */
+      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
+       */
+      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
+       */
+      async getGitLabToken() {
+        const config = await this.load();
+        return config?.gitlab?.accessToken || null;
+      }
+      /**
+       * 获取 GitLab 配置
+       */
+      async getGitLabConfig() {
+        const config = await this.load();
+        return config?.gitlab || null;
+      }
+      /**
+       * 检查是否已有配置
+       */
+      async hasConfig() {
+        const config = await this.load();
+        return config !== null && config.gitlab?.accessToken !== void 0;
+      }
+      /**
+       * 删除配置
+       */
+      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}`);
+        }
+      }
+      /**
+       * 简单加密 (使用机器特定密钥)
+       */
+      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;
+      }
+      /**
+       * 简单解密
+       */
+      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;
+        }
+      }
+      /**
+       * 获取机器特定密钥
+       */
+      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();
+      }
+      /**
+       * 获取配置目录
+       */
+      getConfigDir() {
+        return path4.dirname(this.configPath);
+      }
+      /**
+       * 获取配置文件路径
+       */
+      getConfigPath() {
+        return this.configPath;
+      }
+    };
+    userConfigManager = new UserConfigManager();
   }
-  /**
-   * 打印带标签的文本
-   */
-  labeled(label, text, labelColor = "blue") {
-    const coloredLabel = chalk[labelColor](`[${label}]`);
-    console.log(`${coloredLabel} ${text}`);
+});
+
+// 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
+        };
+      }
+      /**
+       * 验证 Token 是否有效
+       */
+      async authenticate() {
+        try {
+          const response = await this.request("/user");
+          return response.ok;
+        } catch (error) {
+          return false;
+        }
+      }
+      /**
+       * 列出项目的所有 Tags
+       */
+      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}`);
+        }
+      }
+      /**
+       * 列出项目的所有 Branches
+       */
+      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 是否存在
+       */
+      async validateTag(projectPath, tag) {
+        try {
+          const tags = await this.listTags(projectPath);
+          return tags.some((t) => t.name === tag);
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * 验证 Branch 是否存在
+       */
+      async validateBranch(projectPath, branch) {
+        try {
+          const branches = await this.listBranches(projectPath);
+          return branches.some((b) => b.name === branch);
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * 获取项目信息
+       */
+      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;
+        }
+      }
+      /**
+       * 获取指定 Tag 的 commit 信息
+       */
+      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 信息
+       */
+      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;
+        }
+      }
+      /**
+       * 对比两个版本之间的差异
+       */
+      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)
+       */
+      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;
+      }
+      /**
+       * 获取最新的版本（优先 Tag，否则 latest commit）
+       */
+      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;
+        }
+      }
+      /**
+       * 解析项目路径
+       * 从 Git URL 中提取项目路径
+       */
+      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("/");
+        }
+        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);
+        }
+      }
+      /**
+       * 获取默认分支
+       */
+      async getDefaultBranch(projectPath) {
+        try {
+          const project = await this.getProject(projectPath);
+          return project?.default_branch || null;
+        } catch {
+          return null;
+        }
+      }
+    };
   }
-};
-var logger = new Logger();
+});
+
+// src/index.ts
+init_esm_shims();
+init_logger();
+import { Command as Command16 } from "commander";
+import chalk4 from "chalk";
 
 // src/commands/init.ts
+init_esm_shims();
+init_logger();
 import { Command } from "commander";
 import inquirer from "inquirer";
-import path2 from "path";
+import path5 from "path";
 import fs2 from "fs-extra";
 
 // src/lib/claude.ts
+init_esm_shims();
+init_logger();
+init_utils();
 import { execa } from "execa";
 var ClaudeAI = class {
   verbose;
@@ -202,25 +893,45 @@ var ClaudeAI = class {
   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}` : ""}`);
     }
   }
   /**
@@ -244,12 +955,17 @@ var ClaudeAI = class {
         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;
@@ -460,234 +1176,135 @@ ${projectContext}
 };
 var claudeAI = new ClaudeAI();
 
-// src/lib/utils.ts
-import fs from "fs-extra";
-import path from "path";
-import { glob } from "glob";
-var 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 });
+// src/commands/init.ts
+init_utils();
+import { Listr } from "listr2";
+
+// src/lib/template-version.ts
+init_esm_shims();
+init_utils();
+init_logger();
+import { execa as execa2 } from "execa";
+import path3 from "path";
+var 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"
   }
 };
-var 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);
+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;
   }
-  /**
-   * 截断字符串
-   */
-  static truncate(str, length, suffix = "...") {
-    if (str.length <= length) return str;
-    return str.slice(0, length - suffix.length) + suffix;
+  try {
+    const content = await FileUtils.read(configPath);
+    return JSON.parse(content);
+  } catch {
+    return null;
   }
-  /**
-   * 生成 slug
-   */
-  static slugify(str) {
-    return str.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+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;
   }
-};
-var 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);
+  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 "";
   }
-  /**
-   * 获取相对时间
-   */
-  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 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 "";
   }
-};
-var GitUtils = class {
-  /**
-   * 检查是否在 Git 仓库中
-   */
-  static async isGitRepo(cwd = process.cwd()) {
-    const gitDir = path.join(cwd, ".git");
-    return await FileUtils.exists(gitDir);
+}
+async function checkTemplateUpdate(projectPath, type) {
+  const config = await readTemplateConfig(projectPath);
+  if (!config || !config[type]) {
+    return null;
   }
-  /**
-   * 获取当前分支名
-   */
-  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();
+  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;
   }
-  /**
-   * 获取当前 commit hash
-   */
-  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);
+  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;
   }
-};
-var 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;
+  config[type].commit = commit;
+  if (options?.tag) {
+    config[type].tag = options.tag;
   }
-  /**
-   * 获取 spec 状态
-   */
-  static async getSpecStatus(file) {
-    try {
-      const spec = await this.parseSpec(file);
-      return spec.status || "\u672A\u77E5";
-    } catch {
-      return "\u9519\u8BEF";
-    }
+  if (options?.branch) {
+    config[type].branch = options.branch;
   }
-};
+  config[type].lastUpdate = (/* @__PURE__ */ new Date()).toISOString();
+  await saveTemplateConfig(projectPath, config);
+}
 
 // src/commands/init.ts
-import { Listr } from "listr2";
-var 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) => {
+var 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([
@@ -718,7 +1335,7 @@ var initCommand = new Command("init").argument("[project-name]", "\u9879\u76EE\u
       logger.info("\u8BF7\u5B89\u88C5 Claude CLI: npm install -g @anthropic-ai/claude-code");
       process.exit(1);
     }
-    const projectPath = path2.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");
@@ -737,11 +1354,11 @@ var initCommand = new Command("init").argument("[project-name]", "\u9879\u76EE\u
           title: "\u521B\u5EFA\u9879\u76EE\u76EE\u5F55",
           task: async () => {
             await FileUtils.ensureDir(projectPath);
-            await FileUtils.ensureDir(path2.join(projectPath, "frontend"));
-            await FileUtils.ensureDir(path2.join(projectPath, "backend"));
-            await FileUtils.ensureDir(path2.join(projectPath, "docs/specs"));
-            await FileUtils.ensureDir(path2.join(projectPath, "docs/api"));
-            await FileUtils.ensureDir(path2.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"));
           }
         },
         {
@@ -771,7 +1388,12 @@ var initCommand = new Command("init").argument("[project-name]", "\u9879\u76EE\u
         {
           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
+            });
           }
         },
         {
@@ -916,7 +1538,7 @@ docs/
 \u2514\u2500\u2500 sessions/            # \u5F00\u53D1\u4F1A\u8BDD\u8BB0\u5F55
 \`\`\`
 `;
-  await FileUtils.write(path2.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
@@ -1219,7 +1841,7 @@ test('renders user name', () => {
 });
 \`\`\`
 `;
-  await FileUtils.write(path2.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
@@ -1230,6 +1852,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 |
@@ -1269,7 +1900,7 @@ async function generateAIMemory(projectPath, projectName) {
 | Bug ID | \u65E5\u671F | \u95EE\u9898\u63CF\u8FF0 | \u72B6\u6001 |
 |--------|------|---------|------|
 `;
-  await FileUtils.write(path2.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]
@@ -1333,35 +1964,78 @@ async function generateSpecTemplate(projectPath) {
 ----
 *\u751F\u6210\u4E8E: {{TIMESTAMP}} by team-cli*
 `;
-  await FileUtils.write(path2.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 = path2.join(projectPath, "backend");
+  const backendPath = path5.join(projectPath, "backend");
   try {
     const { execaCommand } = await import("execa");
-    const tempDir = path2.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 = path2.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(path2.join(backendPath, "src/main/java/com/example"));
-    await FileUtils.ensureDir(path2.join(backendPath, "src/main/resources"));
-    await FileUtils.ensureDir(path2.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 = path2.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:
@@ -1374,16 +2048,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: [
-        path2.join(projectPath, "TECH_STACK.md"),
-        path2.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(path2.join(frontendPath, "src/app"));
-    await FileUtils.ensureDir(path2.join(frontendPath, "src/components"));
-    await FileUtils.ensureDir(path2.join(frontendPath, "src/lib"));
-    await FileUtils.ensureDir(path2.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) {
@@ -1405,9 +2079,12 @@ async function initGit(projectPath, projectName) {
 }
 
 // src/commands/breakdown.ts
+init_esm_shims();
+init_utils();
+init_logger();
 import { Command as Command2 } from "commander";
 import inquirer2 from "inquirer";
-import path3 from "path";
+import path6 from "path";
 import { Listr as Listr2 } from "listr2";
 var breakdownCommand = new Command2("breakdown").argument("[spec-file]", "Spec \u6587\u4EF6\u8DEF\u5F84").description("\u5C06 spec \u62C6\u5206\u4E3A milestones \u548C todos").action(async (specFile) => {
   try {
@@ -1453,9 +2130,9 @@ var breakdownCommand = new Command2("breakdown").argument("[spec-file]", "Spec \
                 choices: ctx.specs
               }
             ]);
-            return path3.join("docs/specs", selectedFile);
+            return path6.join("docs/specs", selectedFile);
           }
-          const fullPath = specFile.startsWith("docs/specs/") ? specFile : path3.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}`);
@@ -1582,9 +2259,12 @@ Important Instructions:
 }
 
 // src/commands/dev.ts
+init_esm_shims();
+init_utils();
+init_logger();
 import { Command as Command3 } from "commander";
 import inquirer3 from "inquirer";
-import path4 from "path";
+import path7 from "path";
 var devCommand = new Command3("dev").description("\u5F00\u53D1\u6A21\u5F0F\uFF0C\u6267\u884C\u5177\u4F53\u4EFB\u52A1").action(async () => {
   try {
     logger.header("\u5F00\u53D1\u6A21\u5F0F");
@@ -1629,7 +2309,7 @@ async function selectSpec() {
   }
   const specs = [];
   for (let i = 0; i < specFiles.length; i++) {
-    const file = path4.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);
@@ -1943,8 +2623,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 = path4.basename(specFile, ".md");
-  const logFile = path4.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")}
@@ -1976,9 +2656,12 @@ ${result}
 }
 
 // src/commands/add-feature.ts
+init_esm_shims();
+init_utils();
+init_logger();
 import { Command as Command4 } from "commander";
 import inquirer4 from "inquirer";
-import path5 from "path";
+import path8 from "path";
 import { Listr as Listr3 } from "listr2";
 var addFeatureCommand = new Command4("add-feature").argument("<feature-name>", "\u529F\u80FD\u540D\u79F0").description("\u6DFB\u52A0\u65B0\u529F\u80FD\uFF08\u652F\u6301 PRD \u6216\u7B80\u5355\u63CF\u8FF0\u6A21\u5F0F\uFF09").action(async (featureName) => {
   try {
@@ -1997,7 +2680,7 @@ var addFeatureCommand = new Command4("add-feature").argument("<feature-name>", "
       process.exit(1);
     }
     const featureSlug = StringUtils2.toKebabCase(featureName);
-    const specFile = path5.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}`);
@@ -2056,7 +2739,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(path5.join(specDir, file));
+          const status = await SpecUtils.getSpecStatus(path8.join(specDir, file));
           if (status === "\u5DF2\u5B8C\u6210") {
             ctx2.completedSpecs.push(file.replace(".md", ""));
           }
@@ -2128,7 +2811,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(path5.join(specDir, file));
+          const status = await SpecUtils.getSpecStatus(path8.join(specDir, file));
           if (status === "\u5DF2\u5B8C\u6210") {
             ctx2.completedSpecs.push(file.replace(".md", ""));
           }
@@ -2225,7 +2908,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(path5.join("docs/specs", file));
+      const status = await SpecUtils.getSpecStatus(path8.join("docs/specs", file));
       context.push(`  - ${file.replace(".md", "")} [${status}]`);
     }
   }
@@ -2465,8 +3148,11 @@ async function askToAdjust(specFile) {
 }
 
 // src/commands/split-prd.ts
+init_esm_shims();
+init_utils();
+init_logger();
 import { Command as Command5 } from "commander";
-import path6 from "path";
+import path9 from "path";
 import { Listr as Listr4 } from "listr2";
 var splitPrdCommand = new Command5("split-prd").argument("<prd-folder>", "PRD \u6587\u6863\u76EE\u5F55").description("\u5C06 PRD \u62C6\u5206\u6210\u591A\u4E2A specs").action(async (prdFolder) => {
   try {
@@ -2496,7 +3182,7 @@ var splitPrdCommand = new Command5("split-prd").argument("<prd-folder>", "PRD \u
           ctx2.prdFiles = [];
           for (const ext of supportedExtensions) {
             const files = await FileUtils.findFiles(`*.${ext}`, prdFolder);
-            ctx2.prdFiles.push(...files.map((f) => path6.join(prdFolder, f)));
+            ctx2.prdFiles.push(...files.map((f) => path9.join(prdFolder, f)));
           }
           if (ctx2.prdFiles.length === 0) {
             throw new Error(
@@ -2514,7 +3200,7 @@ var splitPrdCommand = new Command5("split-prd").argument("<prd-folder>", "PRD \u
       {
         title: "\u626B\u63CF\u622A\u56FE\u6587\u4EF6",
         task: async (ctx2) => {
-          const screenshotDir = path6.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");
@@ -2525,7 +3211,7 @@ var splitPrdCommand = new Command5("split-prd").argument("<prd-folder>", "PRD \u
           ctx2.screenshots = [];
           for (const ext of imageExtensions) {
             const files = await FileUtils.findFiles(`*.${ext}`, screenshotDir);
-            ctx2.screenshots.push(...files.map((f) => path6.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`);
         }
@@ -2536,8 +3222,8 @@ var splitPrdCommand = new Command5("split-prd").argument("<prd-folder>", "PRD \u
           const entries = await FileUtils.findFiles("*/", prdFolder);
           ctx2.demoRepos = [];
           for (const entry of entries) {
-            const dirPath = path6.join(prdFolder, entry);
-            const gitDir = path6.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);
@@ -2705,9 +3391,12 @@ IMPORTANT:
 }
 
 // src/commands/bugfix.ts
+init_esm_shims();
+init_utils();
+init_logger();
 import { Command as Command6 } from "commander";
 import inquirer5 from "inquirer";
-import path7 from "path";
+import path10 from "path";
 import { Listr as Listr5 } from "listr2";
 var bugfixCommand = new Command6("bugfix").description("\u521B\u5EFA Bugfix \u8BB0\u5F55").action(async () => {
   try {
@@ -2756,7 +3445,7 @@ var bugfixCommand = new Command6("bugfix").description("\u521B\u5EFA Bugfix \u8B
     const relatedSpec = await findRelatedSpec(answers.description);
     const bugfixDir = "docs/bugfixes";
     await FileUtils.ensureDir(bugfixDir);
-    const bugfixFile = path7.join(bugfixDir, `${timestamp}_${bugId}.md`);
+    const bugfixFile = path10.join(bugfixDir, `${timestamp}_${bugId}.md`);
     const content = formatBugfixDocument({
       id: bugId,
       severity: answers.severity,
@@ -2822,8 +3511,8 @@ var hotfixCommand = new Command6("hotfix").description("\u7D27\u6025\u4FEE\u590D
       {
         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" });
         }
       },
       {
@@ -2832,7 +3521,7 @@ var hotfixCommand = new Command6("hotfix").description("\u7D27\u6025\u4FEE\u590D
           const timestamp = DateUtils.format(/* @__PURE__ */ new Date(), "YYYY-MM-DD HH:mm:ss");
           const hotfixDir = "docs/hotfixes";
           await FileUtils.ensureDir(hotfixDir);
-          const hotfixFile = path7.join(hotfixDir, `${timestamp}_${hotfixId}.md`);
+          const hotfixFile = path10.join(hotfixDir, `${timestamp}_${hotfixId}.md`);
           const content = formatHotfixDocument({
             id: hotfixId,
             description: answers.description,
@@ -2847,9 +3536,9 @@ var hotfixCommand = new Command6("hotfix").description("\u7D27\u6025\u4FEE\u590D
       {
         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",
@@ -2907,7 +3596,7 @@ async function findRelatedSpec(description) {
   }
   const keywords = extractKeywords(description);
   for (const file of specs) {
-    const filePath = path7.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())) {
@@ -2995,8 +3684,11 @@ git checkout ${data.branch}
 }
 
 // src/commands/lint.ts
+init_esm_shims();
+init_utils();
+init_logger();
 import { Command as Command7 } from "commander";
-import { execa as execa2 } from "execa";
+import { execa as execa3 } from "execa";
 var lintCommand = new Command7("lint").option("--fix", "\u81EA\u52A8\u4FEE\u590D\u95EE\u9898").description("\u4EE3\u7801\u8D28\u91CF\u68C0\u67E5 (\u524D\u7AEF + \u540E\u7AEF)").action(async (options) => {
   try {
     logger.header("\u4EE3\u7801\u8D28\u91CF\u68C0\u67E5");
@@ -3017,17 +3709,17 @@ var lintCommand = new Command7("lint").option("--fix", "\u81EA\u52A8\u4FEE\u590D
       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"
         });
@@ -3050,23 +3742,23 @@ var lintCommand = new Command7("lint").option("--fix", "\u81EA\u52A8\u4FEE\u590D
         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"
           });
@@ -3118,8 +3810,11 @@ var lintCommand = new Command7("lint").option("--fix", "\u81EA\u52A8\u4FEE\u590D
 });
 
 // src/commands/status.ts
+init_esm_shims();
+init_utils();
+init_logger();
 import { Command as Command8 } from "commander";
-import path8 from "path";
+import path11 from "path";
 var statusCommand = new Command8("status").description("\u67E5\u770B\u9879\u76EE\u72B6\u6001").action(async () => {
   try {
     logger.header("\u9879\u76EE\u72B6\u6001");
@@ -3177,7 +3872,7 @@ async function displayFeatureInventory() {
   }
   const inventory = [];
   for (const file of specs) {
-    const filePath = path8.join(specDir, file);
+    const filePath = path11.join(specDir, file);
     const content = await FileUtils.read(filePath);
     const status = parseSpecStatus2(content);
     inventory.push({
@@ -3236,7 +3931,7 @@ async function displayRecentActivity() {
   }
   const sorted = files.sort().reverse().slice(0, 5);
   for (const file of sorted) {
-    const filePath = path8.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";
@@ -3274,8 +3969,11 @@ function getProgress(spec) {
 }
 
 // src/commands/detect-deps.ts
+init_esm_shims();
+init_utils();
+init_logger();
 import { Command as Command9 } from "commander";
-import path9 from "path";
+import path12 from "path";
 import inquirer6 from "inquirer";
 var detectDepsCommand = new Command9("detect-deps").argument("[spec-file]", "Spec \u6587\u4EF6\u8DEF\u5F84").description("\u68C0\u6D4B\u4F9D\u8D56\u5173\u7CFB").action(async (specFile) => {
   try {
@@ -3303,7 +4001,7 @@ var detectDepsCommand = new Command9("detect-deps").argument("[spec-file]", "Spe
         process.exit(1);
       }
       for (const spec of specs) {
-        const specPath = path9.join(specsDir, spec);
+        const specPath = path12.join(specsDir, spec);
         logger.step(`\u5904\u7406: ${spec}`);
         await detectDependencies(specPath);
         logger.newLine();
@@ -3329,7 +4027,7 @@ async function detectDependencies(specFile) {
   logger.step("\u81EA\u52A8\u68C0\u6D4B\u4F9D\u8D56\u5173\u7CFB...");
   const projectDir = ".";
   const allDeps = /* @__PURE__ */ new Set();
-  const backendDir = path9.join(projectDir, "backend");
+  const backendDir = path12.join(projectDir, "backend");
   const backendExists = await FileUtils.exists(backendDir);
   if (backendExists) {
     const apiDeps = await scanBackendApiCalls(backendDir);
@@ -3339,7 +4037,7 @@ async function detectDependencies(specFile) {
     const serviceDeps = await scanBackendServiceRefs(backendDir);
     serviceDeps.forEach((d) => allDeps.add(d));
   }
-  const frontendDir = path9.join(projectDir, "frontend");
+  const frontendDir = path12.join(projectDir, "frontend");
   const frontendExists = await FileUtils.exists(frontendDir);
   if (frontendExists) {
     const frontendDeps = await scanFrontendApiCalls(frontendDir);
@@ -3380,11 +4078,11 @@ async function detectDependencies(specFile) {
 }
 async function scanBackendApiCalls(backendDir) {
   const deps = [];
-  const srcDir = path9.join(backendDir, "src");
+  const srcDir = path12.join(backendDir, "src");
   try {
     const javaFiles = await FileUtils.findFiles("*.java", srcDir);
     for (const file of javaFiles) {
-      const filePath = path9.join(srcDir, file);
+      const filePath = path12.join(srcDir, file);
       const content = await FileUtils.read(filePath);
       const pathRegex = /"(\/api\/[^"]+)"/g;
       let match;
@@ -3402,11 +4100,11 @@ async function scanBackendApiCalls(backendDir) {
 }
 async function scanBackendEntityRelations(backendDir) {
   const deps = [];
-  const srcDir = path9.join(backendDir, "src");
+  const srcDir = path12.join(backendDir, "src");
   try {
     const javaFiles = await FileUtils.findFiles("*.java", srcDir);
     for (const file of javaFiles) {
-      const filePath = path9.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;
@@ -3422,11 +4120,11 @@ async function scanBackendEntityRelations(backendDir) {
 }
 async function scanBackendServiceRefs(backendDir) {
   const deps = [];
-  const srcDir = path9.join(backendDir, "src");
+  const srcDir = path12.join(backendDir, "src");
   try {
     const javaFiles = await FileUtils.findFiles("*.java", srcDir);
     for (const file of javaFiles) {
-      const filePath = path9.join(srcDir, file);
+      const filePath = path12.join(srcDir, file);
       const content = await FileUtils.read(filePath);
       const serviceRegex = /private\s+(\w+)Service/g;
       let match;
@@ -3442,11 +4140,11 @@ async function scanBackendServiceRefs(backendDir) {
 }
 async function scanFrontendApiCalls(frontendDir) {
   const deps = [];
-  const srcDir = path9.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 = path9.join(srcDir, file);
+      const filePath = path12.join(srcDir, file);
       const content = await FileUtils.read(filePath);
       const pathRegex = /"(\/api\/[^"]+)"/g;
       let match;
@@ -3532,8 +4230,11 @@ ${deps.map((d) => `  - [x] ${d}`).join("\n")}
 }
 
 // src/commands/sync-memory.ts
+init_esm_shims();
+init_utils();
+init_logger();
 import { Command as Command10 } from "commander";
-import path10 from "path";
+import path13 from "path";
 var syncMemoryCommand = new Command10("sync-memory").description("\u540C\u6B65 AI_MEMORY.md").action(async () => {
   try {
     logger.header("\u540C\u6B65 AI_MEMORY.md");
@@ -3553,6 +4254,7 @@ var syncMemoryCommand = new Command10("sync-memory").description("\u540C\u6B65 A
     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) {
@@ -3565,7 +4267,7 @@ var syncMemoryCommand = new Command10("sync-memory").description("\u540C\u6B65 A
 });
 async function syncFeatureInventory(aiMemoryFile, projectDir) {
   logger.step("\u540C\u6B65\u529F\u80FD\u6E05\u5355...");
-  const specsDir = path10.join(projectDir, "docs/specs");
+  const specsDir = path13.join(projectDir, "docs/specs");
   const exists = await FileUtils.exists(specsDir);
   if (!exists) {
     return;
@@ -3580,7 +4282,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 = path10.join(specsDir, specFile);
+    const specPath = path13.join(specsDir, specFile);
     const content = await FileUtils.read(specPath);
     const status = parseSpecStatus3(content);
     const progress = getSpecProgress(content);
@@ -3598,7 +4300,7 @@ async function syncFeatureInventory(aiMemoryFile, projectDir) {
 }
 async function syncApiInventory(aiMemoryFile, projectDir) {
   logger.step("\u540C\u6B65 API \u5217\u8868...");
-  const backendDir = path10.join(projectDir, "backend");
+  const backendDir = path13.join(projectDir, "backend");
   const exists = await FileUtils.exists(backendDir);
   if (!exists) {
     return;
@@ -3608,13 +4310,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 = path10.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 = path10.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`);
@@ -3691,7 +4393,7 @@ function extractMethodComment(content, methodName) {
 }
 async function syncDataModels(aiMemoryFile, projectDir) {
   logger.step("\u540C\u6B65\u6570\u636E\u6A21\u578B...");
-  const backendDir = path10.join(projectDir, "backend");
+  const backendDir = path13.join(projectDir, "backend");
   const exists = await FileUtils.exists(backendDir);
   if (!exists) {
     return;
@@ -3701,7 +4403,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 = path10.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");
@@ -3709,7 +4411,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 = path10.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);
@@ -3798,10 +4500,56 @@ 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;
+}
 
 // src/commands/check-api.ts
+init_esm_shims();
+init_utils();
+init_logger();
 import { Command as Command11 } from "commander";
-import path11 from "path";
+import path14 from "path";
 import inquirer7 from "inquirer";
 import { Listr as Listr6 } from "listr2";
 var checkApiCommand = new Command11("check-api").description("API \u68C0\u67E5\uFF08\u51B2\u7A81/\u53D8\u66F4/Registry\uFF09").action(async () => {
@@ -3865,7 +4613,7 @@ var checkApiCommand = new Command11("check-api").description("API \u68C0\u67E5\u
   }
 });
 async function checkApiConflicts(projectDir) {
-  const backendDir = path11.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");
@@ -3874,10 +4622,10 @@ async function checkApiConflicts(projectDir) {
   logger.step("\u626B\u63CF\u540E\u7AEF API...");
   logger.newLine();
   const apiMap = /* @__PURE__ */ new Map();
-  const srcDir = path11.join(backendDir, "src");
+  const srcDir = path14.join(backendDir, "src");
   const controllers = await FileUtils.findFiles("*Controller.java", srcDir);
   for (const controllerFile of controllers) {
-    const controllerPath = path11.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}`;
@@ -3908,8 +4656,8 @@ async function checkApiConflicts(projectDir) {
   }
 }
 async function detectApiChanges(projectDir) {
-  const backendDir = path11.join(projectDir, "backend");
-  const registryFile = path11.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");
@@ -3921,10 +4669,10 @@ async function detectApiChanges(projectDir) {
   const registryContent = await FileUtils.read(registryFile);
   const existingApis = extractApisFromRegistry(registryContent);
   const currentApis = /* @__PURE__ */ new Map();
-  const srcDir = path11.join(backendDir, "src");
+  const srcDir = path14.join(backendDir, "src");
   const controllers = await FileUtils.findFiles("*Controller.java", srcDir);
   for (const controllerFile of controllers) {
-    const controllerPath = path11.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}`;
@@ -3986,9 +4734,9 @@ async function detectApiChanges(projectDir) {
   }
 }
 async function generateApiRegistry(projectDir) {
-  const registryFile = path11.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(path11.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
@@ -4017,14 +4765,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 = path11.join(projectDir, "backend");
+  const backendDir = path14.join(projectDir, "backend");
   const exists = await FileUtils.exists(backendDir);
   if (exists) {
-    const srcDir = path11.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 = path11.join(srcDir, controllerFile);
+      const controllerPath = path14.join(srcDir, controllerFile);
       const controllerName = controllerFile.replace(".java", "");
       const module = controllerName.replace(/Controller$/, "").toLowerCase();
       if (!moduleMap.has(module)) {
@@ -4108,10 +4856,10 @@ function extractApisFromRegistry(registryContent) {
   let match;
   while ((match = apiRegex.exec(registryContent)) !== null) {
     const method = match[1];
-    const path13 = match[2].trim();
+    const path17 = match[2].trim();
     const description = match[3].trim();
-    const key = `${method}:${path13}`;
-    apis.set(key, { method, path: path13, description });
+    const key = `${method}:${path17}`;
+    apis.set(key, { method, path: path17, description });
   }
   return apis;
 }
@@ -4129,8 +4877,11 @@ function extractMethodComment2(content, methodName) {
 }
 
 // src/commands/logs.ts
+init_esm_shims();
+init_utils();
+init_logger();
 import { Command as Command12 } from "commander";
-import path12 from "path";
+import path15 from "path";
 import inquirer8 from "inquirer";
 var logsCommand = new Command12("logs").argument("[filter]", "\u8FC7\u6EE4\u5668 (today, --all, \u6216\u65E5\u671F YYYY-MM-DD)").description("\u67E5\u770B\u4F1A\u8BDD\u65E5\u5FD7").action(async (filter = "today") => {
   try {
@@ -4155,7 +4906,7 @@ var logsCommand = new Command12("logs").argument("[filter]", "\u8FC7\u6EE4\u5668
       case "":
       case "today": {
         const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-        targetDir = path12.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");
@@ -4171,7 +4922,7 @@ var logsCommand = new Command12("logs").argument("[filter]", "\u8FC7\u6EE4\u5668
         break;
       }
       default: {
-        targetDir = path12.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`);
@@ -4195,7 +4946,7 @@ var logsCommand = new Command12("logs").argument("[filter]", "\u8FC7\u6EE4\u5668
       process.exit(0);
     }
     for (let i = 0; i < logs.length; i++) {
-      const relPath = path12.relative(sessionsDir, logs[i]);
+      const relPath = path15.relative(sessionsDir, logs[i]);
       logger.step(`${i + 1}) ${relPath}`);
     }
     logger.newLine();
@@ -4236,7 +4987,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 = path12.join(targetDir, file);
+      const filePath = path15.join(targetDir, file);
       const stat = await FileUtils.exists(filePath);
       if (stat) {
         logs.push(filePath);
@@ -4247,9 +4998,683 @@ async function collectLogFiles(targetDir) {
   return logs;
 }
 
+// src/commands/update.ts
+init_esm_shims();
+import { Command as Command13 } from "commander";
+import path16 from "path";
+init_logger();
+init_utils();
+import { execa as execa4 } from "execa";
+import inquirer9 from "inquirer";
+import fs3 from "fs-extra";
+var 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);
+  }
+});
+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();
+}
+
+// src/commands/config.ts
+init_esm_shims();
+init_user_config();
+init_gitlab_api();
+init_logger();
+import { Command as Command14 } from "commander";
+import inquirer10 from "inquirer";
+import chalk2 from "chalk";
+var 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);
+  }
+});
+var 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);
+  }
+});
+var 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);
+  }
+});
+var 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);
+  }
+});
+var configCommand = new Command14("config").description("\u7BA1\u7406 GitLab \u914D\u7F6E").addCommand(setTokenCommand).addCommand(showConfigCommand).addCommand(removeConfigCommand).addCommand(validateTokenCommand);
+
+// src/commands/diff.ts
+init_esm_shims();
+import { Command as Command15 } from "commander";
+import chalk3 from "chalk";
+init_logger();
+init_utils();
+init_user_config();
+init_gitlab_api();
+var 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);
+  }
+});
+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 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 program = new Command13();
-program.name("team-cli").description("AI-Native \u56E2\u961F\u7814\u53D1\u811A\u624B\u67B6").version("2.0.0");
+var 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);
@@ -4264,6 +5689,9 @@ program.addCommand(detectDepsCommand);
 program.addCommand(syncMemoryCommand);
 program.addCommand(checkApiCommand);
 program.addCommand(logsCommand);
+program.addCommand(updateCommand);
+program.addCommand(configCommand);
+program.addCommand(diffCommand);
 program.action(() => {
   showHelp();
 });
@@ -4271,7 +5699,7 @@ 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");
@@ -4285,21 +5713,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");
@@ -4308,7 +5739,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("");
 }
 process.on("uncaughtException", (error) => {