ocean-brain 0.10.0 → 0.11.0

package/server/client/dist/assets/trash-D4-9sv8q.js

@@ -0,0 +1 @@
+import{j as e,r as E}from"./floating-ui.react-dom-BWTnA00G.js";import{u as M,b as k,i as L,m as _,N as I,d as Q,a as q}from"./time-D5LRMumI.js";import{Q as B,h as O,u as H,i as K,j as W,q as y,r as Y,p as $,P as w,E as z,T as o,B as j,k as G,l as i,e as U,m as V,n as Z,M as x}from"./note.api-D3oJmG3q.js";import{S as C}from"./SurfaceCard-t7pdfhEe.js";import{S as J,N as X}from"./url-9nrbQs7Z.js";import"./NotePropertiesPanel-aCKXAe5F.js";import"./AuxiliaryPanelHeader-B1k7pZpn.js";import"./Plus.es-DRfLW_bI.js";const m=25,v=O(J),S=30,R=`Deleted notes stay here for ${S} days before permanent removal`,g={title:"Permanently delete note?",description:"This note is referenced by the notes below. If you permanently delete it, those links will stay broken. Other notes will not be edited automatically.",confirmLabel:"Delete now",confirmVariant:"danger"},P=s=>Q(s).format("YYYY-MM-DD HH:mm"),ee=({note:s,onClose:n})=>{const h=s?.id??"",l=s?.title||"Untitled note",a=q({queryKey:y.notes.trashDetail(h),enabled:!!s,queryFn:async()=>{const d=await Z(h);if(d.type==="error")throw d;if(!d.trashedNote)throw new Error("Trashed note not found");return d.trashedNote}}),u=a.data?.contentAsMarkdown.trim()??"";return e.jsxs(x,{isOpen:!!s,onClose:n,variant:"inspect",children:[e.jsx(x.Header,{title:l,onClose:n}),e.jsx(x.Body,{children:e.jsxs("div",{className:"flex flex-col gap-3",children:[s&&e.jsxs(o,{as:"p",variant:"meta",tone:"secondary",children:["Deleted ",P(s.deletedAt)]}),a.isLoading&&e.jsx(o,{as:"p",variant:"meta",tone:"secondary",children:"Loading deleted note content..."}),a.isError&&e.jsx(o,{as:"p",variant:"meta",tone:"error",children:"Failed to load deleted note content."}),!a.isLoading&&!a.isError&&u&&e.jsx("pre",{className:"max-h-[60vh] overflow-auto whitespace-pre-wrap break-words rounded-[14px] border border-border-subtle bg-hover-subtle/50 px-4 py-3 text-sm leading-6 text-fg-secondary",children:u}),!a.isLoading&&!a.isError&&!u&&e.jsx(o,{as:"p",variant:"meta",tone:"secondary",className:"rounded-[14px] border border-border-subtle bg-hover-subtle/50 px-4 py-3",children:"No readable content was found for this deleted note."})]})}),e.jsx(x.Footer,{children:e.jsx(j,{variant:"ghost",size:"sm",onClick:n,children:"Close"})})]})},te=()=>e.jsx(w,{title:"Trash",variant:"default",heading:e.jsx(i,{width:118,height:24,className:"rounded-full"}),description:e.jsx(i,{width:352,height:16,className:"rounded-full"}),children:e.jsx("div",{className:"grid gap-3",children:Array.from({length:3},(s,n)=>e.jsx(C,{padding:"compact",children:e.jsxs("div",{className:"flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between",children:[e.jsxs("div",{className:"min-w-0 flex-1 space-y-2",children:[e.jsx(i,{width:"40%",height:18,className:"rounded-full"}),e.jsxs("div",{className:"flex flex-wrap gap-2",children:[e.jsx(i,{width:168,height:14,className:"rounded-full"}),e.jsx(i,{width:176,height:14,className:"rounded-full"})]}),e.jsxs("div",{className:"flex flex-wrap gap-2",children:[e.jsx(i,{width:56,height:24,className:"rounded-full"}),e.jsx(i,{width:72,height:24,className:"rounded-full"})]})]}),e.jsx(i,{width:92,height:32,className:"rounded-[12px]"})]})},n))})}),se=()=>{const{page:s}=v.useSearch(),n=v.useNavigate(),h=H(),l=U(),a=M(),[u,d]=E.useState(null),[f,b]=E.useState(null),{data:c}=K({queryKey:y.notes.trash({limit:m,offset:(s-1)*m}),queryFn:async()=>{const t=await W({limit:m,offset:(s-1)*m});if(t.type==="error")throw t;return t.trashedNotes}}),N=k({mutationFn:Y,onSuccess:async t=>{if(t.type==="error")throw t;await L(h),l("The note has been restored."),n({to:X,params:{id:t.restoreTrashedNote.id}})},onError:()=>{l("Failed to restore the note.")}}),p=k({mutationFn:$,onSuccess:async t=>{if(t.type==="error")throw t;await h.invalidateQueries({queryKey:y.notes.trashAll(),exact:!1}),l("The note has been permanently deleted.")},onError:()=>{l("Failed to permanently delete the note.")}}),D=()=>{if(!f)return;const{id:t}=f;b(null),p.mutate(t)},A=async t=>{const r=await V(t);if(r.type==="error"){l("Failed to check linked notes before permanently deleting this note.");return}if(h.setQueryData(y.notes.backReferences(t),r.backReferences),r.backReferences.length>0){b({id:t,backReferences:r.backReferences});return}await a("Permanently delete this note? This cannot be undone.")&&p.mutate(t)},T=c.totalCount>0?`Trash (${c.totalCount})`:void 0,F=c.notes.find(t=>t.id===u)??null;return c.notes.length===0?e.jsx(w,{title:"Trash",variant:"default",heading:T,description:R,children:e.jsx(z,{title:"Trash is empty",description:`Delete a note and you can restore it here for ${S} days before permanent removal`})}):e.jsxs(w,{title:"Trash",variant:"default",heading:T,description:R,children:[e.jsxs("div",{className:"flex flex-col gap-4",children:[e.jsx("div",{className:"grid gap-3",children:c.notes.map(t=>e.jsx(C,{padding:"compact",children:e.jsxs("div",{className:"flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between",children:[e.jsxs("div",{className:"min-w-0 flex-1",children:[e.jsxs("div",{className:"flex min-w-0 items-start gap-1.5",children:[e.jsx(o,{as:"h2",variant:"body",weight:"medium",className:"min-w-0 flex-1 break-words leading-[1.25]",children:t.title||"Untitled note"}),t.pinned&&e.jsx("span",{title:"Pinned",className:"inline-flex h-5 w-5 shrink-0 items-center justify-center text-fg-tertiary",children:e.jsx(_,{className:"h-3.5 w-3.5"})})]}),e.jsx("div",{className:"mt-1 flex flex-wrap items-center gap-x-3 gap-y-1",children:e.jsxs(o,{as:"div",variant:"meta",weight:"medium",tone:"secondary",children:["Deleted ",P(t.deletedAt)]})}),t.tagNames.length>0&&e.jsx("div",{className:"mt-2 flex flex-wrap gap-1.5",children:t.tagNames.map(r=>e.jsx(o,{as:"span",variant:"label",weight:"medium",tone:"tertiary",className:"rounded-full border border-border-subtle bg-hover-subtle px-2 py-0.5",children:r},`${t.id}-${r}`))}),t.contentPreview&&e.jsx("div",{className:"mt-3 rounded-[14px] border border-border-subtle bg-hover-subtle/50 px-3 py-2",children:e.jsx(o,{as:"p",variant:"meta",tone:"secondary",className:"line-clamp-3 whitespace-pre-wrap break-words",children:t.contentPreview})})]}),e.jsxs("div",{className:"flex shrink-0 flex-wrap gap-2 sm:justify-end",children:[e.jsx(j,{variant:"subtle",size:"sm",onClick:()=>d(t.id),children:"View content"}),e.jsx(j,{variant:"subtle",size:"sm",isLoading:N.isPending&&N.variables===t.id,onClick:()=>N.mutate(t.id),children:"Restore"}),e.jsx(j,{variant:"soft-danger",size:"sm",isLoading:p.isPending&&p.variables===t.id,onClick:()=>A(t.id),children:"Delete now"})]})]})},t.id))}),c.totalCount>m&&e.jsx(G,{page:s,last:Math.ceil(c.totalCount/m),onChange:t=>{n({search:r=>({...r,page:t})})}})]}),e.jsx(ee,{note:F,onClose:()=>d(null)}),e.jsx(I,{isOpen:!!f,title:g.title,description:g.description,references:f?.backReferences??[],confirmLabel:g.confirmLabel,confirmVariant:g.confirmVariant,onClose:()=>b(null),onConfirm:D})]})},he=()=>{const{page:s}=v.useSearch();return e.jsx(B,{fallback:e.jsx(te,{}),errorTitle:"Failed to load trash",errorDescription:"Retry loading deleted notes",resetKeys:[s],children:e.jsx(se,{})})};export{he as default};

package/server/client/dist/assets/{useReminderMutate--omDLmBV.js → useReminderMutate-BrGO9M0o.js}

@@ -1,4 +1,4 @@
-import{j as y,r as l}from"./floating-ui.react-dom-BWTnA00G.js";import{g as u,h as f,q as n,u as R,d as $}from"./note.api-BQovzEzd.js";const g=(e={})=>({limit:e.limit??10,offset:e.offset??0}),D=async(e,t)=>u(`
+import{j as y,r as l}from"./floating-ui.react-dom-BWTnA00G.js";import{g as u,i as f,q as n,u as R,e as $}from"./note.api-D3oJmG3q.js";const g=(e={})=>({limit:e.limit??10,offset:e.offset??0}),D=async(e,t)=>u(`
         query FetchNoteReminders($noteId: ID!, $pagination: PaginationInput) {
             noteReminders(noteId: $noteId, pagination: $pagination) {
                 totalCount

package/server/client/dist/index.html

@@ -8,14 +8,14 @@
     <link rel="icon" type="image/png" href="/icon.png" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Ocean Brain</title>
-  <script type="module" crossorigin src="/assets/app-DQBV36r_.js"></script>
+  <script type="module" crossorigin src="/assets/app-BpSMjzET.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/floating-ui.react-dom-BWTnA00G.js">
   <link rel="modulepreload" crossorigin href="/assets/url-9nrbQs7Z.js">
-  <link rel="modulepreload" crossorigin href="/assets/note.api-BQovzEzd.js">
-  <link rel="modulepreload" crossorigin href="/assets/time-CfAYZipR.js">
+  <link rel="modulepreload" crossorigin href="/assets/note.api-D3oJmG3q.js">
+  <link rel="modulepreload" crossorigin href="/assets/time-D5LRMumI.js">
   <link rel="modulepreload" crossorigin href="/assets/preload-helper-BXl3LOEh.js">
-  <link rel="modulepreload" crossorigin href="/assets/Graph-vXQQ0a-Q.js">
-  <link rel="stylesheet" crossorigin href="/assets/app-ZgwR5t_I.css">
+  <link rel="modulepreload" crossorigin href="/assets/Graph-LY_IgMYy.js">
+  <link rel="stylesheet" crossorigin href="/assets/app-B9WZRrAH.css">
 </head>
 
 <body>

package/server/dist/features/note/graphql/note.field.resolver.js

@@ -1,9 +1,11 @@
 import { listNoteProperties } from "../../../features/note/services/properties.js";
+import { buildNoteContentPreview } from "../../../features/note/services/search.js";
 import { renderNoteSnapshotContentAsMarkdown } from "../../../features/note/services/snapshot.js";
 import models from "../../../models.js";
 const noteFieldResolvers = {
   tags: async (note) => models.tag.findMany({ where: { notes: { some: { id: note.id } } } }),
   properties: async (note) => listNoteProperties(note.id),
+  contentPreview: (note) => buildNoteContentPreview(note.content),
   contentAsMarkdown: async (note) => {
     const { blocksToMarkdown } = await import("../../../modules/blocknote.js");
     return blocksToMarkdown(note.content);

package/server/dist/features/note/graphql/note.mutation.resolver.js

@@ -1,5 +1,6 @@
 import { GraphQLError } from "graphql";
 import { extractBlocksByType, parseNoteContent } from "../../../features/note/services/content-blocks.js";
+import { replaceNoteReferences } from "../../../features/note/services/note-reference-index.js";
 import {
   createNotePropertyDefinition,
   deleteNotePropertyDefinition,
@@ -63,22 +64,26 @@ const noteMutationResolvers = {
     const replacedContent = await replacePlaceholders(note.content);
     const parsedContent = replacedContent ? parseRequiredNoteContent(replacedContent) : null;
     const blocks = parsedContent ? extractBlocksByType("tag", parsedContent) : [];
-    const createdNote = await models.note.create({
-      data: {
-        title: replacedTitle,
-        content: replacedContent,
-        ...buildNoteSearchProjection({
+    const noteResult = await models.$transaction(async (tx) => {
+      const createdNote = await tx.note.create({
+        data: {
           title: replacedTitle,
-          content: replacedContent
-        }),
-        ...note.layout && { layout: note.layout }
-      }
+          content: replacedContent,
+          ...buildNoteSearchProjection({
+            title: replacedTitle,
+            content: replacedContent
+          }),
+          ...note.layout && { layout: note.layout }
+        }
+      });
+      const noteResult2 = replacedContent ? await tx.note.update({
+        where: { id: createdNote.id },
+        data: { tags: { set: toTagConnections(blocks) } }
+      }) : createdNote;
+      await replaceNoteReferences(tx, createdNote.id, replacedContent);
+      return noteResult2;
     });
-    const noteResult = replacedContent ? await models.note.update({
-      where: { id: createdNote.id },
-      data: { tags: { set: toTagConnections(blocks) } }
-    }) : createdNote;
-    notifySemanticSearchNoteChanged(createdNote.id);
+    notifySemanticSearchNoteChanged(noteResult.id);
     return noteResult;
   },
   updateNote: async (_, {

package/server/dist/features/note/graphql/note.query.resolver.js

@@ -194,12 +194,22 @@ const createAllNotesQueryResolver = (deps = {
   };
 };
 const createBackReferencesQueryResolver = (deps = {
-  findCandidateNotes: (noteId) => models.note.findMany({
-    orderBy: [{ pinned: "desc" }, { updatedAt: "desc" }],
-    where: {
-      NOT: { id: noteId }
+  findCandidateNotes: async (noteId) => {
+    const references = await models.noteReference.findMany({
+      where: { targetNoteId: noteId },
+      select: { sourceNoteId: true }
+    });
+    if (references.length === 0) {
+      return [];
     }
-  })
+    return models.note.findMany({
+      orderBy: [{ pinned: "desc" }, { updatedAt: "desc" }],
+      where: {
+        id: { in: references.map((reference) => reference.sourceNoteId) },
+        NOT: { id: noteId }
+      }
+    });
+  }
 }) => {
   return async (_, { id }) => {
     const notes = await deps.findCandidateNotes(Number(id));

package/server/dist/features/note/graphql/note.type-defs.js

@@ -98,6 +98,7 @@ const noteType = gql`
         id: ID!
         title: String!
         content: String!
+        contentPreview: String!
         contentAsMarkdown: String!
         createdAt: String!
         updatedAt: String!

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

@@ -1,5 +1,6 @@
 import models from "../../../models.js";
 import { extractTagIdsFromContentJson, markdownToBlocksJson } from "../../../modules/blocknote.js";
+import { replaceNoteReferences } from "./note-reference-index.js";
 import { buildNoteSearchProjection } from "./search.js";
 class InvalidNoteAuthoringInputError extends Error {
   constructor(message) {
@@ -64,17 +65,21 @@ const createNoteAuthoringService = (deps) => {
 };
 const defaultNoteAuthoringService = createNoteAuthoringService({
   createNote: async (input) => {
-    return models.note.create({
-      data: {
-        title: input.title,
-        content: input.content,
-        ...buildNoteSearchProjection({
+    return models.$transaction(async (tx) => {
+      const note = await tx.note.create({
+        data: {
           title: input.title,
-          content: input.content
-        }),
-        ...input.layout ? { layout: input.layout } : {},
-        ...input.tagIds ? { tags: { connect: input.tagIds.map((id) => ({ id: Number(id) })) } } : {}
-      }
+          content: input.content,
+          ...buildNoteSearchProjection({
+            title: input.title,
+            content: input.content
+          }),
+          ...input.layout ? { layout: input.layout } : {},
+          ...input.tagIds ? { tags: { connect: input.tagIds.map((id) => ({ id: Number(id) })) } } : {}
+        }
+      });
+      await replaceNoteReferences(tx, note.id, input.content);
+      return note;
     });
   },
   findPlaceholders: async (templates) => {

package/server/dist/features/note/services/note-reference-index.js

@@ -0,0 +1,98 @@
+import models from "../../../models.js";
+import { extractReferenceBlocksFromContent, normalizeReferenceId } from "./content-blocks.js";
+const NOTE_REFERENCE_INDEX_VERSION = 1;
+const NOTE_REFERENCE_INDEX_STATE_ID = 1;
+const SQLITE_MAX_INT_ID = 2147483647;
+const REFERENCE_INDEX_REBUILD_BATCH_SIZE = 250;
+const toNoteId = (value) => {
+  const normalized = normalizeReferenceId(value);
+  if (!normalized || !/^[1-9]\d*$/.test(normalized)) {
+    return null;
+  }
+  const id = Number(normalized);
+  return Number.isSafeInteger(id) && id <= SQLITE_MAX_INT_ID ? id : null;
+};
+const extractNoteReferenceIds = (content) => {
+  return Array.from(
+    new Set(
+      extractReferenceBlocksFromContent(content).map((block) => toNoteId(block.props?.id)).filter((id) => id !== null)
+    )
+  );
+};
+const replaceNoteReferences = async (db, sourceNoteId, content) => {
+  const targetIds = extractNoteReferenceIds(content).filter((targetNoteId) => targetNoteId !== sourceNoteId);
+  await db.noteReference.deleteMany({ where: { sourceNoteId } });
+  if (targetIds.length === 0) {
+    return 0;
+  }
+  const references = targetIds.map((targetNoteId) => ({ sourceNoteId, targetNoteId }));
+  if (references.length > 0) {
+    await db.noteReference.createMany({ data: references });
+  }
+  return references.length;
+};
+const rebuildNoteReferenceIndex = async () => {
+  await models.noteReference.deleteMany();
+  let cursor = 0;
+  let processedCount = 0;
+  while (true) {
+    const notes = await models.note.findMany({
+      where: { id: { gt: cursor } },
+      orderBy: { id: "asc" },
+      take: REFERENCE_INDEX_REBUILD_BATCH_SIZE,
+      select: {
+        id: true,
+        content: true
+      }
+    });
+    if (notes.length === 0) {
+      break;
+    }
+    const references = notes.flatMap(
+      (note) => extractNoteReferenceIds(note.content).filter((targetNoteId) => targetNoteId !== note.id).map((targetNoteId) => ({
+        sourceNoteId: note.id,
+        targetNoteId
+      }))
+    );
+    if (references.length > 0) {
+      await models.noteReference.createMany({ data: references });
+      processedCount += references.length;
+    }
+    cursor = notes[notes.length - 1].id;
+  }
+  await models.noteReferenceIndexState.upsert({
+    where: { id: NOTE_REFERENCE_INDEX_STATE_ID },
+    create: {
+      id: NOTE_REFERENCE_INDEX_STATE_ID,
+      version: NOTE_REFERENCE_INDEX_VERSION,
+      updatedAt: /* @__PURE__ */ new Date()
+    },
+    update: {
+      version: NOTE_REFERENCE_INDEX_VERSION
+    }
+  });
+  return processedCount;
+};
+let activeRebuild = null;
+const ensureNoteReferenceIndex = async () => {
+  const state = await models.noteReferenceIndexState.findUnique({
+    where: { id: NOTE_REFERENCE_INDEX_STATE_ID },
+    select: { version: true }
+  });
+  if (state?.version === NOTE_REFERENCE_INDEX_VERSION) {
+    return 0;
+  }
+  if (!activeRebuild) {
+    activeRebuild = rebuildNoteReferenceIndex().finally(() => {
+      activeRebuild = null;
+    });
+  }
+  return activeRebuild;
+};
+export {
+  NOTE_REFERENCE_INDEX_STATE_ID,
+  NOTE_REFERENCE_INDEX_VERSION,
+  ensureNoteReferenceIndex,
+  extractNoteReferenceIds,
+  replaceNoteReferences
+};

package/server/dist/features/note/services/search.js

@@ -140,6 +140,10 @@ const extractVisibleSearchTextFromContent = (content) => {
     return "";
   }
 };
+const NOTE_CONTENT_PREVIEW_MAX_LENGTH = 100;
+const buildNoteContentPreview = (content) => {
+  return extractVisibleSearchTextFromContent(content).slice(0, NOTE_CONTENT_PREVIEW_MAX_LENGTH);
+};
 const matchesNoteSearchQuery = (note, query) => {
   const parsedQuery = typeof query === "string" ? parseNoteSearchQuery(query) : query;
   if (!parsedQuery.hasFilters) {
@@ -166,6 +170,7 @@ export {
   NOTE_SEARCH_IGNORED_NODE_TYPES,
   NOTE_SEARCH_PASS_THROUGH_NODE_TYPES,
   NOTE_SEARCH_TEXT_SCHEMA_VERSION,
+  buildNoteContentPreview,
   buildNoteSearchProjection,
   buildNoteSearchText,
   extractVisibleSearchTextFromContent,

package/server/dist/features/note/services/snapshot.js

@@ -10,6 +10,7 @@ import {
   SNAPSHOT_RETENTION_DAYS
 } from "../../../modules/recovery-retention.js";
 import { calculateMarkdownSha256 } from "./markdown-patch.js";
+import { replaceNoteReferences } from "./note-reference-index.js";
 import { resolveRestoredPropertyTarget } from "./property-restore.js";
 import { buildNoteSearchProjection, extractVisibleSearchTextFromContent } from "./search.js";
 import { createNoteVersionConflictError, MissingNoteVersionError, parseNoteVersion } from "./write-conflict.js";
@@ -561,6 +562,9 @@ const defaultNoteSnapshotService = createNoteSnapshotService({
             ...tagIds !== void 0 ? { tags: { set: tagIds.map((tagId) => ({ id: tagId })) } } : {}
           }
         });
+        if (noteInput.content !== void 0) {
+          await replaceNoteReferences(tx, note.id, noteInput.content);
+        }
         if (properties !== void 0) {
           await tx.noteProperty.deleteMany({ where: { noteId: id } });
           for (const property of properties) {

package/server/dist/features/note/services/trash.js

@@ -4,6 +4,7 @@ import {
   RECOVERY_CLEANUP_BATCH_LIMIT,
   TRASH_RETENTION_DAYS
 } from "../../../modules/recovery-retention.js";
+import { replaceNoteReferences } from "./note-reference-index.js";
 import { resolveRestoredPropertyTarget } from "./property-restore.js";
 import { buildNoteSearchProjection, extractVisibleSearchTextFromContent } from "./search.js";
 const TRASHED_NOTE_CONTENT_PREVIEW_MAX_LENGTH = 240;
@@ -289,6 +290,7 @@ const noteTrashService = createNoteTrashService({
           } : {}
         }
       });
+      await replaceNoteReferences(tx, note.id, restoredContent);
       for (const property of deletedNote.properties ?? []) {
         const target = await resolveRestoredPropertyTarget(property, {
           findDefinitionByKey: (key) => tx.propertyDefinition.findUnique({ where: { key } }),

package/server/dist/features/note/services/write.js

@@ -1,4 +1,5 @@
 import models, { Prisma } from "../../../models.js";
+import { replaceNoteReferences } from "./note-reference-index.js";
 import { buildNoteSearchProjection } from "./search.js";
 import { captureNoteBaseline } from "./snapshot.js";
 import { createNoteVersionConflictError, MissingNoteVersionError, parseNoteVersion } from "./write-conflict.js";
@@ -101,9 +102,15 @@ const defaultNoteWriteService = createNoteWriteService({
     }
   }),
   captureBaseline: captureNoteBaseline,
-  updateNote: ({ where, data }) => models.note.update({
-    where,
-    data
+  updateNote: ({ where, data }) => models.$transaction(async (tx) => {
+    const note = await tx.note.update({
+      where,
+      data
+    });
+    if (data.content !== void 0) {
+      await replaceNoteReferences(tx, note.id, data.content);
+    }
+    return note;
   }),
   isRecordNotFoundError
 });

package/server/dist/features/search/graphql/resolver.js

@@ -1,4 +1,5 @@
 import { searchNotesHybrid } from "../hybrid-search.js";
+import { searchRelatedNotes } from "../related-notes.js";
 const createSearchNotesResolver = (search = searchNotesHybrid) => {
   return async (_, { query, pagination, mode = "HYBRID" }) => {
     return search({
@@ -9,12 +10,23 @@ const createSearchNotesResolver = (search = searchNotesHybrid) => {
     });
   };
 };
+const createSearchRelatedNotesResolver = (findRelatedNotes = searchRelatedNotes) => {
+  return async (_, { noteId, limit = 5 }) => {
+    const numericNoteId = Number(noteId);
+    if (!Number.isSafeInteger(numericNoteId) || numericNoteId <= 0) {
+      return [];
+    }
+    return findRelatedNotes(numericNoteId, Math.min(5, Math.max(0, Number(limit))));
+  };
+};
 const searchResolvers = {
   Query: {
-    searchNotes: createSearchNotesResolver()
+    searchNotes: createSearchNotesResolver(),
+    searchRelatedNotes: createSearchRelatedNotesResolver()
   }
 };
 export {
   createSearchNotesResolver,
+  createSearchRelatedNotesResolver,
   searchResolvers
 };

package/server/dist/features/search/graphql/type-defs.js

@@ -12,6 +12,12 @@ const searchTypeDefs = gql`
         semantic: Boolean!
     }
 
+    type SearchRelatedNote {
+        id: ID!
+        title: String!
+        reasons: [String!]!
+    }
+
     type SearchNotesResult {
         totalCount: Int!
         notes: [Note!]!
@@ -23,6 +29,7 @@ const searchTypeDefs = gql`
 
     extend type Query {
         searchNotes(query: String!, pagination: PaginationInput!, mode: SearchMode = HYBRID): SearchNotesResult!
+        searchRelatedNotes(noteId: ID!, limit: Int = 5): [SearchRelatedNote!]!
     }
 `;
 export {

package/server/dist/features/search/hybrid-ranking.js

@@ -1,3 +1,5 @@
+const DEFAULT_LEXICAL_WEIGHT = 1;
+const DEFAULT_SEMANTIC_WEIGHT = 1.25;
 const DEFAULT_RANK_CONSTANT = 60;
 const uniqueNoteIds = (noteIds) => {
   return [...new Set(noteIds.filter((noteId) => Number.isInteger(noteId) && noteId > 0))];
@@ -5,8 +7,8 @@ const uniqueNoteIds = (noteIds) => {
 const fuseHybridSearchRanks = ({
   lexicalNoteIds,
   semanticNoteIds,
-  lexicalWeight = 1,
-  semanticWeight = 1,
+  lexicalWeight = DEFAULT_LEXICAL_WEIGHT,
+  semanticWeight = DEFAULT_SEMANTIC_WEIGHT,
   rankConstant = DEFAULT_RANK_CONSTANT
 }) => {
   const lexicalIds = uniqueNoteIds(lexicalNoteIds);

package/server/dist/features/search/hybrid-search.js

@@ -8,6 +8,7 @@ import { runDataMaintenanceInBackground } from "../../modules/data-maintenance.j
 import { fuseHybridSearchRanks } from "./hybrid-ranking.js";
 import { getDefaultSemanticSearchManager } from "./search-manager.js";
 const MAX_HYBRID_CANDIDATES = 80;
+const MAX_HYBRID_SEMANTIC_CANDIDATES = 30;
 const unavailableSemanticAttempt = (error) => ({
   available: false,
   used: false,
@@ -134,6 +135,7 @@ const createHybridNoteSearch = (dependencies = defaultDependencies) => {
       };
     }
     const candidateLimit = MAX_HYBRID_CANDIDATES;
+    const semanticCandidateLimit = mode === "hybrid" ? MAX_HYBRID_SEMANTIC_CANDIDATES : MAX_HYBRID_CANDIDATES;
     const [lexicalNoteIds, semanticAttempt] = await Promise.all([
       mode === "semantic" ? Promise.resolve([]) : dependencies.listLexicalNoteIds(normalizedQuery, candidateLimit),
       mode === "lexical" ? Promise.resolve({
@@ -141,11 +143,11 @@ const createHybridNoteSearch = (dependencies = defaultDependencies) => {
         used: false,
         matches: [],
         error: null
-      }) : dependencies.trySemanticSearch(normalizedQuery, candidateLimit).catch((error) => unavailableSemanticAttempt(error))
+      }) : dependencies.trySemanticSearch(normalizedQuery, semanticCandidateLimit).catch((error) => unavailableSemanticAttempt(error))
     ]);
     const rankedCandidates = fuseHybridSearchRanks({
       lexicalNoteIds,
-      semanticNoteIds: semanticAttempt.matches.map((match) => match.noteId)
+      semanticNoteIds: semanticAttempt.matches.slice(0, semanticCandidateLimit).map((match) => match.noteId)
     });
     const pageCandidates = rankedCandidates.slice(offset, offset + limit);
     const notes = await dependencies.findNotesByIds(pageCandidates.map((candidate) => candidate.noteId));

package/server/dist/features/search/related-notes.js

@@ -0,0 +1,186 @@
+import models, { Prisma } from "../../models.js";
+const MAX_RELATED_NOTES = 5;
+const normalizeLimit = (limit) => Math.min(MAX_RELATED_NOTES, Math.max(0, Math.trunc(limit)));
+const toDate = (value) => value instanceof Date ? value : new Date(value);
+const buildReasons = (candidate) => {
+  const reasons = [];
+  if (candidate.linked) {
+    reasons.push("Linked from this note");
+  }
+  if (candidate.backlink) {
+    reasons.push("Backlink to this note");
+  }
+  for (const tagName of candidate.sharedTagNames) {
+    reasons.push(`Shares ${tagName}`);
+  }
+  return reasons;
+};
+const compareCandidates = (left, right) => {
+  const leftScore = (left.linked ? 100 : 0) + (left.backlink ? 100 : 0) + left.sharedTagNames.length * 20;
+  const rightScore = (right.linked ? 100 : 0) + (right.backlink ? 100 : 0) + right.sharedTagNames.length * 20;
+  if (leftScore !== rightScore) {
+    return rightScore - leftScore;
+  }
+  const updatedAtDifference = right.updatedAt.getTime() - left.updatedAt.getTime();
+  return updatedAtDifference !== 0 ? updatedAtDifference : left.id - right.id;
+};
+const findCandidatesFromIndex = async ({
+  noteId,
+  tagIds,
+  limit
+}) => {
+  const rows = tagIds.length === 0 ? await models.$queryRaw(Prisma.sql`
+                  WITH candidate_scores AS (
+                      SELECT
+                          note."id" AS "id",
+                          note."title" AS "title",
+                          note."updatedAt" AS "updatedAt",
+                          CASE WHEN EXISTS (
+                              SELECT 1
+                              FROM "NoteReference" AS outgoing
+                              WHERE outgoing."sourceNoteId" = ${noteId}
+                                AND outgoing."targetNoteId" = note."id"
+                          ) THEN 1 ELSE 0 END AS "linked",
+                          CASE WHEN EXISTS (
+                              SELECT 1
+                              FROM "NoteReference" AS incoming
+                              WHERE incoming."targetNoteId" = ${noteId}
+                                AND incoming."sourceNoteId" = note."id"
+                          ) THEN 1 ELSE 0 END AS "backlink",
+                          0 AS "sharedTagCount"
+                      FROM "Note" AS note
+                      WHERE note."id" <> ${noteId}
+                        AND (
+                            EXISTS (
+                                SELECT 1
+                                FROM "NoteReference" AS outgoing
+                                WHERE outgoing."sourceNoteId" = ${noteId}
+                                  AND outgoing."targetNoteId" = note."id"
+                            )
+                            OR EXISTS (
+                                SELECT 1
+                                FROM "NoteReference" AS incoming
+                                WHERE incoming."targetNoteId" = ${noteId}
+                                  AND incoming."sourceNoteId" = note."id"
+                            )
+                        )
+                  )
+                  SELECT *, ("linked" * 100 + "backlink" * 100 + "sharedTagCount" * 20) AS "score"
+                  FROM candidate_scores
+                  ORDER BY "score" DESC, "updatedAt" DESC, "id" ASC
+                  LIMIT ${limit}
+              `) : await models.$queryRaw(Prisma.sql`
+                  WITH candidate_scores AS (
+                      SELECT
+                          note."id" AS "id",
+                          note."title" AS "title",
+                          note."updatedAt" AS "updatedAt",
+                          CASE WHEN EXISTS (
+                              SELECT 1
+                              FROM "NoteReference" AS outgoing
+                              WHERE outgoing."sourceNoteId" = ${noteId}
+                                AND outgoing."targetNoteId" = note."id"
+                          ) THEN 1 ELSE 0 END AS "linked",
+                          CASE WHEN EXISTS (
+                              SELECT 1
+                              FROM "NoteReference" AS incoming
+                              WHERE incoming."targetNoteId" = ${noteId}
+                                AND incoming."sourceNoteId" = note."id"
+                          ) THEN 1 ELSE 0 END AS "backlink",
+                          COUNT(DISTINCT noteTags."B") AS "sharedTagCount"
+                      FROM "Note" AS note
+                      LEFT JOIN "_NoteToTag" AS noteTags
+                        ON noteTags."A" = note."id"
+                       AND noteTags."B" IN (${Prisma.join(tagIds)})
+                      WHERE note."id" <> ${noteId}
+                        AND (
+                            EXISTS (
+                                SELECT 1
+                                FROM "NoteReference" AS outgoing
+                                WHERE outgoing."sourceNoteId" = ${noteId}
+                                  AND outgoing."targetNoteId" = note."id"
+                            )
+                            OR EXISTS (
+                                SELECT 1
+                                FROM "NoteReference" AS incoming
+                                WHERE incoming."targetNoteId" = ${noteId}
+                                  AND incoming."sourceNoteId" = note."id"
+                            )
+                            OR noteTags."B" IS NOT NULL
+                        )
+                      GROUP BY note."id", note."title", note."updatedAt"
+                  )
+                  SELECT *, ("linked" * 100 + "backlink" * 100 + "sharedTagCount" * 20) AS "score"
+                  FROM candidate_scores
+                  ORDER BY "score" DESC, "updatedAt" DESC, "id" ASC
+                  LIMIT ${limit}
+              `);
+  if (rows.length === 0) {
+    return [];
+  }
+  const candidateIds = rows.map((row) => row.id);
+  const candidateNotes = await models.note.findMany({
+    where: { id: { in: candidateIds } },
+    select: {
+      id: true,
+      tags: {
+        select: {
+          id: true,
+          name: true
+        }
+      }
+    }
+  });
+  const tagsByNoteId = new Map(candidateNotes.map((note) => [note.id, note.tags]));
+  const sourceTagIds = new Set(tagIds);
+  return rows.map((row) => ({
+    id: row.id,
+    title: row.title || "Untitled",
+    updatedAt: toDate(row.updatedAt),
+    linked: Number(row.linked) === 1,
+    backlink: Number(row.backlink) === 1,
+    sharedTagNames: (tagsByNoteId.get(row.id) ?? []).filter((tag) => sourceTagIds.has(tag.id)).map((tag) => tag.name).sort((left, right) => left.localeCompare(right))
+  }));
+};
+const defaultDependencies = {
+  findSourceNote: (noteId) => models.note.findUnique({
+    where: { id: noteId },
+    select: {
+      id: true,
+      tags: {
+        select: {
+          id: true,
+          name: true
+        }
+      }
+    }
+  }),
+  findCandidates: findCandidatesFromIndex
+};
+const createSearchRelatedNotes = (dependencies = defaultDependencies) => {
+  return async (noteId, limit = MAX_RELATED_NOTES) => {
+    const normalizedLimit = normalizeLimit(limit);
+    if (!Number.isSafeInteger(noteId) || noteId <= 0 || normalizedLimit === 0) {
+      return [];
+    }
+    const source = await dependencies.findSourceNote(noteId);
+    if (!source) {
+      return [];
+    }
+    const candidates = await dependencies.findCandidates({
+      noteId,
+      tagIds: source.tags.map((tag) => tag.id),
+      limit: normalizedLimit
+    });
+    return candidates.filter((candidate) => candidate.linked || candidate.backlink || candidate.sharedTagNames.length > 0).sort(compareCandidates).slice(0, normalizedLimit).map((candidate) => ({
+      id: candidate.id,
+      title: candidate.title || "Untitled",
+      reasons: buildReasons(candidate)
+    }));
+  };
+};
+const searchRelatedNotes = createSearchRelatedNotes();
+export {
+  createSearchRelatedNotes,
+  searchRelatedNotes
+};