@fenglimg/fabric-cli 0.1.4 → 1.0.0

package/dist/{bootstrap-HUDJ2E3Q.js → bootstrap-PMIA4W6G.js}

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
 import {
   resolveClients
-} from "./chunk-N7TTCGJA.js";
+} from "./chunk-VMYPJPKV.js";
 import {
   readFabricConfig
 } from "./chunk-AEOYCVBG.js";
+import {
+  t
+} from "./chunk-6ICJICVU.js";
 
 // src/commands/bootstrap.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -50,18 +53,18 @@ var CLIENT_TARGET_MAP = {
 var bootstrapCommand = defineCommand({
   meta: {
     name: "bootstrap",
-    description: "\u4E3A\u652F\u6301\u7684 AI \u5BA2\u6237\u7AEF\u5B89\u88C5 Fabric \u5F15\u5BFC\u63D0\u793A\u6A21\u677F\u3002"
+    description: t("cli.bootstrap.description")
   },
   subCommands: {
     install: defineCommand({
       meta: {
         name: "install",
-        description: "\u5C06 Fabric \u5F15\u5BFC\u6A21\u677F\u590D\u5236\u5230\u5404\u5BA2\u6237\u7AEF\u7684\u539F\u751F\u4F4D\u7F6E\u3002"
+        description: t("cli.bootstrap.install.description")
       },
       args: {
         clients: {
           type: "string",
-          description: "\u53EF\u9009\u7684\u9017\u53F7\u5206\u9694\u5BA2\u6237\u7AEF\u8FC7\u6EE4\u5668\uFF0C\u4F8B\u5982 claude,cursor,codex\u3002"
+          description: t("cli.bootstrap.install.args.clients.description")
         }
       },
       async run({ args }) {
@@ -72,7 +75,8 @@ var bootstrapCommand = defineCommand({
         const clients = selectedClients ?? detectedClients;
         if (clients.size === 0) {
           process.stderr.write(
-            "No bootstrap targets detected. Pass --clients claude,cursor,windsurf,roo,gemini,codex to install explicitly.\n"
+            `${t("cli.bootstrap.install.no-targets")}
+`
           );
           return;
         }
@@ -93,7 +97,7 @@ function parseClientFilter(value) {
     const alias = rawClient.trim().toLowerCase();
     const client = CLIENT_ALIASES[alias];
     if (client === void 0) {
-      throw new Error(`Unknown client "${rawClient}". Use a comma-separated list such as claude,cursor,codex.`);
+      throw new Error(t("cli.bootstrap.errors.unknown-client", { client: rawClient }));
     }
     clients.add(client);
   }
@@ -138,26 +142,26 @@ function installBootstrap(client, workspaceRoot) {
     return;
   }
   writeFileSync(targetPath, ensureTrailingNewline(template), "utf8");
-  process.stderr.write(`Installed ${targetPath}
+  process.stderr.write(`${t("cli.bootstrap.install.installed", { path: targetPath })}
 `);
 }
 function writeCodexBootstrap(targetPath, template) {
   const nextContent = ensureTrailingNewline(template);
   if (!existsSync(targetPath)) {
     writeFileSync(targetPath, nextContent, "utf8");
-    process.stderr.write(`Installed ${targetPath}
+    process.stderr.write(`${t("cli.bootstrap.install.installed", { path: targetPath })}
 `);
     return;
   }
   const existing = readFileSync(targetPath, "utf8");
   if (existing.includes("# Fabric Bootstrap")) {
-    process.stderr.write(`Skipped ${targetPath}: Fabric Bootstrap header already present.
+    process.stderr.write(`${t("cli.bootstrap.install.skipped-header", { path: targetPath })}
 `);
     return;
   }
   const separator = existing.startsWith("\n") || existing.length === 0 ? "" : "\n";
   writeFileSync(targetPath, `${nextContent}${separator}${existing}`, "utf8");
-  process.stderr.write(`Prepended ${targetPath}
+  process.stderr.write(`${t("cli.bootstrap.install.prepended", { path: targetPath })}
 `);
 }
 function ensureTrailingNewline(content) {
@@ -175,7 +179,7 @@ function findTemplatePath(relativePath) {
       return candidate;
     }
   }
-  throw new Error(`Template not found: ${relativePath}`);
+  throw new Error(t("cli.shared.template-not-found", { path: relativePath }));
 }
 function templateCandidatesFrom(start, relativePath) {
   const candidates = [];
@@ -188,7 +192,7 @@ function templateCandidatesFrom(start, relativePath) {
     }
     current = parent;
   }
-  return candidates;
+  return candidates.reverse();
 }
 export {
   bootstrapCommand,

package/dist/{chunk-T3WQUWW4.js → chunk-5BSTO745.js}

@@ -2,6 +2,9 @@
 import {
   resolveIgnores
 } from "./chunk-P4KVFB2T.js";
+import {
+  t
+} from "./chunk-6ICJICVU.js";
 
 // src/commands/sync-meta.ts
 import { createHash } from "crypto";
@@ -11,17 +14,17 @@ import { defineCommand } from "citty";
 var syncMetaCommand = defineCommand({
   meta: {
     name: "sync-meta",
-    description: "\u4ECE AGENTS.md \u6587\u4EF6\u540C\u6B65 Fabric \u5143\u6570\u636E\u3002"
+    description: t("cli.sync-meta.description")
   },
   args: {
     target: {
       type: "string",
-      description: "\u76EE\u6807\u9879\u76EE\u8DEF\u5F84\uFF0C\u9ED8\u8BA4\u4E3A\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u3002",
+      description: t("cli.sync-meta.args.target.description"),
       default: process.cwd()
     },
     "check-only": {
       type: "boolean",
-      description: "\u5982\u679C .fabric/agents.meta.json \u5DF2\u8FC7\u671F\u5219\u4EE5\u4EE3\u7801 1 \u9000\u51FA\u3002",
+      description: t("cli.sync-meta.args.check-only.description"),
       default: false
     }
   },
@@ -32,7 +35,7 @@ var syncMetaCommand = defineCommand({
     const existingMeta = readExistingMeta(metaPath);
     if (args["check-only"]) {
       if (!existingMeta || stableStringify(existingMeta) !== stableStringify(computedMeta)) {
-        writeStderr("Fabric metadata drift detected. Run fab sync-meta to update.");
+        writeStderr(t("cli.sync-meta.drift-detected"));
         process.exitCode = 1;
       }
       return;
@@ -43,7 +46,7 @@ var syncMetaCommand = defineCommand({
     mkdirSync(join(target, ".fabric"), { recursive: true });
     writeFileSync(metaPath, `${JSON.stringify(computedMeta, null, 2)}
 `, "utf8");
-    writeStderr(`Updated ${metaPath}`);
+    writeStderr(t("cli.sync-meta.updated", { label: t("cli.shared.updated"), path: metaPath }));
   }
 });
 var sync_meta_default = syncMetaCommand;
@@ -77,7 +80,7 @@ function normalizeTarget(targetInput) {
 }
 function assertExistingDirectory(target) {
   if (!existsSync(target) || !statSync(target).isDirectory()) {
-    throw new Error(`Target must be an existing directory: ${target}`);
+    throw new Error(t("cli.shared.target-invalid", { target }));
   }
 }
 function readExistingMeta(metaPath) {

package/dist/chunk-6ICJICVU.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+// src/i18n.ts
+import { createTranslator, detectNodeLocale } from "@fenglimg/fabric-shared";
+var locale = detectNodeLocale();
+var t = createTranslator(locale);
+
+export {
+  t
+};

package/dist/chunk-DKQ3HOTK.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+import {
+  createDebugLogger,
+  readFabricConfig,
+  resolveDevMode
+} from "./chunk-AEOYCVBG.js";
+import {
+  resolveIgnores
+} from "./chunk-P4KVFB2T.js";
+import {
+  displayWidth,
+  padEnd,
+  paint,
+  symbol
+} from "./chunk-WWNXR34K.js";
+import {
+  t
+} from "./chunk-6ICJICVU.js";
+
+// src/commands/scan.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { isAbsolute, join, relative, resolve, sep } from "path";
+import { defineCommand } from "citty";
+
+// src/scanner/detector.ts
+import { detectFramework } from "@fenglimg/fabric-shared";
+
+// src/commands/scan.ts
+function createScanReport(targetInput = process.cwd(), fabricConfig) {
+  const target = normalizeTarget(targetInput);
+  const framework = detectFramework(target);
+  const readmeQuality = getReadmeQuality(target);
+  const hasContributing = existsSync(join(target, "CONTRIBUTING.md"));
+  const hasExistingFabric = existsSync(join(target, "AGENTS.md")) || existsSync(join(target, ".fabric"));
+  const walkResult = walkFiles(target, resolveIgnores(fabricConfig));
+  return {
+    target,
+    framework,
+    readmeQuality,
+    hasContributing,
+    fileCount: walkResult.fileCount,
+    ignoredCount: walkResult.ignoredCount,
+    hasExistingFabric,
+    recommendations: buildRecommendations({
+      framework,
+      readmeQuality,
+      hasContributing,
+      hasExistingFabric
+    })
+  };
+}
+var scanCommand = defineCommand({
+  meta: {
+    name: "scan",
+    description: t("cli.scan.description")
+  },
+  args: {
+    target: {
+      type: "string",
+      description: t("cli.scan.args.target.description")
+    },
+    debug: {
+      type: "boolean",
+      description: t("cli.scan.args.debug.description"),
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: t("cli.scan.args.json.description"),
+      default: false
+    }
+  },
+  async run({ args }) {
+    const workspaceRoot = process.cwd();
+    const logger = createDebugLogger(args.debug);
+    const resolution = resolveDevMode(args.target, workspaceRoot);
+    const fabricConfig = readFabricConfig(workspaceRoot);
+    logger(`scan target source: ${resolution.source}`);
+    for (const step of resolution.chain) {
+      logger(step);
+    }
+    const report = createScanReport(resolution.target, fabricConfig);
+    if (args.json) {
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+    printPrettyReport(report, Boolean(args.debug));
+  }
+});
+var scan_default = scanCommand;
+function normalizeTarget(targetInput) {
+  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
+}
+function getReadmeQuality(target) {
+  const readmePath = join(target, "README.md");
+  if (!existsSync(readmePath)) {
+    return "stub";
+  }
+  const wordCount = readFileSync(readmePath, "utf8").trim().split(/\s+/).filter(Boolean).length;
+  return wordCount >= 200 ? "ok" : "stub";
+}
+function walkFiles(root, ignorePatterns) {
+  if (!existsSync(root) || !statSync(root).isDirectory()) {
+    throw new Error(t("cli.shared.target-invalid", { target: root }));
+  }
+  let fileCount = 0;
+  let ignoredCount = 0;
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === void 0) {
+      continue;
+    }
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const absolutePath = join(current, entry.name);
+      const relativePath = toPosixPath(relative(root, absolutePath));
+      if (shouldIgnore(relativePath, entry.isDirectory(), ignorePatterns)) {
+        ignoredCount += 1;
+        continue;
+      }
+      if (entry.isDirectory()) {
+        stack.push(absolutePath);
+      } else if (entry.isFile()) {
+        fileCount += 1;
+      }
+    }
+  }
+  return { fileCount, ignoredCount };
+}
+function shouldIgnore(relativePath, isDirectory, ignorePatterns) {
+  return ignorePatterns.some((pattern) => matchesIgnorePattern(relativePath, isDirectory, pattern));
+}
+function matchesIgnorePattern(relativePath, isDirectory, pattern) {
+  const normalizedPattern = toPosixPath(pattern);
+  if (normalizedPattern === "**/*.meta") {
+    return relativePath.endsWith(".meta");
+  }
+  if (normalizedPattern.endsWith("/**")) {
+    const directoryPrefix = normalizedPattern.slice(0, -3);
+    return relativePath === directoryPrefix || relativePath.startsWith(`${directoryPrefix}/`) || isDirectory && `${relativePath}/` === directoryPrefix;
+  }
+  return relativePath === normalizedPattern;
+}
+function toPosixPath(path) {
+  return path.split(sep).join("/");
+}
+function buildRecommendations(input) {
+  const recommendations = [];
+  if (!input.hasExistingFabric) {
+    recommendations.push(t("cli.scan.recommendation.init"));
+  }
+  if (input.readmeQuality === "stub") {
+    recommendations.push(t("cli.scan.recommendation.readme"));
+  }
+  if (!input.hasContributing) {
+    recommendations.push(t("cli.scan.recommendation.contributing"));
+  }
+  if (input.framework.kind === "unknown") {
+    recommendations.push(t("cli.scan.recommendation.unknown-framework"));
+  } else {
+    recommendations.push(t("cli.scan.recommendation.framework-dirs", { framework: input.framework.kind }));
+  }
+  return recommendations;
+}
+function printPrettyReport(report, debug) {
+  console.log(paint.ai(t("cli.scan.report.title")));
+  const rows = [
+    [t("cli.scan.report.target"), paint.human(report.target)],
+    [t("cli.scan.report.framework"), paint.ai(report.framework.kind)],
+    [
+      t("cli.scan.report.readme-quality"),
+      report.readmeQuality === "ok" ? paint.success(t("cli.scan.readme-quality.ok")) : paint.warn(t("cli.scan.readme-quality.stub"))
+    ],
+    [
+      t("cli.scan.report.contributing"),
+      report.hasContributing ? paint.success(t("cli.shared.present")) : paint.warn(t("cli.shared.absent"))
+    ],
+    [t("cli.scan.report.files-counted"), String(report.fileCount)],
+    [t("cli.scan.report.ignored-entries"), report.ignoredCount > 0 ? paint.muted(String(report.ignoredCount)) : "0"],
+    [
+      t("cli.scan.report.existing-fabric"),
+      report.hasExistingFabric ? paint.warn(t("cli.shared.yes")) : paint.success(t("cli.shared.no"))
+    ]
+  ];
+  if (debug) {
+    rows.splice(2, 0, [
+      t("cli.scan.report.evidence"),
+      report.framework.evidence.length > 0 ? paint.muted(report.framework.evidence.join(", ")) : paint.muted(t("cli.shared.none"))
+    ]);
+  }
+  const labelWidth = Math.max(...rows.map(([key]) => displayWidth(key)));
+  for (const [key, value] of rows) {
+    console.log(`${paint.muted(padEnd(key, labelWidth))} ${value}`);
+  }
+  console.log(paint.muted(t("cli.scan.report.recommendations")));
+  for (const recommendation of report.recommendations) {
+    console.log(`${symbol.warn} ${paint.drift(recommendation)}`);
+  }
+}
+
+export {
+  detectFramework,
+  createScanReport,
+  scanCommand,
+  scan_default
+};

package/dist/{chunk-U376IPKT.js → chunk-F2BXHPM5.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  t
+} from "./chunk-6ICJICVU.js";
 
 // src/commands/ledger-append.ts
 import { execSync } from "child_process";
@@ -10,17 +13,17 @@ var INITIAL_PARENT_SHA = "root";
 var ledgerAppendCommand = defineCommand({
   meta: {
     name: "ledger-append",
-    description: "\u5411 Fabric \u610F\u56FE\u65E5\u5FD7\u6DFB\u52A0\u4E00\u6761\u8BB0\u5F55\u3002"
+    description: t("cli.ledger-append.description")
   },
   args: {
     target: {
       type: "string",
-      description: "\u76EE\u6807\u9879\u76EE\u8DEF\u5F84\uFF0C\u9ED8\u8BA4\u4E3A\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u3002",
+      description: t("cli.ledger-append.args.target.description"),
       default: process.cwd()
     },
     staged: {
       type: "boolean",
-      description: "\u4ECE\u6682\u5B58\u53D8\u66F4\u4E2D\u63A8\u5BFC\u8BB0\u5F55\uFF08\u7528\u4E8E pre-commit \u9636\u6BB5\uFF09\u3002",
+      description: t("cli.ledger-append.args.staged.description"),
       default: false
     }
   },
@@ -28,7 +31,7 @@ var ledgerAppendCommand = defineCommand({
     const target = normalizeTarget(args.target);
     assertExistingDirectory(target);
     if (!args.staged) {
-      writeStderr("requires --staged in pre-commit context");
+      writeStderr(t("cli.ledger-append.requires-staged"));
       process.exitCode = 1;
       return;
     }
@@ -40,6 +43,7 @@ var ledgerAppendCommand = defineCommand({
     const diffStat = readDiffStat(target).trim();
     const entry = {
       ts: Date.now(),
+      source: "human",
       parent_sha: readParentSha(target),
       intent,
       affected_paths: stagedFiles,
@@ -59,7 +63,7 @@ function normalizeTarget(targetInput) {
 }
 function assertExistingDirectory(target) {
   if (!existsSync(target) || !statSync(target).isDirectory()) {
-    throw new Error(`Target must be an existing directory: ${target}`);
+    throw new Error(t("cli.shared.target-invalid", { target }));
   }
 }
 function getStagedFiles(target) {
@@ -83,8 +87,8 @@ function deriveIntent(stagedFiles) {
   }
   const uniqueNames = Array.from(new Set(stagedFiles.map((file) => basename(file))));
   const head = uniqueNames.slice(0, 2).join(", ");
-  const suffix = uniqueNames.length > 2 ? ` +${uniqueNames.length - 2} more` : "";
-  return `auto: ${head}${suffix}`;
+  const suffix = uniqueNames.length > 2 ? t("cli.ledger-append.intent.auto-more", { count: String(uniqueNames.length - 2) }) : "";
+  return t("cli.ledger-append.intent.auto", { head, suffix });
 }
 function hasMatchingTailEntry(target, entry) {
   const ledgerPath = join(target, LEDGER_FILE);

package/dist/{chunk-CZ7U6ULM.js → chunk-L43IGJ6X.js}

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+import {
+  padEnd
+} from "./chunk-WWNXR34K.js";
+import {
+  t
+} from "./chunk-6ICJICVU.js";
 
 // src/commands/human-lint.ts
 import { createHash } from "crypto";
@@ -6,15 +12,16 @@ import { existsSync } from "fs";
 import { readFile } from "fs/promises";
 import { isAbsolute, join, resolve } from "path";
 import { defineCommand } from "citty";
+import { humanLockEntrySchema } from "@fenglimg/fabric-shared";
 var humanLintCommand = defineCommand({
   meta: {
     name: "human-lint",
-    description: "\u9A8C\u8BC1\u9501\u5B9A\u7684\u4EBA\u5DE5\u7F16\u8F91\u533A\u5757\u3002"
+    description: t("cli.human-lint.description")
   },
   args: {
     target: {
       type: "string",
-      description: "\u76EE\u6807\u9879\u76EE\u8DEF\u5F84\uFF0C\u9ED8\u8BA4\u4E3A\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u3002",
+      description: t("cli.human-lint.args.target.description"),
       default: process.cwd()
     }
   },
@@ -60,11 +67,13 @@ var humanLintCommand = defineCommand({
     if (violations.length === 0) {
       return;
     }
-    writeStderr("Human-locked content drift detected. Revert the edit or update approved hashes before committing.");
-    writeStderr("Location                         Expected            Got");
+    writeStderr(t("cli.human-lint.drift-detected"));
+    writeStderr(
+      `${padEnd(t("cli.human-lint.table.location"), 32)} ${padEnd(t("cli.human-lint.table.expected"), 18)} ${t("cli.human-lint.table.got")}`
+    );
     for (const violation of violations) {
       writeStderr(
-        `${violation.location.padEnd(32)} ${violation.expected.padEnd(18)} ${violation.actual}`
+        `${padEnd(violation.location, 32)} ${padEnd(violation.expected, 18)} ${violation.actual}`
       );
     }
     process.exitCode = 1;
@@ -81,7 +90,7 @@ function hashLockedContent(content, entry) {
 }
 function shortenHash(value) {
   if (value === "missing") {
-    return value;
+    return t("cli.shared.missing");
   }
   return value.slice(0, 15);
 }
@@ -92,5 +101,6 @@ function writeStderr(message) {
 
 export {
   humanLintCommand,
-  human_lint_default
+  human_lint_default,
+  humanLockEntrySchema
 };

package/dist/{chunk-N7TTCGJA.js → chunk-VMYPJPKV.js}

@@ -240,6 +240,7 @@ var CodexTOMLConfigWriter = class {
 };
 
 // src/config/resolver.ts
+import { clientPathsSchema, fabricConfigSchema } from "@fenglimg/fabric-shared";
 function hasExplicitPath(clientPaths, key) {
   return typeof clientPaths?.[key] === "string" && clientPaths[key].trim().length > 0;
 }

package/dist/chunk-WWNXR34K.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+// src/colors.ts
+import pc from "picocolors";
+import stringWidth from "string-width";
+function isColorEnabled() {
+  return !process.env.NO_COLOR && Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY);
+}
+function colorize(painter) {
+  return (value) => isColorEnabled() ? painter(value) : value;
+}
+var paint = {
+  success: colorize(pc.green),
+  warn: colorize(pc.yellow),
+  error: colorize(pc.red),
+  drift: colorize(pc.magenta),
+  ai: colorize(pc.blue),
+  human: colorize(pc.cyan),
+  muted: colorize(pc.dim)
+};
+var symbol = {
+  get ok() {
+    return isColorEnabled() ? paint.success("\u2713") : "[ok]";
+  },
+  get warn() {
+    return isColorEnabled() ? paint.warn("!") : "[warn]";
+  },
+  get error() {
+    return isColorEnabled() ? paint.error("x") : "[error]";
+  }
+};
+function displayWidth(value) {
+  return stringWidth(value);
+}
+function padEnd(value, width, char = " ") {
+  const fill = char.length > 0 ? char : " ";
+  let result = value;
+  while (displayWidth(result) < width) {
+    result += fill;
+  }
+  return result;
+}
+
+export {
+  paint,
+  symbol,
+  displayWidth,
+  padEnd
+};

package/dist/{config-YKDWIRCT.js → config-PXEEXWLM.js}

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 import {
   resolveClients
-} from "./chunk-N7TTCGJA.js";
+} from "./chunk-VMYPJPKV.js";
+import {
+  t
+} from "./chunk-6ICJICVU.js";
 
 // src/commands/config.ts
 import { existsSync } from "fs";
@@ -37,7 +40,7 @@ function parseClientFilter(value) {
     const alias = rawClient.trim().toLowerCase();
     const clientKind = CLIENT_ALIASES[alias];
     if (clientKind === void 0) {
-      throw new Error(`Unknown client "${rawClient}". Use a comma-separated list such as cursor,codex,gemini.`);
+      throw new Error(t("cli.config.errors.unknown-client", { client: rawClient }));
     }
     clients.add(clientKind);
   }
@@ -50,7 +53,7 @@ async function loadFabricConfig(workspaceRoot) {
   }
   const parsed = JSON.parse(await readFile(configPath, "utf8"));
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`Expected object in ${configPath}`);
+    throw new Error(t("cli.config.errors.expected-object", { path: configPath }));
   }
   return parsed;
 }
@@ -65,22 +68,22 @@ function writeStderr(message) {
 var configCmd = defineCommand({
   meta: {
     name: "config",
-    description: "\u7BA1\u7406 Fabric MCP \u5BA2\u6237\u7AEF\u914D\u7F6E\u3002"
+    description: t("cli.config.description")
   },
   subCommands: {
     install: defineCommand({
       meta: {
         name: "install",
-        description: "\u5C06 Fabric MCP \u670D\u52A1\u5668\u6761\u76EE\u5B89\u88C5\u5230\u68C0\u6D4B\u5230\u7684\u5BA2\u6237\u7AEF\u914D\u7F6E\u4E2D\u3002"
+        description: t("cli.config.install.description")
       },
       args: {
         clients: {
           type: "string",
-          description: "\u53EF\u9009\u7684\u9017\u53F7\u5206\u9694\u5BA2\u6237\u7AEF\u8FC7\u6EE4\u5668\uFF0C\u4F8B\u5982 cursor,codex,gemini\u3002"
+          description: t("cli.config.install.args.clients.description")
         },
         "dry-run": {
           type: "boolean",
-          description: "\u9884\u89C8\u68C0\u6D4B\u5230\u7684\u5199\u5165\u64CD\u4F5C\uFF0C\u4E0D\u4FEE\u6539\u6587\u4EF6\u3002",
+          description: t("cli.config.install.args.dry-run.description"),
           default: false
         }
       },
@@ -93,21 +96,21 @@ var configCmd = defineCommand({
           (writer) => selectedClients === null ? true : selectedClients.has(writer.clientKind)
         );
         if (writers.length === 0) {
-          writeStderr("\u672A\u68C0\u6D4B\u5230 Fabric MCP \u5BA2\u6237\u7AEF\u914D\u7F6E\u3002\u8BF7\u521B\u5EFA\u5BA2\u6237\u7AEF\u76EE\u5F55\u6216\u5728 fabric.config.json \u4E2D\u8BBE\u7F6E clientPaths\u3002");
+          writeStderr(t("cli.config.install.no-configs"));
           return;
         }
         for (const writer of writers) {
           const configPath = await writer.detect(workspaceRoot);
           if (configPath === null) {
-            writeStderr(`Skipping ${writer.clientKind}: no config path detected.`);
+            writeStderr(t("cli.config.install.no-config-path", { client: writer.clientKind }));
             continue;
           }
           if (args["dry-run"]) {
-            writeStderr(`[dry-run] ${writer.clientKind}: would write ${configPath}`);
+            writeStderr(t("cli.config.install.dry-run", { client: writer.clientKind, path: configPath }));
             continue;
           }
           await writer.write(serverPath, workspaceRoot);
-          writeStderr(`${writer.clientKind}: wrote ${configPath}`);
+          writeStderr(t("cli.config.install.wrote", { client: writer.clientKind, path: configPath }));
         }
       }
     })