@vpxa/kb 0.1.1

package/packages/server/dist/tools/forge.tools.js

@@ -0,0 +1,501 @@
+import { digest, evidenceMap, forgeClassify, forgeGround, stratumCard } from "@kb/tools";
+import { z } from "zod";
+function registerEvidenceMapTool(server) {
+  server.registerTool(
+    "evidence_map",
+    {
+      description: "FORGE Evidence Map \u2014 track critical-path claims as Verified/Assumed/Unresolved with receipts. Supports CRUD operations and deterministic Gate evaluation (YIELD/HOLD/HARD_BLOCK/FORCED_DELIVERY). Persists across tool calls.",
+      inputSchema: {
+        action: z.enum(["create", "add", "update", "get", "gate", "list", "delete"]).describe("Operation to perform"),
+        task_id: z.string().optional().describe("Task identifier (required for all except list)"),
+        tier: z.enum(["floor", "standard", "critical"]).optional().describe("FORGE tier (required for create)"),
+        claim: z.string().optional().describe("Critical-path claim text (for add)"),
+        status: z.enum(["V", "A", "U"]).optional().describe("Evidence status: V=Verified, A=Assumed, U=Unresolved"),
+        receipt: z.string().optional().describe("Evidence receipt: tool\u2192ref for V, reasoning for A, attempts for U"),
+        id: z.number().optional().describe("Entry ID (for update)"),
+        critical_path: z.boolean().default(true).describe("Whether this claim is on the critical path"),
+        unknown_type: z.enum(["contract", "convention", "freshness", "runtime", "data-flow", "impact"]).optional().describe("Typed unknown classification"),
+        retry_count: z.number().default(0).describe("Retry count for gate evaluation (0 = first attempt)"),
+        cwd: z.string().optional().describe(
+          "Working directory for evidence map storage (default: server cwd). Use root_path from forge_ground to match."
+        )
+      }
+    },
+    async ({
+      action,
+      task_id,
+      tier,
+      claim,
+      status,
+      receipt,
+      id,
+      critical_path,
+      unknown_type,
+      retry_count,
+      cwd
+    }) => {
+      try {
+        switch (action) {
+          case "create": {
+            if (!task_id) throw new Error("task_id required for create");
+            if (!tier) throw new Error("tier required for create");
+            evidenceMap({ action: "create", taskId: task_id, tier }, cwd);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Created evidence map "${task_id}" (tier: ${tier}).
+
+---
+_Next: Use \`evidence_map\` with action "add" to record critical-path claims._`
+                }
+              ]
+            };
+          }
+          case "add": {
+            if (!task_id) throw new Error("task_id required for add");
+            if (!claim) throw new Error("claim required for add");
+            if (!status) throw new Error("status required for add");
+            const result = evidenceMap(
+              {
+                action: "add",
+                taskId: task_id,
+                claim,
+                status,
+                receipt: receipt ?? "",
+                criticalPath: critical_path,
+                unknownType: unknown_type
+              },
+              cwd
+            );
+            const lines = [
+              `Added entry #${result.entry?.id} to "${task_id}": [${status}] ${claim}`
+            ];
+            if (result.formattedMap) {
+              lines.push("", result.formattedMap);
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+          }
+          case "update": {
+            if (!task_id) throw new Error("task_id required for update");
+            if (id === void 0) throw new Error("id required for update");
+            if (!status) throw new Error("status required for update");
+            const result = evidenceMap(
+              {
+                action: "update",
+                taskId: task_id,
+                id,
+                status,
+                receipt: receipt ?? ""
+              },
+              cwd
+            );
+            const lines = [`Updated entry #${id} in "${task_id}" \u2192 ${status}`];
+            if (result.formattedMap) {
+              lines.push("", result.formattedMap);
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+          }
+          case "get": {
+            if (!task_id) throw new Error("task_id required for get");
+            const result = evidenceMap({ action: "get", taskId: task_id }, cwd);
+            if (!result.state) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Evidence map "${task_id}" not found.`
+                  }
+                ]
+              };
+            }
+            const lines = [
+              `## Evidence Map: ${task_id} (${result.state.tier})`,
+              "",
+              result.formattedMap ?? "No entries.",
+              "",
+              `_${result.state.entries.length} entries \u2014 created ${result.state.createdAt}_`
+            ];
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+          }
+          case "gate": {
+            if (!task_id) throw new Error("task_id required for gate");
+            const result = evidenceMap(
+              {
+                action: "gate",
+                taskId: task_id,
+                retryCount: retry_count
+              },
+              cwd
+            );
+            if (!result.gate) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Evidence map "${task_id}" not found.`
+                  }
+                ]
+              };
+            }
+            const g = result.gate;
+            const lines = [
+              `## FORGE Gate: **${g.decision}**`,
+              "",
+              `**Reason:** ${g.reason}`,
+              "",
+              `**Stats:** ${g.stats.verified}V / ${g.stats.assumed}A / ${g.stats.unresolved}U (${g.stats.total} total)`
+            ];
+            if (g.warnings.length > 0) {
+              lines.push("", "**Warnings:**", ...g.warnings.map((w) => `- \u26A0\uFE0F ${w}`));
+            }
+            if (g.unresolvedCritical.length > 0) {
+              lines.push(
+                "",
+                "**Blocking entries:**",
+                ...g.unresolvedCritical.map(
+                  (e) => `- #${e.id}: ${e.claim} [${e.unknownType ?? "untyped"}]`
+                )
+              );
+            }
+            if (g.annotation) {
+              lines.push("", "**Annotation:**", g.annotation);
+            }
+            if (result.formattedMap) {
+              lines.push("", "---", "", result.formattedMap);
+            }
+            lines.push(
+              "",
+              "---",
+              `_Next: ${g.decision === "YIELD" ? "Proceed to implementation." : g.decision === "HOLD" ? "Resolve blocking entries, then re-run gate." : g.decision === "HARD_BLOCK" ? "Contract unknowns MUST be resolved. Use search or schema_validate." : "Proceed with annotation \u2014 document unresolved items in delivery."}_`
+            );
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+          }
+          case "list": {
+            const result = evidenceMap({ action: "list" }, cwd);
+            if (!result.states || result.states.length === 0) {
+              return {
+                content: [{ type: "text", text: "No evidence maps found." }]
+              };
+            }
+            const lines = result.states.map(
+              (s) => `- **${s.taskId}** (${s.tier}) \u2014 ${s.entries.length} entries \u2014 ${s.updatedAt}`
+            );
+            return {
+              content: [{ type: "text", text: lines.join("\n") }]
+            };
+          }
+          case "delete": {
+            if (!task_id) throw new Error("task_id required for delete");
+            const result = evidenceMap({ action: "delete", taskId: task_id }, cwd);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: result.deleted ? `Deleted evidence map "${task_id}".` : `Evidence map "${task_id}" not found.`
+                }
+              ]
+            };
+          }
+        }
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Evidence map error: ${err.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerDigestTool(server, embedder) {
+  server.registerTool(
+    "digest",
+    {
+      description: "Compress multiple text sources (handoffs, debates, phase summaries) into a token-budgeted digest. Jointly ranks across all sources, pins structured fields (status, files, decisions, blockers), and allocates budget by priority weight.",
+      inputSchema: {
+        sources: z.array(
+          z.object({
+            id: z.string().describe('Source identifier (e.g., "phase-2-handoff")'),
+            text: z.string().describe("Source text to compress"),
+            weight: z.number().min(0).default(1).describe("Priority weight (higher = more budget)")
+          })
+        ).min(1).describe("Text sources to compress"),
+        query: z.string().describe("Focus query \u2014 what matters for the next step?"),
+        max_chars: z.number().min(100).max(5e4).default(4e3).describe("Target budget in characters"),
+        pin_fields: z.array(z.string()).optional().describe(
+          "Key fields to always extract (default: status, files, decisions, blockers, next)"
+        ),
+        segmentation: z.enum(["paragraph", "sentence", "line"]).default("paragraph").describe("How to split text for scoring")
+      }
+    },
+    async ({ sources, query, max_chars, pin_fields, segmentation }) => {
+      try {
+        const result = await digest(embedder, {
+          sources,
+          query,
+          maxChars: max_chars,
+          pinFields: pin_fields,
+          segmentation
+        });
+        const lines = [
+          `## Digest (${result.totalOriginalChars} \u2192 ${result.totalCompressedChars} chars, ${(result.ratio * 100).toFixed(0)}%)`,
+          ""
+        ];
+        const fieldKeys = Object.keys(result.fields);
+        if (fieldKeys.length > 0) {
+          lines.push("### Extracted Fields");
+          for (const key of fieldKeys) {
+            const entries = result.fields[key];
+            lines.push(`**${key}:**`);
+            for (const e of entries) {
+              lines.push(`  - [${e.sourceId}] ${e.value}`);
+            }
+          }
+          lines.push("");
+        }
+        lines.push("### Compressed Content", "", result.text);
+        lines.push("", "### Source Stats");
+        for (const s of result.sourceStats) {
+          lines.push(
+            `- **${s.id}**: ${s.originalChars} \u2192 ${s.keptChars} chars (${s.segmentsKept}/${s.segmentsTotal} segments)`
+          );
+        }
+        lines.push(
+          "",
+          "---",
+          "_Next: Use the digest as compressed context for the next phase. Use `stash` to persist it if needed._"
+        );
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Digest failed: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerForgeClassifyTool(server) {
+  server.registerTool(
+    "forge_classify",
+    {
+      description: "Classify FORGE tier (Floor/Standard/Critical) from target files and task description. Checks blast radius, cross-package boundaries, schema/contract patterns, and security signals. Returns tier, triggers, typed unknown seeds, and ceremony guidance.",
+      inputSchema: {
+        files: z.array(z.string()).min(1).describe("Files being modified (paths)"),
+        task: z.string().describe("Task description"),
+        root_path: z.string().describe("Root path of the codebase")
+      }
+    },
+    async ({ files, task, root_path }) => {
+      try {
+        const result = await forgeClassify({ files, task, rootPath: root_path });
+        const lines = [`## FORGE Classification: **${result.tier.toUpperCase()}**`, ""];
+        if (result.triggers.length > 0) {
+          lines.push("### Triggers");
+          for (const t of result.triggers) {
+            lines.push(`- **${t.rule}** (${t.source}): ${t.detail}`);
+          }
+          lines.push("");
+        }
+        if (result.packagesCrossed.length > 0) {
+          lines.push(`**Packages crossed:** ${result.packagesCrossed.join(", ")}`);
+        }
+        if (result.typedUnknownSeeds.length > 0) {
+          lines.push("", "### Typed Unknown Seeds");
+          for (const u of result.typedUnknownSeeds) {
+            lines.push(`- [${u.type}] ${u.description} \u2192 use \`${u.suggestedTool}\``);
+          }
+        }
+        lines.push("", "### Ceremony");
+        const c = result.ceremony;
+        lines.push(
+          `- **Ground:** ${c.ground}`,
+          `- **Build:** ${c.build}`,
+          `- **Break:** ${c.break}`,
+          `- **Evidence Map:** ${c.evidenceMap}`,
+          `- **Gate:** ${c.gate}`
+        );
+        lines.push(
+          "",
+          "---",
+          `_Next: ${result.tier === "floor" ? "Proceed directly to implementation." : "Run `forge_ground` to execute the full Ground phase."}_`
+        );
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `FORGE classify failed: ${err.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerStratumCardTool(server, embedder) {
+  server.registerTool(
+    "stratum_card",
+    {
+      description: "Generate STRATUM context cards from files. T1 = structural metadata (~100 tokens/file). T2 = T1 + compressed content (~300 tokens/file). Replaces reading full files \u2014 10-100x token reduction.",
+      inputSchema: {
+        files: z.array(z.string()).min(1).describe("Absolute file paths to generate cards for"),
+        query: z.string().describe("Current task query \u2014 guides relevance scoring"),
+        tier: z.enum(["T1", "T2"]).default("T1").describe("Card tier: T1 = structural only, T2 = T1 + compressed content"),
+        max_content_chars: z.number().min(100).max(5e3).default(800).describe("For T2: max chars for compressed content section")
+      }
+    },
+    async ({ files, query, tier, max_content_chars }) => {
+      try {
+        const result = await stratumCard(embedder, {
+          files,
+          query,
+          tier,
+          maxContentChars: max_content_chars
+        });
+        const lines = [
+          `## STRATUM Cards (${tier}) \u2014 ${result.cards.length} files`,
+          `Total: ~${result.totalTokenEstimate} tokens (was ~${result.totalOriginalTokenEstimate}, ${(result.compressionRatio * 100).toFixed(0)}% of original)`,
+          ""
+        ];
+        for (const card of result.cards) {
+          lines.push(card.card, "");
+        }
+        lines.push(
+          "---",
+          `_Next: Use these cards as context instead of reading full files. Use \`compact\` for deeper content extraction on specific files._`
+        );
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `STRATUM cards failed: ${err.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerForgeGroundTool(server, embedder, store) {
+  server.registerTool(
+    "forge_ground",
+    {
+      description: "Execute the complete FORGE Ground phase in a single call. Chains: tier classification \u2192 scope map \u2192 typed unknown seeds \u2192 constraint loading \u2192 file summaries \u2192 evidence map creation. Replaces 5-15 manual tool calls.",
+      inputSchema: {
+        task: z.string().describe("Task description"),
+        files: z.array(z.string()).min(1).describe("Target files being modified (absolute paths)"),
+        root_path: z.string().describe("Root path of the codebase"),
+        max_constraints: z.number().min(0).max(10).default(3).describe("Max constraint entries to load from KB"),
+        force_tier: z.enum(["floor", "standard", "critical"]).optional().describe("Force a specific tier (skips auto-classification)"),
+        task_id: z.string().optional().describe("Custom task ID for evidence map (auto-generated if omitted)")
+      }
+    },
+    async ({ task, files, root_path, max_constraints, force_tier, task_id }) => {
+      try {
+        const result = await forgeGround(embedder, store, {
+          task,
+          files,
+          rootPath: root_path,
+          maxConstraints: max_constraints,
+          forceTier: force_tier,
+          taskId: task_id
+        });
+        const lines = [
+          `## FORGE Ground: **${result.tier.toUpperCase()}**`,
+          `Estimated output: ~${result.estimatedTokens} tokens`,
+          ""
+        ];
+        if (result.classifyTriggers.length > 0) {
+          lines.push("### Classification Triggers");
+          for (const t of result.classifyTriggers) {
+            lines.push(`- **${t.rule}** (${t.source}): ${t.detail}`);
+          }
+          lines.push("");
+        }
+        if (result.fileSummaries.length > 0) {
+          lines.push("### Target Files");
+          for (const f of result.fileSummaries) {
+            lines.push(
+              `- **${f.path}** (${f.lines} lines) \u2014 exports: ${f.exports.join(", ") || "none"} \u2014 functions: ${f.functions.join(", ") || "none"}`
+            );
+          }
+          lines.push("");
+        }
+        if (result.typedUnknownSeeds.length > 0) {
+          lines.push("### Typed Unknown Seeds");
+          for (const u of result.typedUnknownSeeds) {
+            lines.push(`- [${u.type}] ${u.description} \u2192 \`${u.suggestedTool}\``);
+          }
+          lines.push("");
+        }
+        if (result.constraints.length > 0) {
+          lines.push("### Constraint Seed");
+          for (const c2 of result.constraints) {
+            lines.push(`- **${c2.source}** (${(c2.relevance * 100).toFixed(0)}%): ${c2.snippet}`);
+          }
+          lines.push("");
+        }
+        if (result.scopeMap) {
+          lines.push(
+            `### Scope Map: ${result.scopeMap.files.length} files (~${result.scopeMap.totalEstimatedTokens} tokens)`
+          );
+          for (const f of result.scopeMap.files.slice(0, 5)) {
+            lines.push(`- ${f.path} (${(f.relevance * 100).toFixed(0)}%) \u2014 ${f.reason}`);
+          }
+          if (result.scopeMap.files.length > 5) {
+            lines.push(`- _...and ${result.scopeMap.files.length - 5} more_`);
+          }
+          lines.push("");
+        }
+        if (result.evidenceMapTaskId) {
+          lines.push(`**Evidence Map:** \`${result.evidenceMapTaskId}\` (initialized)`);
+          lines.push("");
+        }
+        lines.push("### Ceremony Guidance");
+        const c = result.ceremony;
+        lines.push(
+          `- **Ground:** ${c.ground}`,
+          `- **Build:** ${c.build}`,
+          `- **Break:** ${c.break}`,
+          `- **Evidence Map:** ${c.evidenceMap}`,
+          `- **Gate:** ${c.gate}`
+        );
+        lines.push(
+          "",
+          "---",
+          `_Next: ${result.tier === "floor" ? "Proceed to Build phase." : "Use `evidence_map` to track claims during Build, then `evidence_map` gate after Break."}_`
+        );
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `FORGE Ground failed: ${err.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+export {
+  registerDigestTool,
+  registerEvidenceMapTool,
+  registerForgeClassifyTool,
+  registerForgeGroundTool,
+  registerStratumCardTool
+};
+//# sourceMappingURL=forge.tools.js.map

package/packages/server/dist/tools/forget.tool.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CuratedKnowledgeManager } from '../curated-manager.js';
+export declare function registerForgetTool(server: McpServer, curated: CuratedKnowledgeManager): void;
+//# sourceMappingURL=forget.tool.d.ts.map

package/packages/server/dist/tools/forget.tool.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+function registerForgetTool(server, curated) {
+  server.registerTool(
+    "forget",
+    {
+      description: "Remove a curated knowledge entry. Deletes the file and removes it from the vector store.",
+      inputSchema: {
+        path: z.string().describe('Relative path within curated/ (e.g., "decisions/deprecated-approach.md")'),
+        reason: z.string().min(3).describe("Why this entry is being removed")
+      }
+    },
+    async ({ path, reason }) => {
+      try {
+        const result = await curated.forget(path, reason);
+        console.error(`[KB] Forgot: ${result.path} \u2014 reason: ${reason}`);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Forgotten: \`curated/${result.path}\`
+
+Removed from disk and vector store.
+Reason: ${reason}
+
+---
+_Next: Use \`list\` to verify removal, or \`search\` to confirm the entry is no longer returned._`
+            }
+          ]
+        };
+      } catch (err) {
+        console.error("[KB] Forget failed:", err);
+        return {
+          content: [{ type: "text", text: `Forget failed: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+export {
+  registerForgetTool
+};
+//# sourceMappingURL=forget.tool.js.map

package/packages/server/dist/tools/graph.tool.d.ts

@@ -0,0 +1,4 @@
+import type { IGraphStore } from '@kb/store';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerGraphTool(server: McpServer, graphStore: IGraphStore): void;
+//# sourceMappingURL=graph.tool.d.ts.map

package/packages/server/dist/tools/graph.tool.js

@@ -0,0 +1,110 @@
+import { graphQuery } from "@kb/tools";
+import { z } from "zod";
+const nodeSchema = z.object({
+  id: z.string().optional().describe("Node ID (auto-generated if omitted)"),
+  type: z.string().describe("Node type (entity, service, api, concept, decision)"),
+  name: z.string().describe("Display name"),
+  properties: z.record(z.string(), z.unknown()).optional().describe("Arbitrary properties"),
+  sourceRecordId: z.string().optional().describe("Back-link to knowledge record ID"),
+  sourcePath: z.string().optional().describe("Source file path")
+});
+const edgeSchema = z.object({
+  id: z.string().optional().describe("Edge ID (auto-generated if omitted)"),
+  fromId: z.string().describe("Source node ID"),
+  toId: z.string().describe("Target node ID"),
+  type: z.string().describe("Relationship type (depends-on, implements, calls, affects)"),
+  weight: z.number().min(0).max(1).optional().describe("Relationship weight"),
+  properties: z.record(z.string(), z.unknown()).optional().describe("Arbitrary properties")
+});
+function registerGraphTool(server, graphStore) {
+  server.registerTool(
+    "graph",
+    {
+      description: "Query and manage the knowledge graph. Find nodes/edges, traverse connections, add entities and relationships. The graph captures structural relationships between concepts discovered in the codebase.",
+      inputSchema: {
+        action: z.enum([
+          "find_nodes",
+          "find_edges",
+          "neighbors",
+          "traverse",
+          "stats",
+          "add",
+          "delete",
+          "clear"
+        ]).describe(
+          "Action: find_nodes (search nodes), find_edges (search edges), neighbors (direct connections), traverse (multi-hop), stats (graph overview), add (insert nodes/edges), delete (remove nodes), clear (remove all)"
+        ),
+        node_type: z.string().optional().describe("Node type filter (for find_nodes)"),
+        name_pattern: z.string().optional().describe("Name substring match (for find_nodes)"),
+        source_path: z.string().optional().describe("Source path filter"),
+        node_id: z.string().optional().describe("Node ID (for neighbors, traverse, delete)"),
+        edge_type: z.string().optional().describe("Edge type filter"),
+        from_id: z.string().optional().describe("Source node ID (for find_edges)"),
+        to_id: z.string().optional().describe("Target node ID (for find_edges)"),
+        direction: z.enum(["outgoing", "incoming", "both"]).default("both").describe("Traversal direction"),
+        max_depth: z.number().min(1).max(5).default(2).describe("Max traversal depth"),
+        limit: z.number().min(1).max(100).default(50).describe("Max results"),
+        nodes: z.array(nodeSchema).optional().describe("Nodes to add (for action=add)"),
+        edges: z.array(edgeSchema).optional().describe("Edges to add (for action=add)")
+      }
+    },
+    async (args) => {
+      try {
+        const result = await graphQuery(graphStore, {
+          action: args.action,
+          nodeType: args.node_type,
+          namePattern: args.name_pattern,
+          sourcePath: args.source_path,
+          nodeId: args.node_id,
+          edgeType: args.edge_type,
+          fromId: args.from_id,
+          toId: args.to_id,
+          direction: args.direction,
+          maxDepth: args.max_depth,
+          limit: args.limit,
+          nodes: args.nodes,
+          edges: args.edges
+        });
+        const parts = [result.summary];
+        if (result.nodes && result.nodes.length > 0) {
+          parts.push("\n### Nodes");
+          for (const n of result.nodes) {
+            const props = Object.keys(n.properties).length > 0 ? ` \u2014 ${JSON.stringify(n.properties)}` : "";
+            parts.push(`- **${n.name}** (${n.type}, id: \`${n.id}\`)${props}`);
+          }
+        }
+        if (result.edges && result.edges.length > 0) {
+          parts.push("\n### Edges");
+          for (const e of result.edges) {
+            parts.push(
+              `- \`${e.fromId}\` \u2014[${e.type}]\u2192 \`${e.toId}\`${e.weight !== 1 ? ` (weight: ${e.weight})` : ""}`
+            );
+          }
+        }
+        if (result.stats) {
+          parts.push(`
+Node types: ${JSON.stringify(result.stats.nodeTypes)}`);
+          parts.push(`Edge types: ${JSON.stringify(result.stats.edgeTypes)}`);
+        }
+        parts.push(
+          "\n---\n_Next: Use `graph(traverse)` to explore connections, `graph(add)` to insert entities, or `search` with graph-augmented results._"
+        );
+        return {
+          content: [{ type: "text", text: parts.join("\n") }]
+        };
+      } catch (err) {
+        console.error("[KB] Graph query failed:", err);
+        return {
+          content: [
+            { type: "text", text: `Graph query failed: ${err.message}` }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+export {
+  registerGraphTool
+};
+//# sourceMappingURL=graph.tool.js.map

package/packages/server/dist/tools/list.tool.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CuratedKnowledgeManager } from '../curated-manager.js';
+export declare function registerListTool(server: McpServer, curated: CuratedKnowledgeManager): void;
+//# sourceMappingURL=list.tool.d.ts.map