minimem 0.0.5 → 0.0.6

package/dist/index.d.cts

@@ -0,0 +1,858 @@
+import { DatabaseSync } from 'node:sqlite';
+import { DebugFn, MemoryFileEntry, MemoryChunk } from './internal.cjs';
+export { buildFileEntry, chunkMarkdown, cosineSimilarity, extractChunkMetadata, hashText, isMemoryPath, listMemoryFiles, stripPrivateContent } from './internal.cjs';
+export { KnowledgeLink, KnowledgeSource, MemoryFrontmatter, SessionContext, addFrontmatter, addSessionToContent, extractSession, parseFrontmatter, serializeFrontmatter } from './session.cjs';
+
+/**
+ * A knowledge graph link between two nodes
+ */
+type GraphLink = {
+    fromId: string;
+    toId: string;
+    relation: string;
+    layer: string | null;
+    weight: number;
+    sourcePath: string | null;
+};
+/**
+ * A neighbor node discovered during graph traversal
+ */
+type GraphNeighbor = {
+    id: string;
+    depth: number;
+    link: GraphLink;
+};
+/**
+ * Get all outgoing links from a node.
+ */
+declare function getLinksFrom(db: DatabaseSync, fromId: string, opts?: {
+    relation?: string;
+    layer?: string;
+}): GraphLink[];
+/**
+ * Get all incoming links to a node.
+ */
+declare function getLinksTo(db: DatabaseSync, toId: string, opts?: {
+    relation?: string;
+    layer?: string;
+}): GraphLink[];
+/**
+ * BFS traversal to find neighbors up to a given depth.
+ *
+ * @param db - Database handle
+ * @param startId - The starting node ID
+ * @param depth - Maximum traversal depth (default: 1)
+ * @param opts - Optional filters for relation and layer
+ * @returns Array of neighbor nodes with their depth and connecting link
+ */
+declare function getNeighbors(db: DatabaseSync, startId: string, depth?: number, opts?: {
+    relation?: string;
+    layer?: string;
+}): GraphNeighbor[];
+/**
+ * BFS shortest path between two nodes, max depth 3.
+ *
+ * @returns Array of links forming the path, or empty if no path found.
+ */
+declare function getPathBetween(db: DatabaseSync, fromId: string, toId: string, maxDepth?: number): GraphLink[];
+
+type EmbeddingProvider = {
+    id: string;
+    model: string;
+    embedQuery: (text: string) => Promise<number[]>;
+    embedBatch: (texts: string[]) => Promise<number[][]>;
+};
+type EmbeddingProviderResult = {
+    provider: EmbeddingProvider;
+    requestedProvider: "openai" | "local" | "gemini" | "auto" | "none";
+    fallbackFrom?: "openai" | "local" | "gemini" | "auto";
+    fallbackReason?: string;
+    openAi?: OpenAiEmbeddingClient;
+    gemini?: GeminiEmbeddingClient;
+};
+type EmbeddingProviderOptions = {
+    provider: "openai" | "local" | "gemini" | "auto" | "none";
+    model?: string;
+    fallback?: "openai" | "gemini" | "local" | "none";
+    openai?: {
+        apiKey?: string;
+        baseUrl?: string;
+        headers?: Record<string, string>;
+    };
+    gemini?: {
+        apiKey?: string;
+        baseUrl?: string;
+        headers?: Record<string, string>;
+    };
+    local?: {
+        modelPath?: string;
+        modelCacheDir?: string;
+    };
+};
+type OpenAiEmbeddingClient = {
+    baseUrl: string;
+    headers: Record<string, string>;
+    model: string;
+};
+type GeminiEmbeddingClient = {
+    baseUrl: string;
+    headers: Record<string, string>;
+    model: string;
+    modelPath: string;
+};
+declare function createOpenAiEmbeddingProvider(options: EmbeddingProviderOptions): Promise<{
+    provider: EmbeddingProvider;
+    client: OpenAiEmbeddingClient;
+}>;
+declare function createGeminiEmbeddingProvider(options: EmbeddingProviderOptions): Promise<{
+    provider: EmbeddingProvider;
+    client: GeminiEmbeddingClient;
+}>;
+declare function createEmbeddingProvider(options: EmbeddingProviderOptions): Promise<EmbeddingProviderResult>;
+
+type MinimemConfig = {
+    /** Directory containing memory files (MEMORY.md, memory/*.md) */
+    memoryDir: string;
+    /** Path to SQLite database. Defaults to memoryDir/.minimem/index.db */
+    dbPath?: string;
+    /** Embedding provider options */
+    embedding: EmbeddingProviderOptions;
+    /** Chunking configuration */
+    chunking?: {
+        /** Tokens per chunk (default: 256) */
+        tokens?: number;
+        /** Overlap tokens between chunks (default: 32) */
+        overlap?: number;
+    };
+    /** Embedding cache configuration */
+    cache?: {
+        /** Enable embedding cache (default: true) */
+        enabled?: boolean;
+        /** Max cache entries before LRU pruning (default: 10000) */
+        maxEntries?: number;
+    };
+    /** Hybrid search configuration */
+    hybrid?: {
+        /** Enable hybrid search (default: true) */
+        enabled?: boolean;
+        /** Weight for vector search (default: 0.7) */
+        vectorWeight?: number;
+        /** Weight for keyword search (default: 0.3) */
+        textWeight?: number;
+        /** Candidate multiplier for search (default: 2.0) */
+        candidateMultiplier?: number;
+    };
+    /** Query configuration */
+    query?: {
+        /** Max results (default: 10) */
+        maxResults?: number;
+        /** Min score threshold (default: 0.3) */
+        minScore?: number;
+    };
+    /** File watching configuration */
+    watch?: {
+        /** Enable file watching (default: true) */
+        enabled?: boolean;
+        /** Debounce delay in ms (default: 1000) */
+        debounceMs?: number;
+    };
+    /** Batch embedding configuration */
+    batch?: {
+        /** Enable batch embedding API (default: false) */
+        enabled?: boolean;
+        /** Wait for batch completion (default: true) */
+        wait?: boolean;
+        /** Concurrent batch requests (default: 2) */
+        concurrency?: number;
+        /** Poll interval in ms (default: 2000) */
+        pollIntervalMs?: number;
+        /** Timeout in ms (default: 60 minutes) */
+        timeoutMs?: number;
+    };
+    /** sqlite-vec extension path (optional) */
+    vectorExtensionPath?: string;
+    /** Debug logging function */
+    debug?: (message: string, data?: Record<string, unknown>) => void;
+};
+type MinimemSearchResult = {
+    path: string;
+    startLine: number;
+    endLine: number;
+    score: number;
+    snippet: string;
+};
+declare class Minimem {
+    private readonly memoryDir;
+    private readonly dbPath;
+    private readonly chunking;
+    private readonly cache;
+    private readonly hybrid;
+    private readonly queryConfig;
+    private readonly watchConfig;
+    private readonly batchConfig;
+    private readonly vectorExtensionPath?;
+    private readonly debug?;
+    private provider;
+    private openAi?;
+    private gemini?;
+    private providerKey;
+    private providerFallbackReason?;
+    private db;
+    private readonly vector;
+    private readonly fts;
+    private vectorReady;
+    private watcher;
+    private watchTimer;
+    private closed;
+    private dirty;
+    private syncing;
+    private syncLock;
+    private embeddingOptions;
+    private constructor();
+    static create(config: MinimemConfig): Promise<Minimem>;
+    private initialize;
+    private openDatabase;
+    private ensureSchema;
+    private computeProviderKey;
+    private readMeta;
+    private writeMeta;
+    private ensureWatcher;
+    /**
+     * Check if the index is stale by comparing file mtimes against stored values.
+     * This is a lightweight check (stat calls only, no file reads).
+     */
+    private isStale;
+    search(query: string, opts?: {
+        maxResults?: number;
+        minScore?: number;
+        type?: string;
+    }): Promise<MinimemSearchResult[]>;
+    sync(opts?: {
+        reason?: string;
+        force?: boolean;
+    }): Promise<void>;
+    private runSync;
+    private indexFile;
+    private embedChunks;
+    private embedBatchWithRetry;
+    private embedWithBatchApi;
+    private embedQueryWithTimeout;
+    private loadEmbeddingCache;
+    private upsertEmbeddingCache;
+    private pruneEmbeddingCacheIfNeeded;
+    private ensureVectorReady;
+    private loadVectorExtension;
+    private ensureVectorTable;
+    readFile(relativePath: string): Promise<string | null>;
+    /**
+     * Read specific lines from a memory file
+     */
+    readLines(relativePath: string, opts?: {
+        from?: number;
+        lines?: number;
+    }): Promise<{
+        content: string;
+        startLine: number;
+        endLine: number;
+    } | null>;
+    /**
+     * Write content to a memory file (creates or overwrites)
+     */
+    writeFile(relativePath: string, content: string): Promise<void>;
+    /**
+     * Append content to a memory file (creates if doesn't exist)
+     */
+    appendFile(relativePath: string, content: string): Promise<void>;
+    /**
+     * Append content to today's daily log (memory/YYYY-MM-DD.md)
+     */
+    appendToday(content: string): Promise<string>;
+    /**
+     * List all memory files
+     */
+    listFiles(): Promise<string[]>;
+    /**
+     * Validate that a path is within allowed memory locations
+     */
+    private validateMemoryPath;
+    status(): Promise<{
+        memoryDir: string;
+        dbPath: string;
+        provider: string;
+        model: string;
+        vectorAvailable: boolean;
+        ftsAvailable: boolean;
+        bm25Only: boolean;
+        fallbackReason?: string;
+        fileCount: number;
+        chunkCount: number;
+        cacheCount: number;
+    }>;
+    /**
+     * Search with knowledge metadata filters (domain, entities, confidence, type).
+     * Runs a standard search then post-filters by knowledge columns.
+     */
+    knowledgeSearch(query: string, opts?: {
+        maxResults?: number;
+        minScore?: number;
+        domain?: string[];
+        entities?: string[];
+        minConfidence?: number;
+        knowledgeType?: string;
+    }): Promise<MinimemSearchResult[]>;
+    /**
+     * Get knowledge graph links from or to a node.
+     */
+    getLinks(nodeId: string, direction?: "from" | "to", opts?: {
+        relation?: string;
+        layer?: string;
+    }): GraphLink[];
+    /**
+     * Get neighbor nodes via BFS traversal.
+     */
+    getGraphNeighbors(nodeId: string, depth?: number, opts?: {
+        relation?: string;
+        layer?: string;
+    }): GraphNeighbor[];
+    /**
+     * Find shortest path between two knowledge nodes.
+     */
+    getGraphPath(fromId: string, toId: string, maxDepth?: number): GraphLink[];
+    close(): void;
+}
+
+type OpenAiBatchRequest = {
+    custom_id: string;
+    method: "POST";
+    url: "/v1/embeddings";
+    body: {
+        model: string;
+        input: string;
+    };
+};
+declare function runOpenAiEmbeddingBatches(params: {
+    openAi: OpenAiEmbeddingClient;
+    source: string;
+    requests: OpenAiBatchRequest[];
+    wait: boolean;
+    pollIntervalMs: number;
+    timeoutMs: number;
+    concurrency: number;
+    debug?: (message: string, data?: Record<string, unknown>) => void;
+}): Promise<Map<string, number[]>>;
+
+type GeminiBatchRequest = {
+    custom_id: string;
+    content: {
+        parts: Array<{
+            text: string;
+        }>;
+    };
+    taskType: "RETRIEVAL_DOCUMENT" | "RETRIEVAL_QUERY";
+};
+declare function runGeminiEmbeddingBatches(params: {
+    gemini: GeminiEmbeddingClient;
+    source: string;
+    requests: GeminiBatchRequest[];
+    wait: boolean;
+    pollIntervalMs: number;
+    timeoutMs: number;
+    concurrency: number;
+    debug?: (message: string, data?: Record<string, unknown>) => void;
+}): Promise<Map<string, number[]>>;
+
+/**
+ * Tool definitions for memory operations
+ *
+ * These tools are compatible with:
+ * - MCP (Model Context Protocol)
+ * - Anthropic Claude tool use
+ * - OpenAI function calling
+ *
+ * Note: Only memory_search is provided since the memory system is file-based.
+ * Agents can use filesystem tools directly for read/write operations.
+ */
+
+/**
+ * JSON Schema for tool parameters (MCP/OpenAI/Anthropic compatible)
+ */
+type ToolInputSchema = {
+    type: "object";
+    properties: Record<string, {
+        type: string;
+        description?: string;
+        enum?: string[];
+        items?: {
+            type: string;
+        };
+        default?: unknown;
+    }>;
+    required?: string[];
+};
+/**
+ * Tool definition compatible with MCP, Anthropic, and OpenAI
+ */
+type ToolDefinition = {
+    name: string;
+    description: string;
+    inputSchema: ToolInputSchema;
+};
+/**
+ * Tool execution result
+ */
+type ToolResult = {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+};
+/**
+ * Memory search tool parameters
+ */
+type MemorySearchParams = {
+    query: string;
+    maxResults?: number;
+    minScore?: number;
+    directories?: string[];
+    /** "compact" returns lightweight index; "full" returns complete snippets (default: "compact") */
+    detail?: "compact" | "full";
+    /** Filter by observation type (e.g., "decision", "bugfix", "feature", "discovery") */
+    type?: string;
+};
+/**
+ * Memory get details tool parameters
+ */
+type MemoryGetDetailsParams = {
+    results: Array<{
+        path: string;
+        startLine: number;
+        endLine: number;
+    }>;
+    directories?: string[];
+};
+/**
+ * Knowledge search tool parameters
+ */
+type KnowledgeSearchParams = {
+    query: string;
+    domain?: string[];
+    entities?: string[];
+    minConfidence?: number;
+    knowledgeType?: string;
+    maxResults?: number;
+    minScore?: number;
+    directories?: string[];
+};
+/**
+ * Knowledge graph traversal parameters
+ */
+type KnowledgeGraphParams = {
+    nodeId: string;
+    depth?: number;
+    relation?: string;
+    layer?: string;
+    directories?: string[];
+};
+/**
+ * Knowledge path parameters
+ */
+type KnowledgePathParams = {
+    fromId: string;
+    toId: string;
+    maxDepth?: number;
+    directories?: string[];
+};
+declare const MEMORY_SEARCH_TOOL: ToolDefinition;
+declare const MEMORY_GET_DETAILS_TOOL: ToolDefinition;
+declare const KNOWLEDGE_SEARCH_TOOL: ToolDefinition;
+declare const KNOWLEDGE_GRAPH_TOOL: ToolDefinition;
+declare const KNOWLEDGE_PATH_TOOL: ToolDefinition;
+/**
+ * All available memory tools
+ */
+declare const MEMORY_TOOLS: ToolDefinition[];
+/**
+ * Get tool definitions for use with LLM APIs
+ */
+declare function getToolDefinitions(): ToolDefinition[];
+/**
+ * Memory instance with its directory path
+ */
+type MemoryInstance = {
+    minimem: Minimem;
+    memoryDir: string;
+    name?: string;
+};
+/**
+ * Tool executor that handles memory search across multiple directories
+ */
+declare class MemoryToolExecutor {
+    private instances;
+    constructor(instances: Minimem | MemoryInstance | MemoryInstance[]);
+    /**
+     * Get list of configured directory names/paths
+     */
+    getDirectories(): string[];
+    /**
+     * Execute a tool by name with given parameters
+     */
+    execute(toolName: string, params: Record<string, unknown>): Promise<ToolResult>;
+    /**
+     * Filter instances by directory names/paths
+     */
+    private filterInstances;
+    private memorySearch;
+    private formatCompactResults;
+    private formatFullResults;
+    private memoryGetDetails;
+    private knowledgeSearch;
+    private knowledgeGraph;
+    private knowledgePath;
+}
+/**
+ * Create a tool executor for the given Minimem instance(s)
+ */
+declare function createToolExecutor(instances: Minimem | MemoryInstance | MemoryInstance[]): MemoryToolExecutor;
+
+/**
+ * MCP (Model Context Protocol) Server for Minimem
+ *
+ * Provides memory tools via JSON-RPC 2.0 over stdio.
+ * Compatible with Claude Desktop, Cursor, and other MCP clients.
+ *
+ * Usage:
+ *   import { Minimem } from "minimem";
+ *   import { createMcpServer, runMcpServer } from "minimem/mcp";
+ *
+ *   const minimem = await Minimem.create({ ... });
+ *   const server = createMcpServer(minimem);
+ *   await runMcpServer(server);  // Runs over stdio
+ */
+
+/**
+ * JSON-RPC 2.0 request
+ */
+type JsonRpcRequest = {
+    jsonrpc: "2.0";
+    id: string | number;
+    method: string;
+    params?: Record<string, unknown>;
+};
+/**
+ * JSON-RPC 2.0 response
+ */
+type JsonRpcResponse = {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+};
+/**
+ * MCP Server implementation
+ */
+declare class McpServer {
+    private executor;
+    private initialized;
+    constructor(instances: Minimem | MemoryInstance | MemoryInstance[]);
+    /**
+     * Handle a JSON-RPC request and return a response
+     */
+    handleRequest(request: JsonRpcRequest): Promise<JsonRpcResponse>;
+    /**
+     * Dispatch a method call
+     */
+    private dispatch;
+    /**
+     * Handle initialize request
+     */
+    private initialize;
+    /**
+     * List available tools
+     */
+    private listTools;
+    /**
+     * Call a tool
+     */
+    private callTool;
+}
+/**
+ * Create an MCP server for the given Minimem instance(s)
+ */
+declare function createMcpServer(instances: Minimem | MemoryInstance | MemoryInstance[]): McpServer;
+/**
+ * Run the MCP server over stdio
+ */
+declare function runMcpServer(server: McpServer): Promise<void>;
+/**
+ * MCP server configuration for claude_desktop_config.json
+ *
+ * Example:
+ * {
+ *   "mcpServers": {
+ *     "minimem": {
+ *       "command": "node",
+ *       "args": ["path/to/your/mcp-server.js"],
+ *       "env": {
+ *         "MEMORY_DIR": "/path/to/memory"
+ *       }
+ *     }
+ *   }
+ * }
+ */
+type McpServerConfig = {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+};
+/**
+ * Generate MCP server config for Claude Desktop
+ */
+declare function generateMcpConfig(opts: {
+    serverPath: string;
+    memoryDir: string;
+    embeddingProvider?: "openai" | "gemini" | "local" | "auto";
+}): McpServerConfig;
+
+/**
+ * Options for filtering search results by knowledge metadata
+ */
+type KnowledgeSearchOptions = {
+    /** Filter to chunks matching any of these domains */
+    domain?: string[];
+    /** Filter to chunks referencing any of these entities */
+    entities?: string[];
+    /** Minimum confidence threshold */
+    minConfidence?: number;
+    /** Filter to a specific knowledge type */
+    knowledgeType?: string;
+};
+/**
+ * Build SQL WHERE clause fragments for knowledge filters.
+ * Uses json_each() for array column filtering.
+ */
+declare function buildKnowledgeFilterSql(opts: KnowledgeSearchOptions): {
+    sql: string;
+    params: (string | number)[];
+};
+
+/**
+ * MemoryIndexer - Handles file indexing and embedding management
+ *
+ * Responsible for:
+ * - Processing memory files into chunks
+ * - Computing and caching embeddings
+ * - Managing file records in the database
+ * - Detecting stale content
+ */
+
+type IndexerConfig = {
+    memoryDir: string;
+    chunking: {
+        tokens: number;
+        overlap: number;
+    };
+    cache: {
+        enabled: boolean;
+        maxEntries: number;
+    };
+    batch: {
+        enabled: boolean;
+        wait: boolean;
+        concurrency: number;
+        pollIntervalMs: number;
+        timeoutMs: number;
+    };
+    ftsEnabled: boolean;
+    debug?: DebugFn;
+};
+type MemoryIndexMeta = {
+    model: string;
+    provider: string;
+    providerKey?: string;
+    chunkTokens: number;
+    chunkOverlap: number;
+    vectorDims?: number;
+};
+type IndexStats = {
+    filesProcessed: number;
+    chunksCreated: number;
+    staleRemoved: number;
+};
+/**
+ * MemoryIndexer handles file indexing, chunking, and embedding management
+ */
+declare class MemoryIndexer {
+    private readonly config;
+    private readonly db;
+    private readonly provider;
+    private readonly providerKey;
+    private readonly openAi?;
+    private readonly gemini?;
+    private vectorState;
+    private ftsAvailable;
+    constructor(db: DatabaseSync, provider: EmbeddingProvider, config: IndexerConfig, options?: {
+        openAi?: OpenAiEmbeddingClient;
+        gemini?: GeminiEmbeddingClient;
+        vectorState?: {
+            available: boolean;
+            dims?: number;
+        };
+        ftsAvailable?: boolean;
+    });
+    /**
+     * Update vector/FTS availability (called by parent when extensions load)
+     */
+    setVectorState(state: {
+        available: boolean;
+        dims?: number;
+    }): void;
+    setFtsAvailable(available: boolean): void;
+    getVectorDims(): number | undefined;
+    /**
+     * Compute a unique key for the current provider configuration
+     */
+    private computeProviderKey;
+    /**
+     * Read index metadata from database
+     */
+    readMeta(): MemoryIndexMeta | null;
+    /**
+     * Write index metadata to database
+     */
+    writeMeta(meta: MemoryIndexMeta): void;
+    /**
+     * Check if the index is stale by comparing file mtimes
+     */
+    isStale(): Promise<boolean>;
+    /**
+     * Check if a full reindex is needed based on configuration changes
+     */
+    needsFullReindex(force?: boolean): boolean;
+    /**
+     * Index all memory files, returns stats
+     */
+    indexAll(force?: boolean): Promise<IndexStats>;
+    /**
+     * Index a single file
+     */
+    indexFile(entry: MemoryFileEntry): Promise<number>;
+    /**
+     * Delete all chunks for a file
+     */
+    private deleteChunksForFile;
+    /**
+     * Insert a chunk into the database
+     */
+    private insertChunk;
+    /**
+     * Remove stale file entries that no longer exist
+     */
+    private removeStaleEntries;
+    /**
+     * Create vector table with the given dimensions
+     */
+    ensureVectorTable(dimensions: number): void;
+    /**
+     * Get embeddings for chunks, using cache when available
+     */
+    embedChunks(chunks: MemoryChunk[]): Promise<number[][]>;
+    /**
+     * Embed texts with retry logic
+     */
+    private embedBatchWithRetry;
+    /**
+     * Use batch API for large embedding jobs
+     */
+    private embedWithBatchApi;
+    /**
+     * Load embeddings from cache
+     */
+    private loadEmbeddingCache;
+    /**
+     * Save embedding to cache
+     */
+    private upsertEmbeddingCache;
+    /**
+     * Prune old cache entries if over limit
+     */
+    private pruneEmbeddingCacheIfNeeded;
+}
+
+/**
+ * MemorySearcher - Handles search operations
+ *
+ * Responsible for:
+ * - Executing vector searches
+ * - Executing keyword (FTS) searches
+ * - Merging results with hybrid scoring
+ */
+
+type SearchConfig = {
+    hybrid: {
+        enabled: boolean;
+        vectorWeight: number;
+        textWeight: number;
+        candidateMultiplier: number;
+    };
+    query: {
+        maxResults: number;
+        minScore: number;
+    };
+    debug?: DebugFn;
+};
+type SearchResult = {
+    path: string;
+    startLine: number;
+    endLine: number;
+    score: number;
+    snippet: string;
+};
+/**
+ * MemorySearcher handles search queries against the indexed memory
+ */
+declare class MemorySearcher {
+    private readonly db;
+    private readonly provider;
+    private readonly config;
+    private vectorState;
+    private ftsAvailable;
+    private ensureVectorReadyFn?;
+    constructor(db: DatabaseSync, provider: EmbeddingProvider, config: SearchConfig, options?: {
+        vectorState?: {
+            available: boolean;
+            dims?: number;
+        };
+        ftsAvailable?: boolean;
+        ensureVectorReady?: (dims?: number) => Promise<boolean>;
+    });
+    /**
+     * Update vector/FTS availability (called by parent when extensions load)
+     */
+    setVectorState(state: {
+        available: boolean;
+        dims?: number;
+    }): void;
+    setFtsAvailable(available: boolean): void;
+    /**
+     * Execute a search query
+     */
+    search(query: string, opts?: {
+        maxResults?: number;
+        minScore?: number;
+    }): Promise<SearchResult[]>;
+    /**
+     * Embed a query string with timeout
+     */
+    private embedQueryWithTimeout;
+    /**
+     * Ensure vector extension is ready
+     */
+    private ensureVectorReady;
+}
+
+export { type SearchResult as CoreSearchResult, DebugFn, type EmbeddingProvider, type EmbeddingProviderOptions, type EmbeddingProviderResult, type GeminiBatchRequest, type GeminiEmbeddingClient, type GraphLink, type GraphNeighbor, type IndexStats, type IndexerConfig, KNOWLEDGE_GRAPH_TOOL, KNOWLEDGE_PATH_TOOL, KNOWLEDGE_SEARCH_TOOL, type KnowledgeGraphParams, type KnowledgePathParams, type KnowledgeSearchOptions, type KnowledgeSearchParams, MEMORY_GET_DETAILS_TOOL, MEMORY_SEARCH_TOOL, MEMORY_TOOLS, McpServer, type McpServerConfig, MemoryChunk, MemoryFileEntry, type MemoryGetDetailsParams, type MemoryIndexMeta, MemoryIndexer, type MemoryInstance, type MemorySearchParams, MemorySearcher, MemoryToolExecutor, Minimem, type MinimemConfig, type MinimemSearchResult, type OpenAiBatchRequest, type OpenAiEmbeddingClient, type SearchConfig, type MinimemSearchResult as SearchResult, type ToolDefinition, type ToolInputSchema, type ToolResult, buildKnowledgeFilterSql, createEmbeddingProvider, createGeminiEmbeddingProvider, createMcpServer, createOpenAiEmbeddingProvider, createToolExecutor, generateMcpConfig, getLinksFrom, getLinksTo, getNeighbors, getPathBetween, getToolDefinitions, runGeminiEmbeddingBatches, runMcpServer, runOpenAiEmbeddingBatches };