@fenglimg/fabric-cli 2.0.0 → 2.1.0-rc.2

package/dist/chunk-HFQVXY6P.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import {
+  loadProjectConfig,
+  saveProjectConfig
+} from "./chunk-LFIKMVY7.js";
+import {
+  loadGlobalConfig,
+  resolveGlobalRoot,
+  saveGlobalConfig
+} from "./chunk-RYAFBNES.js";
+
+// src/store/store-ops.ts
+import {
+  addMountedStore,
+  bindRequiredStore,
+  detachMountedStore,
+  explainStore
+} from "@fenglimg/fabric-shared";
+var NO_GLOBAL_CONFIG = "no global Fabric config found \u2014 run `fabric install --global <url>` first";
+function requireConfig(globalRoot) {
+  const config = loadGlobalConfig(globalRoot);
+  if (config === null) {
+    throw new Error(NO_GLOBAL_CONFIG);
+  }
+  return config;
+}
+function storeList(globalRoot = resolveGlobalRoot()) {
+  return requireConfig(globalRoot).stores;
+}
+function storeAdd(store, globalRoot = resolveGlobalRoot()) {
+  const next = addMountedStore(requireConfig(globalRoot), store);
+  saveGlobalConfig(next, globalRoot);
+  return next;
+}
+function storeRemove(alias, globalRoot = resolveGlobalRoot()) {
+  const result = detachMountedStore(requireConfig(globalRoot), alias);
+  saveGlobalConfig(result.config, globalRoot);
+  return result;
+}
+function storeExplain(alias, globalRoot = resolveGlobalRoot()) {
+  return explainStore(requireConfig(globalRoot), alias);
+}
+var NO_PROJECT_CONFIG = "no project Fabric config \u2014 run `fabric install` in this repo first";
+function requireProjectConfig(projectRoot) {
+  const config = loadProjectConfig(projectRoot);
+  if (config === null) {
+    throw new Error(NO_PROJECT_CONFIG);
+  }
+  return config;
+}
+function storeBind(projectRoot, entry) {
+  const config = requireProjectConfig(projectRoot);
+  const next = {
+    ...config,
+    required_stores: bindRequiredStore(config.required_stores ?? [], entry)
+  };
+  saveProjectConfig(next, projectRoot);
+  return next;
+}
+function storeSwitchWrite(projectRoot, alias) {
+  const config = requireProjectConfig(projectRoot);
+  const next = { ...config, active_write_store: alias };
+  saveProjectConfig(next, projectRoot);
+  return next;
+}
+function missingRequiredStores(projectRoot, globalRoot = resolveGlobalRoot()) {
+  const project = loadProjectConfig(projectRoot);
+  if (project === null || project.required_stores === void 0) {
+    return [];
+  }
+  const global = loadGlobalConfig(globalRoot);
+  const mounted = new Set(
+    (global?.stores ?? []).flatMap((s) => [s.alias, s.store_uuid])
+  );
+  return project.required_stores.filter((r) => !mounted.has(r.id));
+}
+
+export {
+  storeList,
+  storeAdd,
+  storeRemove,
+  storeExplain,
+  storeBind,
+  storeSwitchWrite,
+  missingRequiredStores
+};

package/dist/chunk-L4Q55UC4.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import {
+  loadProjectConfig
+} from "./chunk-LFIKMVY7.js";
+import {
+  loadGlobalConfig,
+  resolveGlobalRoot
+} from "./chunk-RYAFBNES.js";
+
+// src/store/scope-explain.ts
+import {
+  createStoreResolver
+} from "@fenglimg/fabric-shared";
+function buildResolveInput(projectRoot, globalRoot = resolveGlobalRoot()) {
+  const global = loadGlobalConfig(globalRoot);
+  if (global === null) {
+    return null;
+  }
+  const project = loadProjectConfig(projectRoot);
+  return {
+    uid: global.uid,
+    mountedStores: global.stores.map((s) => ({
+      store_uuid: s.store_uuid,
+      alias: s.alias,
+      ...s.remote === void 0 ? {} : { remote: s.remote },
+      writable: s.writable ?? true,
+      personal: s.personal ?? false
+    })),
+    requiredStores: (project?.required_stores ?? []).map((r) => ({
+      id: r.id,
+      ...r.suggested_remote === void 0 ? {} : { suggested_remote: r.suggested_remote }
+    })),
+    ...project?.active_write_store === void 0 ? {} : { activeWriteAlias: project.active_write_store }
+  };
+}
+function scopeExplain(projectRoot, scope, globalRoot = resolveGlobalRoot()) {
+  const input = buildResolveInput(projectRoot, globalRoot);
+  if (input === null) {
+    return null;
+  }
+  const resolver = createStoreResolver();
+  return {
+    scope,
+    readSet: resolver.resolveReadSet(input),
+    writeTarget: resolver.resolveWriteTarget(input, scope).target
+  };
+}
+
+export {
+  buildResolveInput,
+  scopeExplain
+};

package/dist/chunk-LFIKMVY7.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+// src/store/project-config-io.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { fabricConfigSchema } from "@fenglimg/fabric-shared";
+function projectConfigPath(projectRoot) {
+  return join(projectRoot, ".fabric", "fabric-config.json");
+}
+function loadProjectConfig(projectRoot) {
+  const path = projectConfigPath(projectRoot);
+  if (!existsSync(path)) {
+    return null;
+  }
+  return fabricConfigSchema.parse(JSON.parse(readFileSync(path, "utf8")));
+}
+function saveProjectConfig(config, projectRoot) {
+  const validated = fabricConfigSchema.parse(config);
+  mkdirSync(join(projectRoot, ".fabric"), { recursive: true });
+  writeFileSync(projectConfigPath(projectRoot), `${JSON.stringify(validated, null, 2)}
+`, "utf8");
+}
+
+export {
+  loadProjectConfig,
+  saveProjectConfig
+};

package/dist/chunk-MF3OTILQ.js

@@ -0,0 +1,544 @@
+#!/usr/bin/env node
+
+// src/config/resolver.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+
+// src/config/claude-code.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+import { homedir as homedir2, platform } from "os";
+
+// src/config/json.ts
+import { existsSync } from "fs";
+import { mkdir, readFile } from "fs/promises";
+import { dirname, join, resolve } from "path";
+import { homedir } from "os";
+import { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
+
+// src/config/writer.ts
+function createServerEntry(serverPath) {
+  return {
+    command: process.execPath,
+    args: [serverPath]
+  };
+}
+
+// src/config/json.ts
+function deepMerge(target, source, options = {}) {
+  return deepMergeAtPath(target, source, "", options);
+}
+function deepMergeAtPath(target, source, path, options) {
+  if (options.arrayAppendPaths && options.arrayAppendPaths.includes(path) && Array.isArray(target) && Array.isArray(source)) {
+    return appendArrayWithDedupe(target, source);
+  }
+  if (target === null || typeof target !== "object" || Array.isArray(target) || source === null || typeof source !== "object" || Array.isArray(source)) {
+    return source;
+  }
+  const out = { ...target };
+  for (const key of Object.keys(source)) {
+    const childPath = path === "" ? key : `${path}.${key}`;
+    out[key] = deepMergeAtPath(
+      target[key],
+      source[key],
+      childPath,
+      options
+    );
+  }
+  return out;
+}
+function appendArrayWithDedupe(target, source) {
+  const out = [...target];
+  for (const candidate of source) {
+    if (out.some((existing) => isSameHookEntry(existing, candidate))) {
+      continue;
+    }
+    out.push(candidate);
+  }
+  return out;
+}
+function isSameHookEntry(a, b) {
+  const cmdA = extractHookCommand(a);
+  const cmdB = extractHookCommand(b);
+  if (cmdA !== null && cmdB !== null) {
+    return cmdA === cmdB;
+  }
+  return deepEqual(a, b);
+}
+function extractHookCommand(item) {
+  if (item === null || typeof item !== "object") {
+    return null;
+  }
+  const obj = item;
+  if (typeof obj.command === "string") {
+    return obj.command;
+  }
+  if (Array.isArray(obj.hooks)) {
+    for (const inner of obj.hooks) {
+      if (inner !== null && typeof inner === "object") {
+        const innerObj = inner;
+        if (typeof innerObj.command === "string") {
+          return innerObj.command;
+        }
+      }
+    }
+  }
+  return null;
+}
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) {
+    return false;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    return a.every((value, index) => deepEqual(value, b[index]));
+  }
+  const aObj = a;
+  const bObj = b;
+  const aKeys = Object.keys(aObj);
+  const bKeys = Object.keys(bObj);
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  return aKeys.every((key) => deepEqual(aObj[key], bObj[key]));
+}
+function expandHome(filePath) {
+  if (filePath === "~") {
+    return homedir();
+  }
+  if (filePath.startsWith("~/")) {
+    return join(homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+function normalizeConfigPath(filePath) {
+  return resolve(expandHome(filePath));
+}
+async function readJsonConfig(configPath) {
+  try {
+    const raw = await readFile(configPath, "utf8");
+    if (raw.trim().length === 0) {
+      return {};
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error(`Expected JSON object in ${configPath}`);
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+}
+async function writeJsonClientConfig(configPath, serverEntry) {
+  const existing = await readJsonConfig(configPath);
+  const merged = deepMerge(existing, { mcpServers: { fabric: serverEntry } });
+  await mkdir(dirname(configPath), { recursive: true });
+  await atomicWriteJson(configPath, merged, { indent: 2 });
+}
+async function removeJsonClientConfigEntry(configPath, serverName) {
+  if (!existsSync(configPath)) {
+    return { status: "skipped", path: configPath, message: "no-config-file" };
+  }
+  let existing;
+  try {
+    existing = await readJsonConfig(configPath);
+  } catch (error) {
+    return {
+      status: "error",
+      path: configPath,
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+  const mcpServers = existing.mcpServers;
+  if (mcpServers === void 0 || mcpServers === null || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+    return { status: "skipped", path: configPath, message: "no-mcp-servers-object" };
+  }
+  const servers = mcpServers;
+  if (!Object.prototype.hasOwnProperty.call(servers, serverName)) {
+    return { status: "skipped", path: configPath, message: "not-present" };
+  }
+  const nextServers = { ...servers };
+  delete nextServers[serverName];
+  const next = { ...existing, mcpServers: nextServers };
+  try {
+    await mkdir(dirname(configPath), { recursive: true });
+    await atomicWriteJson(configPath, next, { indent: 2 });
+    return { status: "removed", path: configPath };
+  } catch (error) {
+    return {
+      status: "error",
+      path: configPath,
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+var JsonClientConfigWriter = class {
+  configuredPath;
+  constructor(configuredPath) {
+    this.configuredPath = configuredPath;
+  }
+  async detect(workspaceRoot, overridePath) {
+    const explicitPath = overridePath ?? this.configuredPath;
+    if (explicitPath !== void 0) {
+      return normalizeConfigPath(explicitPath);
+    }
+    const configPath = this.defaultPath(workspaceRoot);
+    return configPath === null ? null : normalizeConfigPath(configPath);
+  }
+  async write(serverPath, workspaceRoot, overridePath) {
+    const configPath = await this.detect(workspaceRoot, overridePath);
+    if (configPath === null) {
+      return;
+    }
+    await writeJsonClientConfig(configPath, createServerEntry(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);
+  }
+};
+var ClaudeCodeCLIWriter = class extends JsonClientConfigWriter {
+  clientKind = "ClaudeCodeCLI";
+  scope;
+  constructor(configuredPath, scope = "project") {
+    super(configuredPath);
+    this.scope = scope;
+  }
+  // Writes to project-level .mcp.json (per Claude Code MCP spec) by default,
+  // or ~/.claude.json for user scope.
+  // Detection still checks ~/.claude to confirm Claude Code is installed.
+  defaultPath(workspaceRoot) {
+    const globalClaudeDir = join(homedir(), ".claude");
+    const projectClaudeDir = join(workspaceRoot, ".claude");
+    if (!existsSync(globalClaudeDir) && !existsSync(projectClaudeDir)) {
+      return null;
+    }
+    return this.scope === "user" ? join(homedir(), ".claude.json") : join(workspaceRoot, ".mcp.json");
+  }
+};
+var CursorWriter = class extends JsonClientConfigWriter {
+  clientKind = "Cursor";
+  constructor(configuredPath) {
+    super(configuredPath);
+  }
+  defaultPath(workspaceRoot) {
+    const cursorDir = join(workspaceRoot, ".cursor");
+    return existsSync(cursorDir) ? join(cursorDir, "mcp.json") : null;
+  }
+};
+
+// src/config/claude-code.ts
+function getClaudeDesktopConfigPath() {
+  const os = platform();
+  if (os === "darwin") {
+    return join2(homedir2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  }
+  if (os === "win32") {
+    return join2(process.env.APPDATA ?? join2(homedir2(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+  }
+  return join2(homedir2(), ".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 existsSync2(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 existsSync3 } from "fs";
+import { mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
+import { dirname as dirname2, join as join3, resolve as resolve3 } from "path";
+import { homedir as homedir3 } from "os";
+import { atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
+function expandHome2(filePath) {
+  if (filePath === "~") {
+    return homedir3();
+  }
+  if (filePath.startsWith("~/")) {
+    return join3(homedir3(), 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 readFile2(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 resolve3(expandHome2(explicitPath));
+    }
+    const codexDir = join3(homedir3(), ".codex");
+    return existsSync3(codexDir) ? resolve3(join3(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 mkdir2(dirname2(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 (!existsSync3(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 mkdir2(dirname2(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,
+    existsSync4(join4(homedir4(), ".claude")) || existsSync4(join4(workspaceRoot, ".claude")),
+    (configuredPath) => new ClaudeCodeCLIWriter(configuredPath, claudeMcpScope),
+    hasExplicitPath(clientPaths, "claudeCodeCLI") ? clientPaths.claudeCodeCLI : void 0
+  );
+  addIfDetected(
+    writers,
+    existsSync4(getClaudeDesktopConfigPath()),
+    (configuredPath) => new ClaudeCodeDesktopWriter(configuredPath),
+    hasExplicitPath(clientPaths, "claudeCodeDesktop") ? clientPaths.claudeCodeDesktop : void 0
+  );
+  addIfDetected(
+    writers,
+    existsSync4(join4(workspaceRoot, ".cursor")),
+    (configuredPath) => new CursorWriter(configuredPath),
+    hasExplicitPath(clientPaths, "cursor") ? clientPaths.cursor : void 0
+  );
+  addIfDetected(
+    writers,
+    existsSync4(join4(homedir4(), ".codex")),
+    (configuredPath) => new CodexTOMLConfigWriter(configuredPath),
+    hasExplicitPath(clientPaths, "codexCLI") ? clientPaths.codexCLI : void 0
+  );
+  return writers;
+}
+function detectClientSupports(workspaceRoot, fabricConfig = {}) {
+  const clientPaths = fabricConfig.clientPaths;
+  const claudeDetected = existsSync4(join4(homedir4(), ".claude")) || existsSync4(join4(workspaceRoot, ".claude"));
+  const claudeDesktopDetected = existsSync4(getClaudeDesktopConfigPath());
+  const cursorDetected = existsSync4(join4(workspaceRoot, ".cursor"));
+  const codexDetected = existsSync4(join4(homedir4(), ".codex"));
+  return [
+    {
+      clientKind: "ClaudeCodeCLI",
+      label: "Claude Code CLI",
+      detected: claudeDetected || hasExplicitPath(clientPaths, "claudeCodeCLI"),
+      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"),
+      configPath: "desktop Claude config",
+      capabilities: {
+        bootstrap: true,
+        mcp: true,
+        hook: false,
+        skill: false
+      }
+    },
+    {
+      clientKind: "Cursor",
+      label: "Cursor",
+      detected: cursorDetected || hasExplicitPath(clientPaths, "cursor"),
+      configPath: ".cursor/mcp.json",
+      capabilities: {
+        bootstrap: true,
+        mcp: true,
+        hook: false,
+        skill: false
+      }
+    },
+    {
+      clientKind: "CodexCLI",
+      label: "Codex CLI",
+      detected: codexDetected || hasExplicitPath(clientPaths, "codexCLI"),
+      configPath: "~/.codex/config.toml",
+      capabilities: {
+        bootstrap: true,
+        mcp: true,
+        hook: true,
+        skill: true
+      },
+      installedCapabilities: {
+        hook: existsSync4(join4(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 {
+  deepMerge,
+  resolveClients,
+  detectClientSupports
+};