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

package/dist/chunk-4HC5ZK7H.js

@@ -0,0 +1,598 @@
+#!/usr/bin/env node
+import {
+  deepMerge
+} from "./chunk-MF3OTILQ.js";
+
+// src/install/write-bootstrap-snapshot.ts
+import { existsSync, readFileSync } from "fs";
+import { mkdir } from "fs/promises";
+import { dirname, join } from "path";
+import { atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
+import { BOOTSTRAP_CANONICAL } from "@fenglimg/fabric-shared/templates/bootstrap-canonical";
+var FABRIC_AGENTS_RELPATH = join(".fabric", "AGENTS.md");
+var PROJECT_RULES_RELPATH = join(".fabric", "project-rules.md");
+function fabricAgentsSnapshotPath(targetRoot) {
+  return join(targetRoot, FABRIC_AGENTS_RELPATH);
+}
+function projectRulesPath(targetRoot) {
+  return join(targetRoot, PROJECT_RULES_RELPATH);
+}
+function readProjectRulesIfPresent(targetRoot) {
+  const path = projectRulesPath(targetRoot);
+  if (!existsSync(path)) return null;
+  return readFileSync(path, "utf8");
+}
+async function writeFabricAgentsSnapshot(targetRoot) {
+  const step = "bootstrap-snapshot";
+  const target = fabricAgentsSnapshotPath(targetRoot);
+  if (existsSync(target)) {
+    try {
+      const existing = readFileSync(target, "utf8");
+      if (existing === BOOTSTRAP_CANONICAL) {
+        return { step, path: target, status: "skipped", message: "up-to-date" };
+      }
+    } catch {
+    }
+  }
+  await mkdir(dirname(target), { recursive: true });
+  await atomicWriteText(target, BOOTSTRAP_CANONICAL);
+  return { step, path: target, status: "written" };
+}
+
+// src/install/skills-and-hooks.ts
+import { chmodSync, existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { mkdir as mkdir2, readFile, rm } from "fs/promises";
+import { dirname as dirname2, join as join2, parse, resolve } from "path";
+import { fileURLToPath } from "url";
+import { atomicWriteJson, atomicWriteText as atomicWriteText2 } from "@fenglimg/fabric-shared/node/atomic-write";
+import {
+  BOOTSTRAP_MARKER_BEGIN,
+  BOOTSTRAP_MARKER_END,
+  BOOTSTRAP_REGEX,
+  LEGACY_KB_REGEX
+} from "@fenglimg/fabric-shared/templates/bootstrap-canonical";
+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 HOOK_LIB_TEMPLATE_DIR_REL = "hooks/lib";
+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_LIB_DESTINATIONS = [
+  ".claude/hooks/lib",
+  ".codex/hooks/lib",
+  ".cursor/hooks/lib"
+];
+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"
+  }
+};
+function readFabricLanguagePreference(projectRoot) {
+  const configPath = join2(projectRoot, ".fabric", "fabric-config.json");
+  if (!existsSync2(configPath)) {
+    return "match-existing";
+  }
+  try {
+    const raw = readFileSync2(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";
+  }
+}
+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 installHookLibs(projectRoot, _options = {}) {
+  const libTemplateDir = findTemplatePath(HOOK_LIB_TEMPLATE_DIR_REL);
+  let libFiles;
+  try {
+    libFiles = readdirSync(libTemplateDir).filter((name) => name.endsWith(".cjs"));
+  } catch (error) {
+    return [
+      {
+        step: "hook-lib",
+        path: libTemplateDir,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    ];
+  }
+  if (libFiles.length === 0) {
+    return [
+      {
+        step: "hook-lib",
+        path: libTemplateDir,
+        status: "skipped",
+        message: "no-libs-to-ship"
+      }
+    ];
+  }
+  const results = [];
+  for (const libFile of libFiles) {
+    const sourcePath = join2(libTemplateDir, libFile);
+    let source;
+    try {
+      source = readFileSync2(sourcePath, "utf8");
+    } catch (error) {
+      results.push({
+        step: "hook-lib",
+        path: sourcePath,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      });
+      continue;
+    }
+    for (const destDirRel of HOOK_LIB_DESTINATIONS) {
+      const target = join2(projectRoot, destDirRel, libFile);
+      results.push(await copyTextIdempotent("hook-lib", source, target));
+    }
+  }
+  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]
+  );
+}
+function buildManagedBlockBody(targetRoot) {
+  const snapshotPath = fabricAgentsSnapshotPath(targetRoot);
+  const snapshot = readFileSync2(snapshotPath, "utf8");
+  const projectRules = readProjectRulesIfPresent(targetRoot);
+  if (projectRules === null) {
+    return snapshot;
+  }
+  return `${snapshot}
+---
+${projectRules}`;
+}
+function wrapInBootstrapMarkers(body) {
+  return `${BOOTSTRAP_MARKER_BEGIN}
+${body}
+${BOOTSTRAP_MARKER_END}`;
+}
+function stripLegacyKnowledgeBaseSection(existing) {
+  const match = existing.match(LEGACY_KB_REGEX);
+  if (match === null) return existing;
+  const before = existing.slice(0, match.index ?? 0);
+  const after = existing.slice((match.index ?? 0) + match[0].length);
+  return `${before}${after.replace(/^\r?\n/, "")}`;
+}
+var CLAUDE_BOOTSTRAP_HEADER = "# Project Knowledge";
+var CLAUDE_AGENTS_IMPORT_LINE = "@.fabric/AGENTS.md";
+var CLAUDE_PROJECT_RULES_IMPORT_LINE = "@.fabric/project-rules.md";
+async function writeClaudeBootstrapThinShell(targetRoot, _options = {}) {
+  const step = "bootstrap-claude";
+  const target = join2(targetRoot, "CLAUDE.md");
+  const projectRulesPresent = existsSync2(projectRulesPath(targetRoot));
+  let existing = "";
+  let preExisted = false;
+  if (existsSync2(target)) {
+    preExisted = true;
+    try {
+      existing = await readFile(target, "utf8");
+    } catch (error) {
+      return {
+        step,
+        path: target,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  let next = stripLegacyKnowledgeBaseSection(existing);
+  if (!projectRulesPresent) {
+    next = removeImportLine(next, CLAUDE_PROJECT_RULES_IMPORT_LINE);
+  }
+  if (!preExisted && next.length === 0) {
+    next = `${CLAUDE_BOOTSTRAP_HEADER}
+`;
+  }
+  next = ensureImportLine(next, CLAUDE_AGENTS_IMPORT_LINE);
+  if (projectRulesPresent) {
+    next = ensureImportLine(next, CLAUDE_PROJECT_RULES_IMPORT_LINE);
+  }
+  if (next === existing) {
+    return { step, path: target, status: "skipped", message: "up-to-date" };
+  }
+  try {
+    await mkdir2(dirname2(target), { recursive: true });
+    await atomicWriteText2(target, next);
+    return { step, path: target, status: "written" };
+  } catch (error) {
+    return {
+      step,
+      path: target,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function ensureImportLine(content, line) {
+  if (hasExactLine(content, line)) return content;
+  if (content.length === 0) return `${line}
+`;
+  const endsWithBlank = content.endsWith("\n\n");
+  const endsWithNewline = content.endsWith("\n");
+  if (endsWithBlank) {
+    return `${content}${line}
+`;
+  }
+  if (endsWithNewline) {
+    return `${content}
+${line}
+`;
+  }
+  return `${content}
+
+${line}
+`;
+}
+function removeImportLine(content, line) {
+  const lines = content.split(/\r?\n/);
+  const filtered = lines.filter((l) => l.replace(/\s+$/, "") !== line);
+  return filtered.join("\n");
+}
+function hasExactLine(content, line) {
+  const lines = content.split(/\r?\n/);
+  return lines.some((l) => l.replace(/\s+$/, "") === line);
+}
+async function writeCodexBootstrapManagedBlock(targetRoot, _options = {}) {
+  const step = "bootstrap-codex";
+  const target = join2(targetRoot, "AGENTS.md");
+  let existing = "";
+  if (existsSync2(target)) {
+    try {
+      existing = await readFile(target, "utf8");
+    } catch (error) {
+      return {
+        step,
+        path: target,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  const body = buildManagedBlockBody(targetRoot);
+  const managedBlock = wrapInBootstrapMarkers(body);
+  const stripped = stripLegacyKnowledgeBaseSection(existing);
+  let next;
+  const match = stripped.match(BOOTSTRAP_REGEX);
+  if (match !== null) {
+    const before = stripped.slice(0, match.index ?? 0);
+    const after = stripped.slice((match.index ?? 0) + match[0].length);
+    const cleaned = `${before}${after.replace(/^\r?\n/, "")}`;
+    const trailingNewline = cleaned.length === 0 || cleaned.endsWith("\n") ? "" : "\n";
+    next = `${cleaned}${trailingNewline}${cleaned.length === 0 ? "" : "\n"}${managedBlock}
+`;
+  } else {
+    if (stripped.length === 0) {
+      next = `${managedBlock}
+`;
+    } else {
+      const trailingNewline = stripped.endsWith("\n") ? "" : "\n";
+      next = `${stripped}${trailingNewline}
+${managedBlock}
+`;
+    }
+  }
+  if (next === existing) {
+    return { step, path: target, status: "skipped", message: "up-to-date" };
+  }
+  try {
+    await mkdir2(dirname2(target), { recursive: true });
+    await atomicWriteText2(target, next);
+    return { step, path: target, status: "written" };
+  } catch (error) {
+    return {
+      step,
+      path: target,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+var CURSOR_RULE_FRONT_MATTER = "---\nalwaysApply: true\ndescription: Fabric Protocol bootstrap rules\n---\n\n";
+var CURSOR_LEGACY_FLAT_FILE_REL = join2(".cursor", "rules");
+var CURSOR_BOOTSTRAP_MDC_REL = join2(".cursor", "rules", "fabric-bootstrap.mdc");
+async function writeCursorBootstrapManagedBlock(targetRoot, _options = {}) {
+  const step = "bootstrap-cursor";
+  const target = join2(targetRoot, CURSOR_BOOTSTRAP_MDC_REL);
+  const legacyFlatFile = join2(targetRoot, CURSOR_LEGACY_FLAT_FILE_REL);
+  try {
+    if (existsSync2(legacyFlatFile)) {
+      const stat = statSync(legacyFlatFile);
+      if (stat.isFile()) {
+        await rm(legacyFlatFile, { force: true });
+      }
+    }
+  } catch {
+  }
+  const body = buildManagedBlockBody(targetRoot);
+  const managedBlock = wrapInBootstrapMarkers(body);
+  const expected = `${CURSOR_RULE_FRONT_MATTER}${managedBlock}
+`;
+  let existing = "";
+  if (existsSync2(target)) {
+    try {
+      existing = await readFile(target, "utf8");
+    } catch (error) {
+      return {
+        step,
+        path: target,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  if (existing === expected) {
+    return { step, path: target, status: "skipped", message: "up-to-date" };
+  }
+  try {
+    await mkdir2(dirname2(target), { recursive: true });
+    await atomicWriteText2(target, expected);
+    return { step, path: target, status: "written" };
+  } catch (error) {
+    return {
+      step,
+      path: target,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function copyTextIdempotent(step, source, target) {
+  if (existsSync2(target)) {
+    try {
+      const existing = readFileSync2(target, "utf8");
+      if (existing === source) {
+        return { step, path: target, status: "skipped", message: "up-to-date" };
+      }
+    } catch {
+    }
+  }
+  await mkdir2(dirname2(target), { recursive: true });
+  await atomicWriteText2(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 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 = dirname2(fileURLToPath(import.meta.url));
+  let current = resolve(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 {
+  fabricAgentsSnapshotPath,
+  writeFabricAgentsSnapshot,
+  SKILL_DESTINATIONS,
+  HOOK_SCRIPT_DESTINATIONS,
+  HOOK_LIB_DESTINATIONS,
+  HOOK_CONFIG_TARGETS,
+  HOOK_CONFIG_ARRAY_PATHS,
+  FABRIC_HOOK_COMMAND_PATHS,
+  readFabricLanguagePreference,
+  installFabricArchiveSkill,
+  installFabricReviewSkill,
+  installFabricImportSkill,
+  installArchiveHintHook,
+  installKnowledgeHintBroadHook,
+  installKnowledgeHintNarrowHook,
+  installHookLibs,
+  mergeClaudeCodeHookConfig,
+  mergeCodexHookConfig,
+  mergeCursorHookConfig,
+  writeClaudeBootstrapThinShell,
+  writeCodexBootstrapManagedBlock,
+  writeCursorBootstrapManagedBlock
+};

package/dist/{chunk-AXIFEVAS.js → chunk-FNO7CQDG.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-6ICJICVU.js";
 import {
   readFabricConfig
-} from "./chunk-OBQU6NHO.js";
+} from "./chunk-ZSESMG6L.js";
 
 // src/commands/scan.ts
 import { createHash } from "crypto";