@fenglimg/fabric-server 0.1.0 → 1.1.0

package/dist/index.d.ts

@@ -1,6 +1,75 @@
+import { Server } from 'node:http';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { AuditMode } from '@fenglimg/fabric-shared';
+
+type DoctorStatus = "ok" | "warn" | "error";
+type DoctorCheck = {
+    name: string;
+    status: DoctorStatus;
+    message: string;
+};
+type DoctorSummary = {
+    target: string;
+    framework: {
+        kind: string;
+        version: string;
+        subkind: string;
+    };
+    entryPoints: Array<{
+        path: string;
+        reason: string;
+    }>;
+    driftCount: number;
+    protectedPathCount: number;
+    protectedPathsIntact: boolean;
+    lastLedgerEntryTs: number | null;
+    lastLedgerEntryAgeMs: number | null;
+    metaRevision: string | null;
+    audit: {
+        enabled: boolean;
+        mode: AuditMode;
+        checkedPathCount: number;
+        violationCount: number;
+        windowMs: number;
+    } | null;
+};
+type DoctorReport = {
+    status: DoctorStatus;
+    checks: DoctorCheck[];
+    summary: DoctorSummary;
+    audit: DoctorAuditReport | null;
+};
+type DoctorAuditViolation = {
+    editTs: number;
+    entryId: string;
+    intent: string;
+    lastGetRulesTs: number | null;
+    path: string;
+};
+type DoctorAuditReport = {
+    mode: AuditMode;
+    skipped: boolean;
+    windowMs: number;
+    checkedPathCount: number;
+    violationCount: number;
+    violations: DoctorAuditViolation[];
+};
+declare function runDoctorReport(target: string): Promise<DoctorReport>;
+declare function runDoctorAuditReport(target: string, options?: {
+    force?: boolean;
+    mode?: AuditMode;
+    windowMs?: number;
+}): Promise<DoctorAuditReport>;
 
 declare function createFabricServer(): McpServer;
 declare function startStdioServer(): Promise<void>;
+declare function startHttpServer(options: {
+    port: number;
+    projectRoot: string;
+    host?: string;
+    authToken?: string;
+    dashboardDistPath?: string;
+    dev?: boolean;
+}): Promise<Server>;
 
-export { createFabricServer, startStdioServer };
+export { type DoctorAuditReport, type DoctorReport, createFabricServer, runDoctorAuditReport, runDoctorReport, startHttpServer, startStdioServer };

package/dist/index.js

@@ -1,3 +1,17 @@
+import {
+  FABRIC_DIR,
+  appendEditIntentAuditEvents,
+  appendGetRulesAuditEvent,
+  appendLedgerEntry,
+  atomicWriteText,
+  readAgentsMeta,
+  readHumanLock,
+  resolveProjectRoot,
+  runDoctorAuditReport,
+  runDoctorReport,
+  sha256
+} from "./chunk-U3IQH5H6.js";
+
 // src/index.ts
 import { resolve } from "path";
 import { fileURLToPath } from "url";
@@ -5,74 +19,38 @@ 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";
+import { aiLedgerEntrySchema } from "@fenglimg/fabric-shared";
 
-// 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;
-  }
+// src/services/append-intent.ts
+async function appendIntent(projectRoot, input) {
+  const ts = Date.now();
+  const entry = await appendLedgerEntry(projectRoot, {
+    ...input.entry,
+    ts,
+    source: "ai"
+  });
   try {
-    return agentsMetaSchema.parse(JSON.parse(raw));
-  } catch (error) {
-    throw new AgentsMetaInvalidError(metaPath, error);
+    await appendEditIntentAuditEvents(projectRoot, {
+      affected_paths: entry.affected_paths,
+      intent: entry.intent,
+      ledger_entry_id: entry.id,
+      ts
+    });
+  } catch {
   }
+  return {
+    success: true,
+    timestamp: ts,
+    entry
+  };
 }
 
 // src/tools/append-intent.ts
 var inputSchema = {
-  entry: z2.object({
-    commit_sha: z2.string().optional(),
-    intent: z2.string(),
-    affected_paths: z2.array(z2.string())
+  entry: aiLedgerEntrySchema.omit({
+    id: true,
+    source: true,
+    ts: true
   })
 };
 function createTextResponse(payload) {
@@ -92,43 +70,66 @@ function registerAppendIntent(server) {
     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
-      });
+      const result = await appendIntent(projectRoot, { entry });
+      return createTextResponse(result);
     }
   );
 }
 
 // src/tools/get-rules.ts
+import { z } from "zod";
+
+// src/services/get-rules.ts
 import { readFile } from "fs/promises";
-import { join as join3 } from "path";
+import { join } 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) {
+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 l0Content = await readFile(join(projectRoot, "AGENTS.md"), "utf8");
+  const humanLockedNearby = (await readHumanLock(projectRoot)).map((entry) => ({
+    file: entry.file,
+    excerpt: JSON.stringify(entry)
+  }));
   return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(payload)
-      }
-    ]
+    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 normalizePath(value) {
+function normalizeRulesPath(value) {
   return value.replaceAll("\\", "/");
 }
 function classifyNode(nodeId) {
@@ -140,32 +141,66 @@ function classifyNode(nodeId) {
   }
   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)
-        };
+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);
+  });
+  return await Promise.all(
+    matchedNodes.map(async ([nodeId, node]) => ({
+      level: classifyNode(nodeId),
+      entry: {
+        path: node.file,
+        content: await readFile(join(projectRoot, node.file), "utf8")
       }
-      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 [];
+    }))
+  );
+}
+function partitionRulesByLevel(loadedRules, dedupeByPath) {
+  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);
     }
-    throw error;
   }
+  return {
+    L1: dedupeByPath ? dedupeEntriesByPath(l1) : l1,
+    L2: dedupeByPath ? dedupeEntriesByPath(l2) : l2
+  };
+}
+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
+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")
+};
+function createTextResponse2(payload) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(payload)
+      }
+    ]
+  };
 }
 function registerGetRules(server) {
   server.tool(
@@ -174,68 +209,49 @@ function registerGetRules(server) {
     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
-        }
-      });
+      const result = await getRules(projectRoot, { path, client_hash });
+      return createTextResponse2(result);
     }
   );
 }
 
-// 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";
+// 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 = {
-  op: z4.enum(["add-node", "remove-node", "update-node"]),
-  node_id: z4.string(),
-  data: z4.record(z4.unknown()).optional()
+  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")
 };
-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: [
@@ -246,15 +262,56 @@ function createTextResponse3(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";
+async function updateRegistry(projectRoot, input) {
+  const metaPath = join2(projectRoot, FABRIC_DIR, "agents.meta.json");
+  const currentMeta = readAgentsMeta(projectRoot);
+  const nextMeta = applyRegistryOperation(currentMeta, input.op, input.node_id, input.data);
+  const newRevision = computeRevision(nextMeta);
+  await atomicWriteText(
+    metaPath,
+    `${JSON.stringify(
+      {
+        ...nextMeta,
+        revision: newRevision
+      },
+      null,
+      2
+    )}
+`
+  );
+  return {
+    revision_hash: newRevision,
+    success: true
+  };
+}
 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")}`;
+  return sha256(joinedHashes);
 }
 function assertNodeData(data, message) {
   if (data === void 0) {
     throw new Error(message);
   }
-  return agentsMetaNodeSchema2.parse(data);
+  return agentsMetaNodeSchema.parse(data);
 }
 function applyRegistryOperation(meta, op, nodeId, data) {
   const nextNodes = { ...meta.nodes };
@@ -276,7 +333,7 @@ function applyRegistryOperation(meta, op, nodeId, data) {
   if (currentNode === void 0) {
     throw new Error(`Cannot update missing Fabric registry node: ${nodeId}`);
   }
-  nextNodes[nodeId] = agentsMetaNodeSchema2.parse({
+  nextNodes[nodeId] = agentsMetaNodeSchema.parse({
     ...currentNode,
     ...data
   });
@@ -285,34 +342,32 @@ function applyRegistryOperation(meta, op, nodeId, data) {
     nodes: nextNodes
   };
 }
+
+// src/tools/update-registry.ts
+var inputSchema4 = {
+  op: z3.enum(["add-node", "remove-node", "update-node"]),
+  node_id: z3.string(),
+  data: z3.record(z3.unknown()).optional()
+};
+function createTextResponse4(payload) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(payload)
+      }
+    ]
+  };
+}
 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 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
-      });
+      const result = await updateRegistry(projectRoot, { op, node_id, data });
+      return createTextResponse4(result);
     }
   );
 }
@@ -331,9 +386,10 @@ function formatError(error) {
 function createFabricServer() {
   const server = new McpServer({
     name: "fabric-context-server",
-    version: "0.0.0"
+    version: "1.1.0"
   });
   registerGetRules(server);
+  registerPlanContext(server);
   registerAppendIntent(server);
   registerUpdateRegistry(server);
   return server;
@@ -343,6 +399,20 @@ async function startStdioServer() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
+async function startHttpServer(options) {
+  const { createFabricHttpApp } = await import("./http-FL3MB4L2.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("listening", () => {
+      resolveServer(server);
+    });
+    server.once("error", (error) => {
+      rejectServer(error);
+    });
+  });
+}
 var entrypoint = process.argv[1];
 var currentFilePath = fileURLToPath(import.meta.url);
 var isMainModule = entrypoint !== void 0 && resolve(entrypoint) === currentFilePath;
@@ -354,5 +424,8 @@ if (isMainModule) {
 }
 export {
   createFabricServer,
+  runDoctorAuditReport,
+  runDoctorReport,
+  startHttpServer,
   startStdioServer
 };