@fenglimg/fabric-server 1.8.0-rc.1 → 1.8.0-rc.3

package/dist/{chunk-E3BHIUIW.js → chunk-ZZGARZL5.js}

@@ -1142,7 +1142,7 @@ async function reconcileRules(projectRoot, opts) {
 }
 
 // src/services/doctor.ts
-import { existsSync as existsSync4, mkdirSync, readdirSync, readFileSync, rmdirSync, renameSync, statSync as statSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync, readdirSync, readFileSync, rmdirSync, renameSync, statSync as statSync3, unlinkSync } from "fs";
 import { access, readFile as readFile7, writeFile as writeFile2 } from "fs/promises";
 import { constants } from "fs";
 import { isAbsolute as isAbsolute3, join as join8, posix as posix2, resolve as resolve4 } from "path";
@@ -1911,6 +1911,8 @@ async function runDoctorReport(target) {
   const rulesDirUnindexed = inspectRulesDirUnindexed(projectRoot, meta);
   const stableIdCollision = await inspectStableIdCollisions(projectRoot);
   const claudeSkillLegacyPath = inspectClaudeSkillLegacyPath(projectRoot);
+  const claudeHookLegacyPath = inspectClaudeHookLegacyPath(projectRoot);
+  const codexSkillLegacyPath = inspectCodexSkillLegacyPath(projectRoot);
   const preexistingRootFiles = inspectPreexistingRootFiles(projectRoot);
   const legacyClientPaths = inspectLegacyClientPaths(projectRoot);
   const taxonomyExists = existsSync4(join8(projectRoot, ".fabric", "INITIAL_TAXONOMY.md"));
@@ -1931,6 +1933,8 @@ async function runDoctorReport(target) {
     createRulesDirUnindexedCheck(rulesDirUnindexed),
     createStableIdCollisionCheck(stableIdCollision),
     createClaudeSkillLegacyPathCheck(claudeSkillLegacyPath),
+    createClaudeHookLegacyPathCheck(claudeHookLegacyPath),
+    createCodexSkillLegacyPathCheck(codexSkillLegacyPath),
     createPreexistingRootFilesCheck(preexistingRootFiles),
     createLegacyClientPathCheck(legacyClientPaths)
   ];
@@ -2023,6 +2027,14 @@ async function runDoctorFix(target) {
     await fixClaudeSkillLegacyPath(projectRoot);
     fixed.push(findIssue(before.fixable_errors, "claude_skill_legacy_path"));
   }
+  if (before.fixable_errors.some((issue) => issue.code === "claude_hook_legacy_path")) {
+    await fixClaudeHookLegacyPath(projectRoot);
+    fixed.push(findIssue(before.fixable_errors, "claude_hook_legacy_path"));
+  }
+  if (before.fixable_errors.some((issue) => issue.code === "codex_skill_legacy_path")) {
+    await fixCodexSkillLegacyPath(projectRoot);
+    fixed.push(findIssue(before.fixable_errors, "codex_skill_legacy_path"));
+  }
   if (before.warnings.some((issue) => issue.code === "legacy_client_path_present")) {
     await fixLegacyClientPaths(projectRoot);
     fixed.push(findIssue(before.warnings, "legacy_client_path_present"));
@@ -2641,6 +2653,110 @@ async function fixClaudeSkillLegacyPath(projectRoot) {
     to: newPath
   });
 }
+var LEGACY_HOOK_FILENAME = "agents-md-init-reminder.cjs";
+var NEW_HOOK_FILENAME = "fabric-init-reminder.cjs";
+function inspectClaudeHookLegacyPath(projectRoot) {
+  const legacyHookPath = join8(projectRoot, ".claude", "hooks", LEGACY_HOOK_FILENAME);
+  const newHookPath = join8(projectRoot, ".claude", "hooks", NEW_HOOK_FILENAME);
+  const settingsPath = join8(projectRoot, ".claude", "settings.json");
+  const hasLegacyFile = existsSync4(legacyHookPath);
+  let hasLegacySettingsCommand = false;
+  if (existsSync4(settingsPath)) {
+    try {
+      const raw = readFileSync(settingsPath, "utf8");
+      hasLegacySettingsCommand = raw.includes(LEGACY_HOOK_FILENAME);
+    } catch {
+    }
+  }
+  return { hasLegacyFile, hasLegacySettingsCommand, legacyHookPath, newHookPath, settingsPath };
+}
+function createClaudeHookLegacyPathCheck(inspection) {
+  if (inspection.hasLegacyFile || inspection.hasLegacySettingsCommand) {
+    return issueCheck(
+      "Claude hook path",
+      "error",
+      "fixable_error",
+      "claude_hook_legacy_path",
+      `.claude/hooks/${LEGACY_HOOK_FILENAME} (or its reference in .claude/settings.json) exists at the legacy path. Run --fix to migrate to ${NEW_HOOK_FILENAME}.`,
+      `Run \`fab doctor --fix\` to rename ${LEGACY_HOOK_FILENAME} to ${NEW_HOOK_FILENAME} and update .claude/settings.json hook commands.`
+    );
+  }
+  return okCheck("Claude hook path", `.claude/hooks/${NEW_HOOK_FILENAME} is at the canonical path (or not present).`);
+}
+async function fixClaudeHookLegacyPath(projectRoot) {
+  const { hasLegacyFile, hasLegacySettingsCommand, legacyHookPath, newHookPath, settingsPath } = inspectClaudeHookLegacyPath(projectRoot);
+  if (hasLegacyFile) {
+    if (existsSync4(newHookPath)) {
+      unlinkSync(legacyHookPath);
+    } else {
+      mkdirSync(join8(newHookPath, ".."), { recursive: true });
+      renameSync(legacyHookPath, newHookPath);
+    }
+  }
+  if (hasLegacySettingsCommand) {
+    try {
+      const raw = readFileSync(settingsPath, "utf8");
+      const updated = raw.split(LEGACY_HOOK_FILENAME).join(NEW_HOOK_FILENAME);
+      if (updated !== raw) {
+        const parsed = JSON.parse(updated);
+        await atomicWriteJson2(settingsPath, parsed);
+      }
+    } catch {
+    }
+  }
+  if (hasLegacyFile || hasLegacySettingsCommand) {
+    await appendEventLedgerEvent(projectRoot, {
+      event_type: "claude_hook_path_migrated",
+      from: legacyHookPath,
+      to: newHookPath
+    });
+  }
+}
+function inspectCodexSkillLegacyPath(projectRoot) {
+  const legacyPath = join8(projectRoot, ".agents", "skills", "fabric-init", "SKILL.md");
+  const newPath = join8(projectRoot, ".codex", "skills", "fabric-init", "SKILL.md");
+  const hasLegacy = existsSync4(legacyPath) && !existsSync4(newPath);
+  return { hasLegacy, legacyPath, newPath };
+}
+function createCodexSkillLegacyPathCheck(inspection) {
+  if (inspection.hasLegacy) {
+    return issueCheck(
+      "Codex skill path",
+      "error",
+      "fixable_error",
+      "codex_skill_legacy_path",
+      `.agents/skills/fabric-init/SKILL.md exists at the legacy path. Codex CLI reads repo skills from .codex/skills/, not .agents/skills/. Run --fix to migrate it to .codex/skills/fabric-init/SKILL.md (user edits preserved).`,
+      "Run `fab doctor --fix` to move .agents/skills/fabric-init/ to .codex/skills/fabric-init/, preserving any user edits to SKILL.md."
+    );
+  }
+  return okCheck("Codex skill path", ".codex/skills/fabric-init/SKILL.md is at the canonical path (or not present).");
+}
+async function fixCodexSkillLegacyPath(projectRoot) {
+  const { hasLegacy, legacyPath, newPath } = inspectCodexSkillLegacyPath(projectRoot);
+  if (!hasLegacy) {
+    return;
+  }
+  mkdirSync(join8(newPath, ".."), { recursive: true });
+  renameSync(legacyPath, newPath);
+  const legacyDir = join8(legacyPath, "..");
+  try {
+    rmdirSync(legacyDir);
+  } catch {
+  }
+  try {
+    rmdirSync(join8(legacyDir, ".."));
+  } catch {
+  }
+  try {
+    rmdirSync(join8(legacyDir, "..", ".."));
+  } catch {
+  }
+  await appendEventLedgerEvent(projectRoot, {
+    event_type: "codex_skill_path_migrated",
+    from: legacyPath,
+    to: newPath
+  });
+}
 function inspectLegacyClientPaths(projectRoot) {
   const configPath = join8(projectRoot, "fabric.config.json");
   if (!existsSync4(configPath)) {

package/dist/{http-MEFXOG3L.js → http-PXFWUKCA.js}

@@ -15,7 +15,7 @@ import {
   readEventLedger,
   runDoctorReport,
   sha256
-} from "./chunk-E3BHIUIW.js";
+} from "./chunk-ZZGARZL5.js";
 
 // src/http.ts
 import { randomUUID as randomUUID2 } from "crypto";

package/dist/index.js

@@ -22,7 +22,7 @@ import {
   runDoctorReport,
   stableStringify,
   writeRuleMeta
-} from "./chunk-E3BHIUIW.js";
+} from "./chunk-ZZGARZL5.js";
 
 // src/index.ts
 import { existsSync as existsSync2 } from "fs";
@@ -312,7 +312,7 @@ function formatPreexistingRootMessage(projectRoot) {
 function createFabricServer(tracker) {
   const server = new McpServer({
     name: "fabric-context-server",
-    version: "1.8.0-rc.1"
+    version: "1.8.0-rc.3"
   });
   registerPlanContext(server, tracker);
   registerRuleSections(server, tracker);
@@ -406,7 +406,7 @@ function createShutdownHandler(deps) {
   };
 }
 async function startHttpServer(options) {
-  const { createFabricHttpApp } = await import("./http-MEFXOG3L.js");
+  const { createFabricHttpApp } = await import("./http-PXFWUKCA.js");
   const { port, projectRoot, host = "127.0.0.1", authToken, dashboardDistPath, dev } = options;
   const app = createFabricHttpApp({ projectRoot, host, authToken, dashboardDistPath, dev });
   return await new Promise((resolveServer, rejectServer) => {