@fenglimg/fabric-cli 2.0.0-rc.13 → 2.0.0-rc.15

package/README.md

@@ -9,16 +9,18 @@
 3. 在目标项目运行 `fabric install`，完成一站式安装。
 4. 启动 `fabric serve`，再去客户端里验证 `fab_plan_context` 和 `fab_get_knowledge_sections`。
 
-`fabric install` 会自动准备 bootstrap、MCP 配置和 git hooks。公共命令面只保留 `install`、`scan`、`doctor`、`serve`。
+`fabric install` 会自动准备 bootstrap、MCP 配置和 git hooks。公共命令面只保留 `install`、`doctor`、`serve`、`uninstall`、`config`（rc.15 起 `fab scan` 已折叠到 `fab doctor --rescan`）。
 
 ## 常用命令
 
 - `fabric install`
-- `fabric scan`
 - `fabric doctor`
 - `fabric doctor --json`
 - `fabric doctor --strict`
 - `fabric doctor --fix`
+- `fabric doctor --rescan`（替代旧的 `fabric scan`）
 - `fabric serve`
+- `fabric uninstall`
+- `fabric config`（rc.16 起将提供配置面板；当前为占位提示）
 
 `fabric doctor --fix` 只修复确定性的派生状态，例如 `.fabric/agents.meta.json`、`.fabric/.cache/knowledge-test.index.json`、缺失的 `.fabric/events.jsonl` 和 stale hashes；语义冲突、缺失 rule section、未完成的初始化确认仍需要人工处理。

package/dist/chunk-AIB54QRT.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import {
+  resolveClients
+} from "./chunk-SKSYUHKK.js";
+import {
+  t
+} from "./chunk-6ICJICVU.js";
+
+// src/commands/config.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import { fileURLToPath } from "url";
+import { defineCommand } from "citty";
+async function loadFabricConfig(workspaceRoot) {
+  const configPath = resolve(workspaceRoot, "fabric.config.json");
+  if (!existsSync(configPath)) {
+    return {};
+  }
+  const parsed = JSON.parse(await readFile(configPath, "utf8"));
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(t("cli.config.errors.expected-object", { path: configPath }));
+  }
+  return parsed;
+}
+function resolveServerPath(override) {
+  if (override) return override;
+  if (process.env.FAB_SERVER_PATH) return resolve(process.env.FAB_SERVER_PATH);
+  return fileURLToPath(import.meta.resolve("@fenglimg/fabric-server"));
+}
+var configCmd = defineCommand({
+  meta: {
+    name: "config",
+    description: t("cli.config.description")
+  },
+  args: {
+    target: {
+      type: "string",
+      description: t("cli.config.args.target.description"),
+      valueHint: "path"
+    }
+  },
+  async run(_ctx) {
+    console.log(t("cli.config.placeholder"));
+  }
+});
+var config_default = configCmd;
+async function installMcpClients(target, options = {}) {
+  const workspaceRoot = resolve(target);
+  const fabricConfig = await loadFabricConfig(workspaceRoot);
+  const selectedClients = options.clients === void 0 ? null : new Set(options.clients);
+  const serverPath = resolveServerPath(options.localServerPath);
+  const writers = resolveClients(workspaceRoot, fabricConfig, { claudeMcpScope: options.claudeMcpScope }).filter(
+    (writer) => selectedClients === null ? true : selectedClients.has(writer.clientKind)
+  );
+  const installed = [];
+  const skipped = [];
+  const details = [];
+  for (const writer of writers) {
+    const configPath = await writer.detect(workspaceRoot);
+    if (configPath === null) {
+      skipped.push(writer.clientKind);
+      details.push({ client: writer.clientKind, path: null, action: "skipped" });
+      continue;
+    }
+    if (options.dryRun) {
+      skipped.push(writer.clientKind);
+      details.push({ client: writer.clientKind, path: configPath, action: "dry-run" });
+      continue;
+    }
+    await writer.write(serverPath, workspaceRoot);
+    installed.push(writer.clientKind);
+    details.push({ client: writer.clientKind, path: configPath, action: "wrote" });
+  }
+  return { installed, skipped, details };
+}
+
+export {
+  configCmd,
+  config_default,
+  installMcpClients
+};

package/dist/{chunk-FDRLV5PL.js → chunk-AXIFEVAS.js}

@@ -1,23 +1,16 @@
 #!/usr/bin/env node
-import {
-  paint,
-  symbol
-} from "./chunk-WWNXR34K.js";
-import {
-  createDebugLogger,
-  readFabricConfig,
-  resolveDevMode
-} from "./chunk-OBQU6NHO.js";
 import {
   t
 } from "./chunk-6ICJICVU.js";
+import {
+  readFabricConfig
+} from "./chunk-OBQU6NHO.js";
 
 // src/commands/scan.ts
 import { createHash } from "crypto";
 import { existsSync, readdirSync, readFileSync, statSync } from "fs";
 import { mkdir, readFile } from "fs/promises";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
-import { defineCommand } from "citty";
+import { dirname, isAbsolute, join, resolve } from "path";
 import {
   KnowledgeIdAllocator,
   appendEventLedgerEvent,
@@ -27,51 +20,6 @@ import {
   formatKnowledgeId
 } from "@fenglimg/fabric-shared";
 import { atomicWriteJson, atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
-
-// 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
-async 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, ".fabric", "bootstrap", "README.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 KNOWLEDGE_DIR = ".fabric/knowledge";
 var SCAN_STATE_FILE = ".scan-state.json";
 var FORENSIC_FILE = ".fabric/forensic.json";
@@ -142,50 +90,6 @@ async function runInitScan(targetInput, options = {}) {
     duration_ms: durationMs
   };
 }
-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);
-    logger(`scan target source: ${resolution.source}`);
-    for (const step of resolution.chain) {
-      logger(step);
-    }
-    try {
-      const result = await runInitScan(resolution.target, { source: "scan" });
-      if (args.json) {
-        console.log(JSON.stringify(result, null, 2));
-        return;
-      }
-      printPrettyResult(result);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error(`${symbol.warn} ${paint.warn(message)}`);
-      process.exitCode = 1;
-    }
-  }
-});
-var scan_default = scanCommand;
 var STRICT_BASELINE_TEMPLATES = {
   en: {
     "tech-stack": {
@@ -884,123 +788,11 @@ async function registerKnowledgeNodesInMeta(target, entries) {
 async function ensureParentDirectory(filePath) {
   await mkdir(dirname(filePath), { recursive: true });
 }
-function printPrettyResult(result) {
-  const writtenCount = result.written_stable_ids.length;
-  const skippedCount = result.skipped_stable_ids.length;
-  if (writtenCount === 0) {
-    console.log(`${symbol.ok} ${paint.success(t("cli.scan.summary.skipped", { count: String(skippedCount) }))}`);
-    return;
-  }
-  console.log(`${symbol.ok} ${paint.success(t("cli.scan.summary.created", { count: String(writtenCount) }))}`);
-  for (const id of result.written_stable_ids) {
-    console.log(`  - ${paint.ai(id)}`);
-  }
-  if (skippedCount > 0) {
-    console.log(paint.muted(`(${skippedCount} unchanged, skipped)`));
-  }
-}
 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;
-}
-var __testing__ = {
-  buildTechStackEntry,
-  buildModuleStructureEntry,
-  buildBuildConfigEntry,
-  buildCodeStyleEntry,
-  buildCIConfigEntry,
-  buildReadmeFirstParaEntry,
-  buildProjectBriefEntry,
-  renderMarkdown,
-  stripFrontmatter,
-  isCIConfigPath,
-  isBuildConfigPath,
-  extractFirstParagraph,
-  extractExplicitDescription,
-  // TASK-008 / rc.12: bilingual template registry + language detection
-  detectExistingLanguage,
-  resolveFabricLanguage,
-  BASELINE_TEMPLATES
-};
 
 export {
-  detectFramework,
-  formatKnowledgeId,
-  createScanReport,
   runInitScan,
-  scanCommand,
-  scan_default,
-  detectExistingLanguage,
-  deriveTagsFromForensic,
-  __testing__
+  detectExistingLanguage
 };

package/dist/{chunk-WWNXR34K.js → chunk-G2CIOLD4.js}

@@ -41,9 +41,24 @@ function padEnd(value, width, char = " ") {
   return result;
 }
 
+// src/lib/error-render.ts
+function hasActionHint(err) {
+  if (err === null || typeof err !== "object") return false;
+  const candidate = err;
+  return typeof candidate.message === "string" && candidate.message.length > 0 && typeof candidate.actionHint === "string" && candidate.actionHint.length > 0;
+}
+function renderFabricError(err, stream = process.stderr) {
+  stream.write(`${err.message}
+`);
+  stream.write(`  -> ${err.actionHint}
+`);
+}
+
 export {
   paint,
   symbol,
   displayWidth,
-  padEnd
+  padEnd,
+  hasActionHint,
+  renderFabricError
 };