@fenglimg/fabric-cli 2.0.0-rc.1 → 2.0.0-rc.10

package/README.md

@@ -1,16 +1,16 @@
-# @fenglimg/fabric-cli
-
+# @fenglimg/fabric-cli
+
 `fabric` 是 Fabric 的主命令，`fab` 是永久别名，两者等价。
-
+
 ## 快速开始
 
 1. 在 monorepo 根目录运行 `pnpm install`。
 2. 用 `pnpm --filter @fenglimg/fabric-cli build` 构建 CLI。
 3. 在目标项目运行 `fabric init`，完成一站式初始化。
-4. 启动 `fabric serve`，再去客户端里验证 `fab_plan_context` 和 `fab_get_rule_sections`。
+4. 启动 `fabric serve`，再去客户端里验证 `fab_plan_context` 和 `fab_get_knowledge_sections`。
 
 `fabric init` 会自动准备 bootstrap、MCP 配置和 git hooks。公共命令面只保留 `init`、`scan`、`doctor`、`serve`。
-
+
 ## 常用命令
 
 - `fabric init`
@@ -21,4 +21,4 @@
 - `fabric doctor --fix`
 - `fabric serve`
 
-`fabric doctor --fix` 只修复确定性的派生状态，例如 `.fabric/agents.meta.json`、`.fabric/rule-test.index.json`、缺失的 `.fabric/events.jsonl` 和 stale hashes；语义冲突、缺失 rule section、未完成的初始化确认仍需要人工处理。
+`fabric doctor --fix` 只修复确定性的派生状态，例如 `.fabric/agents.meta.json`、`.fabric/.cache/knowledge-test.index.json`、缺失的 `.fabric/events.jsonl` 和 stale hashes；语义冲突、缺失 rule section、未完成的初始化确认仍需要人工处理。

package/dist/chunk-6ICJICVU.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+// src/i18n.ts
+import { createTranslator, detectNodeLocale } from "@fenglimg/fabric-shared";
+var locale = detectNodeLocale();
+var t = createTranslator(locale);
+
+export {
+  t
+};

package/dist/chunk-AW3G7ZH5.js

@@ -0,0 +1,576 @@
+#!/usr/bin/env node
+
+// src/install/skills-and-hooks.ts
+import { chmodSync, existsSync as existsSync2, readFileSync } from "fs";
+import { mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
+import { dirname as dirname2, join as join2, parse, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+import { atomicWriteJson as atomicWriteJson2, atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
+
+// src/config/json.ts
+import { existsSync } from "fs";
+import { mkdir, readFile } from "fs/promises";
+import { dirname, join, resolve } from "path";
+import { homedir } from "os";
+import { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
+
+// src/config/writer.ts
+function createServerEntry(serverPath) {
+  return {
+    command: process.execPath,
+    args: [serverPath]
+  };
+}
+
+// src/config/json.ts
+function deepMerge(target, source, options = {}) {
+  return deepMergeAtPath(target, source, "", options);
+}
+function deepMergeAtPath(target, source, path, options) {
+  if (options.arrayAppendPaths && options.arrayAppendPaths.includes(path) && Array.isArray(target) && Array.isArray(source)) {
+    return appendArrayWithDedupe(target, source);
+  }
+  if (target === null || typeof target !== "object" || Array.isArray(target) || source === null || typeof source !== "object" || Array.isArray(source)) {
+    return source;
+  }
+  const out = { ...target };
+  for (const key of Object.keys(source)) {
+    const childPath = path === "" ? key : `${path}.${key}`;
+    out[key] = deepMergeAtPath(
+      target[key],
+      source[key],
+      childPath,
+      options
+    );
+  }
+  return out;
+}
+function appendArrayWithDedupe(target, source) {
+  const out = [...target];
+  for (const candidate of source) {
+    if (out.some((existing) => isSameHookEntry(existing, candidate))) {
+      continue;
+    }
+    out.push(candidate);
+  }
+  return out;
+}
+function isSameHookEntry(a, b) {
+  const cmdA = extractHookCommand(a);
+  const cmdB = extractHookCommand(b);
+  if (cmdA !== null && cmdB !== null) {
+    return cmdA === cmdB;
+  }
+  return deepEqual(a, b);
+}
+function extractHookCommand(item) {
+  if (item === null || typeof item !== "object") {
+    return null;
+  }
+  const obj = item;
+  if (typeof obj.command === "string") {
+    return obj.command;
+  }
+  if (Array.isArray(obj.hooks)) {
+    for (const inner of obj.hooks) {
+      if (inner !== null && typeof inner === "object") {
+        const innerObj = inner;
+        if (typeof innerObj.command === "string") {
+          return innerObj.command;
+        }
+      }
+    }
+  }
+  return null;
+}
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) {
+    return false;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    return a.every((value, index) => deepEqual(value, b[index]));
+  }
+  const aObj = a;
+  const bObj = b;
+  const aKeys = Object.keys(aObj);
+  const bKeys = Object.keys(bObj);
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  return aKeys.every((key) => deepEqual(aObj[key], bObj[key]));
+}
+function expandHome(filePath) {
+  if (filePath === "~") {
+    return homedir();
+  }
+  if (filePath.startsWith("~/")) {
+    return join(homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+function normalizeConfigPath(filePath) {
+  return resolve(expandHome(filePath));
+}
+async function readJsonConfig(configPath) {
+  try {
+    const raw = await readFile(configPath, "utf8");
+    if (raw.trim().length === 0) {
+      return {};
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error(`Expected JSON object in ${configPath}`);
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+}
+async function writeJsonClientConfig(configPath, serverEntry) {
+  const existing = await readJsonConfig(configPath);
+  const merged = deepMerge(existing, { mcpServers: { fabric: serverEntry } });
+  await mkdir(dirname(configPath), { recursive: true });
+  await atomicWriteJson(configPath, merged, { indent: 2 });
+}
+async function removeJsonClientConfigEntry(configPath, serverName) {
+  if (!existsSync(configPath)) {
+    return { status: "skipped", path: configPath, message: "no-config-file" };
+  }
+  let existing;
+  try {
+    existing = await readJsonConfig(configPath);
+  } catch (error) {
+    return {
+      status: "error",
+      path: configPath,
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+  const mcpServers = existing.mcpServers;
+  if (mcpServers === void 0 || mcpServers === null || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+    return { status: "skipped", path: configPath, message: "no-mcp-servers-object" };
+  }
+  const servers = mcpServers;
+  if (!Object.prototype.hasOwnProperty.call(servers, serverName)) {
+    return { status: "skipped", path: configPath, message: "not-present" };
+  }
+  const nextServers = { ...servers };
+  delete nextServers[serverName];
+  const next = { ...existing, mcpServers: nextServers };
+  try {
+    await mkdir(dirname(configPath), { recursive: true });
+    await atomicWriteJson(configPath, next, { indent: 2 });
+    return { status: "removed", path: configPath };
+  } catch (error) {
+    return {
+      status: "error",
+      path: configPath,
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+var JsonClientConfigWriter = class {
+  configuredPath;
+  constructor(configuredPath) {
+    this.configuredPath = configuredPath;
+  }
+  async detect(workspaceRoot, overridePath) {
+    const explicitPath = overridePath ?? this.configuredPath;
+    if (explicitPath !== void 0) {
+      return normalizeConfigPath(explicitPath);
+    }
+    const configPath = this.defaultPath(workspaceRoot);
+    return configPath === null ? null : normalizeConfigPath(configPath);
+  }
+  async write(serverPath, workspaceRoot, overridePath) {
+    const configPath = await this.detect(workspaceRoot, overridePath);
+    if (configPath === null) {
+      return;
+    }
+    await writeJsonClientConfig(configPath, createServerEntry(serverPath));
+  }
+  async remove(serverName, workspaceRoot, overridePath) {
+    const configPath = await this.detect(workspaceRoot, overridePath);
+    if (configPath === null) {
+      return { status: "skipped", message: "no-config-path" };
+    }
+    return removeJsonClientConfigEntry(configPath, serverName);
+  }
+};
+var ClaudeCodeCLIWriter = class extends JsonClientConfigWriter {
+  clientKind = "ClaudeCodeCLI";
+  scope;
+  constructor(configuredPath, scope = "project") {
+    super(configuredPath);
+    this.scope = scope;
+  }
+  // Writes to project-level .mcp.json (per Claude Code MCP spec) by default,
+  // or ~/.claude.json for user scope.
+  // Detection still checks ~/.claude to confirm Claude Code is installed.
+  defaultPath(workspaceRoot) {
+    const globalClaudeDir = join(homedir(), ".claude");
+    const projectClaudeDir = join(workspaceRoot, ".claude");
+    if (!existsSync(globalClaudeDir) && !existsSync(projectClaudeDir)) {
+      return null;
+    }
+    return this.scope === "user" ? join(homedir(), ".claude.json") : join(workspaceRoot, ".mcp.json");
+  }
+};
+var CursorWriter = class extends JsonClientConfigWriter {
+  clientKind = "Cursor";
+  constructor(configuredPath) {
+    super(configuredPath);
+  }
+  defaultPath(workspaceRoot) {
+    const cursorDir = join(workspaceRoot, ".cursor");
+    return existsSync(cursorDir) ? join(cursorDir, "mcp.json") : null;
+  }
+};
+
+// src/install/skills-and-hooks.ts
+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: ["events.Stop", "events.SessionStart", "events.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 POINTER_LINE = "> Use the fabric-archive Skill when archiving knowledge entries (see .claude/skills/fabric-archive/SKILL.md).";
+var REVIEW_POINTER_LINE = "> Use the fabric-review Skill to review pending knowledge entries (see .claude/skills/fabric-review/SKILL.md).";
+var IMPORT_POINTER_LINE = "> Use the fabric-import Skill for cold-start enrichment from git history and docs (see .claude/skills/fabric-import/SKILL.md).";
+var POINTER_TARGETS = ["CLAUDE.md", "AGENTS.md", join2(".cursor", "rules")];
+async function installFabricArchiveSkill(projectRoot, _options = {}) {
+  const source = await readTemplate(SKILL_TEMPLATE_REL);
+  const targets = SKILL_DESTINATIONS.fabricArchive.map((rel) => join2(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) => join2(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) => join2(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) => join2(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) => join2(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) => join2(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 = join2(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 = join2(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 = join2(projectRoot, HOOK_CONFIG_TARGETS.cursor);
+  return mergeJsonIdempotent(
+    "cursor-hook-config",
+    targetPath,
+    fragment,
+    [...HOOK_CONFIG_ARRAY_PATHS.cursor]
+  );
+}
+async function addArchiveSkillPointer(projectRoot, _options = {}) {
+  const results = [];
+  for (const rel of POINTER_TARGETS) {
+    const target = join2(projectRoot, rel);
+    if (!existsSync2(target)) {
+      results.push({ step: "pointer", path: target, status: "skipped", message: "absent" });
+      continue;
+    }
+    let existing;
+    try {
+      existing = await readFile2(target, "utf8");
+    } catch (error) {
+      results.push({
+        step: "pointer",
+        path: target,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      });
+      continue;
+    }
+    let next = existing;
+    let wrote = false;
+    if (next.includes(POINTER_LINE)) {
+      results.push({ step: "pointer", path: target, status: "skipped", message: "already-present" });
+    } else {
+      const trailingNewline = next.length === 0 || next.endsWith("\n") ? "" : "\n";
+      next = `${next}${trailingNewline}
+${POINTER_LINE}
+`;
+      wrote = true;
+      results.push({ step: "pointer", path: target, status: "written" });
+    }
+    if (next.includes(REVIEW_POINTER_LINE)) {
+      results.push({ step: "pointer-review", path: target, status: "skipped", message: "already-present" });
+    } else {
+      const trailingNewline = next.length === 0 || next.endsWith("\n") ? "" : "\n";
+      next = `${next}${trailingNewline}
+${REVIEW_POINTER_LINE}
+`;
+      wrote = true;
+      results.push({ step: "pointer-review", path: target, status: "written" });
+    }
+    if (next.includes(IMPORT_POINTER_LINE)) {
+      results.push({ step: "pointer-import", path: target, status: "skipped", message: "already-present" });
+    } else {
+      const trailingNewline = next.length === 0 || next.endsWith("\n") ? "" : "\n";
+      next = `${next}${trailingNewline}
+${IMPORT_POINTER_LINE}
+`;
+      wrote = true;
+      results.push({ step: "pointer-import", path: target, status: "written" });
+    }
+    if (wrote) {
+      await atomicWriteText(target, next);
+    }
+  }
+  return results;
+}
+async function copyTextIdempotent(step, source, target) {
+  if (existsSync2(target)) {
+    try {
+      const existing = readFileSync(target, "utf8");
+      if (existing === source) {
+        return { step, path: target, status: "skipped", message: "up-to-date" };
+      }
+    } catch {
+    }
+  }
+  await mkdir2(dirname2(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 mkdir2(dirname2(target), { recursive: true });
+  await atomicWriteJson2(target, merged, { indent: 2 });
+  return { step, path: target, status: "written" };
+}
+async function readJsonObjectOrEmpty(path) {
+  try {
+    const raw = await readFile2(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 readFile2(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 = dirname2(fileURLToPath(import.meta.url));
+  let current = resolve2(startDir);
+  while (true) {
+    const candidate = join2(current, "templates", relativePath);
+    if (existsSync2(candidate)) {
+      return candidate;
+    }
+    const parent = dirname2(current);
+    if (parent === current || parse(current).root === current) {
+      throw new Error(`Template not found: templates/${relativePath} (searched up from ${startDir})`);
+    }
+    current = parent;
+  }
+}
+
+export {
+  createServerEntry,
+  normalizeConfigPath,
+  writeJsonClientConfig,
+  removeJsonClientConfigEntry,
+  ClaudeCodeCLIWriter,
+  CursorWriter,
+  SKILL_DESTINATIONS,
+  HOOK_SCRIPT_DESTINATIONS,
+  HOOK_CONFIG_TARGETS,
+  HOOK_CONFIG_ARRAY_PATHS,
+  FABRIC_HOOK_COMMAND_PATHS,
+  POINTER_LINE,
+  REVIEW_POINTER_LINE,
+  IMPORT_POINTER_LINE,
+  POINTER_TARGETS,
+  installFabricArchiveSkill,
+  installFabricReviewSkill,
+  installFabricImportSkill,
+  installArchiveHintHook,
+  installKnowledgeHintBroadHook,
+  installKnowledgeHintNarrowHook,
+  mergeClaudeCodeHookConfig,
+  mergeCodexHookConfig,
+  mergeCursorHookConfig,
+  addArchiveSkillPointer
+};