@fenglimg/fabric-cli 0.1.0

package/dist/chunk-LHPBYOF5.js

@@ -0,0 +1,293 @@
+// 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);
+  }
+  defaultPath() {
+    const claudeDir = join(homedir(), ".claude");
+    return existsSync(claudeDir) ? join(claudeDir, "settings.json") : null;
+  }
+};
+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";
+import * as TOML from "@iarna/toml";
+function expandHome2(filePath) {
+  if (filePath === "~") {
+    return homedir3();
+  }
+  if (filePath.startsWith("~/")) {
+    return join3(homedir3(), filePath.slice(2));
+  }
+  return filePath;
+}
+function asObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+async function readTomlConfig(configPath) {
+  try {
+    const raw = await readFile2(configPath, "utf8");
+    if (raw.trim().length === 0) {
+      return {};
+    }
+    return TOML.parse(raw);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+}
+function mergeCodexServer(config, serverEntry) {
+  const mcp = asObject(config.mcp);
+  const servers = asObject(mcp.servers);
+  servers.fabric = serverEntry;
+  mcp.servers = servers;
+  config.mcp = mcp;
+  return config;
+}
+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 config = mergeCodexServer(await readTomlConfig(configPath), createServerEntry(serverPath));
+    await mkdir2(dirname2(configPath), { recursive: true });
+    await writeFile2(configPath, TOML.stringify(config), "utf8");
+  }
+};
+
+// src/config/resolver.ts
+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")),
+    (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;
+}
+
+export {
+  resolveClients
+};

package/dist/chunk-QK6XBP6I.js

@@ -0,0 +1,187 @@
+import {
+  resolveIgnores
+} from "./chunk-ZTNSMODH.js";
+
+// src/commands/sync-meta.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { isAbsolute, join, relative, resolve, sep } from "path";
+import { defineCommand } from "citty";
+var syncMetaCommand = defineCommand({
+  meta: {
+    name: "sync-meta",
+    description: "Sync Fabric metadata from AGENTS.md files."
+  },
+  args: {
+    target: {
+      type: "string",
+      description: "Target project path. Defaults to the current working directory.",
+      default: process.cwd()
+    },
+    "check-only": {
+      type: "boolean",
+      description: "Exit with code 1 if .fabric/agents.meta.json is stale.",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const target = normalizeTarget(args.target);
+    const metaPath = join(target, ".fabric", "agents.meta.json");
+    const computedMeta = computeAgentsMeta(target);
+    const existingMeta = readExistingMeta(metaPath);
+    if (args["check-only"]) {
+      if (!existingMeta || stableStringify(existingMeta) !== stableStringify(computedMeta)) {
+        writeStderr("Fabric metadata drift detected. Run fab sync-meta to update.");
+        process.exitCode = 1;
+      }
+      return;
+    }
+    if (existingMeta && stableStringify(existingMeta) === stableStringify(computedMeta)) {
+      return;
+    }
+    mkdirSync(join(target, ".fabric"), { recursive: true });
+    writeFileSync(metaPath, `${JSON.stringify(computedMeta, null, 2)}
+`, "utf8");
+    writeStderr(`Updated ${metaPath}`);
+  }
+});
+var sync_meta_default = syncMetaCommand;
+function computeAgentsMeta(target) {
+  assertExistingDirectory(target);
+  const metaPath = join(target, ".fabric", "agents.meta.json");
+  const existingMeta = readExistingMeta(metaPath);
+  const existingByFile = indexExistingNodesByFile(existingMeta);
+  const agentsFiles = findAgentsFiles(target);
+  const nodes = {};
+  for (const file of agentsFiles) {
+    const existing = existingByFile.get(file);
+    const id = existing?.id ?? deriveNodeId(file);
+    const hash = sha256(readFileSync(join(target, file), "utf8"));
+    const defaults = createDefaultNodeMeta(file);
+    nodes[id] = {
+      ...defaults,
+      ...existing?.node,
+      file,
+      hash
+    };
+  }
+  return {
+    ...existingMeta ?? {},
+    revision: computeRevision(nodes),
+    nodes: sortNodes(nodes)
+  };
+}
+function normalizeTarget(targetInput) {
+  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
+}
+function assertExistingDirectory(target) {
+  if (!existsSync(target) || !statSync(target).isDirectory()) {
+    throw new Error(`Target must be an existing directory: ${target}`);
+  }
+}
+function readExistingMeta(metaPath) {
+  if (!existsSync(metaPath)) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(readFileSync(metaPath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function findAgentsFiles(target) {
+  const ignorePatterns = resolveIgnores();
+  const files = [];
+  const stack = [target];
+  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(target, absolutePath));
+      if (shouldIgnore(relativePath, entry.isDirectory(), ignorePatterns)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        stack.push(absolutePath);
+      } else if (entry.isFile() && entry.name === "AGENTS.md") {
+        files.push(relativePath);
+      }
+    }
+  }
+  return files.sort();
+}
+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 indexExistingNodesByFile(existingMeta) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const [id, node] of Object.entries(existingMeta?.nodes ?? {})) {
+    byFile.set(toPosixPath(node.file), { id, node });
+  }
+  return byFile;
+}
+function deriveNodeId(file) {
+  if (file === "AGENTS.md") {
+    return "L0";
+  }
+  return file.replace(/\/AGENTS\.md$/, "");
+}
+function createDefaultNodeMeta(file) {
+  const scope = file === "AGENTS.md" ? "**" : `${file.replace(/\/AGENTS\.md$/, "")}/**`;
+  return {
+    file,
+    scope_glob: scope,
+    deps: file === "AGENTS.md" ? [] : ["L0"],
+    priority: file === "AGENTS.md" ? "high" : "medium",
+    hash: ""
+  };
+}
+function sortNodes(nodes) {
+  return Object.fromEntries(Object.entries(nodes).sort(([left], [right]) => left.localeCompare(right)));
+}
+function computeRevision(nodes) {
+  const hashes = Object.values(sortNodes(nodes)).map((node) => node.hash).join("");
+  return sha256(hashes);
+}
+function writeStderr(message) {
+  process.stderr.write(`${message}
+`);
+}
+function stableStringify(value) {
+  return JSON.stringify(value, Object.keys(flattenKeys(value)).sort());
+}
+function flattenKeys(value, keys = {}) {
+  if (value && typeof value === "object") {
+    for (const [key, child] of Object.entries(value)) {
+      keys[key] = true;
+      flattenKeys(child, keys);
+    }
+  }
+  return keys;
+}
+function toPosixPath(path) {
+  return path.split(sep).join("/");
+}
+function sha256(content) {
+  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+
+export {
+  syncMetaCommand,
+  sync_meta_default,
+  computeAgentsMeta
+};