@vpxa/kb 0.1.1 → 0.1.2

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

@@ -1,110 +1,5 @@
-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
+import{graphQuery as a}from"@kb/tools";import{z as e}from"zod";const p=e.object({id:e.string().optional().describe("Node ID (auto-generated if omitted)"),type:e.string().describe("Node type (entity, service, api, concept, decision)"),name:e.string().describe("Display name"),properties:e.record(e.string(),e.unknown()).optional().describe("Arbitrary properties"),sourceRecordId:e.string().optional().describe("Back-link to knowledge record ID"),sourcePath:e.string().optional().describe("Source file path")}),c=e.object({id:e.string().optional().describe("Edge ID (auto-generated if omitted)"),fromId:e.string().describe("Source node ID"),toId:e.string().describe("Target node ID"),type:e.string().describe("Relationship type (depends-on, implements, calls, affects)"),weight:e.number().min(0).max(1).optional().describe("Relationship weight"),properties:e.record(e.string(),e.unknown()).optional().describe("Arbitrary properties")});function h(n,s){n.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:e.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:e.string().optional().describe("Node type filter (for find_nodes)"),name_pattern:e.string().optional().describe("Name substring match (for find_nodes)"),source_path:e.string().optional().describe("Source path filter"),node_id:e.string().optional().describe("Node ID (for neighbors, traverse, delete)"),edge_type:e.string().optional().describe("Edge type filter"),from_id:e.string().optional().describe("Source node ID (for find_edges)"),to_id:e.string().optional().describe("Target node ID (for find_edges)"),direction:e.enum(["outgoing","incoming","both"]).default("both").describe("Traversal direction"),max_depth:e.number().min(1).max(5).default(2).describe("Max traversal depth"),limit:e.number().min(1).max(100).default(50).describe("Max results"),nodes:e.array(p).optional().describe("Nodes to add (for action=add)"),edges:e.array(c).optional().describe("Edges to add (for action=add)")}},async t=>{try{const r=await a(s,{action:t.action,nodeType:t.node_type,namePattern:t.name_pattern,sourcePath:t.source_path,nodeId:t.node_id,edgeType:t.edge_type,fromId:t.from_id,toId:t.to_id,direction:t.direction,maxDepth:t.max_depth,limit:t.limit,nodes:t.nodes,edges:t.edges}),i=[r.summary];if(r.nodes&&r.nodes.length>0){i.push(`
+### Nodes`);for(const o of r.nodes){const d=Object.keys(o.properties).length>0?` \u2014 ${JSON.stringify(o.properties)}`:"";i.push(`- **${o.name}** (${o.type}, id: \`${o.id}\`)${d}`)}}if(r.edges&&r.edges.length>0){i.push(`
+### Edges`);for(const o of r.edges)i.push(`- \`${o.fromId}\` \u2014[${o.type}]\u2192 \`${o.toId}\`${o.weight!==1?` (weight: ${o.weight})`:""}`)}return r.stats&&(i.push(`
+Node types: ${JSON.stringify(r.stats.nodeTypes)}`),i.push(`Edge types: ${JSON.stringify(r.stats.edgeTypes)}`)),i.push("\n---\n_Next: Use `graph(traverse)` to explore connections, `graph(add)` to insert entities, or `search` with graph-augmented results._"),{content:[{type:"text",text:i.join(`
+`)}]}}catch(r){return console.error("[KB] Graph query failed:",r),{content:[{type:"text",text:`Graph query failed: ${r.message}`}],isError:!0}}})}export{h as registerGraphTool};

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

@@ -1,56 +1,8 @@
-import { z } from "zod";
-function registerListTool(server, curated) {
-  server.registerTool(
-    "list",
-    {
-      description: "List curated knowledge entries. Optionally filter by category or tag.",
-      inputSchema: {
-        category: z.string().optional().describe('Filter by category (e.g., "decisions", "patterns")'),
-        tag: z.string().optional().describe("Filter by tag")
-      }
-    },
-    async ({ category, tag }) => {
-      try {
-        const entries = await curated.list({ category, tag });
-        if (entries.length === 0) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "No curated knowledge entries found." + (category ? ` (category: ${category})` : "") + (tag ? ` (tag: ${tag})` : "")
-              }
-            ]
-          };
-        }
-        const formatted = entries.map((e) => {
-          const tags = e.tags.length > 0 ? ` [${e.tags.join(", ")}]` : "";
-          return `- **${e.title}** (v${e.version})${tags}
-  \`${e.path}\` \u2014 ${e.contentPreview.slice(0, 80)}\u2026`;
-        }).join("\n");
-        return {
-          content: [
-            {
-              type: "text",
-              text: `## Curated Knowledge (${entries.length} entries)
+import{z as o}from"zod";function g(s,i){s.registerTool("list",{description:"List curated knowledge entries. Optionally filter by category or tag.",inputSchema:{category:o.string().optional().describe('Filter by category (e.g., "decisions", "patterns")'),tag:o.string().optional().describe("Filter by tag")}},async({category:r,tag:n})=>{try{const t=await i.list({category:r,tag:n});if(t.length===0)return{content:[{type:"text",text:"No curated knowledge entries found."+(r?` (category: ${r})`:"")+(n?` (tag: ${n})`:"")}]};const a=t.map(e=>{const c=e.tags.length>0?` [${e.tags.join(", ")}]`:"";return`- **${e.title}** (v${e.version})${c}
+  \`${e.path}\` \u2014 ${e.contentPreview.slice(0,80)}\u2026`}).join(`
+`);return{content:[{type:"text",text:`## Curated Knowledge (${t.length} entries)
 
-${formatted}
+${a}
 
 ---
-_Next: Use \`read\` to view full content of any entry, or \`remember\` to store new knowledge._`
-            }
-          ]
-        };
-      } catch (err) {
-        console.error("[KB] List failed:", err);
-        return {
-          content: [{ type: "text", text: `List failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-export {
-  registerListTool
-};
-//# sourceMappingURL=list.tool.js.map
+_Next: Use \`read\` to view full content of any entry, or \`remember\` to store new knowledge._`}]}}catch(t){return console.error("[KB] List failed:",t),{content:[{type:"text",text:`List failed: ${t.message}`}],isError:!0}}})}export{g as registerListTool};

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

@@ -1,53 +1,10 @@
-import { z } from "zod";
-function registerLookupTool(server, store) {
-  server.registerTool(
-    "lookup",
-    {
-      description: "Look up all indexed chunks for a specific file path. Returns all chunks sorted by position.",
-      inputSchema: {
-        path: z.string().describe('Relative file path to look up (e.g., "src/index.ts")')
-      }
-    },
-    async ({ path }) => {
-      try {
-        const records = await store.getBySourcePath(path);
-        if (records.length === 0) {
-          return {
-            content: [{ type: "text", text: `No indexed content found for: ${path}` }]
-          };
-        }
-        records.sort((a, b) => a.chunkIndex - b.chunkIndex);
-        const header = `## ${path}
-**Chunks**: ${records.length} | **Type**: ${records[0].contentType}
-`;
-        const chunks = records.map((r) => {
-          const lineInfo = r.startLine ? ` (lines ${r.startLine}-${r.endLine})` : "";
-          return `### Chunk ${r.chunkIndex + 1}/${r.totalChunks}${lineInfo}
-${r.content}`;
-        }).join("\n\n");
-        return {
-          content: [
-            {
-              type: "text",
-              text: `${header}
-${chunks}
+import{z as p}from"zod";function d(r,s){r.registerTool("lookup",{description:"Look up all indexed chunks for a specific file path. Returns all chunks sorted by position.",inputSchema:{path:p.string().describe('Relative file path to look up (e.g., "src/index.ts")')}},async({path:n})=>{try{const e=await s.getBySourcePath(n);if(e.length===0)return{content:[{type:"text",text:`No indexed content found for: ${n}`}]};e.sort((t,o)=>t.chunkIndex-o.chunkIndex);const c=`## ${n}
+**Chunks**: ${e.length} | **Type**: ${e[0].contentType}
+`,i=e.map(t=>{const o=t.startLine?` (lines ${t.startLine}-${t.endLine})`:"";return`### Chunk ${t.chunkIndex+1}/${t.totalChunks}${o}
+${t.content}`}).join(`
+
+`);return{content:[{type:"text",text:`${c}
+${i}
 
 ---
-_Next: Use \`search\` to find related content, or \`analyze_dependencies\` to see what this file imports._`
-            }
-          ]
-        };
-      } catch (err) {
-        console.error("[KB] Lookup failed:", err);
-        return {
-          content: [{ type: "text", text: `Lookup failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-export {
-  registerLookupTool
-};
-//# sourceMappingURL=lookup.tool.js.map
+_Next: Use \`search\` to find related content, or \`analyze_dependencies\` to see what this file imports._`}]}}catch(e){return console.error("[KB] Lookup failed:",e),{content:[{type:"text",text:`Lookup failed: ${e.message}`}],isError:!0}}})}export{d as registerLookupTool};

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

@@ -1,112 +1,2 @@
-import { createHash } from "node:crypto";
-import { onboard } from "@kb/tools";
-import { z } from "zod";
-async function persistOnboardResults(store, embedder, result) {
-  for (const step of result.steps) {
-    if (step.status !== "success" || !step.output) continue;
-    try {
-      const pathHash = createHash("sha256").update(result.path).digest("hex").slice(0, 12);
-      const sourcePath = `produced/onboard/${step.name}/${pathHash}.md`;
-      const contentHash = createHash("sha256").update(step.output).digest("hex").slice(0, 16);
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const sections = step.output.length > 2e3 ? step.output.split(/(?=^## )/m).filter((s) => s.trim().length > 0) : [step.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: ["onboard", step.name],
-        category: "analysis",
-        version: 1
-      }));
-      const vectors = await embedder.embedBatch(records.map((r) => r.content));
-      await store.upsert(records, vectors);
-    } catch (err) {
-      console.error(`[KB] Auto-persist onboard/${step.name} failed:`, err);
-    }
-  }
-}
-function registerOnboardTool(server, store, embedder) {
-  server.registerTool(
-    "onboard",
-    {
-      description: "First-time codebase onboarding: runs all analysis tools (structure, dependencies, entry-points, symbols, patterns, diagram) in one command. Results are auto-persisted to KB. Use mode=generate to also write structured output to .ai/kb/ directory.",
-      inputSchema: {
-        path: z.string().describe("Root path of the codebase to onboard"),
-        mode: z.enum(["memory", "generate"]).default("memory").describe(
-          "Output mode: memory = KB vector store only; generate = also write to .ai/kb/ directory"
-        ),
-        out_dir: z.string().optional().describe("Custom output directory for generate mode (default: <path>/.ai/kb)")
-      }
-    },
-    async ({ path, mode, out_dir }) => {
-      try {
-        console.error(`[KB] Starting onboard for: ${path} (mode: ${mode})`);
-        const result = await onboard({
-          path,
-          mode,
-          outDir: out_dir
-        });
-        persistOnboardResults(store, embedder, result);
-        const lines = [
-          "## Onboard Complete",
-          "",
-          `**Path:** \`${result.path}\``,
-          `**Mode:** ${result.mode}`,
-          `**Duration:** ${result.totalDurationMs}ms`,
-          ""
-        ];
-        if (result.outDir) {
-          lines.push(`**Output directory:** \`${result.outDir}\``);
-          lines.push("");
-        }
-        lines.push("### Analysis Results", "");
-        const successSteps = [];
-        const failedSteps = [];
-        for (const step of result.steps) {
-          if (step.status === "success") {
-            successSteps.push(
-              `- \u2713 **${step.name}** (${step.durationMs}ms) \u2014 ${step.output.length} chars`
-            );
-          } else {
-            failedSteps.push(`- \u2717 **${step.name}** \u2014 ${step.error}`);
-          }
-        }
-        lines.push(...successSteps);
-        if (failedSteps.length > 0) {
-          lines.push("", "### Failed", "", ...failedSteps);
-        }
-        lines.push("", "---", "");
-        for (const step of result.steps) {
-          if (step.status !== "success") continue;
-          lines.push(`### ${step.name}`, "", step.output, "", "---", "");
-        }
-        lines.push(
-          "_All results auto-saved to KB.",
-          result.mode === "generate" ? ` Files written to \`${result.outDir}\`.` : "",
-          " Next: Use `search` to query the knowledge, or `remember` to add custom insights._"
-        );
-        return {
-          content: [{ type: "text", text: lines.join("\n") }]
-        };
-      } catch (err) {
-        console.error("[KB] Onboard failed:", err);
-        return {
-          content: [{ type: "text", text: `Onboard failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-export {
-  registerOnboardTool
-};
-//# sourceMappingURL=onboard.tool.js.map
+import{createHash as m}from"node:crypto";import{onboard as g}from"@kb/tools";import{z as l}from"zod";async function b(c,p,d){for(const t of d.steps)if(!(t.status!=="success"||!t.output))try{const s=m("sha256").update(d.path).digest("hex").slice(0,12),u=`produced/onboard/${t.name}/${s}.md`,e=m("sha256").update(t.output).digest("hex").slice(0,16),r=new Date().toISOString(),a=t.output.length>2e3?t.output.split(/(?=^## )/m).filter(i=>i.trim().length>0):[t.output],n=a.map((i,h)=>({id:m("sha256").update(`${u}::${h}`).digest("hex").slice(0,16),content:i.trim(),sourcePath:u,contentType:"produced-knowledge",chunkIndex:h,totalChunks:a.length,startLine:0,endLine:0,fileHash:e,indexedAt:r,origin:"produced",tags:["onboard",t.name],category:"analysis",version:1})),o=await p.embedBatch(n.map(i=>i.content));await c.upsert(n,o)}catch(s){console.error(`[KB] Auto-persist onboard/${t.name} failed:`,s)}}function w(c,p,d){c.registerTool("onboard",{description:"First-time codebase onboarding: runs all analysis tools (structure, dependencies, entry-points, symbols, patterns, diagram) in one command. Results are auto-persisted to KB. Use mode=generate to also write structured output to .ai/kb/ directory.",inputSchema:{path:l.string().describe("Root path of the codebase to onboard"),mode:l.enum(["memory","generate"]).default("memory").describe("Output mode: memory = KB vector store only; generate = also write to .ai/kb/ directory"),out_dir:l.string().optional().describe("Custom output directory for generate mode (default: <path>/.ai/kb)")}},async({path:t,mode:s,out_dir:u})=>{try{console.error(`[KB] Starting onboard for: ${t} (mode: ${s})`);const e=await g({path:t,mode:s,outDir:u});b(p,d,e);const r=["## Onboard Complete","",`**Path:** \`${e.path}\``,`**Mode:** ${e.mode}`,`**Duration:** ${e.totalDurationMs}ms`,""];e.outDir&&(r.push(`**Output directory:** \`${e.outDir}\``),r.push("")),r.push("### Analysis Results","");const a=[],n=[];for(const o of e.steps)o.status==="success"?a.push(`- \u2713 **${o.name}** (${o.durationMs}ms) \u2014 ${o.output.length} chars`):n.push(`- \u2717 **${o.name}** \u2014 ${o.error}`);r.push(...a),n.length>0&&r.push("","### Failed","",...n),r.push("","---","");for(const o of e.steps)o.status==="success"&&r.push(`### ${o.name}`,"",o.output,"","---","");return r.push("_All results auto-saved to KB.",e.mode==="generate"?` Files written to \`${e.outDir}\`.`:""," Next: Use `search` to query the knowledge, or `remember` to add custom insights._"),{content:[{type:"text",text:r.join(`
+`)}]}}catch(e){return console.error("[KB] Onboard failed:",e),{content:[{type:"text",text:`Onboard failed: ${e.message}`}],isError:!0}}})}export{w as registerOnboardTool};

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

@@ -1,74 +1,4 @@
-import {
-  DependencyAnalyzer,
-  DiagramGenerator,
-  EntryPointAnalyzer,
-  KnowledgeProducer,
-  PatternAnalyzer,
-  StructureAnalyzer,
-  SymbolAnalyzer
-} from "@kb/analyzers";
-import { z } from "zod";
-function registerProduceKnowledgeTool(server) {
-  const analyzers = {
-    structure: new StructureAnalyzer(),
-    dependencies: new DependencyAnalyzer(),
-    symbols: new SymbolAnalyzer(),
-    patterns: new PatternAnalyzer(),
-    entryPoints: new EntryPointAnalyzer(),
-    diagrams: new DiagramGenerator()
-  };
-  const producer = new KnowledgeProducer(analyzers);
-  server.registerTool(
-    "produce_knowledge",
-    {
-      description: "Run automated codebase analysis and produce synthesis instructions. Executes Tier 1 deterministic analyzers, then returns structured baselines and instructions for you to synthesize knowledge using remember.",
-      inputSchema: {
-        scope: z.string().optional().describe("Root path to analyze (defaults to workspace root)"),
-        aspects: z.array(
-          z.enum([
-            "all",
-            "structure",
-            "dependencies",
-            "symbols",
-            "patterns",
-            "entry-points",
-            "diagrams"
-          ])
-        ).default(["all"]).describe("Which analysis aspects to run")
-      }
-    },
-    async ({ scope, aspects }) => {
-      try {
-        const rootPath = scope ?? ".";
-        console.error(
-          `[KB] Running knowledge production for: ${rootPath}, aspects: ${aspects.join(", ")}`
-        );
-        const baselines = await producer.runExtraction(rootPath, aspects);
-        const instructions = producer.buildSynthesisInstructions(baselines, aspects);
-        return {
-          content: [
-            {
-              type: "text",
-              text: instructions + "\n\n---\n_Next: Review the baselines above and use `remember` to store synthesized knowledge entries._"
-            }
-          ]
-        };
-      } catch (err) {
-        console.error("[KB] Knowledge production failed:", err);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Knowledge production failed: ${err.message}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-export {
-  registerProduceKnowledgeTool
-};
-//# sourceMappingURL=produce.tool.js.map
+import{DependencyAnalyzer as c,DiagramGenerator as d,EntryPointAnalyzer as l,KnowledgeProducer as u,PatternAnalyzer as p,StructureAnalyzer as y,SymbolAnalyzer as m}from"@kb/analyzers";import{z as n}from"zod";function h(o){const s={structure:new y,dependencies:new c,symbols:new m,patterns:new p,entryPoints:new l,diagrams:new d},r=new u(s);o.registerTool("produce_knowledge",{description:"Run automated codebase analysis and produce synthesis instructions. Executes Tier 1 deterministic analyzers, then returns structured baselines and instructions for you to synthesize knowledge using remember.",inputSchema:{scope:n.string().optional().describe("Root path to analyze (defaults to workspace root)"),aspects:n.array(n.enum(["all","structure","dependencies","symbols","patterns","entry-points","diagrams"])).default(["all"]).describe("Which analysis aspects to run")}},async({scope:i,aspects:t})=>{try{const e=i??".";console.error(`[KB] Running knowledge production for: ${e}, aspects: ${t.join(", ")}`);const a=await r.runExtraction(e,t);return{content:[{type:"text",text:r.buildSynthesisInstructions(a,t)+`
+
+---
+_Next: Review the baselines above and use \`remember\` to store synthesized knowledge entries._`}]}}catch(e){return console.error("[KB] Knowledge production failed:",e),{content:[{type:"text",text:`Knowledge production failed: ${e.message}`}],isError:!0}}})}export{h as registerProduceKnowledgeTool};

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

@@ -1,49 +1,6 @@
-import { z } from "zod";
-function registerReadTool(server, curated) {
-  server.registerTool(
-    "read",
-    {
-      description: "Read the full content of a specific curated knowledge entry by its path. Use list first to discover available entries.",
-      inputSchema: {
-        path: z.string().describe('Relative path within curated/ (e.g., "decisions/use-lancedb.md")')
-      }
-    },
-    async ({ path }) => {
-      try {
-        const entry = await curated.read(path);
-        const meta = [
-          `## ${entry.title}`,
-          `- **Path**: curated/${path}`,
-          `- **Category**: ${entry.category}`,
-          entry.tags.length ? `- **Tags**: ${entry.tags.join(", ")}` : null,
-          `- **Version**: ${entry.version}`,
-          `- **Created**: ${entry.created}`,
-          entry.updated !== entry.created ? `- **Updated**: ${entry.updated}` : null,
-          ""
-        ].filter((l) => l !== null).join("\n");
-        return {
-          content: [
-            {
-              type: "text",
-              text: `${meta}
-${entry.content}
+import{z as o}from"zod";function i(r,a){r.registerTool("read",{description:"Read the full content of a specific curated knowledge entry by its path. Use list first to discover available entries.",inputSchema:{path:o.string().describe('Relative path within curated/ (e.g., "decisions/use-lancedb.md")')}},async({path:t})=>{try{const e=await a.read(t);return{content:[{type:"text",text:`${[`## ${e.title}`,`- **Path**: curated/${t}`,`- **Category**: ${e.category}`,e.tags.length?`- **Tags**: ${e.tags.join(", ")}`:null,`- **Version**: ${e.version}`,`- **Created**: ${e.created}`,e.updated!==e.created?`- **Updated**: ${e.updated}`:null,""].filter(n=>n!==null).join(`
+`)}
+${e.content}
 
 ---
-_Next: Use \`update\` to modify this entry, or \`search\` to find related entries._`
-            }
-          ]
-        };
-      } catch (err) {
-        console.error("[KB] Read failed:", err);
-        return {
-          content: [{ type: "text", text: `Read failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-export {
-  registerReadTool
-};
-//# sourceMappingURL=read.tool.js.map
+_Next: Use \`update\` to modify this entry, or \`search\` to find related entries._`}]}}catch(e){return console.error("[KB] Read failed:",e),{content:[{type:"text",text:`Read failed: ${e.message}`}],isError:!0}}})}export{i as registerReadTool};

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

@@ -1,70 +1,2 @@
-import { z } from "zod";
-function registerReindexTool(server, indexer, config, curated, store) {
-  server.registerTool(
-    "reindex",
-    {
-      description: "Trigger re-indexing of the knowledge base. Can do incremental (only changed files) or full re-index.",
-      inputSchema: {
-        full: z.boolean().default(false).describe("If true, force full re-index ignoring file hashes")
-      }
-    },
-    async ({ full }) => {
-      try {
-        console.error(`[KB] Starting ${full ? "full" : "incremental"} re-index...`);
-        const logProgress = (prefix) => (p) => {
-          if (p.phase === "chunking" && p.currentFile) {
-            console.error(
-              `[KB] ${prefix} [${p.filesProcessed + 1}/${p.filesTotal}] ${p.currentFile}`
-            );
-          }
-        };
-        const result = full ? await indexer.reindexAll(config, logProgress("Reindex")) : await indexer.index(config, logProgress("Index"));
-        const text = [
-          "## Re-index Complete",
-          "",
-          `- **Files Processed**: ${result.filesProcessed}`,
-          `- **Files Skipped** (unchanged): ${result.filesSkipped}`,
-          `- **Chunks Created**: ${result.chunksCreated}`,
-          `- **Files Removed**: ${result.filesRemoved}`,
-          `- **Duration**: ${(result.durationMs / 1e3).toFixed(1)}s`
-        ];
-        if (store) {
-          try {
-            await store.createFtsIndex();
-          } catch (ftsErr) {
-            text.push("", `- **FTS Index Failed**: ${ftsErr.message}`);
-          }
-        }
-        try {
-          const curatedResult = await curated.reindexAll();
-          text.push("", `- **Curated Entries Re-indexed**: ${curatedResult.indexed}`);
-          if (curatedResult.errors.length > 0) {
-            text.push(`- **Curated Errors**: ${curatedResult.errors.length}`);
-          }
-          console.error(`[KB] Curated re-index: ${curatedResult.indexed} entries`);
-        } catch (curatedErr) {
-          text.push("", `- **Curated Re-index Failed**: ${curatedErr.message}`);
-          console.error("[KB] Curated re-index failed:", curatedErr);
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: text.join("\n") + "\n\n---\n_Next: Use `search` to query the refreshed index, or `status` to verify index stats._"
-            }
-          ]
-        };
-      } catch (err) {
-        console.error("[KB] Reindex failed:", err);
-        return {
-          content: [{ type: "text", text: `Reindex failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-export {
-  registerReindexTool
-};
-//# sourceMappingURL=reindex.tool.js.map
+import{z as u}from"zod";function f(l,s,i,c,d){l.registerTool("reindex",{description:"Trigger re-indexing of the knowledge base. Can do incremental (only changed files) or full re-index.",inputSchema:{full:u.boolean().default(!1).describe("If true, force full re-index ignoring file hashes")}},async({full:a})=>{try{console.error(`[KB] Starting ${a?"full":"incremental"} re-index...`);const r=e=>o=>{o.phase==="chunking"&&o.currentFile&&console.error(`[KB] ${e} [${o.filesProcessed+1}/${o.filesTotal}] ${o.currentFile}`)},t=a?await s.reindexAll(i,r("Reindex")):await s.index(i,r("Index")),n=["## Re-index Complete","",`- **Files Processed**: ${t.filesProcessed}`,`- **Files Skipped** (unchanged): ${t.filesSkipped}`,`- **Chunks Created**: ${t.chunksCreated}`,`- **Files Removed**: ${t.filesRemoved}`,`- **Duration**: ${(t.durationMs/1e3).toFixed(1)}s`];if(d)try{await d.createFtsIndex()}catch(e){n.push("",`- **FTS Index Failed**: ${e.message}`)}try{const e=await c.reindexAll();n.push("",`- **Curated Entries Re-indexed**: ${e.indexed}`),e.errors.length>0&&n.push(`- **Curated Errors**: ${e.errors.length}`),console.error(`[KB] Curated re-index: ${e.indexed} entries`)}catch(e){n.push("",`- **Curated Re-index Failed**: ${e.message}`),console.error("[KB] Curated re-index failed:",e)}return{content:[{type:"text",text:n.join(`
+`)+"\n\n---\n_Next: Use `search` to query the refreshed index, or `status` to verify index stats._"}]}}catch(r){return console.error("[KB] Reindex failed:",r),{content:[{type:"text",text:`Reindex failed: ${r.message}`}],isError:!0}}})}export{f as registerReindexTool};

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

@@ -1,45 +1,6 @@
-import { z } from "zod";
-function registerRememberTool(server, curated) {
-  server.registerTool(
-    "remember",
-    {
-      description: "Store a new piece of curated knowledge. Use this to persist decisions, patterns, conventions, or any insight worth remembering across sessions.",
-      inputSchema: {
-        title: z.string().min(3).max(120).describe("Short descriptive title for the knowledge entry"),
-        content: z.string().min(10).describe("The markdown content to store"),
-        category: z.string().regex(/^[a-z][a-z0-9-]*$/).describe(
-          'Category slug (e.g., "decisions", "patterns", "conventions", "api-contracts")'
-        ),
-        tags: z.array(z.string()).default([]).describe("Optional tags for filtering")
-      }
-    },
-    async ({ title, content, category, tags }) => {
-      try {
-        const result = await curated.remember(title, content, category, tags);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Remembered: **${title}**
+import{z as e}from"zod";function d(n,o){n.registerTool("remember",{description:"Store a new piece of curated knowledge. Use this to persist decisions, patterns, conventions, or any insight worth remembering across sessions.",inputSchema:{title:e.string().min(3).max(120).describe("Short descriptive title for the knowledge entry"),content:e.string().min(10).describe("The markdown content to store"),category:e.string().regex(/^[a-z][a-z0-9-]*$/).describe('Category slug (e.g., "decisions", "patterns", "conventions", "api-contracts")'),tags:e.array(e.string()).default([]).describe("Optional tags for filtering")}},async({title:t,content:s,category:i,tags:a})=>{try{const r=await o.remember(t,s,i,a);return{content:[{type:"text",text:`Remembered: **${t}**
 
-Stored at \`curated/${result.path}\` and indexed for semantic search.
+Stored at \`curated/${r.path}\` and indexed for semantic search.
 
 ---
-_Next: Use \`search\` to verify the entry is findable, or \`list\` to see all curated entries._`
-            }
-          ]
-        };
-      } catch (err) {
-        console.error("[KB] Remember failed:", err);
-        return {
-          content: [{ type: "text", text: `Remember failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-export {
-  registerRememberTool
-};
-//# sourceMappingURL=remember.tool.js.map
+_Next: Use \`search\` to verify the entry is findable, or \`list\` to see all curated entries._`}]}}catch(r){return console.error("[KB] Remember failed:",r),{content:[{type:"text",text:`Remember failed: ${r.message}`}],isError:!0}}})}export{d as registerRememberTool};