opensidian 1.0.0

package/tests/api/routes.test.ts

@@ -0,0 +1,167 @@
+import express from 'express';
+import fs from 'fs/promises';
+import { createServer, type Server } from 'http';
+import os from 'os';
+import path from 'path';
+import routes from '../../src/api/routes.js';
+
+describe('API routes', () => {
+  let server: Server;
+  let baseUrl: string;
+
+  beforeAll(async () => {
+    const app = express();
+    app.use(express.json());
+    app.use('/api', routes);
+
+    server = createServer(app);
+
+    await new Promise<void>((resolve) => {
+      server.listen(0, '127.0.0.1', () => resolve());
+    });
+
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+      throw new Error('Failed to start test server');
+    }
+
+    baseUrl = `http://127.0.0.1:${address.port}`;
+  });
+
+  afterAll(async () => {
+    await new Promise<void>((resolve, reject) => {
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  });
+
+  it('lists vaults and validates required params', async () => {
+    const listResponse = await fetch(`${baseUrl}/api/vaults`);
+    expect(listResponse.status).toBe(200);
+    expect(Array.isArray((await listResponse.json()).vaults)).toBe(true);
+
+    const createResponse = await fetch(`${baseUrl}/api/vaults`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({}),
+    });
+
+    expect(createResponse.status).toBe(400);
+    expect(await createResponse.json()).toEqual({
+      error: 'name and path are required',
+    });
+
+    const notFoundResponse = await fetch(`${baseUrl}/api/vaults/does-not-exist`);
+    expect(notFoundResponse.status).toBe(404);
+
+    const deleteResponse = await fetch(`${baseUrl}/api/vaults/any`, {
+      method: 'DELETE',
+    });
+    expect(deleteResponse.status).toBe(501);
+  });
+
+  it('executes the note lifecycle and graph endpoints', async () => {
+    const vaultPath = await fs.mkdtemp(path.join(os.tmpdir(), 'opensidian-routes-'));
+
+    const vaultResponse = await fetch(`${baseUrl}/api/vaults`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ name: 'Routes Vault', path: vaultPath }),
+    });
+    expect(vaultResponse.status).toBe(201);
+
+    const missingVaultResponse = await fetch(`${baseUrl}/api/notes`);
+    expect(missingVaultResponse.status).toBe(400);
+
+    const secondNoteResponse = await fetch(`${baseUrl}/api/notes`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        vaultPath,
+        filename: 'second',
+        content: '# Second',
+      }),
+    });
+    expect(secondNoteResponse.status).toBe(201);
+
+    const createNoteResponse = await fetch(`${baseUrl}/api/notes`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        vaultPath,
+        filename: 'first',
+        content: '# First\n\nSee [[second]] for more.',
+      }),
+    });
+    expect(createNoteResponse.status).toBe(201);
+
+    const listNotesResponse = await fetch(
+      `${baseUrl}/api/notes?${new URLSearchParams({ vault: vaultPath }).toString()}`
+    );
+    expect(listNotesResponse.status).toBe(200);
+    expect((await listNotesResponse.json()).notes.length).toBeGreaterThan(0);
+
+    const readNoteResponse = await fetch(
+      `${baseUrl}/api/notes/first.md?${new URLSearchParams({ vault: vaultPath }).toString()}`
+    );
+    expect(readNoteResponse.status).toBe(200);
+    expect((await readNoteResponse.json()).note.filename).toBe('first');
+
+    const missingNoteResponse = await fetch(
+      `${baseUrl}/api/notes/missing.md?${new URLSearchParams({ vault: vaultPath }).toString()}`
+    );
+    expect(missingNoteResponse.status).toBe(404);
+
+    const updateMissingContentResponse = await fetch(
+      `${baseUrl}/api/notes/first.md?${new URLSearchParams({ vault: vaultPath }).toString()}`,
+      {
+        method: 'PUT',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({}),
+      }
+    );
+    expect(updateMissingContentResponse.status).toBe(400);
+
+    const updateNoteResponse = await fetch(
+      `${baseUrl}/api/notes/first.md?${new URLSearchParams({ vault: vaultPath }).toString()}`,
+      {
+        method: 'PUT',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ content: '# Updated\n\nStill linked to [[second]].' }),
+      }
+    );
+    expect(updateNoteResponse.status).toBe(200);
+
+    const graphMissingVaultResponse = await fetch(`${baseUrl}/api/graph`);
+    expect(graphMissingVaultResponse.status).toBe(400);
+
+    const graphResponse = await fetch(
+      `${baseUrl}/api/graph?${new URLSearchParams({ vault: vaultPath }).toString()}`
+    );
+    expect(graphResponse.status).toBe(200);
+    expect((await graphResponse.json()).graph.metadata.totalNotes).toBeGreaterThan(0);
+
+    const neighborsResponse = await fetch(
+      `${baseUrl}/api/graph/neighbors/first.md?${new URLSearchParams({ vault: vaultPath }).toString()}`
+    );
+    expect(neighborsResponse.status).toBe(200);
+    expect((await neighborsResponse.json()).neighbors).toEqual(
+      expect.arrayContaining([expect.objectContaining({ id: 'second.md' })])
+    );
+
+    const deleteNoteResponse = await fetch(
+      `${baseUrl}/api/notes/first.md?${new URLSearchParams({ vault: vaultPath }).toString()}`,
+      {
+        method: 'DELETE',
+      }
+    );
+    expect(deleteNoteResponse.status).toBe(204);
+
+    await fs.rm(vaultPath, { recursive: true, force: true });
+  });
+});

package/tests/core/graph.test.ts

@@ -0,0 +1,236 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { GraphEngine } from '../../src/core/graph';
+import { Note } from '../../src/shared/types';
+
+describe('GraphEngine', () => {
+  let graphEngine: GraphEngine;
+  const testVaultPath = '/tmp/test-vault';
+
+  beforeEach(() => {
+    graphEngine = new GraphEngine();
+  });
+
+  describe('indexNote', () => {
+    it('should add node to graph when indexing note', () => {
+      const note: Note = {
+        path: 'test-note.md',
+        filename: 'test-note',
+        content: '# Test',
+        frontmatter: {},
+        links: [],
+        created: new Date().toISOString(),
+        modified: new Date().toISOString(),
+      };
+
+      graphEngine.indexNote(testVaultPath, note);
+      const graph = graphEngine.getGraph(testVaultPath);
+
+      expect(graph).toBeDefined();
+      expect(graph?.nodes).toHaveLength(1);
+      expect(graph?.nodes[0].id).toBe('test-note.md');
+      expect(graph?.nodes[0].label).toBe('test-note');
+    });
+
+    it('should extract tags from frontmatter', () => {
+      const note: Note = {
+        path: 'tagged-note.md',
+        filename: 'tagged-note',
+        content: '# Tagged',
+        frontmatter: { tags: ['javascript', 'programming'] },
+        links: [],
+        created: new Date().toISOString(),
+        modified: new Date().toISOString(),
+      };
+
+      graphEngine.indexNote(testVaultPath, note);
+      const graph = graphEngine.getGraph(testVaultPath);
+
+      expect(graph?.nodes[0].tags).toContain('javascript');
+      expect(graph?.nodes[0].tags).toContain('programming');
+    });
+
+    it('should create edges for wiki links', () => {
+      const note: Note = {
+        path: 'source.md',
+        filename: 'source',
+        content: '# Source\n\nSee [[target]] for info.',
+        frontmatter: {},
+        links: ['target'],
+        created: new Date().toISOString(),
+        modified: new Date().toISOString(),
+      };
+
+      graphEngine.indexNote(testVaultPath, note);
+      const graph = graphEngine.getGraph(testVaultPath);
+
+      expect(graph?.edges).toHaveLength(1);
+      expect(graph?.edges[0].source).toBe('source.md');
+      expect(graph?.edges[0].target).toBe('target.md');
+    });
+
+    it('should update existing node when re-indexing', () => {
+      const note1: Note = {
+        path: 'note.md',
+        filename: 'note',
+        content: '# Original',
+        frontmatter: {},
+        links: [],
+        created: new Date().toISOString(),
+        modified: new Date().toISOString(),
+      };
+
+      const note2: Note = {
+        ...note1,
+        content: '# Updated',
+        links: ['link1', 'link2'],
+      };
+
+      graphEngine.indexNote(testVaultPath, note1);
+      graphEngine.indexNote(testVaultPath, note2);
+      const graph = graphEngine.getGraph(testVaultPath);
+
+      expect(graph?.nodes).toHaveLength(1);
+      expect(graph?.edges).toHaveLength(2);
+    });
+
+    it('should update metadata after indexing', () => {
+      const note1: Note = createNote('note1.md', ['link1']);
+      const note2: Note = createNote('note2.md', ['link1', 'link2']);
+
+      graphEngine.indexNote(testVaultPath, note1);
+      graphEngine.indexNote(testVaultPath, note2);
+      const graph = graphEngine.getGraph(testVaultPath);
+
+      expect(graph?.metadata.totalNotes).toBe(2);
+      expect(graph?.metadata.totalLinks).toBe(3);
+    });
+  });
+
+  describe('removeNote', () => {
+    it('should remove node from graph', () => {
+      const note: Note = createNote('to-remove.md', []);
+      graphEngine.indexNote(testVaultPath, note);
+      
+      graphEngine.removeNote(testVaultPath, 'to-remove.md');
+      const graph = graphEngine.getGraph(testVaultPath);
+
+      expect(graph?.nodes).toHaveLength(0);
+    });
+
+    it('should remove associated edges', () => {
+      const note1: Note = createNote('source.md', ['target.md']);
+      const note2: Note = createNote('target.md', []);
+      
+      graphEngine.indexNote(testVaultPath, note1);
+      graphEngine.indexNote(testVaultPath, note2);
+      
+      graphEngine.removeNote(testVaultPath, 'source.md');
+      const graph = graphEngine.getGraph(testVaultPath);
+
+      expect(graph?.edges).toHaveLength(0);
+    });
+  });
+
+  describe('getNeighbors', () => {
+    it('should return connected nodes', () => {
+      const note1: Note = createNote('note1.md', ['note2.md', 'note3.md']);
+      const note2: Note = createNote('note2.md', []);
+      const note3: Note = createNote('note3.md', []);
+
+      graphEngine.indexNote(testVaultPath, note1);
+      graphEngine.indexNote(testVaultPath, note2);
+      graphEngine.indexNote(testVaultPath, note3);
+
+      const neighbors = graphEngine.getNeighbors(testVaultPath, 'note1.md');
+
+      expect(neighbors).toHaveLength(2);
+      expect(neighbors.map(n => n.id)).toContain('note2.md');
+      expect(neighbors.map(n => n.id)).toContain('note3.md');
+    });
+
+    it('should return empty array for isolated node', () => {
+      const note: Note = createNote('isolated.md', []);
+      graphEngine.indexNote(testVaultPath, note);
+
+      const neighbors = graphEngine.getNeighbors(testVaultPath, 'isolated.md');
+
+      expect(neighbors).toHaveLength(0);
+    });
+  });
+
+  describe('getBacklinks', () => {
+    it('should return nodes that link to specified node', () => {
+      const note1: Note = createNote('note1.md', ['target.md']);
+      const note2: Note = createNote('note2.md', ['target.md']);
+      const note3: Note = createNote('note3.md', []);
+
+      graphEngine.indexNote(testVaultPath, note1);
+      graphEngine.indexNote(testVaultPath, note2);
+      graphEngine.indexNote(testVaultPath, note3);
+
+      const backlinks = graphEngine.getBacklinks(testVaultPath, 'target.md');
+
+      expect(backlinks).toHaveLength(2);
+      expect(backlinks.map(n => n.id)).toContain('note1.md');
+      expect(backlinks.map(n => n.id)).toContain('note2.md');
+    });
+  });
+
+  describe('searchByTag', () => {
+    it('should find nodes by tag', () => {
+      const note1: Note = createNote('js-note.md', [], { tags: ['javascript'] });
+      const note2: Note = createNote('py-note.md', [], { tags: ['python'] });
+      const note3: Note = createNote('both-note.md', [], { tags: ['javascript', 'python'] });
+
+      graphEngine.indexNote(testVaultPath, note1);
+      graphEngine.indexNote(testVaultPath, note2);
+      graphEngine.indexNote(testVaultPath, note3);
+
+      const results = graphEngine.searchByTag(testVaultPath, 'javascript');
+
+      expect(results).toHaveLength(2);
+    });
+  });
+
+  describe('computeStats', () => {
+    it('should return most connected nodes', () => {
+      const highlyConnected: Note = createNote('hub.md', ['n1.md', 'n2.md', 'n3.md']);
+      const leaf1: Note = createNote('leaf1.md', ['hub.md']);
+      const leaf2: Note = createNote('leaf2.md', ['hub.md']);
+
+      graphEngine.indexNote(testVaultPath, highlyConnected);
+      graphEngine.indexNote(testVaultPath, leaf1);
+      graphEngine.indexNote(testVaultPath, leaf2);
+
+      const { mostConnected } = graphEngine.computeStats(testVaultPath);
+
+      expect(mostConnected[0].id).toBe('hub.md');
+    });
+
+    it('should return orphan notes', () => {
+      const orphan: Note = createNote('orphan.md', []);
+      const connected: Note = createNote('connected.md', ['linked.md']);
+      const linked: Note = createNote('linked.md', []);
+
+      graphEngine.indexNote(testVaultPath, orphan);
+      graphEngine.indexNote(testVaultPath, connected);
+      graphEngine.indexNote(testVaultPath, linked);
+
+      const { orphanNotes } = graphEngine.computeStats(testVaultPath);
+
+      expect(orphanNotes.some(n => n.id === 'orphan.md')).toBe(true);
+    });
+  });
+});
+
+function createNote(path: string, links: string[], frontmatter: Record<string, unknown> = {}): Note {
+  return {
+    path,
+    filename: path.replace('.md', ''),
+    content: `# ${path}`,
+    frontmatter,
+    links,
+    created: new Date().toISOString(),
+    modified: new Date().toISOString(),
+  };
+}

package/tests/core/markdown.test.ts

@@ -0,0 +1,157 @@
+import { describe, it, expect } from 'vitest';
+import { MarkdownParser } from '../../src/core/markdown';
+
+describe('MarkdownParser', () => {
+  let parser: MarkdownParser;
+
+  beforeEach(() => {
+    parser = new MarkdownParser();
+  });
+
+  describe('parse', () => {
+    it('should parse basic markdown content', () => {
+      const result = parser.parse('# Hello World\n\nThis is content.');
+      
+      expect(result.body).toBe('# Hello World\n\nThis is content.');
+      expect(result.html).toContain('<h1');
+      expect(result.html).toContain('Hello World');
+    });
+
+    it('should extract frontmatter', () => {
+      const content = `---
+title: Test Title
+author: Test Author
+---
+# Content`;
+
+      const result = parser.parse<{ title: string; author: string }>(content);
+      
+      expect(result.frontmatter).toHaveProperty('title', 'Test Title');
+      expect(result.frontmatter).toHaveProperty('author', 'Test Author');
+    });
+
+    it('should extract wiki links', () => {
+      const content = '# Note\n\nSee [[Another Note]] for details.\n\nAlso check [[Third Note|See this]].';
+      
+      const result = parser.parse(content);
+      
+      expect(result.links).toContain('Another Note');
+      expect(result.links).toContain('Third Note');
+    });
+
+    it('should extract markdown links', () => {
+      const content = '# Note\n\nCheck [this link](other-note.md) for info.';
+      
+      const result = parser.parse(content);
+      
+      expect(result.links).toContain('other-note');
+    });
+
+    it('should exclude external links', () => {
+      const content = '# Note\n\nVisit [Google](https://google.com) for search.';
+      
+      const result = parser.parse(content);
+      
+      expect(result.links).not.toContain('https://google.com');
+    });
+
+    it('should extract headings with IDs', () => {
+      const content = '# Main Title\n\n## Section One\n\n### Subsection\n\n## Section Two';
+      
+      const result = parser.parse(content);
+      
+      expect(result.headings).toHaveLength(4);
+      expect(result.headings[0]).toEqual({ level: 1, text: 'Main Title', id: 'main-title' });
+      expect(result.headings[1]).toEqual({ level: 2, text: 'Section One', id: 'section-one' });
+    });
+
+    it('should handle empty content', () => {
+      const result = parser.parse('');
+      
+      expect(result.body).toBe('');
+      expect(result.html).toBe('');
+      expect(result.links).toEqual([]);
+      expect(result.headings).toEqual([]);
+    });
+
+    it('should handle content without frontmatter', () => {
+      const content = '# Just a heading\n\nSome content.';
+      
+      const result = parser.parse(content);
+      
+      expect(Object.keys(result.frontmatter)).toHaveLength(0);
+      expect(result.body).toBe(content);
+    });
+  });
+
+  describe('extractLinks', () => {
+    it('should extract wiki links from content', () => {
+      const content = 'See [[Link One]] and [[Link Two]] for more.';
+      const links = parser.extractLinks(content);
+      
+      expect(links).toContain('Link One');
+      expect(links).toContain('Link Two');
+    });
+
+    it('should deduplicate links', () => {
+      const content = 'See [[Same Link]] and [[Same Link]] again.';
+      const links = parser.extractLinks(content);
+      
+      const sameLinkCount = links.filter(l => l === 'Same Link').length;
+      expect(sameLinkCount).toBe(1);
+    });
+  });
+
+  describe('extractHeadings', () => {
+    it('should extract all heading levels', () => {
+      const content = `# H1\n## H2\n### H3\n#### H4\n##### H5\n###### H6`;
+      const headings = parser.extractHeadings(content);
+      
+      expect(headings).toHaveLength(6);
+      expect(headings[0].level).toBe(1);
+      expect(headings[5].level).toBe(6);
+    });
+
+    it('should generate slug IDs for headings', () => {
+      const headings = parser.extractHeadings('# My Great Heading');
+      
+      expect(headings[0].id).toBe('my-great-heading');
+    });
+  });
+
+  describe('slugify', () => {
+    it('should convert text to URL-friendly slug', () => {
+      expect(parser.slugify('Hello World')).toBe('hello-world');
+      expect(parser.slugify('Test  Multiple   Spaces')).toBe('test-multiple-spaces');
+      expect(parser.slugify('Special!@#Characters')).toBe('specialcharacters');
+    });
+
+    it('should handle international characters', () => {
+      expect(parser.slugify('Über uns')).toBe('uber-uns');
+    });
+  });
+
+  describe('toMarkdown', () => {
+    it('should convert note to markdown with frontmatter', () => {
+      const note = {
+        frontmatter: { title: 'Test', tags: 'test' },
+        body: '# Content\n\nSome text.',
+      };
+      
+      const markdown = parser.toMarkdown(note);
+      
+      expect(markdown).toContain('---');
+      expect(markdown).toContain('title: Test');
+      expect(markdown).toContain('# Content');
+    });
+
+    it('should handle note without frontmatter', () => {
+      const note = { body: '# Just Content' };
+      
+      const markdown = parser.toMarkdown(note);
+      
+      expect(markdown).toBe('# Just Content');
+      expect(markdown).not.toContain('---');
+    });
+  });
+});

package/tests/core/search.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { FullTextIndexer } from '../../src/core/search';
+
+describe('FullTextIndexer', () => {
+  let indexer: FullTextIndexer;
+
+  beforeEach(() => {
+    indexer = new FullTextIndexer('./data/test-search-index');
+    indexer.load();
+  });
+
+  const makeDoc = (path: string, content: string, tags: string[] = [], backlinks = 0) => ({
+    path,
+    filename: path.replace('.md', ''),
+    content,
+    tags,
+    modified: new Date().toISOString(),
+    backlinks,
+  });
+
+  describe('tokenize', () => {
+    it('should normalize and remove stopwords', () => {
+      indexer.indexNote(makeDoc('test.md', 'A casa é azul e o carro é vermelho'));
+      const results = indexer.search('casa azul carro', [makeDoc('test.md', 'A casa é azul e o carro é vermelho')]);
+      expect(results.length).toBeGreaterThan(0);
+    });
+
+    it('should handle accented characters', () => {
+      indexer.indexNote(makeDoc('test.md', 'coração órgão vídeo'));
+      const results = indexer.search('coracao orgao video', [makeDoc('test.md', 'coração órgão vídeo')]);
+      expect(results.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('indexNote', () => {
+    it('should add document to index', () => {
+      indexer.indexNote(makeDoc('note1.md', 'TypeScript is great for building apps'));
+      const results = indexer.search('TypeScript', [makeDoc('note1.md', 'TypeScript is great for building apps')]);
+      expect(results).toHaveLength(1);
+      expect(results[0].filename).toBe('note1');
+    });
+
+    it('should index multiple documents', () => {
+      indexer.indexNote(makeDoc('a.md', 'Node.js runtime'));
+      indexer.indexNote(makeDoc('b.md', 'Node.js backend server'));
+      const results = indexer.search('Node.js', [makeDoc('a.md', 'Node.js runtime'), makeDoc('b.md', 'Node.js backend server')]);
+      expect(results).toHaveLength(2);
+    });
+  });
+
+  describe('removeNote', () => {
+    it('should remove document from index', () => {
+      indexer.indexNote(makeDoc('to-remove.md', 'temporary content'));
+      indexer.removeNote('to-remove.md');
+      const results = indexer.search('temporary', [makeDoc('to-remove.md', 'temporary content')]);
+      expect(results).toHaveLength(0);
+    });
+  });
+
+  describe('search', () => {
+    it('should order by relevance (TF-IDF)', () => {
+      indexer.indexNote(makeDoc('short.md', 'TypeScript'));
+      indexer.indexNote(makeDoc('long.md', 'TypeScript TypeScript TypeScript'));
+      const docs = [
+        makeDoc('short.md', 'TypeScript'),
+        makeDoc('long.md', 'TypeScript TypeScript TypeScript'),
+      ];
+      const results = indexer.search('TypeScript', docs);
+      expect(results.length).toBeGreaterThanOrEqual(2);
+      expect(results[0].score).toBeGreaterThanOrEqual(results[1]?.score ?? 0);
+    });
+
+    it('should apply tag filter', () => {
+      const doc = makeDoc('tagged.md', 'javascript programming', ['javascript']);
+      indexer.indexNote(doc);
+      const results = indexer.search('javascript', [doc], { tag: 'javascript' });
+      expect(results).toHaveLength(1);
+      const empty = indexer.search('javascript', [doc], { tag: 'python' });
+      expect(empty).toHaveLength(0);
+    });
+
+    it('should apply date filter', () => {
+      const doc = makeDoc('old.md', 'content');
+      doc.modified = '2024-01-01T00:00:00.000Z';
+      indexer.indexNote(doc);
+      const resultsAfter = indexer.search('content', [doc], { after: '2025-01-01' });
+      expect(resultsAfter).toHaveLength(0);
+      const resultsBefore = indexer.search('content', [doc], { before: '2024-06-01' });
+      expect(resultsBefore).toHaveLength(1);
+    });
+
+    it('should apply backlinks filter', () => {
+      const withLinks = makeDoc('linked.md', 'content', [], 5);
+      const isolated = makeDoc('alone.md', 'content', [], 0);
+      indexer.indexNote(withLinks);
+      indexer.indexNote(isolated);
+      const linked = indexer.search('content', [withLinks, isolated], { hasBacklinks: true });
+      expect(linked).toHaveLength(1);
+      expect(linked[0].path).toBe('linked.md');
+      const alone = indexer.search('content', [withLinks, isolated], { hasBacklinks: false });
+      expect(alone).toHaveLength(1);
+      expect(alone[0].path).toBe('alone.md');
+    });
+
+    it('should include highlighted snippet', () => {
+      indexer.indexNote(makeDoc('snippet.md', 'This is the most important text in the entire document'));
+      const results = indexer.search('important', [makeDoc('snippet.md', 'This is the most important text in the entire document')]);
+      expect(results[0].snippet).toContain('<mark>');
+      expect(results[0].snippet).toContain('</mark>');
+    });
+
+    it('should return empty array for no matches', () => {
+      indexer.indexNote(makeDoc('note.md', 'some random words'));
+      const results = indexer.search('nonexistent', [makeDoc('note.md', 'some random words')]);
+      expect(results).toHaveLength(0);
+    });
+  });
+
+  describe('persist and load', () => {
+    it('should persist and reload index', async () => {
+      indexer.indexNote(makeDoc('persist.md', 'persistent content'));
+      await indexer.save();
+
+      const loaded = new FullTextIndexer('./data/test-search-index');
+      await loaded.load();
+
+      const results = loaded.search('persistent', [makeDoc('persist.md', 'persistent content')]);
+      expect(results).toHaveLength(1);
+      expect(results[0].filename).toBe('persist');
+    });
+  });
+});