@fenglimg/fabric-server 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+declare function createFabricServer(): McpServer;
+declare function startStdioServer(): Promise<void>;
+
+export { createFabricServer, startStdioServer };

package/dist/index.js

@@ -0,0 +1,358 @@
+// src/index.ts
+import { 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 { appendFile } from "fs/promises";
+import { join as join2 } from "path";
+import { z as z2 } from "zod";
+
+// src/meta-reader.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { z } from "zod";
+var agentsMetaNodeSchema = z.object({
+  file: z.string(),
+  scope_glob: z.string(),
+  deps: z.array(z.string()),
+  priority: z.enum(["high", "medium", "low"]),
+  hash: z.string()
+});
+var agentsMetaSchema = z.object({
+  revision: z.string(),
+  nodes: z.record(agentsMetaNodeSchema)
+});
+var AgentsMetaFileMissingError = class extends Error {
+  constructor(metaPath) {
+    super(`Fabric agents metadata file is missing: ${metaPath}`);
+    this.metaPath = metaPath;
+    this.name = "AgentsMetaFileMissingError";
+  }
+  metaPath;
+  code = "FABRIC_META_MISSING";
+};
+var AgentsMetaInvalidError = class extends Error {
+  constructor(metaPath, cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    super(`Fabric agents metadata file is invalid: ${metaPath}. ${detail}`);
+    this.metaPath = metaPath;
+    this.name = "AgentsMetaInvalidError";
+  }
+  metaPath;
+  code = "FABRIC_META_INVALID";
+};
+function getAgentsMetaPath(projectRoot) {
+  return join(projectRoot, ".fabric", "agents.meta.json");
+}
+function resolveProjectRoot() {
+  return process.env.FABRIC_PROJECT_ROOT ?? process.cwd();
+}
+function readAgentsMeta(projectRoot) {
+  const metaPath = getAgentsMetaPath(projectRoot);
+  let raw;
+  try {
+    raw = readFileSync(metaPath, "utf8");
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      throw new AgentsMetaFileMissingError(metaPath);
+    }
+    throw error;
+  }
+  try {
+    return agentsMetaSchema.parse(JSON.parse(raw));
+  } catch (error) {
+    throw new AgentsMetaInvalidError(metaPath, error);
+  }
+}
+
+// src/tools/append-intent.ts
+var inputSchema = {
+  entry: z2.object({
+    commit_sha: z2.string().optional(),
+    intent: z2.string(),
+    affected_paths: z2.array(z2.string())
+  })
+};
+function createTextResponse(payload) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(payload)
+      }
+    ]
+  };
+}
+function registerAppendIntent(server) {
+  server.tool(
+    "fab_append_intent",
+    "MANDATORY: Call after a completed task to append an intent ledger entry for Fabric.",
+    inputSchema,
+    async ({ entry }) => {
+      const projectRoot = resolveProjectRoot();
+      const ledgerPath = join2(projectRoot, ".intent-ledger.jsonl");
+      const ts = Date.now();
+      await appendFile(ledgerPath, `${JSON.stringify({ ts, ...entry })}
+`, "utf8");
+      return createTextResponse({
+        success: true,
+        timestamp: ts
+      });
+    }
+  );
+}
+
+// src/tools/get-rules.ts
+import { readFile } from "fs/promises";
+import { join as join3 } from "path";
+import { minimatch } from "minimatch";
+import { z as z3 } from "zod";
+var inputSchema2 = {
+  path: z3.string().describe("Target file path to query rules for"),
+  client_hash: z3.string().optional().describe("Revision hash from prior fab_get_rules response; enables stale detection")
+};
+var PRIORITY_ORDER = {
+  high: 0,
+  medium: 1,
+  low: 2
+};
+function createTextResponse2(payload) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(payload)
+      }
+    ]
+  };
+}
+function normalizePath(value) {
+  return value.replaceAll("\\", "/");
+}
+function classifyNode(nodeId) {
+  if (nodeId.startsWith("L1/")) {
+    return "L1";
+  }
+  if (nodeId.startsWith("L2/")) {
+    return "L2";
+  }
+  return null;
+}
+async function readHumanLockedNearby(projectRoot) {
+  const humanLockPath = join3(projectRoot, ".fabric", "human-lock.json");
+  try {
+    const raw = await readFile(humanLockPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const entries = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && "human_locked" in parsed && Array.isArray(parsed.human_locked) ? parsed.human_locked : [];
+    return entries.map((entry) => {
+      if (!entry || typeof entry !== "object") {
+        return {
+          file: "(unknown)",
+          excerpt: JSON.stringify(entry)
+        };
+      }
+      const file = typeof entry.file === "string" ? entry.file : "(unknown)";
+      const excerptCandidate = typeof entry.excerpt === "string" ? entry.excerpt : typeof entry.locked_text === "string" ? entry.locked_text : typeof entry.text === "string" ? entry.text : typeof entry.content === "string" ? entry.content : JSON.stringify(entry);
+      return {
+        file,
+        excerpt: excerptCandidate
+      };
+    });
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+function registerGetRules(server) {
+  server.tool(
+    "fab_get_rules",
+    "MANDATORY: Call before modifying any file to retrieve Fabric rules for a target path.",
+    inputSchema2,
+    async ({ path, client_hash }) => {
+      const projectRoot = resolveProjectRoot();
+      const meta = readAgentsMeta(projectRoot);
+      const stale = client_hash !== void 0 && client_hash !== meta.revision;
+      const requestedPath = normalizePath(path);
+      const l0Content = await readFile(join3(projectRoot, "AGENTS.md"), "utf8");
+      const matchedNodes = Object.entries(meta.nodes).filter(([, node]) => minimatch(requestedPath, normalizePath(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(
+        matchedNodes.map(async ([nodeId, node]) => ({
+          level: classifyNode(nodeId),
+          entry: {
+            path: node.file,
+            content: await readFile(join3(projectRoot, node.file), "utf8")
+          }
+        }))
+      );
+      const l1 = [];
+      const l2 = [];
+      for (const rule of loadedRules) {
+        if (rule.level === "L1") {
+          l1.push(rule.entry);
+          continue;
+        }
+        if (rule.level === "L2") {
+          l2.push(rule.entry);
+        }
+      }
+      const humanLockedNearby = await readHumanLockedNearby(projectRoot);
+      return createTextResponse2({
+        revision_hash: meta.revision,
+        stale,
+        rules: {
+          L0: l0Content,
+          L1: l1,
+          L2: l2,
+          human_locked_nearby: humanLockedNearby
+        }
+      });
+    }
+  );
+}
+
+// src/tools/update-registry.ts
+import { createHash } from "crypto";
+import { writeFile } from "fs/promises";
+import { join as join4 } from "path";
+import { z as z4 } from "zod";
+var inputSchema3 = {
+  op: z4.enum(["add-node", "remove-node", "update-node"]),
+  node_id: z4.string(),
+  data: z4.record(z4.unknown()).optional()
+};
+var agentsMetaNodeSchema2 = z4.object({
+  file: z4.string(),
+  scope_glob: z4.string(),
+  deps: z4.array(z4.string()),
+  priority: z4.enum(["high", "medium", "low"]),
+  hash: z4.string()
+});
+function createTextResponse3(payload) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(payload)
+      }
+    ]
+  };
+}
+function computeRevision(meta) {
+  const joinedHashes = Object.entries(meta.nodes).sort(([leftId], [rightId]) => leftId.localeCompare(rightId)).map(([, node]) => node.hash).join("");
+  return `sha256:${createHash("sha256").update(joinedHashes).digest("hex")}`;
+}
+function assertNodeData(data, message) {
+  if (data === void 0) {
+    throw new Error(message);
+  }
+  return agentsMetaNodeSchema2.parse(data);
+}
+function applyRegistryOperation(meta, op, nodeId, data) {
+  const nextNodes = { ...meta.nodes };
+  if (op === "remove-node") {
+    delete nextNodes[nodeId];
+    return {
+      ...meta,
+      nodes: nextNodes
+    };
+  }
+  if (op === "add-node") {
+    nextNodes[nodeId] = assertNodeData(data, `fab_update_registry requires data for ${op}`);
+    return {
+      ...meta,
+      nodes: nextNodes
+    };
+  }
+  const currentNode = nextNodes[nodeId];
+  if (currentNode === void 0) {
+    throw new Error(`Cannot update missing Fabric registry node: ${nodeId}`);
+  }
+  nextNodes[nodeId] = agentsMetaNodeSchema2.parse({
+    ...currentNode,
+    ...data
+  });
+  return {
+    ...meta,
+    nodes: nextNodes
+  };
+}
+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,
+    async ({ op, node_id, data }) => {
+      const projectRoot = resolveProjectRoot();
+      const metaPath = join4(projectRoot, ".fabric", "agents.meta.json");
+      const currentMeta = readAgentsMeta(projectRoot);
+      const nextMeta = applyRegistryOperation(currentMeta, op, node_id, data);
+      const newRevision = computeRevision(nextMeta);
+      await writeFile(
+        metaPath,
+        `${JSON.stringify(
+          {
+            ...nextMeta,
+            revision: newRevision
+          },
+          null,
+          2
+        )}
+`,
+        "utf8"
+      );
+      return createTextResponse3({
+        revision_hash: newRevision,
+        success: true
+      });
+    }
+  );
+}
+
+// src/index.ts
+function writeStderr(message) {
+  process.stderr.write(`${message}
+`);
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.stack ?? `${error.name}: ${error.message}`;
+  }
+  return `Unknown error: ${String(error)}`;
+}
+function createFabricServer() {
+  const server = new McpServer({
+    name: "fabric-context-server",
+    version: "0.0.0"
+  });
+  registerGetRules(server);
+  registerAppendIntent(server);
+  registerUpdateRegistry(server);
+  return server;
+}
+async function startStdioServer() {
+  const server = createFabricServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+var entrypoint = process.argv[1];
+var currentFilePath = fileURLToPath(import.meta.url);
+var isMainModule = entrypoint !== void 0 && resolve(entrypoint) === currentFilePath;
+if (isMainModule) {
+  void startStdioServer().catch((error) => {
+    writeStderr(formatError(error));
+    process.exitCode = 1;
+  });
+}
+export {
+  createFabricServer,
+  startStdioServer
+};

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@fenglimg/fabric-server",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "minimatch": "^10.0.1",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3"
+  }
+}