@fenglimg/fabric-cli 1.1.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/{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/{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/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-3JBB77TX.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import {
+  configCmd,
+  config_default,
+  installMcpClients,
+  parseClientFilter
+} from "./chunk-MDI7523D.js";
+import "./chunk-VMYPJPKV.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,43 @@ 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-3FPLOABB.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-CJ7EDKJK.js").then((module) => module.default),
+  bootstrap: () => import("./bootstrap-IUL4SAAK.js").then((module) => ({
+    ...module.default,
+    meta: {
+      ...module.default.meta,
+      hidden: true
+    }
+  })),
+  config: () => import("./config-3JBB77TX.js").then((module) => ({
+    ...module.configCmd,
+    meta: {
+      ...module.configCmd.meta,
+      hidden: true
+    }
+  })),
+  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.2.0",
+    description: 'Initialize and manage Fabric projects. Use "fabric init" for one-shot setup.'
   },
   subCommands: allCommands
 });

package/dist/{init-R73E5YTG.js → init-3FPLOABB.js}

@@ -1,22 +1,33 @@
 #!/usr/bin/env node
+import {
+  installBootstrap
+} from "./chunk-RUQCZA2Q.js";
+import {
+  installMcpClients
+} from "./chunk-MDI7523D.js";
+import "./chunk-VMYPJPKV.js";
+import {
+  installHooks
+} from "./chunk-YDZJRLHL.js";
 import {
   createScanReport,
   detectFramework
-} from "./chunk-JWUO6TIS.js";
+} from "./chunk-N4DCTOXW.js";
+import {
+  paint
+} from "./chunk-WWNXR34K.js";
 import {
   createDebugLogger,
   resolveDevMode
 } from "./chunk-AEOYCVBG.js";
-import {
-  paint
-} from "./chunk-WWNXR34K.js";
 import {
   t
 } from "./chunk-6ICJICVU.js";
 
 // src/commands/init.ts
 import { createHash } from "crypto";
-import { chmodSync, copyFileSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, renameSync, statSync as statSync2, writeFileSync } from "fs";
+import * as childProcess from "child_process";
+import { chmodSync, copyFileSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, renameSync, rmSync, statSync as statSync2, writeFileSync } from "fs";
 import { dirname, isAbsolute as isAbsolute2, join as join2, parse, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 import { defineCommand } from "citty";
@@ -841,7 +852,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "1.1.0" : "unknown";
+  return true ? "1.2.0" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -859,6 +870,8 @@ var AGENTS_TEMPLATE_BY_FRAMEWORK = {
 var CLAUDE_INIT_SKILL_TEMPLATE = "templates/claude-skills/agents-md-init/SKILL.md";
 var CLAUDE_INIT_REMINDER_HOOK_TEMPLATE = "templates/claude-hooks/agents-md-init-reminder.cjs";
 var CLAUDE_INIT_REMINDER_COMMAND = ".claude/hooks/agents-md-init-reminder.cjs";
+var LOCAL_FABRIC_SERVER_PATH = join2("node_modules", "@fenglimg", "fabric-server", "dist", "index.js");
+var FABRIC_SERVER_PACKAGE = "@fenglimg/fabric-server";
 var initCommand = defineCommand({
   meta: {
     name: "init",
@@ -873,44 +886,148 @@ var initCommand = defineCommand({
       type: "boolean",
       description: t("cli.init.args.debug.description"),
       default: false
+    },
+    force: {
+      type: "boolean",
+      description: t("cli.init.args.force.description"),
+      default: false
+    },
+    bootstrap: {
+      type: "boolean",
+      default: true,
+      negativeDescription: t("cli.init.args.no-bootstrap.description")
+    },
+    mcp: {
+      type: "boolean",
+      default: true,
+      negativeDescription: t("cli.init.args.no-mcp.description")
+    },
+    hooks: {
+      type: "boolean",
+      default: true,
+      negativeDescription: t("cli.init.args.no-hooks.description")
+    },
+    "mcp-install": {
+      type: "string",
+      default: "global",
+      description: t("cli.init.mcp.install.prompt")
     }
   },
   async run({ args }) {
     const logger = createDebugLogger(args.debug);
     const resolution = resolveDevMode(args.target, process.cwd());
     const target = normalizeTarget2(resolution.target);
+    const mcpInstallMode = resolveMcpInstallMode(args["mcp-install"]);
+    const options = {
+      force: args.force,
+      skipBootstrap: args.bootstrap === false ? true : args.skipBootstrap,
+      skipMcp: args.mcp === false ? true : args.skipMcp,
+      skipHooks: args.hooks === false ? true : args.skipHooks
+    };
     logger(`init target source: ${resolution.source}`);
     for (const step of resolution.chain) {
       logger(step);
     }
-    const created = initFabric(target);
-    console.log(t("cli.init.created-path", { label: createdLabel(), path: created.agentsPath }));
-    console.log(t("cli.init.created-path", { label: createdLabel(), path: created.metaPath }));
-    console.log(t("cli.init.created-path", { label: createdLabel(), path: created.humanLockPath }));
-    console.log(t("cli.init.created-path", { label: createdLabel(), path: created.forensicPath }));
+    if (options.force) {
+      writeStderr(t("cli.init.force.warning", { path: target }));
+    }
+    const created = initFabric(target, options);
+    console.log(formatInitPathAction(created.agentsPath, created.agentsAction));
+    console.log(formatInitPathAction(created.metaPath, created.metaAction));
+    console.log(formatInitPathAction(created.humanLockPath, created.humanLockAction));
+    console.log(formatInitPathAction(created.forensicPath, created.forensicAction));
     writeStderr(
-      created.claudeSkillAction === "created" ? t("cli.init.created-path", { label: createdLabel(), path: created.claudeSkillPath }) : t("cli.init.skipped-existing-path", { label: skippedLabel(), path: created.claudeSkillPath })
+      formatOptionalInitPathAction(created.claudeSkillPath, created.claudeSkillAction)
     );
     writeStderr(
-      created.claudeHookAction === "created" ? t("cli.init.created-path", { label: createdLabel(), path: created.claudeHookPath }) : t("cli.init.skipped-existing-path", { label: skippedLabel(), path: created.claudeHookPath })
+      formatOptionalInitPathAction(created.claudeHookPath, created.claudeHookAction)
     );
     writeStderr(formatClaudeSettingsAction(created.claudeSettingsPath, created.claudeSettingsAction));
-    console.log(
-      t("cli.init.next-step", {
-        label: nextLabel(),
-        message: paint.muted(t("cli.init.next-step.message"))
-      })
-    );
+    const stageResults = [];
+    if (options.skipBootstrap) {
+      stageResults.push({ name: "bootstrap", disposition: "skipped" });
+    } else {
+      console.log(formatInitStageHeader(t("cli.init.stages.bootstrap")));
+      try {
+        const result = await installBootstrap(target, { force: options.force });
+        if (result.details.length === 0) {
+          console.log(formatInitStageResult("bootstrap", "skipped", 0, 0, t("cli.bootstrap.install.no-targets")));
+          stageResults.push({ name: "bootstrap", disposition: "skipped" });
+        } else {
+          console.log(
+            formatInitStageResult("bootstrap", "completed", result.installed.length, result.skipped.length)
+          );
+          stageResults.push({ name: "bootstrap", disposition: "ran" });
+        }
+      } catch (error) {
+        writeStderr(formatInitStageFailure("bootstrap", error));
+        stageResults.push({ name: "bootstrap", disposition: "failed" });
+      }
+    }
+    if (options.skipMcp) {
+      stageResults.push({ name: "mcp", disposition: "skipped" });
+    } else {
+      console.log(formatInitStageHeader(t("cli.init.stages.mcp")));
+      try {
+        let localServerPath;
+        if (mcpInstallMode === "local") {
+          const manager = detectPackageManager(target);
+          writeStderr(t("cli.init.mcp.install.local"));
+          writeStderr(t("cli.init.mcp.local.installing", { manager }));
+          installLocalFabricServer(target, manager);
+          writeStderr(t("cli.init.mcp.local.installed"));
+          localServerPath = LOCAL_FABRIC_SERVER_PATH;
+        } else {
+          writeStderr(t("cli.init.mcp.install.global"));
+        }
+        const result = await installMcpClients(target, {
+          force: options.force,
+          localServerPath
+        });
+        if (result.details.length === 0) {
+          console.log(formatInitStageResult("mcp", "skipped", 0, 0, t("cli.config.install.no-configs")));
+          stageResults.push({ name: "mcp", disposition: "skipped" });
+        } else {
+          console.log(formatInitStageResult("mcp", "completed", result.installed.length, result.skipped.length));
+          stageResults.push({ name: "mcp", disposition: "ran" });
+        }
+      } catch (error) {
+        writeStderr(formatInitStageFailure("mcp", error));
+        stageResults.push({ name: "mcp", disposition: "failed" });
+      }
+    }
+    if (options.skipHooks) {
+      stageResults.push({ name: "hooks", disposition: "skipped" });
+    } else {
+      console.log(formatInitStageHeader(t("cli.init.stages.hooks")));
+      try {
+        const result = await installHooks(target, { force: options.force });
+        console.log(formatInitStageResult("hooks", "completed", result.installed.length, result.skipped.length));
+        stageResults.push({ name: "hooks", disposition: "ran" });
+      } catch (error) {
+        writeStderr(formatInitStageFailure("hooks", error));
+        stageResults.push({ name: "hooks", disposition: "failed" });
+      }
+    }
+    if (shouldPrintHooksNextStep(options, stageResults)) {
+      console.log(
+        t("cli.init.next-step", {
+          label: nextLabel(),
+          message: paint.muted(t("cli.init.next-step.message"))
+        })
+      );
+    }
     console.log(
       t("cli.init.reason-message", {
         label: reasonLabel(),
         message: paint.muted(t("cli.init.reason-message.body"))
       })
     );
+    printInitStageSummary(stageResults);
   }
 });
 var init_default = initCommand;
-function initFabric(target) {
+function initFabric(target, options) {
   assertExistingDirectory2(target);
   const agentsPath = join2(target, "AGENTS.md");
   const fabricDir = join2(target, ".fabric");
@@ -918,15 +1035,10 @@ function initFabric(target) {
   const claudeSkillPath = join2(target, ".claude", "skills", "agents-md-init", "SKILL.md");
   const claudeHookPath = join2(target, ".claude", "hooks", "agents-md-init-reminder.cjs");
   const claudeSettingsPath = join2(target, ".claude", "settings.json");
-  if (existsSync2(forensicPath)) {
-    throw new Error(`ABORT: ${forensicPath} already exists. fab init is non-destructive.`);
-  }
-  if (existsSync2(agentsPath)) {
-    throw new Error(`ABORT: ${agentsPath} already exists. fab init is non-destructive.`);
-  }
-  if (existsSync2(fabricDir)) {
-    throw new Error(`ABORT: ${fabricDir} already exists. fab init is non-destructive.`);
-  }
+  const forensicGuardAction = prepareFreshPath(forensicPath, options);
+  const agentsAction = prepareFreshPath(agentsPath, options);
+  const fabricDirAction = prepareFreshPath(fabricDir, options);
+  const forensicAction = forensicGuardAction === "overwritten" || fabricDirAction === "overwritten" ? "overwritten" : "created";
   const scanReport = createScanReport(target);
   const forensicReport = buildForensicReport(target);
   const template = readFileSync2(findAgentsTemplatePath(scanReport.framework.kind), "utf8");
@@ -938,24 +1050,29 @@ function initFabric(target) {
   const metaPath = join2(fabricDir, "agents.meta.json");
   const humanLockPath = join2(fabricDir, "human-lock.json");
   mkdirSync(fabricDir, { recursive: false });
-  writeNewFile(agentsPath, agentsContent);
+  writeNewFile(agentsPath, agentsContent, options);
   writeNewFile(metaPath, `${JSON.stringify(meta, null, 2)}
-`);
+`, options);
   writeNewFile(humanLockPath, humanLockTemplate.endsWith("\n") ? humanLockTemplate : `${humanLockTemplate}
-`);
+`, options);
   writeNewFile(forensicPath, `${JSON.stringify(forensicReport, null, 2)}
-`);
-  const claudeSkillAction = copyTemplateIfMissing(findTemplatePath(CLAUDE_INIT_SKILL_TEMPLATE), claudeSkillPath);
+`, options);
+  const claudeSkillAction = copyTemplateIfMissing(findTemplatePath(CLAUDE_INIT_SKILL_TEMPLATE), claudeSkillPath, options);
   const claudeHookAction = copyExecutableTemplateIfMissing(
     findTemplatePath(CLAUDE_INIT_REMINDER_HOOK_TEMPLATE),
-    claudeHookPath
+    claudeHookPath,
+    options
   );
-  const claudeSettingsAction = mergeClaudeStopHook(claudeSettingsPath);
+  const claudeSettingsAction = mergeClaudeStopHook(claudeSettingsPath, options);
   return {
     agentsPath,
+    agentsAction,
     metaPath,
+    metaAction: fabricDirAction,
     humanLockPath,
+    humanLockAction: fabricDirAction,
     forensicPath,
+    forensicAction,
     claudeSkillPath,
     claudeSkillAction,
     claudeHookPath,
@@ -976,6 +1093,34 @@ function assertExistingDirectory2(target) {
     throw new Error(`Target must be an existing directory: ${target}`);
   }
 }
+function detectPackageManager(cwd) {
+  const workspaceRoot = resolve2(cwd);
+  if (existsSync2(join2(workspaceRoot, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync2(join2(workspaceRoot, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (existsSync2(join2(workspaceRoot, "package-lock.json"))) {
+    return "npm";
+  }
+  return "npm";
+}
+function resolveMcpInstallMode(rawMode) {
+  if (rawMode === void 0 || rawMode === "global" || rawMode === "local") {
+    return rawMode ?? "global";
+  }
+  writeStderr(t("cli.init.mcp.install.invalid", { value: rawMode }));
+  return "global";
+}
+function installLocalFabricServer(target, manager) {
+  const installArgs = manager === "npm" ? ["install", "-D", FABRIC_SERVER_PACKAGE] : ["add", "-D", FABRIC_SERVER_PACKAGE];
+  childProcess.execFileSync(manager, installArgs, {
+    cwd: target,
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+}
 function createInitialMeta(agentsHash) {
   return {
     revision: sha256(agentsHash),
@@ -1030,28 +1175,41 @@ function templateCandidatesFrom(start, relativePath) {
   }
   return candidates.reverse();
 }
-function writeNewFile(path, content) {
-  if (existsSync2(path)) {
-    throw new Error(`ABORT: ${path} already exists. fab init is non-destructive.`);
+function prepareFreshPath(path, options) {
+  if (!existsSync2(path)) {
+    return "created";
+  }
+  if (!options?.force) {
+    throw new Error(t("cli.init.errors.abort-existing", { path }));
+  }
+  rmSync(path, { recursive: true, force: true });
+  return "overwritten";
+}
+function writeNewFile(path, content, options) {
+  const existed = existsSync2(path);
+  if (existed && !options?.force) {
+    throw new Error(t("cli.init.errors.abort-existing", { path }));
   }
   writeFileSync(path, content, "utf8");
+  return existed ? "overwritten" : "created";
 }
-function copyTemplateIfMissing(templatePath, targetPath) {
+function copyTemplateIfMissing(templatePath, targetPath, options) {
   mkdirSync(dirname(targetPath), { recursive: true });
-  if (existsSync2(targetPath)) {
+  const existed = existsSync2(targetPath);
+  if (existed && !options?.force) {
     return "skipped";
   }
   copyFileSync(templatePath, targetPath);
-  return "created";
+  return existed ? "overwritten" : "created";
 }
-function copyExecutableTemplateIfMissing(templatePath, targetPath) {
-  const action = copyTemplateIfMissing(templatePath, targetPath);
-  if (action === "created") {
+function copyExecutableTemplateIfMissing(templatePath, targetPath, options) {
+  const action = copyTemplateIfMissing(templatePath, targetPath, options);
+  if (action !== "skipped") {
     chmodSync(targetPath, 493);
   }
   return action;
 }
-function mergeClaudeStopHook(settingsPath) {
+function mergeClaudeStopHook(settingsPath, options) {
   mkdirSync(dirname(settingsPath), { recursive: true });
   let settings;
   let action = "updated";
@@ -1083,10 +1241,12 @@ function mergeClaudeStopHook(settingsPath) {
     return "skipped-invalid";
   }
   const stopHooks = Array.isArray(stopHooksValue) ? stopHooksValue : [];
-  if (hasClaudeInitReminderHook(stopHooks)) {
+  const hasExistingFabricHook = hasClaudeInitReminderHook(stopHooks);
+  if (hasExistingFabricHook && !options?.force) {
     return "skipped";
   }
-  stopHooks.push({
+  const nextStopHooks = hasExistingFabricHook && options?.force ? removeClaudeInitReminderHook(stopHooks) : [...stopHooks];
+  nextStopHooks.push({
     matcher: "*",
     hooks: [
       {
@@ -1097,20 +1257,24 @@ function mergeClaudeStopHook(settingsPath) {
   });
   settings.hooks = {
     ...hooks,
-    Stop: stopHooks
+    Stop: nextStopHooks
   };
   writeJsonAtomically(settingsPath, settings);
-  return action;
+  return hasExistingFabricHook && options?.force ? "overwritten" : action;
 }
 function hasClaudeInitReminderHook(stopHooks) {
-  return stopHooks.some((entry) => {
-    if (!isRecord(entry) || !Array.isArray(entry.hooks)) {
-      return false;
-    }
-    return entry.hooks.some(
-      (hook) => isRecord(hook) && hook.type === "command" && typeof hook.command === "string" && hook.command.includes("agents-md-init-reminder.cjs")
-    );
-  });
+  return stopHooks.some((entry) => isClaudeInitReminderStopEntry(entry));
+}
+function removeClaudeInitReminderHook(stopHooks) {
+  return stopHooks.filter((entry) => !isClaudeInitReminderStopEntry(entry));
+}
+function isClaudeInitReminderStopEntry(entry) {
+  if (!isRecord(entry) || !Array.isArray(entry.hooks)) {
+    return false;
+  }
+  return entry.hooks.some(
+    (hook) => isRecord(hook) && hook.type === "command" && typeof hook.command === "string" && hook.command.includes("agents-md-init-reminder.cjs")
+  );
 }
 function writeJsonAtomically(path, value) {
   const tempPath = `${path}.${process.pid}.tmp`;
@@ -1127,6 +1291,8 @@ function formatClaudeSettingsAction(settingsPath, action) {
       return t("cli.init.claude-settings.created", { label: createdLabel(), path: settingsPath });
     case "updated":
       return t("cli.init.claude-settings.updated", { label: updatedLabel(), path: settingsPath });
+    case "overwritten":
+      return t("cli.init.claude-settings.updated", { label: overwrittenLabel(), path: settingsPath });
     case "skipped":
       return t("cli.init.claude-settings.skipped", { label: skippedLabel(), path: settingsPath });
     case "skipped-invalid":
@@ -1135,6 +1301,46 @@ function formatClaudeSettingsAction(settingsPath, action) {
       return t("cli.init.claude-settings.updated", { label: updatedLabel(), path: settingsPath });
   }
 }
+function formatInitStageHeader(message) {
+  return `${nextLabel()} ${paint.muted(message)}`;
+}
+function formatInitStageResult(stage, status, installedCount, skippedCount, note) {
+  const label = status === "completed" ? completedStageLabel() : skippedStageLabel();
+  const counts = `installed=${installedCount} skipped=${skippedCount}`;
+  const suffix = note ? ` ${paint.muted(`(${note})`)}` : "";
+  return `${label} ${stage}: ${counts}${suffix}`;
+}
+function formatInitStageFailure(stage, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return `${failedStageLabel()} ${stage}: ${message}`;
+}
+function printInitStageSummary(stageResults) {
+  console.log(formatInitStageSummaryLine("ran", collectInitStageNames(stageResults, "ran")));
+  console.log(formatInitStageSummaryLine("skipped", collectInitStageNames(stageResults, "skipped")));
+  console.log(formatInitStageSummaryLine("failed", collectInitStageNames(stageResults, "failed")));
+}
+function formatInitStageSummaryLine(disposition, stages) {
+  const label = disposition === "ran" ? paint.success(t("cli.init.stages.summary.ran")) : disposition === "skipped" ? paint.muted(t("cli.init.stages.summary.skipped")) : paint.error(t("cli.init.stages.summary.failed"));
+  return `${label}: ${stages.length > 0 ? stages.join(", ") : t("cli.shared.none")}`;
+}
+function collectInitStageNames(stageResults, disposition) {
+  return stageResults.filter((stage) => stage.disposition === disposition).map((stage) => stage.name);
+}
+function shouldPrintHooksNextStep(options, stageResults) {
+  return Boolean(options.skipHooks) || stageResults.some((stage) => stage.name === "hooks" && stage.disposition === "failed");
+}
+function formatInitPathAction(path, action) {
+  return t("cli.init.created-path", { label: labelForInitWriteAction(action), path });
+}
+function formatOptionalInitPathAction(path, action) {
+  if (action === "skipped") {
+    return t("cli.init.skipped-existing-path", { label: skippedLabel(), path });
+  }
+  return formatInitPathAction(path, action);
+}
+function labelForInitWriteAction(action) {
+  return action === "overwritten" ? overwrittenLabel() : createdLabel();
+}
 function createdLabel() {
   return paint.success(t("cli.shared.created"));
 }
@@ -1150,6 +1356,18 @@ function reasonLabel() {
 function updatedLabel() {
   return paint.success(t("cli.shared.updated"));
 }
+function overwrittenLabel() {
+  return paint.warn(t("cli.init.force.overwritten"));
+}
+function completedStageLabel() {
+  return paint.success(t("cli.init.stages.completed"));
+}
+function skippedStageLabel() {
+  return paint.muted(t("cli.init.stages.skipped"));
+}
+function failedStageLabel() {
+  return paint.error(t("cli.init.stages.failed"));
+}
 function writeStderr(message) {
   process.stderr.write(`${message}
 `);
@@ -1159,6 +1377,7 @@ function sha256(content) {
 }
 export {
   init_default as default,
+  detectPackageManager,
   initCommand,
   initFabric
 };

package/dist/{scan-JBGFRB7P.js → scan-WKDSKEBB.js}

@@ -3,9 +3,9 @@ import {
   createScanReport,
   scanCommand,
   scan_default
-} from "./chunk-JWUO6TIS.js";
-import "./chunk-AEOYCVBG.js";
+} from "./chunk-N4DCTOXW.js";
 import "./chunk-WWNXR34K.js";
+import "./chunk-AEOYCVBG.js";
 import "./chunk-6ICJICVU.js";
 export {
   createScanReport,

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@fenglimg/fabric-cli",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "type": "module",
   "bin": {
-    "fab": "dist/index.js"
+    "fab": "dist/index.js",
+    "fabric": "dist/index.js"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -16,8 +17,8 @@
     "citty": "^0.2.2",
     "picocolors": "^1.1.1",
     "string-width": "^7.2.0",
-    "@fenglimg/fabric-shared": "1.1.0",
-    "@fenglimg/fabric-server": "1.1.0"
+    "@fenglimg/fabric-shared": "1.2.0",
+    "@fenglimg/fabric-server": "1.2.0"
   },
   "devDependencies": {
     "@types/iarna__toml": "^2.0.5",

package/dist/hooks-5S5IRVQE.js

@@ -1,124 +0,0 @@
-#!/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 target = normalizeTarget(args.target);
-        assertExistingDirectory(target);
-        const huskyDir = join(target, ".husky");
-        const hookPath = join(huskyDir, "pre-commit");
-        const packageJsonPath = join(target, "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");
-        let hookAction;
-        if (existsSync(hookPath)) {
-          const existing = readFileSync(hookPath, "utf8");
-          if (existing.includes("FAB_BIN=")) {
-            hookAction = "skipped";
-          } else {
-            const fabricBlock = templateContent.replace(/^#!\/bin\/sh\n/, "");
-            const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-            writeFileSync(hookPath, `${existing}${separator}# --- Fabric ---
-${fabricBlock}`, "utf8");
-            hookAction = "appended";
-          }
-        } else {
-          writeFileSync(hookPath, templateContent, "utf8");
-          hookAction = "created";
-        }
-        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;
-        if (!hadPrepare) {
-          scripts.prepare = "husky install";
-          packageJson.scripts = scripts;
-          writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
-`, "utf8");
-        }
-        if (hookAction === "skipped") {
-          writeStderr(t("cli.hooks.install.hook-skipped", { path: hookPath }));
-        } else if (hookAction === "appended") {
-          writeStderr(t("cli.hooks.install.hook-appended", { path: hookPath }));
-        } else {
-          writeStderr(t("cli.hooks.install.hook-created", { path: hookPath }));
-        }
-        if (hadPrepare) {
-          writeStderr(t("cli.hooks.install.prepare-left", { path: packageJsonPath }));
-        } else {
-          writeStderr(t("cli.hooks.install.prepare-added", { path: packageJsonPath }));
-        }
-      }
-    })
-  }
-});
-var hooks_default = hooksCommand;
-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 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 {
-  hooks_default as default,
-  hooksCommand
-};

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

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
-import {
-  createDebugLogger,
-  readFabricConfig,
-  resolveDevMode
-} from "./chunk-AEOYCVBG.js";
 import {
   displayWidth,
   padEnd,
   paint,
   symbol
 } from "./chunk-WWNXR34K.js";
+import {
+  createDebugLogger,
+  readFabricConfig,
+  resolveDevMode
+} from "./chunk-AEOYCVBG.js";
 import {
   t
 } from "./chunk-6ICJICVU.js";

package/dist/{doctor-QTSG2RWF.js → doctor-5KJGOV2P.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import {
-  resolveDevMode
-} from "./chunk-AEOYCVBG.js";
 import {
   padEnd,
   paint,
   symbol
 } from "./chunk-WWNXR34K.js";
+import {
+  resolveDevMode
+} from "./chunk-AEOYCVBG.js";
 import {
   t
 } from "./chunk-6ICJICVU.js";

package/dist/{pre-commit-BLSUMT3P.js → pre-commit-CJ7EDKJK.js}

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
-import {
-  ledger_append_default
-} from "./chunk-F2BXHPM5.js";
-import {
-  resolveDevModeTarget
-} from "./chunk-AEOYCVBG.js";
 import {
   sync_meta_default
 } from "./chunk-6UUPKSDE.js";
 import {
   human_lint_default
 } from "./chunk-L43IGJ6X.js";
+import {
+  ledger_append_default
+} from "./chunk-F2BXHPM5.js";
 import "./chunk-WWNXR34K.js";
+import {
+  resolveDevModeTarget
+} from "./chunk-AEOYCVBG.js";
 import {
   t
 } from "./chunk-6ICJICVU.js";

package/dist/{serve-4J2CQY25.js → serve-MMN4GYLM.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import {
-  createDebugLogger,
-  resolveDevMode
-} from "./chunk-AEOYCVBG.js";
 import {
   paint,
   symbol
 } from "./chunk-WWNXR34K.js";
+import {
+  createDebugLogger,
+  resolveDevMode
+} from "./chunk-AEOYCVBG.js";
 import {
   t
 } from "./chunk-6ICJICVU.js";