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

package/dist/{chunk-FDRLV5PL.js → chunk-FNO7CQDG.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-ZSESMG6L.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
 };

package/dist/chunk-KZ2YITOS.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+import {
+  resolveClients
+} from "./chunk-MF3OTILQ.js";
+import {
+  t
+} from "./chunk-6ICJICVU.js";
+
+// src/commands/config.ts
+import { existsSync, statSync } from "fs";
+import { readFile } from "fs/promises";
+import { join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { cancel, intro, isCancel, log, outro, select, text } from "@clack/prompts";
+import { getPanelFields } from "@fenglimg/fabric-shared";
+import { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
+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 PANEL_CONFIG_RELATIVE_PATH = [".fabric", "fabric-config.json"];
+var EXIT_CHOICE = "__exit__";
+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({ args }) {
+    const workspaceRoot = resolve(args.target ?? process.cwd());
+    const configPath = join(workspaceRoot, ...PANEL_CONFIG_RELATIVE_PATH);
+    const fabricDir = join(workspaceRoot, ".fabric");
+    const fabricDirOk = existsSync(fabricDir) && statSync(fabricDir).isDirectory();
+    const configOk = fabricDirOk && existsSync(configPath);
+    if (!configOk) {
+      console.error(t("cli.config.errors.uninit-workspace.message"));
+      process.exitCode = 1;
+      return;
+    }
+    if (!isInteractiveConfig()) {
+      console.log(t("cli.config.intro"));
+      console.log(t("cli.config.non-tty-notice"));
+      return;
+    }
+    intro(t("cli.config.intro"));
+    let edited = false;
+    while (true) {
+      const current = await readPanelConfig(configPath);
+      const fields = getPanelFields();
+      const fieldChoice = await select({
+        message: t("cli.config.menu.field-select"),
+        options: [
+          ...fields.map((field2) => ({
+            value: field2.key,
+            label: formatFieldMenuLabel(field2, current)
+          })),
+          { value: EXIT_CHOICE, label: t("cli.config.menu.exit") }
+        ]
+      });
+      if (isCancel(fieldChoice)) {
+        cancel(t("cli.config.cancel"));
+        return;
+      }
+      if (fieldChoice === EXIT_CHOICE) {
+        outro(edited ? t("cli.config.outro") : t("cli.config.outro-no-changes"));
+        return;
+      }
+      const field = fields.find((f) => f.key === fieldChoice);
+      if (!field) {
+        log.warn(t("cli.config.errors.unknown-field"));
+        continue;
+      }
+      const newValue = await promptFieldValue(field, current);
+      if (newValue === CANCELLED) {
+        cancel(t("cli.config.cancel"));
+        return;
+      }
+      if (newValue === SKIPPED) {
+        continue;
+      }
+      try {
+        const refreshed = await readPanelConfig(configPath);
+        const merged = { ...refreshed, [field.key]: newValue };
+        await atomicWriteJson(configPath, merged);
+        edited = true;
+        log.success(
+          t("cli.config.write.success", {
+            key: field.key,
+            value: field.format_for_display(newValue)
+          })
+        );
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log.error(t("cli.config.write.failure", { message }));
+      }
+    }
+  }
+});
+var config_default = configCmd;
+var CANCELLED = /* @__PURE__ */ Symbol("config-cancelled");
+var SKIPPED = /* @__PURE__ */ Symbol("config-skipped");
+async function promptFieldValue(field, current) {
+  const currentValue = current[field.key];
+  const currentDisplay = field.format_for_display(currentValue);
+  if (field.widget === "select") {
+    const enumValues = field.enum_values ?? [];
+    if (enumValues.length === 0) {
+      log.warn(t("cli.config.errors.no-enum-options"));
+      return SKIPPED;
+    }
+    const initialValue = enumValues.includes(String(currentValue)) ? String(currentValue) : enumValues.includes(String(field.default)) ? String(field.default) : enumValues[0];
+    const picked = await select({
+      message: t("cli.config.prompt.select", {
+        key: field.key,
+        current: currentDisplay
+      }),
+      options: enumValues.map((value) => ({ value, label: value })),
+      initialValue
+    });
+    if (isCancel(picked)) {
+      return CANCELLED;
+    }
+    const result = field.validate(String(picked));
+    if (!result.ok) {
+      log.error(result.error);
+      return SKIPPED;
+    }
+    return result.value;
+  }
+  const entered = await text({
+    message: t("cli.config.prompt.text", {
+      key: field.key,
+      current: currentDisplay
+    }),
+    placeholder: currentDisplay,
+    initialValue: currentDisplay,
+    validate(raw) {
+      const result = field.validate(raw ?? "");
+      return result.ok ? void 0 : result.error;
+    }
+  });
+  if (isCancel(entered)) {
+    return CANCELLED;
+  }
+  const finalResult = field.validate(String(entered));
+  if (!finalResult.ok) {
+    log.error(finalResult.error);
+    return SKIPPED;
+  }
+  return finalResult.value;
+}
+function formatFieldMenuLabel(field, current) {
+  const key = field.key;
+  const rawValue = current[key];
+  const display = field.format_for_display(rawValue);
+  const isDefault = rawValue === void 0 || rawValue === null;
+  const labelText = t(field.label_i18n_key);
+  const valueLabel = isDefault ? `${display} ${t("cli.config.value.default-marker")}` : display;
+  return `[${field.group}] ${key} (${labelText}) \u2014 ${t("cli.config.value.current", { value: valueLabel })}`;
+}
+async function readPanelConfig(configPath) {
+  const raw = await readFile(configPath, "utf8");
+  const parsed = JSON.parse(raw);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(t("cli.config.errors.expected-object", { path: configPath }));
+  }
+  return parsed;
+}
+function isInteractiveConfig() {
+  return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY);
+}
+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
+};