@noteplanco/noteplan-mcp 1.1.7 → 1.1.9

package/dist/tools/notes.test.js

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 // ---------------------------------------------------------------------------
 // Copies of private helper functions from notes.ts
 // These are verbatim copies so we can unit-test them without exporting.
@@ -595,4 +595,962 @@ describe('findParagraphBounds', () => {
         expect(findParagraphBounds(lines, 3)).toEqual({ startIndex: 2, endIndex: 3 });
     });
 });
+// ---------------------------------------------------------------------------
+// matchesFrontmatterProperties — exported from unified-store
+// ---------------------------------------------------------------------------
+import { matchesFrontmatterProperties, normalizeFrontmatterScalar } from '../noteplan/unified-store.js';
+describe('normalizeFrontmatterScalar', () => {
+    it('strips surrounding double quotes', () => {
+        expect(normalizeFrontmatterScalar('"book"', false)).toBe('book');
+    });
+    it('strips surrounding single quotes', () => {
+        expect(normalizeFrontmatterScalar("'book'", false)).toBe('book');
+    });
+    it('lowercases when caseSensitive is false', () => {
+        expect(normalizeFrontmatterScalar('Book', false)).toBe('book');
+    });
+    it('preserves case when caseSensitive is true', () => {
+        expect(normalizeFrontmatterScalar('Book', true)).toBe('Book');
+    });
+    it('trims whitespace', () => {
+        expect(normalizeFrontmatterScalar('  hello  ', false)).toBe('hello');
+    });
+});
+describe('matchesFrontmatterProperties', () => {
+    const makeNote = (content) => ({
+        id: 'test-id',
+        title: 'Test Note',
+        filename: 'test.md',
+        type: 'note',
+        source: 'local',
+        folder: '',
+        content,
+        modifiedAt: new Date(),
+        createdAt: new Date(),
+        spaceId: undefined,
+        date: undefined,
+    });
+    it('matches a single property filter', () => {
+        const note = makeNote('---\ntype: book\n---\nSome content');
+        expect(matchesFrontmatterProperties(note, [['type', 'book']], false)).toBe(true);
+    });
+    it('rejects when property value does not match', () => {
+        const note = makeNote('---\ntype: article\n---\nSome content');
+        expect(matchesFrontmatterProperties(note, [['type', 'book']], false)).toBe(false);
+    });
+    it('rejects when property key is missing', () => {
+        const note = makeNote('---\ntitle: My Note\n---\nSome content');
+        expect(matchesFrontmatterProperties(note, [['type', 'book']], false)).toBe(false);
+    });
+    it('returns false when there is no frontmatter', () => {
+        const note = makeNote('Just some text without frontmatter');
+        expect(matchesFrontmatterProperties(note, [['type', 'book']], false)).toBe(false);
+    });
+    it('matches case-insensitively by default', () => {
+        const note = makeNote('---\nType: Book\n---\nContent');
+        expect(matchesFrontmatterProperties(note, [['type', 'book']], false)).toBe(true);
+    });
+    it('matches comma-separated list values', () => {
+        const note = makeNote('---\ntags: fiction, book, novel\n---\nContent');
+        expect(matchesFrontmatterProperties(note, [['tags', 'book']], false)).toBe(true);
+    });
+    it('requires all filters to match', () => {
+        const note = makeNote('---\ntype: book\nstatus: reading\n---\nContent');
+        expect(matchesFrontmatterProperties(note, [['type', 'book'], ['status', 'reading']], false)).toBe(true);
+        expect(matchesFrontmatterProperties(note, [['type', 'book'], ['status', 'done']], false)).toBe(false);
+    });
+});
+// ── Regression: read-write line number consistency with frontmatter ──
+// These tests verify that line numbers from buildLineWindow (used by get_notes
+// and getParagraphs) can be directly used in delete/edit/replace operations
+// without any frontmatter offset mismatch. This was a real user-reported bug
+// where delete_lines previewed wrong content because it applied a frontmatter
+// offset while get_notes used absolute line numbers.
+describe('frontmatter line number consistency (regression)', () => {
+    // A note with 3 lines of frontmatter (lines 1-3) and 5 content lines (4-8)
+    const noteWithFM = [
+        '---', // line 1
+        'title: Wishlist', // line 2
+        '---', // line 3
+        '# Wishlist', // line 4
+        '', // line 5
+        '## AI', // line 6
+        '- Feature A', // line 7
+        '- Choose AI provider', // line 8  ← user wants to delete this
+    ].join('\n');
+    const allLines = noteWithFM.split('\n');
+    it('buildLineWindow reports absolute line numbers including frontmatter', () => {
+        const window = buildLineWindow(allLines, {
+            startLine: 1,
+            endLine: 8,
+            defaultLimit: 100,
+            maxLimit: 100,
+        });
+        expect(window.lines[0]).toEqual({ line: 1, lineIndex: 0, content: '---' });
+        expect(window.lines[3]).toEqual({ line: 4, lineIndex: 3, content: '# Wishlist' });
+        expect(window.lines[7]).toEqual({ line: 8, lineIndex: 7, content: '- Choose AI provider' });
+    });
+    it('line number from buildLineWindow can be used directly for array splice', () => {
+        // Simulate: user reads note, gets line 8 = "- Choose AI provider"
+        const window = buildLineWindow(allLines, {
+            startLine: 1,
+            endLine: 8,
+            defaultLimit: 100,
+            maxLimit: 100,
+        });
+        const targetLine = window.lines.find(l => l.content === '- Choose AI provider');
+        expect(targetLine).toBeDefined();
+        expect(targetLine.line).toBe(8);
+        // Now simulate delete: splice at (line - 1) with no frontmatter offset
+        const splicedLines = [...allLines];
+        splicedLines.splice(targetLine.line - 1, 1);
+        expect(splicedLines).toEqual([
+            '---', 'title: Wishlist', '---', '# Wishlist', '', '## AI', '- Feature A',
+        ]);
+        // The deleted line should be "- Choose AI provider", not something else
+        expect(splicedLines).not.toContain('- Choose AI provider');
+    });
+    it('searching for content returns line numbers usable for deletion', () => {
+        // Simulate searchParagraphs: find "Choose AI provider", get line number
+        const window = buildLineWindow(allLines, {
+            defaultLimit: allLines.length,
+            maxLimit: allLines.length,
+        });
+        const match = window.lines.find(l => l.content.includes('Choose AI provider'));
+        expect(match).toBeDefined();
+        expect(match.line).toBe(8);
+        // Use that line number for deletion (absolute, no offset)
+        const startIndex = match.line - 1; // 0-indexed
+        expect(allLines[startIndex]).toBe('- Choose AI provider');
+    });
+    it('startLine/endLine window with frontmatter uses absolute numbering', () => {
+        // Read lines 6-8 (the AI section)
+        const window = buildLineWindow(allLines, {
+            startLine: 6,
+            endLine: 8,
+            defaultLimit: 100,
+            maxLimit: 100,
+        });
+        expect(window.lines).toEqual([
+            { line: 6, lineIndex: 5, content: '## AI' },
+            { line: 7, lineIndex: 6, content: '- Feature A' },
+            { line: 8, lineIndex: 7, content: '- Choose AI provider' },
+        ]);
+    });
+    it('note without frontmatter: line 1 is first line of content', () => {
+        const noFM = ['# Title', 'Body 1', 'Body 2'].join('\n');
+        const noFMLines = noFM.split('\n');
+        const window = buildLineWindow(noFMLines, {
+            defaultLimit: 100,
+            maxLimit: 100,
+        });
+        expect(window.lines[0]).toEqual({ line: 1, lineIndex: 0, content: '# Title' });
+        expect(window.lines[1]).toEqual({ line: 2, lineIndex: 1, content: 'Body 1' });
+    });
+});
+// ── Regression: editLine / replaceLines use absolute line numbers with frontmatter ──
+// editLine and replaceLines (in notes.ts) depend on the note store, so we can't
+// call them as pure functions here. Instead we replicate their core splice logic
+// to prove the line-index arithmetic is consistent with buildLineWindow.
+describe('editLine – frontmatter line number regression', () => {
+    const noteWithFM = [
+        '---', // line 1
+        'title: Wishlist', // line 2
+        '---', // line 3
+        '# Wishlist', // line 4
+        '', // line 5
+        '## AI', // line 6
+        '- Feature A', // line 7
+        '- Choose AI provider', // line 8
+    ].join('\n');
+    const allLines = noteWithFM.split('\n');
+    it('editing line 8 replaces "- Choose AI provider", not an offset line', () => {
+        // Mirrors editLine logic: lineIndex = params.line - 1, then splice
+        const paramLine = 8;
+        const lineIndex = paramLine - 1; // 0-indexed, no frontmatter offset
+        expect(allLines[lineIndex]).toBe('- Choose AI provider');
+        const edited = [...allLines];
+        edited.splice(lineIndex, 1, '- Choose AI provider (edited)');
+        expect(edited[lineIndex]).toBe('- Choose AI provider (edited)');
+        expect(edited).toHaveLength(allLines.length);
+    });
+    it('editing line 4 replaces "# Wishlist" (first content line after frontmatter)', () => {
+        const paramLine = 4;
+        const lineIndex = paramLine - 1;
+        expect(allLines[lineIndex]).toBe('# Wishlist');
+        const edited = [...allLines];
+        edited.splice(lineIndex, 1, '# Wishlist (renamed)');
+        expect(edited[lineIndex]).toBe('# Wishlist (renamed)');
+    });
+    it('line number from buildLineWindow can be used directly in editLine splice', () => {
+        const window = buildLineWindow(allLines, {
+            startLine: 1,
+            endLine: allLines.length,
+            defaultLimit: 100,
+            maxLimit: 100,
+        });
+        const target = window.lines.find(l => l.content === '- Feature A');
+        expect(target).toBeDefined();
+        expect(target.line).toBe(7);
+        // Use that line number exactly as editLine would
+        const lineIndex = target.line - 1;
+        expect(allLines[lineIndex]).toBe('- Feature A');
+    });
+});
+describe('replaceLines – frontmatter line number regression', () => {
+    const noteWithFM = [
+        '---', // line 1
+        'title: Wishlist', // line 2
+        '---', // line 3
+        '# Wishlist', // line 4
+        '', // line 5
+        '## AI', // line 6
+        '- Feature A', // line 7
+        '- Feature B', // line 8
+        '- Feature C', // line 9
+    ].join('\n');
+    const allLines = noteWithFM.split('\n');
+    it('replacing lines 7-9 targets the three feature lines, not offset lines', () => {
+        // Mirrors replaceLines logic: startIndex = boundedStartLine - 1
+        const startLine = 7;
+        const endLine = 9;
+        const startIndex = startLine - 1;
+        const count = endLine - startLine + 1;
+        expect(allLines.slice(startIndex, startIndex + count)).toEqual([
+            '- Feature A', '- Feature B', '- Feature C',
+        ]);
+        const replaced = [...allLines];
+        replaced.splice(startIndex, count, '- Replaced A', '- Replaced B');
+        expect(replaced[startIndex]).toBe('- Replaced A');
+        expect(replaced[startIndex + 1]).toBe('- Replaced B');
+        expect(replaced).toHaveLength(allLines.length - 1); // 3 removed, 2 added
+    });
+    it('replacing line 4 targets "# Wishlist" (first content line)', () => {
+        const startLine = 4;
+        const endLine = 4;
+        const startIndex = startLine - 1;
+        expect(allLines[startIndex]).toBe('# Wishlist');
+        const replaced = [...allLines];
+        replaced.splice(startIndex, 1, '# New Title');
+        expect(replaced[startIndex]).toBe('# New Title');
+        expect(replaced).toHaveLength(allLines.length);
+    });
+    it('line numbers from buildLineWindow can be used directly in replaceLines splice', () => {
+        const window = buildLineWindow(allLines, {
+            startLine: 1,
+            endLine: allLines.length,
+            defaultLimit: 100,
+            maxLimit: 100,
+        });
+        const first = window.lines.find(l => l.content === '- Feature A');
+        const last = window.lines.find(l => l.content === '- Feature C');
+        expect(first).toBeDefined();
+        expect(last).toBeDefined();
+        const startIndex = first.line - 1;
+        const count = last.line - first.line + 1;
+        expect(allLines.slice(startIndex, startIndex + count)).toEqual([
+            '- Feature A', '- Feature B', '- Feature C',
+        ]);
+    });
+});
+// ── Regression: getTasks → completeTask/updateTask line number round-trip ──
+// getTasks returns { lineIndex (0-based), line (1-based) } from parseTasks.
+// completeTask/updateTask accept either field and resolve via resolveTaskLineIndex.
+// These tests verify the full chain: parseTasks lineIndex includes frontmatter
+// lines, and the resolved index targets the correct line in a splice.
+// Inline copy of resolveTaskLineIndex from tasks.ts (not exported)
+function resolveTaskLineIndex(input) {
+    const numLineIndex = input.lineIndex !== undefined && input.lineIndex !== null ? Number(input.lineIndex) : NaN;
+    const numLine = input.line !== undefined && input.line !== null ? Number(input.line) : NaN;
+    const hasLineIndex = Number.isFinite(numLineIndex);
+    const hasLine = Number.isFinite(numLine);
+    if (!hasLineIndex && !hasLine) {
+        return { ok: false, error: 'Provide lineIndex (0-based) or line (1-based)' };
+    }
+    const resolvedFromLine = hasLine ? Math.floor(numLine) - 1 : undefined;
+    const resolvedFromIndex = hasLineIndex ? Math.floor(numLineIndex) : undefined;
+    if (resolvedFromLine !== undefined && resolvedFromLine < 0) {
+        return { ok: false, error: 'line must be >= 1' };
+    }
+    if (resolvedFromIndex !== undefined && resolvedFromIndex < 0) {
+        return { ok: false, error: 'lineIndex must be >= 0' };
+    }
+    return { ok: true, lineIndex: resolvedFromIndex ?? resolvedFromLine };
+}
+// Minimal parseTasks that returns lineIndex (matching markdown-parser.ts logic)
+function parseTasksMinimal(content) {
+    const lines = content.split('\n');
+    const tasks = [];
+    for (let i = 0; i < lines.length; i++) {
+        const match = lines[i].match(/^(\s*)[*+\-]\s*\[.\]\s*(.*)$/);
+        if (match) {
+            tasks.push({ lineIndex: i, content: match[2].trim() });
+        }
+    }
+    return tasks;
+}
+describe('getTasks → completeTask/updateTask – frontmatter line number regression', () => {
+    const noteWithFM = [
+        '---', // line 1 (index 0)
+        'title: Test', // line 2 (index 1)
+        '---', // line 3 (index 2)
+        '# Tasks', // line 4 (index 3)
+        '', // line 5 (index 4)
+        '* [ ] Task A', // line 6 (index 5)
+        'Some text', // line 7 (index 6)
+        '* [ ] Task B', // line 8 (index 7)
+        '* [x] Task C', // line 9 (index 8)
+    ].join('\n');
+    const allLines = noteWithFM.split('\n');
+    it('parseTasks lineIndex is absolute (includes frontmatter)', () => {
+        const tasks = parseTasksMinimal(noteWithFM);
+        expect(tasks).toHaveLength(3);
+        expect(tasks[0]).toEqual({ lineIndex: 5, content: 'Task A' });
+        expect(tasks[1]).toEqual({ lineIndex: 7, content: 'Task B' });
+        expect(tasks[2]).toEqual({ lineIndex: 8, content: 'Task C' });
+    });
+    it('getTasks line field (lineIndex + 1) is consistent with get_notes', () => {
+        const tasks = parseTasksMinimal(noteWithFM);
+        const window = buildLineWindow(allLines, {
+            defaultLimit: allLines.length,
+            maxLimit: allLines.length,
+        });
+        for (const task of tasks) {
+            const line1Based = task.lineIndex + 1; // what getTasks returns as `line`
+            const windowLine = window.lines.find(l => l.line === line1Based);
+            expect(windowLine).toBeDefined();
+            expect(windowLine.content).toContain(task.content);
+        }
+    });
+    it('resolveTaskLineIndex with lineIndex targets the correct line', () => {
+        const tasks = parseTasksMinimal(noteWithFM);
+        const taskB = tasks.find(t => t.content === 'Task B');
+        const resolved = resolveTaskLineIndex({ lineIndex: taskB.lineIndex });
+        expect(resolved.ok).toBe(true);
+        if (resolved.ok) {
+            expect(allLines[resolved.lineIndex]).toBe('* [ ] Task B');
+        }
+    });
+    it('resolveTaskLineIndex with line (1-based) targets the correct line', () => {
+        const tasks = parseTasksMinimal(noteWithFM);
+        const taskB = tasks.find(t => t.content === 'Task B');
+        const line1Based = taskB.lineIndex + 1; // what getTasks exposes
+        const resolved = resolveTaskLineIndex({ line: line1Based });
+        expect(resolved.ok).toBe(true);
+        if (resolved.ok) {
+            expect(allLines[resolved.lineIndex]).toBe('* [ ] Task B');
+        }
+    });
+    it('completeTask splice simulation: mark Task A done using lineIndex from parseTasks', () => {
+        const tasks = parseTasksMinimal(noteWithFM);
+        const taskA = tasks.find(t => t.content === 'Task A');
+        const resolved = resolveTaskLineIndex({ lineIndex: taskA.lineIndex });
+        expect(resolved.ok).toBe(true);
+        if (resolved.ok) {
+            // Simulate updateTaskStatus: replace checkbox at resolved.lineIndex
+            const lines = [...allLines];
+            expect(lines[resolved.lineIndex]).toBe('* [ ] Task A');
+            lines[resolved.lineIndex] = lines[resolved.lineIndex].replace('[ ]', '[x]');
+            expect(lines[resolved.lineIndex]).toBe('* [x] Task A');
+            // Frontmatter and other lines untouched
+            expect(lines[0]).toBe('---');
+            expect(lines[2]).toBe('---');
+            expect(lines[7]).toBe('* [ ] Task B');
+        }
+    });
+    it('updateTask splice simulation: edit Task B content using line from getTasks', () => {
+        const tasks = parseTasksMinimal(noteWithFM);
+        const taskB = tasks.find(t => t.content === 'Task B');
+        const line1Based = taskB.lineIndex + 1;
+        const resolved = resolveTaskLineIndex({ line: line1Based });
+        expect(resolved.ok).toBe(true);
+        if (resolved.ok) {
+            const lines = [...allLines];
+            expect(lines[resolved.lineIndex]).toBe('* [ ] Task B');
+            lines[resolved.lineIndex] = '* [ ] Task B (updated)';
+            expect(lines[resolved.lineIndex]).toBe('* [ ] Task B (updated)');
+            expect(lines[5]).toBe('* [ ] Task A'); // unchanged
+        }
+    });
+    it('note without frontmatter: task lineIndex still correct', () => {
+        const noFM = [
+            '# Tasks', // index 0
+            '* [ ] First', // index 1
+            '* [ ] Second', // index 2
+        ].join('\n');
+        const tasks = parseTasksMinimal(noFM);
+        expect(tasks[0].lineIndex).toBe(1);
+        expect(tasks[1].lineIndex).toBe(2);
+        const lines = noFM.split('\n');
+        expect(lines[tasks[0].lineIndex]).toBe('* [ ] First');
+        expect(lines[tasks[1].lineIndex]).toBe('* [ ] Second');
+    });
+});
+// ── Regression: endLine range handling in deleteLines / replaceLines ──
+// A user reported that endLine was ignored — multi-line ranges collapsed to a
+// single line. These tests verify that endLine is respected and that the
+// bounded range covers the expected span.
+describe('deleteLines – endLine range is respected', () => {
+    // Note with 3-line frontmatter and 7 content lines (lines 4-10)
+    const noteWithFM = [
+        '---', // line 1
+        'title: Test', // line 2
+        '---', // line 3
+        '# Heading', // line 4
+        '', // line 5
+        'Line A', // line 6
+        'Line B', // line 7
+        'Line C', // line 8
+        'Line D', // line 9
+        'Line E', // line 10
+    ].join('\n');
+    const allLines = noteWithFM.split('\n');
+    const totalLineCount = allLines.length;
+    const fmLineCount = 3;
+    const minLine = fmLineCount + 1; // 4
+    it('startLine=6, endLine=8 deletes 3 lines (Line A, B, C)', () => {
+        const boundedStartLine = toBoundedInt(6, minLine, minLine, Math.max(minLine, totalLineCount));
+        const boundedEndLine = toBoundedInt(8, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, totalLineCount));
+        expect(boundedStartLine).toBe(6);
+        expect(boundedEndLine).toBe(8);
+        const lineCountToDelete = boundedEndLine - boundedStartLine + 1;
+        expect(lineCountToDelete).toBe(3);
+        const deletedLines = allLines.slice(boundedStartLine - 1, boundedEndLine);
+        expect(deletedLines).toEqual(['Line A', 'Line B', 'Line C']);
+    });
+    it('startLine=6, endLine=6 deletes exactly 1 line', () => {
+        const boundedStartLine = toBoundedInt(6, minLine, minLine, Math.max(minLine, totalLineCount));
+        const boundedEndLine = toBoundedInt(6, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, totalLineCount));
+        expect(boundedEndLine - boundedStartLine + 1).toBe(1);
+        expect(allLines[boundedStartLine - 1]).toBe('Line A');
+    });
+    it('startLine=9, endLine=10 deletes last 2 lines', () => {
+        const boundedStartLine = toBoundedInt(9, minLine, minLine, Math.max(minLine, totalLineCount));
+        const boundedEndLine = toBoundedInt(10, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, totalLineCount));
+        expect(boundedStartLine).toBe(9);
+        expect(boundedEndLine).toBe(10);
+        expect(boundedEndLine - boundedStartLine + 1).toBe(2);
+        expect(allLines.slice(boundedStartLine - 1, boundedEndLine)).toEqual(['Line D', 'Line E']);
+    });
+    it('endLine beyond total lines is clamped to last line', () => {
+        const boundedStartLine = toBoundedInt(9, minLine, minLine, Math.max(minLine, totalLineCount));
+        const boundedEndLine = toBoundedInt(99, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, totalLineCount));
+        expect(boundedEndLine).toBe(10); // clamped to totalLineCount
+        expect(boundedEndLine - boundedStartLine + 1).toBe(2);
+    });
+    it('endLine passed as string is correctly parsed', () => {
+        const boundedStartLine = toBoundedInt(6, minLine, minLine, Math.max(minLine, totalLineCount));
+        const boundedEndLine = toBoundedInt('8', boundedStartLine, boundedStartLine, Math.max(boundedStartLine, totalLineCount));
+        expect(boundedEndLine).toBe(8);
+        expect(boundedEndLine - boundedStartLine + 1).toBe(3);
+    });
+    it('endLine passed as undefined collapses range to single line (default)', () => {
+        const boundedStartLine = toBoundedInt(6, minLine, minLine, Math.max(minLine, totalLineCount));
+        const boundedEndLine = toBoundedInt(undefined, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, totalLineCount));
+        // undefined → NaN → falls back to default (boundedStartLine)
+        expect(boundedEndLine).toBe(boundedStartLine);
+        expect(boundedEndLine - boundedStartLine + 1).toBe(1);
+    });
+});
+describe('replaceLines – endLine range is respected', () => {
+    const noteWithFM = [
+        '---', // line 1
+        'title: Test', // line 2
+        '---', // line 3
+        '# Heading', // line 4
+        'Line A', // line 5
+        'Line B', // line 6
+        'Line C', // line 7
+        'Line D', // line 8
+    ].join('\n');
+    const allLines = noteWithFM.split('\n');
+    const originalLineCount = allLines.length;
+    const fmLineCount = 3;
+    const minLine = fmLineCount + 1;
+    it('startLine=5, endLine=7 replaces 3 lines (Line A, B, C)', () => {
+        const boundedStartLine = toBoundedInt(5, minLine, minLine, Math.max(minLine, originalLineCount));
+        const boundedEndLine = toBoundedInt(7, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, originalLineCount));
+        expect(boundedStartLine).toBe(5);
+        expect(boundedEndLine).toBe(7);
+        const startIndex = boundedStartLine - 1;
+        const lineCountToReplace = boundedEndLine - boundedStartLine + 1;
+        expect(lineCountToReplace).toBe(3);
+        const replacedText = allLines.slice(startIndex, boundedEndLine);
+        expect(replacedText).toEqual(['Line A', 'Line B', 'Line C']);
+        // Simulate splice with replacement content
+        const result = [...allLines];
+        result.splice(startIndex, lineCountToReplace, 'Replaced A', 'Replaced B');
+        expect(result).toEqual([
+            '---', 'title: Test', '---', '# Heading',
+            'Replaced A', 'Replaced B', 'Line D',
+        ]);
+    });
+    it('startLine=5, endLine=5 replaces exactly 1 line', () => {
+        const boundedStartLine = toBoundedInt(5, minLine, minLine, Math.max(minLine, originalLineCount));
+        const boundedEndLine = toBoundedInt(5, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, originalLineCount));
+        const lineCountToReplace = boundedEndLine - boundedStartLine + 1;
+        expect(lineCountToReplace).toBe(1);
+        expect(allLines[boundedStartLine - 1]).toBe('Line A');
+    });
+    it('endLine passed as string is correctly parsed', () => {
+        const boundedStartLine = toBoundedInt(5, minLine, minLine, Math.max(minLine, originalLineCount));
+        const boundedEndLine = toBoundedInt('7', boundedStartLine, boundedStartLine, Math.max(boundedStartLine, originalLineCount));
+        expect(boundedEndLine).toBe(7);
+        expect(boundedEndLine - boundedStartLine + 1).toBe(3);
+    });
+    it('endLine passed as undefined collapses range to single line (default)', () => {
+        const boundedStartLine = toBoundedInt(5, minLine, minLine, Math.max(minLine, originalLineCount));
+        const boundedEndLine = toBoundedInt(undefined, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, originalLineCount));
+        expect(boundedEndLine).toBe(boundedStartLine);
+        expect(boundedEndLine - boundedStartLine + 1).toBe(1);
+    });
+});
+// ── Regression: MCP dispatch — missing endLine must not silently collapse range ──
+// The MCP tool schema only requires "action", so startLine/endLine may arrive as
+// undefined when the client omits them. The functions should either reject the
+// call or preserve the intended range — NOT silently collapse to a single line.
+//
+// These tests simulate the exact parameter shapes that MCP delivers to
+// deleteLines/replaceLines (via `args as any`) and verify correct behavior.
+describe('deleteLines – MCP param validation: missing endLine', () => {
+    const fmLineCount = 3;
+    const totalLineCount = 10;
+    const minLine = fmLineCount + 1;
+    it('rejects missing endLine instead of silently collapsing range', () => {
+        // Simulate: MCP delivers { startLine: 6 } with no endLine
+        const params = { startLine: 6 };
+        // Validate the same way deleteLines should: endLine must be a finite number
+        const endLineNum = params.endLine !== undefined && params.endLine !== null ? Number(params.endLine) : NaN;
+        expect(Number.isFinite(endLineNum)).toBe(false); // undefined → NaN → not finite
+        // The function should detect this and return an error, not silently collapse
+        const startLineNum = params.startLine !== undefined && params.startLine !== null ? Number(params.startLine) : NaN;
+        expect(Number.isFinite(startLineNum)).toBe(true); // startLine is valid
+    });
+    it('valid endLine as number is preserved in range', () => {
+        const params = { startLine: 6, endLine: 8 };
+        const boundedStartLine = toBoundedInt(params.startLine, minLine, minLine, Math.max(minLine, totalLineCount));
+        const boundedEndLine = toBoundedInt(params.endLine, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, totalLineCount));
+        expect(boundedStartLine).toBe(6);
+        expect(boundedEndLine).toBe(8);
+        expect(boundedEndLine - boundedStartLine + 1).toBe(3);
+    });
+    it('valid endLine as string (MCP coercion) is preserved in range', () => {
+        const params = { startLine: 6, endLine: '8' };
+        const boundedStartLine = toBoundedInt(params.startLine, minLine, minLine, Math.max(minLine, totalLineCount));
+        const boundedEndLine = toBoundedInt(params.endLine, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, totalLineCount));
+        expect(boundedEndLine).toBe(8);
+        expect(boundedEndLine - boundedStartLine + 1).toBe(3);
+    });
+});
+describe('replaceLines – MCP param validation: missing endLine', () => {
+    const fmLineCount = 3;
+    const originalLineCount = 8;
+    const minLine = fmLineCount + 1;
+    it('rejects missing endLine instead of silently collapsing range', () => {
+        const params = { startLine: 5 };
+        const endLineNum = params.endLine !== undefined && params.endLine !== null ? Number(params.endLine) : NaN;
+        expect(Number.isFinite(endLineNum)).toBe(false);
+        const startLineNum = params.startLine !== undefined && params.startLine !== null ? Number(params.startLine) : NaN;
+        expect(Number.isFinite(startLineNum)).toBe(true);
+    });
+    it('valid endLine as number is preserved in range', () => {
+        const params = { startLine: 5, endLine: 7 };
+        const boundedStartLine = toBoundedInt(params.startLine, minLine, minLine, Math.max(minLine, originalLineCount));
+        const boundedEndLine = toBoundedInt(params.endLine, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, originalLineCount));
+        expect(boundedStartLine).toBe(5);
+        expect(boundedEndLine).toBe(7);
+        expect(boundedEndLine - boundedStartLine + 1).toBe(3);
+    });
+});
+// ── Regression: frontmatter protection guards ──
+// editLine, deleteLines, and replaceLines must reject or clamp attempts to
+// modify frontmatter lines. These tests verify the guard logic directly.
+describe('editLine – frontmatter protection', () => {
+    const noteWithFM = [
+        '---', // line 1 (index 0)
+        'title: Test', // line 2 (index 1)
+        '---', // line 3 (index 2)
+        '# Heading', // line 4 (index 3)
+        '* [ ] Task A', // line 5 (index 4)
+    ].join('\n');
+    const allLines = noteWithFM.split('\n');
+    const fmLineCount = 3; // lines 1-3 are frontmatter
+    it('rejects editing line 1 (opening ---)', () => {
+        const lineIndex = 1 - 1; // line 1 → index 0
+        expect(fmLineCount > 0 && lineIndex < fmLineCount).toBe(true);
+    });
+    it('rejects editing line 2 (frontmatter content)', () => {
+        const lineIndex = 2 - 1;
+        expect(fmLineCount > 0 && lineIndex < fmLineCount).toBe(true);
+    });
+    it('rejects editing line 3 (closing ---)', () => {
+        const lineIndex = 3 - 1;
+        expect(fmLineCount > 0 && lineIndex < fmLineCount).toBe(true);
+    });
+    it('allows editing line 4 (first content line after frontmatter)', () => {
+        const lineIndex = 4 - 1;
+        const rejected = fmLineCount > 0 && lineIndex < fmLineCount;
+        expect(rejected).toBe(false);
+        expect(allLines[lineIndex]).toBe('# Heading');
+    });
+});
+describe('deleteLines – frontmatter protection via clamping', () => {
+    const noteWithFM = [
+        '---', // line 1
+        'title: Test', // line 2
+        '---', // line 3
+        '# Heading', // line 4
+        'Body line 1', // line 5
+        'Body line 2', // line 6
+    ].join('\n');
+    const allLines = noteWithFM.split('\n');
+    const totalLineCount = allLines.length;
+    const fmLineCount = 3;
+    const minLine = fmLineCount + 1; // 4
+    it('clamps startLine=1 up to first content line', () => {
+        // Simulate: user passes startLine=1, endLine=1 (trying to delete frontmatter)
+        const boundedStartLine = toBoundedInt(1, minLine, minLine, Math.max(minLine, totalLineCount));
+        expect(boundedStartLine).toBe(4); // clamped to first content line
+        expect(allLines[boundedStartLine - 1]).toBe('# Heading');
+    });
+    it('clamps startLine=3 up to first content line', () => {
+        const boundedStartLine = toBoundedInt(3, minLine, minLine, Math.max(minLine, totalLineCount));
+        expect(boundedStartLine).toBe(4);
+    });
+    it('does not clamp startLine=4 (already at first content line)', () => {
+        const boundedStartLine = toBoundedInt(4, minLine, minLine, Math.max(minLine, totalLineCount));
+        expect(boundedStartLine).toBe(4);
+    });
+    it('does not clamp startLine=5 (beyond frontmatter)', () => {
+        const boundedStartLine = toBoundedInt(5, minLine, minLine, Math.max(minLine, totalLineCount));
+        expect(boundedStartLine).toBe(5);
+        expect(allLines[boundedStartLine - 1]).toBe('Body line 1');
+    });
+    it('range startLine=1 endLine=6 gets clamped to 4-6 (frontmatter protected)', () => {
+        const boundedStartLine = toBoundedInt(1, minLine, minLine, Math.max(minLine, totalLineCount));
+        const boundedEndLine = toBoundedInt(6, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, totalLineCount));
+        expect(boundedStartLine).toBe(4);
+        expect(boundedEndLine).toBe(6);
+        const deletedLines = allLines.slice(boundedStartLine - 1, boundedEndLine);
+        expect(deletedLines).toEqual(['# Heading', 'Body line 1', 'Body line 2']);
+    });
+});
+describe('replaceLines – frontmatter protection via clamping', () => {
+    const noteWithFM = [
+        '---', // line 1
+        'title: Test', // line 2
+        '---', // line 3
+        '# Heading', // line 4
+        'Body line 1', // line 5
+    ].join('\n');
+    const allLines = noteWithFM.split('\n');
+    const totalLineCount = allLines.length;
+    const fmLineCount = 3;
+    const minLine = fmLineCount + 1;
+    it('clamps startLine=1 up to first content line', () => {
+        const boundedStartLine = toBoundedInt(1, minLine, minLine, Math.max(minLine, totalLineCount));
+        expect(boundedStartLine).toBe(4);
+    });
+    it('safety-net check rejects if startLine somehow lands inside frontmatter', () => {
+        // This shouldn't happen due to clamping, but test the guard anyway
+        const hypotheticalStartLine = 2; // inside frontmatter
+        expect(hypotheticalStartLine <= fmLineCount).toBe(true);
+    });
+    it('allows replacing line 4 (first content line)', () => {
+        const boundedStartLine = toBoundedInt(4, minLine, minLine, Math.max(minLine, totalLineCount));
+        expect(boundedStartLine).toBe(4);
+        expect(boundedStartLine <= fmLineCount).toBe(false);
+        expect(allLines[boundedStartLine - 1]).toBe('# Heading');
+    });
+    it('note without frontmatter: minLine is 1, no clamping needed', () => {
+        const noFM = ['# Title', 'Body'].join('\n');
+        const noFMLines = noFM.split('\n');
+        const noFMCount = 0; // no frontmatter
+        const noFMMin = noFMCount > 0 ? noFMCount + 1 : 1;
+        expect(noFMMin).toBe(1);
+        const boundedStartLine = toBoundedInt(1, noFMMin, noFMMin, noFMLines.length);
+        expect(boundedStartLine).toBe(1);
+        expect(noFMLines[boundedStartLine - 1]).toBe('# Title');
+    });
+});
+// ---------------------------------------------------------------------------
+// matchesFrontmatterProperties — edge cases for developer report
+// ---------------------------------------------------------------------------
+describe('matchesFrontmatterProperties – property filter edge cases', () => {
+    const makeNote = (content) => ({
+        id: 'test-id',
+        title: 'Test Note',
+        filename: 'test.md',
+        type: 'note',
+        source: 'local',
+        folder: '',
+        content,
+        modifiedAt: new Date(),
+        createdAt: new Date(),
+        spaceId: undefined,
+        date: undefined,
+    });
+    it('matches quoted property value: type: "book" matches filter {type: "book"}', () => {
+        const note = makeNote('---\ntype: "book"\n---\nContent');
+        expect(matchesFrontmatterProperties(note, [['type', 'book']], false)).toBe(true);
+    });
+    it('matches quoted filter against unquoted value: filter "book" matches type: book', () => {
+        const note = makeNote('---\ntype: book\n---\nContent');
+        expect(matchesFrontmatterProperties(note, [['type', '"book"']], false)).toBe(true);
+    });
+    it('matches single-quoted property value', () => {
+        const note = makeNote("---\ntype: 'book'\n---\nContent");
+        expect(matchesFrontmatterProperties(note, [['type', 'book']], false)).toBe(true);
+    });
+    it('matches semicolon-separated list values', () => {
+        const note = makeNote('---\ncategories: fiction;non-fiction;book\n---\nContent');
+        expect(matchesFrontmatterProperties(note, [['categories', 'book']], false)).toBe(true);
+    });
+    it('matches semicolon-separated list with spaces', () => {
+        const note = makeNote('---\ncategories: fiction; book; novel\n---\nContent');
+        expect(matchesFrontmatterProperties(note, [['categories', 'book']], false)).toBe(true);
+    });
+    it('does not match empty property value against non-empty filter', () => {
+        const note = makeNote('---\ntype: \n---\nContent');
+        expect(matchesFrontmatterProperties(note, [['type', 'book']], false)).toBe(false);
+    });
+    it('does not match when property value is whitespace-only', () => {
+        const note = makeNote('---\ntype:   \n---\nContent');
+        expect(matchesFrontmatterProperties(note, [['type', 'book']], false)).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// getNote id/filename resolution — regression test
+// ---------------------------------------------------------------------------
+// We test the getNote logic by importing the function and mocking the readers.
+// Since getNote depends on sqliteReader and fileReader, we use vi.mock.
+import { getNote } from '../noteplan/unified-store.js';
+import * as sqliteReader from '../noteplan/sqlite-reader.js';
+import * as fileReader from '../noteplan/file-reader.js';
+vi.mock('../noteplan/sqlite-reader.js', () => ({
+    getSpaceNote: vi.fn(),
+    listSpaces: vi.fn(() => []),
+    listSpaceNotes: vi.fn(() => []),
+    searchSpaceNotesFTS: vi.fn(() => []),
+    getSpaceNoteByTitle: vi.fn(),
+    getSpaceCalendarNote: vi.fn(),
+    listSpaceFolders: vi.fn(() => []),
+    extractSpaceTags: vi.fn(() => []),
+    resolveSpaceFolder: vi.fn(),
+    isSpaceNoteInTrash: vi.fn(),
+    countSpaceFolderContents: vi.fn(() => ({ noteCount: 0, folderCount: 0 })),
+}));
+vi.mock('../noteplan/file-reader.js', () => ({
+    readNoteFile: vi.fn(),
+    getCalendarNote: vi.fn(),
+    getNoteByTitle: vi.fn(),
+    listProjectNotes: vi.fn(() => []),
+    listCalendarNotes: vi.fn(() => []),
+    listFolders: vi.fn(() => []),
+    searchLocalNotes: vi.fn(() => []),
+    getNotesPath: vi.fn(() => '/tmp/notes'),
+    extractAllTags: vi.fn(() => []),
+    countNotesInDirectory: vi.fn(() => ({ noteCount: 0, folderCount: 0 })),
+}));
+vi.mock('../noteplan/file-writer.js', () => ({}));
+vi.mock('../noteplan/sqlite-writer.js', () => ({}));
+vi.mock('./ripgrep-search.js', () => ({
+    isRipgrepAvailable: vi.fn(() => Promise.resolve(false)),
+    searchWithRipgrep: vi.fn(),
+}));
+vi.mock('../noteplan/fuzzy-search.js', () => ({
+    fuzzySearch: vi.fn(() => []),
+}));
+describe('getNote id/filename resolution', () => {
+    const localNote = {
+        id: 'Notes/Books/my-book.md',
+        title: 'My Book',
+        filename: 'Notes/Books/my-book.md',
+        type: 'note',
+        source: 'local',
+        folder: 'Books',
+        content: '---\ntype: book\n---\n# My Book\nContent here',
+        modifiedAt: new Date(),
+        createdAt: new Date(),
+        spaceId: undefined,
+        date: undefined,
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('retrieves a local note via id when SQLite lookup returns null', () => {
+        vi.mocked(sqliteReader.getSpaceNote).mockReturnValue(null);
+        vi.mocked(fileReader.readNoteFile).mockReturnValue(localNote);
+        const result = getNote({ id: 'Notes/Books/my-book.md' });
+        expect(result).toEqual(localNote);
+        expect(sqliteReader.getSpaceNote).toHaveBeenCalledWith('Notes/Books/my-book.md');
+        expect(fileReader.readNoteFile).toHaveBeenCalledWith('Notes/Books/my-book.md');
+    });
+    it('retrieves a local note via filename', () => {
+        vi.mocked(fileReader.readNoteFile).mockReturnValue(localNote);
+        const result = getNote({ filename: 'Notes/Books/my-book.md' });
+        expect(result).toEqual(localNote);
+    });
+    it('id and filename return the same note for local notes', () => {
+        vi.mocked(sqliteReader.getSpaceNote).mockReturnValue(null);
+        vi.mocked(fileReader.readNoteFile).mockReturnValue(localNote);
+        const byId = getNote({ id: localNote.filename });
+        const byFilename = getNote({ filename: localNote.filename });
+        expect(byId).toEqual(byFilename);
+    });
+    it('returns null for non-existent id', () => {
+        vi.mocked(sqliteReader.getSpaceNote).mockReturnValue(null);
+        vi.mocked(fileReader.readNoteFile).mockReturnValue(null);
+        const result = getNote({ id: 'Notes/nonexistent.md' });
+        expect(result).toBeNull();
+    });
+    it('prefers space note when SQLite lookup succeeds', () => {
+        const spaceNote = { ...localNote, source: 'space', id: 'space-uuid-123' };
+        vi.mocked(sqliteReader.getSpaceNote).mockReturnValue(spaceNote);
+        const result = getNote({ id: 'space-uuid-123' });
+        expect(result).toEqual(spaceNote);
+        expect(fileReader.readNoteFile).not.toHaveBeenCalled();
+    });
+});
+// ---------------------------------------------------------------------------
+// Issue #2 verification: searchLocalNotes with colons in query
+// searchLocalNotes uses a simple content.toLowerCase().includes(query) check.
+// This verifies colons in the query don't cause matching failures.
+// ---------------------------------------------------------------------------
+describe('searchLocalNotes – colon in query (issue #2 verification)', () => {
+    // Replicate the matching logic from file-reader.ts searchLocalNotes
+    function matchesSearchQuery(note, query) {
+        const lowerQuery = query.toLowerCase();
+        return (note.content.toLowerCase().includes(lowerQuery) ||
+            note.title.toLowerCase().includes(lowerQuery));
+    }
+    it('finds notes containing "type: book" when query includes a colon', () => {
+        const note = {
+            content: '---\ntype: book\n---\n# My Book\nSome content',
+            title: 'My Book',
+        };
+        expect(matchesSearchQuery(note, 'type: book')).toBe(true);
+    });
+    it('finds notes containing "articles:" when query ends with a colon', () => {
+        const note = {
+            content: '---\ntitle: Reading List\narticles: yes\n---\n# Reading List',
+            title: 'Reading List',
+        };
+        expect(matchesSearchQuery(note, 'articles:')).toBe(true);
+    });
+    it('colon in query does not cause false positives', () => {
+        const note = {
+            content: '---\ntype: article\n---\n# Article\nSome content',
+            title: 'Article',
+        };
+        expect(matchesSearchQuery(note, 'type: book')).toBe(false);
+    });
+    it('matches colon query case-insensitively', () => {
+        const note = {
+            content: '---\nType: Book\n---\n# My Book',
+            title: 'My Book',
+        };
+        expect(matchesSearchQuery(note, 'type: book')).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// Issue #3 verification: searchParagraphsGlobal finds frontmatter text
+// searchParagraphsGlobal iterates ALL lines of a note (including frontmatter).
+// This verifies frontmatter lines are not skipped during paragraph search.
+// ---------------------------------------------------------------------------
+describe('searchParagraphsGlobal – frontmatter text matching (issue #3 verification)', () => {
+    // Replicate the core line-matching logic from searchParagraphsGlobal in notes.ts
+    function findMatchingLines(content, query, caseSensitive = false) {
+        const normalizedQuery = caseSensitive ? query : query.toLowerCase();
+        const lines = content.split('\n');
+        const matches = [];
+        for (let i = 0; i < lines.length; i++) {
+            const lineText = caseSensitive ? lines[i] : lines[i].toLowerCase();
+            if (lineText.includes(normalizedQuery)) {
+                matches.push({ lineIndex: i, line: i + 1, content: lines[i] });
+            }
+        }
+        return matches;
+    }
+    it('finds "type: book" in frontmatter lines', () => {
+        const content = '---\ntype: book\nauthor: Someone\n---\n# My Book\nContent';
+        const matches = findMatchingLines(content, 'type: book');
+        expect(matches.length).toBeGreaterThan(0);
+        expect(matches[0].content).toBe('type: book');
+        expect(matches[0].line).toBe(2); // line 2 in the frontmatter
+    });
+    it('finds frontmatter property among all note lines', () => {
+        const content = '---\ntags: fiction, novel\nstatus: reading\n---\n# Novel\nGreat book';
+        const matches = findMatchingLines(content, 'status: reading');
+        expect(matches).toHaveLength(1);
+        expect(matches[0].lineIndex).toBe(2); // 0-indexed: ---(0), tags(1), status(2)
+    });
+    it('does not skip the opening --- delimiter', () => {
+        const content = '---\ntype: book\n---\n# Title';
+        const matches = findMatchingLines(content, '---');
+        // Should find both the opening and closing ---
+        expect(matches.length).toBe(2);
+        expect(matches[0].line).toBe(1);
+        expect(matches[1].line).toBe(3);
+    });
+    it('finds matches in both frontmatter and body', () => {
+        const content = '---\nnote: book review\n---\n# Book Review\nThis is a book review.';
+        const matches = findMatchingLines(content, 'book review');
+        expect(matches.length).toBe(3); // frontmatter line, heading, body line
+    });
+    it('returns empty when query does not match any line', () => {
+        const content = '---\ntype: article\n---\n# Article\nSome content';
+        const matches = findMatchingLines(content, 'type: book');
+        expect(matches).toHaveLength(0);
+    });
+});
+// ── Manual test procedure for frontmatter line consistency ──
+// Run this against a live NotePlan MCP server to verify read/write consistency.
+//
+// SETUP: Create a test note with frontmatter:
+//   noteplan_manage_note(action="create", title="FM Line Test", content=`
+//   ---
+//   test: true
+//   ---
+//   # FM Line Test
+//
+//   Line A
+//   Line B
+//   Line C
+//   `)
+//
+// TEST 1: Read and verify line numbers
+//   noteplan_get_notes(filename="...", includeContent=true)
+//   → Verify: "---" is line 1, "# FM Line Test" is line 4, "Line A" is line 6
+//
+// TEST 2: Search and verify line numbers match
+//   noteplan_paragraphs(action="search", filename="...", query="Line B")
+//   → Verify: result.line matches get_notes line for "Line B" (should be 7)
+//
+// TEST 3: Delete using the line number from search
+//   noteplan_edit_content(action="delete_lines", filename="...", startLine=7, endLine=7, dryRun=true)
+//   → Verify: dry run preview shows "Line B", NOT a different line
+//   → If preview shows wrong content, the frontmatter offset bug has regressed!
+//
+// TEST 4: Edit a line using absolute number
+//   noteplan_edit_content(action="edit_line", filename="...", line=6, content="Line A (edited)")
+//   → Verify: "Line A" was changed, not a different line
+//
+// TEST 5: Replace lines using absolute numbers
+//   noteplan_edit_content(action="replace_lines", filename="...", startLine=6, endLine=8,
+//     content="Replaced A\nReplaced B\nReplaced C", dryRun=true)
+//   → Verify: preview shows "Line A", "Line B", "Line C" being replaced
+//
+// TEST 6: Insert at absolute line
+//   noteplan_edit_content(action="insert", filename="...", position="at-line", line=6,
+//     content="Inserted before Line A")
+//   → Verify: new line appears at line 6, "Line A" moves to line 7
+//
+// TEST 7: Frontmatter protection
+//   noteplan_edit_content(action="delete_lines", filename="...", startLine=1, endLine=3)
+//   → Verify: returns error about frontmatter protection, does NOT delete
+//
+// CLEANUP:
+//   noteplan_manage_note(action="delete", filename="...")
+//
 //# sourceMappingURL=notes.test.js.map