@noteplanco/noteplan-mcp 1.1.23 → 1.1.24

package/dist/tools/notes.test.js

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 // Mock preferences before importing markdown-parser (which reads UserDefaults at runtime)
 vi.mock('../noteplan/preferences.js', () => ({
     getTaskMarkerConfigCached: vi.fn(() => ({
@@ -1384,7 +1384,7 @@ describe('matchesFrontmatterProperties – property filter edge cases', () => {
 // ---------------------------------------------------------------------------
 // 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 { getNote, listNotes } 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', () => ({
@@ -1438,36 +1438,36 @@ describe('getNote id/filename resolution', () => {
     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' });
+    it('retrieves a local note via id when SQLite lookup returns null', async () => {
+        vi.mocked(sqliteReader.getSpaceNote).mockResolvedValue(null);
+        vi.mocked(fileReader.readNoteFile).mockResolvedValue(localNote);
+        const result = await 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' });
+    it('retrieves a local note via filename', async () => {
+        vi.mocked(fileReader.readNoteFile).mockResolvedValue(localNote);
+        const result = await 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 });
+    it('id and filename return the same note for local notes', async () => {
+        vi.mocked(sqliteReader.getSpaceNote).mockResolvedValue(null);
+        vi.mocked(fileReader.readNoteFile).mockResolvedValue(localNote);
+        const byId = await getNote({ id: localNote.filename });
+        const byFilename = await 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' });
+    it('returns null for non-existent id', async () => {
+        vi.mocked(sqliteReader.getSpaceNote).mockResolvedValue(null);
+        vi.mocked(fileReader.readNoteFile).mockResolvedValue(null);
+        const result = await getNote({ id: 'Notes/nonexistent.md' });
         expect(result).toBeNull();
     });
-    it('prefers space note when SQLite lookup succeeds', () => {
+    it('prefers space note when SQLite lookup succeeds', async () => {
         const spaceNote = { ...localNote, source: 'space', id: 'space-uuid-123' };
-        vi.mocked(sqliteReader.getSpaceNote).mockReturnValue(spaceNote);
-        const result = getNote({ id: 'space-uuid-123' });
+        vi.mocked(sqliteReader.getSpaceNote).mockResolvedValue(spaceNote);
+        const result = await getNote({ id: 'space-uuid-123' });
         expect(result).toEqual(spaceNote);
         expect(fileReader.readNoteFile).not.toHaveBeenCalled();
     });
@@ -2477,4 +2477,225 @@ describe('title resolution for search – frontmatter title takes priority', ()
         expect(matchesTitleOrFilename(note, 'knuth reviewer')).toBe(true);
     });
 });
+// ── listNotes — folder scope inside a space (regression: PR #6 by @steinwaywhw) ──
+// Ported from PR #6 to the post-bridge async architecture.
+describe('listNotes – folder scope inside a space', () => {
+    const spaceId = 'space-001';
+    const folderId = 'folder-001';
+    const noteInFolder = {
+        id: 'note-in-folder',
+        title: 'Project Alpha',
+        filename: `%%NotePlanCloud%%/${spaceId}/${folderId}/note-in-folder`,
+        type: 'note',
+        source: 'space',
+        folder: folderId,
+        content: '# Project Alpha',
+        modifiedAt: new Date(),
+        createdAt: new Date(),
+        spaceId,
+    };
+    const noteInOtherFolder = {
+        ...noteInFolder,
+        id: 'note-other',
+        title: 'Other Note',
+        folder: 'folder-002',
+        filename: `%%NotePlanCloud%%/${spaceId}/folder-002/note-other`,
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(sqliteReader.listSpaces).mockResolvedValue([
+            { id: spaceId, name: 'My Space', noteCount: 2 },
+        ]);
+        vi.mocked(sqliteReader.listSpaceNotes).mockResolvedValue([noteInFolder, noteInOtherFolder]);
+    });
+    it('returns only notes in the resolved folder', async () => {
+        vi.mocked(sqliteReader.resolveSpaceFolder).mockResolvedValue({
+            id: folderId,
+            path: 'Active Projects',
+            name: 'Active Projects',
+            source: 'space',
+            spaceId,
+        });
+        const result = await listNotes({ folder: 'Active Projects', space: 'My Space' });
+        expect(result.map((n) => n.title)).toEqual(['Project Alpha']);
+        expect(sqliteReader.resolveSpaceFolder).toHaveBeenCalledWith(spaceId, 'Active Projects');
+    });
+    it('returns empty when the folder does not resolve in the space', async () => {
+        vi.mocked(sqliteReader.resolveSpaceFolder).mockResolvedValue(null);
+        const result = await listNotes({ folder: 'Nonexistent', space: 'My Space' });
+        expect(result).toHaveLength(0);
+    });
+    it('returns all space notes when no folder is specified', async () => {
+        const result = await listNotes({ space: 'My Space' });
+        expect(result).toHaveLength(2);
+        expect(sqliteReader.resolveSpaceFolder).not.toHaveBeenCalled();
+    });
+});
+// ---------------------------------------------------------------------------
+// Folder access rules — read-side filtering in unified-store
+// ---------------------------------------------------------------------------
+import { searchNotes, listFolders, listTags, getCalendarNote, invalidateListingCaches } from '../noteplan/unified-store.js';
+import { __resetFolderAccessConfigForTests } from '../utils/folder-access.js';
+describe('folder-access read-side filtering', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        delete process.env.NOTEPLAN_ALLOWED_FOLDERS;
+        delete process.env.NOTEPLAN_DENIED_FOLDERS;
+        __resetFolderAccessConfigForTests();
+        // The listNotes cache is module-level so a previous test's filtered
+        // result would leak into this one. Reset before every case.
+        invalidateListingCaches();
+        // Reset readers to safe defaults — individual tests override.
+        vi.mocked(sqliteReader.listSpaces).mockResolvedValue([]);
+        vi.mocked(sqliteReader.listSpaceNotes).mockResolvedValue([]);
+        vi.mocked(sqliteReader.searchSpaceNotesFTS).mockResolvedValue({ results: [], backend: 'sqlite' });
+        vi.mocked(fileReader.listProjectNotes).mockResolvedValue([]);
+        vi.mocked(fileReader.listCalendarNotes).mockResolvedValue([]);
+        vi.mocked(fileReader.searchLocalNotes).mockResolvedValue([]);
+        vi.mocked(fileReader.readNoteFile).mockResolvedValue(null);
+    });
+    afterEach(() => {
+        delete process.env.NOTEPLAN_ALLOWED_FOLDERS;
+        delete process.env.NOTEPLAN_DENIED_FOLDERS;
+        __resetFolderAccessConfigForTests();
+    });
+    it('listNotes drops notes inside a denied folder', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        const personal = {
+            id: 'Notes/Personal/Diary.md',
+            title: 'Diary',
+            filename: 'Notes/Personal/Diary.md',
+            type: 'note',
+            source: 'local',
+            folder: 'Notes/Personal',
+            content: '',
+            modifiedAt: new Date(),
+            createdAt: new Date(),
+            spaceId: undefined,
+        };
+        const work = { ...personal, id: 'Notes/Work/Plan.md', filename: 'Notes/Work/Plan.md', folder: 'Notes/Work', title: 'Plan' };
+        vi.mocked(fileReader.listProjectNotes).mockResolvedValue([personal, work]);
+        const result = await listNotes();
+        expect(result.map((n) => n.filename)).toEqual(['Notes/Work/Plan.md']);
+    });
+    it('getNote returns null for a denied filename even if the reader has it', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        const personal = {
+            id: 'Notes/Personal/Diary.md',
+            title: 'Diary',
+            filename: 'Notes/Personal/Diary.md',
+            type: 'note',
+            source: 'local',
+            folder: 'Notes/Personal',
+            content: '',
+            modifiedAt: new Date(),
+            createdAt: new Date(),
+            spaceId: undefined,
+        };
+        vi.mocked(fileReader.readNoteFile).mockResolvedValue(personal);
+        vi.mocked(sqliteReader.getSpaceNote).mockResolvedValue(null);
+        const result = await getNote({ filename: 'Notes/Personal/Diary.md' });
+        expect(result).toBeNull();
+    });
+    it('searchNotes filters denied folders out of the result set', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        const personal = {
+            id: 'Notes/Personal/Diary.md',
+            title: 'Diary about work',
+            filename: 'Notes/Personal/Diary.md',
+            type: 'note',
+            source: 'local',
+            folder: 'Notes/Personal',
+            content: 'meeting work plan',
+            modifiedAt: new Date(),
+            createdAt: new Date(),
+            spaceId: undefined,
+        };
+        const work = { ...personal, id: 'Notes/Work/Plan.md', filename: 'Notes/Work/Plan.md', folder: 'Notes/Work', title: 'Diary at Work' };
+        // Use the metadata-search branch (searchField=title) so we don't need to
+        // wrangle the ripgrep mock — same filter site applies.
+        vi.mocked(fileReader.listProjectNotes).mockResolvedValue([personal, work]);
+        const result = await searchNotes('diary', { searchField: 'title' });
+        // Both notes have "diary" in their title; the denied one must be filtered out.
+        expect(result.results.map((r) => r.note.filename)).toEqual(['Notes/Work/Plan.md']);
+    });
+    // Folder *listings* themselves used to leak — `noteplan_folders(action: list/find/resolve)`
+    // would return a denied folder by name. The fix prepends `Notes/` to the folder's relative
+    // path so the same env-var match works ("Notes/Personal" rule against `Personal/Diary`).
+    it('listFolders drops local folders inside a denied subtree', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        vi.mocked(fileReader.listFolders).mockResolvedValue([
+            { path: 'Personal', name: 'Personal', source: 'local' },
+            { path: 'Personal/Finance', name: 'Finance', source: 'local' },
+            { path: 'Work', name: 'Work', source: 'local' },
+        ]);
+        const result = await listFolders();
+        expect(result.map((f) => f.path)).toEqual(['Work']);
+    });
+    // getCalendarNote / getTodayNote / per-day fetches in getNotesInRange used
+    // to call fileReader.getCalendarNote directly, bypassing isFolderAllowed.
+    // Important: a user can deny `Calendar` outright to hide all calendar notes.
+    it('getCalendarNote returns null when Calendar/ is denied', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Calendar';
+        __resetFolderAccessConfigForTests();
+        vi.mocked(fileReader.getCalendarNote).mockResolvedValue({
+            id: 'Calendar/20260507.txt',
+            title: '20260507',
+            filename: 'Calendar/20260507.txt',
+            type: 'calendar',
+            source: 'local',
+            folder: 'Calendar',
+            content: 'private',
+            modifiedAt: new Date(),
+            createdAt: new Date(),
+            spaceId: undefined,
+        });
+        const result = await getCalendarNote('20260507');
+        expect(result).toBeNull();
+    });
+    // listTags walked the bridge / ripgrep / filesystem indiscriminately, so
+    // tag NAMES from denied notes leaked through `noteplan_search(action:
+    // list_tags)` even though the notes themselves were filtered. When rules
+    // are configured we now iterate the already-filtered listNotes() output.
+    it('listTags excludes tags that exist only inside a denied folder', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        const personal = {
+            id: 'Notes/Personal/Diary.md',
+            title: 'Diary',
+            filename: 'Notes/Personal/Diary.md',
+            type: 'note',
+            source: 'local',
+            folder: 'Notes/Personal',
+            content: 'session with #therapist about #anxiety',
+            modifiedAt: new Date(),
+            createdAt: new Date(),
+            spaceId: undefined,
+        };
+        const work = {
+            ...personal,
+            id: 'Notes/Work/Plan.md',
+            filename: 'Notes/Work/Plan.md',
+            folder: 'Notes/Work',
+            title: 'Plan',
+            content: 'review #q2 plan with #team',
+        };
+        vi.mocked(fileReader.listProjectNotes).mockResolvedValue([personal, work]);
+        const tags = await listTags();
+        expect(tags).toEqual(expect.arrayContaining(['#q2', '#team']));
+        expect(tags).not.toContain('#therapist');
+        expect(tags).not.toContain('#anxiety');
+    });
+    // No rules configured → keep the fast bridge / ripgrep / extractAllTags path.
+    it('listTags uses the fast extractAllTags path when no rules are configured', async () => {
+        vi.mocked(fileReader.extractAllTags).mockResolvedValue(['#fast', '#path']);
+        const tags = await listTags();
+        expect(tags).toEqual(['#fast', '#path']);
+        expect(fileReader.extractAllTags).toHaveBeenCalled();
+    });
+});
 //# sourceMappingURL=notes.test.js.map