@fenglimg/fabric-cli 1.8.0-rc.3 → 2.0.0-rc.8

package/dist/{chunk-QPCRBQ5Y.js → chunk-OBQU6NHO.js}

@@ -1,46 +1,5 @@
 #!/usr/bin/env node
 
-// src/colors.ts
-import pc from "picocolors";
-import stringWidth from "string-width";
-function isColorEnabled() {
-  return !process.env.NO_COLOR && Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY);
-}
-function colorize(painter) {
-  return (value) => isColorEnabled() ? painter(value) : value;
-}
-var paint = {
-  success: colorize(pc.green),
-  warn: colorize(pc.yellow),
-  error: colorize(pc.red),
-  drift: colorize(pc.magenta),
-  ai: colorize(pc.blue),
-  human: colorize(pc.cyan),
-  muted: colorize(pc.dim)
-};
-var symbol = {
-  get ok() {
-    return isColorEnabled() ? paint.success("\u2713") : "[ok]";
-  },
-  get warn() {
-    return isColorEnabled() ? paint.warn("!") : "[warn]";
-  },
-  get error() {
-    return isColorEnabled() ? paint.error("x") : "[error]";
-  }
-};
-function displayWidth(value) {
-  return stringWidth(value);
-}
-function padEnd(value, width, char = " ") {
-  const fill = char.length > 0 ? char : " ";
-  let result = value;
-  while (displayWidth(result) < width) {
-    result += fill;
-  }
-  return result;
-}
-
 // src/dev-mode.ts
 import { existsSync, readFileSync } from "fs";
 import { isAbsolute, join, resolve } from "path";
@@ -97,18 +56,8 @@ function formatResolutionStep(source, value) {
   return `${source}: ${value ?? "<unset>"}`;
 }
 
-// src/i18n.ts
-import { createTranslator, detectNodeLocale } from "@fenglimg/fabric-shared";
-var locale = detectNodeLocale();
-var t = createTranslator(locale);
-
 export {
-  paint,
-  symbol,
-  displayWidth,
-  padEnd,
   readFabricConfig,
   resolveDevMode,
-  createDebugLogger,
-  t
+  createDebugLogger
 };

package/dist/chunk-WWNXR34K.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+// src/colors.ts
+import pc from "picocolors";
+import stringWidth from "string-width";
+function isColorEnabled() {
+  return !process.env.NO_COLOR && Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY);
+}
+function colorize(painter) {
+  return (value) => isColorEnabled() ? painter(value) : value;
+}
+var paint = {
+  success: colorize(pc.green),
+  warn: colorize(pc.yellow),
+  error: colorize(pc.red),
+  drift: colorize(pc.magenta),
+  ai: colorize(pc.blue),
+  human: colorize(pc.cyan),
+  muted: colorize(pc.dim)
+};
+var symbol = {
+  get ok() {
+    return isColorEnabled() ? paint.success("\u2713") : "[ok]";
+  },
+  get warn() {
+    return isColorEnabled() ? paint.warn("!") : "[warn]";
+  },
+  get error() {
+    return isColorEnabled() ? paint.error("x") : "[error]";
+  }
+};
+function displayWidth(value) {
+  return stringWidth(value);
+}
+function padEnd(value, width, char = " ") {
+  const fill = char.length > 0 ? char : " ";
+  let result = value;
+  while (displayWidth(result) < width) {
+    result += fill;
+  }
+  return result;
+}
+
+export {
+  paint,
+  symbol,
+  displayWidth,
+  padEnd
+};

package/dist/doctor-T7JWODKG.js

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+import {
+  paint,
+  symbol
+} from "./chunk-WWNXR34K.js";
+import {
+  t
+} from "./chunk-6ICJICVU.js";
+import {
+  resolveDevMode
+} from "./chunk-OBQU6NHO.js";
+
+// src/commands/doctor.ts
+import { confirm, isCancel } from "@clack/prompts";
+import { defineCommand } from "citty";
+import {
+  appendEventLedgerEvent,
+  checkLockOrThrow,
+  runDoctorApplyLint,
+  runDoctorFix,
+  runDoctorReport
+} from "@fenglimg/fabric-server";
+var APPLY_LINT_CODE_LABELS = {
+  knowledge_orphan_demote_required: "demote (maturity)",
+  knowledge_stale_archive_required: "archive (git mv)",
+  knowledge_pending_auto_archive: "archive (git mv, pending)",
+  knowledge_index_drift: "counter bump (agents.meta)",
+  knowledge_session_hints_stale: "cache delete"
+};
+var PLAN_PREVIEW_LIMIT = 12;
+var doctorCommand = defineCommand({
+  meta: {
+    name: "doctor",
+    description: t("cli.doctor.description")
+  },
+  args: {
+    target: {
+      type: "string",
+      description: t("cli.doctor.args.target.description")
+    },
+    fix: {
+      type: "boolean",
+      description: t("cli.doctor.args.fix.description"),
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: t("cli.doctor.args.json.description"),
+      default: false
+    },
+    strict: {
+      type: "boolean",
+      description: t("cli.doctor.args.strict.description"),
+      default: false
+    },
+    force: {
+      type: "boolean",
+      description: t("cli.doctor.args.force.description"),
+      default: false
+    },
+    "apply-lint": {
+      type: "boolean",
+      description: t("cli.doctor.args.apply-lint.description"),
+      default: false
+    },
+    // rc.7 T11: skip the safety confirm before mutations. Required for any
+    // non-tty invocation that wants to run --apply-lint without setting
+    // FABRIC_NONINTERACTIVE=1 in the environment.
+    yes: {
+      type: "boolean",
+      description: t("cli.doctor.args.yes.description"),
+      default: false
+    }
+  },
+  async run({ args }) {
+    const workspaceRoot = process.cwd();
+    const resolution = resolveDevMode(args.target, workspaceRoot);
+    checkLockOrThrow(resolution.target, { force: args.force });
+    const applyLint = args["apply-lint"] === true;
+    const fix = args.fix === true;
+    if (applyLint && fix) {
+      writeStderr(t("cli.doctor.errors.apply-lint-fix-mutually-exclusive"));
+      process.exitCode = 1;
+      return;
+    }
+    let applyLintReport = null;
+    let fixReport = null;
+    let report;
+    if (applyLint) {
+      const preReport = await runDoctorReport(resolution.target);
+      const plan = computeApplyLintPlan(preReport);
+      const yesFlag = args.yes === true;
+      const envBypass = process.env.FABRIC_NONINTERACTIVE === "1";
+      if (plan.totalCount === 0) {
+      } else {
+        renderApplyLintPlan(plan);
+        const decision = await resolveApplyLintConsent({
+          yesFlag,
+          envBypass,
+          plan
+        });
+        if (decision === "abort") {
+          process.exitCode = 1;
+          return;
+        }
+      }
+      applyLintReport = await runDoctorApplyLint(resolution.target);
+      report = applyLintReport.report;
+    } else if (fix) {
+      fixReport = await runDoctorFix(resolution.target);
+      report = fixReport.report;
+    } else {
+      report = await runDoctorReport(resolution.target);
+    }
+    if (args.json === true) {
+      writeStdout(JSON.stringify(applyLintReport ?? fixReport ?? report, null, 2));
+    } else {
+      if (applyLintReport !== null) {
+        writeStdout(applyLintReport.message);
+        if (applyLintReport.aborted && applyLintReport.abort_reason !== void 0) {
+          writeStderr(applyLintReport.abort_reason);
+        }
+        renderApplyLintMutations(applyLintReport);
+      } else if (fixReport !== null) {
+        writeStdout(fixReport.message);
+      }
+      renderHumanReport(report);
+    }
+    await emitDoctorRunEventBestEffort(resolution.target, {
+      mode: applyLint ? "apply-lint" : "lint",
+      issues: report.fixable_errors.length + report.manual_errors.length + report.warnings.length,
+      mutations: applyLintReport !== null ? applyLintReport.mutations.filter((m) => m.applied).length : void 0
+    });
+    if (applyLintReport !== null) {
+      if (applyLintReport.aborted) {
+        process.exitCode = 1;
+        return;
+      }
+      if (applyLintReport.mutations.some((m) => !m.applied)) {
+        process.exitCode = 1;
+        return;
+      }
+    }
+    if (report.status === "error" || args.strict === true && (report.status === "warn" || report.warnings.length > 0)) {
+      process.exitCode = 1;
+    }
+  }
+});
+var doctor_default = doctorCommand;
+function renderHumanReport(report) {
+  writeStdout(`${renderStatus(report.status)} ${paint.ai("fabric doctor")} ${paint.human(report.summary.target)}`);
+  for (const check of report.checks) {
+    writeStdout(`${renderStatus(check.status)} ${check.name}: ${check.message}`);
+  }
+  writeIssueSection(t("doctor.section.fixable"), report.fixable_errors);
+  writeIssueSection(t("doctor.section.manual"), report.manual_errors);
+  writeIssueSection(t("doctor.section.warnings"), report.warnings);
+}
+function renderApplyLintMutations(applyLintReport) {
+  if (applyLintReport.mutations.length === 0) {
+    return;
+  }
+  writeStdout("");
+  writeStdout(t("doctor.section.apply-lint-mutations"));
+  for (const mutation of applyLintReport.mutations) {
+    const marker = mutation.applied ? symbol.ok : symbol.error;
+    const errSuffix = mutation.applied || mutation.error === void 0 ? "" : ` (${mutation.error})`;
+    writeStdout(`${marker} ${mutation.kind}: ${mutation.path} [${mutation.detail}]${errSuffix}`);
+  }
+}
+function writeIssueSection(title, issues) {
+  if (issues.length === 0) {
+    return;
+  }
+  writeStdout("");
+  writeStdout(title);
+  for (const issue of issues) {
+    writeStdout(`- ${issue.code}: ${issue.message}`);
+  }
+}
+function renderStatus(status) {
+  if (status === "ok") {
+    return symbol.ok;
+  }
+  if (status === "warn") {
+    return symbol.warn;
+  }
+  return symbol.error;
+}
+function writeStdout(message) {
+  process.stdout.write(`${message}
+`);
+}
+async function emitDoctorRunEventBestEffort(projectRoot, payload) {
+  try {
+    await appendEventLedgerEvent(projectRoot, {
+      event_type: "doctor_run",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      mode: payload.mode,
+      issues: payload.issues,
+      ...payload.mutations !== void 0 ? { mutations: payload.mutations } : {}
+    });
+  } catch {
+  }
+}
+function writeStderr(message) {
+  process.stderr.write(`${message}
+`);
+}
+function computeApplyLintPlan(report) {
+  const buckets = {};
+  const sources = [
+    ...report.fixable_errors,
+    ...report.warnings
+  ];
+  for (const issue of sources) {
+    if (APPLY_LINT_CODE_LABELS[issue.code] === void 0) continue;
+    if (!Array.isArray(buckets[issue.code])) {
+      buckets[issue.code] = [];
+    }
+    buckets[issue.code].push(issue);
+  }
+  const codes = Object.keys(buckets).sort(
+    (a, b) => APPLY_LINT_CODE_LABELS[a].localeCompare(APPLY_LINT_CODE_LABELS[b])
+  );
+  const perCodeLines = [];
+  let totalCount = 0;
+  for (const code of codes) {
+    const items = buckets[code];
+    totalCount += items.length;
+    perCodeLines.push(`  - ${APPLY_LINT_CODE_LABELS[code]}: ${items.length}`);
+  }
+  const previewLines = [];
+  const flattened = codes.flatMap((c) => buckets[c]);
+  for (const item of flattened.slice(0, PLAN_PREVIEW_LIMIT)) {
+    const where = item.path !== void 0 && item.path.length > 0 ? `${item.path}` : "(no path)";
+    previewLines.push(`    \u2022 ${where} \u2014 ${item.message}`);
+  }
+  if (flattened.length > PLAN_PREVIEW_LIMIT) {
+    previewLines.push(`    \u2022 ... and ${flattened.length - PLAN_PREVIEW_LIMIT} more`);
+  }
+  return { totalCount, perCodeLines, previewLines };
+}
+function renderApplyLintPlan(plan) {
+  writeStdout("");
+  writeStdout(`${paint.warn("apply-lint mutation plan")} (${plan.totalCount} total)`);
+  for (const line of plan.perCodeLines) {
+    writeStdout(line);
+  }
+  if (plan.previewLines.length > 0) {
+    writeStdout("");
+    writeStdout("  preview:");
+    for (const line of plan.previewLines) {
+      writeStdout(line);
+    }
+  }
+}
+async function resolveApplyLintConsent(options) {
+  if (options.yesFlag || options.envBypass) {
+    return "proceed";
+  }
+  if (process.stdin.isTTY !== true) {
+    writeStderr(
+      "doctor --apply-lint: stdin is not a TTY and neither --yes nor FABRIC_NONINTERACTIVE=1 is set. Refusing to mutate."
+    );
+    return "abort";
+  }
+  const message = `About to apply ${options.plan.totalCount} mutation(s) to knowledge entries (frontmatter writes + git mv + cache deletes). Proceed?`;
+  const answer = await confirm({
+    message,
+    initialValue: false
+  });
+  if (isCancel(answer) || answer !== true) {
+    writeStderr("doctor --apply-lint: aborted by user.");
+    return "abort";
+  }
+  return "proceed";
+}
+export {
+  doctor_default as default,
+  doctorCommand
+};

package/dist/hooks-Y74Y5LQS.js

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

package/dist/index.js

@@ -8,17 +8,19 @@ import { defineCommand, runMain } from "citty";
 
 // src/commands/index.ts
 var allCommands = {
-  init: () => import("./init-7EYGUJNJ.js").then((module) => module.default),
-  scan: () => import("./scan-NNBNGIZG.js").then((module) => module.default),
-  serve: () => import("./serve-466QXQ5Q.js").then((module) => module.default),
-  doctor: () => import("./doctor-F52XWWZC.js").then((module) => module.default)
+  init: () => import("./init-55WZSUK6.js").then((module) => module.default),
+  scan: () => import("./scan-LMK3UCWL.js").then((module) => module.default),
+  serve: () => import("./serve-H554BHLG.js").then((module) => module.default),
+  doctor: () => import("./doctor-T7JWODKG.js").then((module) => module.default),
+  hooks: () => import("./hooks-Y74Y5LQS.js").then((module) => module.default),
+  "plan-context-hint": () => import("./plan-context-hint-QMUPAXIB.js").then((module) => module.default)
 };
 
 // src/index.ts
 var main = defineCommand({
   meta: {
     name: "fabric",
-    version: "1.8.0-rc.3",
+    version: "2.0.0-rc.8",
     description: 'Initialize and manage Fabric projects. Use "fabric init" for one-shot setup.'
   },
   subCommands: allCommands