@fenglimg/fabric-server 1.2.0 → 1.3.1

package/dist/index.js

@@ -1,25 +1,29 @@
 import {
+  AGENTS_MD_RESOURCE_URI,
   FABRIC_DIR,
   appendEditIntentAuditEvents,
   appendGetRulesAuditEvent,
   appendLedgerEntry,
   atomicWriteText,
+  contextCache,
   readAgentsMeta,
   readHumanLock,
   resolveProjectRoot,
   runDoctorAuditReport,
   runDoctorReport,
   sha256
-} from "./chunk-U3IQH5H6.js";
+} from "./chunk-GU7AMRM3.js";
 
 // src/index.ts
-import { resolve } from "path";
+import { readFile as readFile2 } from "fs/promises";
+import { join as join3, resolve } from "path";
 import { fileURLToPath } from "url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/tools/append-intent.ts
 import { aiLedgerEntrySchema } from "@fenglimg/fabric-shared";
+import { z } from "zod";
 
 // src/services/append-intent.ts
 async function appendIntent(projectRoot, input) {
@@ -29,19 +33,22 @@ async function appendIntent(projectRoot, input) {
     ts,
     source: "ai"
   });
+  let compliance;
   try {
-    await appendEditIntentAuditEvents(projectRoot, {
+    const auditResult = await appendEditIntentAuditEvents(projectRoot, {
       affected_paths: entry.affected_paths,
       intent: entry.intent,
       ledger_entry_id: entry.id,
       ts
     });
+    compliance = auditResult.compliance;
   } catch {
   }
   return {
     success: true,
     timestamp: ts,
-    entry
+    entry,
+    compliance
   };
 }
 
@@ -53,31 +60,44 @@ var inputSchema = {
     ts: true
   })
 };
-function createTextResponse(payload) {
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(payload)
-      }
-    ]
-  };
-}
+var outputSchema = z.object({
+  success: z.boolean(),
+  timestamp: z.number(),
+  entry: z.record(z.unknown()),
+  compliance: z.object({
+    compliant: z.boolean(),
+    matched_get_rules_ts: z.string().nullable(),
+    window_ms: z.number()
+  }).optional()
+});
 function registerAppendIntent(server) {
-  server.tool(
+  server.registerTool(
     "fab_append_intent",
-    "MANDATORY: Call after a completed task to append an intent ledger entry for Fabric.",
-    inputSchema,
+    {
+      description: "Call after a completed task to append an intent ledger entry for Fabric.",
+      inputSchema,
+      outputSchema,
+      annotations: { readOnlyHint: false }
+    },
     async ({ entry }) => {
       const projectRoot = resolveProjectRoot();
       const result = await appendIntent(projectRoot, { entry });
-      return createTextResponse(result);
+      const structuredContent = {
+        success: result.success,
+        timestamp: result.timestamp,
+        entry: { ...result.entry },
+        compliance: result.compliance
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        structuredContent
+      };
     }
   );
 }
 
 // src/tools/get-rules.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 
 // src/services/get-rules.ts
 import { readFile } from "fs/promises";
@@ -107,17 +127,23 @@ async function getRules(projectRoot, input) {
   return result;
 }
 async function loadGetRulesContext(projectRoot) {
-  const meta = readAgentsMeta(projectRoot);
-  const l0Content = await readFile(join(projectRoot, "AGENTS.md"), "utf8");
+  const cached = contextCache.get("context", projectRoot);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const meta = await readAgentsMeta(projectRoot);
+  const l0Content = await readFile(join(projectRoot, ".fabric", "bootstrap", "README.md"), "utf8");
   const humanLockedNearby = (await readHumanLock(projectRoot)).map((entry) => ({
     file: entry.file,
     excerpt: JSON.stringify(entry)
   }));
-  return {
+  const context = {
     meta,
     l0Content,
     humanLockedNearby
   };
+  contextCache.set("context", projectRoot, context);
+  return context;
 }
 async function resolveRulesForPath(projectRoot, context, path, options = {}) {
   const loadedRules = await loadRulesForPath(projectRoot, context.meta, path);
@@ -189,34 +215,43 @@ function dedupeEntriesByPath(entries) {
 
 // src/tools/get-rules.ts
 var inputSchema2 = {
-  path: z.string().describe("Target file path to query rules for"),
-  client_hash: z.string().optional().describe("Revision hash from prior fab_get_rules response; enables stale detection")
+  path: z2.string().describe("Target file path to query rules for"),
+  client_hash: z2.string().optional().describe("Revision hash from prior fab_get_rules response; enables stale detection")
 };
-function createTextResponse2(payload) {
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(payload)
-      }
-    ]
-  };
-}
+var rulesEntrySchema = z2.object({ path: z2.string(), content: z2.string() });
+var humanLockedSchema = z2.object({ file: z2.string(), excerpt: z2.string() });
+var outputSchema2 = z2.object({
+  revision_hash: z2.string(),
+  stale: z2.boolean(),
+  rules: z2.object({
+    L0: z2.string(),
+    L1: z2.array(rulesEntrySchema),
+    L2: z2.array(rulesEntrySchema),
+    human_locked_nearby: z2.array(humanLockedSchema)
+  })
+});
 function registerGetRules(server) {
-  server.tool(
+  server.registerTool(
     "fab_get_rules",
-    "MANDATORY: Call before modifying any file to retrieve Fabric rules for a target path.",
-    inputSchema2,
+    {
+      description: "Call before modifying any file to retrieve Fabric rules for a target path.",
+      inputSchema: inputSchema2,
+      outputSchema: outputSchema2,
+      annotations: { readOnlyHint: true }
+    },
     async ({ path, client_hash }) => {
       const projectRoot = resolveProjectRoot();
       const result = await getRules(projectRoot, { path, client_hash });
-      return createTextResponse2(result);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        structuredContent: result
+      };
     }
   );
 }
 
 // src/tools/plan-context.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/services/plan-context.ts
 async function planContext(projectRoot, input) {
@@ -249,41 +284,57 @@ function dedupePaths(paths) {
 
 // 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")
+  paths: z3.array(z3.string()).min(2).describe("Candidate file paths to query rules for during planning or architecture review"),
+  client_hash: z3.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)
-      }
-    ]
-  };
-}
+var rulesEntrySchema2 = z3.object({ path: z3.string(), content: z3.string() });
+var humanLockedSchema2 = z3.object({ file: z3.string(), excerpt: z3.string() });
+var rulesPayloadSchema = z3.object({
+  L0: z3.string(),
+  L1: z3.array(rulesEntrySchema2),
+  L2: z3.array(rulesEntrySchema2),
+  human_locked_nearby: z3.array(humanLockedSchema2)
+});
+var outputSchema3 = z3.object({
+  revision_hash: z3.string(),
+  stale: z3.boolean(),
+  entries: z3.array(
+    z3.object({
+      path: z3.string(),
+      rules: rulesPayloadSchema
+    })
+  )
+});
 function registerPlanContext(server) {
-  server.tool(
+  server.registerTool(
     "fab_plan_context",
-    "Use during plan or architecture phases to batch-query Fabric rules for multiple candidate paths in one round-trip.",
-    inputSchema3,
+    {
+      description: "Use during plan or architecture phases to batch-query Fabric rules for multiple candidate paths in one round-trip. Use fab_get_rules for single-file queries; use fab_plan_context for 2+ files.",
+      inputSchema: inputSchema3,
+      outputSchema: outputSchema3,
+      annotations: { readOnlyHint: true }
+    },
     async ({ paths, client_hash }) => {
       const projectRoot = resolveProjectRoot();
       const result = await planContext(projectRoot, { paths, client_hash });
-      return createTextResponse3(result);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        structuredContent: result
+      };
     }
   );
 }
 
 // src/tools/update-registry.ts
-import { z as z3 } from "zod";
+import { agentsLayerSchema, agentsTopologyTypeSchema } from "@fenglimg/fabric-shared";
+import { z as z4 } from "zod";
 
 // src/services/update-registry.ts
 import { agentsMetaNodeSchema } from "@fenglimg/fabric-shared";
 import { join as join2 } from "path";
 async function updateRegistry(projectRoot, input) {
   const metaPath = join2(projectRoot, FABRIC_DIR, "agents.meta.json");
-  const currentMeta = readAgentsMeta(projectRoot);
+  const currentMeta = await readAgentsMeta(projectRoot);
   const nextMeta = applyRegistryOperation(currentMeta, input.op, input.node_id, input.data);
   const newRevision = computeRevision(nextMeta);
   await atomicWriteText(
@@ -298,6 +349,7 @@ async function updateRegistry(projectRoot, input) {
     )}
 `
   );
+  contextCache.invalidate("meta_write", projectRoot);
   return {
     revision_hash: newRevision,
     success: true
@@ -344,30 +396,40 @@ function applyRegistryOperation(meta, op, nodeId, data) {
 }
 
 // src/tools/update-registry.ts
+var nodeInputSchema = z4.object({
+  file: z4.string().optional(),
+  scope_glob: z4.string().optional(),
+  deps: z4.array(z4.string()).optional(),
+  priority: z4.enum(["high", "medium", "low"]).optional(),
+  layer: agentsLayerSchema.optional(),
+  topology_type: agentsTopologyTypeSchema.optional(),
+  hash: z4.string().optional()
+});
 var inputSchema4 = {
-  op: z3.enum(["add-node", "remove-node", "update-node"]),
-  node_id: z3.string(),
-  data: z3.record(z3.unknown()).optional()
+  op: z4.enum(["add-node", "remove-node", "update-node"]),
+  node_id: z4.string(),
+  data: nodeInputSchema.optional()
 };
-function createTextResponse4(payload) {
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(payload)
-      }
-    ]
-  };
-}
+var outputSchema4 = z4.object({
+  success: z4.boolean(),
+  revision_hash: z4.string()
+});
 function registerUpdateRegistry(server) {
-  server.tool(
+  server.registerTool(
     "fab_update_registry",
-    "MANDATORY: Call to add, remove, or update Fabric registry nodes instead of editing registry files directly.",
-    inputSchema4,
+    {
+      description: "Call to add, remove, or update Fabric registry nodes. Use instead of editing .fabric/agents.meta.json directly.",
+      inputSchema: inputSchema4,
+      outputSchema: outputSchema4,
+      annotations: { destructiveHint: true }
+    },
     async ({ op, node_id, data }) => {
       const projectRoot = resolveProjectRoot();
       const result = await updateRegistry(projectRoot, { op, node_id, data });
-      return createTextResponse4(result);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        structuredContent: result
+      };
     }
   );
 }
@@ -386,12 +448,33 @@ function formatError(error) {
 function createFabricServer() {
   const server = new McpServer({
     name: "fabric-context-server",
-    version: "1.2.0"
+    version: "1.3.1"
   });
   registerGetRules(server);
   registerPlanContext(server);
   registerAppendIntent(server);
   registerUpdateRegistry(server);
+  server.registerResource(
+    "bootstrap README",
+    AGENTS_MD_RESOURCE_URI,
+    {
+      description: "L0 fabric bootstrap file \u2014 global agent instructions for this project",
+      mimeType: "text/markdown"
+    },
+    async (_uri) => {
+      const projectRoot = process.env.FABRIC_PROJECT_ROOT ?? process.cwd();
+      const content = await readFile2(join3(projectRoot, ".fabric", "bootstrap", "README.md"), "utf8");
+      return {
+        contents: [
+          {
+            uri: AGENTS_MD_RESOURCE_URI,
+            mimeType: "text/markdown",
+            text: content
+          }
+        ]
+      };
+    }
+  );
   return server;
 }
 async function startStdioServer() {
@@ -400,11 +483,14 @@ async function startStdioServer() {
   await server.connect(transport);
 }
 async function startHttpServer(options) {
-  const { createFabricHttpApp } = await import("./http-EQBDM4C7.js");
+  const { createFabricHttpApp } = await import("./http-6V75VA23.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) => {
     const server = app.listen(port, host);
+    server.once("close", () => {
+      void app.dispose();
+    });
     server.once("listening", () => {
       resolveServer(server);
     });
@@ -423,6 +509,7 @@ if (isMainModule) {
   });
 }
 export {
+  AGENTS_MD_RESOURCE_URI,
   createFabricServer,
   runDoctorAuditReport,
   runDoctorReport,