@disco_trooper/apple-notes-mcp 1.0.1 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@disco_trooper/apple-notes-mcp",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "MCP server for Apple Notes with semantic search and CRUD operations",
   "type": "module",
   "main": "src/index.ts",

package/src/notes/crud.test.ts

@@ -22,9 +22,15 @@ vi.mock("../utils/debug.js", () => ({
   createDebugLogger: vi.fn(() => vi.fn()),
 }));
 
+vi.mock("./tables.js", () => ({
+  findTables: vi.fn(),
+  updateTableCell: vi.fn(),
+}));
+
 import { runJxa } from "run-jxa";
-import { checkReadOnly, createNote, updateNote, deleteNote, moveNote } from "./crud.js";
+import { checkReadOnly, createNote, updateNote, deleteNote, moveNote, editTable } from "./crud.js";
 import { resolveNoteTitle } from "./read.js";
+import { findTables, updateTableCell } from "./tables.js";
 
 describe("checkReadOnly", () => {
   const originalEnv = process.env.READONLY_MODE;
@@ -197,3 +203,57 @@ describe("moveNote", () => {
     await expect(moveNote("Note", "Archive")).rejects.toThrow("Suggestions: Work/Note, Personal/Note");
   });
 });
+
+describe("editTable", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    delete process.env.READONLY_MODE;
+  });
+
+  it("should throw if READONLY_MODE is enabled", async () => {
+    process.env.READONLY_MODE = "true";
+    await expect(editTable("Test", 0, [])).rejects.toThrow("read-only mode");
+  });
+
+  it("should throw if note not found", async () => {
+    vi.mocked(resolveNoteTitle).mockResolvedValueOnce({
+      success: false,
+      error: "Note not found",
+    });
+    await expect(editTable("Missing", 0, [{ row: 0, column: 0, value: "x" }])).rejects.toThrow("Note not found");
+  });
+
+  it("should throw if table index out of bounds", async () => {
+    vi.mocked(resolveNoteTitle).mockResolvedValueOnce({
+      success: true,
+      note: { id: "123", title: "Test", folder: "Work" },
+    });
+    vi.mocked(runJxa).mockResolvedValueOnce(JSON.stringify({ html: "<div>No tables</div>" }));
+    vi.mocked(findTables).mockReturnValueOnce([]);
+
+    await expect(editTable("Test", 0, [{ row: 0, column: 0, value: "x" }]))
+      .rejects.toThrow("Table index 0 out of bounds");
+  });
+
+  it("should update table cells and save", async () => {
+    vi.mocked(resolveNoteTitle).mockResolvedValueOnce({
+      success: true,
+      note: { id: "123", title: "Test", folder: "Work" },
+    });
+    vi.mocked(runJxa)
+      .mockResolvedValueOnce(JSON.stringify({ html: "<div><object><table></table></object></div>" }))
+      .mockResolvedValueOnce("ok");
+    vi.mocked(findTables).mockReturnValueOnce(["<object><table></table></object>"]);
+    vi.mocked(updateTableCell).mockReturnValueOnce("<object><table>updated</table></object>");
+
+    await expect(editTable("Test", 0, [{ row: 1, column: 0, value: "✅ Done" }]))
+      .resolves.toBeUndefined();
+
+    expect(updateTableCell).toHaveBeenCalledWith(
+      "<object><table></table></object>",
+      1,
+      0,
+      "✅ Done"
+    );
+  });
+});

package/src/notes/crud.ts

@@ -9,6 +9,7 @@ import { runJxa } from "run-jxa";
 import { marked } from "marked";
 import { resolveNoteTitle } from "./read.js";
 import { createDebugLogger } from "../utils/debug.js";
+import { findTables, updateTableCell } from "./tables.js";
 
 // Debug logging
 const debug = createDebugLogger("CRUD");
@@ -255,3 +256,78 @@ export async function moveNote(title: string, folder: string): Promise<void> {
 
   debug(`Note moved: "${title}" -> "${folder}"`);
 }
+
+export interface TableEdit {
+  row: number;
+  column: number;
+  value: string;
+}
+
+/**
+ * Edit cells in a table within a note.
+ *
+ * @param title - Note title (supports folder prefix)
+ * @param tableIndex - Which table to edit (0-based)
+ * @param edits - Array of cell edits to apply
+ */
+export async function editTable(
+  title: string,
+  tableIndex: number,
+  edits: TableEdit[]
+): Promise<void> {
+  checkReadOnly();
+
+  debug(`Editing table ${tableIndex} in note: "${title}"`);
+
+  // Resolve the note
+  const resolved = await resolveNoteTitle(title);
+  if (!resolved.success || !resolved.note) {
+    if (resolved.suggestions && resolved.suggestions.length > 0) {
+      throw new Error(
+        `${resolved.error} Suggestions: ${resolved.suggestions.join(", ")}`
+      );
+    }
+    throw new Error(resolved.error || `Note not found: "${title}"`);
+  }
+
+  // Get current HTML content
+  const escapedNoteId = JSON.stringify(resolved.note.id);
+  const htmlResult = await runJxa(`
+    const app = Application('Notes');
+    const note = app.notes.byId(${escapedNoteId});
+    if (!note.exists()) {
+      throw new Error("Note no longer exists");
+    }
+    return JSON.stringify({ html: note.body() });
+  `);
+
+  const { html } = JSON.parse(htmlResult as string);
+
+  // Find all tables
+  const tables = findTables(html);
+  if (tableIndex >= tables.length) {
+    throw new Error(
+      `Table index ${tableIndex} out of bounds (note has ${tables.length} tables)`
+    );
+  }
+
+  // Apply edits to the target table
+  let updatedTable = tables[tableIndex];
+  for (const edit of edits) {
+    updatedTable = updateTableCell(updatedTable, edit.row, edit.column, edit.value);
+  }
+
+  // Replace the table in the full HTML
+  const updatedHtml = html.replace(tables[tableIndex], updatedTable);
+
+  // Save back to Apple Notes
+  const escapedHtml = JSON.stringify(updatedHtml);
+  await runJxa(`
+    const app = Application('Notes');
+    const note = app.notes.byId(${escapedNoteId});
+    note.body = ${escapedHtml};
+    return "ok";
+  `);
+
+  debug(`Table ${tableIndex} updated in note: "${title}"`);
+}

package/src/notes/tables.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from "vitest";
+import { parseTable, updateTableCell, findTables } from "./tables.js";
+
+const SAMPLE_TABLE_HTML = `<object><table cellspacing="0" cellpadding="0" style="border-collapse: collapse">
+<tbody>
+<tr><td valign="top" style="border-style: solid"><div><b>Typ</b></div></td><td valign="top" style="border-style: solid"><div><b>Částka</b></div></td></tr>
+<tr><td valign="top" style="border-style: solid"><div>Sociální</div></td><td valign="top" style="border-style: solid"><div>9 154 Kč</div></td></tr>
+<tr><td valign="top" style="border-style: solid"><div>Zdravotní</div></td><td valign="top" style="border-style: solid"><div>3 848 Kč</div></td></tr>
+</tbody>
+</table></object>`;
+
+describe("parseTable", () => {
+  it("should parse table rows and cells", () => {
+    const result = parseTable(SAMPLE_TABLE_HTML);
+    expect(result.rows).toHaveLength(3);
+    expect(result.rows[0]).toEqual(["Typ", "Částka"]);
+    expect(result.rows[1]).toEqual(["Sociální", "9 154 Kč"]);
+    expect(result.rows[2]).toEqual(["Zdravotní", "3 848 Kč"]);
+  });
+
+  it("should preserve bold formatting info", () => {
+    const result = parseTable(SAMPLE_TABLE_HTML);
+    expect(result.formatting[0][0].bold).toBe(true);
+    expect(result.formatting[1][0].bold).toBe(false);
+  });
+
+  it("should return empty for non-table HTML", () => {
+    const result = parseTable("<div>Not a table</div>");
+    expect(result.rows).toHaveLength(0);
+  });
+});
+
+describe("updateTableCell", () => {
+  it("should update cell content", () => {
+    const updated = updateTableCell(SAMPLE_TABLE_HTML, 1, 0, "✅ Sociální");
+    expect(updated).toContain("✅ Sociální");
+  });
+
+  it("should preserve table structure", () => {
+    const updated = updateTableCell(SAMPLE_TABLE_HTML, 1, 0, "✅ Sociální");
+    expect(updated).toContain("<object>");
+    expect(updated).toContain("</table></object>");
+  });
+
+  it("should throw for out of bounds row", () => {
+    expect(() => updateTableCell(SAMPLE_TABLE_HTML, 10, 0, "test")).toThrow("Row 10 out of bounds");
+  });
+
+  it("should throw for out of bounds column", () => {
+    expect(() => updateTableCell(SAMPLE_TABLE_HTML, 0, 10, "test")).toThrow("Column 10 out of bounds");
+  });
+});
+
+describe("findTables", () => {
+  it("should find single table", () => {
+    const tables = findTables(SAMPLE_TABLE_HTML);
+    expect(tables).toHaveLength(1);
+  });
+
+  it("should find multiple tables", () => {
+    const html = `<div>${SAMPLE_TABLE_HTML}</div><p>text</p>${SAMPLE_TABLE_HTML}`;
+    const tables = findTables(html);
+    expect(tables).toHaveLength(2);
+  });
+
+  it("should return empty for no tables", () => {
+    const tables = findTables("<div>No tables here</div>");
+    expect(tables).toHaveLength(0);
+  });
+});

package/src/notes/tables.ts

@@ -0,0 +1,146 @@
+/**
+ * Apple Notes table HTML parsing and editing utilities.
+ *
+ * Apple Notes wraps tables in <object> tags with a specific structure:
+ * <object><table><tbody><tr><td><div>content</div></td>...</tr>...</tbody></table></object>
+ */
+
+export interface CellFormatting {
+  bold: boolean;
+}
+
+export interface TableData {
+  rows: string[][];
+  formatting: CellFormatting[][];
+  raw: string;
+}
+
+/**
+ * Parse Apple Notes table HTML into structured data.
+ */
+export function parseTable(html: string): TableData {
+  const result: TableData = {
+    rows: [],
+    formatting: [],
+    raw: html,
+  };
+
+  // Match table content inside <object>
+  const tableMatch = html.match(/<object[^>]*>[\s\S]*?<table[\s\S]*?<tbody>([\s\S]*?)<\/tbody>[\s\S]*?<\/table>[\s\S]*?<\/object>/i);
+  if (!tableMatch) {
+    return result;
+  }
+
+  const tbodyContent = tableMatch[1];
+
+  // Match all rows
+  const rowRegex = /<tr[^>]*>([\s\S]*?)<\/tr>/gi;
+  let rowMatch;
+
+  while ((rowMatch = rowRegex.exec(tbodyContent)) !== null) {
+    const rowContent = rowMatch[1];
+    const cells: string[] = [];
+    const cellFormats: CellFormatting[] = [];
+
+    // Match all cells in this row
+    const cellRegex = /<td[^>]*>[\s\S]*?<div[^>]*>([\s\S]*?)<\/div>[\s\S]*?<\/td>/gi;
+    let cellMatch;
+
+    while ((cellMatch = cellRegex.exec(rowContent)) !== null) {
+      const cellContent = cellMatch[1];
+      // Extract text, stripping HTML tags
+      const text = cellContent.replace(/<[^>]+>/g, "").trim();
+      const isBold = /<b>/i.test(cellContent);
+
+      cells.push(text);
+      cellFormats.push({ bold: isBold });
+    }
+
+    if (cells.length > 0) {
+      result.rows.push(cells);
+      result.formatting.push(cellFormats);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Update a specific cell in an Apple Notes table HTML.
+ *
+ * @param html - The table HTML
+ * @param row - Row index (0-based, 0 = header)
+ * @param column - Column index (0-based)
+ * @param value - New cell value
+ * @returns Updated HTML
+ */
+export function updateTableCell(html: string, row: number, column: number, value: string): string {
+  const parsed = parseTable(html);
+
+  if (row >= parsed.rows.length) {
+    throw new Error(`Row ${row} out of bounds (table has ${parsed.rows.length} rows)`);
+  }
+
+  if (column >= parsed.rows[row].length) {
+    throw new Error(`Column ${column} out of bounds (row has ${parsed.rows[row].length} columns)`);
+  }
+
+  // Find and replace the specific cell
+  let currentRow = 0;
+  let result = html;
+
+  const rowRegex = /<tr[^>]*>([\s\S]*?)<\/tr>/gi;
+  let rowMatch;
+
+  while ((rowMatch = rowRegex.exec(html)) !== null) {
+    if (currentRow === row) {
+      const rowContent = rowMatch[1];
+      let currentCol = 0;
+      let newRowContent = rowContent;
+
+      const cellRegex = /(<td[^>]*>[\s\S]*?<div[^>]*>)([\s\S]*?)(<\/div>[\s\S]*?<\/td>)/gi;
+      let cellMatch;
+      const replacements: Array<{original: string; replacement: string}> = [];
+
+      while ((cellMatch = cellRegex.exec(rowContent)) !== null) {
+        if (currentCol === column) {
+          const prefix = cellMatch[1];
+          const suffix = cellMatch[3];
+          const isBold = parsed.formatting[row][column].bold;
+          const newContent = isBold ? `<b>${value}</b>` : value;
+          replacements.push({
+            original: cellMatch[0],
+            replacement: `${prefix}${newContent}${suffix}`
+          });
+        }
+        currentCol++;
+      }
+
+      for (const r of replacements) {
+        newRowContent = newRowContent.replace(r.original, r.replacement);
+      }
+
+      result = result.replace(rowMatch[0], `<tr>${newRowContent}</tr>`);
+      break;
+    }
+    currentRow++;
+  }
+
+  return result;
+}
+
+/**
+ * Find all tables in note HTML content.
+ * Returns array of table HTML strings.
+ */
+export function findTables(html: string): string[] {
+  const tables: string[] = [];
+  const tableRegex = /<object[^>]*>[\s\S]*?<table[\s\S]*?<\/table>[\s\S]*?<\/object>/gi;
+  let match;
+
+  while ((match = tableRegex.exec(html)) !== null) {
+    tables.push(match[0]);
+  }
+
+  return tables;
+}

package/src/server.ts

@@ -18,7 +18,7 @@ import { validateEnv } from "./config/env.js";
 // Import implementations
 import { getVectorStore } from "./db/lancedb.js";
 import { getNoteByTitle, getAllFolders } from "./notes/read.js";
-import { createNote, updateNote, deleteNote, moveNote } from "./notes/crud.js";
+import { createNote, updateNote, deleteNote, moveNote, editTable } from "./notes/crud.js";
 import { searchNotes } from "./search/index.js";
 import { indexNotes, reindexNote } from "./search/indexer.js";
 
@@ -72,6 +72,16 @@ const MoveNoteSchema = z.object({
   folder: z.string(),
 });
 
+const EditTableSchema = z.object({
+  title: z.string(),
+  table_index: z.number().min(0).default(0),
+  edits: z.array(z.object({
+    row: z.number().min(0),
+    column: z.number().min(0),
+    value: z.string(),
+  })).min(1),
+});
+
 // Helper to create text responses
 function textResponse(text: string) {
   return {
@@ -245,6 +255,31 @@ export default function createServer() {
             required: ["title", "folder"],
           },
         },
+        {
+          name: "edit-table",
+          description: "Edit cells in a table within a note. Use for updating table data without rewriting the entire note.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              title: { type: "string", description: "Note title (use folder/title for disambiguation)" },
+              table_index: { type: "number", description: "Which table to edit (0 = first table, default: 0)" },
+              edits: {
+                type: "array",
+                description: "Array of cell edits",
+                items: {
+                  type: "object",
+                  properties: {
+                    row: { type: "number", description: "Row index (0 = header row)" },
+                    column: { type: "number", description: "Column index (0 = first column)" },
+                    value: { type: "string", description: "New cell value" },
+                  },
+                  required: ["row", "column", "value"],
+                },
+              },
+            },
+            required: ["title", "edits"],
+          },
+        },
       ],
     };
   });
@@ -367,6 +402,12 @@ export default function createServer() {
           return textResponse(`Moved note: "${params.title}" to folder "${params.folder}"`);
         }
 
+        case "edit-table": {
+          const params = EditTableSchema.parse(args);
+          await editTable(params.title, params.table_index, params.edits);
+          return textResponse(`Updated ${params.edits.length} cell(s) in table ${params.table_index}`);
+        }
+
         default:
           return errorResponse(`Unknown tool: ${name}`);
       }