@fenglimg/fabric-cli 1.6.0 → 1.8.0-rc.1

package/dist/chunk-BEKSXO5N.js

@@ -1,442 +0,0 @@
-#!/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, writeFile } from "fs/promises";
-import { dirname, join, resolve } from "path";
-import { homedir } from "os";
-
-// src/config/writer.ts
-function createServerEntry(serverPath) {
-  return {
-    command: process.execPath,
-    args: [serverPath]
-  };
-}
-
-// src/config/json.ts
-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 config = await readJsonConfig(configPath);
-  const existingServers = config.mcpServers;
-  config.mcpServers = existingServers !== null && typeof existingServers === "object" && !Array.isArray(existingServers) ? { ...existingServers, fabric: serverEntry } : { fabric: serverEntry };
-  await mkdir(dirname(configPath), { recursive: true });
-  await writeFile(configPath, `${JSON.stringify(config, null, 2)}
-`, "utf8");
-}
-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));
-  }
-};
-var ClaudeCodeCLIWriter = class extends JsonClientConfigWriter {
-  clientKind = "ClaudeCodeCLI";
-  constructor(configuredPath) {
-    super(configuredPath);
-  }
-  // Writes to project-level .claude/settings.json so MCP is scoped to the project.
-  // Detection in resolver still checks ~/ 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 join(projectClaudeDir, "settings.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;
-  }
-};
-var WindsurfWriter = class extends JsonClientConfigWriter {
-  clientKind = "Windsurf";
-  constructor(configuredPath) {
-    super(configuredPath);
-  }
-  defaultPath(workspaceRoot) {
-    const windsurfDir = join(workspaceRoot, ".windsurf");
-    return existsSync(windsurfDir) ? join(windsurfDir, "mcp.json") : null;
-  }
-};
-var RooCodeWriter = class extends JsonClientConfigWriter {
-  clientKind = "RooCode";
-  constructor(configuredPath) {
-    super(configuredPath);
-  }
-  defaultPath(workspaceRoot) {
-    const rooDir = join(workspaceRoot, ".roo");
-    return existsSync(rooDir) ? join(rooDir, "mcp.json") : null;
-  }
-};
-var GeminiCLIWriter = class extends JsonClientConfigWriter {
-  clientKind = "GeminiCLI";
-  constructor(configuredPath) {
-    super(configuredPath);
-  }
-  defaultPath(workspaceRoot) {
-    const geminiDir = join(homedir(), ".gemini");
-    return existsSync(geminiDir) || existsSync(join(workspaceRoot, "GEMINI.md")) ? join(geminiDir, "settings.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]
-    });
-  }
-};
-
-// src/config/toml.ts
-import { existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, join as join3, resolve as resolve3 } from "path";
-import { homedir as homedir3 } from "os";
-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 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 writeFile2(configPath, nextConfig, "utf8");
-  }
-};
-
-// 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 = {}) {
-  const clientPaths = fabricConfig.clientPaths;
-  const writers = [];
-  addIfDetected(
-    writers,
-    existsSync4(join4(homedir4(), ".claude")) || existsSync4(join4(workspaceRoot, ".claude")),
-    (configuredPath) => new ClaudeCodeCLIWriter(configuredPath),
-    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(workspaceRoot, ".windsurf")),
-    (configuredPath) => new WindsurfWriter(configuredPath),
-    hasExplicitPath(clientPaths, "windsurf") ? clientPaths.windsurf : void 0
-  );
-  addIfDetected(
-    writers,
-    existsSync4(join4(workspaceRoot, ".roo")),
-    (configuredPath) => new RooCodeWriter(configuredPath),
-    hasExplicitPath(clientPaths, "rooCode") ? clientPaths.rooCode : void 0
-  );
-  addIfDetected(
-    writers,
-    existsSync4(join4(homedir4(), ".gemini")) || existsSync4(join4(workspaceRoot, "GEMINI.md")),
-    (configuredPath) => new GeminiCLIWriter(configuredPath),
-    hasExplicitPath(clientPaths, "geminiCLI") ? clientPaths.geminiCLI : 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 windsurfDetected = existsSync4(join4(workspaceRoot, ".windsurf"));
-  const rooDetected = existsSync4(join4(workspaceRoot, ".roo"));
-  const geminiDetected = existsSync4(join4(homedir4(), ".gemini")) || existsSync4(join4(workspaceRoot, "GEMINI.md"));
-  const codexDetected = existsSync4(join4(homedir4(), ".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: "Windsurf",
-      label: "Windsurf",
-      detected: windsurfDetected || hasExplicitPath(clientPaths, "windsurf"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
-      configPath: ".windsurf/mcp.json",
-      capabilities: {
-        bootstrap: true,
-        mcp: true,
-        hook: false,
-        skill: false
-      }
-    },
-    {
-      clientKind: "RooCode",
-      label: "Roo Code",
-      detected: rooDetected || hasExplicitPath(clientPaths, "rooCode"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
-      configPath: ".roo/mcp.json",
-      capabilities: {
-        bootstrap: true,
-        mcp: true,
-        hook: false,
-        skill: false
-      }
-    },
-    {
-      clientKind: "GeminiCLI",
-      label: "Gemini CLI",
-      detected: geminiDetected || hasExplicitPath(clientPaths, "geminiCLI"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
-      configPath: "~/.gemini/settings.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: existsSync4(join4(workspaceRoot, ".codex", "hooks.json")),
-        skill: existsSync4(join4(workspaceRoot, ".agents", "skills", "fabric-init", "SKILL.md"))
-      }
-    }
-  ];
-}
-
-export {
-  resolveClients,
-  detectClientSupports
-};

package/dist/chunk-BVTMVW5M.js

@@ -1,159 +0,0 @@
-#!/usr/bin/env node
-import {
-  resolveClients
-} from "./chunk-BEKSXO5N.js";
-import {
-  hooksCommand
-} from "./chunk-YDZJRLHL.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";
-var CLIENT_ALIASES = {
-  claude: "ClaudeCodeCLI",
-  claudecodecli: "ClaudeCodeCLI",
-  "claude-code-cli": "ClaudeCodeCLI",
-  claudecli: "ClaudeCodeCLI",
-  claudecodedesktop: "ClaudeCodeDesktop",
-  "claude-code-desktop": "ClaudeCodeDesktop",
-  claudedesktop: "ClaudeCodeDesktop",
-  cursor: "Cursor",
-  windsurf: "Windsurf",
-  roocode: "RooCode",
-  "roo-code": "RooCode",
-  roo: "RooCode",
-  geminicli: "GeminiCLI",
-  "gemini-cli": "GeminiCLI",
-  gemini: "GeminiCLI",
-  codexcli: "CodexCLI",
-  "codex-cli": "CodexCLI",
-  codex: "CodexCLI"
-};
-function parseClientFilter(value) {
-  if (value === void 0 || value.trim().length === 0) {
-    return null;
-  }
-  const clients = /* @__PURE__ */ new Set();
-  for (const rawClient of value.split(",")) {
-    const alias = rawClient.trim().toLowerCase();
-    const clientKind = CLIENT_ALIASES[alias];
-    if (clientKind === void 0) {
-      throw new Error(t("cli.config.errors.unknown-client", { client: rawClient }));
-    }
-    clients.add(clientKind);
-  }
-  return clients;
-}
-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"));
-}
-function writeStderr(message) {
-  process.stderr.write(`${message}
-`);
-}
-var configCmd = defineCommand({
-  meta: {
-    name: "config",
-    description: t("cli.config.description")
-  },
-  subCommands: {
-    hooks: hooksCommand,
-    install: defineCommand({
-      meta: {
-        name: "install",
-        description: t("cli.config.install.description")
-      },
-      args: {
-        clients: {
-          type: "string",
-          description: t("cli.config.install.args.clients.description")
-        },
-        "dry-run": {
-          type: "boolean",
-          description: t("cli.config.install.args.dry-run.description"),
-          default: false
-        }
-      },
-      async run({ args }) {
-        const selectedClients = parseClientFilter(args.clients);
-        const result = await installMcpClients(process.cwd(), {
-          clients: selectedClients === null ? void 0 : Array.from(selectedClients),
-          dryRun: args["dry-run"]
-        });
-        if (result.details.length === 0) {
-          writeStderr(t("cli.config.install.no-configs"));
-          return;
-        }
-        for (const detail of result.details) {
-          if (detail.action === "skipped") {
-            writeStderr(t("cli.config.install.no-config-path", { client: detail.client }));
-            continue;
-          }
-          if (detail.action === "dry-run" && detail.path !== null) {
-            writeStderr(t("cli.config.install.dry-run", { client: detail.client, path: detail.path }));
-            continue;
-          }
-          if (detail.path !== null) {
-            writeStderr(t("cli.config.install.wrote", { client: detail.client, path: detail.path }));
-          }
-        }
-      }
-    })
-  }
-});
-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).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 {
-  parseClientFilter,
-  configCmd,
-  config_default,
-  installMcpClients
-};