@fenglimg/fabric-cli 0.1.4 → 1.1.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-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-T3WQUWW4.js → chunk-6UUPKSDE.js}

@@ -1,27 +1,32 @@
 #!/usr/bin/env node
 import {
-  resolveIgnores
-} from "./chunk-P4KVFB2T.js";
+  t
+} from "./chunk-6ICJICVU.js";
 
 // src/commands/sync-meta.ts
 import { createHash } from "crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
 import { isAbsolute, join, relative, resolve, sep } from "path";
+import {
+  agentsMetaSchema,
+  deriveAgentsMetaLayer,
+  deriveAgentsMetaTopologyType
+} from "@fenglimg/fabric-shared";
 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 +37,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 +48,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;
@@ -52,11 +57,15 @@ function computeAgentsMeta(target) {
   const metaPath = join(target, ".fabric", "agents.meta.json");
   const existingMeta = readExistingMeta(metaPath);
   const existingByFile = indexExistingNodesByFile(existingMeta);
-  const agentsFiles = findAgentsFiles(target);
+  const agentsFiles = findFabricAgentsFiles(target);
   const nodes = {};
+  const bootstrapNode = createBootstrapNode(target, existingByFile.get("AGENTS.md")?.node);
+  if (bootstrapNode !== void 0) {
+    nodes.L0 = bootstrapNode;
+  }
   for (const file of agentsFiles) {
     const existing = existingByFile.get(file);
-    const id = existing?.id ?? deriveNodeId(file);
+    const id = deriveNodeId(file);
     const hash = sha256(readFileSync(join(target, file), "utf8"));
     const defaults = createDefaultNodeMeta(file);
     nodes[id] = {
@@ -77,7 +86,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) {
@@ -85,15 +94,18 @@ function readExistingMeta(metaPath) {
     return void 0;
   }
   try {
-    return JSON.parse(readFileSync(metaPath, "utf8"));
+    return agentsMetaSchema.parse(JSON.parse(readFileSync(metaPath, "utf8")));
   } catch {
     return void 0;
   }
 }
-function findAgentsFiles(target) {
-  const ignorePatterns = resolveIgnores();
+function findFabricAgentsFiles(target) {
+  const agentsRoot = join(target, ".fabric", "agents");
+  if (!existsSync(agentsRoot) || !statSync(agentsRoot).isDirectory()) {
+    return [];
+  }
   const files = [];
-  const stack = [target];
+  const stack = [agentsRoot];
   while (stack.length > 0) {
     const current = stack.pop();
     if (current === void 0) {
@@ -102,31 +114,20 @@ function findAgentsFiles(target) {
     for (const entry of readdirSync(current, { withFileTypes: true })) {
       const absolutePath = join(current, entry.name);
       const relativePath = toPosixPath(relative(target, absolutePath));
-      if (shouldIgnore(relativePath, entry.isDirectory(), ignorePatterns)) {
-        continue;
-      }
       if (entry.isDirectory()) {
         stack.push(absolutePath);
-      } else if (entry.isFile() && entry.name === "AGENTS.md") {
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
         files.push(relativePath);
       }
     }
   }
   return files.sort();
 }
-function shouldIgnore(relativePath, isDirectory, ignorePatterns) {
-  return ignorePatterns.some((pattern) => matchesIgnorePattern(relativePath, isDirectory, pattern));
+function deriveLayer(relativePath) {
+  return deriveAgentsMetaLayer(relativePath);
 }
-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 deriveTopologyType(relativePath) {
+  return deriveAgentsMetaTopologyType(relativePath);
 }
 function indexExistingNodesByFile(existingMeta) {
   const byFile = /* @__PURE__ */ new Map();
@@ -139,18 +140,57 @@ function deriveNodeId(file) {
   if (file === "AGENTS.md") {
     return "L0";
   }
-  return file.replace(/\/AGENTS\.md$/, "");
+  const layer = deriveLayer(file);
+  const relativeStem = getMirrorRelativeStem(file);
+  return `${layer}/${relativeStem}`;
 }
 function createDefaultNodeMeta(file) {
-  const scope = file === "AGENTS.md" ? "**" : `${file.replace(/\/AGENTS\.md$/, "")}/**`;
+  const layer = deriveLayer(file);
+  const topologyType = deriveTopologyType(file);
   return {
     file,
-    scope_glob: scope,
-    deps: file === "AGENTS.md" ? [] : ["L0"],
-    priority: file === "AGENTS.md" ? "high" : "medium",
+    scope_glob: deriveScopeGlob(file),
+    deps: layer === "L0" ? [] : ["L0"],
+    priority: layer === "L0" ? "high" : "medium",
+    layer,
+    topology_type: topologyType,
     hash: ""
   };
 }
+function createBootstrapNode(target, existing) {
+  const bootstrapPath = join(target, "AGENTS.md");
+  if (!existsSync(bootstrapPath)) {
+    return void 0;
+  }
+  const hash = sha256(readFileSync(bootstrapPath, "utf8"));
+  return {
+    ...createDefaultNodeMeta("AGENTS.md"),
+    ...existing,
+    file: "AGENTS.md",
+    hash
+  };
+}
+function deriveScopeGlob(file) {
+  if (file === "AGENTS.md") {
+    return "**";
+  }
+  const stem = getMirrorRelativeStem(file);
+  const segments = stem.split("/").filter(Boolean);
+  if (segments.length === 0 || stem === "root") {
+    return "**";
+  }
+  if (segments[0] === "_cross") {
+    return "**";
+  }
+  if (segments.at(-1) === "rules") {
+    segments.pop();
+  }
+  const scopePath = segments.join("/");
+  return scopePath === "" ? "**" : `${scopePath}/**`;
+}
+function getMirrorRelativeStem(file) {
+  return file.replace(/^\.fabric\/agents\//, "").replace(/\.md$/, "");
+}
 function sortNodes(nodes) {
   return Object.fromEntries(Object.entries(nodes).sort(([left], [right]) => left.localeCompare(right)));
 }
@@ -184,5 +224,7 @@ function sha256(content) {
 export {
   syncMetaCommand,
   sync_meta_default,
-  computeAgentsMeta
+  computeAgentsMeta,
+  deriveLayer,
+  deriveTopologyType
 };

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-JWUO6TIS.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+import {
+  createDebugLogger,
+  readFabricConfig,
+  resolveDevMode
+} from "./chunk-AEOYCVBG.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/node";
+
+// src/scanner/ignores.ts
+var DEFAULT_IGNORES = [
+  "**/*.meta",
+  "library/**",
+  "temp/**",
+  "build/**",
+  "settings/**",
+  "profiles/**",
+  "node_modules/**",
+  "dist/**",
+  ".git/**",
+  ".fabric/**"
+];
+function resolveIgnores(fabricConfig) {
+  return [...DEFAULT_IGNORES, ...fabricConfig?.scanIgnores ?? []];
+}
+
+// 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-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;
 }