feat(notes): liens internes, onglet Réseau, living blocks et consentement IA

Rend les liens entre notes visibles et persistants (sync NoteLink au save, auto-save, graphe réseau rafraîchi), ajoute living blocks, Memory Echo, recherche globale, consentement IA explicite et consolide les prototypes design en architectural-grid.

Co-authored-by: Cursor <cursoragent@cursor.com>

memento-note/app/api/notes/[id]/network/route.ts

@@ -0,0 +1,184 @@
+import { NextRequest, NextResponse } from 'next/server'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+import { memoryEchoService } from '@/lib/ai/services/memory-echo.service'
+import { hasUserAiConsent } from '@/lib/consent/server-consent'
+import { SEMANTIC_SIMILARITY_FLOOR, SEMANTIC_SIMILARITY_FLOOR_DEMO } from '@/lib/ai/semantic-proximity'
+import { extractNoteLinkTargets } from '@/lib/notes/sync-note-links'
+
+function excerpt(text: string, max = 120): string {
+  const plain = text.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim()
+  if (plain.length <= max) return plain
+  return `${plain.slice(0, max).trim()}…`
+}
+
+function extractWikilinks(content: string): { title: string; snippet: string }[] {
+  return extractNoteLinkTargets(content).map(t => ({
+    title: t.title,
+    snippet: t.snippet,
+  }))
+}
+
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const { id } = await params
+
+  const note = await prisma.note.findUnique({
+    where: { id },
+    select: { id: true, userId: true, title: true, content: true },
+  })
+
+  if (!note || note.userId !== session.user.id) {
+    return NextResponse.json({ error: 'Not found' }, { status: 404 })
+  }
+
+  let backlinks: Awaited<ReturnType<typeof prisma.noteLink.findMany>> = []
+  let outbound: Awaited<ReturnType<typeof prisma.noteLink.findMany>> = []
+  try {
+    ;[backlinks, outbound] = await Promise.all([
+      prisma.noteLink.findMany({
+        where: { targetNoteId: id },
+        include: {
+          sourceNote: {
+            select: { id: true, title: true, updatedAt: true, notebookId: true },
+          },
+        },
+        orderBy: { createdAt: 'desc' },
+      }),
+      prisma.noteLink.findMany({
+        where: { sourceNoteId: id },
+        include: {
+          targetNote: {
+            select: { id: true, title: true, updatedAt: true, notebookId: true },
+          },
+        },
+        orderBy: { createdAt: 'desc' },
+      }),
+    ])
+  } catch (err) {
+    console.error('[network] NoteLink query failed:', err)
+  }
+
+  const mapBacklink = (bl: (typeof backlinks)[number]) => ({
+    id: bl.id,
+    note: bl.sourceNote,
+    contextSnippet: bl.contextSnippet,
+    createdAt: bl.createdAt,
+  })
+  const mapOutbound = (ol: (typeof outbound)[number]) => ({
+    id: ol.id,
+    note: ol.targetNote,
+    contextSnippet: ol.contextSnippet,
+    createdAt: ol.createdAt,
+  })
+
+  const backlinkRows = backlinks.map(mapBacklink)
+  const outboundRows = outbound.map(mapOutbound)
+
+  const linkedTitles = new Set(
+    outboundRows.map(link => (link.note?.title || '').toLowerCase()).filter(Boolean)
+  )
+
+  const wikilinks = extractWikilinks(note.content || '')
+  const unlinkedMentions = wikilinks
+    .filter(w => !linkedTitles.has(w.title.toLowerCase()))
+    .map(w => ({
+      title: w.title,
+      snippet: w.snippet,
+    }))
+
+  const liveBlockRefs = await prisma.liveBlockRef.findMany({
+    where: { sourceNoteId: id },
+    orderBy: { createdAt: 'desc' },
+    select: {
+      id: true,
+      blockId: true,
+      targetNoteId: true,
+      targetNote: {
+        select: { id: true, title: true, notebookId: true },
+      },
+    },
+  })
+
+  const embedHosts = new Map<string, {
+    note: { id: string; title: string | null; notebookId: string | null }
+    blockIds: string[]
+  }>()
+  for (const ref of liveBlockRefs) {
+    const existing = embedHosts.get(ref.targetNoteId)
+    if (existing) {
+      if (!existing.blockIds.includes(ref.blockId)) existing.blockIds.push(ref.blockId)
+      continue
+    }
+    embedHosts.set(ref.targetNoteId, {
+      note: ref.targetNote,
+      blockIds: [ref.blockId],
+    })
+  }
+
+  let semanticConnections: {
+    noteId: string
+    title: string | null
+    notebookId: string | null
+    similarity: number
+    excerpt: string
+  }[] = []
+  let consentRequired = false
+  let similarityFloor = SEMANTIC_SIMILARITY_FLOOR
+
+  try {
+    if (await hasUserAiConsent()) {
+      const aiSettings = await prisma.userAISettings.findUnique({
+        where: { userId: session.user.id },
+        select: { demoMode: true },
+      })
+      similarityFloor = aiSettings?.demoMode ? SEMANTIC_SIMILARITY_FLOOR_DEMO : SEMANTIC_SIMILARITY_FLOOR
+
+      const echoLinks = await memoryEchoService.getConnectionsForNote(id, session.user.id)
+      const otherIds = echoLinks.map(conn => (conn.note1.id === id ? conn.note2.id : conn.note1.id))
+      const notebookRows = otherIds.length > 0
+        ? await prisma.note.findMany({
+            where: { id: { in: otherIds }, userId: session.user.id },
+            select: { id: true, notebookId: true },
+          })
+        : []
+      const notebookByNote = Object.fromEntries(notebookRows.map(n => [n.id, n.notebookId]))
+
+      semanticConnections = echoLinks.map(conn => {
+        const isNote1Target = conn.note1.id === id
+        const other = isNote1Target ? conn.note2 : conn.note1
+        return {
+          noteId: other.id,
+          title: other.title,
+          notebookId: notebookByNote[other.id] ?? null,
+          similarity: conn.similarityScore,
+          excerpt: excerpt(other.content || ''),
+        }
+      })
+    } else {
+      consentRequired = true
+    }
+  } catch {
+    semanticConnections = []
+  }
+
+  return NextResponse.json({
+    backlinks: backlinkRows,
+    outbound: outboundRows,
+    unlinkedMentions,
+    semanticConnections,
+    consentRequired,
+    similarityFloor,
+    embedHosts: Array.from(embedHosts.values()).map(entry => ({
+      note: entry.note,
+      blockIds: entry.blockIds,
+    })),
+  })
+}