@vpxa/kb 0.1.1

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

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

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

@@ -0,0 +1,42 @@
+import { z } from "zod";
+function registerUpdateTool(server, curated) {
+  server.registerTool(
+    "update",
+    {
+      description: "Update an existing curated knowledge entry. Increments version and records the reason in the changelog.",
+      inputSchema: {
+        path: z.string().describe('Relative path within curated/ (e.g., "decisions/use-lancedb.md")'),
+        content: z.string().min(10).describe("New markdown content to replace existing content"),
+        reason: z.string().min(3).describe("Why this update is being made (recorded in changelog)")
+      }
+    },
+    async ({ path, content, reason }) => {
+      try {
+        const result = await curated.update(path, content, reason);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Updated: \`curated/${result.path}\` \u2192 version ${result.version}
+
+Reason: ${reason}
+
+---
+_Next: Use \`read\` to verify the updated content, or \`search\` to test searchability._`
+            }
+          ]
+        };
+      } catch (err) {
+        console.error("[KB] Update failed:", err);
+        return {
+          content: [{ type: "text", text: `Update failed: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+export {
+  registerUpdateTool
+};
+//# sourceMappingURL=update.tool.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * MCP tool registrations for utility tools (web-search, http, regex, encode, etc.)
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerWebSearchTool(server: McpServer): void;
+export declare function registerHttpTool(server: McpServer): void;
+export declare function registerRegexTestTool(server: McpServer): void;
+export declare function registerEncodeTool(server: McpServer): void;
+export declare function registerMeasureTool(server: McpServer): void;
+export declare function registerChangelogTool(server: McpServer): void;
+export declare function registerSchemaValidateTool(server: McpServer): void;
+export declare function registerSnippetTool(server: McpServer): void;
+export declare function registerEnvTool(server: McpServer): void;
+export declare function registerTimeTool(server: McpServer): void;
+//# sourceMappingURL=utility.tools.d.ts.map

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

@@ -0,0 +1,461 @@
+import {
+  changelog,
+  encode,
+  envInfo,
+  httpRequest,
+  measure,
+  regexTest,
+  schemaValidate,
+  snippet,
+  timeUtils,
+  webSearch
+} from "@kb/tools";
+import { z } from "zod";
+function registerWebSearchTool(server) {
+  server.registerTool(
+    "web_search",
+    {
+      description: "PREFERRED web search \u2014 search the web via DuckDuckGo (no API key). Returns structured results with title, URL, and snippet.",
+      inputSchema: {
+        query: z.string().describe("Search query"),
+        limit: z.number().min(1).max(20).default(5).describe("Max results to return"),
+        site: z.string().optional().describe('Restrict to domain (e.g., "docs.aws.amazon.com")')
+      }
+    },
+    async ({ query, limit, site }) => {
+      try {
+        const result = await webSearch({ query, limit, site });
+        const lines = [`## Search: ${result.query}`, ""];
+        if (result.results.length === 0) {
+          lines.push("No results found.");
+        } else {
+          for (const r of result.results) {
+            lines.push(`### [${r.title}](${r.url})`, r.snippet, "");
+          }
+        }
+        lines.push("---", "_Next: Use `web_fetch` to read any of these pages in full._");
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        return {
+          content: [
+            { type: "text", text: `Web search failed: ${err.message}` }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerHttpTool(server) {
+  server.registerTool(
+    "http",
+    {
+      description: "Make HTTP requests (GET/POST/PUT/PATCH/DELETE/HEAD) for API testing. Returns status, headers, and formatted body with timing info.",
+      inputSchema: {
+        url: z.string().url().describe("Request URL (http/https only)"),
+        method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]).default("GET").describe("HTTP method"),
+        headers: z.record(z.string(), z.string()).optional().describe("Request headers as key-value pairs"),
+        body: z.string().optional().describe("Request body (for POST/PUT/PATCH)"),
+        timeout: z.number().min(1e3).max(6e4).default(15e3).describe("Timeout in milliseconds")
+      }
+    },
+    async ({ url, method, headers, body, timeout }) => {
+      try {
+        const result = await httpRequest({
+          url,
+          method,
+          headers,
+          body,
+          timeout
+        });
+        const lines = [
+          `## ${method} ${url}`,
+          "",
+          `**Status:** ${result.status} ${result.statusText}`,
+          `**Time:** ${result.durationMs}ms`,
+          `**Size:** ${result.sizeBytes} bytes`,
+          `**Content-Type:** ${result.contentType}`,
+          "",
+          "### Headers",
+          "```json",
+          JSON.stringify(result.headers, null, 2),
+          "```",
+          "",
+          "### Body",
+          result.contentType.includes("json") ? "```json" : "```",
+          result.body,
+          "```"
+        ];
+        if (result.truncated) {
+          lines.push("", `_Response truncated \u2014 total size: ${result.sizeBytes} bytes_`);
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        return {
+          content: [
+            { type: "text", text: `HTTP request failed: ${err.message}` }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerRegexTestTool(server) {
+  server.registerTool(
+    "regex_test",
+    {
+      description: "Test a regex pattern against sample strings. Supports match, replace, and split modes.",
+      inputSchema: {
+        pattern: z.string().describe("Regex pattern (without delimiters)"),
+        flags: z.string().default("").describe("Regex flags (g, i, m, s, etc.)"),
+        test_strings: z.array(z.string()).describe("Strings to test the pattern against"),
+        mode: z.enum(["match", "replace", "split"]).default("match").describe("Test mode"),
+        replacement: z.string().optional().describe("Replacement string (for replace mode)")
+      }
+    },
+    async ({ pattern, flags, test_strings, mode, replacement }) => {
+      const result = regexTest({
+        pattern,
+        flags,
+        testStrings: test_strings,
+        mode,
+        replacement
+      });
+      if (!result.valid) {
+        return {
+          content: [{ type: "text", text: `Invalid regex: ${result.error}` }],
+          isError: true
+        };
+      }
+      const lines = [`## Regex: \`/${result.pattern}/${result.flags}\``, "", `Mode: ${mode}`, ""];
+      for (const r of result.results) {
+        lines.push(`**Input:** \`${r.input}\``);
+        lines.push(`**Matched:** ${r.matched}`);
+        if (r.matches) {
+          for (const m of r.matches) {
+            const groups = m.groups.length > 0 ? ` groups: [${m.groups.join(", ")}]` : "";
+            lines.push(`  - "${m.full}" at index ${m.index}${groups}`);
+          }
+        }
+        if (r.replaced !== void 0) lines.push(`**Result:** \`${r.replaced}\``);
+        if (r.split) lines.push(`**Split:** ${JSON.stringify(r.split)}`);
+        lines.push("");
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+}
+function registerEncodeTool(server) {
+  server.registerTool(
+    "encode",
+    {
+      description: "Encode, decode, or hash text. Supports base64, URL encoding, SHA-256, MD5, JWT decode, hex.",
+      inputSchema: {
+        operation: z.enum([
+          "base64_encode",
+          "base64_decode",
+          "url_encode",
+          "url_decode",
+          "sha256",
+          "md5",
+          "jwt_decode",
+          "hex_encode",
+          "hex_decode"
+        ]).describe("Operation to perform"),
+        input: z.string().describe("Input text")
+      }
+    },
+    async ({ operation, input }) => {
+      try {
+        const result = encode({ operation, input });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `## ${operation}
+
+**Input:** \`${input.length > 100 ? `${input.slice(0, 100)}...` : input}\`
+**Output:**
+\`\`\`
+${result.output}
+\`\`\``
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Encode failed: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerMeasureTool(server) {
+  server.registerTool(
+    "measure",
+    {
+      description: "Measure code complexity, line counts, and function counts for a file or directory. Returns per-file metrics sorted by complexity.",
+      inputSchema: {
+        path: z.string().describe("File or directory path to measure"),
+        extensions: z.array(z.string()).optional().describe("File extensions to include (default: .ts,.tsx,.js,.jsx)")
+      }
+    },
+    async ({ path, extensions }) => {
+      try {
+        const result = measure({ path, extensions });
+        const lines = [
+          "## Code Metrics",
+          "",
+          `**Files:** ${result.summary.totalFiles}`,
+          `**Total lines:** ${result.summary.totalLines} (${result.summary.totalCodeLines} code)`,
+          `**Functions:** ${result.summary.totalFunctions}`,
+          `**Avg complexity:** ${result.summary.avgComplexity}`,
+          `**Max complexity:** ${result.summary.maxComplexity.value} (${result.summary.maxComplexity.file})`,
+          "",
+          "### Top files by complexity",
+          "",
+          "| File | Lines | Code | Complexity | Functions | Imports |",
+          "|------|-------|------|------------|-----------|---------|"
+        ];
+        for (const f of result.files.slice(0, 20)) {
+          lines.push(
+            `| ${f.path} | ${f.lines.total} | ${f.lines.code} | ${f.complexity} | ${f.functions} | ${f.imports} |`
+          );
+        }
+        if (result.files.length > 20) {
+          lines.push(``, `_...and ${result.files.length - 20} more files_`);
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Measure failed: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerChangelogTool(server) {
+  server.registerTool(
+    "changelog",
+    {
+      description: "Generate a changelog from git history between two refs. Groups by conventional commit type.",
+      inputSchema: {
+        from: z.string().describe("Start ref (tag, SHA, HEAD~N)"),
+        to: z.string().default("HEAD").describe("End ref (default: HEAD)"),
+        format: z.enum(["grouped", "chronological", "per-scope"]).default("grouped").describe("Output format"),
+        include_breaking: z.boolean().default(true).describe("Highlight breaking changes")
+      }
+    },
+    async ({ from, to, format, include_breaking }) => {
+      try {
+        const result = changelog({ from, to, format, includeBreaking: include_breaking });
+        const stats = `${result.stats.total} commits (${Object.entries(result.stats.types).map(([k, v]) => `${v} ${k}`).join(", ")})`;
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${result.markdown}
+---
+_${stats}_`
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Changelog failed: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerSchemaValidateTool(server) {
+  server.registerTool(
+    "schema_validate",
+    {
+      description: "Validate JSON data against a JSON Schema. Supports type, required, properties, items, enum, pattern, min/max.",
+      inputSchema: {
+        data: z.string().describe("JSON data to validate (as string)"),
+        schema: z.string().describe("JSON Schema to validate against (as string)")
+      }
+    },
+    async ({ data, schema }) => {
+      try {
+        const parsedData = JSON.parse(data);
+        const parsedSchema = JSON.parse(schema);
+        const result = schemaValidate({ data: parsedData, schema: parsedSchema });
+        if (result.valid) {
+          return {
+            content: [
+              { type: "text", text: "## Validation: PASSED\n\nData matches the schema." }
+            ]
+          };
+        }
+        const lines = ["## Validation: FAILED", "", `**${result.errors.length} error(s):**`, ""];
+        for (const e of result.errors) {
+          const detail = e.expected ? ` (expected: ${e.expected}, got: ${e.received})` : "";
+          lines.push(`- \`${e.path}\`: ${e.message}${detail}`);
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        return {
+          content: [
+            { type: "text", text: `Schema validation failed: ${err.message}` }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerSnippetTool(server) {
+  server.registerTool(
+    "snippet",
+    {
+      description: "Save, retrieve, search, and manage persistent code snippets/templates.",
+      inputSchema: {
+        action: z.enum(["save", "get", "list", "search", "delete"]).describe("Operation to perform"),
+        name: z.string().optional().describe("Snippet name (required for save/get/delete)"),
+        language: z.string().optional().describe("Language tag (for save)"),
+        code: z.string().optional().describe("Code content (for save)"),
+        tags: z.array(z.string()).optional().describe("Tags for categorization (for save)"),
+        query: z.string().optional().describe("Search query (for search)")
+      }
+    },
+    async ({ action, name, language, code, tags, query }) => {
+      try {
+        const result = snippet({ action, name, language, code, tags, query });
+        if ("deleted" in result) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: result.deleted ? `Snippet "${name}" deleted.` : `Snippet "${name}" not found.`
+              }
+            ]
+          };
+        }
+        if ("snippets" in result) {
+          if (result.snippets.length === 0) {
+            return { content: [{ type: "text", text: "No snippets found." }] };
+          }
+          const lines = ["## Snippets", ""];
+          for (const s2 of result.snippets) {
+            const tagStr2 = s2.tags.length > 0 ? ` [${s2.tags.join(", ")}]` : "";
+            lines.push(`- **${s2.name}** (${s2.language})${tagStr2}`);
+          }
+          return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        const s = result;
+        const tagStr = s.tags.length > 0 ? `
+Tags: ${s.tags.join(", ")}` : "";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `## ${s.name} (${s.language})${tagStr}
+
+\`\`\`${s.language}
+${s.code}
+\`\`\``
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Snippet failed: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerEnvTool(server) {
+  server.registerTool(
+    "env",
+    {
+      description: "Get system and runtime environment info. Sensitive env vars are redacted by default.",
+      inputSchema: {
+        include_env: z.boolean().default(false).describe("Include environment variables"),
+        filter_env: z.string().optional().describe("Filter env vars by name substring"),
+        show_sensitive: z.boolean().default(false).describe("Show sensitive values (keys, tokens, etc.) \u2014 redacted by default")
+      }
+    },
+    async ({ include_env, filter_env, show_sensitive }) => {
+      const result = envInfo({
+        includeEnv: include_env,
+        filterEnv: filter_env,
+        showSensitive: show_sensitive
+      });
+      const lines = [
+        "## Environment",
+        "",
+        `**Platform:** ${result.system.platform} ${result.system.arch}`,
+        `**OS:** ${result.system.type} ${result.system.release}`,
+        `**Host:** ${result.system.hostname}`,
+        `**CPUs:** ${result.system.cpus}`,
+        `**Memory:** ${result.system.memoryFreeGb}GB free / ${result.system.memoryTotalGb}GB total`,
+        "",
+        `**Node:** ${result.runtime.node}`,
+        `**V8:** ${result.runtime.v8}`,
+        `**CWD:** ${result.cwd}`
+      ];
+      if (result.env) {
+        lines.push("", "### Environment Variables", "");
+        for (const [key, value] of Object.entries(result.env)) {
+          lines.push(`- \`${key}\`: ${value}`);
+        }
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+}
+function registerTimeTool(server) {
+  server.registerTool(
+    "time",
+    {
+      description: "Parse dates, convert timezones, calculate durations, add time. Supports ISO 8601, unix timestamps, and human-readable formats.",
+      inputSchema: {
+        operation: z.enum(["now", "parse", "convert", "diff", "add"]).describe(
+          "now: current time | parse: parse a date string | convert: timezone conversion | diff: duration between two dates | add: add duration to date"
+        ),
+        input: z.string().optional().describe(
+          "Date input (ISO, unix timestamp, or parseable string). For diff: two comma-separated dates"
+        ),
+        timezone: z.string().optional().describe('Target timezone (e.g., "America/New_York", "Asia/Tokyo")'),
+        duration: z.string().optional().describe('Duration to add (e.g., "2h30m", "1d", "30s") \u2014 for add operation')
+      }
+    },
+    async ({ operation, input, timezone, duration }) => {
+      try {
+        const result = timeUtils({ operation, input, timezone, duration });
+        const lines = [`**${result.output}**`, "", `ISO: ${result.iso}`, `Unix: ${result.unix}`];
+        if (result.details) {
+          lines.push("", "```json", JSON.stringify(result.details, null, 2), "```");
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Time failed: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+export {
+  registerChangelogTool,
+  registerEncodeTool,
+  registerEnvTool,
+  registerHttpTool,
+  registerMeasureTool,
+  registerRegexTestTool,
+  registerSchemaValidateTool,
+  registerSnippetTool,
+  registerTimeTool,
+  registerWebSearchTool
+};
+//# sourceMappingURL=utility.tools.js.map

package/packages/store/dist/graph-store.interface.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Knowledge graph store abstraction — typed nodes + edges for entity-relationship storage.
+ * Complements the vector store: vector search finds similar content,
+ * graph traversal finds connected concepts.
+ */
+/** A node in the knowledge graph (entity, concept, service, etc.) */
+export interface GraphNode {
+    /** Unique identifier */
+    id: string;
+    /** Node type (e.g., 'entity', 'service', 'api', 'concept', 'decision') */
+    type: string;
+    /** Display name */
+    name: string;
+    /** Arbitrary properties */
+    properties: Record<string, unknown>;
+    /** Back-link to KnowledgeRecord.id that produced this node */
+    sourceRecordId?: string;
+    /** Source file path (for cleanup on re-index) */
+    sourcePath?: string;
+    /** ISO timestamp */
+    createdAt?: string;
+}
+/** An edge connecting two nodes */
+export interface GraphEdge {
+    /** Unique identifier */
+    id: string;
+    /** Source node ID */
+    fromId: string;
+    /** Target node ID */
+    toId: string;
+    /** Relationship type (e.g., 'depends-on', 'implements', 'calls', 'affects') */
+    type: string;
+    /** Optional weight (0-1) */
+    weight?: number;
+    /** Arbitrary properties */
+    properties?: Record<string, unknown>;
+}
+/** Options for graph traversal */
+export interface GraphTraversalOptions {
+    /** Relationship type filter */
+    edgeType?: string;
+    /** Max traversal depth (default: 2) */
+    maxDepth?: number;
+    /** Direction: outgoing from start, incoming to start, or both */
+    direction?: 'outgoing' | 'incoming' | 'both';
+    /** Max total nodes returned (default: 50) */
+    limit?: number;
+}
+/** Result of a graph traversal */
+export interface GraphTraversalResult {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+}
+/** Graph statistics */
+export interface GraphStats {
+    nodeCount: number;
+    edgeCount: number;
+    nodeTypes: Record<string, number>;
+    edgeTypes: Record<string, number>;
+}
+/** Knowledge graph store interface */
+export interface IGraphStore {
+    /** Initialize the store (create tables, indices) */
+    initialize(): Promise<void>;
+    /** Add or update a single node */
+    upsertNode(node: GraphNode): Promise<void>;
+    /** Add or update a single edge */
+    upsertEdge(edge: GraphEdge): Promise<void>;
+    /** Batch add/update nodes */
+    upsertNodes(nodes: GraphNode[]): Promise<void>;
+    /** Batch add/update edges */
+    upsertEdges(edges: GraphEdge[]): Promise<void>;
+    /** Get a node by ID */
+    getNode(id: string): Promise<GraphNode | null>;
+    /** Get direct neighbors of a node */
+    getNeighbors(nodeId: string, options?: GraphTraversalOptions): Promise<GraphTraversalResult>;
+    /** Multi-hop traversal from a starting node */
+    traverse(startId: string, options?: GraphTraversalOptions): Promise<GraphTraversalResult>;
+    /** Find nodes by type and/or name pattern */
+    findNodes(filter: {
+        type?: string;
+        namePattern?: string;
+        sourcePath?: string;
+        limit?: number;
+    }): Promise<GraphNode[]>;
+    /** Find edges by type between optional node filters */
+    findEdges(filter: {
+        type?: string;
+        fromId?: string;
+        toId?: string;
+        limit?: number;
+    }): Promise<GraphEdge[]>;
+    /** Delete a node and all its edges */
+    deleteNode(id: string): Promise<void>;
+    /** Delete all nodes/edges originating from a source path */
+    deleteBySourcePath(sourcePath: string): Promise<number>;
+    /** Delete all nodes and edges (full reset) */
+    clear(): Promise<void>;
+    /** Get graph statistics */
+    getStats(): Promise<GraphStats>;
+    /** Close the store */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=graph-store.interface.d.ts.map

package/packages/store/dist/graph-store.interface.js

@@ -0,0 +1 @@
+//# sourceMappingURL=graph-store.interface.js.map

package/packages/store/dist/index.d.ts

@@ -0,0 +1,6 @@
+export type { GraphEdge, GraphNode, GraphStats, GraphTraversalOptions, GraphTraversalResult, IGraphStore, } from './graph-store.interface.js';
+export { LanceStore } from './lance-store.js';
+export { SqliteGraphStore } from './sqlite-graph-store.js';
+export type { IKnowledgeStore, SearchOptions } from './store.interface.js';
+export { createStore, type StoreBackend, type StoreConfig } from './store-factory.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/store/dist/index.js

@@ -0,0 +1,9 @@
+import { LanceStore } from "./lance-store.js";
+import { SqliteGraphStore } from "./sqlite-graph-store.js";
+import { createStore } from "./store-factory.js";
+export {
+  LanceStore,
+  SqliteGraphStore,
+  createStore
+};
+//# sourceMappingURL=index.js.map

package/packages/store/dist/lance-store.d.ts

@@ -0,0 +1,32 @@
+/**
+ * LanceDB implementation of the knowledge store.
+ * Uses @lancedb/lancedb for local vector + full-text search.
+ */
+import type { IndexStats, KnowledgeRecord, SearchResult } from '@kb/core';
+import type { IKnowledgeStore, SearchOptions } from './store.interface.js';
+export declare class LanceStore implements IKnowledgeStore {
+    private db;
+    private table;
+    private readonly dbPath;
+    private readonly tableName;
+    constructor(options?: {
+        path?: string;
+        tableName?: string;
+    });
+    initialize(): Promise<void>;
+    upsert(records: KnowledgeRecord[], vectors: Float32Array[]): Promise<void>;
+    search(queryVector: Float32Array, options?: SearchOptions): Promise<SearchResult[]>;
+    createFtsIndex(): Promise<void>;
+    ftsSearch(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    getById(id: string): Promise<KnowledgeRecord | null>;
+    deleteBySourcePath(sourcePath: string): Promise<number>;
+    deleteById(id: string): Promise<boolean>;
+    getBySourcePath(sourcePath: string): Promise<KnowledgeRecord[]>;
+    getStats(): Promise<IndexStats>;
+    listSourcePaths(): Promise<string[]>;
+    dropTable(): Promise<void>;
+    close(): Promise<void>;
+    private buildFilterString;
+    private fromLanceRecord;
+}
+//# sourceMappingURL=lance-store.d.ts.map