joplin-mcp-server 1.0.0

package/dist/lib/tools/read-multi-note.js

@@ -0,0 +1,108 @@
+import BaseTool from "./base-tool.js";
+class ReadMultiNote extends BaseTool {
+    async call(noteIds) {
+        if (!noteIds || !Array.isArray(noteIds) || noteIds.length === 0) {
+            return 'Please provide an array of note IDs. Example: read_multinote note_ids=["id1", "id2", "id3"]';
+        }
+        // Validate that all IDs look like valid note IDs
+        const invalidIds = noteIds.filter((id) => !id || id.length < 10 || !id.match(/[a-f0-9]/i));
+        if (invalidIds.length > 0) {
+            return `Error: Some IDs do not appear to be valid note IDs: ${invalidIds.join(", ")}\n\nNote IDs are long alphanumeric strings like "58a0a29f68bc4141b49c99f5d367638a".\n\nUse search_notes to find notes and their IDs.`;
+        }
+        const resultLines = [];
+        const notFound = [];
+        const errors = [];
+        const successful = [];
+        // Add a header
+        resultLines.push(`# Reading ${noteIds.length} notes\n`);
+        // Process each note ID
+        for (let i = 0; i < noteIds.length; i++) {
+            const noteId = noteIds[i];
+            resultLines.push(`## Note ${i + 1} of ${noteIds.length} (ID: ${noteId})\n`);
+            try {
+                // Get the note details with all relevant fields
+                const note = await this.apiClient.get(`/notes/${noteId}`, {
+                    query: {
+                        fields: "id,title,body,parent_id,created_time,updated_time,is_todo,todo_completed,todo_due",
+                    },
+                });
+                // Validate note response
+                if (!note || typeof note !== "object" || !note.id) {
+                    errors.push(noteId);
+                    resultLines.push(`Error: Unexpected response format from Joplin API when fetching note ${noteId}\n`);
+                    continue;
+                }
+                successful.push(noteId);
+                // Get the notebook info to show where this note is located
+                let notebookInfo = "Unknown notebook";
+                if (note.parent_id) {
+                    try {
+                        const notebook = await this.apiClient.get(`/folders/${note.parent_id}`, {
+                            query: { fields: "id,title" },
+                        });
+                        if (notebook && notebook.title) {
+                            notebookInfo = `"${notebook.title}" (notebook_id: "${note.parent_id}")`;
+                        }
+                    }
+                    catch (error) {
+                        process.stderr.write(`Error fetching notebook info for note ${noteId}: ${error}\n`);
+                        // Continue even if we can't get the notebook info
+                    }
+                }
+                // Add note metadata
+                resultLines.push(`### Note: "${note.title}"`);
+                resultLines.push(`Notebook: ${notebookInfo}`);
+                // Add todo status if applicable
+                if (note.is_todo) {
+                    const status = note.todo_completed ? "Completed" : "Not completed";
+                    resultLines.push(`Status: ${status}`);
+                    if (note.todo_due) {
+                        const dueDate = this.formatDate(note.todo_due);
+                        resultLines.push(`Due: ${dueDate}`);
+                    }
+                }
+                // Add timestamps
+                const createdDate = this.formatDate(note.created_time);
+                const updatedDate = this.formatDate(note.updated_time);
+                resultLines.push(`Created: ${createdDate}`);
+                resultLines.push(`Updated: ${updatedDate}`);
+                // Add a separator before the note content
+                resultLines.push("\n---\n");
+                // Add the note body
+                if (note.body) {
+                    resultLines.push(note.body);
+                }
+                else {
+                    resultLines.push("(This note has no content)");
+                }
+                // Add a separator after the note
+                resultLines.push("\n---\n");
+            }
+            catch (error) {
+                process.stderr.write(`Error reading note ${noteId}: ${error}\n`);
+                if (error.response && error.response.status === 404) {
+                    notFound.push(noteId);
+                    resultLines.push(`Note with ID "${noteId}" not found.\n`);
+                }
+                else {
+                    errors.push(noteId);
+                    resultLines.push(`Error reading note: ${error.message || "Unknown error"}\n`);
+                }
+            }
+        }
+        // Add a summary at the end
+        resultLines.push("# Summary");
+        resultLines.push(`Total notes requested: ${noteIds.length}`);
+        resultLines.push(`Successfully retrieved: ${successful.length}`);
+        if (notFound.length > 0) {
+            resultLines.push(`Notes not found: ${notFound.length}`);
+            resultLines.push(`IDs not found: ${notFound.join(", ")}`);
+        }
+        if (errors.length > 0) {
+            resultLines.push(`Errors encountered: ${errors.length}`);
+            resultLines.push(`IDs with errors: ${errors.join(", ")}`);
+        }
+        return resultLines.join("\n");
+    }
+}
+export default ReadMultiNote;

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

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

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

@@ -0,0 +1,80 @@
+import BaseTool from "./base-tool.js";
+class ReadNote extends BaseTool {
+    async call(noteId) {
+        const validationError = this.validateId(noteId, "note");
+        if (validationError) {
+            return validationError;
+        }
+        try {
+            // Get the note details with all relevant fields
+            const note = await this.apiClient.get(`/notes/${noteId}`, {
+                query: {
+                    fields: "id,title,body,parent_id,created_time,updated_time,is_todo,todo_completed,todo_due",
+                },
+            });
+            // Validate note response
+            if (!note || typeof note !== "object" || !note.id) {
+                return `Error: Unexpected response format from Joplin API when fetching note`;
+            }
+            // Get the notebook info to show where this note is located
+            let notebookInfo = "Unknown notebook";
+            if (note.parent_id) {
+                try {
+                    const notebook = await this.apiClient.get(`/folders/${note.parent_id}`, {
+                        query: { fields: "id,title" },
+                    });
+                    if (notebook && notebook.title) {
+                        notebookInfo = `"${notebook.title}" (notebook_id: "${note.parent_id}")`;
+                    }
+                }
+                catch (error) {
+                    process.stderr.write(`Error fetching notebook info: ${error}\n`);
+                    // Continue even if we can't get the notebook info
+                }
+            }
+            // Format the note content
+            const resultLines = [];
+            // Add note header with metadata
+            resultLines.push(`# Note: "${note.title}"`);
+            resultLines.push(`Note ID: ${note.id}`);
+            resultLines.push(`Notebook: ${notebookInfo}`);
+            // Add todo status if applicable
+            if (note.is_todo) {
+                const status = note.todo_completed ? "Completed" : "Not completed";
+                resultLines.push(`Status: ${status}`);
+                if (note.todo_due) {
+                    const dueDate = this.formatDate(note.todo_due);
+                    resultLines.push(`Due: ${dueDate}`);
+                }
+            }
+            // Add timestamps
+            const createdDate = this.formatDate(note.created_time);
+            const updatedDate = this.formatDate(note.updated_time);
+            resultLines.push(`Created: ${createdDate}`);
+            resultLines.push(`Updated: ${updatedDate}`);
+            // Add a separator before the note content
+            resultLines.push("\n---\n");
+            // Add the note body
+            if (note.body) {
+                resultLines.push(note.body);
+            }
+            else {
+                resultLines.push("(This note has no content)");
+            }
+            // Add a footer with helpful commands
+            resultLines.push("\n---\n");
+            resultLines.push("Related commands:");
+            resultLines.push(`- To view the notebook containing this note: read_notebook notebook_id="${note.parent_id}"`);
+            resultLines.push('- To search for more notes: search_notes query="your search term"');
+            return resultLines.join("\n");
+        }
+        catch (error) {
+            if (error.response && error.response.status === 404) {
+                return `Note with ID "${noteId}" not found.\n\nThis might happen if:\n1. The ID is incorrect\n2. You're using a notebook ID instead of a note ID\n3. The note has been deleted\n\nUse search_notes to find notes and their IDs.`;
+            }
+            return (this.formatError(error, "reading note") +
+                `\n\nMake sure you're using a valid note ID.\nUse search_notes to find notes and their IDs.`);
+        }
+    }
+}
+export default ReadNote;

package/dist/lib/tools/read-notebook.d.ts

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

package/dist/lib/tools/read-notebook.js

@@ -0,0 +1,66 @@
+import BaseTool from "./base-tool.js";
+class ReadNotebook extends BaseTool {
+    async call(notebookId) {
+        const validationError = this.validateId(notebookId, "notebook");
+        if (validationError) {
+            return validationError;
+        }
+        try {
+            // First, get the notebook details
+            const notebook = await this.apiClient.get(`/folders/${notebookId}`, {
+                query: { fields: "id,title,parent_id" },
+            });
+            // Validate notebook response
+            if (!notebook || typeof notebook !== "object" || !notebook.id) {
+                return `Error: Unexpected response format from Joplin API when fetching notebook`;
+            }
+            // Get all notes in this notebook
+            const notes = await this.apiClient.get(`/folders/${notebookId}/notes`, {
+                query: { fields: "id,title,updated_time,is_todo,todo_completed" },
+            });
+            // Validate notes response
+            if (!notes || typeof notes !== "object") {
+                return `Error: Unexpected response format from Joplin API when fetching notes`;
+            }
+            if (!notes.items || !Array.isArray(notes.items) || notes.items.length === 0) {
+                return `Notebook "${notebook.title}" (notebook_id: "${notebook.id}") is empty.\n\nTry another notebook ID or use list_notebooks to see all available notebooks.`;
+            }
+            // Format the notebook contents
+            const resultLines = [];
+            resultLines.push(`# Notebook: "${notebook.title}" (notebook_id: "${notebook.id}")`);
+            resultLines.push(`Contains ${notes.items.length} notes:\n`);
+            resultLines.push(`NOTE: This is showing the contents of notebook "${notebook.title}", not a specific note.\n`);
+            // If multiple notes were found, add a hint about read_multinote
+            if (notes.items.length > 1) {
+                const noteIds = notes.items.map((note) => note.id);
+                resultLines.push(`TIP: To read all ${notes.items.length} notes at once, use:\n`);
+                resultLines.push(`read_multinote note_ids=${JSON.stringify(noteIds)}\n`);
+            }
+            // Sort notes by updated_time (newest first)
+            const sortedNotes = [...notes.items].sort((a, b) => b.updated_time - a.updated_time);
+            sortedNotes.forEach((note) => {
+                const updatedDate = this.formatDate(note.updated_time);
+                // Add checkbox for todos
+                if (note.is_todo) {
+                    const checkboxStatus = note.todo_completed ? "✅" : "☐";
+                    resultLines.push(`- ${checkboxStatus} Note: "${note.title}" (note_id: "${note.id}")`);
+                }
+                else {
+                    resultLines.push(`- Note: "${note.title}" (note_id: "${note.id}")`);
+                }
+                resultLines.push(`  Updated: ${updatedDate}`);
+                resultLines.push(`  To read this note: read_note note_id="${note.id}"`);
+                resultLines.push(""); // Empty line between notes
+            });
+            return resultLines.join("\n");
+        }
+        catch (error) {
+            if (error.response && error.response.status === 404) {
+                return `Notebook with ID "${notebookId}" not found.\n\nThis might happen if:\n1. The ID is incorrect\n2. You're using a note title instead of a notebook ID\n3. The notebook has been deleted\n\nUse list_notebooks to see all available notebooks with their IDs.`;
+            }
+            return (this.formatError(error, "reading notebook") +
+                `\n\nMake sure you're using a valid notebook ID, not a note title.\nUse list_notebooks to see all available notebooks with their IDs.`);
+        }
+    }
+}
+export default ReadNotebook;

package/dist/lib/tools/search-notes.d.ts

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

package/dist/lib/tools/search-notes.js

@@ -0,0 +1,68 @@
+import BaseTool from "./base-tool.js";
+class SearchNotes extends BaseTool {
+    async call(query) {
+        if (!query) {
+            return "Please provide a search query.";
+        }
+        try {
+            // Search for notes with the given query
+            const searchResults = await this.apiClient.get("/search", {
+                query: {
+                    query,
+                    fields: "id,title,body,parent_id,updated_time",
+                },
+            });
+            // Handle case where the API doesn't return the expected structure
+            if (!searchResults || typeof searchResults !== "object") {
+                return `Error: Unexpected response format from Joplin API`;
+            }
+            // Handle case where no items were found
+            if (!searchResults.items || !Array.isArray(searchResults.items) || searchResults.items.length === 0) {
+                return `No notes found matching query: "${query}"`;
+            }
+            // Get all folders to be able to show notebook names
+            const folders = await this.apiClient.getAllItems("/folders", {
+                query: {
+                    fields: "id,title",
+                },
+            });
+            // Create a map of folder IDs to folder titles for quick lookup
+            const folderMap = {};
+            folders.forEach((folder) => {
+                folderMap[folder.id] = folder.title;
+            });
+            // Format the search results
+            const resultLines = [];
+            resultLines.push(`Found ${searchResults.items.length} notes matching query: "${query}"\n`);
+            resultLines.push(`NOTE: To read a notebook, use the notebook ID (not the note title)\n`);
+            // If multiple notes were found, add a hint about read_multinote
+            if (searchResults.items.length > 1) {
+                const noteIds = searchResults.items.map((note) => note.id);
+                resultLines.push(`TIP: To read all ${searchResults.items.length} notes at once, use:\n`);
+                resultLines.push(`read_multinote note_ids=${JSON.stringify(noteIds)}\n`);
+            }
+            searchResults.items.forEach((note) => {
+                const notebookTitle = folderMap[note.parent_id || ""] || "Unknown notebook";
+                const notebookId = note.parent_id || "unknown";
+                const updatedDate = this.formatDate(note.updated_time);
+                resultLines.push(`- Note: "${note.title}" (note_id: "${note.id}")`);
+                resultLines.push(`  Notebook: "${notebookTitle}" (notebook_id: "${notebookId}")`);
+                resultLines.push(`  Updated: ${updatedDate}`);
+                // Add a snippet of the note body if available
+                if (note.body) {
+                    const snippet = note.body.substring(0, 100).replace(/\n/g, " ") + (note.body.length > 100 ? "..." : "");
+                    resultLines.push(`  Snippet: ${snippet}`);
+                }
+                // Add hints for using related commands
+                resultLines.push(`  To read this note: read_note note_id="${note.id}"`);
+                resultLines.push(`  To read this notebook: read_notebook notebook_id="${notebookId}"`);
+                resultLines.push(""); // Empty line between notes
+            });
+            return resultLines.join("\n");
+        }
+        catch (error) {
+            return this.formatError(error, "searching notes");
+        }
+    }
+}
+export default SearchNotes;

package/dist/tests/integration/joplin-integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/integration/joplin-integration.test.js

@@ -0,0 +1,117 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import JoplinAPIClient from "../../lib/joplin-api-client.js";
+import { ListNotebooks, SearchNotes, ReadNotebook } from "../../lib/tools/index.js";
+describe("Joplin Integration Tests", () => {
+    let client;
+    let skipTests = false;
+    beforeAll(async () => {
+        // Check if we have the required environment variables for integration tests
+        if (!process.env.JOPLIN_TOKEN || !process.env.JOPLIN_PORT) {
+            console.warn("Skipping integration tests: JOPLIN_TOKEN or JOPLIN_PORT not set");
+            skipTests = true;
+            return;
+        }
+        client = new JoplinAPIClient({
+            port: parseInt(process.env.JOPLIN_PORT),
+            token: process.env.JOPLIN_TOKEN,
+        });
+        // Check if Joplin is actually running and accessible
+        try {
+            const isAvailable = await client.serviceAvailable();
+            if (!isAvailable) {
+                console.warn("Skipping integration tests: Joplin service not available");
+                skipTests = true;
+            }
+        }
+        catch (error) {
+            console.warn("Skipping integration tests: Cannot connect to Joplin");
+            skipTests = true;
+        }
+    });
+    describe("Joplin API Client Integration", () => {
+        it("should connect to Joplin service", async () => {
+            if (skipTests)
+                return;
+            const isAvailable = await client.serviceAvailable();
+            expect(isAvailable).toBe(true);
+        });
+        it("should fetch folders from Joplin", async () => {
+            if (skipTests)
+                return;
+            const folders = await client.get("/folders", {
+                query: { limit: 5, fields: "id,title,parent_id" },
+            });
+            expect(folders).toHaveProperty("items");
+            expect(Array.isArray(folders.items)).toBe(true);
+            expect(folders).toHaveProperty("has_more");
+        });
+        it("should fetch notes from Joplin", async () => {
+            if (skipTests)
+                return;
+            const notes = await client.get("/notes", {
+                query: { limit: 5, fields: "id,title,parent_id" },
+            });
+            expect(notes).toHaveProperty("items");
+            expect(Array.isArray(notes.items)).toBe(true);
+        });
+    });
+    describe("Tools Integration", () => {
+        it("should list notebooks using ListNotebooks tool", async () => {
+            if (skipTests)
+                return;
+            const tool = new ListNotebooks(client);
+            const result = await tool.call();
+            expect(typeof result).toBe("string");
+            expect(result).toContain("Joplin Notebooks:");
+            expect(result).toContain("notebook_id:");
+        });
+        it("should search notes using SearchNotes tool", async () => {
+            if (skipTests)
+                return;
+            // First, let's check if there are any notes to search
+            const notes = await client.get("/notes", { query: { limit: 1 } });
+            if (notes.items.length === 0) {
+                console.warn("Skipping search test: No notes found in Joplin");
+                return;
+            }
+            const tool = new SearchNotes(client);
+            const result = await tool.call("test");
+            expect(typeof result).toBe("string");
+            // The result should either contain matching notes or indicate no matches
+            expect(result).toMatch(/(Found \d+ notes|No notes found)/);
+        });
+        it("should read a notebook using ReadNotebook tool", async () => {
+            if (skipTests)
+                return;
+            // First get a notebook ID
+            const folders = await client.get("/folders", {
+                query: { limit: 1, fields: "id,title" },
+            });
+            if (folders.items.length === 0) {
+                console.warn("Skipping read notebook test: No notebooks found");
+                return;
+            }
+            const notebookId = folders.items[0].id;
+            const tool = new ReadNotebook(client);
+            const result = await tool.call(notebookId);
+            expect(typeof result).toBe("string");
+            expect(result).toContain("Notebook:");
+            expect(result).toContain(notebookId);
+        });
+    });
+    describe("Error Handling", () => {
+        it("should handle invalid API calls gracefully", async () => {
+            if (skipTests)
+                return;
+            await expect(client.get("/invalid-endpoint")).rejects.toThrow();
+        });
+        it("should handle invalid notebook ID in ReadNotebook tool", async () => {
+            if (skipTests)
+                return;
+            const tool = new ReadNotebook(client);
+            const result = await tool.call("invalid-notebook-id");
+            expect(typeof result).toBe("string");
+            expect(result).toContain("Error:");
+        });
+    });
+});

package/dist/tests/manual/create-folder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/manual/create-folder.test.js

@@ -0,0 +1,81 @@
+import dotenv from "dotenv";
+import JoplinAPIClient from "../../lib/joplin-api-client.js";
+import { CreateFolder, ListNotebooks } from "../../lib/tools/index.js";
+// Load environment variables
+dotenv.config();
+// Check for required environment variables
+const requiredEnvVars = ["JOPLIN_PORT", "JOPLIN_TOKEN"];
+for (const envVar of requiredEnvVars) {
+    if (!process.env[envVar]) {
+        console.error(`Error: ${envVar} environment variable is required`);
+        process.exit(1);
+    }
+}
+// Create the Joplin API client
+const apiClient = new JoplinAPIClient({
+    port: parseInt(process.env.JOPLIN_PORT),
+    token: process.env.JOPLIN_TOKEN,
+});
+// Create the tools
+const createFolder = new CreateFolder(apiClient);
+const listNotebooks = new ListNotebooks(apiClient);
+// Test the create folder functionality
+async function testCreateFolder() {
+    try {
+        // Check if Joplin is available
+        const available = await apiClient.serviceAvailable();
+        if (!available) {
+            console.error("Error: Joplin service is not available");
+            process.exit(1);
+        }
+        // Parse command line arguments
+        const args = process.argv.slice(2);
+        const title = args[0] || `Test Notebook ${new Date().toISOString()}`;
+        const parentId = args[1]; // Optional parent notebook ID
+        console.log("Creating notebook with:");
+        console.log(`  Title: "${title}"`);
+        if (parentId) {
+            console.log(`  Parent Notebook ID: "${parentId}"`);
+        }
+        else {
+            console.log("  Location: Top level (no parent specified)");
+        }
+        console.log("");
+        // Create the folder
+        const createOptions = { title };
+        if (parentId) {
+            createOptions.parent_id = parentId;
+        }
+        const result = await createFolder.call(createOptions);
+        console.log(result);
+        console.log("\n📋 Updated notebook hierarchy:");
+        const notebooks = await listNotebooks.call();
+        console.log(notebooks);
+    }
+    catch (error) {
+        console.error("Error testing create folder:", error);
+    }
+}
+// Show usage if help requested
+if (process.argv.includes("--help") || process.argv.includes("-h")) {
+    console.log(`
+Usage: tsx tests/manual/create-folder.test.ts [title] [parent_id]
+
+Arguments:
+  title     - Notebook title (optional, defaults to timestamped title)
+  parent_id - ID of parent notebook to create subfolder in (optional, creates at top level if omitted)
+
+Examples:
+  tsx tests/manual/create-folder.test.ts
+  tsx tests/manual/create-folder.test.ts "My Notebook"
+  tsx tests/manual/create-folder.test.ts "My Subfolder" "a1b2c3d4e5f6..."
+
+First run list_notebooks to see available notebook IDs:
+  npm run test:manual:list-notebooks
+`);
+    process.exit(0);
+}
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    testCreateFolder();
+}

package/dist/tests/manual/create-note.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/manual/create-note.test.js

@@ -0,0 +1,84 @@
+import dotenv from "dotenv";
+import JoplinAPIClient from "../../lib/joplin-api-client.js";
+import { CreateNote, ListNotebooks } from "../../lib/tools/index.js";
+// Load environment variables
+dotenv.config();
+// Check for required environment variables
+const requiredEnvVars = ["JOPLIN_PORT", "JOPLIN_TOKEN"];
+for (const envVar of requiredEnvVars) {
+    if (!process.env[envVar]) {
+        console.error(`Error: ${envVar} environment variable is required`);
+        process.exit(1);
+    }
+}
+// Create the Joplin API client
+const apiClient = new JoplinAPIClient({
+    port: parseInt(process.env.JOPLIN_PORT),
+    token: process.env.JOPLIN_TOKEN,
+});
+// Create the tools
+const createNote = new CreateNote(apiClient);
+const listNotebooks = new ListNotebooks(apiClient);
+// Test the create note functionality
+async function testCreateNote() {
+    try {
+        // Check if Joplin is available
+        const available = await apiClient.serviceAvailable();
+        if (!available) {
+            console.error("Error: Joplin service is not available");
+            process.exit(1);
+        }
+        // Parse command line arguments
+        const args = process.argv.slice(2);
+        const title = args[0] || `Test Note ${new Date().toISOString()}`;
+        const body = args[1] || `This is a test note created at ${new Date().toLocaleString()}`;
+        const notebookId = args[2]; // Optional notebook ID
+        console.log("Creating note with:");
+        console.log(`  Title: "${title}"`);
+        console.log(`  Body: "${body}"`);
+        if (notebookId) {
+            console.log(`  Notebook ID: "${notebookId}"`);
+        }
+        else {
+            console.log("  Location: Root level (no notebook specified)");
+        }
+        console.log("");
+        // Create the note
+        const createOptions = { title, body };
+        if (notebookId) {
+            createOptions.parent_id = notebookId;
+        }
+        const result = await createNote.call(createOptions);
+        console.log(result);
+        console.log("\n📋 Available notebooks:");
+        const notebooks = await listNotebooks.call();
+        console.log(notebooks);
+    }
+    catch (error) {
+        console.error("Error testing create note:", error);
+    }
+}
+// Show usage if help requested
+if (process.argv.includes("--help") || process.argv.includes("-h")) {
+    console.log(`
+Usage: tsx tests/manual/create-note.test.ts [title] [body] [notebook_id]
+
+Arguments:
+  title       - Note title (optional, defaults to timestamped title)
+  body        - Note body content (optional, defaults to timestamped content)
+  notebook_id - ID of notebook to create note in (optional, creates in root if omitted)
+
+Examples:
+  tsx tests/manual/create-note.test.ts
+  tsx tests/manual/create-note.test.ts "My Note" "My note content"
+  tsx tests/manual/create-note.test.ts "My Note" "My note content" "a1b2c3d4e5f6..."
+
+First run list_notebooks to see available notebook IDs:
+  npm run test:manual:list-notebooks
+`);
+    process.exit(0);
+}
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    testCreateNote();
+}

package/dist/tests/manual/delete-folder.test.d.ts

@@ -0,0 +1 @@
+export {};