ocean-brain 0.13.2 → 0.14.0

package/server/dist/features/note/http/authoring.js

@@ -0,0 +1,493 @@
+import { createNoteFromMarkdown, InvalidNoteAuthoringInputError } from "../../../features/note/services/authoring.js";
+import { deleteNoteById } from "../../../features/note/services/cleanup.js";
+import {
+  appendNoteMarkdown,
+  patchNoteMarkdown,
+  replaceNoteMarkdown,
+  updateNoteMetadata
+} from "../../../features/note/services/markdown-intent-write.js";
+import {
+  InvalidNotePropertyInputError
+} from "../../../features/note/services/properties.js";
+import models from "../../../models.js";
+import { createAppError } from "../../../modules/error-handler.js";
+import { emitServerEvent } from "../../../modules/server-events.js";
+const NOTE_LAYOUTS = /* @__PURE__ */ new Set(["narrow", "wide", "full"]);
+const POSITION_HINTS = /* @__PURE__ */ new Set(["first", "last"]);
+const PRESERVATION_POLICIES = /* @__PURE__ */ new Set([true, false, "warn"]);
+const isRecord = (value) => {
+  return typeof value === "object" && value !== null;
+};
+const resolveNoteLayout = (value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string" && NOTE_LAYOUTS.has(value)) {
+    return value;
+  }
+  return null;
+};
+const resolveOptionalString = (value, code, message) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  throw createAppError(400, code, message);
+};
+const resolveMetadataPropertyPatch = (value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    throw createAppError(400, "INVALID_NOTE_PROPERTIES", "Properties patch must be an object.");
+  }
+  const set = value.set === void 0 ? void 0 : Array.isArray(value.set) ? value.set.map((item) => {
+    if (!isRecord(item) || typeof item.key !== "string" || typeof item.value !== "string") {
+      throw createAppError(
+        400,
+        "INVALID_NOTE_PROPERTIES",
+        "Property set items must include string key and value fields."
+      );
+    }
+    return {
+      key: item.key,
+      value: item.value
+    };
+  }) : null;
+  if (set === null) {
+    throw createAppError(400, "INVALID_NOTE_PROPERTIES", "Property set must be an array.");
+  }
+  const deleteKeys = value.deleteKeys === void 0 ? void 0 : Array.isArray(value.deleteKeys) ? value.deleteKeys.map((key) => {
+    if (typeof key !== "string") {
+      throw createAppError(400, "INVALID_NOTE_PROPERTIES", "Property deleteKeys must be strings.");
+    }
+    return key;
+  }) : null;
+  if (deleteKeys === null) {
+    throw createAppError(400, "INVALID_NOTE_PROPERTIES", "Property deleteKeys must be an array.");
+  }
+  return {
+    ...set !== void 0 ? { set } : {},
+    ...deleteKeys !== void 0 ? { deleteKeys } : {}
+  };
+};
+const resolvePositiveNoteId = (value) => {
+  const noteId = Number(value);
+  if (!Number.isInteger(noteId) || noteId <= 0) {
+    throw createAppError(400, "INVALID_NOTE_ID", "A valid note id is required.");
+  }
+  return noteId;
+};
+const serializeNoteWriteBaseline = (note) => {
+  return {
+    id: String(note.id),
+    updatedAt: note.updatedAt instanceof Date ? note.updatedAt.toISOString() : note.updatedAt
+  };
+};
+const isNonNegativeInteger = (value) => {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+};
+const isPositiveInteger = (value) => {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+};
+const resolveMarkdownWritePolicy = (value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    throw createAppError(400, "INVALID_MARKDOWN_POLICY", "Markdown write policy must be an object.");
+  }
+  const policy = {};
+  if (value.allowNoop !== void 0) {
+    if (typeof value.allowNoop !== "boolean") {
+      throw createAppError(400, "INVALID_MARKDOWN_POLICY", "allowNoop must be a boolean.");
+    }
+    policy.allowNoop = value.allowNoop;
+  }
+  if (value.preserveTags !== void 0) {
+    if (!PRESERVATION_POLICIES.has(value.preserveTags)) {
+      throw createAppError(400, "INVALID_MARKDOWN_POLICY", "preserveTags must be boolean or warn.");
+    }
+    policy.preserveTags = value.preserveTags;
+  }
+  if (value.preserveReferences !== void 0) {
+    if (!PRESERVATION_POLICIES.has(value.preserveReferences)) {
+      throw createAppError(400, "INVALID_MARKDOWN_POLICY", "preserveReferences must be boolean or warn.");
+    }
+    policy.preserveReferences = value.preserveReferences;
+  }
+  return policy;
+};
+const resolvePatchSelector = (value) => {
+  if (!isRecord(value)) {
+    throw createAppError(400, "INVALID_PATCH_SELECTOR", "Patch selector must be an object.");
+  }
+  if (value.type === "exact_text") {
+    if (typeof value.text !== "string") {
+      throw createAppError(400, "INVALID_PATCH_SELECTOR", "Exact text selector requires text.");
+    }
+    return {
+      type: "exact_text",
+      text: value.text,
+      ...value.before !== void 0 ? {
+        before: resolveOptionalString(
+          value.before,
+          "INVALID_PATCH_SELECTOR",
+          "Selector before must be a string."
+        )
+      } : {},
+      ...value.after !== void 0 ? {
+        after: resolveOptionalString(
+          value.after,
+          "INVALID_PATCH_SELECTOR",
+          "Selector after must be a string."
+        )
+      } : {}
+    };
+  }
+  if (value.type === "match_candidate") {
+    const { text, matchIndex, lineStart, matchSha256, surroundingHash, positionHint } = value;
+    if (typeof text !== "string" || !isNonNegativeInteger(matchIndex) || !isPositiveInteger(lineStart) || typeof matchSha256 !== "string" || typeof surroundingHash !== "string") {
+      throw createAppError(400, "INVALID_PATCH_SELECTOR", "Match candidate selector has invalid fields.");
+    }
+    if (positionHint !== void 0 && !POSITION_HINTS.has(String(positionHint))) {
+      throw createAppError(400, "INVALID_PATCH_SELECTOR", "positionHint must be first or last.");
+    }
+    return {
+      type: "match_candidate",
+      text,
+      matchIndex,
+      lineStart,
+      matchSha256,
+      surroundingHash,
+      ...positionHint ? { positionHint } : {}
+    };
+  }
+  throw createAppError(400, "INVALID_PATCH_SELECTOR", "Unsupported patch selector type.");
+};
+const resolvePatchOperation = (value) => {
+  if (!isRecord(value)) {
+    throw createAppError(400, "INVALID_PATCH_OPERATION", "Patch operation must be an object.");
+  }
+  if (value.type === "replace") {
+    if (typeof value.replacement !== "string") {
+      throw createAppError(400, "INVALID_PATCH_OPERATION", "Replace operation requires replacement.");
+    }
+    return {
+      type: "replace",
+      replacement: value.replacement
+    };
+  }
+  if (value.type === "insert_before" || value.type === "insert_after") {
+    if (typeof value.insertion !== "string") {
+      throw createAppError(400, "INVALID_PATCH_OPERATION", "Insert operation requires insertion.");
+    }
+    return {
+      type: value.type,
+      insertion: value.insertion
+    };
+  }
+  throw createAppError(400, "INVALID_PATCH_OPERATION", "Unsupported patch operation type.");
+};
+const resolveAppendPlacement = (value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    throw createAppError(400, "INVALID_APPEND_PLACEMENT", "Append placement must be an object.");
+  }
+  if (value.type === "end") {
+    return { type: "end" };
+  }
+  if (value.type === "after_heading") {
+    if (typeof value.heading !== "string") {
+      throw createAppError(400, "INVALID_APPEND_PLACEMENT", "after_heading placement requires heading.");
+    }
+    const { heading, level } = value;
+    if (typeof heading !== "string") {
+      throw createAppError(400, "INVALID_APPEND_PLACEMENT", "after_heading placement requires heading.");
+    }
+    if (level !== void 0 && (typeof level !== "number" || !Number.isInteger(level) || level < 1 || level > 6)) {
+      throw createAppError(400, "INVALID_APPEND_PLACEMENT", "Heading level must be an integer from 1 to 6.");
+    }
+    return {
+      type: "after_heading",
+      heading,
+      ...level !== void 0 ? { level } : {}
+    };
+  }
+  throw createAppError(400, "INVALID_APPEND_PLACEMENT", "Unsupported append placement type.");
+};
+const resolveSeparator = (value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === "\n" || value === "\n\n") {
+    return value;
+  }
+  throw createAppError(400, "INVALID_SEPARATOR", 'Separator must be "\\n" or "\\n\\n".');
+};
+const emitAuthoringEvent = (request, emit, event) => {
+  if (request.integration && request.integration.connectionId !== "mcp") {
+    const shared = {
+      noteId: event.noteId,
+      source: "integration",
+      connectionId: request.integration.connectionId
+    };
+    if (event.type === "mcp.note.deleted") emit({ ...shared, type: "integration.note.deleted" });
+    else
+      emit({
+        ...shared,
+        type: event.type === "mcp.note.created" ? "integration.note.created" : "integration.note.updated",
+        updatedAt: event.updatedAt
+      });
+    return;
+  }
+  emit(event);
+};
+const createCreateNoteHandler = (createNote = createNoteFromMarkdown, emitEvent = emitServerEvent) => {
+  return async (req, reply) => {
+    const { title, markdown, layout, properties } = req.body ?? {};
+    const resolvedProperties = resolveMetadataPropertyPatch(properties);
+    if (resolvedProperties?.deleteKeys !== void 0)
+      throw createAppError(400, "INVALID_NOTE_PROPERTIES", "Create accepts properties.set only.");
+    const resolvedLayout = resolveNoteLayout(layout);
+    if (typeof title !== "string") {
+      throw createAppError(400, "INVALID_NOTE_TITLE", "A note title is required.");
+    }
+    if (markdown !== void 0 && typeof markdown !== "string") {
+      throw createAppError(400, "INVALID_NOTE_MARKDOWN", "Note markdown must be a string.");
+    }
+    if (layout !== void 0 && resolvedLayout === null) {
+      throw createAppError(400, "INVALID_NOTE_LAYOUT", "Note layout must be one of narrow, wide, or full.");
+    }
+    try {
+      const note = await createNote({
+        title,
+        ...markdown !== void 0 ? { markdown } : {},
+        ...resolvedProperties ? { properties: resolvedProperties } : {},
+        ...resolvedLayout ? { layout: resolvedLayout } : {}
+      });
+      emitAuthoringEvent(req, emitEvent, {
+        type: "mcp.note.created",
+        source: "mcp",
+        noteId: note.id,
+        updatedAt: note.updatedAt
+      });
+      return reply.status(200).send({
+        created: true,
+        note
+      });
+    } catch (error) {
+      if (error instanceof InvalidNotePropertyInputError)
+        throw createAppError(400, "INVALID_NOTE_PROPERTIES", error.message);
+      if (error instanceof InvalidNoteAuthoringInputError) {
+        throw createAppError(400, "INVALID_NOTE_INPUT", error.message);
+      }
+      throw error;
+    }
+  };
+};
+const createNoteWriteBaselineHandler = (findNoteBaseline = async (id) => models.note.findUnique({
+  where: { id },
+  select: {
+    id: true,
+    updatedAt: true
+  }
+})) => {
+  return async (req, reply) => {
+    const noteId = resolvePositiveNoteId(req.body?.id);
+    const note = await findNoteBaseline(noteId);
+    if (!note) {
+      throw createAppError(404, "NOTE_NOT_FOUND", "The requested note was not found.");
+    }
+    return reply.status(200).send({
+      note: serializeNoteWriteBaseline(note)
+    });
+  };
+};
+const createPatchNoteMarkdownHandler = (patchMarkdown = patchNoteMarkdown, emitEvent = emitServerEvent) => {
+  return async (req, reply) => {
+    const { id, expectedUpdatedAt, baseMarkdownSha256, intent, selector, operation, policy } = req.body ?? {};
+    const noteId = resolvePositiveNoteId(id);
+    const resolvedExpectedUpdatedAt = resolveOptionalString(
+      expectedUpdatedAt,
+      "INVALID_NOTE_VERSION",
+      "expectedUpdatedAt must be a string."
+    );
+    const resolvedBaseMarkdownSha256 = resolveOptionalString(
+      baseMarkdownSha256,
+      "INVALID_MARKDOWN_HASH",
+      "baseMarkdownSha256 must be a string."
+    );
+    if (typeof intent !== "string") {
+      throw createAppError(400, "INVALID_PATCH_INTENT", "Patch intent must be a string.");
+    }
+    const result = await patchMarkdown({
+      id: noteId,
+      expectedUpdatedAt: resolvedExpectedUpdatedAt,
+      baseMarkdownSha256: resolvedBaseMarkdownSha256,
+      intent,
+      selector: resolvePatchSelector(selector),
+      operation: resolvePatchOperation(operation),
+      policy: resolveMarkdownWritePolicy(policy)
+    });
+    if (result.status === "applied") {
+      emitAuthoringEvent(req, emitEvent, {
+        type: "mcp.note.updated",
+        source: "mcp",
+        noteId: result.note.id,
+        updatedAt: result.note.updatedAt
+      });
+    }
+    return reply.status(200).send(result);
+  };
+};
+const createAppendNoteMarkdownHandler = (appendMarkdown = appendNoteMarkdown, emitEvent = emitServerEvent) => {
+  return async (req, reply) => {
+    const { id, expectedUpdatedAt, baseMarkdownSha256, intent, insertion, placement, separator, policy } = req.body ?? {};
+    const noteId = resolvePositiveNoteId(id);
+    const resolvedExpectedUpdatedAt = resolveOptionalString(
+      expectedUpdatedAt,
+      "INVALID_NOTE_VERSION",
+      "expectedUpdatedAt must be a string."
+    );
+    const resolvedBaseMarkdownSha256 = resolveOptionalString(
+      baseMarkdownSha256,
+      "INVALID_MARKDOWN_HASH",
+      "baseMarkdownSha256 must be a string."
+    );
+    if (typeof intent !== "string") {
+      throw createAppError(400, "INVALID_APPEND_INTENT", "Append intent must be a string.");
+    }
+    if (typeof insertion !== "string") {
+      throw createAppError(400, "INVALID_APPEND_INSERTION", "Append insertion must be a string.");
+    }
+    const result = await appendMarkdown({
+      id: noteId,
+      expectedUpdatedAt: resolvedExpectedUpdatedAt,
+      baseMarkdownSha256: resolvedBaseMarkdownSha256,
+      intent,
+      insertion,
+      placement: resolveAppendPlacement(placement),
+      separator: resolveSeparator(separator),
+      policy: resolveMarkdownWritePolicy(policy)
+    });
+    if (result.status === "applied") {
+      emitAuthoringEvent(req, emitEvent, {
+        type: "mcp.note.updated",
+        source: "mcp",
+        noteId: result.note.id,
+        updatedAt: result.note.updatedAt
+      });
+    }
+    return reply.status(200).send(result);
+  };
+};
+const createReplaceNoteMarkdownHandler = (replaceMarkdown = replaceNoteMarkdown, emitEvent = emitServerEvent) => {
+  return async (req, reply) => {
+    const { id, expectedUpdatedAt, baseMarkdownSha256, intent, replacement, policy } = req.body ?? {};
+    const noteId = resolvePositiveNoteId(id);
+    const resolvedExpectedUpdatedAt = resolveOptionalString(
+      expectedUpdatedAt,
+      "INVALID_NOTE_VERSION",
+      "expectedUpdatedAt must be a string."
+    );
+    const resolvedBaseMarkdownSha256 = resolveOptionalString(
+      baseMarkdownSha256,
+      "INVALID_MARKDOWN_HASH",
+      "baseMarkdownSha256 must be a string."
+    );
+    if (typeof intent !== "string") {
+      throw createAppError(400, "INVALID_REPLACE_INTENT", "Replace intent must be a string.");
+    }
+    if (typeof replacement !== "string") {
+      throw createAppError(400, "INVALID_REPLACE_MARKDOWN", "Replacement markdown must be a string.");
+    }
+    const result = await replaceMarkdown({
+      id: noteId,
+      expectedUpdatedAt: resolvedExpectedUpdatedAt,
+      baseMarkdownSha256: resolvedBaseMarkdownSha256,
+      intent,
+      replacement,
+      policy: resolveMarkdownWritePolicy(policy)
+    });
+    if (result.status === "applied") {
+      emitAuthoringEvent(req, emitEvent, {
+        type: "mcp.note.updated",
+        source: "mcp",
+        noteId: result.note.id,
+        updatedAt: result.note.updatedAt
+      });
+    }
+    return reply.status(200).send(result);
+  };
+};
+const createUpdateNoteMetadataHandler = (updateMetadata = updateNoteMetadata, emitEvent = emitServerEvent) => {
+  return async (req, reply) => {
+    const { id, expectedUpdatedAt, title, layout, properties } = req.body ?? {};
+    const noteId = resolvePositiveNoteId(id);
+    const resolvedLayout = resolveNoteLayout(layout);
+    const resolvedProperties = resolveMetadataPropertyPatch(properties);
+    if (typeof expectedUpdatedAt !== "string") {
+      throw createAppError(400, "INVALID_NOTE_VERSION", "expectedUpdatedAt must be a string.");
+    }
+    if (title !== void 0 && typeof title !== "string") {
+      throw createAppError(400, "INVALID_NOTE_TITLE", "Note title must be a string.");
+    }
+    if (layout !== void 0 && resolvedLayout === null) {
+      throw createAppError(400, "INVALID_NOTE_LAYOUT", "Note layout must be one of narrow, wide, or full.");
+    }
+    if (title === void 0 && layout === void 0 && resolvedProperties === void 0) {
+      throw createAppError(400, "INVALID_NOTE_INPUT", "At least one metadata field must be provided.");
+    }
+    const result = await updateMetadata({
+      id: noteId,
+      expectedUpdatedAt,
+      ...title !== void 0 ? { title } : {},
+      ...resolvedLayout ? { layout: resolvedLayout } : {},
+      ...resolvedProperties !== void 0 ? { properties: resolvedProperties } : {}
+    });
+    if (result.status === "applied") {
+      emitAuthoringEvent(req, emitEvent, {
+        type: "mcp.note.updated",
+        source: "mcp",
+        noteId: result.note.id,
+        updatedAt: result.note.updatedAt
+      });
+    }
+    return reply.status(200).send(result);
+  };
+};
+const createDeleteNoteHandler = (deleteNote = deleteNoteById, emitEvent = emitServerEvent) => {
+  return async (req, reply) => {
+    const id = Number(req.body?.id);
+    if (!Number.isInteger(id) || id <= 0) {
+      throw createAppError(400, "INVALID_NOTE_ID", "A valid note id is required.");
+    }
+    const deletedNote = await deleteNote(id);
+    if (!deletedNote) {
+      throw createAppError(404, "NOTE_NOT_FOUND", "The requested note was not found.");
+    }
+    emitAuthoringEvent(req, emitEvent, {
+      type: "mcp.note.deleted",
+      source: "mcp",
+      noteId: deletedNote.id
+    });
+    return reply.status(200).send({
+      deleted: true,
+      note: deletedNote
+    });
+  };
+};
+export {
+  createAppendNoteMarkdownHandler,
+  createCreateNoteHandler,
+  createDeleteNoteHandler,
+  createNoteWriteBaselineHandler,
+  createPatchNoteMarkdownHandler,
+  createReplaceNoteMarkdownHandler,
+  createUpdateNoteMetadataHandler
+};