grepmind-app 0.1.0-alpha

package/dist/routes/notes.js

@@ -0,0 +1,829 @@
+/**
+ * Notes API Routes
+ *
+ * Handles notes index operations: search, files, status, sync.
+ * All operations work on the currently active project.
+ */
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { glob } from 'glob';
+import { getCurrentProject, requireProjectContext, updateSecretsIfNeeded } from './project.js';
+import { emitEvent } from './events.js';
+import { createSyncHandler } from './sync-handler.js';
+import { createGrep, isError } from 'grepmind-core';
+import { validateSecrets } from 'grepmind-config';
+/**
+ * Ensure a project is open, return 400 if not
+ */
+function requireProject(reply) {
+    const project = getCurrentProject();
+    if (!project) {
+        reply.status(400).send({
+            error: 'No project open',
+            message: 'Open a project first using POST /api/project/open',
+        });
+        return false;
+    }
+    return true;
+}
+/**
+ * Get vault paths for current project
+ */
+function getVaultPaths() {
+    const project = getCurrentProject();
+    if (!project)
+        return [];
+    const vaultRelatives = project.config.vaultPaths || ['./vault'];
+    return vaultRelatives.map((vp) => path.resolve(project.path, vp));
+}
+/**
+ * Get primary vault path for current project (first in list)
+ */
+function getVaultPath() {
+    const paths = getVaultPaths();
+    return paths.length > 0 ? paths[0] : null;
+}
+function isPathWithinRoot(filePath, root) {
+    const normalizedRoot = path.resolve(root);
+    const normalizedPath = path.resolve(filePath);
+    return (normalizedPath === normalizedRoot ||
+        normalizedPath.startsWith(`${normalizedRoot}${path.sep}`));
+}
+function resolveVaultFilePath(vaultPath, relativePath) {
+    const fullPath = path.resolve(vaultPath, relativePath);
+    return isPathWithinRoot(fullPath, vaultPath) ? fullPath : null;
+}
+/**
+ * Register notes routes
+ */
+export async function notesRoutes(app) {
+    /**
+     * GET /api/notes/status
+     * Get notes index status for current project
+     */
+    app.get('/status', async (request, reply) => {
+        if (!requireProject(reply))
+            return;
+        const vaultPath = getVaultPath();
+        try {
+            const context = requireProjectContext();
+            // Get actual stats from Indexer
+            const stats = await context.indexer.getStats();
+            // Count total files in vault for comparison
+            const files = await glob('**/*.md', {
+                cwd: vaultPath,
+                nodir: true,
+                ignore: ['**/node_modules/**', '**/.git/**'],
+            });
+            const status = {
+                totalFiles: files.length,
+                indexedFiles: stats.totalFiles,
+                totalChunks: stats.totalChunks,
+                lastSync: undefined,
+                lastSyncCommit: undefined,
+            };
+            return reply.send(status);
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to get status',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/notes/files
+     * List all note files with index status
+     */
+    app.get('/files', {
+        schema: {
+            querystring: {
+                type: 'object',
+                properties: {
+                    folder: { type: 'string' },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireProject(reply))
+            return;
+        const { folder } = request.query;
+        const vaultPath = getVaultPath();
+        try {
+            const context = requireProjectContext();
+            const pattern = folder ? `${folder}/**/*.md` : '**/*.md';
+            const files = await glob(pattern, {
+                cwd: vaultPath,
+                nodir: true,
+                ignore: ['**/node_modules/**', '**/.git/**'],
+                stat: true,
+                withFileTypes: true,
+            });
+            // Get indexed files map for status checking
+            const indexedFiles = await context.indexer.getIndexedFiles();
+            const noteFiles = await Promise.all(files.map(async (file) => {
+                const relativePath = typeof file === 'string' ? file : file.relative();
+                const fullPath = path.join(vaultPath, relativePath);
+                const stat = await fs.stat(fullPath);
+                // Check index status
+                const indexInfo = indexedFiles.get(relativePath);
+                let indexStatus = 'unindexed';
+                if (indexInfo) {
+                    // File is indexed - check if modified since
+                    const fileMtime = stat.mtimeMs;
+                    if (fileMtime > indexInfo.indexed_at) {
+                        indexStatus = 'modified';
+                    }
+                    else {
+                        indexStatus = 'indexed';
+                    }
+                }
+                return {
+                    path: fullPath,
+                    name: path.basename(relativePath),
+                    relativePath,
+                    indexStatus,
+                    chunks: indexInfo?.chunks,
+                    size: stat.size,
+                    lastIndexed: indexInfo ? new Date(indexInfo.indexed_at).toISOString() : undefined,
+                };
+            }));
+            return reply.send(noteFiles);
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to list files',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/notes/search-titles
+     * Search note titles and paths for wikilink autocomplete.
+     */
+    app.get('/search-titles', {
+        schema: {
+            querystring: {
+                type: 'object',
+                properties: {
+                    q: { type: 'string' },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireProject(reply))
+            return;
+        const vaultPath = getVaultPath();
+        const query = (request.query.q || '').trim().toLowerCase();
+        try {
+            const files = await glob('**/*.md', {
+                cwd: vaultPath,
+                nodir: true,
+                ignore: ['**/node_modules/**', '**/.git/**'],
+            });
+            const matches = files
+                .map((relativePath) => ({
+                path: relativePath,
+                title: path.basename(relativePath, '.md'),
+            }))
+                .filter((note) => {
+                if (!query)
+                    return true;
+                return (note.title.toLowerCase().includes(query) ||
+                    note.path.toLowerCase().includes(query));
+            })
+                .slice(0, 10);
+            return reply.send({ notes: matches });
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to search titles',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/notes/list
+     * Alias for title search used by wikilink autocomplete clients.
+     */
+    app.get('/list', async (request, reply) => {
+        if (!requireProject(reply))
+            return;
+        const vaultPath = getVaultPath();
+        const query = (request.query.q || '').trim().toLowerCase();
+        try {
+            const files = await glob('**/*.md', {
+                cwd: vaultPath,
+                nodir: true,
+                ignore: ['**/node_modules/**', '**/.git/**'],
+            });
+            const matches = files
+                .map((relativePath) => ({
+                path: relativePath,
+                title: path.basename(relativePath, '.md'),
+            }))
+                .filter((note) => {
+                if (!query)
+                    return true;
+                return (note.title.toLowerCase().includes(query) ||
+                    note.path.toLowerCase().includes(query));
+            })
+                .slice(0, 10);
+            return reply.send({ notes: matches });
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to list notes',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * POST /api/notes/links/check
+     * Check if wiki-link targets exist and are indexed.
+     */
+    app.post('/links/check', {
+        schema: {
+            body: {
+                type: 'object',
+                properties: {
+                    targets: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireProject(reply))
+            return;
+        const targets = (request.body?.targets || [])
+            .map((target) => target.trim())
+            .filter(Boolean);
+        if (targets.length === 0) {
+            return reply.send({});
+        }
+        const vaultPath = getVaultPath();
+        try {
+            const context = requireProjectContext();
+            const files = await glob('**/*.md', {
+                cwd: vaultPath,
+                nodir: true,
+                ignore: ['**/node_modules/**', '**/.git/**'],
+            });
+            const indexedFiles = await context.indexer.getIndexedFiles();
+            const exactPathSet = new Set(files);
+            const normalizedPathSet = new Set(files.map((relativePath) => relativePath.replace(/\.md$/i, '')));
+            const basenameSet = new Set(files.map((relativePath) => path.basename(relativePath, '.md')));
+            const indexedPathSet = new Set(indexedFiles.keys());
+            const indexedNormalizedSet = new Set(Array.from(indexedFiles.keys()).map((relativePath) => relativePath.replace(/\.md$/i, '')));
+            const result = {};
+            for (const target of targets) {
+                const normalized = target.replace(/\.md$/i, '');
+                const withExt = target.endsWith('.md') ? target : `${target}.md`;
+                const exists = exactPathSet.has(withExt) ||
+                    exactPathSet.has(target) ||
+                    normalizedPathSet.has(normalized) ||
+                    basenameSet.has(normalized);
+                const indexed = indexedPathSet.has(withExt) ||
+                    indexedPathSet.has(target) ||
+                    indexedNormalizedSet.has(normalized);
+                result[target] = {
+                    target,
+                    exists,
+                    indexed,
+                };
+            }
+            return reply.send(result);
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to check links',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * POST /api/notes/assets
+     * Save an uploaded image into a local assets folder near the note.
+     */
+    app.post('/assets', {
+        schema: {
+            body: {
+                type: 'object',
+                required: ['notePath', 'fileName', 'contentBase64'],
+                properties: {
+                    notePath: { type: 'string' },
+                    fileName: { type: 'string' },
+                    contentBase64: { type: 'string' },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireProject(reply))
+            return;
+        const vaultPath = getVaultPath();
+        const notePath = (request.body.notePath || '').trim();
+        const rawFileName = (request.body.fileName || '').trim();
+        const contentBase64 = request.body.contentBase64 || '';
+        if (!notePath || !rawFileName || !contentBase64) {
+            return reply.status(400).send({
+                error: 'Invalid body',
+                message: 'notePath, fileName and contentBase64 are required',
+            });
+        }
+        const noteFullPath = resolveVaultFilePath(vaultPath, notePath);
+        if (!noteFullPath) {
+            return reply.status(400).send({
+                error: 'Invalid path',
+                message: 'notePath must be within vault',
+            });
+        }
+        try {
+            const noteDirectory = path.dirname(noteFullPath);
+            const assetsDirectory = path.join(noteDirectory, 'assets');
+            const parsed = path.parse(path.basename(rawFileName));
+            const baseName = parsed.name || 'image';
+            const extension = parsed.ext || '.png';
+            await fs.mkdir(assetsDirectory, { recursive: true });
+            let finalName = `${baseName}${extension}`;
+            let fullAssetPath = path.join(assetsDirectory, finalName);
+            let counter = 1;
+            while (true) {
+                try {
+                    await fs.access(fullAssetPath);
+                    finalName = `${baseName}-${counter}${extension}`;
+                    fullAssetPath = path.join(assetsDirectory, finalName);
+                    counter++;
+                }
+                catch {
+                    break;
+                }
+            }
+            const buffer = Buffer.from(contentBase64, 'base64');
+            await fs.writeFile(fullAssetPath, buffer);
+            const relativeAssetPath = path
+                .relative(vaultPath, fullAssetPath)
+                .split(path.sep)
+                .join('/');
+            return reply.send({
+                success: true,
+                path: relativeAssetPath,
+            });
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to save asset',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/notes/files/:path
+     * Get details for a specific note file
+     */
+    app.get('/files/*', async (request, reply) => {
+        if (!requireProject(reply))
+            return;
+        const filePath = request.params['*'];
+        const vaultPath = getVaultPath();
+        const fullPath = resolveVaultFilePath(vaultPath, filePath);
+        try {
+            // Ensure path is within vault
+            if (!fullPath) {
+                return reply.status(400).send({
+                    error: 'Invalid path',
+                    message: 'Path must be within vault',
+                });
+            }
+            const context = requireProjectContext();
+            const stat = await fs.stat(fullPath);
+            const content = await fs.readFile(fullPath, 'utf-8');
+            // Get index info for this file
+            const indexedFiles = await context.indexer.getIndexedFiles();
+            const indexInfo = indexedFiles.get(filePath);
+            let indexStatus = 'unindexed';
+            if (indexInfo) {
+                const fileMtime = stat.mtimeMs;
+                indexStatus = fileMtime > indexInfo.indexed_at ? 'modified' : 'indexed';
+            }
+            return reply.send({
+                path: fullPath,
+                name: path.basename(filePath),
+                relativePath: filePath,
+                indexStatus,
+                size: stat.size,
+                content,
+                chunks: indexInfo?.chunks ?? 0,
+                lastIndexed: indexInfo ? new Date(indexInfo.indexed_at).toISOString() : undefined,
+            });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return reply.status(404).send({
+                    error: 'File not found',
+                    message: `Note not found: ${filePath}`,
+                });
+            }
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to get file',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/notes/search
+     * Semantic search in notes
+     */
+    app.get('/search', {
+        schema: {
+            querystring: {
+                type: 'object',
+                required: ['q'],
+                properties: {
+                    q: { type: 'string' },
+                    limit: { type: 'number', default: 10 },
+                    threshold: { type: 'number', default: 0.5 },
+                    tags: { type: 'string' },
+                    folder: { type: 'string' },
+                    path: { type: 'string' },
+                    mode: { type: 'string', enum: ['hybrid', 'semantic', 'text'], default: 'hybrid' },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireProject(reply))
+            return;
+        const { q, limit = 10, threshold = 0.5, tags, folder, path: pathFilter, mode = 'hybrid' } = request.query;
+        try {
+            // Update secrets if changed (e.g., Voyage API key added after project open)
+            await updateSecretsIfNeeded(request.secrets || {});
+            const context = requireProjectContext();
+            const parsedTags = tags ? tags.split(',').map(t => t.trim()) : undefined;
+            const folderFilter = folder ?? pathFilter;
+            let searchResults;
+            if (mode === 'text') {
+                searchResults = await context.indexer.searchFts({
+                    query: q,
+                    limit,
+                    folder: folderFilter,
+                    tags: parsedTags,
+                });
+            }
+            else if (mode === 'semantic') {
+                searchResults = await context.indexer.search(q, {
+                    limit,
+                    threshold,
+                    tags: parsedTags,
+                    folder: folderFilter,
+                });
+            }
+            else {
+                searchResults = await context.indexer.searchHybrid({
+                    query: q,
+                    limit,
+                    threshold,
+                    tags: parsedTags,
+                    folder: folderFilter,
+                });
+            }
+            if (isError(searchResults)) {
+                return reply.status(500).send({
+                    error: 'Search failed',
+                    message: searchResults.message,
+                });
+            }
+            const results = searchResults.map(r => ({
+                path: r.path,
+                section: r.section,
+                score: r.score,
+                content: r.content,
+                title: r.title,
+                tags: r.tags,
+                links: r.links,
+            }));
+            return reply.send({
+                query: q,
+                results,
+                total: results.length,
+            });
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Search failed',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/notes/grep
+     * Exact text search in notes
+     */
+    app.get('/grep', {
+        schema: {
+            querystring: {
+                type: 'object',
+                required: ['pattern'],
+                properties: {
+                    pattern: { type: 'string' },
+                    regex: { type: 'boolean', default: false },
+                    caseSensitive: { type: 'boolean', default: false },
+                    limit: { type: 'number', default: 20 },
+                    folder: { type: 'string' },
+                    context: { type: 'number', default: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireProject(reply))
+            return;
+        const { pattern, regex = false, caseSensitive = false, limit = 20, folder, context: contextLines = 1 } = request.query;
+        try {
+            const ctx = requireProjectContext();
+            const grep = createGrep(ctx.vaultUtils);
+            const grepResult = await grep.search({
+                pattern,
+                regex,
+                caseSensitive,
+                limit,
+                folder,
+                context: contextLines,
+            });
+            // Transform to API response format
+            const results = grepResult.files.map(file => ({
+                path: file.path,
+                matches: file.matches.map(m => ({
+                    line: m.lineNumber,
+                    content: m.line,
+                    contextBefore: m.contextBefore,
+                    contextAfter: m.contextAfter,
+                })),
+            }));
+            return reply.send({
+                pattern,
+                results,
+                total: grepResult.totalMatches,
+            });
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Grep failed',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/notes/backlinks/:path
+     * Get notes that link to the specified note
+     */
+    app.get('/backlinks/*', async (request, reply) => {
+        if (!requireProject(reply))
+            return;
+        const filePath = request.params['*'];
+        const vaultPath = getVaultPath();
+        try {
+            // Extract note name without extension for wiki-link matching
+            const noteName = path.basename(filePath, '.md');
+            // Escape special regex characters
+            const escapedName = noteName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            // Match [[noteName]] or [[noteName|alias]] - case insensitive
+            const wikiLinkPattern = new RegExp(`\\[\\[${escapedName}(\\|[^\\]]*)?\\]\\]`, 'gi');
+            const files = await glob('**/*.md', {
+                cwd: vaultPath,
+                nodir: true,
+                ignore: ['**/node_modules/**', '**/.git/**'],
+            });
+            const backlinks = [];
+            for (const file of files) {
+                if (file === filePath)
+                    continue; // Skip self
+                const fullPath = path.join(vaultPath, file);
+                const content = await fs.readFile(fullPath, 'utf-8');
+                const lines = content.split('\n');
+                for (let index = 0; index < lines.length; index++) {
+                    const line = lines[index];
+                    // Reset lastIndex before each test (required for /g flag)
+                    wikiLinkPattern.lastIndex = 0;
+                    if (wikiLinkPattern.test(line)) {
+                        backlinks.push({
+                            source: file,
+                            context: line.trim(),
+                            line: index + 1,
+                        });
+                    }
+                }
+            }
+            return reply.send({
+                target: filePath,
+                backlinks,
+                total: backlinks.length,
+            });
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to get backlinks',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * POST /api/notes/sync
+     * Trigger notes sync using SyncWal for recovery and progress tracking
+     */
+    app.post('/sync', {
+        schema: {
+            body: {
+                type: 'object',
+                properties: {
+                    force: { type: 'boolean', default: false },
+                    resume: { type: 'boolean', default: false },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        // Update secrets if changed (e.g., Voyage API key added after project open)
+        await updateSecretsIfNeeded(request.secrets || {});
+        const handler = createSyncHandler(app, {
+            type: 'notes',
+            isEnabled: (ctx) => !!ctx.indexer,
+            notEnabledError: 'Notes indexer is not initialized for this project',
+            validate: async () => {
+                // Check if required secrets are present for the configured provider
+                const project = getCurrentProject();
+                if (!project)
+                    return 'No project open';
+                const error = validateSecrets(project.config, project.secrets);
+                return error;
+            },
+            clearIndex: async (ctx) => {
+                await ctx.indexer.clearIndex();
+            },
+            runSync: async (ctx, recoveryPlan) => {
+                const result = await ctx.indexer.reindexAllWithSyncWal(recoveryPlan || undefined);
+                return { indexed: result.indexed, deleted: result.deleted };
+            },
+        });
+        return handler(request, reply);
+    });
+    /**
+     * POST /api/notes/reindex
+     * Reindex specific files or folders
+     */
+    app.post('/reindex', {
+        schema: {
+            body: {
+                type: 'object',
+                required: ['paths'],
+                properties: {
+                    paths: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireProject(reply))
+            return;
+        const { paths } = request.body;
+        const project = getCurrentProject();
+        try {
+            emitEvent({
+                type: 'reindex:notes:started',
+                data: { paths },
+            });
+            // TODO: Implement actual reindexing
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            emitEvent({
+                type: 'reindex:notes:completed',
+                data: { paths },
+            });
+            return reply.send({
+                success: true,
+                message: `Reindexed ${paths.length} paths`,
+            });
+        }
+        catch (error) {
+            emitEvent({
+                type: 'reindex:notes:error',
+                data: {
+                    paths,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                },
+            });
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Reindex failed',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    const updateNoteHandler = async (request, reply) => {
+        if (!requireProject(reply))
+            return;
+        const filePath = request.params['*'];
+        const content = request.body?.content;
+        const vaultPath = getVaultPath();
+        const fullPath = resolveVaultFilePath(vaultPath, filePath);
+        if (!fullPath) {
+            return reply.status(400).send({
+                error: 'Invalid path',
+                message: 'Path must be within vault',
+            });
+        }
+        if (typeof content !== 'string') {
+            return reply.status(400).send({
+                error: 'Invalid body',
+                message: 'Body must include string field: content',
+            });
+        }
+        try {
+            const context = requireProjectContext();
+            await fs.mkdir(path.dirname(fullPath), { recursive: true });
+            await fs.writeFile(fullPath, content, 'utf-8');
+            const indexResult = await context.indexer.indexFile(filePath);
+            if (isError(indexResult)) {
+                app.log.error(indexResult);
+                return reply.status(500).send({
+                    error: 'Reindex failed',
+                    message: indexResult.message,
+                });
+            }
+            return reply.send({
+                success: true,
+                indexed: true,
+            });
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to update note',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    };
+    /**
+     * PUT /api/notes/files/:path
+     * Update note content and reindex the file.
+     */
+    app.put('/files/*', {
+        schema: {
+            body: {
+                type: 'object',
+                required: ['content'],
+                properties: {
+                    content: { type: 'string' },
+                },
+            },
+        },
+    }, updateNoteHandler);
+    /**
+     * PUT /api/notes/:path
+     * Alias for updating note content and reindexing.
+     */
+    app.put('/*', {
+        schema: {
+            body: {
+                type: 'object',
+                required: ['content'],
+                properties: {
+                    content: { type: 'string' },
+                },
+            },
+        },
+    }, updateNoteHandler);
+    /**
+     * DELETE /api/notes/files/:path
+     * Remove a file from the index (not from disk)
+     */
+    app.delete('/files/*', async (request, reply) => {
+        if (!requireProject(reply))
+            return;
+        const filePath = request.params['*'];
+        try {
+            // TODO: Implement actual removal from index
+            return reply.send({
+                success: true,
+                message: `Removed ${filePath} from index`,
+            });
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to remove from index',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+}
+//# sourceMappingURL=notes.js.map