@fenglimg/fabric-cli 1.0.0 → 1.2.0

package/README.md

@@ -0,0 +1,24 @@
+# @fenglimg/fabric-cli
+
+`fabric` is the primary CLI binary for Fabric. `fab` is a permanent alias, so you can use either binary.
+
+## Quick Start
+
+1. Install dependencies from the monorepo root with `pnpm install`.
+2. Build the CLI with `pnpm --filter @fenglimg/fabric-cli build`.
+3. Run `fabric init` in the target project for the one-shot setup flow.
+4. Start `fabric serve` and verify `fab_get_rules` in your client.
+
+`fabric init` auto-runs `bootstrap install`, `config install`, and `hooks install`. Use them standalone only for targeted re-runs.
+
+## Common Commands
+
+- `fabric init`
+- `fabric serve`
+- `fabric doctor --audit`
+
+## Advanced Commands
+
+- `fabric bootstrap install`
+- `fabric config install`
+- `fabric hooks install`

package/dist/bootstrap-IUL4SAAK.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import {
+  bootstrapCommand,
+  bootstrap_default,
+  installBootstrap
+} from "./chunk-RUQCZA2Q.js";
+import "./chunk-VMYPJPKV.js";
+import "./chunk-AEOYCVBG.js";
+import "./chunk-6ICJICVU.js";
+export {
+  bootstrapCommand,
+  bootstrap_default as default,
+  installBootstrap
+};

package/dist/{chunk-5BSTO745.js → chunk-6UUPKSDE.js}

@@ -1,7 +1,4 @@
 #!/usr/bin/env node
-import {
-  resolveIgnores
-} from "./chunk-P4KVFB2T.js";
 import {
   t
 } from "./chunk-6ICJICVU.js";
@@ -10,6 +7,11 @@ import {
 import { createHash } from "crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
 import { isAbsolute, join, relative, resolve, sep } from "path";
+import {
+  agentsMetaSchema,
+  deriveAgentsMetaLayer,
+  deriveAgentsMetaTopologyType
+} from "@fenglimg/fabric-shared";
 import { defineCommand } from "citty";
 var syncMetaCommand = defineCommand({
   meta: {
@@ -55,11 +57,15 @@ function computeAgentsMeta(target) {
   const metaPath = join(target, ".fabric", "agents.meta.json");
   const existingMeta = readExistingMeta(metaPath);
   const existingByFile = indexExistingNodesByFile(existingMeta);
-  const agentsFiles = findAgentsFiles(target);
+  const agentsFiles = findFabricAgentsFiles(target);
   const nodes = {};
+  const bootstrapNode = createBootstrapNode(target, existingByFile.get("AGENTS.md")?.node);
+  if (bootstrapNode !== void 0) {
+    nodes.L0 = bootstrapNode;
+  }
   for (const file of agentsFiles) {
     const existing = existingByFile.get(file);
-    const id = existing?.id ?? deriveNodeId(file);
+    const id = deriveNodeId(file);
     const hash = sha256(readFileSync(join(target, file), "utf8"));
     const defaults = createDefaultNodeMeta(file);
     nodes[id] = {
@@ -88,15 +94,18 @@ function readExistingMeta(metaPath) {
     return void 0;
   }
   try {
-    return JSON.parse(readFileSync(metaPath, "utf8"));
+    return agentsMetaSchema.parse(JSON.parse(readFileSync(metaPath, "utf8")));
   } catch {
     return void 0;
   }
 }
-function findAgentsFiles(target) {
-  const ignorePatterns = resolveIgnores();
+function findFabricAgentsFiles(target) {
+  const agentsRoot = join(target, ".fabric", "agents");
+  if (!existsSync(agentsRoot) || !statSync(agentsRoot).isDirectory()) {
+    return [];
+  }
   const files = [];
-  const stack = [target];
+  const stack = [agentsRoot];
   while (stack.length > 0) {
     const current = stack.pop();
     if (current === void 0) {
@@ -105,31 +114,20 @@ function findAgentsFiles(target) {
     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") {
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
         files.push(relativePath);
       }
     }
   }
   return files.sort();
 }
-function shouldIgnore(relativePath, isDirectory, ignorePatterns) {
-  return ignorePatterns.some((pattern) => matchesIgnorePattern(relativePath, isDirectory, pattern));
+function deriveLayer(relativePath) {
+  return deriveAgentsMetaLayer(relativePath);
 }
-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 deriveTopologyType(relativePath) {
+  return deriveAgentsMetaTopologyType(relativePath);
 }
 function indexExistingNodesByFile(existingMeta) {
   const byFile = /* @__PURE__ */ new Map();
@@ -142,18 +140,57 @@ function deriveNodeId(file) {
   if (file === "AGENTS.md") {
     return "L0";
   }
-  return file.replace(/\/AGENTS\.md$/, "");
+  const layer = deriveLayer(file);
+  const relativeStem = getMirrorRelativeStem(file);
+  return `${layer}/${relativeStem}`;
 }
 function createDefaultNodeMeta(file) {
-  const scope = file === "AGENTS.md" ? "**" : `${file.replace(/\/AGENTS\.md$/, "")}/**`;
+  const layer = deriveLayer(file);
+  const topologyType = deriveTopologyType(file);
   return {
     file,
-    scope_glob: scope,
-    deps: file === "AGENTS.md" ? [] : ["L0"],
-    priority: file === "AGENTS.md" ? "high" : "medium",
+    scope_glob: deriveScopeGlob(file),
+    deps: layer === "L0" ? [] : ["L0"],
+    priority: layer === "L0" ? "high" : "medium",
+    layer,
+    topology_type: topologyType,
     hash: ""
   };
 }
+function createBootstrapNode(target, existing) {
+  const bootstrapPath = join(target, "AGENTS.md");
+  if (!existsSync(bootstrapPath)) {
+    return void 0;
+  }
+  const hash = sha256(readFileSync(bootstrapPath, "utf8"));
+  return {
+    ...createDefaultNodeMeta("AGENTS.md"),
+    ...existing,
+    file: "AGENTS.md",
+    hash
+  };
+}
+function deriveScopeGlob(file) {
+  if (file === "AGENTS.md") {
+    return "**";
+  }
+  const stem = getMirrorRelativeStem(file);
+  const segments = stem.split("/").filter(Boolean);
+  if (segments.length === 0 || stem === "root") {
+    return "**";
+  }
+  if (segments[0] === "_cross") {
+    return "**";
+  }
+  if (segments.at(-1) === "rules") {
+    segments.pop();
+  }
+  const scopePath = segments.join("/");
+  return scopePath === "" ? "**" : `${scopePath}/**`;
+}
+function getMirrorRelativeStem(file) {
+  return file.replace(/^\.fabric\/agents\//, "").replace(/\.md$/, "");
+}
 function sortNodes(nodes) {
   return Object.fromEntries(Object.entries(nodes).sort(([left], [right]) => left.localeCompare(right)));
 }
@@ -187,5 +224,7 @@ function sha256(content) {
 export {
   syncMetaCommand,
   sync_meta_default,
-  computeAgentsMeta
+  computeAgentsMeta,
+  deriveLayer,
+  deriveTopologyType
 };

package/dist/{config-PXEEXWLM.js → chunk-MDI7523D.js}

@@ -13,6 +13,7 @@ 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",
@@ -57,7 +58,8 @@ async function loadFabricConfig(workspaceRoot) {
   }
   return parsed;
 }
-function resolveServerPath() {
+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"));
 }
@@ -88,36 +90,66 @@ var configCmd = defineCommand({
         }
       },
       async run({ args }) {
-        const workspaceRoot = process.cwd();
-        const fabricConfig = await loadFabricConfig(workspaceRoot);
         const selectedClients = parseClientFilter(args.clients);
-        const serverPath = resolveServerPath();
-        const writers = resolveClients(workspaceRoot, fabricConfig).filter(
-          (writer) => selectedClients === null ? true : selectedClients.has(writer.clientKind)
-        );
-        if (writers.length === 0) {
+        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 writer of writers) {
-          const configPath = await writer.detect(workspaceRoot);
-          if (configPath === null) {
-            writeStderr(t("cli.config.install.no-config-path", { client: writer.clientKind }));
+        for (const detail of result.details) {
+          if (detail.action === "skipped") {
+            writeStderr(t("cli.config.install.no-config-path", { client: detail.client }));
             continue;
           }
-          if (args["dry-run"]) {
-            writeStderr(t("cli.config.install.dry-run", { client: writer.clientKind, path: configPath }));
+          if (detail.action === "dry-run" && detail.path !== null) {
+            writeStderr(t("cli.config.install.dry-run", { client: detail.client, path: detail.path }));
             continue;
           }
-          await writer.write(serverPath, workspaceRoot);
-          writeStderr(t("cli.config.install.wrote", { client: writer.clientKind, path: configPath }));
+          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 as default
+  config_default,
+  installMcpClients
 };

package/dist/{chunk-DKQ3HOTK.js → chunk-N4DCTOXW.js}

@@ -1,18 +1,15 @@
 #!/usr/bin/env node
-import {
-  createDebugLogger,
-  readFabricConfig,
-  resolveDevMode
-} from "./chunk-AEOYCVBG.js";
-import {
-  resolveIgnores
-} from "./chunk-P4KVFB2T.js";
 import {
   displayWidth,
   padEnd,
   paint,
   symbol
 } from "./chunk-WWNXR34K.js";
+import {
+  createDebugLogger,
+  readFabricConfig,
+  resolveDevMode
+} from "./chunk-AEOYCVBG.js";
 import {
   t
 } from "./chunk-6ICJICVU.js";
@@ -23,7 +20,24 @@ import { isAbsolute, join, relative, resolve, sep } from "path";
 import { defineCommand } from "citty";
 
 // src/scanner/detector.ts
-import { detectFramework } from "@fenglimg/fabric-shared";
+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
 function createScanReport(targetInput = process.cwd(), fabricConfig) {

package/dist/{bootstrap-PMIA4W6G.js → chunk-RUQCZA2Q.js}

@@ -70,24 +70,53 @@ var bootstrapCommand = defineCommand({
       async run({ args }) {
         const workspaceRoot = process.cwd();
         const selectedClients = parseClientFilter(args.clients);
-        const fabricConfig = readFabricConfig(workspaceRoot);
-        const detectedClients = detectBootstrapClients(workspaceRoot, fabricConfig);
-        const clients = selectedClients ?? detectedClients;
-        if (clients.size === 0) {
+        const result = await installBootstrap(workspaceRoot, {
+          clients: selectedClients === null ? void 0 : Array.from(selectedClients, mapBootstrapClientToClientKind)
+        });
+        if (result.details.length === 0) {
           process.stderr.write(
             `${t("cli.bootstrap.install.no-targets")}
 `
           );
           return;
         }
-        for (const client of clients) {
-          installBootstrap(client, workspaceRoot);
+        for (const detail of result.details) {
+          if (detail.action === "skipped") {
+            process.stderr.write(`${t("cli.bootstrap.install.skipped-header", { path: detail.path })}
+`);
+            continue;
+          }
+          if (detail.action === "prepended") {
+            process.stderr.write(`${t("cli.bootstrap.install.prepended", { path: detail.path })}
+`);
+            continue;
+          }
+          process.stderr.write(`${t("cli.bootstrap.install.installed", { path: detail.path })}
+`);
         }
       }
     })
   }
 });
 var bootstrap_default = bootstrapCommand;
+async function installBootstrap(target, options = {}) {
+  const workspaceRoot = resolve(target);
+  const fabricConfig = readFabricConfig(workspaceRoot);
+  const targets = resolveBootstrapTargets(workspaceRoot, fabricConfig, options.clients);
+  const installed = [];
+  const skipped = [];
+  const details = [];
+  for (const bootstrapTarget of targets) {
+    const detail = installBootstrapTarget(bootstrapTarget, workspaceRoot, options);
+    details.push(detail);
+    if (detail.action === "skipped") {
+      skipped.push(bootstrapTarget.client);
+    } else {
+      installed.push(bootstrapTarget.client);
+    }
+  }
+  return { installed, skipped, details };
+}
 function parseClientFilter(value) {
   if (value === void 0 || value.trim().length === 0) {
     return null;
@@ -103,15 +132,19 @@ function parseClientFilter(value) {
   }
   return clients;
 }
-function detectBootstrapClients(workspaceRoot, fabricConfig) {
-  const clients = /* @__PURE__ */ new Set();
-  for (const writer of resolveClients(workspaceRoot, fabricConfig)) {
-    const bootstrapClient = mapClientKind(writer.clientKind);
-    if (bootstrapClient !== null) {
-      clients.add(bootstrapClient);
+function resolveBootstrapTargets(workspaceRoot, fabricConfig, selectedClients) {
+  const targets = [];
+  const seenClients = /* @__PURE__ */ new Set();
+  const clientKinds = selectedClients ?? resolveClients(workspaceRoot, fabricConfig).map((writer) => writer.clientKind);
+  for (const clientKind of clientKinds) {
+    const bootstrapClient = mapClientKind(clientKind);
+    if (bootstrapClient === null || seenClients.has(bootstrapClient)) {
+      continue;
     }
+    seenClients.add(bootstrapClient);
+    targets.push({ client: clientKind, bootstrapClient });
   }
-  return clients;
+  return targets;
 }
 function mapClientKind(clientKind) {
   switch (clientKind) {
@@ -132,37 +165,79 @@ function mapClientKind(clientKind) {
       return null;
   }
 }
-function installBootstrap(client, workspaceRoot) {
-  const targetPath = resolve(workspaceRoot, CLIENT_TARGET_MAP[client]);
-  const templatePath = findTemplatePath(CLIENT_TEMPLATE_MAP[client]);
+function mapBootstrapClientToClientKind(client) {
+  switch (client) {
+    case "claude":
+      return "ClaudeCodeCLI";
+    case "cursor":
+      return "Cursor";
+    case "windsurf":
+      return "Windsurf";
+    case "roo":
+      return "RooCode";
+    case "gemini":
+      return "GeminiCLI";
+    case "codex":
+      return "CodexCLI";
+  }
+}
+function installBootstrapTarget(target, workspaceRoot, options) {
+  const targetPath = resolve(workspaceRoot, CLIENT_TARGET_MAP[target.bootstrapClient]);
+  const templatePath = findTemplatePath(CLIENT_TEMPLATE_MAP[target.bootstrapClient]);
   const template = readFileSync(templatePath, "utf8");
   mkdirSync(dirname(targetPath), { recursive: true });
-  if (client === "codex") {
-    writeCodexBootstrap(targetPath, template);
-    return;
+  if (target.bootstrapClient === "codex") {
+    return {
+      client: target.client,
+      path: targetPath,
+      action: writeCodexBootstrap(targetPath, template, options.force)
+    };
   }
+  const existed = existsSync(targetPath);
   writeFileSync(targetPath, ensureTrailingNewline(template), "utf8");
-  process.stderr.write(`${t("cli.bootstrap.install.installed", { path: targetPath })}
-`);
+  return {
+    client: target.client,
+    path: targetPath,
+    action: existed ? "overwritten" : "installed"
+  };
 }
-function writeCodexBootstrap(targetPath, template) {
+function writeCodexBootstrap(targetPath, template, force) {
   const nextContent = ensureTrailingNewline(template);
   if (!existsSync(targetPath)) {
     writeFileSync(targetPath, nextContent, "utf8");
-    process.stderr.write(`${t("cli.bootstrap.install.installed", { path: targetPath })}
-`);
-    return;
+    return "installed";
   }
   const existing = readFileSync(targetPath, "utf8");
   if (existing.includes("# Fabric Bootstrap")) {
-    process.stderr.write(`${t("cli.bootstrap.install.skipped-header", { path: targetPath })}
-`);
-    return;
+    if (!force) {
+      return "skipped";
+    }
+    const remainder = stripExistingCodexBootstrap(existing, nextContent);
+    writeFileSync(targetPath, joinBootstrapSections(nextContent, remainder), "utf8");
+    return "overwritten";
   }
-  const separator = existing.startsWith("\n") || existing.length === 0 ? "" : "\n";
-  writeFileSync(targetPath, `${nextContent}${separator}${existing}`, "utf8");
-  process.stderr.write(`${t("cli.bootstrap.install.prepended", { path: targetPath })}
-`);
+  writeFileSync(targetPath, joinBootstrapSections(nextContent, existing), "utf8");
+  return force ? "overwritten" : "prepended";
+}
+function stripExistingCodexBootstrap(existing, template) {
+  if (existing.startsWith(template)) {
+    return existing.slice(template.length).replace(/^\n+/, "");
+  }
+  if (!existing.startsWith("# Fabric Bootstrap")) {
+    return existing;
+  }
+  const nextTopLevelHeadingIndex = existing.indexOf("\n# ", "# Fabric Bootstrap".length);
+  if (nextTopLevelHeadingIndex === -1) {
+    return "";
+  }
+  return existing.slice(nextTopLevelHeadingIndex + 1).replace(/^\n+/, "");
+}
+function joinBootstrapSections(header, body) {
+  if (body.trim().length === 0) {
+    return header;
+  }
+  const separator = body.startsWith("\n") ? "" : "\n";
+  return `${header}${separator}${body}`;
 }
 function ensureTrailingNewline(content) {
   return content.endsWith("\n") ? content : `${content}
@@ -194,7 +269,9 @@ function templateCandidatesFrom(start, relativePath) {
   }
   return candidates.reverse();
 }
+
 export {
   bootstrapCommand,
-  bootstrap_default as default
+  bootstrap_default,
+  installBootstrap
 };