@fenglimg/fabric-cli 1.0.0 → 1.2.0

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/doctor-5KJGOV2P.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import {
+  padEnd,
+  paint,
+  symbol
+} from "./chunk-WWNXR34K.js";
+import {
+  resolveDevMode
+} from "./chunk-AEOYCVBG.js";
+import {
+  t
+} from "./chunk-6ICJICVU.js";
+
+// src/commands/doctor.ts
+import { defineCommand } from "citty";
+import { runDoctorAuditReport, runDoctorReport } from "@fenglimg/fabric-server";
+var DEFAULT_AUDIT_WINDOW_MINUTES = 5;
+var doctorCommand = defineCommand({
+  meta: {
+    name: "doctor",
+    description: t("cli.doctor.description")
+  },
+  args: {
+    target: {
+      type: "string",
+      description: t("cli.doctor.args.target.description")
+    },
+    audit: {
+      type: "boolean",
+      description: t("cli.doctor.args.audit.description"),
+      default: false
+    },
+    "window-minutes": {
+      type: "string",
+      description: t("cli.doctor.args.window-minutes.description"),
+      default: String(DEFAULT_AUDIT_WINDOW_MINUTES)
+    }
+  },
+  async run({ args }) {
+    const workspaceRoot = process.cwd();
+    const resolution = resolveDevMode(args.target, workspaceRoot);
+    const report = await runDoctorReport(resolution.target);
+    writeStdout(`${renderStatus(report.status)} ${paint.ai("fab doctor")} ${paint.human(resolution.target)}`);
+    for (const check of report.checks) {
+      writeStdout(`${renderStatus(check.status)} ${check.name}: ${check.message}`);
+    }
+    if (!args.audit) {
+      return;
+    }
+    const auditReport = await runDoctorAuditReport(resolution.target, {
+      force: true,
+      windowMs: parseWindowMinutes(args["window-minutes"])
+    });
+    if (auditReport.mode === "off") {
+      writeStderr(t("cli.doctor.audit.preview-only"));
+    }
+    if (auditReport.checkedPathCount === 0) {
+      writeStderr(t("cli.doctor.audit.none"));
+      return;
+    }
+    if (auditReport.violationCount === 0) {
+      writeStderr(
+        `${symbol.ok} ${t("cli.doctor.audit.clean", {
+          count: String(auditReport.checkedPathCount),
+          window: formatDuration(auditReport.windowMs)
+        })}`
+      );
+      return;
+    }
+    const writer = auditReport.mode === "strict" ? console.error : console.warn;
+    writer(
+      t("cli.doctor.audit.violations", {
+        count: String(auditReport.violationCount),
+        window: formatDuration(auditReport.windowMs)
+      })
+    );
+    writeStderr(
+      `${padEnd(t("cli.doctor.audit.table.path"), 32)} ${padEnd(t("cli.doctor.audit.table.edit"), 22)} ${padEnd(t("cli.doctor.audit.table.rules"), 22)} ${t("cli.doctor.audit.table.intent")}`
+    );
+    for (const violation of auditReport.violations) {
+      writeStderr(
+        `${padEnd(violation.path, 32)} ${padEnd(new Date(violation.editTs).toISOString(), 22)} ${padEnd(formatRulesTs(violation.lastGetRulesTs), 22)} ${violation.intent}`
+      );
+    }
+    if (auditReport.mode === "strict") {
+      process.exitCode = 1;
+    }
+  }
+});
+var doctor_default = doctorCommand;
+function renderStatus(status) {
+  if (status === "ok") {
+    return symbol.ok;
+  }
+  if (status === "warn") {
+    return symbol.warn;
+  }
+  return symbol.error;
+}
+function parseWindowMinutes(value) {
+  const minutes = Number.parseInt(value ?? String(DEFAULT_AUDIT_WINDOW_MINUTES), 10);
+  if (!Number.isInteger(minutes) || minutes < 1) {
+    throw new Error(t("cli.doctor.errors.invalid-window", { value: value ?? "<unset>" }));
+  }
+  return minutes * 60 * 1e3;
+}
+function formatDuration(durationMs) {
+  const minutes = Math.max(Math.floor(durationMs / (60 * 1e3)), 1);
+  return `${minutes}m`;
+}
+function formatRulesTs(value) {
+  return value === null ? t("cli.shared.none") : new Date(value).toISOString();
+}
+function writeStdout(message) {
+  process.stdout.write(`${message}
+`);
+}
+function writeStderr(message) {
+  process.stderr.write(`${message}
+`);
+}
+export {
+  doctor_default as default,
+  doctorCommand
+};

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,24 +8,43 @@ import { defineCommand, runMain } from "citty";
 
 // src/commands/index.ts
 var allCommands = {
-  bootstrap: () => import("./bootstrap-PMIA4W6G.js").then((module) => module.default),
-  init: () => import("./init-G6Q3OOMC.js").then((module) => module.default),
-  scan: () => import("./scan-6CURGC3D.js").then((module) => module.default),
-  serve: () => import("./serve-4J2CQY25.js").then((module) => module.default),
-  "sync-meta": () => import("./sync-meta-L6M4AEUT.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-IEIXHKOD.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.0.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
 });