@fenglimg/fabric-server 1.5.1 → 1.5.2

package/dist/index.js

@@ -1,23 +1,30 @@
 import {
   AGENTS_MD_RESOURCE_URI,
   FABRIC_DIR,
+  LEDGER_PATH,
+  LEGACY_LEDGER_PATH,
   appendEditIntentAuditEvents,
   appendLedgerEntry,
   approveHumanLock,
   atomicWriteText,
+  buildRulesPayload,
   contextCache,
+  getLedgerPath,
+  getLegacyLedgerPath,
   getRules,
   loadGetRulesContext,
+  loadMatchedRules,
+  matchRuleNodes,
   normalizeRulesPath,
   readAgentsMeta,
   readHumanLock,
   readHumanLockEntry,
   resolveProjectRoot,
-  resolveRulesForPath,
   runDoctorAuditReport,
+  runDoctorFix,
   runDoctorReport,
   sha256
-} from "./chunk-E3RZ276F.js";
+} from "./chunk-4G6VFG5N.js";
 
 // src/index.ts
 import { readFile } from "fs/promises";
@@ -149,16 +156,30 @@ async function planContext(projectRoot, input) {
   const context = await loadGetRulesContext(projectRoot);
   const stale = input.client_hash !== void 0 && input.client_hash !== context.meta.revision;
   const uniquePaths = dedupePaths(input.paths);
-  const entries = await Promise.all(
-    uniquePaths.map(async (path) => ({
-      path,
-      rules: await resolveRulesForPath(projectRoot, context, path, { dedupeByPath: true })
-    }))
+  const fileContentCache = /* @__PURE__ */ new Map();
+  const matchedNodesByPath = new Map(
+    uniquePaths.map((path) => [path, matchRuleNodes(context.meta, path)])
   );
+  const loadedByPath = new Map(
+    await Promise.all(
+      uniquePaths.map(async (path) => [
+        path,
+        await loadMatchedRules(projectRoot, matchedNodesByPath.get(path) ?? [], fileContentCache)
+      ])
+    )
+  );
+  const entries = uniquePaths.map((path) => ({
+    path,
+    rules: buildRulesPayload(context, loadedByPath.get(path) ?? { rules: [], stubs: [] }, {
+      dedupeByPath: true
+    })
+  }));
+  const shared = buildSharedView(context.meta.revision, uniquePaths, matchedNodesByPath, loadedByPath);
   return {
     revision_hash: context.meta.revision,
     stale,
-    entries
+    entries,
+    shared
   };
 }
 function dedupePaths(paths) {
@@ -172,6 +193,96 @@ function dedupePaths(paths) {
     return [normalizedPath];
   });
 }
+function buildSharedView(revision, uniquePaths, matchedNodesByPath, loadedByPath) {
+  const sharedEntriesByStableId = /* @__PURE__ */ new Map();
+  const descriptionStubByStableId = /* @__PURE__ */ new Map();
+  const derivedStableIds = /* @__PURE__ */ new Set();
+  const bundleStableIds = /* @__PURE__ */ new Set();
+  const fileMap = Object.fromEntries(
+    uniquePaths.map((path) => {
+      const matchedNodes = matchedNodesByPath.get(path) ?? [];
+      const loaded = loadedByPath.get(path) ?? { rules: [], stubs: [] };
+      const l1 = collectPerPathStableIds(loaded.rules, "L1");
+      const l2 = collectPerPathStableIds(loaded.rules, "L2");
+      const descriptionStubs = dedupeStableIds(loaded.stubs.map((stub) => stub.stable_id));
+      for (const matchedNode of matchedNodes) {
+        bundleStableIds.add(matchedNode.stable_id);
+        if (matchedNode.identity_source === "derived") {
+          derivedStableIds.add(matchedNode.stable_id);
+        }
+      }
+      for (const rule of loaded.rules) {
+        sharedEntriesByStableId.set(rule.stable_id, {
+          stable_id: rule.stable_id,
+          identity_source: rule.identity_source,
+          level: rule.level,
+          path: rule.entry.path,
+          content: rule.entry.content
+        });
+      }
+      for (const stub of loaded.stubs) {
+        descriptionStubByStableId.set(stub.stable_id, stub);
+      }
+      return [
+        path,
+        {
+          L1: l1,
+          L2: l2,
+          description_stubs: descriptionStubs
+        }
+      ];
+    })
+  );
+  const descriptionStubUnion = Array.from(descriptionStubByStableId.values()).sort(compareStableIds);
+  const sharedEntries = Array.from(sharedEntriesByStableId.values()).sort(compareStableIds);
+  const preflightDiagnostics = [];
+  for (const path of uniquePaths) {
+    const slice = fileMap[path];
+    if (slice !== void 0 && slice.L1.length === 0 && slice.L2.length === 0 && slice.description_stubs.length > 0) {
+      preflightDiagnostics.push({
+        code: "description_stub_only",
+        severity: "info",
+        path,
+        stable_ids: slice.description_stubs,
+        message: `Path ${path} only matched description stubs and no loadable L1/L2 rules. Run fab_get_rules on the final target before editing if you need the full rule text.`
+      });
+    }
+  }
+  if (derivedStableIds.size > 0) {
+    const stableIds = Array.from(derivedStableIds).sort();
+    preflightDiagnostics.push({
+      code: "derived_identity",
+      severity: "warn",
+      stable_ids: stableIds,
+      message: `Resolved bundle includes ${stableIds.length} rule node${stableIds.length === 1 ? "" : "s"} that still rely on derived identities. Declare \`<!-- fab:rule-id ... -->\` in the source rule file to stabilize audit references.`
+    });
+  }
+  return {
+    resolved_bundle_id: sha256([revision, ...Array.from(bundleStableIds).sort()].join("\n")),
+    shared_entries: sharedEntries,
+    file_map: fileMap,
+    description_stub_union: descriptionStubUnion,
+    preflight_diagnostics: preflightDiagnostics
+  };
+}
+function dedupeStableIds(stableIds) {
+  return Array.from(new Set(stableIds));
+}
+function collectPerPathStableIds(rules, level) {
+  const seenPaths = /* @__PURE__ */ new Set();
+  const stableIds = [];
+  for (const rule of rules) {
+    if (rule.level !== level || seenPaths.has(rule.entry.path)) {
+      continue;
+    }
+    seenPaths.add(rule.entry.path);
+    stableIds.push(rule.stable_id);
+  }
+  return stableIds;
+}
+function compareStableIds(left, right) {
+  return left.stable_id.localeCompare(right.stable_id);
+}
 
 // src/tools/plan-context.ts
 var inputSchema3 = {
@@ -180,11 +291,13 @@ var inputSchema3 = {
 };
 var rulesEntrySchema2 = z3.object({ path: z3.string(), content: z3.string() });
 var humanLockedSchema2 = z3.object({ file: z3.string(), excerpt: z3.string() });
+var descriptionStubSchema2 = z3.object({ path: z3.string(), description: z3.string() });
 var rulesPayloadSchema = z3.object({
   L0: z3.string(),
   L1: z3.array(rulesEntrySchema2),
   L2: z3.array(rulesEntrySchema2),
-  human_locked_nearby: z3.array(humanLockedSchema2)
+  human_locked_nearby: z3.array(humanLockedSchema2),
+  description_stubs: z3.array(descriptionStubSchema2).optional()
 });
 var outputSchema3 = z3.object({
   revision_hash: z3.string(),
@@ -194,7 +307,44 @@ var outputSchema3 = z3.object({
       path: z3.string(),
       rules: rulesPayloadSchema
     })
-  )
+  ),
+  shared: z3.object({
+    resolved_bundle_id: z3.string(),
+    shared_entries: z3.array(
+      z3.object({
+        stable_id: z3.string(),
+        identity_source: z3.enum(["declared", "derived"]),
+        level: z3.enum(["L1", "L2"]),
+        path: z3.string(),
+        content: z3.string()
+      })
+    ),
+    file_map: z3.record(
+      z3.object({
+        L1: z3.array(z3.string()),
+        L2: z3.array(z3.string()),
+        description_stubs: z3.array(z3.string())
+      })
+    ),
+    description_stub_union: z3.array(
+      z3.object({
+        stable_id: z3.string(),
+        identity_source: z3.enum(["declared", "derived"]),
+        level: z3.enum(["L1", "L2"]),
+        path: z3.string(),
+        description: z3.string()
+      })
+    ),
+    preflight_diagnostics: z3.array(
+      z3.object({
+        code: z3.enum(["description_stub_only", "derived_identity"]),
+        severity: z3.enum(["info", "warn"]),
+        message: z3.string(),
+        path: z3.string().optional(),
+        stable_ids: z3.array(z3.string()).optional()
+      })
+    )
+  })
 });
 function registerPlanContext(server) {
   server.registerTool(
@@ -339,7 +489,7 @@ function formatError(error) {
 function createFabricServer() {
   const server = new McpServer({
     name: "fabric-context-server",
-    version: "1.5.1"
+    version: "1.5.2"
   });
   registerGetRules(server);
   registerPlanContext(server);
@@ -374,7 +524,7 @@ async function startStdioServer() {
   await server.connect(transport);
 }
 async function startHttpServer(options) {
-  const { createFabricHttpApp } = await import("./http-BVF4GWIM.js");
+  const { createFabricHttpApp } = await import("./http-U4S7BUP4.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) => {
@@ -401,11 +551,16 @@ if (isMainModule) {
 }
 export {
   AGENTS_MD_RESOURCE_URI,
+  LEDGER_PATH,
+  LEGACY_LEDGER_PATH,
   approveHumanLock,
   createFabricServer,
+  getLedgerPath,
+  getLegacyLedgerPath,
   readHumanLock,
   readHumanLockEntry,
   runDoctorAuditReport,
+  runDoctorFix,
   runDoctorReport,
   startHttpServer,
   startStdioServer