@fenglimg/fabric-cli 2.0.0-rc.1 → 2.0.0-rc.11

package/dist/chunk-HQLEHH4O.js

@@ -0,0 +1,321 @@
+#!/usr/bin/env node
+import {
+  ClaudeCodeCLIWriter,
+  CursorWriter,
+  createServerEntry,
+  normalizeConfigPath,
+  removeJsonClientConfigEntry,
+  writeJsonClientConfig
+} from "./chunk-AW3G7ZH5.js";
+
+// src/config/resolver.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+
+// src/config/claude-code.ts
+import { existsSync } from "fs";
+import { join, resolve } from "path";
+import { homedir, platform } from "os";
+function getClaudeDesktopConfigPath() {
+  const os = platform();
+  if (os === "darwin") {
+    return join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  }
+  if (os === "win32") {
+    return join(process.env.APPDATA ?? join(homedir(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+  }
+  return join(homedir(), ".config", "Claude", "claude_desktop_config.json");
+}
+var ClaudeCodeDesktopWriter = class {
+  clientKind = "ClaudeCodeDesktop";
+  configuredPath;
+  constructor(configuredPath) {
+    this.configuredPath = configuredPath;
+  }
+  async detect(_workspaceRoot, overridePath) {
+    const configPath = normalizeConfigPath(overridePath ?? this.configuredPath ?? getClaudeDesktopConfigPath());
+    return existsSync(configPath) || overridePath !== void 0 || this.configuredPath !== void 0 ? configPath : null;
+  }
+  async write(serverPath, workspaceRoot, overridePath) {
+    const configPath = await this.detect(workspaceRoot, overridePath);
+    if (configPath === null) {
+      return;
+    }
+    await writeJsonClientConfig(configPath, {
+      command: process.execPath,
+      args: [serverPath]
+    });
+  }
+  async remove(serverName, workspaceRoot, overridePath) {
+    const configPath = await this.detect(workspaceRoot, overridePath);
+    if (configPath === null) {
+      return { status: "skipped", message: "no-config-path" };
+    }
+    return removeJsonClientConfigEntry(configPath, serverName);
+  }
+};
+
+// src/config/toml.ts
+import { existsSync as existsSync2 } from "fs";
+import { mkdir, readFile } from "fs/promises";
+import { dirname, join as join2, resolve as resolve2 } from "path";
+import { homedir as homedir2 } from "os";
+import { atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
+function expandHome(filePath) {
+  if (filePath === "~") {
+    return homedir2();
+  }
+  if (filePath.startsWith("~/")) {
+    return join2(homedir2(), filePath.slice(2));
+  }
+  return filePath;
+}
+function escapeTomlString(value) {
+  return JSON.stringify(value);
+}
+function serializeTomlStringArray(values) {
+  return `[${values.map((value) => escapeTomlString(value)).join(", ")}]`;
+}
+function serializeTomlInlineTable(values) {
+  const entries = Object.entries(values).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key} = ${escapeTomlString(value)}`);
+  return `{ ${entries.join(", ")} }`;
+}
+function serializeCodexServerBlock(serverName, serverEntry) {
+  const lines = [
+    `[mcp_servers.${serverName}]`,
+    `command = ${escapeTomlString(serverEntry.command)}`,
+    `args = ${serializeTomlStringArray(serverEntry.args)}`
+  ];
+  if (serverEntry.env !== void 0 && Object.keys(serverEntry.env).length > 0) {
+    lines.push(`env = ${serializeTomlInlineTable(serverEntry.env)}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function trimTrailingBlankLines(value) {
+  return value.replace(/\s+$/u, "");
+}
+function removeCodexServerBlock(rawConfig, serverName) {
+  const normalized = rawConfig.replace(/\r\n/g, "\n");
+  const escaped = serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const legacyPattern = new RegExp(
+    String.raw`\n?\[mcp\.servers\.${escaped}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`,
+    "g"
+  );
+  const currentPattern = new RegExp(
+    String.raw`\n?\[mcp_servers\.${escaped}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`,
+    "g"
+  );
+  const withoutLegacy = normalized.replace(legacyPattern, "");
+  const withoutCurrent = withoutLegacy.replace(currentPattern, "");
+  const changed = withoutCurrent !== normalized;
+  const text = changed ? `${trimTrailingBlankLines(withoutCurrent)}
+` : rawConfig;
+  return { text, changed };
+}
+function upsertCodexServerBlock(rawConfig, serverName, serverEntry) {
+  const block = serializeCodexServerBlock(serverName, serverEntry);
+  const normalized = rawConfig.replace(/\r\n/g, "\n");
+  const legacyPattern = new RegExp(String.raw`\n?\[mcp\.servers\.${serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`, "g");
+  const currentPattern = new RegExp(
+    String.raw`\n?\[mcp_servers\.${serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`,
+    "g"
+  );
+  const withoutLegacy = normalized.replace(legacyPattern, "");
+  const withoutExisting = withoutLegacy.replace(currentPattern, "");
+  const trimmed = trimTrailingBlankLines(withoutExisting);
+  if (trimmed.length === 0) {
+    return block;
+  }
+  return `${trimmed}
+
+${block}`;
+}
+async function readTomlConfigText(configPath) {
+  try {
+    return await readFile(configPath, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return "";
+    }
+    throw error;
+  }
+}
+var CodexTOMLConfigWriter = class {
+  clientKind = "CodexCLI";
+  configuredPath;
+  constructor(configuredPath) {
+    this.configuredPath = configuredPath;
+  }
+  async detect(_workspaceRoot, overridePath) {
+    const explicitPath = overridePath ?? this.configuredPath;
+    if (explicitPath !== void 0) {
+      return resolve2(expandHome(explicitPath));
+    }
+    const codexDir = join2(homedir2(), ".codex");
+    return existsSync2(codexDir) ? resolve2(join2(codexDir, "config.toml")) : null;
+  }
+  async write(serverPath, workspaceRoot, overridePath) {
+    const configPath = await this.detect(workspaceRoot, overridePath);
+    if (configPath === null) {
+      return;
+    }
+    const rawConfig = await readTomlConfigText(configPath);
+    const nextConfig = upsertCodexServerBlock(rawConfig, "fabric", createServerEntry(serverPath));
+    await mkdir(dirname(configPath), { recursive: true });
+    await atomicWriteText(configPath, nextConfig);
+  }
+  async remove(serverName, workspaceRoot, overridePath) {
+    const configPath = await this.detect(workspaceRoot, overridePath);
+    if (configPath === null) {
+      return { status: "skipped", message: "no-config-path" };
+    }
+    if (!existsSync2(configPath)) {
+      return { status: "skipped", path: configPath, message: "no-config-file" };
+    }
+    let rawConfig;
+    try {
+      rawConfig = await readTomlConfigText(configPath);
+    } catch (error) {
+      return {
+        status: "error",
+        path: configPath,
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+    const { text, changed } = removeCodexServerBlock(rawConfig, serverName);
+    if (!changed) {
+      return { status: "skipped", path: configPath, message: "not-present" };
+    }
+    try {
+      await mkdir(dirname(configPath), { recursive: true });
+      await atomicWriteText(configPath, text);
+      return { status: "removed", path: configPath };
+    } catch (error) {
+      return {
+        status: "error",
+        path: configPath,
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// 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;
+}
+function addIfDetected(writers, detected, createWriter, configuredPath) {
+  if (configuredPath !== void 0 || detected) {
+    writers.push(createWriter(configuredPath));
+  }
+}
+function resolveClients(workspaceRoot, fabricConfig = {}, opts = {}) {
+  const clientPaths = fabricConfig.clientPaths;
+  const writers = [];
+  const claudeMcpScope = opts.claudeMcpScope ?? "project";
+  addIfDetected(
+    writers,
+    existsSync3(join3(homedir3(), ".claude")) || existsSync3(join3(workspaceRoot, ".claude")),
+    (configuredPath) => new ClaudeCodeCLIWriter(configuredPath, claudeMcpScope),
+    hasExplicitPath(clientPaths, "claudeCodeCLI") ? clientPaths.claudeCodeCLI : void 0
+  );
+  addIfDetected(
+    writers,
+    existsSync3(getClaudeDesktopConfigPath()),
+    (configuredPath) => new ClaudeCodeDesktopWriter(configuredPath),
+    hasExplicitPath(clientPaths, "claudeCodeDesktop") ? clientPaths.claudeCodeDesktop : void 0
+  );
+  addIfDetected(
+    writers,
+    existsSync3(join3(workspaceRoot, ".cursor")),
+    (configuredPath) => new CursorWriter(configuredPath),
+    hasExplicitPath(clientPaths, "cursor") ? clientPaths.cursor : void 0
+  );
+  addIfDetected(
+    writers,
+    existsSync3(join3(homedir3(), ".codex")),
+    (configuredPath) => new CodexTOMLConfigWriter(configuredPath),
+    hasExplicitPath(clientPaths, "codexCLI") ? clientPaths.codexCLI : void 0
+  );
+  return writers;
+}
+function detectClientSupports(workspaceRoot, fabricConfig = {}) {
+  const clientPaths = fabricConfig.clientPaths;
+  const claudeDetected = existsSync3(join3(homedir3(), ".claude")) || existsSync3(join3(workspaceRoot, ".claude"));
+  const claudeDesktopDetected = existsSync3(getClaudeDesktopConfigPath());
+  const cursorDetected = existsSync3(join3(workspaceRoot, ".cursor"));
+  const codexDetected = existsSync3(join3(homedir3(), ".codex"));
+  return [
+    {
+      clientKind: "ClaudeCodeCLI",
+      label: "Claude Code CLI",
+      detected: claudeDetected || hasExplicitPath(clientPaths, "claudeCodeCLI"),
+      bootstrapTargetPath: ".fabric/bootstrap/README.md",
+      configPath: "project .claude/settings.json",
+      capabilities: {
+        bootstrap: true,
+        mcp: true,
+        hook: true,
+        skill: true
+      },
+      installedCapabilities: {
+        hook: true,
+        skill: true
+      }
+    },
+    {
+      clientKind: "ClaudeCodeDesktop",
+      label: "Claude Code Desktop",
+      detected: claudeDesktopDetected || hasExplicitPath(clientPaths, "claudeCodeDesktop"),
+      bootstrapTargetPath: ".fabric/bootstrap/README.md",
+      configPath: "desktop Claude config",
+      capabilities: {
+        bootstrap: true,
+        mcp: true,
+        hook: false,
+        skill: false
+      }
+    },
+    {
+      clientKind: "Cursor",
+      label: "Cursor",
+      detected: cursorDetected || hasExplicitPath(clientPaths, "cursor"),
+      bootstrapTargetPath: ".fabric/bootstrap/README.md",
+      configPath: ".cursor/mcp.json",
+      capabilities: {
+        bootstrap: true,
+        mcp: true,
+        hook: false,
+        skill: false
+      }
+    },
+    {
+      clientKind: "CodexCLI",
+      label: "Codex CLI",
+      detected: codexDetected || hasExplicitPath(clientPaths, "codexCLI"),
+      bootstrapTargetPath: ".fabric/bootstrap/README.md",
+      configPath: "~/.codex/config.toml",
+      capabilities: {
+        bootstrap: true,
+        mcp: true,
+        hook: true,
+        skill: true
+      },
+      installedCapabilities: {
+        hook: existsSync3(join3(workspaceRoot, ".codex", "hooks.json")),
+        // v2/rc.2: v1 client-side init skill removed; skill-installation probes
+        // will return once rc.2/3/4 introduce the v2 skills (fabric-archive,
+        // fabric-review, fabric-import). Until then there is nothing to probe.
+        skill: false
+      }
+    }
+  ];
+}
+
+export {
+  resolveClients,
+  detectClientSupports
+};

package/dist/{chunk-5LOYBXWD.js → chunk-OBQU6NHO.js}

@@ -1,46 +1,5 @@
 #!/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;
-}
-
 // src/dev-mode.ts
 import { existsSync, readFileSync } from "fs";
 import { isAbsolute, join, resolve } from "path";
@@ -97,17 +56,8 @@ function formatResolutionStep(source, value) {
   return `${source}: ${value ?? "<unset>"}`;
 }
 
-// src/i18n.ts
-import { createTranslator, detectNodeLocale } from "@fenglimg/fabric-shared";
-var locale = detectNodeLocale();
-var t = createTranslator(locale);
-
 export {
-  paint,
-  symbol,
-  displayWidth,
-  padEnd,
+  readFabricConfig,
   resolveDevMode,
-  createDebugLogger,
-  t
+  createDebugLogger
 };

package/dist/chunk-WPTA74BY.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+import {
+  addArchiveSkillPointer,
+  installArchiveHintHook,
+  installFabricArchiveSkill,
+  installFabricImportSkill,
+  installFabricReviewSkill,
+  installKnowledgeHintBroadHook,
+  installKnowledgeHintNarrowHook,
+  mergeClaudeCodeHookConfig,
+  mergeCodexHookConfig,
+  mergeCursorHookConfig
+} from "./chunk-AW3G7ZH5.js";
+import {
+  t
+} from "./chunk-6ICJICVU.js";
+
+// src/commands/hooks.ts
+import { existsSync, statSync } from "fs";
+import { isAbsolute, join, resolve } from "path";
+import { defineCommand } from "citty";
+var hooksCommand = defineCommand({
+  meta: {
+    name: "hooks",
+    description: t("cli.hooks.description")
+  },
+  subCommands: {
+    install: defineCommand({
+      meta: {
+        name: "install",
+        description: t("cli.hooks.install.description")
+      },
+      args: {
+        target: {
+          type: "string",
+          description: t("cli.hooks.install.args.target.description"),
+          default: process.cwd()
+        }
+      },
+      async run({ args }) {
+        const result = await installHooks(args.target);
+        for (const path of result.installed) {
+          console.log(`installed ${path}`);
+        }
+        for (const path of result.skipped) {
+          console.log(`skipped ${path}`);
+        }
+        for (const message of result.errors) {
+          console.error(`error ${message}`);
+        }
+      }
+    })
+  }
+});
+var hooks_default = hooksCommand;
+async function installHooks(target, _options = {}) {
+  const normalizedTarget = normalizeTarget(target);
+  assertExistingDirectory(normalizedTarget);
+  const results = [];
+  results.push(...await runStep(() => installFabricArchiveSkill(normalizedTarget)));
+  results.push(...await runStep(() => installFabricReviewSkill(normalizedTarget)));
+  results.push(...await runStep(() => installFabricImportSkill(normalizedTarget)));
+  results.push(...await runStep(() => installArchiveHintHook(normalizedTarget)));
+  results.push(...await runStep(() => installKnowledgeHintBroadHook(normalizedTarget)));
+  results.push(...await runStep(() => installKnowledgeHintNarrowHook(normalizedTarget)));
+  results.push(await runSingleStep("claude-hook-config", () => mergeClaudeCodeHookConfig(normalizedTarget)));
+  results.push(await runSingleStep("codex-hook-config", () => mergeCodexHookConfig(normalizedTarget)));
+  results.push(await runSingleStep("cursor-hook-config", () => mergeCursorHookConfig(normalizedTarget)));
+  results.push(...await runStep(() => addArchiveSkillPointer(normalizedTarget)));
+  results.push(...validateHookPaths(normalizedTarget));
+  return summarizeResults(results);
+}
+function validateHookPaths(projectRoot) {
+  const scripts = [
+    { stepSuffix: "", hookFile: "fabric-hint.cjs" },
+    { stepSuffix: "-broad", hookFile: "knowledge-hint-broad.cjs" },
+    { stepSuffix: "-narrow", hookFile: "knowledge-hint-narrow.cjs" }
+  ];
+  const clients = [
+    {
+      client: "claude",
+      configRel: join(".claude", "settings.json"),
+      hookDir: join(".claude", "hooks")
+    },
+    {
+      client: "codex",
+      configRel: join(".codex", "hooks.json"),
+      hookDir: join(".codex", "hooks")
+    },
+    {
+      client: "cursor",
+      configRel: join(".cursor", "hooks.json"),
+      hookDir: join(".cursor", "hooks")
+    }
+  ];
+  const results = [];
+  for (const { client, configRel, hookDir } of clients) {
+    const configPath = resolve(projectRoot, configRel);
+    if (!existsSync(configPath)) {
+      results.push({
+        step: `hook-validate-${client}`,
+        path: configPath,
+        status: "skipped",
+        message: "missing-config"
+      });
+      continue;
+    }
+    for (const { stepSuffix, hookFile } of scripts) {
+      const expectedHookPath = resolve(projectRoot, hookDir, hookFile);
+      const expectedHookRel = join(hookDir, hookFile);
+      const step = `hook-validate-${client}${stepSuffix}`;
+      if (!existsSync(expectedHookPath)) {
+        results.push({
+          step,
+          path: expectedHookPath,
+          status: "error",
+          message: `hook script missing: ${expectedHookRel}`
+        });
+        continue;
+      }
+      results.push({ step, path: expectedHookPath, status: "skipped", message: "ok" });
+    }
+  }
+  return results;
+}
+async function runStep(fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    return [
+      {
+        step: "hook-install",
+        path: "",
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    ];
+  }
+}
+async function runSingleStep(step, fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    return {
+      step,
+      path: "",
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function summarizeResults(results) {
+  const installed = [];
+  const skipped = [];
+  const errors = [];
+  for (const r of results) {
+    switch (r.status) {
+      case "written":
+        installed.push(r.path);
+        break;
+      case "skipped":
+        skipped.push(r.path);
+        break;
+      case "error":
+        errors.push(`${r.step} ${r.path}: ${r.message ?? "unknown error"}`);
+        break;
+    }
+  }
+  return { installed, skipped, errors };
+}
+function normalizeTarget(targetInput) {
+  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
+}
+function assertExistingDirectory(target) {
+  if (!existsSync(target) || !statSync(target).isDirectory()) {
+    throw new Error(t("cli.shared.target-invalid", { target }));
+  }
+}
+
+export {
+  hooksCommand,
+  hooks_default,
+  installHooks
+};

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
+};