@fenglimg/fabric-cli 2.0.0-rc.13 → 2.0.0-rc.21

package/dist/doctor-L6TIXXIX.js

@@ -0,0 +1,425 @@
+#!/usr/bin/env node
+import {
+  runInitScan
+} from "./chunk-FNO7CQDG.js";
+import {
+  hasActionHint,
+  paint,
+  renderFabricError,
+  symbol
+} from "./chunk-G2CIOLD4.js";
+import {
+  t
+} from "./chunk-6ICJICVU.js";
+import {
+  resolveDevMode
+} from "./chunk-ZSESMG6L.js";
+
+// src/commands/doctor.ts
+import { confirm, isCancel } from "@clack/prompts";
+import { defineCommand } from "citty";
+import {
+  appendEventLedgerEvent,
+  checkLockOrThrow,
+  runDoctorApplyLint as runDoctorFixKnowledge,
+  runDoctorCiteCoverage,
+  runDoctorFix,
+  runDoctorReport
+} from "@fenglimg/fabric-server";
+var FIX_KNOWLEDGE_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
+    },
+    "fix-knowledge": {
+      type: "boolean",
+      description: t("cli.doctor.args.fix-knowledge.description"),
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: t("cli.doctor.args.json.description"),
+      default: false
+    },
+    rescan: {
+      type: "boolean",
+      description: t("cli.doctor.args.rescan.description"),
+      default: false
+    },
+    strict: {
+      type: "boolean",
+      description: t("cli.doctor.args.strict.description"),
+      default: false
+    },
+    // rc.7 T11: skip the safety confirm before mutations. Required for any
+    // non-tty invocation that wants to run --fix-knowledge without setting
+    // FABRIC_NONINTERACTIVE=1 in the environment.
+    yes: {
+      type: "boolean",
+      description: t("cli.doctor.args.yes.description"),
+      default: false
+    },
+    // rc.20 TASK-05: cite policy adherence report (read-only). Skips standard
+    // inspections entirely — different output surface. Mutually exclusive
+    // with --fix / --fix-knowledge (enforced in run()).
+    "cite-coverage": {
+      type: "boolean",
+      description: t("cli.doctor.args.cite-coverage.description"),
+      default: false
+    },
+    since: {
+      type: "string",
+      description: t("cli.doctor.args.since.description"),
+      default: "7d"
+    },
+    client: {
+      type: "string",
+      description: t("cli.doctor.args.client.description"),
+      default: "all",
+      valueHint: "cc|codex|cursor|all"
+    }
+  },
+  async run({ args }) {
+    const workspaceRoot = process.cwd();
+    const resolution = resolveDevMode(args.target, workspaceRoot);
+    try {
+      checkLockOrThrow(resolution.target);
+    } catch (err) {
+      if (hasActionHint(err)) {
+        renderFabricError(err);
+        process.exit(1);
+      }
+      throw err;
+    }
+    const fixKnowledge = args["fix-knowledge"] === true;
+    const fix = args.fix === true;
+    const rescan = args.rescan === true;
+    const citeCoverage = args["cite-coverage"] === true;
+    if (citeCoverage) {
+      if (fix || fixKnowledge) {
+        writeStderr(t("cli.doctor.errors.cite-coverage-mutex"));
+        process.exitCode = 1;
+        return;
+      }
+      let sinceMs;
+      try {
+        sinceMs = parseSinceDuration(args.since ?? "7d");
+      } catch {
+        writeStderr(t("cli.doctor.errors.invalid-since", { input: args.since ?? "7d" }));
+        process.exitCode = 1;
+        return;
+      }
+      const clientFilter = args.client ?? "all";
+      if (!isValidClientFilter(clientFilter)) {
+        writeStderr(t("cli.doctor.errors.invalid-client", { input: clientFilter }));
+        process.exitCode = 1;
+        return;
+      }
+      const report2 = await runDoctorCiteCoverage(resolution.target, {
+        since: sinceMs,
+        client: clientFilter
+      });
+      renderCiteCoverageReport(report2, args.json === true);
+      return;
+    }
+    if (fixKnowledge && fix) {
+      writeStderr(t("cli.doctor.errors.fix-knowledge-fix-mutually-exclusive"));
+      process.exitCode = 1;
+      return;
+    }
+    if (rescan) {
+      await runInitScan(resolution.target, { source: "doctor-rescan" });
+    }
+    let fixKnowledgeReport = null;
+    let fixReport = null;
+    let report;
+    if (fixKnowledge) {
+      const preReport = await runDoctorReport(resolution.target);
+      const plan = computeFixKnowledgePlan(preReport);
+      const yesFlag = args.yes === true;
+      const envBypass = process.env.FABRIC_NONINTERACTIVE === "1";
+      if (plan.totalCount === 0) {
+      } else {
+        renderFixKnowledgePlan(plan);
+        const decision = await resolveFixKnowledgeConsent({
+          yesFlag,
+          envBypass,
+          plan
+        });
+        if (decision === "abort") {
+          process.exitCode = 1;
+          return;
+        }
+      }
+      fixKnowledgeReport = await runDoctorFixKnowledge(resolution.target);
+      report = fixKnowledgeReport.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(fixKnowledgeReport ?? fixReport ?? report, null, 2));
+    } else {
+      if (fixKnowledgeReport !== null) {
+        writeStdout(fixKnowledgeReport.message);
+        if (fixKnowledgeReport.aborted && fixKnowledgeReport.abort_reason !== void 0) {
+          writeStderr(fixKnowledgeReport.abort_reason);
+        }
+        renderFixKnowledgeMutations(fixKnowledgeReport);
+      } else if (fixReport !== null) {
+        writeStdout(fixReport.message);
+      }
+      renderHumanReport(report);
+    }
+    await emitDoctorRunEventBestEffort(resolution.target, {
+      mode: fixKnowledge ? "fix-knowledge" : "lint",
+      issues: report.fixable_errors.length + report.manual_errors.length + report.warnings.length,
+      mutations: fixKnowledgeReport !== null ? fixKnowledgeReport.mutations.filter((m) => m.applied).length : void 0
+    });
+    if (fixKnowledgeReport !== null) {
+      if (fixKnowledgeReport.aborted) {
+        process.exitCode = 1;
+        return;
+      }
+      if (fixKnowledgeReport.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 renderFixKnowledgeMutations(fixKnowledgeReport) {
+  if (fixKnowledgeReport.mutations.length === 0) {
+    return;
+  }
+  writeStdout("");
+  writeStdout(t("doctor.section.fix-knowledge-mutations"));
+  for (const mutation of fixKnowledgeReport.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 computeFixKnowledgePlan(report) {
+  const buckets = {};
+  const sources = [
+    ...report.fixable_errors,
+    ...report.warnings
+  ];
+  for (const issue of sources) {
+    if (FIX_KNOWLEDGE_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) => FIX_KNOWLEDGE_CODE_LABELS[a].localeCompare(FIX_KNOWLEDGE_CODE_LABELS[b])
+  );
+  const perCodeLines = [];
+  let totalCount = 0;
+  for (const code of codes) {
+    const items = buckets[code];
+    totalCount += items.length;
+    perCodeLines.push(`  - ${FIX_KNOWLEDGE_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 renderFixKnowledgePlan(plan) {
+  writeStdout("");
+  writeStdout(`${paint.warn("fix-knowledge 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 resolveFixKnowledgeConsent(options) {
+  if (options.yesFlag || options.envBypass) {
+    return "proceed";
+  }
+  if (process.stdin.isTTY !== true) {
+    writeStderr(
+      "doctor --fix-knowledge: 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 --fix-knowledge: aborted by user.");
+    return "abort";
+  }
+  return "proceed";
+}
+var CITE_COVERAGE_CLIENT_FILTERS = /* @__PURE__ */ new Set([
+  "cc",
+  "codex",
+  "cursor",
+  "all"
+]);
+function isValidClientFilter(input) {
+  return CITE_COVERAGE_CLIENT_FILTERS.has(input);
+}
+function renderCiteCoverageReport(report, jsonMode) {
+  if (jsonMode) {
+    writeStdout(JSON.stringify(report, null, 2));
+    return;
+  }
+  if (report.status === "skipped") {
+    writeStdout(t("doctor.cite.status.skipped"));
+    return;
+  }
+  const lines = [];
+  lines.push(t("doctor.section.cite-coverage"));
+  lines.push(
+    t("doctor.cite.header", {
+      since: new Date(report.since_ts).toISOString(),
+      marker: new Date(report.marker_ts).toISOString()
+    })
+  );
+  if (report.marker_emitted_now) {
+    lines.push(t("doctor.cite.warning.justActivated"));
+  }
+  lines.push("");
+  lines.push(`  ${t("doctor.cite.metric.editsTouched")}: ${report.metrics.edits_touched}`);
+  lines.push(`  ${t("doctor.cite.metric.qualifyingCites")}: ${report.metrics.qualifying_cites}`);
+  lines.push(`  ${t("doctor.cite.metric.recalledUnverified")}: ${report.metrics.recalled_unverified}`);
+  lines.push(`  ${t("doctor.cite.metric.expectedButMissed")}: ${report.metrics.expected_but_missed}`);
+  lines.push(`  ${t("doctor.cite.metric.totalTurns")}: ${report.metrics.total_turns}`);
+  if (report.per_client !== void 0 && Object.keys(report.per_client).length > 1) {
+    lines.push("");
+    lines.push(`### ${t("doctor.cite.section.perClient")}`);
+    for (const [client, metrics] of Object.entries(report.per_client)) {
+      const summary = Object.entries(metrics).map(([k, v]) => `${k}=${v}`).join(" / ");
+      lines.push(`  ${client}: ${summary}`);
+    }
+  }
+  if (report.dismissed_reason_histogram !== void 0 && Object.keys(report.dismissed_reason_histogram).length > 0) {
+    lines.push("");
+    lines.push(`### ${t("doctor.cite.section.dismissedReasons")}`);
+    for (const [reason, count] of Object.entries(report.dismissed_reason_histogram)) {
+      const label = t(`doctor.cite.dismissed.${reason}`);
+      lines.push(`  ${label}: ${count}`);
+    }
+  }
+  writeStdout(lines.join("\n"));
+}
+function parseSinceDuration(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`invalid --since value: ${input}`);
+  }
+  const durationMatch = /^(\d+)([dhm])$/.exec(trimmed);
+  if (durationMatch !== null) {
+    const value = Number.parseInt(durationMatch[1], 10);
+    const unit = durationMatch[2];
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new Error(`invalid --since value: ${input}`);
+    }
+    const unitMs = unit === "d" ? 864e5 : unit === "h" ? 36e5 : 6e4;
+    return Date.now() - value * unitMs;
+  }
+  if (/^\d+$/.test(trimmed)) {
+    const value = Number.parseInt(trimmed, 10);
+    if (!Number.isFinite(value) || value < 0) {
+      throw new Error(`invalid --since value: ${input}`);
+    }
+    return value;
+  }
+  throw new Error(`invalid --since value: ${input}`);
+}
+export {
+  doctor_default as default,
+  doctorCommand,
+  parseSinceDuration
+};

package/dist/index.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  t
+} from "./chunk-6ICJICVU.js";
 
 // src/index.ts
 import { realpathSync } from "fs";
@@ -8,21 +11,20 @@ import { defineCommand, runMain } from "citty";
 
 // src/commands/index.ts
 var allCommands = {
-  install: () => import("./install-SLS5W27W.js").then((module) => module.default),
-  scan: () => import("./scan-VHKZPT2W.js").then((module) => module.default),
-  serve: () => import("./serve-NGLXHDYC.js").then((module) => module.default),
-  uninstall: () => import("./uninstall-JHUSFENL.js").then((module) => module.default),
-  doctor: () => import("./doctor-RILCO5OG.js").then((module) => module.default),
-  hooks: () => import("./hooks-HIWYI3VG.js").then((module) => module.default),
-  "plan-context-hint": () => import("./plan-context-hint-QMUPAXIB.js").then((module) => module.default)
+  install: () => import("./install-DNZXGFHJ.js").then((module) => module.default),
+  doctor: () => import("./doctor-L6TIXXIX.js").then((module) => module.default),
+  serve: () => import("./serve-6PPQX7AW.js").then((module) => module.default),
+  uninstall: () => import("./uninstall-L2HEEOU3.js").then((module) => module.default),
+  config: () => import("./config-AYP5F72E.js").then((module) => module.default),
+  "plan-context-hint": () => import("./plan-context-hint-CFDGXHCA.js").then((module) => module.default)
 };
 
 // src/index.ts
 var main = defineCommand({
   meta: {
     name: "fabric",
-    version: "2.0.0-rc.13",
-    description: 'Initialize and manage Fabric projects. Use "fabric install" for one-shot setup.'
+    version: "2.0.0-rc.21",
+    description: t("cli.main.description")
   },
   subCommands: allCommands
 });