@disco_trooper/apple-notes-mcp 1.2.0 → 1.4.0

package/src/notes/crud.ts

@@ -115,20 +115,42 @@ export async function createNote(
   debug(`Note created: "${title}"`);
 }
 
+/**
+ * Result of an update operation.
+ * Apple Notes may rename the note based on content (first h1 heading).
+ */
+export interface UpdateResult {
+  /** Original title before update */
+  originalTitle: string;
+  /** Current title after update (may differ if Apple Notes renamed it) */
+  newTitle: string;
+  /** Folder containing the note */
+  folder: string;
+  /** Whether the title changed */
+  titleChanged: boolean;
+}
+
 /**
  * Update an existing note's content.
  *
+ * Note: Apple Notes may automatically rename the note based on the first
+ * heading in the content. The returned UpdateResult contains the actual
+ * title after the update.
+ *
  * @param title - Note title (supports folder prefix: "Work/My Note")
  * @param content - New content (Markdown)
+ * @returns UpdateResult with original and new title
  * @throws Error if READONLY_MODE is enabled
  * @throws Error if note not found or duplicate titles without folder prefix
  */
-export async function updateNote(title: string, content: string): Promise<void> {
+export async function updateNote(title: string, content: string): Promise<UpdateResult> {
   checkReadOnly();
 
   debug(`Updating note: "${title}"`);
 
   const note = await resolveNoteOrThrow(title);
+  const originalTitle = note.title;
+  const folder = note.folder;
 
   // Convert Markdown to HTML
   const htmlContent = markdownToHtml(content);
@@ -137,7 +159,8 @@ export async function updateNote(title: string, content: string): Promise<void>
 
   debug(`HTML content length: ${htmlContent.length}`);
 
-  await runJxa(`
+  // Update the note and get its new title (Apple Notes may rename it)
+  const result = await runJxa(`
     const app = Application('Notes');
     const noteId = ${escapedNoteId};
     const content = ${escapedContent};
@@ -152,10 +175,25 @@ export async function updateNote(title: string, content: string): Promise<void>
     // Update the body
     note.body = content;
 
-    return "ok";
-  `);
+    // Return the current title (may have changed)
+    return JSON.stringify({ newTitle: note.name() });
+  `) as string;
+
+  const { newTitle } = JSON.parse(result);
+  const titleChanged = newTitle !== originalTitle;
+
+  if (titleChanged) {
+    debug(`Note renamed by Apple Notes: "${originalTitle}" -> "${newTitle}"`);
+  } else {
+    debug(`Note updated: "${title}"`);
+  }
 
-  debug(`Note updated: "${title}"`);
+  return {
+    originalTitle,
+    newTitle,
+    folder,
+    titleChanged,
+  };
 }
 
 /**
@@ -304,3 +342,210 @@ export async function editTable(
 
   debug(`Table ${tableIndex} updated in note: "${title}"`);
 }
+
+/**
+ * Result of a batch operation.
+ */
+export interface BatchResult {
+  /** Number of notes successfully processed */
+  deleted: number;
+  /** Notes that failed to process */
+  failed: string[];
+}
+
+/**
+ * Options for batch delete.
+ */
+export interface BatchDeleteOptions {
+  /** List of note titles (supports folder/title and id:xxx formats) */
+  titles?: string[];
+  /** Delete all notes in this folder */
+  folder?: string;
+}
+
+/**
+ * Delete multiple notes at once.
+ *
+ * @param options - Either titles array OR folder name (not both)
+ * @returns BatchResult with deleted count and failed notes
+ * @throws Error if READONLY_MODE is enabled
+ * @throws Error if both titles and folder provided
+ * @throws Error if neither titles nor folder provided
+ */
+export async function batchDelete(options: BatchDeleteOptions): Promise<BatchResult> {
+  checkReadOnly();
+
+  const { titles, folder } = options;
+
+  if (titles && folder) {
+    throw new Error("Specify either titles or folder, not both");
+  }
+
+  if (!titles && !folder) {
+    throw new Error("Specify either titles or folder");
+  }
+
+  const result: BatchResult = { deleted: 0, failed: [] };
+
+  if (folder) {
+    // Delete all notes in folder via single JXA call
+    debug(`Batch deleting all notes in folder: "${folder}"`);
+
+    const escapedFolder = JSON.stringify(folder);
+    const jxaResult = await runJxa(`
+      const app = Application('Notes');
+      const folderName = ${escapedFolder};
+
+      const folders = app.folders.whose({name: folderName})();
+      if (folders.length === 0) {
+        throw new Error("Folder not found: " + folderName);
+      }
+
+      const folder = folders[0];
+      const notes = folder.notes();
+      let deletedCount = 0;
+
+      // Delete in reverse order to avoid index shifting
+      for (let i = notes.length - 1; i >= 0; i--) {
+        try {
+          notes[i].delete();
+          deletedCount++;
+        } catch (e) {
+          // Continue on individual failures
+        }
+      }
+
+      return JSON.stringify({ deletedCount });
+    `);
+
+    const { deletedCount } = JSON.parse(jxaResult as string);
+    result.deleted = deletedCount;
+  } else if (titles) {
+    // Delete individual notes
+    debug(`Batch deleting ${titles.length} notes by title`);
+
+    for (const title of titles) {
+      try {
+        await deleteNote(title);
+        result.deleted++;
+      } catch (error) {
+        result.failed.push(title);
+        debug(`Failed to delete "${title}":`, error);
+      }
+    }
+  }
+
+  debug(`Batch delete complete: ${result.deleted} deleted, ${result.failed.length} failed`);
+  return result;
+}
+
+/**
+ * Result of a batch move operation.
+ */
+export interface BatchMoveResult {
+  /** Number of notes successfully moved */
+  moved: number;
+  /** Notes that failed to move */
+  failed: string[];
+}
+
+/**
+ * Options for batch move.
+ */
+export interface BatchMoveOptions {
+  /** List of note titles (supports folder/title and id:xxx formats) */
+  titles?: string[];
+  /** Move all notes from this folder */
+  sourceFolder?: string;
+  /** Target folder (required) */
+  targetFolder: string;
+}
+
+/**
+ * Move multiple notes to a target folder.
+ *
+ * @param options - Either titles array OR sourceFolder (not both) + targetFolder
+ * @returns BatchMoveResult with moved count and failed notes
+ * @throws Error if READONLY_MODE is enabled
+ * @throws Error if both titles and sourceFolder provided
+ * @throws Error if neither titles nor sourceFolder provided
+ * @throws Error if targetFolder is empty
+ */
+export async function batchMove(options: BatchMoveOptions): Promise<BatchMoveResult> {
+  checkReadOnly();
+
+  const { titles, sourceFolder, targetFolder } = options;
+
+  if (!targetFolder) {
+    throw new Error("targetFolder is required");
+  }
+
+  if (titles && sourceFolder) {
+    throw new Error("Specify either titles or sourceFolder, not both");
+  }
+
+  if (!titles && !sourceFolder) {
+    throw new Error("Specify either titles or sourceFolder");
+  }
+
+  const result: BatchMoveResult = { moved: 0, failed: [] };
+
+  if (sourceFolder) {
+    // Move all notes from source folder via single JXA call
+    debug(`Batch moving all notes from "${sourceFolder}" to "${targetFolder}"`);
+
+    const escapedSource = JSON.stringify(sourceFolder);
+    const escapedTarget = JSON.stringify(targetFolder);
+    const jxaResult = await runJxa(`
+      const app = Application('Notes');
+      const sourceName = ${escapedSource};
+      const targetName = ${escapedTarget};
+
+      const sourceFolders = app.folders.whose({name: sourceName})();
+      if (sourceFolders.length === 0) {
+        throw new Error("Source folder not found: " + sourceName);
+      }
+
+      const targetFolders = app.folders.whose({name: targetName})();
+      if (targetFolders.length === 0) {
+        throw new Error("Target folder not found: " + targetName);
+      }
+
+      const source = sourceFolders[0];
+      const target = targetFolders[0];
+      const notes = source.notes();
+      let movedCount = 0;
+
+      // Move in reverse order to avoid index shifting
+      for (let i = notes.length - 1; i >= 0; i--) {
+        try {
+          notes[i].move({to: target});
+          movedCount++;
+        } catch (e) {
+          // Continue on individual failures
+        }
+      }
+
+      return JSON.stringify({ movedCount });
+    `);
+
+    const { movedCount } = JSON.parse(jxaResult as string);
+    result.moved = movedCount;
+  } else if (titles) {
+    // Move individual notes
+    debug(`Batch moving ${titles.length} notes to "${targetFolder}"`);
+
+    for (const title of titles) {
+      try {
+        await moveNote(title, targetFolder);
+        result.moved++;
+      } catch (error) {
+        result.failed.push(title);
+        debug(`Failed to move "${title}":`, error);
+      }
+    }
+  }
+
+  debug(`Batch move complete: ${result.moved} moved, ${result.failed.length} failed`);
+  return result;
+}

package/src/notes/read.ts

@@ -40,9 +40,19 @@ export interface NoteDetails extends NoteInfo {
 }
 
 // -----------------------------------------------------------------------------
-// Internal JXA helpers
+// Internal types and helpers
 // -----------------------------------------------------------------------------
 
+/** Raw note data from JXA before markdown conversion */
+interface RawNoteData {
+  id: string;
+  title: string;
+  folder: string;
+  created: string;
+  modified: string;
+  htmlContent: string;
+}
+
 /**
  * Execute JXA code safely with error handling
  */
@@ -58,6 +68,21 @@ async function executeJxa<T>(code: string): Promise<T> {
   }
 }
 
+/**
+ * Convert raw JXA note data to NoteDetails with markdown content
+ */
+function toNoteDetails(raw: RawNoteData): NoteDetails {
+  return {
+    id: raw.id,
+    title: raw.title,
+    folder: raw.folder,
+    created: raw.created,
+    modified: raw.modified,
+    content: htmlToMarkdown(raw.htmlContent),
+    htmlContent: raw.htmlContent,
+  };
+}
+
 // -----------------------------------------------------------------------------
 // Public API
 // -----------------------------------------------------------------------------
@@ -180,14 +205,7 @@ export async function getNoteByTitle(
   `;
 
   const result = await executeJxa<string>(jxaCode);
-  const notes = JSON.parse(result) as Array<{
-    id: string;
-    title: string;
-    folder: string;
-    created: string;
-    modified: string;
-    htmlContent: string;
-  }>;
+  const notes = JSON.parse(result) as RawNoteData[];
 
   if (notes.length === 0) {
     debug("Note not found");
@@ -196,27 +214,11 @@ export async function getNoteByTitle(
 
   if (notes.length > 1) {
     debug(`Multiple notes found with title: ${targetTitle}`);
-    // If folder wasn't specified and multiple exist, return the first one
-    // but log a warning
-    debug(
-      "Returning first match. Use folder/title format for disambiguation."
-    );
+    debug("Returning first match. Use folder/title format for disambiguation.");
   }
 
-  const note = notes[0];
-  const content = htmlToMarkdown(note.htmlContent);
-
-  debug(`Found note in folder: ${note.folder}`);
-
-  return {
-    id: note.id,
-    title: note.title,
-    folder: note.folder,
-    created: note.created,
-    modified: note.modified,
-    content,
-    htmlContent: note.htmlContent,
-  };
+  debug(`Found note in folder: ${notes[0].folder}`);
+  return toNoteDetails(notes[0]);
 }
 
 /**
@@ -268,33 +270,15 @@ export async function getNoteById(id: string): Promise<NoteDetails | null> {
   `;
 
   const result = await executeJxa<string>(jxaCode);
-  const note = JSON.parse(result) as {
-    id: string;
-    title: string;
-    folder: string;
-    created: string;
-    modified: string;
-    htmlContent: string;
-  } | null;
+  const note = JSON.parse(result) as RawNoteData | null;
 
   if (!note) {
     debug("Note not found by ID");
     return null;
   }
 
-  const content = htmlToMarkdown(note.htmlContent);
-
   debug(`Found note: ${note.title} in folder: ${note.folder}`);
-
-  return {
-    id: note.id,
-    title: note.title,
-    folder: note.folder,
-    created: note.created,
-    modified: note.modified,
-    content,
-    htmlContent: note.htmlContent,
-  };
+  return toNoteDetails(note);
 }
 
 /**
@@ -357,34 +341,65 @@ export async function getNoteByFolderAndTitle(
   `;
 
   const result = await executeJxa<string>(jxaCode);
-  const notes = JSON.parse(result) as Array<{
-    id: string;
-    title: string;
-    folder: string;
-    created: string;
-    modified: string;
-    htmlContent: string;
-  }>;
+  const notes = JSON.parse(result) as RawNoteData[];
 
   if (notes.length === 0) {
     debug("Note not found");
     return null;
   }
 
-  const note = notes[0];
-  const content = htmlToMarkdown(note.htmlContent);
+  debug(`Found note in folder: ${notes[0].folder}`);
+  return toNoteDetails(notes[0]);
+}
 
-  debug(`Found note in folder: ${note.folder}`);
+/**
+ * Get all notes with full content in a single JXA call.
+ * This is much faster than calling getNoteByFolderAndTitle for each note
+ * because it avoids the JXA process spawn overhead per note.
+ *
+ * @returns Array of note details with content
+ */
+export async function getAllNotesWithContent(): Promise<NoteDetails[]> {
+  debug("Getting all notes with content (single JXA call)...");
 
-  return {
-    id: note.id,
-    title: note.title,
-    folder: note.folder,
-    created: note.created,
-    modified: note.modified,
-    content,
-    htmlContent: note.htmlContent,
-  };
+  const jxaCode = `
+    const app = Application('Notes');
+    app.includeStandardAdditions = true;
+
+    const allNotes = [];
+    const folders = app.folders();
+
+    for (const folder of folders) {
+      const folderName = folder.name();
+      const notes = folder.notes();
+
+      for (let i = 0; i < notes.length; i++) {
+        try {
+          const note = notes[i];
+          const props = note.properties();
+          allNotes.push({
+            id: note.id(),
+            title: props.name || '',
+            folder: folderName,
+            created: props.creationDate ? props.creationDate.toISOString() : '',
+            modified: props.modificationDate ? props.modificationDate.toISOString() : '',
+            htmlContent: note.body()
+          });
+        } catch (e) {
+          // Skip notes that can't be accessed
+        }
+      }
+    }
+
+    return JSON.stringify(allNotes);
+  `;
+
+  const result = await executeJxa<string>(jxaCode);
+  const notes = JSON.parse(result) as RawNoteData[];
+
+  debug(`Fetched ${notes.length} notes with content`);
+
+  return notes.map(toNoteDetails);
 }
 
 /**