@superspec/cli 1.0.0 → 1.1.1

package/dist/index.js

@@ -2,11 +2,12 @@
 import { readFileSync, existsSync } from "fs";
 import { join } from "path";
 var DEFAULT_CONFIG = {
-  lang: "zh",
+  lang: "en",
   aiEditor: "cursor",
   specDir: "superspec",
-  branchPrefix: "spec/",
-  branchTemplate: "{prefix}{name}",
+  branchPrefix: "",
+  branchTemplate: "{prefix}{intentType}-{date}-{feature}-{user}",
+  changeNameTemplate: "{prefix}{intentType}-{date}-{feature}-{user}",
   boost: false,
   strategy: "follow",
   context: [],
@@ -15,7 +16,8 @@ var DEFAULT_CONFIG = {
     proposal: "proposal.md",
     tasks: "tasks.md",
     clarify: "clarify.md",
-    checklist: "checklist.md"
+    checklist: "checklist.md",
+    design: "design.md"
   },
   archive: {
     dir: "archive",
@@ -26,16 +28,18 @@ var DEFAULT_CONFIG = {
     hardLines: 400
   },
   artifacts: ["proposal"],
-  boostArtifacts: ["proposal", "spec", "tasks", "checklist"]
+  boostArtifacts: ["proposal", "spec", "design", "tasks", "checklist"]
 };
-function loadConfig(projectRoot = process.cwd()) {
+function loadConfig(projectRoot = process.cwd(), silent = false) {
   const configPath = join(projectRoot, "superspec.config.json");
   let userConfig = {};
   if (existsSync(configPath)) {
     try {
       userConfig = JSON.parse(readFileSync(configPath, "utf-8"));
     } catch (e) {
-      console.warn(`\u26A0 \u914D\u7F6E\u6587\u4EF6\u89E3\u6790\u5931\u8D25: ${e.message}`);
+      if (!silent) {
+        console.warn(`\u26A0 Config file parsing failed: ${e.message}`);
+      }
     }
   }
   return deepMerge(DEFAULT_CONFIG, userConfig);
@@ -46,32 +50,41 @@ function getDefaultConfig() {
 function deepMerge(target, source) {
   const result = { ...target };
   for (const key of Object.keys(source)) {
-    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key]) && target[key] && typeof target[key] === "object") {
-      result[key] = deepMerge(target[key], source[key]);
+    const val = source[key];
+    if (val === null || val === void 0) continue;
+    if (typeof val === "object" && !Array.isArray(val) && target[key] && typeof target[key] === "object") {
+      result[key] = deepMerge(target[key], val);
     } else {
-      result[key] = source[key];
+      result[key] = val;
     }
   }
   return result;
 }
 
 // src/core/template.ts
-import { existsSync as existsSync3, copyFileSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { existsSync as existsSync4, copyFileSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { join as join3, dirname as dirname2 } from "path";
 
 // src/utils/paths.ts
 import { dirname, join as join2 } from "path";
+import { existsSync as existsSync2 } from "fs";
 import { fileURLToPath } from "url";
 function getPackageRoot() {
   const __filename2 = fileURLToPath(import.meta.url);
-  const __dirname2 = dirname(__filename2);
-  return join2(__dirname2, "..", "..");
+  let dir = dirname(__filename2);
+  while (dir !== dirname(dir)) {
+    if (existsSync2(join2(dir, "package.json")) && existsSync2(join2(dir, "templates"))) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+  return join2(dirname(__filename2), "..", "..");
 }
 
 // src/utils/fs.ts
-import { mkdirSync, existsSync as existsSync2 } from "fs";
+import { mkdirSync, existsSync as existsSync3, readdirSync } from "fs";
 function ensureDir(dir) {
-  if (!existsSync2(dir)) {
+  if (!existsSync3(dir)) {
     mkdirSync(dir, { recursive: true });
   }
 }
@@ -80,9 +93,10 @@ function ensureDir(dir) {
 function resolveTemplatePath(templateName, lang = "zh") {
   const root = getPackageRoot();
   const langPath = join3(root, "templates", lang, templateName);
-  if (existsSync3(langPath)) return langPath;
-  const fallback = join3(root, "templates", "zh", templateName);
-  if (existsSync3(fallback)) return fallback;
+  if (existsSync4(langPath)) return langPath;
+  const fallbackLang = lang === "zh" ? "en" : "zh";
+  const fallback = join3(root, "templates", fallbackLang, templateName);
+  if (existsSync4(fallback)) return fallback;
   throw new Error(`Template not found: ${templateName} (lang: ${lang})`);
 }
 function copyTemplate(templateName, destPath, lang = "zh") {
@@ -116,28 +130,29 @@ function writeRenderedTemplate(templateName, destPath, vars = {}, lang = "zh") {
 }
 
 // src/core/lint.ts
-import { readFileSync as readFileSync3, existsSync as existsSync4, readdirSync } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync5, readdirSync as readdirSync2 } from "fs";
 import { join as join4, basename } from "path";
 
 // src/core/validate.ts
-import { readFileSync as readFileSync4, existsSync as existsSync5 } from "fs";
+import { readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
 import { join as join5 } from "path";
 
 // src/core/context.ts
-import { readFileSync as readFileSync5, existsSync as existsSync6 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync7 } from "fs";
 import { join as join6 } from "path";
 
 // src/utils/date.ts
 function getDateString() {
   const d = /* @__PURE__ */ new Date();
-  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+  return `${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, "0")}${String(d.getDate()).padStart(2, "0")}`;
 }
 
 // src/utils/git.ts
 import { execSync } from "child_process";
+var GIT_TIMEOUT = 1e4;
 function isGitRepo() {
   try {
-    execSync("git rev-parse --is-inside-work-tree", { stdio: "ignore" });
+    execSync("git rev-parse --is-inside-work-tree", { stdio: "ignore", timeout: GIT_TIMEOUT });
     return true;
   } catch {
     return false;
@@ -148,16 +163,16 @@ function createBranch(branchName) {
   if (!SAFE_BRANCH_RE.test(branchName)) {
     throw new Error(`invalid branch name: ${branchName}`);
   }
-  execSync(`git checkout -b ${branchName}`, { stdio: "inherit" });
+  execSync(`git checkout -b ${branchName}`, { stdio: "inherit", timeout: GIT_TIMEOUT });
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync8, writeFileSync as writeFileSync3, readdirSync as readdirSync4 } from "fs";
+import { existsSync as existsSync9, writeFileSync as writeFileSync3, readdirSync as readdirSync5 } from "fs";
 import { join as join8 } from "path";
 import { execSync as execSync2 } from "child_process";
 
 // src/prompts/index.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync2, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync2, readdirSync as readdirSync4 } from "fs";
 import { join as join7 } from "path";
 
 // src/ui/index.ts
@@ -248,11 +263,19 @@ var symbol = {
   folder: theme.primary("\u{1F4C1}"),
   file: theme.info("\u{1F4C4}"),
   git: theme.warning("\u{1F33F}"),
-  ai: theme.boost("\u{1F916}")
+  ai: theme.boost("\u{1F916}"),
+  info: theme.info("\u2139")
 };
 function printLogo(size = "small") {
   console.log(logo[size]);
 }
+var _lang = "en";
+function setLang(lang) {
+  _lang = lang;
+}
+function t(en, zh) {
+  return _lang === "zh" ? zh : en;
+}
 function printSummary(items) {
   const maxLabel = Math.max(...items.map((i) => i.label.length));
   const width = 50;
@@ -260,7 +283,7 @@ function printSummary(items) {
   for (const { label, value } of items) {
     const padding = " ".repeat(maxLabel - label.length);
     const line = `${theme.dim(label)}${padding} ${symbol.arrow} ${theme.highlight(value)}`;
-    const plainLine = line.replace(/\u001b\[\d+m/g, "");
+    const plainLine = line.replace(/\u001b\[\d+(?:;\d+)*m/g, "");
     const rightPad = " ".repeat(Math.max(0, width - plainLine.length - 4));
     console.log(theme.border("\u2502 ") + line + rightPad + theme.border(" \u2502"));
   }
@@ -310,8 +333,8 @@ function installRules(cwd, editor) {
   }
   const rulesDir = join7(cwd, config.rules);
   ensureDir(rulesDir);
-  const promptSrc = join7(getPackageRoot(), "prompts", "cursor-rules.md");
-  if (existsSync7(promptSrc)) {
+  const promptSrc = join7(getPackageRoot(), "prompts", "rules.md");
+  if (existsSync8(promptSrc)) {
     const content = readFileSync6(promptSrc, "utf-8");
     const rulesFile = "rulesFile" in config ? config.rulesFile : "superspec.md";
     const destPath = join7(rulesDir, rulesFile);
@@ -324,12 +347,12 @@ var SS_END = "<!-- superspec:end -->";
 function installAgentsMd(cwd) {
   const agentsMdPath = join7(cwd, "AGENTS.md");
   const agentPromptSrc = join7(getPackageRoot(), "prompts", "agents.md");
-  if (!existsSync7(agentPromptSrc)) return;
+  if (!existsSync8(agentPromptSrc)) return;
   const newContent = readFileSync6(agentPromptSrc, "utf-8");
   const wrapped = `${SS_START}
 ${newContent}
 ${SS_END}`;
-  if (existsSync7(agentsMdPath)) {
+  if (existsSync8(agentsMdPath)) {
     const existing = readFileSync6(agentsMdPath, "utf-8");
     const startIdx = existing.indexOf(SS_START);
     const endIdx = existing.indexOf(SS_END);
@@ -353,12 +376,12 @@ function installCommands(cwd, editor, lang = "zh") {
   ensureDir(commandsDir);
   const templatesDir = join7(getPackageRoot(), "templates", lang, "commands");
   const fallbackDir = join7(getPackageRoot(), "templates", "zh", "commands");
-  const sourceDir = existsSync7(templatesDir) ? templatesDir : fallbackDir;
-  if (!existsSync7(sourceDir)) {
+  const sourceDir = existsSync8(templatesDir) ? templatesDir : fallbackDir;
+  if (!existsSync8(sourceDir)) {
     log.warn(`${symbol.warn} Commands templates not found: ${sourceDir}`);
     return;
   }
-  const commandFiles = readdirSync3(sourceDir).filter((f) => f.endsWith(".md"));
+  const commandFiles = readdirSync4(sourceDir).filter((f) => f.endsWith(".md"));
   for (const file of commandFiles) {
     const srcPath = join7(sourceDir, file);
     const destPath = join7(commandsDir, file);
@@ -372,11 +395,12 @@ function installCommands(cwd, editor, lang = "zh") {
 async function initCommand(options) {
   const cwd = process.cwd();
   const configPath = join8(cwd, "superspec.config.json");
-  if (existsSync8(configPath) && !options.force) {
-    log.warn(`${symbol.warn} superspec.config.json already exists, use --force to overwrite`);
+  if (existsSync9(configPath) && !options.force) {
+    log.warn(`${symbol.warn} ${t("superspec.config.json already exists, use --force to overwrite", "superspec.config.json \u5DF2\u5B58\u5728\uFF0C\u4F7F\u7528 --force \u8986\u76D6")}`);
     return;
   }
   const lang = options.lang || "zh";
+  setLang(lang);
   printLogo("small");
   console.log(theme.dim("  Spec-Driven Development Toolkit\n"));
   const config = getDefaultConfig();
@@ -386,27 +410,30 @@ async function initCommand(options) {
     config.aiEditor = aiEditor;
   }
   const specDir = join8(cwd, config.specDir);
-  const existingFiles = readdirSync4(cwd).filter((f) => !f.startsWith(".") && f !== "node_modules");
+  const existingFiles = readdirSync5(cwd).filter((f) => !f.startsWith(".") && f !== "node_modules");
   if (existingFiles.length > 0 && !options.force) {
-    log.warn(`${symbol.warn} Current directory is not empty (${existingFiles.length} items)`);
-    log.dim("  Template files will be merged with existing content");
+    log.warn(`${symbol.warn} ${t(`current directory is not empty (${existingFiles.length} items)`, `\u5F53\u524D\u76EE\u5F55\u975E\u7A7A\uFF08${existingFiles.length} \u9879\uFF09`)}`);
+    log.dim(`  ${t("template files will be merged with existing content", "\u6A21\u677F\u6587\u4EF6\u5C06\u4E0E\u73B0\u6709\u5185\u5BB9\u5408\u5E76")}`);
     console.log();
   }
-  log.section("Creating Configuration");
+  log.section(t("Creating Configuration", "\u521B\u5EFA\u914D\u7F6E"));
   writeFileSync3(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   log.success(`${symbol.file} superspec.config.json`);
-  log.section("Creating Directory Structure");
+  log.section(t("Creating Directory Structure", "\u521B\u5EFA\u76EE\u5F55\u7ED3\u6784"));
   ensureDir(join8(specDir, "changes"));
   ensureDir(join8(specDir, "templates"));
   log.success(`${symbol.folder} ${config.specDir}/changes/`);
   log.success(`${symbol.folder} ${config.specDir}/templates/`);
-  log.section("Installing Templates");
-  const templates = ["spec.md", "proposal.md", "tasks.md", "clarify.md", "checklist.md"];
-  for (const tpl of templates) {
-    copyTemplate(tpl, join8(specDir, "templates", tpl), lang);
+  log.section(t("Installing Templates", "\u5B89\u88C5\u6A21\u677F"));
+  const templateNames = Object.values(config.templates).map((v) => v.endsWith(".md") ? v : `${v}.md`);
+  for (const tpl of templateNames) {
+    try {
+      copyTemplate(tpl, join8(specDir, "templates", tpl), lang);
+    } catch {
+    }
   }
-  log.success(`${symbol.ok} ${templates.length} templates (${lang})`);
-  log.section("Installing AI Agent Files");
+  log.success(`${symbol.ok} ${templateNames.length} ${t("templates", "\u4E2A\u6A21\u677F")} (${lang})`);
+  log.section(t("Installing AI Agent Files", "\u5B89\u88C5 AI Agent \u6587\u4EF6"));
   installAgentsMd(cwd);
   if (aiEditor && AI_EDITORS[aiEditor]) {
     installRules(cwd, aiEditor);
@@ -423,44 +450,73 @@ async function initCommand(options) {
     { label: "AI agent", value: options.ai },
     { label: "Language", value: lang }
   ]);
-  log.done("SuperSpec initialized successfully!");
-  log.dim("Next: Run superspec create <name> to create a change");
+  log.done(t("SuperSpec initialized successfully!", "SuperSpec \u521D\u59CB\u5316\u6210\u529F\uFF01"));
+  log.dim(`${t("Next", "\u4E0B\u4E00\u6B65")}: superspec create <feature>`);
 }
 
 // src/commands/create.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { join as join9 } from "path";
-async function createCommand(name, options) {
+
+// src/utils/template.ts
+function renderNameTemplate(template, vars, strict = false) {
+  let result = template;
+  for (const [key, value] of Object.entries(vars)) {
+    if (value !== void 0) {
+      result = result.replace(new RegExp(`\\{${key}\\}`, "g"), value);
+    }
+  }
+  result = result.replace(/\{[^}]+\}/g, "");
+  if (strict) {
+    return result.replace(/[^a-zA-Z0-9._\-/]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  }
+  return result.replace(/[^\p{L}\p{N}._\-/]/gu, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+
+// src/commands/create.ts
+async function createCommand(feature, options) {
   const cwd = process.cwd();
   const config = loadConfig(cwd);
   const specDir = options.specDir || config.specDir;
   const branchPrefix = options.branchPrefix || config.branchPrefix;
   const boost = options.boost || config.boost;
   const strategy = options.creative ? "create" : config.strategy;
-  const lang = config.lang || "zh";
   const description = options.description || "";
-  const changePath = join9(cwd, specDir, "changes", name);
-  if (existsSync9(changePath)) {
-    log.warn(`${symbol.warn} Change "${name}" already exists: ${changePath}`);
+  const lang = options.lang || config.lang || "en";
+  const templateVars = {
+    prefix: branchPrefix,
+    intentType: options.intentType,
+    feature,
+    date: getDateString(),
+    user: options.user
+  };
+  const changeNameTemplate = options.changeNameTemplate || config.changeNameTemplate || "{date}-{feature}";
+  const changeFolderName = renderNameTemplate(changeNameTemplate, templateVars, false);
+  const changePath = join9(cwd, specDir, "changes", changeFolderName);
+  if (existsSync10(changePath)) {
+    log.warn(`${symbol.warn} ${t(`change "${changeFolderName}" already exists`, `\u53D8\u66F4 "${changeFolderName}" \u5DF2\u5B58\u5728`)}: ${changePath}`);
     return;
   }
-  log.title(`Creating Change: ${name}`);
+  log.title(`${t("Creating Change", "\u521B\u5EFA\u53D8\u66F4")}: ${changeFolderName}`);
+  if (options.intentType) {
+    log.info(`${t("Intent Type", "\u610F\u56FE\u7C7B\u578B")}: ${options.intentType}`);
+  }
   if (boost) {
-    log.boost(`${symbol.bolt} Boost mode enabled`);
+    log.boost(`${symbol.bolt} ${t("Boost mode enabled", "\u589E\u5F3A\u6A21\u5F0F\u5DF2\u542F\u7528")}`);
   }
   if (strategy === "create") {
-    log.boost(`${symbol.bolt} Creative mode: exploring new solutions`);
+    log.boost(`${symbol.bolt} ${t("Creative mode: exploring new solutions", "\u521B\u9020\u6A21\u5F0F\uFF1A\u63A2\u7D22\u65B0\u65B9\u6848")}`);
   }
   ensureDir(changePath);
   const vars = {
-    name,
-    date: getDateString(),
+    name: changeFolderName,
+    date: templateVars.date,
     boost: boost ? "true" : "false",
     strategy,
     description
   };
   const artifacts = boost ? config.boostArtifacts : config.artifacts;
-  log.section("Generating Artifacts");
+  log.section(t("Generating Artifacts", "\u751F\u6210 Artifacts"));
   for (const artifact of artifacts) {
     const templateFile = config.templates[artifact] || `${artifact}.md`;
     const destPath = join9(changePath, `${artifact}.md`);
@@ -472,69 +528,70 @@ async function createCommand(name, options) {
     }
   }
   if (options.branch !== false && isGitRepo()) {
-    const branchTemplate = config.branchTemplate || "{prefix}{name}";
-    const branchName = branchTemplate.replace("{prefix}", branchPrefix).replace("{name}", name);
+    const branchTemplate = options.branchTemplate || config.branchTemplate || "{prefix}{date}-{feature}";
+    const branchName = renderNameTemplate(branchTemplate, templateVars, true);
     try {
       createBranch(branchName);
       log.success(`${symbol.ok} Branch: ${branchName}`);
     } catch (e) {
-      log.warn(`${symbol.warn} Branch creation failed: ${e.message}`);
+      log.warn(`${symbol.warn} ${t("branch creation failed", "\u5206\u652F\u521B\u5EFA\u5931\u8D25")}: ${e.message}`);
     }
   }
-  log.done("Change created successfully!");
-  log.dim(`Path: ${specDir}/changes/${name}/`);
+  log.done(t("Change created successfully!", "\u53D8\u66F4\u521B\u5EFA\u6210\u529F\uFF01"));
+  log.dim(`${t("Path", "\u8DEF\u5F84")}: ${specDir}/changes/${changeFolderName}/`);
   if (boost) {
-    log.dim(`Workflow: /ss-create \u2192 /ss-tasks \u2192 /ss-apply (boost)`);
+    log.dim(`${t("Workflow", "\u5DE5\u4F5C\u6D41")}: /ss-create \u2192 /ss-tasks \u2192 /ss-apply (boost)`);
   } else {
-    log.dim(`Workflow: /ss-tasks \u2192 /ss-apply`);
+    log.dim(`${t("Workflow", "\u5DE5\u4F5C\u6D41")}: /ss-tasks \u2192 /ss-apply`);
   }
+  log.dim(`${t("Next", "\u4E0B\u4E00\u6B65")}: superspec lint ${changeFolderName}`);
 }
 
 // src/commands/archive.ts
-import { existsSync as existsSync10, readdirSync as readdirSync5, renameSync } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync6, renameSync } from "fs";
 import { join as join10 } from "path";
 async function archiveCommand(name, options) {
   const cwd = process.cwd();
   const config = loadConfig(cwd);
   const changesDir = join10(cwd, config.specDir, "changes");
   const archiveDir = join10(cwd, config.specDir, "changes", config.archive.dir);
-  if (!existsSync10(changesDir)) {
-    log.warn(`${symbol.warn} \u6CA1\u6709\u627E\u5230 changes \u76EE\u5F55`);
+  if (!existsSync11(changesDir)) {
+    log.warn(`${symbol.warn} ${t("no changes directory found", "\u672A\u627E\u5230 changes \u76EE\u5F55")}`);
     return;
   }
   if (options.all) {
-    const entries = readdirSync5(changesDir, { withFileTypes: true }).filter(
+    const entries = readdirSync6(changesDir, { withFileTypes: true }).filter(
       (e) => e.isDirectory() && e.name !== config.archive.dir
     );
     if (entries.length === 0) {
-      log.warn(`${symbol.warn} \u6CA1\u6709\u53EF\u5F52\u6863\u7684\u53D8\u66F4`);
+      log.warn(`${symbol.warn} ${t("no changes to archive", "\u6CA1\u6709\u53EF\u5F52\u6863\u7684\u53D8\u66F4")}`);
       return;
     }
-    log.info(`${symbol.start} \u5F52\u6863\u6240\u6709\u53D8\u66F4...`);
+    log.info(`${symbol.start} ${t("archiving all changes...", "\u5F52\u6863\u6240\u6709\u53D8\u66F4...")}`);
     for (const entry of entries) {
       archiveOne(entry.name, changesDir, archiveDir, config);
     }
   } else if (name) {
     const changePath = join10(changesDir, name);
-    if (!existsSync10(changePath)) {
-      log.warn(`${symbol.warn} \u53D8\u66F4 "${name}" \u4E0D\u5B58\u5728`);
+    if (!existsSync11(changePath)) {
+      log.warn(`${symbol.warn} ${t(`change "${name}" not found`, `\u53D8\u66F4 "${name}" \u4E0D\u5B58\u5728`)}`);
       return;
     }
-    log.info(`${symbol.start} \u5F52\u6863\u53D8\u66F4: ${name}`);
+    log.info(`${symbol.start} ${t(`archiving: ${name}`, `\u5F52\u6863\u53D8\u66F4: ${name}`)}`);
     archiveOne(name, changesDir, archiveDir, config);
   } else {
-    log.warn(`${symbol.warn} \u8BF7\u6307\u5B9A\u53D8\u66F4\u540D\u79F0\u6216\u4F7F\u7528 --all`);
+    log.warn(`${symbol.warn} ${t("specify a name or use --all", "\u8BF7\u6307\u5B9A\u53D8\u66F4\u540D\u79F0\u6216\u4F7F\u7528 --all")}`);
     return;
   }
-  log.info(`${symbol.start} \u5F52\u6863\u5B8C\u6210\uFF01`);
+  log.info(`${symbol.start} ${t("archive done!", "\u5F52\u6863\u5B8C\u6210\uFF01")}`);
 }
 function archiveOne(name, changesDir, archiveDir, config) {
   ensureDir(archiveDir);
   const src = join10(changesDir, name);
   const dateStr = config.archive.datePrefix ? `${getDateString()}-` : "";
   const dest = join10(archiveDir, `${dateStr}${name}`);
-  if (existsSync10(dest)) {
-    log.warn(`  ${symbol.warn} \u5F52\u6863\u76EE\u6807\u5DF2\u5B58\u5728: ${dest}`);
+  if (existsSync11(dest)) {
+    log.warn(`  ${symbol.warn} ${t("archive target exists", "\u5F52\u6863\u76EE\u6807\u5DF2\u5B58\u5728")}: ${dest}`);
     return;
   }
   renameSync(src, dest);
@@ -542,60 +599,59 @@ function archiveOne(name, changesDir, archiveDir, config) {
 }
 
 // src/commands/update.ts
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { join as join11 } from "path";
 async function updateCommand() {
   const cwd = process.cwd();
   const config = loadConfig(cwd);
   const specDir = join11(cwd, config.specDir);
   const lang = config.lang || "zh";
-  if (!existsSync11(join11(cwd, "superspec.config.json"))) {
-    log.warn(`${symbol.warn} \u5F53\u524D\u76EE\u5F55\u672A\u521D\u59CB\u5316 SuperSpec\uFF0C\u8BF7\u5148\u8FD0\u884C superspec init`);
+  if (!existsSync12(join11(cwd, "superspec.config.json"))) {
+    log.warn(`${symbol.warn} ${t("not initialized, run superspec init first", "\u5F53\u524D\u76EE\u5F55\u672A\u521D\u59CB\u5316 SuperSpec\uFF0C\u8BF7\u5148\u8FD0\u884C superspec init")}`);
     return;
   }
-  log.info(`${symbol.start} \u66F4\u65B0 SuperSpec...`);
-  const templates = ["spec.md", "proposal.md", "tasks.md", "clarify.md", "checklist.md"];
+  log.info(`${symbol.start} ${t("updating SuperSpec...", "\u66F4\u65B0 SuperSpec...")}`);
+  const templateNames = Object.values(config.templates).map((v) => v.endsWith(".md") ? v : `${v}.md`);
   ensureDir(join11(specDir, "templates"));
-  for (const tpl of templates) {
-    copyTemplate(tpl, join11(specDir, "templates", tpl), lang);
+  for (const tpl of templateNames) {
+    try {
+      copyTemplate(tpl, join11(specDir, "templates", tpl), lang);
+    } catch {
+    }
   }
-  log.success(`  ${symbol.ok} \u6A21\u677F\u66F4\u65B0 (${lang})`);
+  log.success(`  ${symbol.ok} ${t("templates updated", "\u6A21\u677F\u66F4\u65B0")} (${lang})`);
   installAgentsMd(cwd);
   const aiEditor = config.aiEditor;
   if (aiEditor && AI_EDITORS[aiEditor]) {
     installRules(cwd, aiEditor);
     installCommands(cwd, aiEditor, lang);
   }
-  log.info(`${symbol.start} \u66F4\u65B0\u5B8C\u6210\uFF01`);
+  log.info(`${symbol.start} ${t("update done!", "\u66F4\u65B0\u5B8C\u6210\uFF01")}`);
 }
 
 // src/commands/lint.ts
-import { existsSync as existsSync12, readdirSync as readdirSync6 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { join as join12 } from "path";
 
 // src/commands/validate.ts
-import { existsSync as existsSync13, readdirSync as readdirSync7 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { join as join13 } from "path";
 
 // src/commands/search.ts
-import { existsSync as existsSync14, readFileSync as readFileSync7, readdirSync as readdirSync8 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync7, readdirSync as readdirSync7 } from "fs";
 import { join as join14, basename as basename3 } from "path";
 
-// src/commands/link.ts
-import { existsSync as existsSync15, readFileSync as readFileSync8, writeFileSync as writeFileSync4, readdirSync as readdirSync9 } from "fs";
+// src/commands/deps.ts
+import { existsSync as existsSync16, readFileSync as readFileSync8, writeFileSync as writeFileSync4, readdirSync as readdirSync8 } from "fs";
 import { join as join15 } from "path";
 
 // src/commands/status.ts
-import { existsSync as existsSync16, readFileSync as readFileSync9, readdirSync as readdirSync10 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync9, readdirSync as readdirSync9 } from "fs";
 import { join as join16 } from "path";
 
-// src/commands/context.ts
-import { existsSync as existsSync17, writeFileSync as writeFileSync5, readdirSync as readdirSync11 } from "fs";
-import { join as join17 } from "path";
-
 // src/commands/sync.ts
-import { existsSync as existsSync18, writeFileSync as writeFileSync6, readdirSync as readdirSync12 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync18, writeFileSync as writeFileSync5 } from "fs";
+import { join as join17 } from "path";
 export {
   archiveCommand,
   createCommand,