@vpxa/kb 0.1.1 → 0.1.3

package/packages/server/dist/server.js

@@ -1,247 +1 @@
-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
+import{initializeTreeSitter as c}from"../../chunker/dist/index.js";import{OnnxEmbedder as m}from"../../embeddings/dist/index.js";import{IncrementalIndexer as g}from"../../indexer/dist/index.js";import{createStore as p,SqliteGraphStore as T}from"../../store/dist/index.js";import{McpServer as u}from"@modelcontextprotocol/sdk/server/mcp.js";import{CuratedKnowledgeManager as f}from"./curated-manager.js";import{installReplayInterceptor as h}from"./replay-interceptor.js";import{registerResources as S}from"./resources/resources.js";import{registerAnalyzeDependenciesTool as x,registerAnalyzeDiagramTool as w,registerAnalyzeEntryPointsTool as K,registerAnalyzePatternsTool as y,registerAnalyzeStructureTool as B,registerAnalyzeSymbolsTool as C,registerBlastRadiusTool as I}from"./tools/analyze.tools.js";import{registerDigestTool as v,registerEvidenceMapTool as P,registerForgeClassifyTool as z,registerForgeGroundTool as R,registerStratumCardTool as E}from"./tools/forge.tools.js";import{registerForgetTool as F}from"./tools/forget.tool.js";import{registerGraphTool as M}from"./tools/graph.tool.js";import{registerListTool as $}from"./tools/list.tool.js";import{registerLookupTool as G}from"./tools/lookup.tool.js";import{registerOnboardTool as A}from"./tools/onboard.tool.js";import{registerProduceKnowledgeTool as D}from"./tools/produce.tool.js";import{registerReadTool as O}from"./tools/read.tool.js";import{registerReindexTool as W}from"./tools/reindex.tool.js";import{registerRememberTool as j}from"./tools/remember.tool.js";import{registerReplayTool as L}from"./tools/replay.tool.js";import{registerSearchTool as H}from"./tools/search.tool.js";import{registerStatusTool as q}from"./tools/status.tool.js";import{registerBatchTool as N,registerCheckpointTool as Q,registerCheckTool as U,registerCodemodTool as V,registerCompactTool as _,registerDataTransformTool as J,registerDeadSymbolsTool as X,registerDelegateTool as Y,registerDiffParseTool as Z,registerEvalTool as b,registerFileSummaryTool as k,registerFindExamplesTool as ee,registerFindTool as re,registerGitContextTool as oe,registerHealthTool as te,registerLaneTool as se,registerParseOutputTool as ie,registerProcessTool as ne,registerQueueTool as ae,registerRenameTool as le,registerScopeMapTool as de,registerStashTool as ce,registerSymbolTool as me,registerTestRunTool as ge,registerTraceTool as pe,registerWatchTool as Te,registerWebFetchTool as ue,registerWorksetTool as fe}from"./tools/toolkit.tools.js";import{registerUpdateTool as he}from"./tools/update.tool.js";import{registerChangelogTool as Se,registerEncodeTool as xe,registerEnvTool as we,registerHttpTool as Ke,registerMeasureTool as ye,registerRegexTestTool as Be,registerSchemaValidateTool as Ce,registerSnippetTool as Ie,registerTimeTool as ve,registerWebSearchTool as Pe}from"./tools/utility.tools.js";async function ze(r){console.error("[KB] Initializing knowledge base components...");const t=new m({model:r.embedding.model,dimensions:r.embedding.dimensions});await t.initialize(),console.error(`[KB] Embedder loaded: ${t.modelId} (${t.dimensions}d)`);const e=await p({backend:r.store.backend,path:r.store.path});await e.initialize(),console.error("[KB] Store initialized");const a=new g(t,e),i=r.curated.path,d=new f(i,e,t),s=new T({path:r.store.path});await s.initialize(),console.error("[KB] Graph store initialized"),a.setGraphStore(s);const n=await c();return console.error(n?"[KB] Tree-sitter chunking enabled":"[KB] Tree-sitter not available \u2014 using regex-based code chunking"),{embedder:t,store:e,indexer:a,curated:d,graphStore:s}}function Re(r,t){const e=new u({name:"kb",version:"0.1.0"});return h(e),H(e,r.embedder,r.store,r.graphStore),G(e,r.store),q(e,r.store,r.graphStore),W(e,r.indexer,t,r.curated,r.store),j(e,r.curated),he(e,r.curated),F(e,r.curated),O(e,r.curated),$(e,r.curated),B(e,r.store,r.embedder),x(e,r.store,r.embedder),C(e,r.store,r.embedder),y(e,r.store,r.embedder),K(e,r.store,r.embedder),w(e,r.store,r.embedder),I(e,r.store,r.embedder),D(e),A(e,r.store,r.embedder),M(e,r.graphStore),_(e,r.embedder),de(e,r.embedder,r.store),re(e,r.embedder,r.store),ie(e),fe(e),U(e),N(e,r.embedder,r.store),me(e,r.embedder,r.store),b(e),ge(e),ce(e),oe(e),Z(e),le(e),V(e),k(e),Q(e),J(e),pe(e,r.embedder,r.store),ee(e,r.embedder,r.store),ne(e),Te(e),X(e,r.embedder,r.store),Y(e),te(e),se(e),ae(e),ue(e),P(e),v(e,r.embedder),z(e),E(e,r.embedder),R(e,r.embedder,r.store),Pe(e),Ke(e),Be(e),xe(e),ye(e),Se(e),Ce(e),Ie(e),we(e),ve(e),S(e,r.store),L(e),e}async function rr(r){const t=await ze(r),e=Re(t,r);console.error("[KB] MCP server configured with 64 tools and 2 resources");const a=async()=>{try{const n=r.sources.map(o=>o.path).join(", ");console.error(`[KB] Running initial index for sources: ${n}`);const l=await t.indexer.index(r,o=>{o.phase==="crawling"||o.phase==="done"||(o.phase==="chunking"&&o.currentFile&&console.error(`[KB]   [${o.filesProcessed+1}/${o.filesTotal}] ${o.currentFile}`),o.phase==="cleanup"&&console.error(`[KB]   cleanup: removing ${o.filesTotal-o.filesProcessed} stale entries`))});console.error(`[KB] Indexed ${l.filesProcessed} files (${l.filesSkipped} skipped, ${l.chunksCreated} chunks) in ${(l.durationMs/1e3).toFixed(1)}s`);try{await t.store.createFtsIndex()}catch(o){console.error("[KB] FTS index creation failed (non-fatal):",o)}try{const o=await t.curated.reindexAll();console.error(`[KB] Curated re-index: ${o.indexed} entries restored to vector store`)}catch(o){console.error("[KB] Curated re-index failed:",o)}}catch(n){console.error("[KB] Initial index failed (will retry on kb_reindex):",n)}},i=async()=>{console.error("[KB] Shutting down..."),await t.graphStore.close().catch(()=>{}),await t.store.close(),process.exit(0)};process.on("SIGINT",i),process.on("SIGTERM",i);const d=process.ppid,s=setInterval(()=>{try{process.kill(d,0)}catch{console.error("[KB] Parent process died \u2014 orphan detected, shutting down..."),clearInterval(s),i()}},5e3);return s.unref(),{server:e,runInitialIndex:a}}export{Re as createMcpServer,rr as createServer,ze as initializeKnowledgeBase};

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

@@ -1,288 +1 @@
-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
+import{createHash as y}from"node:crypto";import{BlastRadiusAnalyzer as f,DependencyAnalyzer as x,DiagramGenerator as b,EntryPointAnalyzer as w,PatternAnalyzer as z,StructureAnalyzer as _,SymbolAnalyzer as v}from"../../../analyzers/dist/index.js";import{z as a}from"zod";async function d(s,o,r,i,e){try{const t=y("sha256").update(i).digest("hex").slice(0,12),n=`produced/analysis/${r}/${t}.md`,c=y("sha256").update(e).digest("hex").slice(0,16),l=new Date().toISOString(),m=e.length>2e3?e.split(/(?=^## )/m).filter(p=>p.trim().length>0):[e],u=m.map((p,g)=>({id:y("sha256").update(`${n}::${g}`).digest("hex").slice(0,16),content:p.trim(),sourcePath:n,contentType:"produced-knowledge",chunkIndex:g,totalChunks:m.length,startLine:0,endLine:0,fileHash:c,indexedAt:l,origin:"produced",tags:["analysis",r],category:"analysis",version:1})),h=await o.embedBatch(u.map(p=>p.content));await s.upsert(u,h),console.error(`[KB] Auto-persisted ${r} analysis (${u.length} chunks)`)}catch(t){console.error(`[KB] Auto-persist ${r} failed:`,t)}}function K(s,o,r){const i=new _;s.registerTool("analyze_structure",{description:"Analyze the file/directory structure of a codebase. Returns an annotated tree with language stats.",inputSchema:{path:a.string().describe("Root path to analyze"),max_depth:a.number().min(1).max(10).default(6).describe("Maximum directory depth"),format:a.enum(["json","markdown"]).default("markdown").describe("Output format")}},async({path:e,max_depth:t,format:n})=>{try{const c=await i.analyze(e,{format:n,maxDepth:t});return d(o,r,"structure",e,c.output),{content:[{type:"text",text:c.output+"\n\n---\n_Analysis auto-saved to KB. Next: Use `analyze_dependencies` for import graphs, or `analyze_patterns` to detect architecture patterns._"}]}}catch(c){return{content:[{type:"text",text:`Analysis failed: ${c.message}`}],isError:!0}}})}function I(s,o,r){const i=new x;s.registerTool("analyze_dependencies",{description:"Analyze import/require dependencies across a codebase. Shows external packages and internal module graph.",inputSchema:{path:a.string().describe("Root path to analyze"),format:a.enum(["json","markdown","mermaid"]).default("markdown").describe("Output format")}},async({path:e,format:t})=>{try{const n=await i.analyze(e,{format:t});return d(o,r,"dependencies",e,n.output),{content:[{type:"text",text:n.output+"\n\n---\n_Analysis auto-saved to KB. Next: Use `analyze_symbols` to explore exported symbols, or `analyze_diagram` for visual representation._"}]}}catch(n){return{content:[{type:"text",text:`Analysis failed: ${n.message}`}],isError:!0}}})}function T(s,o,r){const i=new v;s.registerTool("analyze_symbols",{description:"Extract exported and local symbols (functions, classes, interfaces, types, constants) from a codebase.",inputSchema:{path:a.string().describe("Root path to analyze"),filter:a.string().optional().describe("Filter symbols by name substring"),format:a.enum(["json","markdown"]).default("markdown").describe("Output format")}},async({path:e,filter:t,format:n})=>{try{const c=await i.analyze(e,{format:n,filter:t});return d(o,r,"symbols",e,c.output),{content:[{type:"text",text:c.output+"\n\n---\n_Analysis auto-saved to KB. Next: Use `analyze_dependencies` to see import relationships, or `search` to find usage patterns._"}]}}catch(c){return{content:[{type:"text",text:`Analysis failed: ${c.message}`}],isError:!0}}})}function k(s,o,r){const i=new z;s.registerTool("analyze_patterns",{description:"Detect architectural patterns, frameworks, and conventions in a codebase using directory structure and code heuristics.",inputSchema:{path:a.string().describe("Root path to analyze")}},async({path:e})=>{try{const t=await i.analyze(e);return d(o,r,"patterns",e,t.output),{content:[{type:"text",text:t.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(t){return{content:[{type:"text",text:`Analysis failed: ${t.message}`}],isError:!0}}})}function $(s,o,r){const i=new w;s.registerTool("analyze_entry_points",{description:"Find entry points: Lambda handlers, main exports, CLI bins, and server start scripts.",inputSchema:{path:a.string().describe("Root path to analyze")}},async({path:e})=>{try{const t=await i.analyze(e);return d(o,r,"entry-points",e,t.output),{content:[{type:"text",text:t.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(t){return{content:[{type:"text",text:`Analysis failed: ${t.message}`}],isError:!0}}})}function B(s,o,r){const i=new b;s.registerTool("analyze_diagram",{description:"Generate a Mermaid diagram of the codebase architecture or dependency graph.",inputSchema:{path:a.string().describe("Root path to analyze"),diagram_type:a.enum(["architecture","dependencies"]).default("architecture").describe("Type of diagram")}},async({path:e,diagram_type:t})=>{try{const n=await i.analyze(e,{diagramType:t});return d(o,r,"diagram",e,n.output),{content:[{type:"text",text:n.output+"\n\n---\n_Analysis auto-saved to KB. Next: Use `analyze_structure` for detailed file tree, or `produce_knowledge` for comprehensive analysis._"}]}}catch(n){return{content:[{type:"text",text:`Diagram generation failed: ${n.message}`}],isError:!0}}})}function R(s,o,r){const i=new f;s.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:a.string().describe("Root path of the codebase"),files:a.array(a.string()).min(1).describe("Changed file paths (relative to root)"),max_depth:a.number().min(1).max(20).default(5).describe("Maximum transitive dependency depth"),format:a.enum(["json","markdown"]).default("markdown").describe("Output format")}},async({path:e,files:t,max_depth:n,format:c})=>{try{const l=await i.analyze(e,{files:t,maxDepth:n,format:c});return d(o,r,"blast-radius",e,l.output),{content:[{type:"text",text:l.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(l){return{content:[{type:"text",text:`Blast radius analysis failed: ${l.message}`}],isError:!0}}})}export{I as registerAnalyzeDependenciesTool,B as registerAnalyzeDiagramTool,$ as registerAnalyzeEntryPointsTool,k as registerAnalyzePatternsTool,K as registerAnalyzeStructureTool,T as registerAnalyzeSymbolsTool,R as registerBlastRadiusTool};