@fenglimg/fabric-cli 1.1.0 → 1.3.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/{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
 };

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

@@ -2,6 +2,9 @@
 import {
   resolveClients
 } from "./chunk-VMYPJPKV.js";
+import {
+  hooksCommand
+} from "./chunk-YDZJRLHL.js";
 import {
   t
 } from "./chunk-6ICJICVU.js";
@@ -13,6 +16,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 +61,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"));
 }
@@ -71,6 +76,7 @@ var configCmd = defineCommand({
     description: t("cli.config.description")
   },
   subCommands: {
+    hooks: hooksCommand,
     install: defineCommand({
       meta: {
         name: "install",
@@ -88,36 +94,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-YDZJRLHL.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+import {
+  t
+} from "./chunk-6ICJICVU.js";
+
+// src/commands/hooks.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { dirname, isAbsolute, join, parse, resolve } from "path";
+import { fileURLToPath } from "url";
+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);
+        if (result.hookAction === "skipped") {
+          writeStderr(t("cli.hooks.install.hook-skipped", { path: result.hookPath }));
+        } else if (result.hookAction === "appended") {
+          writeStderr(t("cli.hooks.install.hook-appended", { path: result.hookPath }));
+        } else {
+          writeStderr(t("cli.hooks.install.hook-created", { path: result.hookPath }));
+        }
+        if (result.prepareAction === "left") {
+          writeStderr(t("cli.hooks.install.prepare-left", { path: result.packageJsonPath }));
+        } else {
+          writeStderr(t("cli.hooks.install.prepare-added", { path: result.packageJsonPath }));
+        }
+      }
+    })
+  }
+});
+var hooks_default = hooksCommand;
+async function installHooks(target, options = {}) {
+  const normalizedTarget = normalizeTarget(target);
+  assertExistingDirectory(normalizedTarget);
+  const huskyDir = join(normalizedTarget, ".husky");
+  const hookPath = join(huskyDir, "pre-commit");
+  const packageJsonPath = join(normalizedTarget, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    throw new Error(t("cli.hooks.errors.package-json-required", { path: packageJsonPath }));
+  }
+  mkdirSync(huskyDir, { recursive: true });
+  const templateContent = readFileSync(findTemplatePath("templates/husky/pre-commit"), "utf8");
+  const hookAction = installHookFile(hookPath, templateContent, options.force);
+  chmodSync(hookPath, 493);
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  const scripts = packageJson.scripts && typeof packageJson.scripts === "object" && !Array.isArray(packageJson.scripts) ? packageJson.scripts : {};
+  const hadPrepare = typeof scripts.prepare === "string" && scripts.prepare.trim().length > 0;
+  let prepareAction = "left";
+  if (!hadPrepare) {
+    scripts.prepare = "husky install";
+    packageJson.scripts = scripts;
+    writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`, "utf8");
+    prepareAction = "added";
+  }
+  const installed = [];
+  const skipped = [];
+  if (hookAction === "skipped") {
+    skipped.push(hookPath);
+  } else {
+    installed.push(hookPath);
+  }
+  if (prepareAction === "left") {
+    skipped.push(packageJsonPath);
+  } else {
+    installed.push(packageJsonPath);
+  }
+  return {
+    installed,
+    skipped,
+    hookPath,
+    packageJsonPath,
+    hookAction,
+    prepareAction
+  };
+}
+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 }));
+  }
+}
+function installHookFile(hookPath, templateContent, force) {
+  if (existsSync(hookPath)) {
+    if (force) {
+      writeFileSync(hookPath, templateContent, "utf8");
+      return "overwritten";
+    }
+    const existing = readFileSync(hookPath, "utf8");
+    if (existing.includes("FAB_BIN=")) {
+      return "skipped";
+    }
+    const fabricBlock = templateContent.replace(/^#!\/bin\/sh\n/, "");
+    const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+    writeFileSync(hookPath, `${existing}${separator}# --- Fabric ---
+${fabricBlock}`, "utf8");
+    return "appended";
+  }
+  writeFileSync(hookPath, templateContent, "utf8");
+  return "created";
+}
+function findTemplatePath(relativePath) {
+  const currentModuleDir = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    ...templateCandidatesFrom(process.cwd(), relativePath),
+    ...templateCandidatesFrom(currentModuleDir, relativePath)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(t("cli.shared.template-not-found", { path: relativePath }));
+}
+function templateCandidatesFrom(start, relativePath) {
+  const candidates = [];
+  let current = resolve(start);
+  while (true) {
+    candidates.push(join(current, ...relativePath.split("/")));
+    const parent = dirname(current);
+    if (parent === current || parse(current).root === current) {
+      break;
+    }
+    current = parent;
+  }
+  return candidates.reverse();
+}
+function writeStderr(message) {
+  process.stderr.write(`${message}
+`);
+}
+
+export {
+  hooksCommand,
+  hooks_default,
+  installHooks
+};

package/dist/config-MKWKDE32.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import {
+  configCmd,
+  config_default,
+  installMcpClients,
+  parseClientFilter
+} from "./chunk-TO5RUB4R.js";
+import "./chunk-VMYPJPKV.js";
+import "./chunk-YDZJRLHL.js";
+import "./chunk-6ICJICVU.js";
+export {
+  configCmd,
+  config_default as default,
+  installMcpClients,
+  parseClientFilter
+};

package/dist/hooks-ZSWVH2JD.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import {
+  hooksCommand,
+  hooks_default,
+  installHooks
+} from "./chunk-YDZJRLHL.js";
+import "./chunk-6ICJICVU.js";
+export {
+  hooks_default as default,
+  hooksCommand,
+  installHooks
+};

package/dist/index.js

@@ -1,7 +1,4 @@
 #!/usr/bin/env node
-import {
-  t
-} from "./chunk-6ICJICVU.js";
 
 // src/index.ts
 import { realpathSync } from "fs";
@@ -11,25 +8,32 @@ import { defineCommand, runMain } from "citty";
 
 // src/commands/index.ts
 var allCommands = {
-  bootstrap: () => import("./bootstrap-PMIA4W6G.js").then((module) => module.default),
-  doctor: () => import("./doctor-QTSG2RWF.js").then((module) => module.default),
-  init: () => import("./init-R73E5YTG.js").then((module) => module.default),
-  scan: () => import("./scan-JBGFRB7P.js").then((module) => module.default),
-  serve: () => import("./serve-4J2CQY25.js").then((module) => module.default),
+  init: () => import("./init-BZ73IUHH.js").then((module) => module.default),
+  update: () => import("./update-JZPUJ36D.js").then((module) => module.default),
+  scan: () => import("./scan-WKDSKEBB.js").then((module) => module.default),
+  serve: () => import("./serve-MMN4GYLM.js").then((module) => module.default),
+  doctor: () => import("./doctor-5KJGOV2P.js").then((module) => module.default),
   "sync-meta": () => import("./sync-meta-THZSEM7Y.js").then((module) => module.default),
   "human-lint": () => import("./human-lint-YSFOZHZ7.js").then((module) => module.default),
   "ledger-append": () => import("./ledger-append-XZ5SX4O5.js").then((module) => module.default),
-  hooks: () => import("./hooks-5S5IRVQE.js").then((module) => module.default),
-  config: () => import("./config-PXEEXWLM.js").then((module) => module.configCmd),
-  "pre-commit": () => import("./pre-commit-BLSUMT3P.js").then((module) => module.default)
+  "pre-commit": () => import("./pre-commit-AK55G73F.js").then((module) => module.default),
+  bootstrap: () => import("./bootstrap-IUL4SAAK.js").then((module) => module.default),
+  config: () => import("./config-MKWKDE32.js").then((module) => module.configCmd),
+  hooks: () => import("./hooks-ZSWVH2JD.js").then((module) => ({
+    ...module.default,
+    meta: {
+      ...module.default.meta,
+      hidden: true
+    }
+  }))
 };
 
 // src/index.ts
 var main = defineCommand({
   meta: {
-    name: "fab",
-    version: "1.1.0",
-    description: t("cli.main.description")
+    name: "fabric",
+    version: "1.3.0",
+    description: 'Initialize and manage Fabric projects. Use "fabric init" for one-shot setup.'
   },
   subCommands: allCommands
 });