@noteplanco/noteplan-mcp 1.1.7 → 1.1.9

package/dist/tools/notes.js

@@ -69,7 +69,7 @@ function resolveNoteTarget(id, filename, space) {
         note,
     };
 }
-function resolveWritableNoteReference(input) {
+export function resolveWritableNoteReference(input) {
     if (input.id && input.id.trim().length > 0) {
         const note = store.getNote({ id: input.id.trim(), space: input.space?.trim() });
         return { note, error: note ? undefined : 'Note not found' };
@@ -124,7 +124,7 @@ function resolveWritableNoteReference(input) {
         error: 'Provide one note reference: id, filename, title, date, or query',
     };
 }
-function getWritableIdentifier(note) {
+export function getWritableIdentifier(note) {
     if (note.source === 'space') {
         return {
             identifier: note.id || note.filename,
@@ -302,7 +302,11 @@ export const createNoteSchema = z.object({
     templateTypes: z.array(z.enum(['empty-note', 'meeting-note', 'project-note', 'calendar-note'])).optional().describe('Template type tags — used when noteType="template"'),
 });
 export const updateNoteSchema = z.object({
-    filename: z.string().describe('Filename/path of the note to update'),
+    id: z.string().optional().describe('Note ID (preferred for space notes)'),
+    filename: z.string().optional().describe('Filename/path of the note to update'),
+    title: z.string().optional().describe('Note title to search for'),
+    date: z.string().optional().describe('Date for calendar notes (YYYYMMDD, YYYY-MM-DD, today, tomorrow, yesterday)'),
+    query: z.string().optional().describe('Fuzzy note query'),
     space: z.string().optional().describe('Space name or ID to search in'),
     content: z
         .string()
@@ -323,6 +327,14 @@ export const updateNoteSchema = z.object({
         .boolean()
         .optional()
         .describe('Allow replacing note content with empty/blank text (default: false)'),
+}).superRefine((input, ctx) => {
+    if (!input.id && !input.filename && !input.title && !input.date && !input.query) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Provide one note reference: id, filename, title, date, or query',
+            path: ['filename'],
+        });
+    }
 });
 export const deleteNoteSchema = z.object({
     id: z.string().optional().describe('Note ID (preferred for TeamSpace notes)'),
@@ -348,6 +360,9 @@ export const deleteNoteSchema = z.object({
 export const moveNoteSchema = z.object({
     id: z.string().optional().describe('Note ID (preferred for TeamSpace notes)'),
     filename: z.string().optional().describe('Filename/path of the note to move'),
+    title: z.string().optional().describe('Note title to search for'),
+    date: z.string().optional().describe('Date for calendar notes (YYYYMMDD, YYYY-MM-DD, today, tomorrow, yesterday)'),
+    query: z.string().optional().describe('Fuzzy note query'),
     space: z.string().optional().describe('Space name or ID to search in'),
     destinationFolder: z
         .string()
@@ -698,6 +713,7 @@ export function createNote(params) {
         });
         return {
             success: true,
+            tip: 'Use action "set_property" to add frontmatter fields (e.g. type, tags) or "remove_property" to delete them.',
             note: {
                 title: result.note.title,
                 filename: result.note.filename,
@@ -730,29 +746,33 @@ export function updateNote(params) {
                 error: 'Full note replacement is blocked for noteplan_update_note unless fullReplace=true. Prefer noteplan_search_paragraphs + noteplan_edit_line/insert_content/delete_lines for targeted edits.',
             };
         }
-        const existingNote = store.getNote({ filename: params.filename, space: params.space });
-        if (!existingNote) {
+        const noteRef = resolveWritableNoteReference(params);
+        if (!noteRef.note) {
             return {
                 success: false,
-                error: 'Note not found',
+                error: noteRef.error || 'Note not found',
+                candidates: noteRef.candidates,
             };
         }
+        const existingNote = noteRef.note;
         if (params.allowEmptyContent !== true && params.content.trim().length === 0) {
             return {
                 success: false,
                 error: 'Empty content is blocked for noteplan_update_note. Use allowEmptyContent=true to override intentionally.',
             };
         }
+        // Use the resolved filename as the confirmation token target for consistency
+        const confirmationTarget = existingNote.filename;
         if (isTrueBool(params.dryRun)) {
             const token = issueConfirmationToken({
                 tool: 'noteplan_update_note',
-                target: params.filename,
+                target: confirmationTarget,
                 action: 'full_replace',
             });
             return {
                 success: true,
                 dryRun: true,
-                message: `Dry run: note ${params.filename} would be fully replaced`,
+                message: `Dry run: note ${existingNote.filename} would be fully replaced`,
                 note: {
                     id: existingNote.id,
                     title: existingNote.title,
@@ -769,7 +789,7 @@ export function updateNote(params) {
         }
         const confirmation = validateAndConsumeConfirmationToken(params.confirmationToken, {
             tool: 'noteplan_update_note',
-            target: params.filename,
+            target: confirmationTarget,
             action: 'full_replace',
         });
         if (!confirmation.ok) {
@@ -864,14 +884,16 @@ export function deleteNote(params) {
 }
 export function moveNote(params) {
     try {
-        const target = resolveNoteTarget(params.id, params.filename, params.space);
-        if (!target.note) {
+        const noteRef = resolveWritableNoteReference(params);
+        if (!noteRef.note) {
             return {
                 success: false,
-                error: 'Note not found',
+                error: noteRef.error || 'Note not found',
+                candidates: noteRef.candidates,
             };
         }
-        const preview = store.previewMoveNote(target.identifier, params.destinationFolder);
+        const writable = getWritableIdentifier(noteRef.note);
+        const preview = store.previewMoveNote(writable.identifier, params.destinationFolder);
         const confirmationTarget = `${preview.fromFilename}=>${preview.toFilename}::${preview.destinationParentId ?? preview.destinationFolder}`;
         if (isTrueBool(params.dryRun)) {
             const token = issueConfirmationToken({
@@ -909,7 +931,7 @@ export function moveNote(params) {
                 error: confirmationFailureMessage('noteplan_move_note', confirmation.reason),
             };
         }
-        const moved = store.moveNote(target.identifier, params.destinationFolder);
+        const moved = store.moveNote(writable.identifier, params.destinationFolder);
         return {
             success: true,
             message: moved.note.source === 'space'
@@ -1067,6 +1089,21 @@ export function renameNoteFile(params) {
                 };
             }
             const renamed = store.renameSpaceNote(writeId, params.newTitle);
+            // Also update the # Title heading in the note content if it matches the old title
+            if (renamed.note.content) {
+                const lines = renamed.note.content.split('\n');
+                const titleLineIndex = lines.findIndex((l) => /^#\s+/.test(l));
+                if (titleLineIndex !== -1) {
+                    const oldHeadingTitle = lines[titleLineIndex].replace(/^#\s+/, '');
+                    if (oldHeadingTitle === renamed.fromTitle) {
+                        lines[titleLineIndex] = `# ${params.newTitle}`;
+                        const renamedWriteTarget = getWritableIdentifier(renamed.note);
+                        store.updateNote(renamedWriteTarget.identifier, lines.join('\n'), {
+                            source: renamedWriteTarget.source,
+                        });
+                    }
+                }
+            }
             return {
                 success: true,
                 message: `TeamSpace note renamed from "${renamed.fromTitle}" to "${renamed.toTitle}"`,
@@ -1174,13 +1211,25 @@ export function renameNoteFile(params) {
 }
 // Get note with line numbers
 export const getParagraphsSchema = z.object({
-    filename: z.string().describe('Filename/path of the note'),
+    id: z.string().optional().describe('Note ID (preferred for space notes)'),
+    filename: z.string().optional().describe('Filename/path of the note'),
+    title: z.string().optional().describe('Note title to search for'),
+    date: z.string().optional().describe('Date for calendar notes (YYYYMMDD, YYYY-MM-DD, today, tomorrow, yesterday)'),
+    query: z.string().optional().describe('Fuzzy note query'),
     space: z.string().optional().describe('Space name or ID to search in'),
     startLine: z.number().min(1).optional().describe('First line to include (1-indexed, inclusive)'),
     endLine: z.number().min(1).optional().describe('Last line to include (1-indexed, inclusive)'),
     limit: z.number().min(1).max(1000).optional().default(200).describe('Maximum lines to return'),
     offset: z.number().min(0).optional().default(0).describe('Pagination offset within selected range'),
     cursor: z.string().optional().describe('Cursor token from previous page (preferred over offset)'),
+}).superRefine((input, ctx) => {
+    if (!input.id && !input.filename && !input.title && !input.date && !input.query) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Provide one note reference: id, filename, title, date, or query',
+            path: ['filename'],
+        });
+    }
 });
 export const searchParagraphsSchema = z.object({
     id: z.string().optional().describe('Note ID (preferred for space notes)'),
@@ -1214,13 +1263,15 @@ export const searchParagraphsSchema = z.object({
     }
 });
 export function getParagraphs(params) {
-    const note = store.getNote({ filename: params.filename, space: params.space });
-    if (!note) {
+    const noteRef = resolveWritableNoteReference(params);
+    if (!noteRef.note) {
         return {
             success: false,
-            error: 'Note not found',
+            error: noteRef.error || 'Note not found',
+            candidates: noteRef.candidates,
         };
     }
+    const note = noteRef.note;
     const allLines = note.content.split('\n');
     const lineWindow = buildLineWindow(allLines, {
         startLine: params.startLine,
@@ -1365,6 +1416,7 @@ export function searchParagraphs(params) {
     const nextCursor = hasMore ? String(offset + page.length) : null;
     const result = {
         success: true,
+        tip: 'To search across ALL notes at once, use action "search_global" instead. It supports query "*" to match all tasks.',
         query,
         count: page.length,
         totalCount: allMatches.length,
@@ -1399,15 +1451,39 @@ export function searchParagraphs(params) {
 }
 // Granular note operation schemas
 export const setPropertySchema = z.object({
-    filename: z.string().describe('Filename/path of the note'),
+    id: z.string().optional().describe('Note ID (preferred for space notes)'),
+    filename: z.string().optional().describe('Filename/path of the note'),
+    title: z.string().optional().describe('Note title to search for'),
+    date: z.string().optional().describe('Date for calendar notes (YYYYMMDD, YYYY-MM-DD, today, tomorrow, yesterday)'),
+    query: z.string().optional().describe('Fuzzy note query'),
     space: z.string().optional().describe('Space name or ID to search in'),
     key: z.string().describe('Property key (e.g., "icon", "bg-color", "status")'),
     value: z.string().describe('Property value'),
+}).superRefine((input, ctx) => {
+    if (!input.id && !input.filename && !input.title && !input.date && !input.query) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Provide one note reference: id, filename, title, date, or query',
+            path: ['filename'],
+        });
+    }
 });
 export const removePropertySchema = z.object({
-    filename: z.string().describe('Filename/path of the note'),
+    id: z.string().optional().describe('Note ID (preferred for space notes)'),
+    filename: z.string().optional().describe('Filename/path of the note'),
+    title: z.string().optional().describe('Note title to search for'),
+    date: z.string().optional().describe('Date for calendar notes (YYYYMMDD, YYYY-MM-DD, today, tomorrow, yesterday)'),
+    query: z.string().optional().describe('Fuzzy note query'),
     space: z.string().optional().describe('Space name or ID to search in'),
     key: z.string().describe('Property key to remove'),
+}).superRefine((input, ctx) => {
+    if (!input.id && !input.filename && !input.title && !input.date && !input.query) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Provide one note reference: id, filename, title, date, or query',
+            path: ['filename'],
+        });
+    }
 });
 export const insertContentSchema = z.object({
     id: z.string().optional().describe('Note ID (preferred for space notes)'),
@@ -1549,13 +1625,14 @@ export const replaceLinesSchema = z.object({
 // Granular note operation implementations
 export function setProperty(params) {
     try {
-        const note = store.getNote({ filename: params.filename, space: params.space });
-        if (!note) {
-            return { success: false, error: 'Note not found' };
+        const noteRef = resolveWritableNoteReference(params);
+        if (!noteRef.note) {
+            return { success: false, error: noteRef.error || 'Note not found', candidates: noteRef.candidates };
         }
+        const note = noteRef.note;
         const newContent = frontmatter.setFrontmatterProperty(note.content, params.key, params.value);
-        const writeIdentifier = note.source === 'space' ? (note.id || note.filename) : note.filename;
-        store.updateNote(writeIdentifier, newContent, { source: note.source });
+        const writable = getWritableIdentifier(note);
+        store.updateNote(writable.identifier, newContent, { source: writable.source });
         return {
             success: true,
             message: `Property "${params.key}" set to "${params.value}"`,
@@ -1570,13 +1647,14 @@ export function setProperty(params) {
 }
 export function removeProperty(params) {
     try {
-        const note = store.getNote({ filename: params.filename, space: params.space });
-        if (!note) {
-            return { success: false, error: 'Note not found' };
+        const noteRef = resolveWritableNoteReference(params);
+        if (!noteRef.note) {
+            return { success: false, error: noteRef.error || 'Note not found', candidates: noteRef.candidates };
         }
+        const note = noteRef.note;
         const newContent = frontmatter.removeFrontmatterProperty(note.content, params.key);
-        const writeIdentifier = note.source === 'space' ? (note.id || note.filename) : note.filename;
-        store.updateNote(writeIdentifier, newContent, { source: note.source });
+        const writable = getWritableIdentifier(note);
+        store.updateNote(writable.identifier, newContent, { source: writable.source });
         return {
             success: true,
             message: `Property "${params.key}" removed`,
@@ -1660,6 +1738,7 @@ export function insertContent(params) {
         });
         return {
             success: true,
+            tip: 'Use noteplan_paragraphs(action: "get") to inspect line numbers and content before making further edits.',
             message: `Content inserted at ${params.position}`,
             note: {
                 id: note.id,
@@ -1719,20 +1798,36 @@ export function appendContent(params) {
 }
 export function deleteLines(params) {
     try {
+        // Validate required line params — MCP may deliver them as undefined when omitted
+        const rawStart = params.startLine !== undefined && params.startLine !== null ? Number(params.startLine) : NaN;
+        const rawEnd = params.endLine !== undefined && params.endLine !== null ? Number(params.endLine) : NaN;
+        if (!Number.isFinite(rawStart)) {
+            return { success: false, error: 'startLine is required (1-indexed).' };
+        }
+        if (!Number.isFinite(rawEnd)) {
+            return { success: false, error: 'endLine is required (1-indexed). Pass the same value as startLine to delete a single line.' };
+        }
         const resolved = resolveWritableNoteReference(params);
         if (!resolved.note) {
             return { success: false, error: resolved.error || 'Note not found', candidates: resolved.candidates };
         }
         const note = resolved.note;
         const allLines = note.content.split('\n');
-        // Line numbers are relative to content after frontmatter
-        const fmOffset = frontmatter.getFrontmatterLineCount(note.content);
-        const contentLineCount = allLines.length - fmOffset;
-        const boundedStartLine = toBoundedInt(params.startLine, 1, 1, Math.max(1, contentLineCount));
-        const boundedEndLine = toBoundedInt(params.endLine, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, contentLineCount));
+        // Line numbers are absolute (1-indexed), matching get_notes/getParagraphs
+        const totalLineCount = allLines.length;
+        const fmLineCount = frontmatter.getFrontmatterLineCount(note.content);
+        const minLine = fmLineCount > 0 ? fmLineCount + 1 : 1;
+        const boundedStartLine = toBoundedInt(params.startLine, minLine, minLine, Math.max(minLine, totalLineCount));
+        const boundedEndLine = toBoundedInt(params.endLine, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, totalLineCount));
+        if (boundedStartLine <= fmLineCount) {
+            return {
+                success: false,
+                error: `Lines 1-${fmLineCount} are frontmatter and cannot be deleted. Content starts at line ${fmLineCount + 1}.`,
+            };
+        }
         const lineCountToDelete = boundedEndLine - boundedStartLine + 1;
-        const previewStartIndex = fmOffset + boundedStartLine - 1;
-        const previewEndIndexExclusive = fmOffset + boundedEndLine;
+        const previewStartIndex = boundedStartLine - 1;
+        const previewEndIndexExclusive = boundedEndLine;
         const deletedLinesPreview = allLines
             .slice(previewStartIndex, previewEndIndexExclusive)
             .slice(0, 20)
@@ -1776,7 +1871,10 @@ export function deleteLines(params) {
                 error: confirmationFailureMessage('noteplan_delete_lines', confirmation.reason),
             };
         }
-        const newContent = frontmatter.deleteLines(note.content, boundedStartLine, boundedEndLine);
+        // Splice out lines using absolute indices (no frontmatter offset needed)
+        const splicedLines = [...allLines];
+        splicedLines.splice(boundedStartLine - 1, lineCountToDelete);
+        const newContent = splicedLines.join('\n');
         const writeIdentifier = note.source === 'space' ? (note.id || note.filename) : note.filename;
         store.updateNote(writeIdentifier, newContent, { source: note.source });
         return {
@@ -1810,13 +1908,19 @@ export function editLine(params) {
         const note = resolved.note;
         const lines = note.content.split('\n');
         const originalLineCount = lines.length;
-        // Offset past frontmatter so line 1 = first content line
-        const fmOffset = frontmatter.getFrontmatterLineCount(note.content);
-        const lineIndex = fmOffset + Number(params.line) - 1; // Convert to 0-indexed, skip FM
-        if (lineIndex < fmOffset || lineIndex >= lines.length) {
+        // Line numbers are absolute (1-indexed), matching get_notes/getParagraphs
+        const fmLineCount = frontmatter.getFrontmatterLineCount(note.content);
+        const lineIndex = Number(params.line) - 1; // Convert to 0-indexed
+        if (lineIndex < 0 || lineIndex >= lines.length) {
+            return {
+                success: false,
+                error: `Line ${params.line} does not exist (note has ${lines.length} lines)`,
+            };
+        }
+        if (fmLineCount > 0 && lineIndex < fmLineCount) {
             return {
                 success: false,
-                error: `Line ${params.line} does not exist (note has ${lines.length - fmOffset} content lines)`,
+                error: `Line ${params.line} is inside frontmatter (lines 1-${fmLineCount}). Content starts at line ${fmLineCount + 1}.`,
             };
         }
         const originalLine = lines[lineIndex];
@@ -1862,6 +1966,15 @@ export function editLine(params) {
 }
 export function replaceLines(params) {
     try {
+        // Validate required line params — MCP may deliver them as undefined when omitted
+        const rawStart = params.startLine !== undefined && params.startLine !== null ? Number(params.startLine) : NaN;
+        const rawEnd = params.endLine !== undefined && params.endLine !== null ? Number(params.endLine) : NaN;
+        if (!Number.isFinite(rawStart)) {
+            return { success: false, error: 'startLine is required (1-indexed).' };
+        }
+        if (!Number.isFinite(rawEnd)) {
+            return { success: false, error: 'endLine is required (1-indexed). Pass the same value as startLine to replace a single line.' };
+        }
         const resolved = resolveWritableNoteReference(params);
         if (!resolved.note) {
             return { success: false, error: resolved.error || 'Note not found', candidates: resolved.candidates };
@@ -1869,16 +1982,31 @@ export function replaceLines(params) {
         const note = resolved.note;
         const allLines = note.content.split('\n');
         const originalLineCount = allLines.length;
-        // Line numbers are relative to content after frontmatter
-        const fmOffset = frontmatter.getFrontmatterLineCount(note.content);
-        const contentLineCount = originalLineCount - fmOffset;
-        const boundedStartLine = toBoundedInt(params.startLine, 1, 1, Math.max(1, contentLineCount));
-        const boundedEndLine = toBoundedInt(params.endLine, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, contentLineCount));
-        const startIndex = fmOffset + boundedStartLine - 1;
-        const lineCountToReplace = boundedEndLine - boundedStartLine + 1;
-        const replacedText = allLines.slice(startIndex, fmOffset + boundedEndLine).join('\n');
+        // Line numbers are absolute (1-indexed), matching get_notes/getParagraphs
+        const fmLineCount = frontmatter.getFrontmatterLineCount(note.content);
+        const minLine = fmLineCount > 0 ? fmLineCount + 1 : 1;
+        const boundedStartLine = toBoundedInt(params.startLine, minLine, minLine, Math.max(minLine, originalLineCount));
+        const boundedEndLine = toBoundedInt(params.endLine, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, originalLineCount));
+        if (boundedStartLine <= fmLineCount) {
+            return {
+                success: false,
+                error: `Lines 1-${fmLineCount} are frontmatter and cannot be replaced directly. Content starts at line ${fmLineCount + 1}.`,
+            };
+        }
+        let startIndex = boundedStartLine - 1;
+        let lineCountToReplace = boundedEndLine - boundedStartLine + 1;
+        const replacedText = allLines.slice(startIndex, boundedEndLine).join('\n');
         const indentationStyle = normalizeIndentationStyle(params.indentationStyle);
         const normalized = normalizeContentIndentation(params.content, indentationStyle);
+        // If replacement content includes frontmatter and the note already has
+        // frontmatter, extend the splice to replace the old frontmatter too.
+        // The agent's frontmatter is the intended update.
+        const replacementHasFm = fmLineCount > 0
+            && frontmatter.parseNoteContent(normalized.content).hasFrontmatter;
+        if (replacementHasFm) {
+            lineCountToReplace += startIndex; // extend to also cover frontmatter lines
+            startIndex = 0;
+        }
         if (params.allowEmptyContent !== true && normalized.content.trim().length === 0) {
             return {
                 success: false,
@@ -1956,4 +2084,216 @@ export function replaceLines(params) {
         };
     }
 }
+// ---------------------------------------------------------------------------
+// searchParagraphsGlobal — search ALL lines (including frontmatter) across notes
+// ---------------------------------------------------------------------------
+function normalizeType(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const lower = value.trim().toLowerCase();
+    if (lower === 'calendar' || lower === 'note' || lower === 'trash')
+        return lower;
+    return undefined;
+}
+function normalizeTypeList(values) {
+    if (!Array.isArray(values))
+        return undefined;
+    const unique = new Set();
+    for (const entry of values) {
+        const normalized = normalizeType(entry);
+        if (normalized)
+            unique.add(normalized);
+    }
+    return unique.size > 0 ? Array.from(unique) : undefined;
+}
+function isPeriodicCalendarNote(note) {
+    if (note.type !== 'calendar' || !note.date)
+        return false;
+    return note.date.includes('-');
+}
+export const searchParagraphsGlobalSchema = z.object({
+    query: z.string().describe('Text to find across all notes (searches ALL lines including frontmatter)'),
+    caseSensitive: z.boolean().optional().default(false).describe('Case-sensitive match (default: false)'),
+    wholeWord: z.boolean().optional().default(false).describe('Require whole-word matches (default: false)'),
+    status: z
+        .enum(['open', 'done', 'cancelled', 'scheduled'])
+        .optional()
+        .describe('Filter results to only lines with this task status'),
+    contextLines: z.number().min(0).max(5).optional().default(1).describe('Context lines before/after each match'),
+    paragraphMaxChars: z
+        .number()
+        .min(50)
+        .max(5000)
+        .optional()
+        .default(600)
+        .describe('Maximum paragraph text chars per match'),
+    folder: z.string().optional().describe('Restrict to a specific folder path'),
+    space: z.string().optional().describe('Restrict to a specific space name or ID'),
+    noteQuery: z.string().optional().describe('Filter notes by title/filename/folder substring'),
+    noteTypes: z
+        .array(z.enum(['calendar', 'note', 'trash']))
+        .optional()
+        .describe('Restrict scanned notes by type'),
+    preferCalendar: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Prioritize calendar notes before maxNotes truncation'),
+    periodicOnly: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('When true, only scan periodic calendar notes (weekly/monthly/quarterly/yearly)'),
+    maxNotes: z.number().min(1).max(2000).optional().default(500).describe('Maximum notes to scan'),
+    limit: z.number().min(1).max(300).optional().default(30).describe('Maximum matches to return'),
+    offset: z.number().min(0).optional().default(0).describe('Pagination offset'),
+    cursor: z.string().optional().describe('Cursor token from previous page (preferred over offset)'),
+});
+export function searchParagraphsGlobal(params) {
+    const query = typeof params?.query === 'string' ? params.query.trim() : '';
+    if (!query) {
+        return {
+            success: false,
+            error: 'query is required',
+        };
+    }
+    const caseSensitive = params.caseSensitive ?? false;
+    const wholeWord = params.wholeWord ?? false;
+    const contextLines = toBoundedInt(params.contextLines, 1, 0, 5);
+    const paragraphMaxChars = toBoundedInt(params.paragraphMaxChars, 600, 50, 5000);
+    const normalizedQuery = caseSensitive ? query : query.toLowerCase();
+    const wildcardQuery = query === '*';
+    const matcher = wholeWord
+        ? new RegExp(`\\b${escapeRegExp(query)}\\b`, caseSensitive ? '' : 'i')
+        : null;
+    const maxNotes = toBoundedInt(params.maxNotes, 500, 1, 2000);
+    const noteQuery = typeof params.noteQuery === 'string' ? params.noteQuery.trim().toLowerCase() : '';
+    const noteTypes = normalizeTypeList(params.noteTypes);
+    const preferCalendar = params.preferCalendar === true;
+    const periodicOnly = params.periodicOnly === true;
+    const allNotes = store.listNotes({
+        folder: params.folder,
+        space: params.space,
+    });
+    let filteredNotes = noteQuery
+        ? allNotes.filter((note) => {
+            const haystack = `${note.title} ${note.filename} ${note.folder || ''}`.toLowerCase();
+            return haystack.includes(noteQuery);
+        })
+        : allNotes;
+    if (noteTypes && noteTypes.length > 0) {
+        filteredNotes = filteredNotes.filter((note) => noteTypes.includes(note.type));
+    }
+    if (periodicOnly) {
+        filteredNotes = filteredNotes.filter((note) => isPeriodicCalendarNote(note));
+    }
+    if (preferCalendar) {
+        filteredNotes = [...filteredNotes].sort((a, b) => {
+            const aCalendar = a.type === 'calendar' ? 1 : 0;
+            const bCalendar = b.type === 'calendar' ? 1 : 0;
+            if (aCalendar !== bCalendar)
+                return bCalendar - aCalendar;
+            const aModified = a.modifiedAt?.getTime() ?? 0;
+            const bModified = b.modifiedAt?.getTime() ?? 0;
+            return bModified - aModified;
+        });
+    }
+    const scannedNotes = filteredNotes.slice(0, maxNotes);
+    const truncatedByMaxNotes = filteredNotes.length > scannedNotes.length;
+    const allMatches = [];
+    for (const note of scannedNotes) {
+        const allLines = note.content.split('\n');
+        for (let lineIndex = 0; lineIndex < allLines.length; lineIndex++) {
+            const lineContent = allLines[lineIndex];
+            const haystack = caseSensitive ? lineContent : lineContent.toLowerCase();
+            const isMatch = wildcardQuery
+                ? true
+                : matcher
+                    ? matcher.test(lineContent)
+                    : haystack.includes(normalizedQuery);
+            if (!isMatch)
+                continue;
+            const paragraphBounds = findParagraphBounds(allLines, lineIndex);
+            const paragraphRaw = allLines
+                .slice(paragraphBounds.startIndex, paragraphBounds.endIndex + 1)
+                .join('\n');
+            const paragraphTruncated = paragraphRaw.length > paragraphMaxChars;
+            const paragraph = paragraphTruncated
+                ? `${paragraphRaw.slice(0, Math.max(0, paragraphMaxChars - 3))}...`
+                : paragraphRaw;
+            const contextStart = Math.max(0, lineIndex - contextLines);
+            const contextEnd = Math.min(allLines.length - 1, lineIndex + contextLines);
+            const meta = parseParagraphLine(lineContent, lineIndex, lineIndex === 0);
+            // Apply status filter (backward compat with searchTasksGlobal)
+            if (params.status && meta.taskStatus !== params.status)
+                continue;
+            allMatches.push({
+                note: {
+                    id: note.id,
+                    title: note.title,
+                    filename: note.filename,
+                    type: note.type,
+                    source: note.source,
+                    folder: note.folder,
+                    spaceId: note.spaceId,
+                    date: note.date,
+                },
+                lineIndex,
+                line: lineIndex + 1,
+                content: lineContent,
+                // Backward-compat alias: `status` mirrors `taskStatus` for old consumers
+                ...(meta.taskStatus !== undefined && { status: meta.taskStatus }),
+                type: meta.type,
+                indentLevel: meta.indentLevel,
+                ...(meta.headingLevel !== undefined && { headingLevel: meta.headingLevel }),
+                ...(meta.taskStatus !== undefined && { taskStatus: meta.taskStatus }),
+                ...(meta.priority !== undefined && { priority: meta.priority }),
+                ...(meta.marker !== undefined && { marker: meta.marker }),
+                ...(meta.hasCheckbox !== undefined && { hasCheckbox: meta.hasCheckbox }),
+                tags: meta.tags,
+                mentions: meta.mentions,
+                ...(meta.scheduledDate !== undefined && { scheduledDate: meta.scheduledDate }),
+                paragraphStartLine: paragraphBounds.startIndex + 1,
+                paragraphEndLine: paragraphBounds.endIndex + 1,
+                paragraph,
+                paragraphTruncated,
+                contextBefore: allLines.slice(contextStart, lineIndex),
+                contextAfter: allLines.slice(lineIndex + 1, contextEnd + 1),
+            });
+        }
+    }
+    const offset = toBoundedInt(params.cursor ?? params.offset, 0, 0, Number.MAX_SAFE_INTEGER);
+    const limit = toBoundedInt(params.limit, 30, 1, 300);
+    const page = allMatches.slice(offset, offset + limit);
+    const hasMore = offset + page.length < allMatches.length;
+    const nextCursor = hasMore ? String(offset + page.length) : null;
+    const result = {
+        success: true,
+        query,
+        count: page.length,
+        totalCount: allMatches.length,
+        offset,
+        limit,
+        hasMore,
+        nextCursor,
+        scannedNoteCount: scannedNotes.length,
+        totalNotes: filteredNotes.length,
+        truncatedByMaxNotes,
+        maxNotes,
+        noteTypes,
+        preferCalendar,
+        periodicOnly,
+        matches: page,
+    };
+    if (hasMore) {
+        result.performanceHints = ['Continue with nextCursor to fetch the next global paragraph match page.'];
+    }
+    if (truncatedByMaxNotes) {
+        result.performanceHints = [
+            ...(result.performanceHints ?? []),
+            'Increase maxNotes or narrow folder/space/noteQuery to reduce truncation.',
+        ];
+    }
+    return result;
+}
 //# sourceMappingURL=notes.js.map