@fenglimg/fabric-cli 2.0.0-rc.11 → 2.0.0-rc.15

package/dist/chunk-UTF4YBDN.js

@@ -0,0 +1,366 @@
+#!/usr/bin/env node
+import {
+  deepMerge
+} from "./chunk-SKSYUHKK.js";
+
+// src/install/skills-and-hooks.ts
+import { chmodSync, existsSync, readFileSync } from "fs";
+import { mkdir, readFile } from "fs/promises";
+import { dirname, join, parse, resolve } from "path";
+import { fileURLToPath } from "url";
+import { atomicWriteJson, atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
+var SKILL_TEMPLATE_REL = "skills/fabric-archive/SKILL.md";
+var SKILL_REVIEW_TEMPLATE_REL = "skills/fabric-review/SKILL.md";
+var SKILL_IMPORT_TEMPLATE_REL = "skills/fabric-import/SKILL.md";
+var HOOK_SCRIPT_TEMPLATE_REL = "hooks/fabric-hint.cjs";
+var HOOK_BROAD_SCRIPT_TEMPLATE_REL = "hooks/knowledge-hint-broad.cjs";
+var HOOK_NARROW_SCRIPT_TEMPLATE_REL = "hooks/knowledge-hint-narrow.cjs";
+var CLAUDE_HOOK_CONFIG_TEMPLATE_REL = "hooks/configs/claude-code.json";
+var CODEX_HOOK_CONFIG_TEMPLATE_REL = "hooks/configs/codex-hooks.json";
+var CURSOR_HOOK_CONFIG_TEMPLATE_REL = "hooks/configs/cursor-hooks.json";
+var SKILL_DESTINATIONS = {
+  fabricArchive: [
+    ".claude/skills/fabric-archive/SKILL.md",
+    ".codex/skills/fabric-archive/SKILL.md"
+  ],
+  fabricReview: [
+    ".claude/skills/fabric-review/SKILL.md",
+    ".codex/skills/fabric-review/SKILL.md"
+  ],
+  fabricImport: [
+    ".claude/skills/fabric-import/SKILL.md",
+    ".codex/skills/fabric-import/SKILL.md"
+  ]
+};
+var HOOK_SCRIPT_DESTINATIONS = {
+  fabricHint: [
+    ".claude/hooks/fabric-hint.cjs",
+    ".codex/hooks/fabric-hint.cjs",
+    ".cursor/hooks/fabric-hint.cjs"
+  ],
+  knowledgeHintBroad: [
+    ".claude/hooks/knowledge-hint-broad.cjs",
+    ".codex/hooks/knowledge-hint-broad.cjs",
+    ".cursor/hooks/knowledge-hint-broad.cjs"
+  ],
+  knowledgeHintNarrow: [
+    ".claude/hooks/knowledge-hint-narrow.cjs",
+    ".codex/hooks/knowledge-hint-narrow.cjs",
+    ".cursor/hooks/knowledge-hint-narrow.cjs"
+  ]
+};
+var HOOK_CONFIG_TARGETS = {
+  claudeCode: ".claude/settings.json",
+  codex: ".codex/hooks.json",
+  cursor: ".cursor/hooks.json"
+};
+var HOOK_CONFIG_ARRAY_PATHS = {
+  claudeCode: ["hooks.Stop", "hooks.SessionStart", "hooks.PreToolUse"],
+  codex: ["events.Stop", "events.SessionStart", "events.PreToolUse"],
+  cursor: ["hooks.stop", "hooks.sessionStart", "hooks.preToolUse"]
+};
+var FABRIC_HOOK_COMMAND_PATHS = {
+  claudeCode: {
+    fabricHint: ".claude/hooks/fabric-hint.cjs",
+    knowledgeHintBroad: ".claude/hooks/knowledge-hint-broad.cjs",
+    knowledgeHintNarrow: ".claude/hooks/knowledge-hint-narrow.cjs"
+  },
+  codex: {
+    fabricHint: ".codex/hooks/fabric-hint.cjs",
+    knowledgeHintBroad: ".codex/hooks/knowledge-hint-broad.cjs",
+    knowledgeHintNarrow: ".codex/hooks/knowledge-hint-narrow.cjs"
+  },
+  cursor: {
+    fabricHint: ".cursor/hooks/fabric-hint.cjs",
+    knowledgeHintBroad: ".cursor/hooks/knowledge-hint-broad.cjs",
+    knowledgeHintNarrow: ".cursor/hooks/knowledge-hint-narrow.cjs"
+  }
+};
+var SECTION_TARGETS = ["CLAUDE.md", "AGENTS.md", join(".cursor", "rules")];
+var FABRIC_SECTION_BEGIN_MARKER = "<!-- fabric:knowledge-base:begin -->";
+var FABRIC_SECTION_END_MARKER = "<!-- fabric:knowledge-base:end -->";
+var FABRIC_SECTION_REGEX = /(?:\r?\n){0,2}<!-- fabric:knowledge-base:begin -->[\s\S]*?<!-- fabric:knowledge-base:end -->/;
+function readFabricLanguagePreference(projectRoot) {
+  const configPath = join(projectRoot, ".fabric", "fabric-config.json");
+  if (!existsSync(configPath)) {
+    return "match-existing";
+  }
+  try {
+    const raw = readFileSync(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return "match-existing";
+    }
+    const value = parsed["fabric_language"];
+    return typeof value === "string" && value.length > 0 ? value : "match-existing";
+  } catch {
+    return "match-existing";
+  }
+}
+function buildFabricKnowledgeBaseSection(fabricLanguage) {
+  return `${FABRIC_SECTION_BEGIN_MARKER}
+
+## Fabric Knowledge Base
+
+This project uses Fabric for persistent project knowledge under \`.fabric/knowledge/\`.
+
+- **Discovery**: SessionStart lists available entries (broad menu); editing files may surface narrow hints
+- **Usage**: call \`fab_get_knowledge_sections\` to fetch full content of any entry by id
+- **Write flows**: see fabric-archive (record), fabric-review (validate), fabric-import (backfill) Skills
+- **Language**: rendered per \`fabric_language\` in \`.fabric/fabric-config.json\` (current: \`${fabricLanguage}\`)
+
+${FABRIC_SECTION_END_MARKER}`;
+}
+async function installFabricArchiveSkill(projectRoot, _options = {}) {
+  const source = await readTemplate(SKILL_TEMPLATE_REL);
+  const targets = SKILL_DESTINATIONS.fabricArchive.map((rel) => join(projectRoot, rel));
+  const results = [];
+  for (const target of targets) {
+    results.push(await copyTextIdempotent("skill", source, target));
+  }
+  return results;
+}
+async function installFabricReviewSkill(projectRoot, _options = {}) {
+  const source = await readTemplate(SKILL_REVIEW_TEMPLATE_REL);
+  const targets = SKILL_DESTINATIONS.fabricReview.map((rel) => join(projectRoot, rel));
+  const results = [];
+  for (const target of targets) {
+    results.push(await copyTextIdempotent("skill-review", source, target));
+  }
+  return results;
+}
+async function installFabricImportSkill(projectRoot, _options = {}) {
+  const source = await readTemplate(SKILL_IMPORT_TEMPLATE_REL);
+  const targets = SKILL_DESTINATIONS.fabricImport.map((rel) => join(projectRoot, rel));
+  const results = [];
+  for (const target of targets) {
+    results.push(await copyTextIdempotent("skill-import", source, target));
+  }
+  return results;
+}
+async function installArchiveHintHook(projectRoot, _options = {}) {
+  const source = await readTemplate(HOOK_SCRIPT_TEMPLATE_REL);
+  const targets = HOOK_SCRIPT_DESTINATIONS.fabricHint.map((rel) => join(projectRoot, rel));
+  const results = [];
+  for (const target of targets) {
+    const result = await copyTextIdempotent("hook-script", source, target);
+    if (result.status === "written" && process.platform !== "win32") {
+      try {
+        chmodSync(target, 493);
+      } catch {
+      }
+    }
+    results.push(result);
+  }
+  return results;
+}
+async function installKnowledgeHintBroadHook(projectRoot, _options = {}) {
+  const source = await readTemplate(HOOK_BROAD_SCRIPT_TEMPLATE_REL);
+  const targets = HOOK_SCRIPT_DESTINATIONS.knowledgeHintBroad.map((rel) => join(projectRoot, rel));
+  const results = [];
+  for (const target of targets) {
+    const result = await copyTextIdempotent("hook-broad-script", source, target);
+    if (result.status === "written" && process.platform !== "win32") {
+      try {
+        chmodSync(target, 493);
+      } catch {
+      }
+    }
+    results.push(result);
+  }
+  return results;
+}
+async function installKnowledgeHintNarrowHook(projectRoot, _options = {}) {
+  const source = await readTemplate(HOOK_NARROW_SCRIPT_TEMPLATE_REL);
+  const targets = HOOK_SCRIPT_DESTINATIONS.knowledgeHintNarrow.map((rel) => join(projectRoot, rel));
+  const results = [];
+  for (const target of targets) {
+    const result = await copyTextIdempotent("hook-narrow-script", source, target);
+    if (result.status === "written" && process.platform !== "win32") {
+      try {
+        chmodSync(target, 493);
+      } catch {
+      }
+    }
+    results.push(result);
+  }
+  return results;
+}
+async function mergeClaudeCodeHookConfig(projectRoot, _options = {}) {
+  const fragment = await readJsonTemplate(CLAUDE_HOOK_CONFIG_TEMPLATE_REL);
+  const targetPath = join(projectRoot, HOOK_CONFIG_TARGETS.claudeCode);
+  return mergeJsonIdempotent(
+    "claude-hook-config",
+    targetPath,
+    fragment,
+    [...HOOK_CONFIG_ARRAY_PATHS.claudeCode]
+  );
+}
+async function mergeCodexHookConfig(projectRoot, _options = {}) {
+  const fragment = await readJsonTemplate(CODEX_HOOK_CONFIG_TEMPLATE_REL);
+  const targetPath = join(projectRoot, HOOK_CONFIG_TARGETS.codex);
+  return mergeJsonIdempotent(
+    "codex-hook-config",
+    targetPath,
+    fragment,
+    [...HOOK_CONFIG_ARRAY_PATHS.codex]
+  );
+}
+async function mergeCursorHookConfig(projectRoot, _options = {}) {
+  const fragment = await readJsonTemplate(CURSOR_HOOK_CONFIG_TEMPLATE_REL);
+  const targetPath = join(projectRoot, HOOK_CONFIG_TARGETS.cursor);
+  return mergeJsonIdempotent(
+    "cursor-hook-config",
+    targetPath,
+    fragment,
+    [...HOOK_CONFIG_ARRAY_PATHS.cursor]
+  );
+}
+async function addFabricKnowledgeBaseSection(projectRoot, fabricLanguage, _options = {}) {
+  const sectionBody = buildFabricKnowledgeBaseSection(fabricLanguage);
+  const results = [];
+  for (const rel of SECTION_TARGETS) {
+    const target = join(projectRoot, rel);
+    if (!existsSync(target)) {
+      results.push({ step: "section", path: target, status: "skipped", message: "absent" });
+      continue;
+    }
+    let existing;
+    try {
+      existing = await readFile(target, "utf8");
+    } catch (error) {
+      results.push({
+        step: "section",
+        path: target,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      });
+      continue;
+    }
+    let next;
+    const match = existing.match(FABRIC_SECTION_REGEX);
+    if (match !== null) {
+      const before = existing.slice(0, match.index ?? 0);
+      const after = existing.slice((match.index ?? 0) + match[0].length);
+      const stripped = `${before}${after.replace(/^\r?\n/, "")}`;
+      const trailingNewline = stripped.length === 0 || stripped.endsWith("\n") ? "" : "\n";
+      next = `${stripped}${trailingNewline}
+${sectionBody}
+`;
+    } else {
+      const trailingNewline = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
+      next = `${existing}${trailingNewline}
+${sectionBody}
+`;
+    }
+    if (next === existing) {
+      results.push({ step: "section", path: target, status: "skipped", message: "up-to-date" });
+      continue;
+    }
+    try {
+      await atomicWriteText(target, next);
+      results.push({ step: "section", path: target, status: "written" });
+    } catch (error) {
+      results.push({
+        step: "section",
+        path: target,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return results;
+}
+async function copyTextIdempotent(step, source, target) {
+  if (existsSync(target)) {
+    try {
+      const existing = readFileSync(target, "utf8");
+      if (existing === source) {
+        return { step, path: target, status: "skipped", message: "up-to-date" };
+      }
+    } catch {
+    }
+  }
+  await mkdir(dirname(target), { recursive: true });
+  await atomicWriteText(target, source);
+  return { step, path: target, status: "written" };
+}
+async function mergeJsonIdempotent(step, target, fragment, arrayAppendPaths) {
+  const existing = await readJsonObjectOrEmpty(target);
+  const merged = deepMerge(existing, fragment, { arrayAppendPaths });
+  if (jsonEqual(existing, merged)) {
+    return { step, path: target, status: "skipped", message: "up-to-date" };
+  }
+  await mkdir(dirname(target), { recursive: true });
+  await atomicWriteJson(target, merged, { indent: 2 });
+  return { step, path: target, status: "written" };
+}
+async function readJsonObjectOrEmpty(path) {
+  try {
+    const raw = await readFile(path, "utf8");
+    if (raw.trim().length === 0) {
+      return {};
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {};
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+}
+function jsonEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+async function readTemplate(relativePath) {
+  const path = findTemplatePath(relativePath);
+  return readFile(path, "utf8");
+}
+async function readJsonTemplate(relativePath) {
+  const raw = await readTemplate(relativePath);
+  const parsed = JSON.parse(raw);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Template at ${relativePath} is not a JSON object`);
+  }
+  return parsed;
+}
+function findTemplatePath(relativePath) {
+  const startDir = dirname(fileURLToPath(import.meta.url));
+  let current = resolve(startDir);
+  while (true) {
+    const candidate = join(current, "templates", relativePath);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = dirname(current);
+    if (parent === current || parse(current).root === current) {
+      throw new Error(`Template not found: templates/${relativePath} (searched up from ${startDir})`);
+    }
+    current = parent;
+  }
+}
+
+export {
+  SKILL_DESTINATIONS,
+  HOOK_SCRIPT_DESTINATIONS,
+  HOOK_CONFIG_TARGETS,
+  HOOK_CONFIG_ARRAY_PATHS,
+  FABRIC_HOOK_COMMAND_PATHS,
+  SECTION_TARGETS,
+  FABRIC_SECTION_REGEX,
+  readFabricLanguagePreference,
+  installFabricArchiveSkill,
+  installFabricReviewSkill,
+  installFabricImportSkill,
+  installArchiveHintHook,
+  installKnowledgeHintBroadHook,
+  installKnowledgeHintNarrowHook,
+  mergeClaudeCodeHookConfig,
+  mergeCodexHookConfig,
+  mergeCursorHookConfig,
+  addFabricKnowledgeBaseSection
+};

package/dist/config-7YD365I3.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  configCmd,
+  config_default,
+  installMcpClients
+} from "./chunk-AIB54QRT.js";
+import "./chunk-SKSYUHKK.js";
+import "./chunk-6ICJICVU.js";
+export {
+  configCmd,
+  config_default as default,
+  installMcpClients
+};

package/dist/{doctor-RILCO5OG.js → doctor-6XHLQJXB.js}

@@ -1,14 +1,19 @@
 #!/usr/bin/env node
 import {
+  runInitScan
+} from "./chunk-AXIFEVAS.js";
+import {
+  hasActionHint,
   paint,
+  renderFabricError,
   symbol
-} from "./chunk-WWNXR34K.js";
-import {
-  resolveDevMode
-} from "./chunk-OBQU6NHO.js";
+} from "./chunk-G2CIOLD4.js";
 import {
   t
 } from "./chunk-6ICJICVU.js";
+import {
+  resolveDevMode
+} from "./chunk-OBQU6NHO.js";
 
 // src/commands/doctor.ts
 import { confirm, isCancel } from "@clack/prompts";
@@ -16,11 +21,11 @@ import { defineCommand } from "citty";
 import {
   appendEventLedgerEvent,
   checkLockOrThrow,
-  runDoctorApplyLint,
+  runDoctorApplyLint as runDoctorFixKnowledge,
   runDoctorFix,
   runDoctorReport
 } from "@fenglimg/fabric-server";
-var APPLY_LINT_CODE_LABELS = {
+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)",
@@ -43,28 +48,28 @@ var doctorCommand = defineCommand({
       description: t("cli.doctor.args.fix.description"),
       default: false
     },
-    json: {
+    "fix-knowledge": {
       type: "boolean",
-      description: t("cli.doctor.args.json.description"),
+      description: t("cli.doctor.args.fix-knowledge.description"),
       default: false
     },
-    strict: {
+    json: {
       type: "boolean",
-      description: t("cli.doctor.args.strict.description"),
+      description: t("cli.doctor.args.json.description"),
       default: false
     },
-    force: {
+    rescan: {
       type: "boolean",
-      description: t("cli.doctor.args.force.description"),
+      description: t("cli.doctor.args.rescan.description"),
       default: false
     },
-    "apply-lint": {
+    strict: {
       type: "boolean",
-      description: t("cli.doctor.args.apply-lint.description"),
+      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 --apply-lint without setting
+    // non-tty invocation that wants to run --fix-knowledge without setting
     // FABRIC_NONINTERACTIVE=1 in the environment.
     yes: {
       type: "boolean",
@@ -75,26 +80,38 @@ var doctorCommand = defineCommand({
   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;
+    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;
-    if (applyLint && fix) {
-      writeStderr(t("cli.doctor.errors.apply-lint-fix-mutually-exclusive"));
+    const rescan = args.rescan === true;
+    if (fixKnowledge && fix) {
+      writeStderr(t("cli.doctor.errors.fix-knowledge-fix-mutually-exclusive"));
       process.exitCode = 1;
       return;
     }
-    let applyLintReport = null;
+    if (rescan) {
+      await runInitScan(resolution.target, { source: "doctor-rescan" });
+    }
+    let fixKnowledgeReport = null;
     let fixReport = null;
     let report;
-    if (applyLint) {
+    if (fixKnowledge) {
       const preReport = await runDoctorReport(resolution.target);
-      const plan = computeApplyLintPlan(preReport);
+      const plan = computeFixKnowledgePlan(preReport);
       const yesFlag = args.yes === true;
       const envBypass = process.env.FABRIC_NONINTERACTIVE === "1";
       if (plan.totalCount === 0) {
       } else {
-        renderApplyLintPlan(plan);
-        const decision = await resolveApplyLintConsent({
+        renderFixKnowledgePlan(plan);
+        const decision = await resolveFixKnowledgeConsent({
           yesFlag,
           envBypass,
           plan
@@ -104,8 +121,8 @@ var doctorCommand = defineCommand({
           return;
         }
       }
-      applyLintReport = await runDoctorApplyLint(resolution.target);
-      report = applyLintReport.report;
+      fixKnowledgeReport = await runDoctorFixKnowledge(resolution.target);
+      report = fixKnowledgeReport.report;
     } else if (fix) {
       fixReport = await runDoctorFix(resolution.target);
       report = fixReport.report;
@@ -113,30 +130,30 @@ var doctorCommand = defineCommand({
       report = await runDoctorReport(resolution.target);
     }
     if (args.json === true) {
-      writeStdout(JSON.stringify(applyLintReport ?? fixReport ?? report, null, 2));
+      writeStdout(JSON.stringify(fixKnowledgeReport ?? fixReport ?? report, null, 2));
     } else {
-      if (applyLintReport !== null) {
-        writeStdout(applyLintReport.message);
-        if (applyLintReport.aborted && applyLintReport.abort_reason !== void 0) {
-          writeStderr(applyLintReport.abort_reason);
+      if (fixKnowledgeReport !== null) {
+        writeStdout(fixKnowledgeReport.message);
+        if (fixKnowledgeReport.aborted && fixKnowledgeReport.abort_reason !== void 0) {
+          writeStderr(fixKnowledgeReport.abort_reason);
         }
-        renderApplyLintMutations(applyLintReport);
+        renderFixKnowledgeMutations(fixKnowledgeReport);
       } else if (fixReport !== null) {
         writeStdout(fixReport.message);
       }
       renderHumanReport(report);
     }
     await emitDoctorRunEventBestEffort(resolution.target, {
-      mode: applyLint ? "apply-lint" : "lint",
+      mode: fixKnowledge ? "fix-knowledge" : "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
+      mutations: fixKnowledgeReport !== null ? fixKnowledgeReport.mutations.filter((m) => m.applied).length : void 0
     });
-    if (applyLintReport !== null) {
-      if (applyLintReport.aborted) {
+    if (fixKnowledgeReport !== null) {
+      if (fixKnowledgeReport.aborted) {
         process.exitCode = 1;
         return;
       }
-      if (applyLintReport.mutations.some((m) => !m.applied)) {
+      if (fixKnowledgeReport.mutations.some((m) => !m.applied)) {
         process.exitCode = 1;
         return;
       }
@@ -156,13 +173,13 @@ function renderHumanReport(report) {
   writeIssueSection(t("doctor.section.manual"), report.manual_errors);
   writeIssueSection(t("doctor.section.warnings"), report.warnings);
 }
-function renderApplyLintMutations(applyLintReport) {
-  if (applyLintReport.mutations.length === 0) {
+function renderFixKnowledgeMutations(fixKnowledgeReport) {
+  if (fixKnowledgeReport.mutations.length === 0) {
     return;
   }
   writeStdout("");
-  writeStdout(t("doctor.section.apply-lint-mutations"));
-  for (const mutation of applyLintReport.mutations) {
+  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}`);
@@ -207,28 +224,28 @@ function writeStderr(message) {
   process.stderr.write(`${message}
 `);
 }
-function computeApplyLintPlan(report) {
+function computeFixKnowledgePlan(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 (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) => APPLY_LINT_CODE_LABELS[a].localeCompare(APPLY_LINT_CODE_LABELS[b])
+    (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(`  - ${APPLY_LINT_CODE_LABELS[code]}: ${items.length}`);
+    perCodeLines.push(`  - ${FIX_KNOWLEDGE_CODE_LABELS[code]}: ${items.length}`);
   }
   const previewLines = [];
   const flattened = codes.flatMap((c) => buckets[c]);
@@ -241,9 +258,9 @@ function computeApplyLintPlan(report) {
   }
   return { totalCount, perCodeLines, previewLines };
 }
-function renderApplyLintPlan(plan) {
+function renderFixKnowledgePlan(plan) {
   writeStdout("");
-  writeStdout(`${paint.warn("apply-lint mutation plan")} (${plan.totalCount} total)`);
+  writeStdout(`${paint.warn("fix-knowledge mutation plan")} (${plan.totalCount} total)`);
   for (const line of plan.perCodeLines) {
     writeStdout(line);
   }
@@ -255,13 +272,13 @@ function renderApplyLintPlan(plan) {
     }
   }
 }
-async function resolveApplyLintConsent(options) {
+async function resolveFixKnowledgeConsent(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."
+      "doctor --fix-knowledge: stdin is not a TTY and neither --yes nor FABRIC_NONINTERACTIVE=1 is set. Refusing to mutate."
     );
     return "abort";
   }
@@ -271,7 +288,7 @@ async function resolveApplyLintConsent(options) {
     initialValue: false
   });
   if (isCancel(answer) || answer !== true) {
-    writeStderr("doctor --apply-lint: aborted by user.");
+    writeStderr("doctor --fix-knowledge: aborted by user.");
     return "abort";
   }
   return "proceed";

package/dist/index.js

@@ -8,21 +8,20 @@ import { defineCommand, runMain } from "citty";
 
 // src/commands/index.ts
 var allCommands = {
-  init: () => import("./init-C56PWHID.js").then((module) => module.default),
-  scan: () => import("./scan-66EKMNAY.js").then((module) => module.default),
-  serve: () => import("./serve-NGLXHDYC.js").then((module) => module.default),
-  uninstall: () => import("./uninstall-DBAR2JBS.js").then((module) => module.default),
-  doctor: () => import("./doctor-RILCO5OG.js").then((module) => module.default),
-  hooks: () => import("./hooks-NX32PPEN.js").then((module) => module.default),
-  "plan-context-hint": () => import("./plan-context-hint-QMUPAXIB.js").then((module) => module.default)
+  install: () => import("./install-JLDCHAXV.js").then((module) => module.default),
+  doctor: () => import("./doctor-6XHLQJXB.js").then((module) => module.default),
+  serve: () => import("./serve-L3X5UHG2.js").then((module) => module.default),
+  uninstall: () => import("./uninstall-DD6FIFCI.js").then((module) => module.default),
+  config: () => import("./config-7YD365I3.js").then((module) => module.default),
+  "plan-context-hint": () => import("./plan-context-hint-73U4FGKO.js").then((module) => module.default)
 };
 
 // src/index.ts
 var main = defineCommand({
   meta: {
     name: "fabric",
-    version: "2.0.0-rc.11",
-    description: 'Initialize and manage Fabric projects. Use "fabric init" for one-shot setup.'
+    version: "2.0.0-rc.15",
+    description: 'Initialize and manage Fabric projects. Use "fabric install" for one-shot setup.'
   },
   subCommands: allCommands
 });