@fenglimg/fabric-server 1.0.0 → 1.2.0

package/dist/index.js

@@ -1,12 +1,16 @@
 import {
   FABRIC_DIR,
+  appendEditIntentAuditEvents,
+  appendGetRulesAuditEvent,
   appendLedgerEntry,
   atomicWriteText,
   readAgentsMeta,
   readHumanLock,
   resolveProjectRoot,
+  runDoctorAuditReport,
+  runDoctorReport,
   sha256
-} from "./chunk-KZO24GUQ.js";
+} from "./chunk-U3IQH5H6.js";
 
 // src/index.ts
 import { resolve } from "path";
@@ -25,6 +29,15 @@ async function appendIntent(projectRoot, input) {
     ts,
     source: "ai"
   });
+  try {
+    await appendEditIntentAuditEvents(projectRoot, {
+      affected_paths: entry.affected_paths,
+      intent: entry.intent,
+      ledger_entry_id: entry.id,
+      ts
+    });
+  } catch {
+  }
   return {
     success: true,
     timestamp: ts,
@@ -76,17 +89,67 @@ var PRIORITY_ORDER = {
   low: 2
 };
 async function getRules(projectRoot, input) {
+  const context = await loadGetRulesContext(projectRoot);
+  const stale = input.client_hash !== void 0 && input.client_hash !== context.meta.revision;
+  const rules = await resolveRulesForPath(projectRoot, context, input.path);
+  const result = {
+    revision_hash: context.meta.revision,
+    stale,
+    rules
+  };
+  try {
+    await appendGetRulesAuditEvent(projectRoot, {
+      path: input.path,
+      client_hash: input.client_hash
+    });
+  } catch {
+  }
+  return result;
+}
+async function loadGetRulesContext(projectRoot) {
   const meta = readAgentsMeta(projectRoot);
-  const stale = input.client_hash !== void 0 && input.client_hash !== meta.revision;
-  const requestedPath = normalizePath(input.path);
   const l0Content = await readFile(join(projectRoot, "AGENTS.md"), "utf8");
-  const matchedNodes = Object.entries(meta.nodes).filter(([, node]) => minimatch(requestedPath, normalizePath(node.scope_glob), { dot: true })).sort((left, right) => {
+  const humanLockedNearby = (await readHumanLock(projectRoot)).map((entry) => ({
+    file: entry.file,
+    excerpt: JSON.stringify(entry)
+  }));
+  return {
+    meta,
+    l0Content,
+    humanLockedNearby
+  };
+}
+async function resolveRulesForPath(projectRoot, context, path, options = {}) {
+  const loadedRules = await loadRulesForPath(projectRoot, context.meta, path);
+  const { L1, L2 } = partitionRulesByLevel(loadedRules, options.dedupeByPath ?? false);
+  return {
+    L0: context.l0Content,
+    L1,
+    L2,
+    human_locked_nearby: context.humanLockedNearby
+  };
+}
+function normalizeRulesPath(value) {
+  return value.replaceAll("\\", "/");
+}
+function classifyNode(nodeId) {
+  if (nodeId.startsWith("L1/")) {
+    return "L1";
+  }
+  if (nodeId.startsWith("L2/")) {
+    return "L2";
+  }
+  return null;
+}
+async function loadRulesForPath(projectRoot, meta, path) {
+  const requestedPath = normalizeRulesPath(path);
+  const matchedNodes = Object.entries(meta.nodes).filter(([, node]) => minimatch(requestedPath, normalizeRulesPath(node.scope_glob), { dot: true })).sort((left, right) => {
     const [leftId, leftNode] = left;
     const [rightId, rightNode] = right;
     const priorityDelta = PRIORITY_ORDER[leftNode.priority] - PRIORITY_ORDER[rightNode.priority];
     return priorityDelta !== 0 ? priorityDelta : leftId.localeCompare(rightId);
   });
-  const loadedRules = await Promise.all(
+  return await Promise.all(
     matchedNodes.map(async ([nodeId, node]) => ({
       level: classifyNode(nodeId),
       entry: {
@@ -95,6 +158,8 @@ async function getRules(projectRoot, input) {
       }
     }))
   );
+}
+function partitionRulesByLevel(loadedRules, dedupeByPath) {
   const l1 = [];
   const l2 = [];
   for (const rule of loadedRules) {
@@ -106,32 +171,20 @@ async function getRules(projectRoot, input) {
       l2.push(rule.entry);
     }
   }
-  const humanLockedNearby = (await readHumanLock(projectRoot)).map((entry) => ({
-    file: entry.file,
-    excerpt: JSON.stringify(entry)
-  }));
   return {
-    revision_hash: meta.revision,
-    stale,
-    rules: {
-      L0: l0Content,
-      L1: l1,
-      L2: l2,
-      human_locked_nearby: humanLockedNearby
-    }
+    L1: dedupeByPath ? dedupeEntriesByPath(l1) : l1,
+    L2: dedupeByPath ? dedupeEntriesByPath(l2) : l2
   };
 }
-function normalizePath(value) {
-  return value.replaceAll("\\", "/");
-}
-function classifyNode(nodeId) {
-  if (nodeId.startsWith("L1/")) {
-    return "L1";
-  }
-  if (nodeId.startsWith("L2/")) {
-    return "L2";
-  }
-  return null;
+function dedupeEntriesByPath(entries) {
+  const seenPaths = /* @__PURE__ */ new Set();
+  return entries.filter((entry) => {
+    if (seenPaths.has(entry.path)) {
+      return false;
+    }
+    seenPaths.add(entry.path);
+    return true;
+  });
 }
 
 // src/tools/get-rules.ts
@@ -162,9 +215,69 @@ function registerGetRules(server) {
   );
 }
 
-// src/tools/update-registry.ts
+// src/tools/plan-context.ts
 import { z as z2 } from "zod";
 
+// src/services/plan-context.ts
+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 })
+    }))
+  );
+  return {
+    revision_hash: context.meta.revision,
+    stale,
+    entries
+  };
+}
+function dedupePaths(paths) {
+  const seenPaths = /* @__PURE__ */ new Set();
+  return paths.flatMap((path) => {
+    const normalizedPath = normalizeRulesPath(path);
+    if (seenPaths.has(normalizedPath)) {
+      return [];
+    }
+    seenPaths.add(normalizedPath);
+    return [normalizedPath];
+  });
+}
+
+// src/tools/plan-context.ts
+var inputSchema3 = {
+  paths: z2.array(z2.string()).min(1).describe("Candidate file paths to query rules for during planning or architecture review"),
+  client_hash: z2.string().optional().describe("Revision hash from a prior fab_plan_context response; enables stale detection")
+};
+function createTextResponse3(payload) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(payload)
+      }
+    ]
+  };
+}
+function registerPlanContext(server) {
+  server.tool(
+    "fab_plan_context",
+    "Use during plan or architecture phases to batch-query Fabric rules for multiple candidate paths in one round-trip.",
+    inputSchema3,
+    async ({ paths, client_hash }) => {
+      const projectRoot = resolveProjectRoot();
+      const result = await planContext(projectRoot, { paths, client_hash });
+      return createTextResponse3(result);
+    }
+  );
+}
+
+// src/tools/update-registry.ts
+import { z as z3 } from "zod";
+
 // src/services/update-registry.ts
 import { agentsMetaNodeSchema } from "@fenglimg/fabric-shared";
 import { join as join2 } from "path";
@@ -231,12 +344,12 @@ function applyRegistryOperation(meta, op, nodeId, data) {
 }
 
 // src/tools/update-registry.ts
-var inputSchema3 = {
-  op: z2.enum(["add-node", "remove-node", "update-node"]),
-  node_id: z2.string(),
-  data: z2.record(z2.unknown()).optional()
+var inputSchema4 = {
+  op: z3.enum(["add-node", "remove-node", "update-node"]),
+  node_id: z3.string(),
+  data: z3.record(z3.unknown()).optional()
 };
-function createTextResponse3(payload) {
+function createTextResponse4(payload) {
   return {
     content: [
       {
@@ -250,11 +363,11 @@ function registerUpdateRegistry(server) {
   server.tool(
     "fab_update_registry",
     "MANDATORY: Call to add, remove, or update Fabric registry nodes instead of editing registry files directly.",
-    inputSchema3,
+    inputSchema4,
     async ({ op, node_id, data }) => {
       const projectRoot = resolveProjectRoot();
       const result = await updateRegistry(projectRoot, { op, node_id, data });
-      return createTextResponse3(result);
+      return createTextResponse4(result);
     }
   );
 }
@@ -273,9 +386,10 @@ function formatError(error) {
 function createFabricServer() {
   const server = new McpServer({
     name: "fabric-context-server",
-    version: "1.0.0"
+    version: "1.2.0"
   });
   registerGetRules(server);
+  registerPlanContext(server);
   registerAppendIntent(server);
   registerUpdateRegistry(server);
   return server;
@@ -286,7 +400,7 @@ async function startStdioServer() {
   await server.connect(transport);
 }
 async function startHttpServer(options) {
-  const { createFabricHttpApp } = await import("./http-3BNWQWPP.js");
+  const { createFabricHttpApp } = await import("./http-EQBDM4C7.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) => {
@@ -310,6 +424,8 @@ if (isMainModule) {
 }
 export {
   createFabricServer,
+  runDoctorAuditReport,
+  runDoctorReport,
   startHttpServer,
   startStdioServer
 };