claude-eidetic 0.1.1 → 0.1.2

package/dist/tools.js

@@ -1,9 +1,19 @@
+import { readFile, stat } from 'node:fs/promises';
 import { normalizePath, pathToCollectionName } from './paths.js';
 import { indexCodebase, previewCodebase, deleteSnapshot } from './core/indexer.js';
+import { cleanupVectors } from './core/cleanup.js';
+import { scanFiles, buildSnapshot, diffSnapshots } from './core/sync.js';
+import { loadSnapshot } from './core/snapshot-io.js';
 import { getConfig } from './config.js';
 import { searchCode, formatSearchResults, formatCompactResults } from './core/searcher.js';
+import { indexDocument } from './core/doc-indexer.js';
+import { searchDocuments } from './core/doc-searcher.js';
+import { generateRepoMap, listSymbolsTable, VectorDBSymbolSource } from './core/repo-map.js';
 import { registerProject, resolveProject, listProjects } from './state/registry.js';
-import { textResult, formatPreview, formatIndexResult, formatListIndexed } from './format.js';
+import { textResult, formatCleanupResult, formatPreview, formatIndexResult, formatListIndexed, formatDocIndexResult, formatDocSearchResults, formatMemoryActions, formatMemorySearchResults, formatMemoryList, formatMemoryHistory, } from './format.js';
+function getErrorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
 function resolvePath(args) {
     const pathArg = args.path;
     if (pathArg)
@@ -17,26 +27,25 @@ function noPathError() {
     const projects = listProjects();
     const names = Object.keys(projects);
     if (names.length > 0) {
-        const list = names.map(n => `  - ${n} → ${projects[n]}`).join('\n');
+        const list = names.map((n) => `  - ${n} → ${projects[n]}`).join('\n');
         return textResult(`Error: provide \`path\` or \`project\`. Registered projects:\n${list}`);
     }
-    return textResult('Error: provide \`path\` (absolute) or \`project\` (name). No projects registered yet — index a codebase first.');
+    return textResult('Error: provide `path` (absolute) or `project` (name). No projects registered yet — index a codebase first.');
 }
 const locks = new Map();
 async function withMutex(key, fn) {
-    // Chain onto any existing operation for this key (FIFO ordering, no race)
     const prev = locks.get(key) ?? Promise.resolve();
     let resolve;
-    const current = new Promise(r => { resolve = r; });
+    const current = new Promise((r) => {
+        resolve = r;
+    });
     locks.set(key, current);
-    // Wait for previous operation to complete
     await prev;
     try {
         return await fn();
     }
     finally {
         resolve();
-        // Only delete if we're still the latest operation
         if (locks.get(key) === current) {
             locks.delete(key);
         }
@@ -46,11 +55,15 @@ export class ToolHandlers {
     embedding;
     vectordb;
     state;
+    memoryStore = null;
     constructor(embedding, vectordb, state) {
         this.embedding = embedding;
         this.vectordb = vectordb;
         this.state = state;
     }
+    setMemoryStore(store) {
+        this.memoryStore = store;
+    }
     async handleIndexCodebase(args) {
         const normalizedPath = resolvePath(args);
         if (!normalizedPath)
@@ -63,24 +76,26 @@ export class ToolHandlers {
         const collectionName = pathToCollectionName(normalizedPath);
         if (dryRun) {
             try {
-                const preview = await previewCodebase(normalizedPath, this.embedding, customExt, customIgnore);
+                const preview = await previewCodebase(normalizedPath, customExt, customIgnore);
                 return textResult(formatPreview(preview, normalizedPath));
             }
             catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
+                const message = getErrorMessage(err);
                 return textResult(`Error previewing ${normalizedPath}: ${message}`);
             }
         }
         return withMutex(normalizedPath, async () => {
             this.state.setIndexing(normalizedPath, collectionName);
             try {
-                const result = await indexCodebase(normalizedPath, this.embedding, this.vectordb, force, (pct, msg) => this.state.updateProgress(normalizedPath, pct, msg), customExt, customIgnore);
+                const result = await indexCodebase(normalizedPath, this.embedding, this.vectordb, force, (pct, msg) => {
+                    this.state.updateProgress(normalizedPath, pct, msg);
+                }, customExt, customIgnore);
                 this.state.setIndexed(normalizedPath, result.totalFiles, result.totalChunks);
                 registerProject(normalizedPath);
                 return textResult(formatIndexResult(result, normalizedPath));
             }
             catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
+                const message = getErrorMessage(err);
                 this.state.setError(normalizedPath, message);
                 return textResult(`Error indexing ${normalizedPath}: ${message}`);
             }
@@ -94,20 +109,21 @@ export class ToolHandlers {
         if (!normalizedPath)
             return noPathError();
         const rawLimit = args.limit;
-        const limit = (rawLimit !== undefined && Number.isFinite(rawLimit) && rawLimit >= 1)
-            ? rawLimit
-            : undefined;
+        const limit = rawLimit !== undefined && Number.isFinite(rawLimit) && rawLimit >= 1 ? rawLimit : undefined;
         const extensionFilter = args.extensionFilter;
         const compact = args.compact !== false; // default true
         try {
-            const results = await searchCode(normalizedPath, query, this.embedding, this.vectordb, { limit, extensionFilter });
+            const results = await searchCode(normalizedPath, query, this.embedding, this.vectordb, {
+                limit,
+                extensionFilter,
+            });
             const formatted = compact
                 ? formatCompactResults(results, query, normalizedPath)
                 : formatSearchResults(results, query, normalizedPath);
             return textResult(formatted);
         }
         catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
+            const message = getErrorMessage(err);
             return textResult(`Error: ${message}`);
         }
     }
@@ -124,7 +140,7 @@ export class ToolHandlers {
                 return textResult(`Index cleared for ${normalizedPath}.`);
             }
             catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
+                const message = getErrorMessage(err);
                 return textResult(`Error clearing index: ${message}`);
             }
         });
@@ -158,6 +174,7 @@ export class ToolHandlers {
         }
         return textResult(lines.join('\n'));
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
     async handleListIndexed() {
         const states = this.state.getAllStates();
         if (states.length === 0) {
@@ -165,5 +182,257 @@ export class ToolHandlers {
         }
         return textResult(formatListIndexed(states));
     }
+    async handleCleanupVectors(args) {
+        const normalizedPath = resolvePath(args);
+        if (!normalizedPath)
+            return noPathError();
+        const dryRun = args.dryRun ?? false;
+        const config = getConfig();
+        const customExt = args.customExtensions ?? config.customExtensions;
+        const customIgnore = args.customIgnorePatterns ?? config.customIgnorePatterns;
+        return withMutex(normalizedPath, async () => {
+            try {
+                if (dryRun) {
+                    const previousSnapshot = loadSnapshot(normalizedPath);
+                    if (!previousSnapshot) {
+                        return textResult(`Error: No snapshot found for ${normalizedPath}. Index the codebase first before running cleanup.`);
+                    }
+                    const filePaths = await scanFiles(normalizedPath, customExt, customIgnore);
+                    const currentSnapshot = buildSnapshot(normalizedPath, filePaths);
+                    const { removed } = diffSnapshots(previousSnapshot, currentSnapshot);
+                    const dryResult = { removedFiles: removed, totalRemoved: removed.length, durationMs: 0 };
+                    return textResult(formatCleanupResult(dryResult, normalizedPath, true));
+                }
+                const result = await cleanupVectors(normalizedPath, this.vectordb, undefined, customExt, customIgnore);
+                return textResult(formatCleanupResult(result, normalizedPath, false));
+            }
+            catch (err) {
+                const message = getErrorMessage(err);
+                return textResult(`Error during cleanup: ${message}`);
+            }
+        });
+    }
+    async handleIndexDocument(args) {
+        const content = args.content;
+        if (!content)
+            return textResult('Error: "content" is required. Provide the documentation text to cache.');
+        const source = args.source;
+        if (!source)
+            return textResult('Error: "source" is required. Provide the source URL or identifier.');
+        const library = args.library;
+        if (!library)
+            return textResult('Error: "library" is required. Provide the library name (e.g., "react", "langfuse").');
+        const topic = args.topic;
+        if (!topic)
+            return textResult('Error: "topic" is required. Provide the topic within the library (e.g., "hooks").');
+        const ttlDays = args.ttlDays ?? 7;
+        try {
+            const result = await indexDocument(content, source, library, topic, this.embedding, this.vectordb, ttlDays);
+            return textResult(formatDocIndexResult(result));
+        }
+        catch (err) {
+            const message = getErrorMessage(err);
+            return textResult(`Error caching documentation: ${message}`);
+        }
+    }
+    async handleSearchDocuments(args) {
+        const query = args.query;
+        if (!query)
+            return textResult('Error: "query" is required. Provide a natural language search query.');
+        const library = args.library;
+        const rawLimit = args.limit;
+        const limit = rawLimit !== undefined && Number.isFinite(rawLimit) && rawLimit >= 1 ? rawLimit : undefined;
+        try {
+            const results = await searchDocuments(query, this.embedding, this.vectordb, {
+                library,
+                limit,
+            });
+            return textResult(formatDocSearchResults(results, query));
+        }
+        catch (err) {
+            const message = getErrorMessage(err);
+            return textResult(`Error: ${message}`);
+        }
+    }
+    async handleAddMemory(args) {
+        if (!this.memoryStore)
+            return textResult('Error: Memory system not initialized.');
+        const content = args.content;
+        if (!content)
+            return textResult('Error: "content" is required. Provide text containing developer knowledge to extract.');
+        const source = args.source;
+        try {
+            const actions = await this.memoryStore.addMemory(content, source);
+            return textResult(formatMemoryActions(actions));
+        }
+        catch (err) {
+            const message = getErrorMessage(err);
+            return textResult(`Error adding memory: ${message}`);
+        }
+    }
+    async handleSearchMemory(args) {
+        if (!this.memoryStore)
+            return textResult('Error: Memory system not initialized.');
+        const query = args.query;
+        if (!query)
+            return textResult('Error: "query" is required. Provide a natural language search query.');
+        const limit = args.limit ?? 10;
+        const category = args.category;
+        try {
+            const results = await this.memoryStore.searchMemory(query, limit, category);
+            return textResult(formatMemorySearchResults(results, query));
+        }
+        catch (err) {
+            const message = getErrorMessage(err);
+            return textResult(`Error searching memories: ${message}`);
+        }
+    }
+    async handleListMemories(args) {
+        if (!this.memoryStore)
+            return textResult('Error: Memory system not initialized.');
+        const category = args.category;
+        const limit = args.limit ?? 50;
+        try {
+            const results = await this.memoryStore.listMemories(category, limit);
+            return textResult(formatMemoryList(results));
+        }
+        catch (err) {
+            const message = getErrorMessage(err);
+            return textResult(`Error listing memories: ${message}`);
+        }
+    }
+    async handleDeleteMemory(args) {
+        if (!this.memoryStore)
+            return textResult('Error: Memory system not initialized.');
+        const id = args.id;
+        if (!id)
+            return textResult('Error: "id" is required. Provide the UUID of the memory to delete.');
+        try {
+            const deleted = await this.memoryStore.deleteMemory(id);
+            if (!deleted)
+                return textResult(`Memory not found: ${id}`);
+            return textResult(`Memory deleted: ${id}`);
+        }
+        catch (err) {
+            const message = getErrorMessage(err);
+            return textResult(`Error deleting memory: ${message}`);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async handleMemoryHistory(args) {
+        if (!this.memoryStore)
+            return textResult('Error: Memory system not initialized.');
+        const id = args.id;
+        if (!id)
+            return textResult('Error: "id" is required. Provide the UUID of the memory to view history for.');
+        try {
+            const entries = this.memoryStore.getHistory(id);
+            return textResult(formatMemoryHistory(entries, id));
+        }
+        catch (err) {
+            const message = getErrorMessage(err);
+            return textResult(`Error retrieving memory history: ${message}`);
+        }
+    }
+    async handleBrowseStructure(args) {
+        const normalizedPath = resolvePath(args);
+        if (!normalizedPath)
+            return noPathError();
+        const pathFilter = args.pathFilter;
+        const kindFilter = args.kind;
+        const maxTokens = args.maxTokens;
+        try {
+            const source = new VectorDBSymbolSource(this.vectordb);
+            const map = await generateRepoMap(normalizedPath, source, {
+                pathFilter,
+                kindFilter,
+                maxTokens,
+            });
+            return textResult(map);
+        }
+        catch (err) {
+            const message = getErrorMessage(err);
+            return textResult(`Error: ${message}`);
+        }
+    }
+    async handleListSymbols(args) {
+        const normalizedPath = resolvePath(args);
+        if (!normalizedPath)
+            return noPathError();
+        const pathFilter = args.pathFilter;
+        const kindFilter = args.kind;
+        const nameFilter = args.nameFilter;
+        try {
+            const source = new VectorDBSymbolSource(this.vectordb);
+            const table = await listSymbolsTable(normalizedPath, source, {
+                pathFilter,
+                kindFilter,
+                nameFilter,
+            });
+            return textResult(table);
+        }
+        catch (err) {
+            const message = getErrorMessage(err);
+            return textResult(`Error: ${message}`);
+        }
+    }
+}
+const MAX_LINES = 10_000;
+const DEFAULT_LINES = 5_000;
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+export async function handleReadFile(args) {
+    const rawPath = args.path;
+    if (!rawPath)
+        return textResult('Error: "path" is required. Provide an absolute file path.');
+    const filePath = normalizePath(rawPath);
+    const offset = Math.max(0, args.offset ?? 0);
+    const limit = Math.min(MAX_LINES, Math.max(1, args.limit ?? DEFAULT_LINES));
+    const lineNumbers = args.lineNumbers ?? false;
+    let raw;
+    try {
+        const fileStat = await stat(filePath);
+        if (fileStat.isDirectory())
+            return textResult(`Error: Path is a directory, not a file: ${filePath}`);
+        if (fileStat.size > MAX_FILE_SIZE) {
+            return textResult(`Error: File too large (${(fileStat.size / 1024 / 1024).toFixed(1)}MB). Maximum: 10MB.`);
+        }
+        raw = await readFile(filePath, 'utf-8');
+    }
+    catch (err) {
+        const nodeErr = err;
+        if (nodeErr.code === 'ENOENT')
+            return textResult(`Error: File not found: ${filePath}`);
+        if (nodeErr.code === 'EACCES' || nodeErr.code === 'EPERM')
+            return textResult(`Error: Permission denied: ${filePath}`);
+        if (nodeErr.code === 'EISDIR')
+            return textResult(`Error: Path is a directory, not a file: ${filePath}`);
+        const message = getErrorMessage(err);
+        return textResult(`Error reading file: ${message}`);
+    }
+    if (raw.includes('\x00'))
+        return textResult(`Error: Binary file detected: ${filePath}`);
+    if (raw.length === 0) {
+        return textResult(`File: ${filePath} | Lines: 0 total | (empty file)`);
+    }
+    const allLines = raw.split('\n');
+    const totalLines = allLines.length;
+    // offset is 1-based line number; convert to 0-based index
+    const startIndex = offset > 0 ? offset - 1 : 0;
+    const sliced = allLines.slice(startIndex, startIndex + limit);
+    const startLine = startIndex + 1;
+    const endLine = startIndex + sliced.length;
+    let content;
+    if (lineNumbers) {
+        const pad = String(endLine).length;
+        content = sliced.map((line, i) => `${String(startLine + i).padStart(pad)} ${line}`).join('\n');
+    }
+    else {
+        content = sliced.join('\n');
+    }
+    let meta = `File: ${filePath} | Lines: ${totalLines} total | Showing: ${startLine}–${endLine}`;
+    if (endLine < totalLines) {
+        meta += ` | Next: read_file(path="${filePath}", offset=${endLine + 1})`;
+    }
+    return textResult(meta + '\n\n' + content);
 }
 //# sourceMappingURL=tools.js.map

package/dist/vectordb/milvus.d.ts

@@ -1,4 +1,4 @@
-import type { VectorDB, CodeDocument, HybridSearchParams, SearchResult } from './types.js';
+import type { VectorDB, CodeDocument, HybridSearchParams, SearchResult, SymbolEntry } from './types.js';
 /**
  * Detects the "data type 104 not supported" error from older Milvus versions
  * that lack SparseFloatVector support (< v2.4).
@@ -21,12 +21,14 @@ export declare class MilvusVectorDB implements VectorDB {
     private hybridSearch;
     private denseOnlySearch;
     private mapResults;
-    /**
-     * Detect whether a collection has the sparse_vector field (hybrid) or not.
-     * Caches result in hybridCollections set.
-     */
     private detectHybrid;
+    getById(name: string, id: string): Promise<{
+        payload: Record<string, unknown>;
+        vector: number[];
+    } | null>;
+    updatePoint(name: string, id: string, vector: number[], payload: Record<string, unknown>): Promise<void>;
     deleteByPath(name: string, relativePath: string): Promise<void>;
+    listSymbols(name: string): Promise<SymbolEntry[]>;
     private ensureLoaded;
     private waitForLoad;
 }

package/dist/vectordb/milvus.js

@@ -1,6 +1,6 @@
 import { VectorDBError } from '../errors.js';
 import { getConfig } from '../config.js';
-// Dynamic import -- @zilliz/milvus2-sdk-node is an optional dependency
+import { RRF_K } from './qdrant.js';
 let MilvusClient;
 let DataType;
 let MetricType;
@@ -19,14 +19,13 @@ async function loadMilvusSDK() {
         throw new VectorDBError('Milvus SDK not installed. Run: npm install @zilliz/milvus2-sdk-node');
     }
 }
-const RRF_K = 60;
 /**
  * Detects the "data type 104 not supported" error from older Milvus versions
  * that lack SparseFloatVector support (< v2.4).
  */
 export function isSparseUnsupportedError(err) {
     const msg = String(err && typeof err === 'object' && 'reason' in err ? err.reason : err);
-    return /data type[:\s]*104/i.test(msg) || /not supported/i.test(msg) && /104/.test(msg);
+    return /data type[:\s]*104/i.test(msg) || (/not supported/i.test(msg) && msg.includes('104'));
 }
 export class MilvusVectorDB {
     client = null;
@@ -56,7 +55,6 @@ export class MilvusVectorDB {
     }
     async createCollection(name, dimension) {
         await this.ready();
-        // Try hybrid first, fall back to dense-only if Milvus version doesn't support sparse
         try {
             await this.createHybridCollection(name, dimension);
             this.hybridCollections.add(name);
@@ -67,12 +65,11 @@ export class MilvusVectorDB {
             if (isSparseUnsupportedError(err)) {
                 console.warn(`Milvus does not support SparseFloatVector (requires >= v2.4). ` +
                     `Falling back to dense-only collection for "${name}".`);
-                // Clean up the failed collection attempt
                 try {
                     await this.client.dropCollection({ collection_name: name });
                 }
                 catch (cleanupErr) {
-                    console.warn(`Failed to clean up collection "${name}": ${cleanupErr}`);
+                    console.warn(`Failed to clean up collection "${name}":`, cleanupErr);
                 }
             }
             else {
@@ -98,14 +95,21 @@ export class MilvusVectorDB {
             { name: 'endLine', data_type: DataType.Int64 },
             { name: 'fileExtension', data_type: DataType.VarChar, max_length: 32 },
             { name: 'language', data_type: DataType.VarChar, max_length: 64 },
+            { name: 'fileCategory', data_type: DataType.VarChar, max_length: 32 },
+            { name: 'symbolName', data_type: DataType.VarChar, max_length: 256 },
+            { name: 'symbolKind', data_type: DataType.VarChar, max_length: 64 },
+            { name: 'symbolSignature', data_type: DataType.VarChar, max_length: 512 },
+            { name: 'parentSymbol', data_type: DataType.VarChar, max_length: 256 },
         ];
-        const functions = [{
+        const functions = [
+            {
                 name: 'content_bm25',
                 type: FunctionType.BM25,
                 input_field_names: ['content'],
                 output_field_names: ['sparse_vector'],
                 params: {},
-            }];
+            },
+        ];
         await this.client.createCollection({
             collection_name: name,
             fields: schema,
@@ -135,6 +139,11 @@ export class MilvusVectorDB {
             { name: 'endLine', data_type: DataType.Int64 },
             { name: 'fileExtension', data_type: DataType.VarChar, max_length: 32 },
             { name: 'language', data_type: DataType.VarChar, max_length: 64 },
+            { name: 'fileCategory', data_type: DataType.VarChar, max_length: 32 },
+            { name: 'symbolName', data_type: DataType.VarChar, max_length: 256 },
+            { name: 'symbolKind', data_type: DataType.VarChar, max_length: 64 },
+            { name: 'symbolSignature', data_type: DataType.VarChar, max_length: 512 },
+            { name: 'parentSymbol', data_type: DataType.VarChar, max_length: 256 },
         ];
         await this.client.createCollection({
             collection_name: name,
@@ -176,7 +185,7 @@ export class MilvusVectorDB {
         await this.ready();
         await this.ensureLoaded(name);
         try {
-            const data = documents.map(doc => ({
+            const data = documents.map((doc) => ({
                 id: doc.id,
                 content: doc.content,
                 vector: doc.vector,
@@ -185,6 +194,11 @@ export class MilvusVectorDB {
                 endLine: doc.endLine,
                 fileExtension: doc.fileExtension,
                 language: doc.language,
+                fileCategory: doc.fileCategory ?? 'source',
+                symbolName: doc.symbolName ?? '',
+                symbolKind: doc.symbolKind ?? '',
+                symbolSignature: doc.symbolSignature ?? '',
+                parentSymbol: doc.parentSymbol ?? '',
             }));
             await this.client.insert({ collection_name: name, data });
         }
@@ -199,7 +213,9 @@ export class MilvusVectorDB {
         try {
             let expr;
             if (params.extensionFilter?.length) {
-                const exts = params.extensionFilter.map(e => `"${e.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`).join(', ');
+                const exts = params.extensionFilter
+                    .map((e) => `"${e.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`)
+                    .join(', ');
                 expr = `fileExtension in [${exts}]`;
             }
             if (isHybrid) {
@@ -231,7 +247,16 @@ export class MilvusVectorDB {
             ],
             limit: params.limit,
             rerank: { strategy: 'rrf', params: { k: RRF_K } },
-            output_fields: ['id', 'content', 'relativePath', 'startLine', 'endLine', 'fileExtension', 'language'],
+            output_fields: [
+                'id',
+                'content',
+                'relativePath',
+                'startLine',
+                'endLine',
+                'fileExtension',
+                'language',
+                'fileCategory',
+            ],
         };
         if (expr)
             searchParams.expr = expr;
@@ -243,7 +268,16 @@ export class MilvusVectorDB {
             collection_name: name,
             data: [params.queryVector],
             limit: params.limit,
-            output_fields: ['id', 'content', 'relativePath', 'startLine', 'endLine', 'fileExtension', 'language'],
+            output_fields: [
+                'id',
+                'content',
+                'relativePath',
+                'startLine',
+                'endLine',
+                'fileExtension',
+                'language',
+                'fileCategory',
+            ],
         };
         if (expr)
             searchParams.expr = expr;
@@ -261,12 +295,9 @@ export class MilvusVectorDB {
             fileExtension: r.fileExtension ?? '',
             language: r.language ?? '',
             score: r.score ?? 0,
+            fileCategory: r.fileCategory ?? '',
         }));
     }
-    /**
-     * Detect whether a collection has the sparse_vector field (hybrid) or not.
-     * Caches result in hybridCollections set.
-     */
     async detectHybrid(name) {
         if (this.hybridCollections.has(name))
             return true;
@@ -283,6 +314,39 @@ export class MilvusVectorDB {
             return false;
         }
     }
+    async getById(name, id) {
+        await this.ready();
+        try {
+            const result = await this.client.get({
+                collection_name: name,
+                ids: [id],
+                output_fields: ['*'],
+            });
+            if (!result.data?.length)
+                return null;
+            const point = result.data[0];
+            return {
+                payload: point,
+                vector: point.vector ?? [],
+            };
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to retrieve point "${id}" from "${name}"`, err);
+        }
+    }
+    async updatePoint(name, id, vector, payload) {
+        await this.ready();
+        await this.ensureLoaded(name);
+        try {
+            await this.client.upsert({
+                collection_name: name,
+                data: [{ id, vector, ...payload }],
+            });
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to update point "${id}" in Milvus collection "${name}"`, err);
+        }
+    }
     async deleteByPath(name, relativePath) {
         await this.ready();
         await this.ensureLoaded(name);
@@ -297,6 +361,39 @@ export class MilvusVectorDB {
             throw new VectorDBError(`Failed to delete by path "${relativePath}" from "${name}"`, err);
         }
     }
+    async listSymbols(name) {
+        await this.ready();
+        await this.ensureLoaded(name);
+        try {
+            const result = await this.client.query({
+                collection_name: name,
+                filter: 'symbolName != ""',
+                output_fields: [
+                    'symbolName',
+                    'symbolKind',
+                    'relativePath',
+                    'startLine',
+                    'symbolSignature',
+                    'parentSymbol',
+                ],
+                limit: 16384,
+            });
+            const rows = result.data ?? [];
+            return rows
+                .filter((r) => r.symbolName)
+                .map((r) => ({
+                name: String(r.symbolName),
+                kind: String(r.symbolKind ?? ''),
+                relativePath: String(r.relativePath ?? ''),
+                startLine: Number(r.startLine ?? 0),
+                ...(r.symbolSignature ? { signature: String(r.symbolSignature) } : {}),
+                ...(r.parentSymbol ? { parentName: String(r.parentSymbol) } : {}),
+            }));
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to list symbols from "${name}"`, err);
+        }
+    }
     async ensureLoaded(name) {
         try {
             const result = await this.client.getLoadState({ collection_name: name });
@@ -305,7 +402,7 @@ export class MilvusVectorDB {
             }
         }
         catch (err) {
-            console.warn(`Failed to ensure collection "${name}" is loaded: ${err}`);
+            console.warn(`Failed to ensure collection "${name}" is loaded:`, err);
         }
     }
     async waitForLoad(name, timeoutMs = 30_000) {
@@ -318,9 +415,9 @@ export class MilvusVectorDB {
                     return;
             }
             catch (err) {
-                console.warn(`Load state check failed for "${name}": ${err}`);
+                console.warn(`Load state check failed for "${name}":`, err);
             }
-            await new Promise(r => setTimeout(r, 500));
+            await new Promise((r) => setTimeout(r, 500));
         }
         throw new VectorDBError(`Collection "${name}" failed to load within ${timeoutMs}ms`);
     }