@vpxa/kb 0.1.1

package/packages/server/dist/replay-interceptor.js

@@ -0,0 +1,38 @@
+import { replayAppend } from "@kb/tools";
+function installReplayInterceptor(server) {
+  const original = server.registerTool.bind(server);
+  server.registerTool = (name, config, handler) => {
+    const wrappedHandler = async (args, extra) => {
+      const start = Date.now();
+      try {
+        const result = await handler(args, extra);
+        replayAppend({
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          source: "mcp",
+          tool: name,
+          input: JSON.stringify(args),
+          durationMs: Date.now() - start,
+          status: "ok",
+          output: JSON.stringify(result).slice(0, 200)
+        });
+        return result;
+      } catch (err) {
+        replayAppend({
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          source: "mcp",
+          tool: name,
+          input: JSON.stringify(args),
+          durationMs: Date.now() - start,
+          status: "error",
+          output: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      }
+    };
+    return original(name, config, wrappedHandler);
+  };
+}
+export {
+  installReplayInterceptor
+};
+//# sourceMappingURL=replay-interceptor.js.map

package/packages/server/dist/resources/resources.d.ts

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

package/packages/server/dist/resources/resources.js

@@ -0,0 +1,40 @@
+function registerResources(server, store) {
+  server.resource(
+    "kb-status",
+    "kb://status",
+    { description: "Current knowledge base status and statistics", mimeType: "text/plain" },
+    async () => {
+      const stats = await store.getStats();
+      return {
+        contents: [
+          {
+            uri: "kb://status",
+            text: `Knowledge Base: ${stats.totalRecords} records from ${stats.totalFiles} files. Last indexed: ${stats.lastIndexedAt ?? "Never"}`,
+            mimeType: "text/plain"
+          }
+        ]
+      };
+    }
+  );
+  server.resource(
+    "kb-file-tree",
+    "kb://file-tree",
+    { description: "List of all indexed source files", mimeType: "text/plain" },
+    async () => {
+      const paths = await store.listSourcePaths();
+      return {
+        contents: [
+          {
+            uri: "kb://file-tree",
+            text: paths.sort().join("\n"),
+            mimeType: "text/plain"
+          }
+        ]
+      };
+    }
+  );
+}
+export {
+  registerResources
+};
+//# sourceMappingURL=resources.js.map

package/packages/server/dist/server.d.ts

@@ -0,0 +1,21 @@
+import type { KBConfig } from '@kb/core';
+import { OnnxEmbedder } from '@kb/embeddings';
+import { IncrementalIndexer } from '@kb/indexer';
+import type { IGraphStore } from '@kb/store';
+import { createStore } from '@kb/store';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { CuratedKnowledgeManager } from './curated-manager.js';
+export interface KnowledgeBaseComponents {
+    embedder: OnnxEmbedder;
+    store: Awaited<ReturnType<typeof createStore>>;
+    indexer: IncrementalIndexer;
+    curated: CuratedKnowledgeManager;
+    graphStore: IGraphStore;
+}
+export declare function initializeKnowledgeBase(config: KBConfig): Promise<KnowledgeBaseComponents>;
+export declare function createMcpServer(kb: KnowledgeBaseComponents, config: KBConfig): McpServer;
+export declare function createServer(config: KBConfig): Promise<{
+    server: McpServer;
+    runInitialIndex: () => Promise<void>;
+}>;
+//# sourceMappingURL=server.d.ts.map

package/packages/server/dist/server.js

@@ -0,0 +1,247 @@
+import { initializeTreeSitter } from "@kb/chunker";
+import { OnnxEmbedder } from "@kb/embeddings";
+import { IncrementalIndexer } from "@kb/indexer";
+import { createStore, SqliteGraphStore } from "@kb/store";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CuratedKnowledgeManager } from "./curated-manager.js";
+import { installReplayInterceptor } from "./replay-interceptor.js";
+import { registerResources } from "./resources/resources.js";
+import {
+  registerAnalyzeDependenciesTool,
+  registerAnalyzeDiagramTool,
+  registerAnalyzeEntryPointsTool,
+  registerAnalyzePatternsTool,
+  registerAnalyzeStructureTool,
+  registerAnalyzeSymbolsTool,
+  registerBlastRadiusTool
+} from "./tools/analyze.tools.js";
+import {
+  registerDigestTool,
+  registerEvidenceMapTool,
+  registerForgeClassifyTool,
+  registerForgeGroundTool,
+  registerStratumCardTool
+} from "./tools/forge.tools.js";
+import { registerForgetTool } from "./tools/forget.tool.js";
+import { registerGraphTool } from "./tools/graph.tool.js";
+import { registerListTool } from "./tools/list.tool.js";
+import { registerLookupTool } from "./tools/lookup.tool.js";
+import { registerOnboardTool } from "./tools/onboard.tool.js";
+import { registerProduceKnowledgeTool } from "./tools/produce.tool.js";
+import { registerReadTool } from "./tools/read.tool.js";
+import { registerReindexTool } from "./tools/reindex.tool.js";
+import { registerRememberTool } from "./tools/remember.tool.js";
+import { registerReplayTool } from "./tools/replay.tool.js";
+import { registerSearchTool } from "./tools/search.tool.js";
+import { registerStatusTool } from "./tools/status.tool.js";
+import {
+  registerBatchTool,
+  registerCheckpointTool,
+  registerCheckTool,
+  registerCodemodTool,
+  registerCompactTool,
+  registerDataTransformTool,
+  registerDeadSymbolsTool,
+  registerDelegateTool,
+  registerDiffParseTool,
+  registerEvalTool,
+  registerFileSummaryTool,
+  registerFindExamplesTool,
+  registerFindTool,
+  registerGitContextTool,
+  registerHealthTool,
+  registerLaneTool,
+  registerParseOutputTool,
+  registerProcessTool,
+  registerQueueTool,
+  registerRenameTool,
+  registerScopeMapTool,
+  registerStashTool,
+  registerSymbolTool,
+  registerTestRunTool,
+  registerTraceTool,
+  registerWatchTool,
+  registerWebFetchTool,
+  registerWorksetTool
+} from "./tools/toolkit.tools.js";
+import { registerUpdateTool } from "./tools/update.tool.js";
+import {
+  registerChangelogTool,
+  registerEncodeTool,
+  registerEnvTool,
+  registerHttpTool,
+  registerMeasureTool,
+  registerRegexTestTool,
+  registerSchemaValidateTool,
+  registerSnippetTool,
+  registerTimeTool,
+  registerWebSearchTool
+} from "./tools/utility.tools.js";
+async function initializeKnowledgeBase(config) {
+  console.error("[KB] Initializing knowledge base components...");
+  const embedder = new OnnxEmbedder({
+    model: config.embedding.model,
+    dimensions: config.embedding.dimensions
+  });
+  await embedder.initialize();
+  console.error(`[KB] Embedder loaded: ${embedder.modelId} (${embedder.dimensions}d)`);
+  const store = await createStore({
+    backend: config.store.backend,
+    path: config.store.path
+  });
+  await store.initialize();
+  console.error("[KB] Store initialized");
+  const indexer = new IncrementalIndexer(embedder, store);
+  const curatedDir = config.curated.path;
+  const curated = new CuratedKnowledgeManager(curatedDir, store, embedder);
+  const graphStore = new SqliteGraphStore({ path: config.store.path });
+  await graphStore.initialize();
+  console.error("[KB] Graph store initialized");
+  indexer.setGraphStore(graphStore);
+  const treeSitterAvailable = await initializeTreeSitter();
+  if (treeSitterAvailable) {
+    console.error("[KB] Tree-sitter chunking enabled");
+  } else {
+    console.error("[KB] Tree-sitter not available \u2014 using regex-based code chunking");
+  }
+  return { embedder, store, indexer, curated, graphStore };
+}
+function createMcpServer(kb, config) {
+  const server = new McpServer({
+    name: "kb",
+    version: "0.1.0"
+  });
+  installReplayInterceptor(server);
+  registerSearchTool(server, kb.embedder, kb.store, kb.graphStore);
+  registerLookupTool(server, kb.store);
+  registerStatusTool(server, kb.store, kb.graphStore);
+  registerReindexTool(server, kb.indexer, config, kb.curated, kb.store);
+  registerRememberTool(server, kb.curated);
+  registerUpdateTool(server, kb.curated);
+  registerForgetTool(server, kb.curated);
+  registerReadTool(server, kb.curated);
+  registerListTool(server, kb.curated);
+  registerAnalyzeStructureTool(server, kb.store, kb.embedder);
+  registerAnalyzeDependenciesTool(server, kb.store, kb.embedder);
+  registerAnalyzeSymbolsTool(server, kb.store, kb.embedder);
+  registerAnalyzePatternsTool(server, kb.store, kb.embedder);
+  registerAnalyzeEntryPointsTool(server, kb.store, kb.embedder);
+  registerAnalyzeDiagramTool(server, kb.store, kb.embedder);
+  registerBlastRadiusTool(server, kb.store, kb.embedder);
+  registerProduceKnowledgeTool(server);
+  registerOnboardTool(server, kb.store, kb.embedder);
+  registerGraphTool(server, kb.graphStore);
+  registerCompactTool(server, kb.embedder);
+  registerScopeMapTool(server, kb.embedder, kb.store);
+  registerFindTool(server, kb.embedder, kb.store);
+  registerParseOutputTool(server);
+  registerWorksetTool(server);
+  registerCheckTool(server);
+  registerBatchTool(server, kb.embedder, kb.store);
+  registerSymbolTool(server, kb.embedder, kb.store);
+  registerEvalTool(server);
+  registerTestRunTool(server);
+  registerStashTool(server);
+  registerGitContextTool(server);
+  registerDiffParseTool(server);
+  registerRenameTool(server);
+  registerCodemodTool(server);
+  registerFileSummaryTool(server);
+  registerCheckpointTool(server);
+  registerDataTransformTool(server);
+  registerTraceTool(server, kb.embedder, kb.store);
+  registerFindExamplesTool(server, kb.embedder, kb.store);
+  registerProcessTool(server);
+  registerWatchTool(server);
+  registerDeadSymbolsTool(server, kb.embedder, kb.store);
+  registerDelegateTool(server);
+  registerHealthTool(server);
+  registerLaneTool(server);
+  registerQueueTool(server);
+  registerWebFetchTool(server);
+  registerEvidenceMapTool(server);
+  registerDigestTool(server, kb.embedder);
+  registerForgeClassifyTool(server);
+  registerStratumCardTool(server, kb.embedder);
+  registerForgeGroundTool(server, kb.embedder, kb.store);
+  registerWebSearchTool(server);
+  registerHttpTool(server);
+  registerRegexTestTool(server);
+  registerEncodeTool(server);
+  registerMeasureTool(server);
+  registerChangelogTool(server);
+  registerSchemaValidateTool(server);
+  registerSnippetTool(server);
+  registerEnvTool(server);
+  registerTimeTool(server);
+  registerResources(server, kb.store);
+  registerReplayTool(server);
+  return server;
+}
+async function createServer(config) {
+  const kb = await initializeKnowledgeBase(config);
+  const server = createMcpServer(kb, config);
+  console.error("[KB] MCP server configured with 64 tools and 2 resources");
+  const runInitialIndex = async () => {
+    try {
+      const sourcePaths = config.sources.map((s) => s.path).join(", ");
+      console.error(`[KB] Running initial index for sources: ${sourcePaths}`);
+      const result = await kb.indexer.index(config, (p) => {
+        if (p.phase === "crawling" || p.phase === "done") return;
+        if (p.phase === "chunking" && p.currentFile) {
+          console.error(`[KB]   [${p.filesProcessed + 1}/${p.filesTotal}] ${p.currentFile}`);
+        }
+        if (p.phase === "cleanup") {
+          console.error(
+            `[KB]   cleanup: removing ${p.filesTotal - p.filesProcessed} stale entries`
+          );
+        }
+      });
+      console.error(
+        `[KB] Indexed ${result.filesProcessed} files (${result.filesSkipped} skipped, ${result.chunksCreated} chunks) in ${(result.durationMs / 1e3).toFixed(1)}s`
+      );
+      try {
+        await kb.store.createFtsIndex();
+      } catch (ftsErr) {
+        console.error("[KB] FTS index creation failed (non-fatal):", ftsErr);
+      }
+      try {
+        const curatedResult = await kb.curated.reindexAll();
+        console.error(
+          `[KB] Curated re-index: ${curatedResult.indexed} entries restored to vector store`
+        );
+      } catch (curatedErr) {
+        console.error("[KB] Curated re-index failed:", curatedErr);
+      }
+    } catch (err) {
+      console.error("[KB] Initial index failed (will retry on kb_reindex):", err);
+    }
+  };
+  const shutdown = async () => {
+    console.error("[KB] Shutting down...");
+    await kb.graphStore.close().catch(() => {
+    });
+    await kb.store.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  const originalPpid = process.ppid;
+  const ppidCheck = setInterval(() => {
+    try {
+      process.kill(originalPpid, 0);
+    } catch {
+      console.error("[KB] Parent process died \u2014 orphan detected, shutting down...");
+      clearInterval(ppidCheck);
+      shutdown();
+    }
+  }, 5e3);
+  ppidCheck.unref();
+  return { server, runInitialIndex };
+}
+export {
+  createMcpServer,
+  createServer,
+  initializeKnowledgeBase
+};
+//# sourceMappingURL=server.js.map

package/packages/server/dist/tools/analyze.tools.d.ts

@@ -0,0 +1,11 @@
+import type { IEmbedder } from '@kb/embeddings';
+import type { IKnowledgeStore } from '@kb/store';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerAnalyzeStructureTool(server: McpServer, store: IKnowledgeStore, embedder: IEmbedder): void;
+export declare function registerAnalyzeDependenciesTool(server: McpServer, store: IKnowledgeStore, embedder: IEmbedder): void;
+export declare function registerAnalyzeSymbolsTool(server: McpServer, store: IKnowledgeStore, embedder: IEmbedder): void;
+export declare function registerAnalyzePatternsTool(server: McpServer, store: IKnowledgeStore, embedder: IEmbedder): void;
+export declare function registerAnalyzeEntryPointsTool(server: McpServer, store: IKnowledgeStore, embedder: IEmbedder): void;
+export declare function registerAnalyzeDiagramTool(server: McpServer, store: IKnowledgeStore, embedder: IEmbedder): void;
+export declare function registerBlastRadiusTool(server: McpServer, store: IKnowledgeStore, embedder: IEmbedder): void;
+//# sourceMappingURL=analyze.tools.d.ts.map

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

@@ -0,0 +1,288 @@
+import { createHash } from "node:crypto";
+import {
+  BlastRadiusAnalyzer,
+  DependencyAnalyzer,
+  DiagramGenerator,
+  EntryPointAnalyzer,
+  PatternAnalyzer,
+  StructureAnalyzer,
+  SymbolAnalyzer
+} from "@kb/analyzers";
+import { z } from "zod";
+async function persistAnalysisResult(store, embedder, analyzerName, rootPath, output) {
+  try {
+    const pathHash = createHash("sha256").update(rootPath).digest("hex").slice(0, 12);
+    const sourcePath = `produced/analysis/${analyzerName}/${pathHash}.md`;
+    const contentHash = createHash("sha256").update(output).digest("hex").slice(0, 16);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const sections = output.length > 2e3 ? output.split(/(?=^## )/m).filter((s) => s.trim().length > 0) : [output];
+    const records = sections.map((text, i) => ({
+      id: createHash("sha256").update(`${sourcePath}::${i}`).digest("hex").slice(0, 16),
+      content: text.trim(),
+      sourcePath,
+      contentType: "produced-knowledge",
+      chunkIndex: i,
+      totalChunks: sections.length,
+      startLine: 0,
+      endLine: 0,
+      fileHash: contentHash,
+      indexedAt: now,
+      origin: "produced",
+      tags: ["analysis", analyzerName],
+      category: "analysis",
+      version: 1
+    }));
+    const vectors = await embedder.embedBatch(records.map((r) => r.content));
+    await store.upsert(records, vectors);
+    console.error(`[KB] Auto-persisted ${analyzerName} analysis (${records.length} chunks)`);
+  } catch (err) {
+    console.error(`[KB] Auto-persist ${analyzerName} failed:`, err);
+  }
+}
+function registerAnalyzeStructureTool(server, store, embedder) {
+  const analyzer = new StructureAnalyzer();
+  server.registerTool(
+    "analyze_structure",
+    {
+      description: "Analyze the file/directory structure of a codebase. Returns an annotated tree with language stats.",
+      inputSchema: {
+        path: z.string().describe("Root path to analyze"),
+        max_depth: z.number().min(1).max(10).default(6).describe("Maximum directory depth"),
+        format: z.enum(["json", "markdown"]).default("markdown").describe("Output format")
+      }
+    },
+    async ({ path, max_depth, format }) => {
+      try {
+        const result = await analyzer.analyze(path, { format, maxDepth: max_depth });
+        persistAnalysisResult(store, embedder, "structure", path, result.output);
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.output + "\n\n---\n_Analysis auto-saved to KB. Next: Use `analyze_dependencies` for import graphs, or `analyze_patterns` to detect architecture patterns._"
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Analysis failed: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerAnalyzeDependenciesTool(server, store, embedder) {
+  const analyzer = new DependencyAnalyzer();
+  server.registerTool(
+    "analyze_dependencies",
+    {
+      description: "Analyze import/require dependencies across a codebase. Shows external packages and internal module graph.",
+      inputSchema: {
+        path: z.string().describe("Root path to analyze"),
+        format: z.enum(["json", "markdown", "mermaid"]).default("markdown").describe("Output format")
+      }
+    },
+    async ({ path, format }) => {
+      try {
+        const result = await analyzer.analyze(path, { format });
+        persistAnalysisResult(store, embedder, "dependencies", path, result.output);
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.output + "\n\n---\n_Analysis auto-saved to KB. Next: Use `analyze_symbols` to explore exported symbols, or `analyze_diagram` for visual representation._"
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Analysis failed: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerAnalyzeSymbolsTool(server, store, embedder) {
+  const analyzer = new SymbolAnalyzer();
+  server.registerTool(
+    "analyze_symbols",
+    {
+      description: "Extract exported and local symbols (functions, classes, interfaces, types, constants) from a codebase.",
+      inputSchema: {
+        path: z.string().describe("Root path to analyze"),
+        filter: z.string().optional().describe("Filter symbols by name substring"),
+        format: z.enum(["json", "markdown"]).default("markdown").describe("Output format")
+      }
+    },
+    async ({ path, filter, format }) => {
+      try {
+        const result = await analyzer.analyze(path, { format, filter });
+        persistAnalysisResult(store, embedder, "symbols", path, result.output);
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.output + "\n\n---\n_Analysis auto-saved to KB. Next: Use `analyze_dependencies` to see import relationships, or `search` to find usage patterns._"
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Analysis failed: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerAnalyzePatternsTool(server, store, embedder) {
+  const analyzer = new PatternAnalyzer();
+  server.registerTool(
+    "analyze_patterns",
+    {
+      description: "Detect architectural patterns, frameworks, and conventions in a codebase using directory structure and code heuristics.",
+      inputSchema: {
+        path: z.string().describe("Root path to analyze")
+      }
+    },
+    async ({ path }) => {
+      try {
+        const result = await analyzer.analyze(path);
+        persistAnalysisResult(store, embedder, "patterns", path, result.output);
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.output + "\n\n---\n_Analysis auto-saved to KB. Next: Use `analyze_entry_points` to find Lambda handlers and main exports, or `produce_knowledge` for full analysis._"
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Analysis failed: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerAnalyzeEntryPointsTool(server, store, embedder) {
+  const analyzer = new EntryPointAnalyzer();
+  server.registerTool(
+    "analyze_entry_points",
+    {
+      description: "Find entry points: Lambda handlers, main exports, CLI bins, and server start scripts.",
+      inputSchema: {
+        path: z.string().describe("Root path to analyze")
+      }
+    },
+    async ({ path }) => {
+      try {
+        const result = await analyzer.analyze(path);
+        persistAnalysisResult(store, embedder, "entry-points", path, result.output);
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.output + "\n\n---\n_Analysis auto-saved to KB. Next: Use `analyze_dependencies` to see what each entry point imports, or `produce_knowledge` for comprehensive analysis._"
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Analysis failed: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerAnalyzeDiagramTool(server, store, embedder) {
+  const generator = new DiagramGenerator();
+  server.registerTool(
+    "analyze_diagram",
+    {
+      description: "Generate a Mermaid diagram of the codebase architecture or dependency graph.",
+      inputSchema: {
+        path: z.string().describe("Root path to analyze"),
+        diagram_type: z.enum(["architecture", "dependencies"]).default("architecture").describe("Type of diagram")
+      }
+    },
+    async ({ path, diagram_type }) => {
+      try {
+        const result = await generator.analyze(path, { diagramType: diagram_type });
+        persistAnalysisResult(store, embedder, "diagram", path, result.output);
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.output + "\n\n---\n_Analysis auto-saved to KB. Next: Use `analyze_structure` for detailed file tree, or `produce_knowledge` for comprehensive analysis._"
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            { type: "text", text: `Diagram generation failed: ${err.message}` }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerBlastRadiusTool(server, store, embedder) {
+  const analyzer = new BlastRadiusAnalyzer();
+  server.registerTool(
+    "blast_radius",
+    {
+      description: "Given a list of changed files, trace the dependency graph to find all affected files (direct + transitive importers) and their tests. Useful for scoping code reviews and impact analysis.",
+      inputSchema: {
+        path: z.string().describe("Root path of the codebase"),
+        files: z.array(z.string()).min(1).describe("Changed file paths (relative to root)"),
+        max_depth: z.number().min(1).max(20).default(5).describe("Maximum transitive dependency depth"),
+        format: z.enum(["json", "markdown"]).default("markdown").describe("Output format")
+      }
+    },
+    async ({ path, files, max_depth, format }) => {
+      try {
+        const result = await analyzer.analyze(path, {
+          files,
+          maxDepth: max_depth,
+          format
+        });
+        persistAnalysisResult(store, embedder, "blast-radius", path, result.output);
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.output + "\n\n---\n_Analysis auto-saved to KB. Next: Use `analyze_dependencies` to see the full import graph, or `analyze_symbols` to inspect affected exports._"
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Blast radius analysis failed: ${err.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+export {
+  registerAnalyzeDependenciesTool,
+  registerAnalyzeDiagramTool,
+  registerAnalyzeEntryPointsTool,
+  registerAnalyzePatternsTool,
+  registerAnalyzeStructureTool,
+  registerAnalyzeSymbolsTool,
+  registerBlastRadiusTool
+};
+//# sourceMappingURL=analyze.tools.js.map

package/packages/server/dist/tools/forge.tools.d.ts

@@ -0,0 +1,12 @@
+/**
+ * MCP tool registrations for FORGE/STRATUM protocol tools.
+ */
+import type { IEmbedder } from '@kb/embeddings';
+import type { IKnowledgeStore } from '@kb/store';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerEvidenceMapTool(server: McpServer): void;
+export declare function registerDigestTool(server: McpServer, embedder: IEmbedder): void;
+export declare function registerForgeClassifyTool(server: McpServer): void;
+export declare function registerStratumCardTool(server: McpServer, embedder: IEmbedder): void;
+export declare function registerForgeGroundTool(server: McpServer, embedder: IEmbedder, store: IKnowledgeStore): void;
+//# sourceMappingURL=forge.tools.d.ts.map