iris-chatbot 0.2.4

package/template/src/lib/tooling/tools/notes.ts

@@ -0,0 +1,461 @@
+import { ensureMacOS } from "../safety";
+import { runCommandSafe } from "../runtime";
+import type { ToolDefinition, ToolExecutionContext } from "../types";
+
+type NotesInput = {
+  title?: string;
+  body?: string;
+  folder?: string;
+  mode?: "create" | "append";
+  query?: string;
+  limit?: number;
+};
+
+const APPLESCRIPT_TIMEOUT_MS = 30_000;
+
+function normalizeHeadingLikeText(input: string): string {
+  return input
+    .trim()
+    .replace(/^#{1,6}\s+/, "")
+    .replace(/^\*\*(.+)\*\*$/u, "$1")
+    .replace(/^__(.+)__$/u, "$1")
+    .replace(/\s+/g, " ")
+    .toLowerCase();
+}
+
+function escapeHtml(input: string): string {
+  return input
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+function formatInlineMarkdown(input: string): string {
+  const escaped = escapeHtml(input);
+  return escaped
+    .replace(/\*\*(.+?)\*\*/g, "<b>$1</b>")
+    .replace(/__(.+?)__/g, "<b>$1</b>")
+    .replace(/\*(.+?)\*/g, "<i>$1</i>")
+    .replace(/_(.+?)_/g, "<i>$1</i>")
+    .replace(/`([^`]+)`/g, "<code>$1</code>");
+}
+
+function paragraphHtml(content: string): string {
+  return `<p>${content}</p>`;
+}
+
+function headingHtml(level: number, content: string): string {
+  return `<h${level}>${content}</h${level}>`;
+}
+
+function listHtml(type: "ul" | "ol", items: string[]): string {
+  const renderedItems = items.map((item) => `<li>${formatInlineMarkdown(item)}</li>`).join("");
+  return `<${type}>${renderedItems}</${type}>`;
+}
+
+type NotesBlockKind = "heading" | "paragraph" | "list" | "table";
+
+type NotesBlock = {
+  kind: NotesBlockKind;
+  html: string;
+};
+
+function renderBlocksWithSpacing(blocks: NotesBlock[]): string {
+  if (blocks.length === 0) {
+    return "";
+  }
+
+  const output: string[] = [];
+  for (let index = 0; index < blocks.length; index += 1) {
+    const current = blocks[index];
+    const previous = index > 0 ? blocks[index - 1] : null;
+
+    if (previous) {
+      const needsSectionGap =
+        current.kind === "heading" ||
+        previous.kind === "heading" ||
+        previous.kind === "list" ||
+        previous.kind === "table";
+
+      if (needsSectionGap) {
+        // Apple Notes reliably keeps explicit line breaks.
+        output.push("<div><br/></div>");
+      }
+    }
+
+    output.push(current.html);
+  }
+
+  return output.join("");
+}
+
+function splitTableRow(line: string): string[] {
+  const trimmed = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+  return trimmed.split("|").map((cell) => cell.trim());
+}
+
+function isMarkdownTableSeparator(line: string): boolean {
+  const trimmed = line.trim();
+  if (!trimmed.includes("|")) {
+    return false;
+  }
+  const cells = splitTableRow(trimmed);
+  if (cells.length === 0) {
+    return false;
+  }
+  return cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+}
+
+function toMarkdownTable(lines: string[]): string | null {
+  if (lines.length < 2) {
+    return null;
+  }
+  if (!lines[0].includes("|") || !isMarkdownTableSeparator(lines[1])) {
+    return null;
+  }
+
+  const headerCells = splitTableRow(lines[0]);
+  const bodyRows = lines.slice(2).filter((line) => line.includes("|"));
+  if (headerCells.length === 0 || bodyRows.length === 0) {
+    return null;
+  }
+
+  const thead = `<thead><tr>${headerCells
+    .map((cell) => `<th>${formatInlineMarkdown(cell)}</th>`)
+    .join("")}</tr></thead>`;
+  const tbody = `<tbody>${bodyRows
+    .map((row) => {
+      const cells = splitTableRow(row);
+      return `<tr>${cells.map((cell) => `<td>${formatInlineMarkdown(cell)}</td>`).join("")}</tr>`;
+    })
+    .join("")}</tbody>`;
+
+  return `<table>${thead}${tbody}</table>`;
+}
+
+export function normalizeNotesBody(rawBody: string): string {
+  let source = rawBody.replace(/\r\n/g, "\n").trim();
+  if (!source) {
+    return "";
+  }
+
+  // Heuristic for single-line "dash separated" dumps.
+  if (!source.includes("\n") && source.length > 240 && source.includes(" - ")) {
+    source = source.replace(/\s-\s/g, "\n- ");
+  }
+
+  // Heuristic for collapsed markdown table rows emitted on one line.
+  if (source.includes("|") && source.includes("||")) {
+    source = source
+      .replace(/\s*\|\|\s*/g, "\n")
+      .replace(/\n{3,}/g, "\n\n");
+  }
+
+  const lines = source.split("\n");
+  const blocks: NotesBlock[] = [];
+  let paragraphLines: string[] = [];
+  let listType: "ul" | "ol" | null = null;
+  let listItems: string[] = [];
+
+  const flushParagraph = () => {
+    if (paragraphLines.length === 0) {
+      return;
+    }
+    const text = paragraphLines.join(" ").trim();
+    if (text) {
+      blocks.push({ kind: "paragraph", html: paragraphHtml(formatInlineMarkdown(text)) });
+    }
+    paragraphLines = [];
+  };
+
+  const flushList = () => {
+    if (!listType || listItems.length === 0) {
+      listType = null;
+      listItems = [];
+      return;
+    }
+    blocks.push({ kind: "list", html: listHtml(listType, listItems) });
+    listType = null;
+    listItems = [];
+  };
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index].trim();
+    if (!line) {
+      flushParagraph();
+      flushList();
+      continue;
+    }
+
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      flushParagraph();
+      flushList();
+      const level = headingMatch[1].length;
+      blocks.push({
+        kind: "heading",
+        html: headingHtml(level, formatInlineMarkdown(headingMatch[2])),
+      });
+      continue;
+    }
+
+    if (line.includes("|")) {
+      const block: string[] = [];
+      for (let lookAhead = index; lookAhead < lines.length; lookAhead += 1) {
+        const candidate = lines[lookAhead].trim();
+        if (!candidate || !candidate.includes("|")) {
+          break;
+        }
+        block.push(candidate);
+      }
+      const tableHtml = toMarkdownTable(block);
+      if (tableHtml) {
+        flushParagraph();
+        flushList();
+        blocks.push({ kind: "table", html: tableHtml });
+        // Skip rows that were consumed by the table parser.
+        index += block.length - 1;
+        continue;
+      }
+    }
+
+    const bulletMatch = line.match(/^[-*]\s+(.+)$/);
+    if (bulletMatch) {
+      flushParagraph();
+      if (listType && listType !== "ul") {
+        flushList();
+      }
+      listType = "ul";
+      listItems.push(bulletMatch[1]);
+      continue;
+    }
+
+    const numberMatch = line.match(/^\d+\.\s+(.+)$/);
+    if (numberMatch) {
+      flushParagraph();
+      if (listType && listType !== "ol") {
+        flushList();
+      }
+      listType = "ol";
+      listItems.push(numberMatch[1]);
+      continue;
+    }
+
+    if (listType) {
+      flushList();
+    }
+    paragraphLines.push(line);
+  }
+
+  flushParagraph();
+  flushList();
+
+  if (blocks.length === 0) {
+    return paragraphHtml(formatInlineMarkdown(source));
+  }
+
+  return renderBlocksWithSpacing(blocks);
+}
+
+function asObject(input: unknown): Record<string, unknown> {
+  if (!input || typeof input !== "object") {
+    throw new Error("Tool input must be an object.");
+  }
+  return input as Record<string, unknown>;
+}
+
+function asString(input: unknown, field: string): string {
+  if (typeof input !== "string" || !input.trim()) {
+    throw new Error(`Missing required string field: ${field}`);
+  }
+  return input.trim();
+}
+
+async function runAppleScript(script: string, args: string[], signal?: AbortSignal): Promise<string> {
+  const { stdout } = await runCommandSafe({
+    command: "osascript",
+    args: ["-e", script, ...args],
+    signal,
+    timeoutMs: APPLESCRIPT_TIMEOUT_MS,
+  });
+  return stdout;
+}
+
+async function runNotesCreateOrAppend(input: unknown, context: ToolExecutionContext) {
+  const payload = asObject(input) as NotesInput;
+  const title = asString(payload.title, "title");
+  const body = asString(payload.body, "body");
+  const normalizedLines = body.replace(/\r\n/g, "\n").split("\n");
+  // Remove duplicated leading title lines while keeping the richer/markdown heading when present.
+  while (
+    normalizedLines.length > 1 &&
+    normalizeHeadingLikeText(normalizedLines[0]) &&
+    normalizeHeadingLikeText(normalizedLines[0]) === normalizeHeadingLikeText(normalizedLines[1])
+  ) {
+    normalizedLines.shift();
+  }
+  // Avoid repeating the note title as the first body line.
+  if (
+    normalizedLines.length > 0 &&
+    normalizeHeadingLikeText(normalizedLines[0]) === normalizeHeadingLikeText(title)
+  ) {
+    normalizedLines.shift();
+  }
+  const normalizedBodyInput = normalizedLines.join("\n").trim();
+  const formattedBody = normalizeNotesBody(normalizedBodyInput);
+  const folder = typeof payload.folder === "string" ? payload.folder.trim() : "";
+  const mode = payload.mode === "append" ? "append" : "create";
+
+  ensureMacOS("Apple Notes automation");
+
+  if (context.localTools.dryRun) {
+    return {
+      dryRun: true,
+      action: "notes_create_or_append",
+      title,
+      folder,
+      mode,
+      bodyPreview: formattedBody.slice(0, 200),
+    };
+  }
+
+  const script =
+    'on run argv\n' +
+    'set noteTitle to item 1 of argv\n' +
+    'set noteBody to item 2 of argv\n' +
+    'set folderName to item 3 of argv\n' +
+    'set noteMode to item 4 of argv\n' +
+    'tell application "Notes"\n' +
+    'if not (exists account 1) then error "No Notes account is available."\n' +
+    'set targetAccount to account 1\n' +
+    'set targetFolder to missing value\n' +
+    'if folderName is not "" then\n' +
+    'repeat with f in folders of targetAccount\n' +
+    'if name of f is folderName then set targetFolder to f\n' +
+    'end repeat\n' +
+    'if targetFolder is missing value then\n' +
+    'set targetFolder to make new folder at targetAccount with properties {name:folderName}\n' +
+    'end if\n' +
+    'else\n' +
+    'set targetFolder to folder "Notes" of targetAccount\n' +
+    'end if\n' +
+    'set existingNote to missing value\n' +
+    'repeat with n in notes of targetFolder\n' +
+    'if name of n is noteTitle then\n' +
+    'set existingNote to n\n' +
+    'exit repeat\n' +
+    'end if\n' +
+    'end repeat\n' +
+    'if noteMode is "append" and existingNote is not missing value then\n' +
+    'set body of existingNote to (body of existingNote) & "<br/>" & noteBody\n' +
+    'return "appended"\n' +
+    'else if existingNote is missing value then\n' +
+    'set newNote to make new note at targetFolder with properties {name:noteTitle, body:noteBody}\n' +
+    'return "created"\n' +
+    'else\n' +
+    'set body of existingNote to noteBody\n' +
+    'return "updated"\n' +
+    'end if\n' +
+    'end tell\n' +
+    'end run';
+
+  const status = await runAppleScript(script, [title, formattedBody, folder, mode], context.signal);
+  return {
+    status,
+    title,
+    folder,
+    mode,
+  };
+}
+
+async function runNotesFind(input: unknown, context: ToolExecutionContext) {
+  const payload = asObject(input) as NotesInput;
+  const query = asString(payload.query, "query").toLowerCase();
+  const limit =
+    typeof payload.limit === "number" && Number.isFinite(payload.limit)
+      ? Math.max(1, Math.min(100, Math.floor(payload.limit)))
+      : 10;
+
+  ensureMacOS("Apple Notes automation");
+
+  const script =
+    'on run argv\n' +
+    'set needle to item 1 of argv\n' +
+    'set maxCount to (item 2 of argv) as integer\n' +
+    'set outText to ""\n' +
+    'set itemCount to 0\n' +
+    'tell application "Notes"\n' +
+    'if not (exists account 1) then error "No Notes account is available."\n' +
+    'ignoring case\n' +
+    'repeat with acc in accounts\n' +
+    'repeat with f in folders of acc\n' +
+    'repeat with n in notes of f\n' +
+    'set noteTitle to name of n\n' +
+    'set noteBody to body of n\n' +
+    'if ((noteTitle as text) contains needle) or ((noteBody as text) contains needle) then\n' +
+    'set outText to outText & noteTitle & tab & name of f & linefeed\n' +
+    'set itemCount to itemCount + 1\n' +
+    'if itemCount is greater than or equal to maxCount then return outText\n' +
+    'end if\n' +
+    'end if\n' +
+    'end repeat\n' +
+    'end repeat\n' +
+    'end repeat\n' +
+    'end ignoring\n' +
+    'end tell\n' +
+    'return outText\n' +
+    'end run';
+
+  const output = await runAppleScript(script, [query, String(limit)], context.signal);
+  const entries = output
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const [title, folder] = line.split("\t");
+      return { title, folder };
+    });
+
+  return {
+    query,
+    count: entries.length,
+    entries,
+  };
+}
+
+export const notesTools: ToolDefinition[] = [
+  {
+    name: "notes_create_or_append",
+    description: "Create or append text in Apple Notes.",
+    inputSchema: {
+      type: "object",
+      required: ["title", "body", "mode"],
+      properties: {
+        title: { type: "string" },
+        body: { type: "string" },
+        folder: { type: "string" },
+        mode: { type: "string", enum: ["create", "append"] },
+      },
+      additionalProperties: false,
+    },
+    risk: "write",
+    execute: runNotesCreateOrAppend,
+  },
+  {
+    name: "notes_find",
+    description: "Search Apple Notes by title/body text.",
+    inputSchema: {
+      type: "object",
+      required: ["query"],
+      properties: {
+        query: { type: "string" },
+        limit: { type: "number" },
+      },
+      additionalProperties: false,
+    },
+    risk: "read",
+    execute: runNotesFind,
+  },
+];