@fenglimg/fabric-cli 1.1.0 → 1.3.0

package/dist/{init-R73E5YTG.js → init-BZ73IUHH.js}

@@ -1,22 +1,33 @@
 #!/usr/bin/env node
+import {
+  installBootstrap
+} from "./chunk-RUQCZA2Q.js";
 import {
   createScanReport,
   detectFramework
-} from "./chunk-JWUO6TIS.js";
+} from "./chunk-N4DCTOXW.js";
 import {
-  createDebugLogger,
-  resolveDevMode
-} from "./chunk-AEOYCVBG.js";
+  installMcpClients
+} from "./chunk-TO5RUB4R.js";
+import "./chunk-VMYPJPKV.js";
+import {
+  installHooks
+} from "./chunk-YDZJRLHL.js";
 import {
   paint
 } from "./chunk-WWNXR34K.js";
+import {
+  createDebugLogger,
+  resolveDevMode
+} from "./chunk-AEOYCVBG.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.3.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/pre-commit-AK55G73F.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+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";
+
+// src/commands/pre-commit.ts
+import { execSync } from "child_process";
+import { readFileSync } from "fs";
+import { join } from "path";
+import process from "process";
+import { agentsMetaSchema } from "@fenglimg/fabric-shared";
+import { defineCommand } from "citty";
+import { minimatch } from "minimatch";
+async function runOrFail(name, cmd, args) {
+  try {
+    await cmd.run?.({ args });
+  } catch (err) {
+    process.stderr.write(
+      `${t("cli.pre-commit.run-failed", { name, message: err.message })}
+`
+    );
+    process.exit(1);
+  }
+}
+function getStagedFiles(target) {
+  try {
+    const output = execSync("git diff --cached --name-only --no-renames", {
+      cwd: target,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function tryReadAgentsMeta(target) {
+  const metaPath = join(target, ".fabric", "agents.meta.json");
+  try {
+    const raw = readFileSync(metaPath, "utf8");
+    return agentsMetaSchema.parse(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+function matchesFabricScope(stagedFiles, meta) {
+  const scopeGlobs = Object.values(meta.nodes).filter((node) => node.file !== "AGENTS.md").map((node) => node.scope_glob);
+  return stagedFiles.some(
+    (file) => file === "AGENTS.md" || file === ".fabric/agents.meta.json" || file === ".fabric/human-lock.json" || file === ".intent-ledger.jsonl" || scopeGlobs.some((pattern) => minimatch(file, pattern, { dot: true }))
+  );
+}
+var pre_commit_default = defineCommand({
+  meta: {
+    name: "pre-commit",
+    description: t("cli.pre-commit.description")
+  },
+  args: {
+    target: {
+      type: "string",
+      description: t("cli.pre-commit.args.target.description")
+    }
+  },
+  async run({ args }) {
+    const target = resolveDevModeTarget(args.target);
+    const stagedFiles = getStagedFiles(target);
+    const meta = tryReadAgentsMeta(target);
+    if (stagedFiles.length > 0 && meta !== null && !matchesFabricScope(stagedFiles, meta)) {
+      process.stderr.write("No fabric-managed files staged, skipping checks\n");
+      return;
+    }
+    await runOrFail("sync-meta --check-only", sync_meta_default, {
+      target,
+      "check-only": true
+    });
+    await runOrFail("human-lint", human_lint_default, { target });
+    await runOrFail("ledger-append --staged", ledger_append_default, {
+      target,
+      staged: true
+    });
+  }
+});
+export {
+  pre_commit_default as default
+};

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,