@fenglimg/fabric-server 1.5.2 → 1.7.0

package/dist/index.js

@@ -1,347 +1,102 @@
 import {
   AGENTS_MD_RESOURCE_URI,
-  FABRIC_DIR,
+  EVENT_LEDGER_PATH,
   LEDGER_PATH,
   LEGACY_LEDGER_PATH,
-  appendEditIntentAuditEvents,
-  appendLedgerEntry,
-  approveHumanLock,
-  atomicWriteText,
-  buildRulesPayload,
-  contextCache,
+  RULE_SECTION_NAMES,
+  buildRuleMeta,
+  computeRuleTestIndex,
+  computeRulesBasedAgentsMeta,
+  deriveRuleMetaLayer,
+  deriveRuleMetaTopologyType,
+  getEventLedgerPath,
   getLedgerPath,
   getLegacyLedgerPath,
-  getRules,
-  loadGetRulesContext,
-  loadMatchedRules,
-  matchRuleNodes,
-  normalizeRulesPath,
-  readAgentsMeta,
-  readHumanLock,
-  readHumanLockEntry,
+  getRuleSections,
+  isSameRuleTestIndex,
+  planContext,
   resolveProjectRoot,
-  runDoctorAuditReport,
   runDoctorFix,
   runDoctorReport,
-  sha256
-} from "./chunk-4G6VFG5N.js";
+  stableStringify,
+  writeRuleMeta
+} from "./chunk-PTFSYO4Y.js";
 
 // src/index.ts
 import { readFile } from "fs/promises";
-import { join as join2, resolve } from "path";
+import { join, 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";
+// src/tools/plan-context.ts
 import { z } from "zod";
-
-// src/services/append-intent.ts
-async function appendIntent(projectRoot, input) {
-  const ts = Date.now();
-  const entry = await appendLedgerEntry(projectRoot, {
-    ...input.entry,
-    ts,
-    source: "ai"
-  });
-  let compliance;
-  try {
-    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,
-    compliance
-  };
-}
-
-// src/tools/append-intent.ts
 var inputSchema = {
-  entry: aiLedgerEntrySchema.omit({
-    id: true,
-    source: true,
-    ts: true
-  })
+  paths: z.array(z.string()).min(1).describe("Candidate file paths to build neutral rule selection context for"),
+  intent: z.string().optional().describe("User-stated requirement or implementation intent; used only to build a neutral requirement profile"),
+  known_tech: z.array(z.string()).optional().describe("Known technologies involved in the requirement profile"),
+  detected_entities: z.record(z.array(z.string())).optional().describe("Optional path-keyed detected entities for the requirement profile"),
+  client_hash: z.string().optional().describe("Revision hash from a prior fab_plan_context response; enables stale detection"),
+  correlation_id: z.string().optional().describe("Optional caller-provided correlation id for Event Ledger records"),
+  session_id: z.string().optional().describe("Optional caller-provided session id for Event Ledger records")
 };
-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()
+var ruleDescriptionSchema = z.object({
+  summary: z.string(),
+  intent_clues: z.array(z.string()),
+  tech_stack: z.array(z.string()),
+  impact: z.array(z.string()),
+  must_read_if: z.string(),
+  entities: z.array(z.string()).optional()
 });
-function registerAppendIntent(server) {
-  server.registerTool(
-    "fab_append_intent",
-    {
-      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 });
-      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 as z2 } from "zod";
-var inputSchema2 = {
-  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")
-};
-var rulesEntrySchema = z2.object({ path: z2.string(), content: z2.string() });
-var humanLockedSchema = z2.object({ file: z2.string(), excerpt: z2.string() });
-var descriptionStubSchema = z2.object({ path: z2.string(), description: 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),
-    description_stubs: z2.array(descriptionStubSchema).optional()
-  })
+var descriptionIndexItemSchema = z.object({
+  stable_id: z.string(),
+  level: z.enum(["L0", "L1", "L2"]),
+  required: z.boolean(),
+  selectable: z.boolean(),
+  description: ruleDescriptionSchema
 });
-function registerGetRules(server) {
-  server.registerTool(
-    "fab_get_rules",
-    {
-      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 {
-        content: [{ type: "text", text: JSON.stringify(result) }],
-        structuredContent: result
-      };
-    }
-  );
-}
-
-// src/tools/plan-context.ts
-import { z as z3 } 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 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,
-    shared
-  };
-}
-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];
-  });
-}
-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 = {
-  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")
-};
-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),
-  description_stubs: z3.array(descriptionStubSchema2).optional()
+var requirementProfileSchema = z.object({
+  target_path: z.string(),
+  path_segments: z.array(z.string()),
+  extension: z.string(),
+  inferred_domain: z.array(z.string()),
+  known_tech: z.array(z.string()),
+  user_intent: z.string(),
+  intent_tokens: z.array(z.string()),
+  impact_hints: z.array(z.string()),
+  detected_entities: z.array(z.string())
 });
-var outputSchema3 = z3.object({
-  revision_hash: z3.string(),
-  stale: z3.boolean(),
-  entries: z3.array(
-    z3.object({
-      path: z3.string(),
-      rules: rulesPayloadSchema
+var selectionPolicySchema = z.object({
+  required_levels: z.tuple([z.literal("L0"), z.literal("L2")]),
+  ai_selectable_levels: z.tuple([z.literal("L1")]),
+  final_fetch_rule: z.literal("required_stable_ids + ai_selected_l1_stable_ids")
+});
+var outputSchema = z.object({
+  revision_hash: z.string(),
+  stale: z.boolean(),
+  selection_token: z.string(),
+  entries: z.array(
+    z.object({
+      path: z.string(),
+      requirement_profile: requirementProfileSchema,
+      description_index: z.array(descriptionIndexItemSchema),
+      required_stable_ids: z.array(z.string()),
+      ai_selectable_stable_ids: z.array(z.string()),
+      initial_selected_stable_ids: z.array(z.string()),
+      selection_policy: selectionPolicySchema
     })
   ),
-  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()
+  shared: z.object({
+    required_stable_ids: z.array(z.string()),
+    ai_selectable_stable_ids: z.array(z.string()),
+    description_index: z.array(descriptionIndexItemSchema),
+    preflight_diagnostics: z.array(
+      z.object({
+        code: z.literal("missing_description"),
+        severity: z.literal("warn"),
+        message: z.string(),
+        stable_ids: z.array(z.string()).optional(),
+        path: z.string().optional()
       })
     )
   })
@@ -350,14 +105,22 @@ function registerPlanContext(server) {
   server.registerTool(
     "fab_plan_context",
     {
-      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,
+      description: "Use during plan or architecture phases to build a neutral Fabric rule description index and selection token before fetching rule sections.",
+      inputSchema,
+      outputSchema,
       annotations: { readOnlyHint: true }
     },
-    async ({ paths, client_hash }) => {
+    async ({ paths, intent, known_tech, detected_entities, client_hash, correlation_id, session_id }) => {
       const projectRoot = resolveProjectRoot();
-      const result = await planContext(projectRoot, { paths, client_hash });
+      const result = await planContext(projectRoot, {
+        paths,
+        intent,
+        known_tech,
+        detected_entities,
+        client_hash,
+        correlation_id,
+        session_id
+      });
       return {
         content: [{ type: "text", text: JSON.stringify(result) }],
         structuredContent: result
@@ -366,107 +129,50 @@ function registerPlanContext(server) {
   );
 }
 
-// src/tools/update-registry.ts
-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 } from "path";
-async function updateRegistry(projectRoot, input) {
-  const metaPath = join(projectRoot, FABRIC_DIR, "agents.meta.json");
-  const currentMeta = await 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
-    )}
-`
-  );
-  contextCache.invalidate("meta_write", projectRoot);
-  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(joinedHashes);
-}
-function assertNodeData(data, message) {
-  if (data === void 0) {
-    throw new Error(message);
-  }
-  return agentsMetaNodeSchema.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] = agentsMetaNodeSchema.parse({
-    ...currentNode,
-    ...data
-  });
-  return {
-    ...meta,
-    nodes: nextNodes
-  };
-}
-
-// 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: z4.enum(["add-node", "remove-node", "update-node"]),
-  node_id: z4.string(),
-  data: nodeInputSchema.optional()
+// src/tools/rule-sections.ts
+import { z as z2 } from "zod";
+var inputSchema2 = {
+  selection_token: z2.string().min(1).describe("Selection token returned by fab_plan_context"),
+  sections: z2.array(z2.enum(RULE_SECTION_NAMES)).min(1).describe("Structured rule sections to fetch"),
+  ai_selected_stable_ids: z2.array(z2.string()).describe("AI-selected L1 stable_ids chosen from fab_plan_context ai_selectable_stable_ids"),
+  ai_selection_reasons: z2.record(z2.string().min(1)).describe("Reason for each AI-selected L1 stable_id"),
+  correlation_id: z2.string().optional().describe("Optional caller-provided correlation id for Event Ledger records"),
+  session_id: z2.string().optional().describe("Optional caller-provided session id for Event Ledger records")
 };
-var outputSchema4 = z4.object({
-  success: z4.boolean(),
-  revision_hash: z4.string()
+var outputSchema2 = z2.object({
+  revision_hash: z2.string(),
+  precedence: z2.tuple([z2.literal("L2"), z2.literal("L1"), z2.literal("L0")]),
+  selected_stable_ids: z2.array(z2.string()),
+  rules: z2.array(
+    z2.object({
+      stable_id: z2.string(),
+      level: z2.enum(["L0", "L1", "L2"]),
+      path: z2.string(),
+      sections: z2.record(z2.string())
+    })
+  ),
+  diagnostics: z2.array(
+    z2.object({
+      code: z2.literal("missing_section"),
+      severity: z2.literal("warn"),
+      stable_id: z2.string(),
+      section: z2.enum(RULE_SECTION_NAMES),
+      message: z2.string()
+    })
+  )
 });
-function registerUpdateRegistry(server) {
+function registerRuleSections(server) {
   server.registerTool(
-    "fab_update_registry",
+    "fab_get_rule_sections",
     {
-      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 }
+      description: "Fetch structured Fabric rule sections after fab_plan_context. Required L0/L2 rules are merged with AI-selected L1 rules server-side.",
+      inputSchema: inputSchema2,
+      outputSchema: outputSchema2,
+      annotations: { readOnlyHint: true }
     },
-    async ({ op, node_id, data }) => {
+    async (input) => {
       const projectRoot = resolveProjectRoot();
-      const result = await updateRegistry(projectRoot, { op, node_id, data });
+      const result = await getRuleSections(projectRoot, input);
       return {
         content: [{ type: "text", text: JSON.stringify(result) }],
         structuredContent: result
@@ -489,12 +195,10 @@ function formatError(error) {
 function createFabricServer() {
   const server = new McpServer({
     name: "fabric-context-server",
-    version: "1.5.2"
+    version: "1.7.0"
   });
-  registerGetRules(server);
   registerPlanContext(server);
-  registerAppendIntent(server);
-  registerUpdateRegistry(server);
+  registerRuleSections(server);
   server.registerResource(
     "bootstrap README",
     AGENTS_MD_RESOURCE_URI,
@@ -504,7 +208,7 @@ function createFabricServer() {
     },
     async (_uri) => {
       const projectRoot = process.env.FABRIC_PROJECT_ROOT ?? process.cwd();
-      const content = await readFile(join2(projectRoot, ".fabric", "bootstrap", "README.md"), "utf8");
+      const content = await readFile(join(projectRoot, ".fabric", "bootstrap", "README.md"), "utf8");
       return {
         contents: [
           {
@@ -524,7 +228,7 @@ async function startStdioServer() {
   await server.connect(transport);
 }
 async function startHttpServer(options) {
-  const { createFabricHttpApp } = await import("./http-U4S7BUP4.js");
+  const { createFabricHttpApp } = await import("./http-6LFZLHCN.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) => {
@@ -551,17 +255,23 @@ if (isMainModule) {
 }
 export {
   AGENTS_MD_RESOURCE_URI,
+  EVENT_LEDGER_PATH,
   LEDGER_PATH,
   LEGACY_LEDGER_PATH,
-  approveHumanLock,
+  buildRuleMeta,
+  computeRuleTestIndex,
+  computeRulesBasedAgentsMeta,
   createFabricServer,
+  deriveRuleMetaLayer,
+  deriveRuleMetaTopologyType,
+  getEventLedgerPath,
   getLedgerPath,
   getLegacyLedgerPath,
-  readHumanLock,
-  readHumanLockEntry,
-  runDoctorAuditReport,
+  isSameRuleTestIndex,
   runDoctorFix,
   runDoctorReport,
+  stableStringify,
   startHttpServer,
-  startStdioServer
+  startStdioServer,
+  writeRuleMeta
 };