joplin-mcp-server 1.0.0

package/dist/lib/tools/delete-folder.js

@@ -0,0 +1,138 @@
+import BaseTool from "./base-tool.js";
+class DeleteFolder extends BaseTool {
+    async call(options) {
+        if (!options || typeof options !== "object") {
+            return 'Please provide folder deletion options. Example: delete_folder {"folder_id": "abc123", "confirm": true}';
+        }
+        // Validate required folder_id
+        if (!options.folder_id) {
+            return 'Please provide folder deletion options. Example: delete_folder {"folder_id": "abc123", "confirm": true}';
+        }
+        const folderIdError = this.validateId(options.folder_id, "notebook");
+        if (folderIdError) {
+            return folderIdError.replace("notebook ID", "folder ID").replace("notebook_id", "folder_id");
+        }
+        // Require explicit confirmation for safety
+        if (!options.confirm) {
+            return `⚠️  This will permanently delete the notebook/folder!\n\nTo confirm deletion, use:\ndelete_folder {"folder_id": "${options.folder_id}", "confirm": true}\n\n⚠️  This action cannot be undone!`;
+        }
+        try {
+            // First, get the folder details to show what's being deleted
+            const folderToDelete = await this.apiClient.get(`/folders/${options.folder_id}`, {
+                query: { fields: "id,title,parent_id" },
+            });
+            if (!folderToDelete || !folderToDelete.id) {
+                return `Folder with ID "${options.folder_id}" not found.\n\nUse list_notebooks to see available folders and their IDs.`;
+            }
+            // Check if folder contains notes or subfolders
+            const [notes, subfolders] = await Promise.all([
+                this.apiClient
+                    .get(`/folders/${options.folder_id}/notes`, {
+                    query: { fields: "id,title" },
+                })
+                    .catch(() => ({ items: [] })),
+                this.apiClient
+                    .get("/folders", {
+                    query: { fields: "id,title,parent_id" },
+                })
+                    .then((response) => ({
+                    items: response.items?.filter((folder) => folder.parent_id === options.folder_id) || [],
+                }))
+                    .catch(() => ({ items: [] })),
+            ]);
+            const noteCount = notes.items?.length || 0;
+            const subfolderCount = subfolders.items?.length || 0;
+            const totalContent = noteCount + subfolderCount;
+            // Warn if folder is not empty and force is not specified
+            if (totalContent > 0 && !options.force) {
+                const resultLines = [];
+                resultLines.push(`⚠️  Cannot delete non-empty notebook!`);
+                resultLines.push("");
+                resultLines.push(`📁 Notebook: "${folderToDelete.title}"`);
+                resultLines.push(`   Contains: ${noteCount} notes and ${subfolderCount} subfolders`);
+                if (noteCount > 0) {
+                    resultLines.push("");
+                    resultLines.push(`📝 Contains ${noteCount} notes:`);
+                    notes.items.slice(0, 5).forEach((note) => {
+                        resultLines.push(`   - ${note.title || "Untitled"}`);
+                    });
+                    if (noteCount > 5) {
+                        resultLines.push(`   ... and ${noteCount - 5} more notes`);
+                    }
+                }
+                if (subfolderCount > 0) {
+                    resultLines.push("");
+                    resultLines.push(`📁 Contains ${subfolderCount} subfolders:`);
+                    subfolders.items.slice(0, 5).forEach((folder) => {
+                        resultLines.push(`   - ${folder.title}`);
+                    });
+                    if (subfolderCount > 5) {
+                        resultLines.push(`   ... and ${subfolderCount - 5} more folders`);
+                    }
+                }
+                resultLines.push("");
+                resultLines.push(`💡 Options:`);
+                resultLines.push(`   1. Move or delete the contents first, then delete the folder`);
+                resultLines.push(`   2. Force delete (⚠️  DESTROYS ALL CONTENT):`);
+                resultLines.push(`      delete_folder {"folder_id": "${options.folder_id}", "confirm": true, "force": true}`);
+                resultLines.push("");
+                resultLines.push(`⚠️  Force delete will permanently delete ALL ${totalContent} items inside!`);
+                return resultLines.join("\n");
+            }
+            // Get parent folder info if available
+            let parentInfo = "Top level";
+            if (folderToDelete.parent_id) {
+                try {
+                    const parentFolder = await this.apiClient.get(`/folders/${folderToDelete.parent_id}`, {
+                        query: { fields: "title" },
+                    });
+                    if (parentFolder?.title) {
+                        parentInfo = `Inside "${parentFolder.title}" (notebook_id: "${folderToDelete.parent_id}")`;
+                    }
+                }
+                catch (error) {
+                    parentInfo = `Parent ID: ${folderToDelete.parent_id}`;
+                }
+            }
+            // Delete the folder
+            await this.apiClient.delete(`/folders/${options.folder_id}`);
+            // Format success response
+            const resultLines = [];
+            resultLines.push(`🗑️  Successfully deleted notebook!`);
+            resultLines.push("");
+            resultLines.push(`📁 Deleted Notebook Details:`);
+            resultLines.push(`   Title: "${folderToDelete.title}"`);
+            resultLines.push(`   Folder ID: ${folderToDelete.id}`);
+            resultLines.push(`   Location: ${parentInfo}`);
+            if (totalContent > 0) {
+                resultLines.push(`   Deleted Content: ${noteCount} notes and ${subfolderCount} subfolders`);
+                resultLines.push("");
+                resultLines.push(`⚠️  All ${totalContent} items inside have been permanently deleted!`);
+            }
+            resultLines.push("");
+            resultLines.push(`⚠️  This notebook has been permanently deleted and cannot be recovered.`);
+            if (folderToDelete.parent_id) {
+                resultLines.push("");
+                resultLines.push(`🔗 Related actions:`);
+                resultLines.push(`   - View parent notebook: read_notebook notebook_id="${folderToDelete.parent_id}"`);
+                resultLines.push(`   - View all notebooks: list_notebooks`);
+            }
+            return resultLines.join("\n");
+        }
+        catch (error) {
+            if (error.response) {
+                if (error.response.status === 404) {
+                    return `Folder with ID "${options.folder_id}" not found.\n\nUse list_notebooks to see available folders and their IDs.`;
+                }
+                if (error.response.status === 403) {
+                    return `Permission denied: Cannot delete folder with ID "${options.folder_id}".\n\nThis might be a protected system folder.`;
+                }
+                if (error.response.status === 409) {
+                    return `Cannot delete folder: It may contain items that prevent deletion.\n\nTry moving or deleting the contents first, or use force option.`;
+                }
+            }
+            return this.formatError(error, "deleting folder");
+        }
+    }
+}
+export default DeleteFolder;

package/dist/lib/tools/delete-note.d.ts

@@ -0,0 +1,9 @@
+import BaseTool from "./base-tool.js";
+interface DeleteNoteOptions {
+    note_id: string;
+    confirm?: boolean | undefined;
+}
+declare class DeleteNote extends BaseTool {
+    call(options: DeleteNoteOptions): Promise<string>;
+}
+export default DeleteNote;

package/dist/lib/tools/delete-note.js

@@ -0,0 +1,92 @@
+import BaseTool from "./base-tool.js";
+class DeleteNote extends BaseTool {
+    async call(options) {
+        if (!options || typeof options !== "object") {
+            return 'Please provide note deletion options. Example: delete_note {"note_id": "abc123", "confirm": true}';
+        }
+        // Validate required note_id
+        if (!options.note_id) {
+            return 'Please provide note deletion options. Example: delete_note {"note_id": "abc123", "confirm": true}';
+        }
+        const noteIdError = this.validateId(options.note_id, "note");
+        if (noteIdError) {
+            return noteIdError;
+        }
+        // Require explicit confirmation for safety
+        if (!options.confirm) {
+            return `⚠️  This will permanently delete the note!\n\nTo confirm deletion, use:\ndelete_note {"note_id": "${options.note_id}", "confirm": true}\n\n⚠️  This action cannot be undone!`;
+        }
+        try {
+            // First, get the note details to show what's being deleted
+            const noteToDelete = await this.apiClient.get(`/notes/${options.note_id}`, {
+                query: { fields: "id,title,body,parent_id,is_todo,todo_completed,created_time,updated_time" },
+            });
+            if (!noteToDelete || !noteToDelete.id) {
+                return `Note with ID "${options.note_id}" not found.\n\nUse search_notes to find notes and their IDs.`;
+            }
+            // Get notebook info if available
+            let notebookInfo = "Root level";
+            if (noteToDelete.parent_id) {
+                try {
+                    const notebook = await this.apiClient.get(`/folders/${noteToDelete.parent_id}`, {
+                        query: { fields: "title" },
+                    });
+                    if (notebook?.title) {
+                        notebookInfo = `"${notebook.title}" (notebook_id: "${noteToDelete.parent_id}")`;
+                    }
+                }
+                catch (error) {
+                    notebookInfo = `Notebook ID: ${noteToDelete.parent_id}`;
+                }
+            }
+            // Delete the note
+            await this.apiClient.delete(`/notes/${options.note_id}`);
+            // Format success response
+            const resultLines = [];
+            resultLines.push(`🗑️  Successfully deleted note!`);
+            resultLines.push("");
+            resultLines.push(`📝 Deleted Note Details:`);
+            resultLines.push(`   Title: "${noteToDelete.title || "Untitled"}"`);
+            resultLines.push(`   Note ID: ${noteToDelete.id}`);
+            resultLines.push(`   Location: ${notebookInfo}`);
+            if (noteToDelete.is_todo) {
+                const status = noteToDelete.todo_completed ? "Completed" : "Not completed";
+                resultLines.push(`   Type: Todo (${status})`);
+            }
+            else {
+                resultLines.push(`   Type: Regular note`);
+            }
+            const createdDate = this.formatDate(noteToDelete.created_time);
+            const updatedDate = this.formatDate(noteToDelete.updated_time);
+            resultLines.push(`   Created: ${createdDate}`);
+            resultLines.push(`   Last Updated: ${updatedDate}`);
+            // Show content preview if available
+            if (noteToDelete.body) {
+                const preview = noteToDelete.body.substring(0, 100).replace(/\n/g, " ");
+                const truncated = noteToDelete.body.length > 100 ? "..." : "";
+                resultLines.push(`   Content Preview: ${preview}${truncated}`);
+            }
+            resultLines.push("");
+            resultLines.push(`⚠️  This note has been permanently deleted and cannot be recovered.`);
+            if (noteToDelete.parent_id) {
+                resultLines.push("");
+                resultLines.push(`🔗 Related actions:`);
+                resultLines.push(`   - View containing notebook: read_notebook notebook_id="${noteToDelete.parent_id}"`);
+                resultLines.push(`   - Search for similar notes: search_notes query="${noteToDelete.title}"`);
+            }
+            return resultLines.join("\n");
+        }
+        catch (error) {
+            if (error.response) {
+                if (error.response.status === 404) {
+                    return `Note with ID "${options.note_id}" not found.\n\nUse search_notes to find notes and their IDs.`;
+                }
+                if (error.response.status === 403) {
+                    return `Permission denied: Cannot delete note with ID "${options.note_id}".\n\nThis might be a protected system note.`;
+                }
+            }
+            return this.formatError(error, "deleting note");
+        }
+    }
+}
+export default DeleteNote;

package/dist/lib/tools/edit-folder.d.ts

@@ -0,0 +1,10 @@
+import BaseTool from "./base-tool.js";
+interface EditFolderOptions {
+    folder_id: string;
+    title?: string | undefined;
+    parent_id?: string | undefined;
+}
+declare class EditFolder extends BaseTool {
+    call(options: EditFolderOptions): Promise<string>;
+}
+export default EditFolder;

package/dist/lib/tools/edit-folder.js

@@ -0,0 +1,136 @@
+import BaseTool from "./base-tool.js";
+class EditFolder extends BaseTool {
+    async call(options) {
+        if (!options || typeof options !== "object") {
+            return 'Please provide folder edit options. Example: edit_folder {"folder_id": "abc123", "title": "New Name"}';
+        }
+        // Validate required folder_id
+        if (!options.folder_id) {
+            return 'Please provide folder edit options. Example: edit_folder {"folder_id": "abc123", "title": "New Name"}';
+        }
+        const folderIdError = this.validateId(options.folder_id, "notebook");
+        if (folderIdError) {
+            return folderIdError.replace("notebook ID", "folder ID").replace("notebook_id", "folder_id");
+        }
+        // Validate that we have at least one field to update
+        const updateFields = ["title", "parent_id"];
+        const hasUpdate = updateFields.some((field) => options[field] !== undefined);
+        if (!hasUpdate) {
+            return "Please provide at least one field to update. Available fields: title, parent_id";
+        }
+        // Validate title if provided
+        if (options.title !== undefined && (typeof options.title !== "string" || options.title.trim() === "")) {
+            return "Title must be a non-empty string.";
+        }
+        // Validate parent_id if provided
+        if (options.parent_id !== undefined && options.parent_id !== null && options.parent_id !== "") {
+            if (options.parent_id.length < 10 || !options.parent_id.match(/[a-f0-9]/i)) {
+                return `Error: "${options.parent_id}" does not appear to be a valid parent notebook ID.\n\nNotebook IDs are long alphanumeric strings like "58a0a29f68bc4141b49c99f5d367638a".\n\nUse list_notebooks to see available notebooks and their IDs.`;
+            }
+            // Prevent self-parenting
+            if (options.parent_id === options.folder_id) {
+                return "Error: A folder cannot be its own parent.";
+            }
+        }
+        try {
+            // First, get the current folder to show before/after comparison
+            const currentFolder = await this.apiClient.get(`/folders/${options.folder_id}`, {
+                query: { fields: "id,title,parent_id" },
+            });
+            if (!currentFolder || !currentFolder.id) {
+                return `Folder with ID "${options.folder_id}" not found.\n\nUse list_notebooks to see available folders and their IDs.`;
+            }
+            // Prepare the update body - only include fields that are being updated
+            const updateBody = {};
+            if (options.title !== undefined)
+                updateBody.title = options.title.trim();
+            if (options.parent_id !== undefined)
+                updateBody.parent_id = options.parent_id;
+            // Update the folder
+            const updatedFolder = await this.apiClient.put(`/folders/${options.folder_id}`, updateBody);
+            // Validate response
+            if (!updatedFolder || typeof updatedFolder !== "object" || !updatedFolder.id) {
+                return "Error: Unexpected response format from Joplin API when updating folder";
+            }
+            // Get parent folder info for both old and new locations if parent_id changed
+            let oldParentInfo = "Top level";
+            let newParentInfo = "Top level";
+            if (currentFolder.parent_id) {
+                try {
+                    const oldParent = await this.apiClient.get(`/folders/${currentFolder.parent_id}`, {
+                        query: { fields: "title" },
+                    });
+                    if (oldParent?.title) {
+                        oldParentInfo = `Inside "${oldParent.title}"`;
+                    }
+                }
+                catch (error) {
+                    oldParentInfo = `Parent ID: ${currentFolder.parent_id}`;
+                }
+            }
+            if (updatedFolder.parent_id && updatedFolder.parent_id !== currentFolder.parent_id) {
+                try {
+                    const newParent = await this.apiClient.get(`/folders/${updatedFolder.parent_id}`, {
+                        query: { fields: "title" },
+                    });
+                    if (newParent?.title) {
+                        newParentInfo = `Inside "${newParent.title}"`;
+                    }
+                }
+                catch (error) {
+                    newParentInfo = `Parent ID: ${updatedFolder.parent_id}`;
+                }
+            }
+            else if (updatedFolder.parent_id) {
+                newParentInfo = oldParentInfo;
+            }
+            // Format success response with before/after comparison
+            const resultLines = [];
+            resultLines.push(`✅ Successfully updated notebook!`);
+            resultLines.push("");
+            resultLines.push(`📁 Notebook: "${updatedFolder.title}"`);
+            resultLines.push(`   Folder ID: ${updatedFolder.id}`);
+            resultLines.push("");
+            // Show what changed
+            resultLines.push(`🔄 Changes made:`);
+            if (options.title !== undefined && currentFolder.title !== updatedFolder.title) {
+                resultLines.push(`   Title: "${currentFolder.title}" → "${updatedFolder.title}"`);
+            }
+            if (options.parent_id !== undefined && currentFolder.parent_id !== updatedFolder.parent_id) {
+                resultLines.push(`   Location: ${oldParentInfo} → ${newParentInfo}`);
+            }
+            if (updatedFolder.updated_time) {
+                const updatedTime = this.formatDate(updatedFolder.updated_time);
+                resultLines.push(`   Last Updated: ${updatedTime}`);
+            }
+            resultLines.push("");
+            resultLines.push(`🔗 Next steps:`);
+            resultLines.push(`   - View notebook: read_notebook notebook_id="${updatedFolder.id}"`);
+            resultLines.push(`   - View all notebooks: list_notebooks`);
+            if (updatedFolder.parent_id) {
+                resultLines.push(`   - View parent notebook: read_notebook notebook_id="${updatedFolder.parent_id}"`);
+            }
+            return resultLines.join("\n");
+        }
+        catch (error) {
+            if (error.response) {
+                if (error.response.status === 404) {
+                    if (error.config?.url?.includes(`/folders/${options.folder_id}`)) {
+                        return `Folder with ID "${options.folder_id}" not found.\n\nUse list_notebooks to see available folders and their IDs.`;
+                    }
+                    if (options.parent_id) {
+                        return `Error: Parent folder with ID "${options.parent_id}" not found.\n\nUse list_notebooks to see available folders and their IDs.`;
+                    }
+                }
+                if (error.response.status === 400) {
+                    return `Error updating folder: Invalid request data.\n\nPlease check your input parameters. ${error.response.data?.error || ""}`;
+                }
+                if (error.response.status === 409) {
+                    return `Error: A folder with the title "${options.title}" might already exist in this location.\n\nTry a different title or check existing folders with list_notebooks.`;
+                }
+            }
+            return this.formatError(error, "updating folder");
+        }
+    }
+}
+export default EditFolder;

package/dist/lib/tools/edit-note.d.ts

@@ -0,0 +1,15 @@
+import BaseTool from "./base-tool.js";
+interface EditNoteOptions {
+    note_id: string;
+    title?: string | undefined;
+    body?: string | undefined;
+    body_html?: string | undefined;
+    parent_id?: string | undefined;
+    is_todo?: boolean | undefined;
+    todo_completed?: boolean | undefined;
+    todo_due?: number | undefined;
+}
+declare class EditNote extends BaseTool {
+    call(options: EditNoteOptions): Promise<string>;
+}
+export default EditNote;

package/dist/lib/tools/edit-note.js

@@ -0,0 +1,153 @@
+import BaseTool from "./base-tool.js";
+class EditNote extends BaseTool {
+    async call(options) {
+        if (!options || typeof options !== "object") {
+            return 'Please provide note edit options. Example: edit_note {"note_id": "abc123", "title": "Updated Title"}';
+        }
+        // Validate required note_id
+        if (!options.note_id) {
+            return 'Please provide note edit options. Example: edit_note {"note_id": "abc123", "title": "Updated Title"}';
+        }
+        const noteIdError = this.validateId(options.note_id, "note");
+        if (noteIdError) {
+            return noteIdError;
+        }
+        // Validate that we have at least one field to update
+        const updateFields = ["title", "body", "body_html", "parent_id", "is_todo", "todo_completed", "todo_due"];
+        const hasUpdate = updateFields.some((field) => options[field] !== undefined);
+        if (!hasUpdate) {
+            return "Please provide at least one field to update. Available fields: title, body, body_html, parent_id, is_todo, todo_completed, todo_due";
+        }
+        // Validate parent_id if provided
+        if (options.parent_id !== undefined && options.parent_id !== null && options.parent_id !== "") {
+            if (options.parent_id.length < 10 || !options.parent_id.match(/[a-f0-9]/i)) {
+                return `Error: "${options.parent_id}" does not appear to be a valid notebook ID.\n\nNotebook IDs are long alphanumeric strings like "58a0a29f68bc4141b49c99f5d367638a".\n\nUse list_notebooks to see available notebooks and their IDs.`;
+            }
+        }
+        try {
+            // First, get the current note to show before/after comparison
+            const currentNote = await this.apiClient.get(`/notes/${options.note_id}`, {
+                query: { fields: "id,title,body,parent_id,is_todo,todo_completed,todo_due,updated_time" },
+            });
+            if (!currentNote || !currentNote.id) {
+                return `Note with ID "${options.note_id}" not found.\n\nUse search_notes to find notes and their IDs.`;
+            }
+            // Prepare the update body - only include fields that are being updated
+            const updateBody = {};
+            if (options.title !== undefined)
+                updateBody.title = options.title;
+            if (options.body !== undefined)
+                updateBody.body = options.body;
+            if (options.body_html !== undefined)
+                updateBody.body_html = options.body_html;
+            if (options.parent_id !== undefined)
+                updateBody.parent_id = options.parent_id;
+            if (options.is_todo !== undefined)
+                updateBody.is_todo = options.is_todo;
+            if (options.todo_completed !== undefined)
+                updateBody.todo_completed = options.todo_completed;
+            if (options.todo_due !== undefined)
+                updateBody.todo_due = options.todo_due;
+            // Update the note
+            const updatedNote = await this.apiClient.put(`/notes/${options.note_id}`, updateBody);
+            // Validate response
+            if (!updatedNote || typeof updatedNote !== "object" || !updatedNote.id) {
+                return "Error: Unexpected response format from Joplin API when updating note";
+            }
+            // Get notebook info for both old and new locations if parent_id changed
+            let oldNotebookInfo = "Root level";
+            let newNotebookInfo = "Root level";
+            if (currentNote.parent_id) {
+                try {
+                    const oldNotebook = await this.apiClient.get(`/folders/${currentNote.parent_id}`, {
+                        query: { fields: "title" },
+                    });
+                    if (oldNotebook?.title) {
+                        oldNotebookInfo = `"${oldNotebook.title}"`;
+                    }
+                }
+                catch (error) {
+                    oldNotebookInfo = `Notebook ID: ${currentNote.parent_id}`;
+                }
+            }
+            if (updatedNote.parent_id && updatedNote.parent_id !== currentNote.parent_id) {
+                try {
+                    const newNotebook = await this.apiClient.get(`/folders/${updatedNote.parent_id}`, {
+                        query: { fields: "title" },
+                    });
+                    if (newNotebook?.title) {
+                        newNotebookInfo = `"${newNotebook.title}"`;
+                    }
+                }
+                catch (error) {
+                    newNotebookInfo = `Notebook ID: ${updatedNote.parent_id}`;
+                }
+            }
+            else if (updatedNote.parent_id) {
+                newNotebookInfo = oldNotebookInfo;
+            }
+            // Format success response with before/after comparison
+            const resultLines = [];
+            resultLines.push(`✅ Successfully updated note!`);
+            resultLines.push("");
+            resultLines.push(`📝 Note: "${updatedNote.title || "Untitled"}"`);
+            resultLines.push(`   Note ID: ${updatedNote.id}`);
+            resultLines.push("");
+            // Show what changed
+            resultLines.push(`🔄 Changes made:`);
+            if (options.title !== undefined && currentNote.title !== updatedNote.title) {
+                resultLines.push(`   Title: "${currentNote.title}" → "${updatedNote.title}"`);
+            }
+            if (options.parent_id !== undefined && currentNote.parent_id !== updatedNote.parent_id) {
+                resultLines.push(`   Location: ${oldNotebookInfo} → ${newNotebookInfo}`);
+            }
+            if (options.is_todo !== undefined && currentNote.is_todo !== updatedNote.is_todo) {
+                const oldType = currentNote.is_todo ? "Todo" : "Regular note";
+                const newType = updatedNote.is_todo ? "Todo" : "Regular note";
+                resultLines.push(`   Type: ${oldType} → ${newType}`);
+            }
+            if (options.todo_completed !== undefined && currentNote.todo_completed !== updatedNote.todo_completed) {
+                const oldStatus = currentNote.todo_completed ? "Completed" : "Not completed";
+                const newStatus = updatedNote.todo_completed ? "Completed" : "Not completed";
+                resultLines.push(`   Todo Status: ${oldStatus} → ${newStatus}`);
+            }
+            if (options.todo_due !== undefined) {
+                const oldDue = currentNote.todo_due ? this.formatDate(currentNote.todo_due) : "No due date";
+                const newDue = updatedNote.todo_due ? this.formatDate(updatedNote.todo_due) : "No due date";
+                if (oldDue !== newDue) {
+                    resultLines.push(`   Due Date: ${oldDue} → ${newDue}`);
+                }
+            }
+            if (options.body !== undefined) {
+                resultLines.push(`   Content: Updated`);
+            }
+            if (options.body_html !== undefined) {
+                resultLines.push(`   HTML Content: Updated`);
+            }
+            const updatedTime = this.formatDate(updatedNote.updated_time);
+            resultLines.push(`   Last Updated: ${updatedTime}`);
+            resultLines.push("");
+            resultLines.push(`🔗 Next steps:`);
+            resultLines.push(`   - Read the note: read_note note_id="${updatedNote.id}"`);
+            if (updatedNote.parent_id) {
+                resultLines.push(`   - View notebook: read_notebook notebook_id="${updatedNote.parent_id}"`);
+            }
+            return resultLines.join("\n");
+        }
+        catch (error) {
+            if (error.response) {
+                if (error.response.status === 404) {
+                    return `Note with ID "${options.note_id}" not found.\n\nUse search_notes to find notes and their IDs.`;
+                }
+                if (error.response.status === 400) {
+                    return `Error updating note: Invalid request data.\n\nPlease check your input parameters. ${error.response.data?.error || ""}`;
+                }
+                if (error.response.status === 404 && options.parent_id) {
+                    return `Error: Notebook with ID "${options.parent_id}" not found.\n\nUse list_notebooks to see available notebooks and their IDs.`;
+                }
+            }
+            return this.formatError(error, "updating note");
+        }
+    }
+}
+export default EditNote;

package/dist/lib/tools/index.d.ts

@@ -0,0 +1,12 @@
+import ListNotebooks from "./list-notebooks.js";
+import SearchNotes from "./search-notes.js";
+import ReadNotebook from "./read-notebook.js";
+import ReadNote from "./read-note.js";
+import ReadMultiNote from "./read-multi-note.js";
+import CreateNote from "./create-note.js";
+import CreateFolder from "./create-folder.js";
+import EditNote from "./edit-note.js";
+import EditFolder from "./edit-folder.js";
+import DeleteNote from "./delete-note.js";
+import DeleteFolder from "./delete-folder.js";
+export { ListNotebooks, SearchNotes, ReadNotebook, ReadNote, ReadMultiNote, CreateNote, CreateFolder, EditNote, EditFolder, DeleteNote, DeleteFolder, };

package/dist/lib/tools/index.js

@@ -0,0 +1,12 @@
+import ListNotebooks from "./list-notebooks.js";
+import SearchNotes from "./search-notes.js";
+import ReadNotebook from "./read-notebook.js";
+import ReadNote from "./read-note.js";
+import ReadMultiNote from "./read-multi-note.js";
+import CreateNote from "./create-note.js";
+import CreateFolder from "./create-folder.js";
+import EditNote from "./edit-note.js";
+import EditFolder from "./edit-folder.js";
+import DeleteNote from "./delete-note.js";
+import DeleteFolder from "./delete-folder.js";
+export { ListNotebooks, SearchNotes, ReadNotebook, ReadNote, ReadMultiNote, CreateNote, CreateFolder, EditNote, EditFolder, DeleteNote, DeleteFolder, };

package/dist/lib/tools/list-notebooks.d.ts

@@ -0,0 +1,7 @@
+import BaseTool from "./base-tool.js";
+declare class ListNotebooks extends BaseTool {
+    call(): Promise<string>;
+    private notebooksLines;
+    private sortNotebooks;
+}
+export default ListNotebooks;

package/dist/lib/tools/list-notebooks.js

@@ -0,0 +1,59 @@
+import BaseTool from "./base-tool.js";
+class ListNotebooks extends BaseTool {
+    async call() {
+        try {
+            const notebooks = await this.apiClient.getAllItems("/folders", {
+                query: { fields: "id,title,parent_id" },
+            });
+            const notebooksByParentId = {};
+            notebooks.forEach((notebook) => {
+                const parentId = notebook.parent_id || "";
+                if (!notebooksByParentId[parentId]) {
+                    notebooksByParentId[parentId] = [];
+                }
+                notebooksByParentId[parentId].push(notebook);
+            });
+            // Add a header with instructions
+            const resultLines = [
+                "Joplin Notebooks:\n",
+                "NOTE: To read a notebook, use the notebook_id with the read_notebook command\n",
+                'Example: read_notebook notebook_id="your-notebook-id"\n\n',
+            ];
+            // Add the notebook hierarchy
+            resultLines.push(...this.notebooksLines(notebooksByParentId[""] || [], {
+                indent: 0,
+                notebooksByParentId,
+            }));
+            return resultLines.join("");
+        }
+        catch (error) {
+            return this.formatError(error, "listing notebooks");
+        }
+    }
+    notebooksLines(notebooks, { indent = 0, notebooksByParentId, }) {
+        const result = [];
+        const indentSpaces = " ".repeat(indent);
+        this.sortNotebooks(notebooks).forEach((notebook) => {
+            const id = notebook.id;
+            result.push(`${indentSpaces}Notebook: "${notebook.title}" (notebook_id: "${id}")\n`);
+            const childNotebooks = notebooksByParentId[id];
+            if (childNotebooks) {
+                result.push(...this.notebooksLines(childNotebooks, {
+                    indent: indent + 2,
+                    notebooksByParentId,
+                }));
+            }
+        });
+        return result;
+    }
+    sortNotebooks(notebooks) {
+        // Ensure that notebooks starting with '[0]' are sorted first
+        const CHARACTER_BEFORE_A = String.fromCharCode("A".charCodeAt(0) - 1);
+        return [...notebooks].sort((a, b) => {
+            const titleA = a.title.replace("[", CHARACTER_BEFORE_A);
+            const titleB = b.title.replace("[", CHARACTER_BEFORE_A);
+            return titleA.localeCompare(titleB);
+        });
+    }
+}
+export default ListNotebooks;

package/dist/lib/tools/read-multi-note.d.ts

@@ -0,0 +1,5 @@
+import BaseTool from "./base-tool.js";
+declare class ReadMultiNote extends BaseTool {
+    call(noteIds: string[]): Promise<string>;
+}
+export default ReadMultiNote;