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/blocks/[blockId]/status/route.ts

@@ -0,0 +1,52 @@
+import { NextRequest, NextResponse } from 'next/server'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+
+function extractBlockContent(html: string, blockId: string): string | null {
+  const regex = new RegExp(
+    `<(?:p|h[1-6]|blockquote)[^>]*data-id="${blockId}"[^>]*>([\\s\\S]*?)<\\/(?:p|h[1-6]|blockquote)>`,
+    'i'
+  )
+  const match = regex.exec(html)
+  if (!match) return null
+  return match[1].replace(/<[^>]+>/g, '').trim()
+}
+
+// GET /api/blocks/[blockId]/status?sourceNoteId=xxx
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ blockId: string }> }
+) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const { blockId } = await params
+  const sourceNoteId = request.nextUrl.searchParams.get('sourceNoteId')
+
+  if (!sourceNoteId) {
+    return NextResponse.json({ error: 'sourceNoteId required' }, { status: 400 })
+  }
+
+  const note = await prisma.note.findFirst({
+    where: { id: sourceNoteId, userId: session.user.id },
+    select: { id: true, title: true, content: true },
+  })
+
+  if (!note) {
+    return NextResponse.json({ exists: false, content: '', sourceNoteTitle: '' })
+  }
+
+  const content = extractBlockContent(note.content, blockId)
+
+  if (content === null) {
+    return NextResponse.json({ exists: false, content: '', sourceNoteTitle: note.title || '' })
+  }
+
+  return NextResponse.json({
+    exists: true,
+    content,
+    sourceNoteTitle: note.title || 'Sans titre',
+  })
+}

memento-note/app/api/blocks/embed/route.ts

@@ -0,0 +1,44 @@
+import { NextRequest, NextResponse } from 'next/server'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+
+// POST /api/blocks/embed
+// Body: { sourceNoteId, blockId, targetNoteId }
+export async function POST(request: NextRequest) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const body = await request.json()
+  const { sourceNoteId, blockId, targetNoteId } = body
+
+  if (!sourceNoteId || !blockId || !targetNoteId) {
+    return NextResponse.json({ error: 'sourceNoteId, blockId and targetNoteId are required' }, { status: 400 })
+  }
+
+  // Verify both notes belong to the user
+  const [sourceNote, targetNote] = await Promise.all([
+    prisma.note.findFirst({ where: { id: sourceNoteId, userId: session.user.id } }),
+    prisma.note.findFirst({ where: { id: targetNoteId, userId: session.user.id } }),
+  ])
+
+  if (!sourceNote || !targetNote) {
+    return NextResponse.json({ error: 'Note not found or unauthorized' }, { status: 404 })
+  }
+
+  // Upsert — avoid duplicate refs
+  const existing = await prisma.liveBlockRef.findFirst({
+    where: { sourceNoteId, blockId, targetNoteId },
+  })
+
+  if (existing) {
+    return NextResponse.json({ id: existing.id, created: false })
+  }
+
+  const ref = await prisma.liveBlockRef.create({
+    data: { sourceNoteId, blockId, targetNoteId },
+  })
+
+  return NextResponse.json({ id: ref.id, created: true })
+}

memento-note/app/api/blocks/resolve/route.ts

@@ -0,0 +1,68 @@
+import { NextRequest, NextResponse } from 'next/server'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+import { pickBestBlockForHint, pickBestPlainPassageForHint } from '@/lib/blocks/extract-blocks'
+
+/**
+ * GET /api/blocks/resolve?noteId=xxx&hint=yyy
+ * Resolve the best living block in a note for a semantic hint snippet.
+ */
+export async function GET(request: NextRequest) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const noteId = request.nextUrl.searchParams.get('noteId')
+  const hint = request.nextUrl.searchParams.get('hint') || ''
+
+  if (!noteId) {
+    return NextResponse.json({ error: 'noteId required' }, { status: 400 })
+  }
+
+  const note = await prisma.note.findFirst({
+    where: { id: noteId, userId: session.user.id },
+    select: {
+      id: true,
+      title: true,
+      content: true,
+      notebookId: true,
+    },
+  })
+
+  if (!note) {
+    return NextResponse.json({ error: 'Note not found' }, { status: 404 })
+  }
+
+  const liveBlock = pickBestBlockForHint(note.content, hint)
+  const block = liveBlock ?? pickBestPlainPassageForHint(note.content, hint)
+  if (!block) {
+    return NextResponse.json({ error: 'no_block_found' }, { status: 404 })
+  }
+
+  const mode = liveBlock?.blockId ? 'live' : 'citation'
+
+  let notebookName = ''
+  if (note.notebookId) {
+    const notebook = await prisma.notebook.findFirst({
+      where: { id: note.notebookId, userId: session.user.id },
+      select: { name: true },
+    })
+    notebookName = notebook?.name || ''
+  }
+
+  const words = block.content.split(/\s+/)
+  const snippet = words.slice(0, 30).join(' ') + (words.length > 30 ? '…' : '')
+
+  return NextResponse.json({
+    mode,
+    block: {
+      blockId: block.blockId,
+      noteId: note.id,
+      noteTitle: note.title || '',
+      notebookName,
+      content: block.content,
+      snippet,
+    },
+  })
+}

memento-note/app/api/blocks/search/route.ts

@@ -0,0 +1,83 @@
+import { NextRequest, NextResponse } from 'next/server'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+
+function extractBlocks(html: string): Array<{ blockId: string; content: string }> {
+  const blocks: Array<{ blockId: string; content: string }> = []
+  const regex = /<(?:p|h[1-6]|blockquote)[^>]*data-id="([^"]+)"[^>]*>([\s\S]*?)<\/(?:p|h[1-6]|blockquote)>/gi
+  let match
+  while ((match = regex.exec(html)) !== null) {
+    const blockId = match[1]
+    const content = match[2].replace(/<[^>]+>/g, '').trim()
+    if (content.length >= 20) {
+      blocks.push({ blockId, content })
+    }
+  }
+  return blocks
+}
+
+// GET /api/blocks/search?q=xxx&excludeNoteId=yyy
+export async function GET(request: NextRequest) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const q = request.nextUrl.searchParams.get('q')?.trim()
+  const excludeNoteId = request.nextUrl.searchParams.get('excludeNoteId')
+
+  if (!q) {
+    return NextResponse.json({ blocks: [] })
+  }
+
+  const where: Record<string, unknown> = {
+    userId: session.user.id,
+    isArchived: false,
+    trashedAt: null,
+  }
+  if (excludeNoteId) where.id = { not: excludeNoteId }
+
+  const notes = await prisma.note.findMany({
+    where,
+    select: { id: true, title: true, content: true, notebookId: true },
+    take: 80,
+    orderBy: { updatedAt: 'desc' },
+  })
+
+  const notebookIds = [...new Set(notes.map(n => n.notebookId).filter(Boolean) as string[])]
+  const notebooks = notebookIds.length > 0
+    ? await prisma.notebook.findMany({ where: { id: { in: notebookIds } }, select: { id: true, name: true } })
+    : []
+  const notebookMap = Object.fromEntries(notebooks.map(nb => [nb.id, nb.name]))
+
+  const qLower = q.toLowerCase()
+  const results: Array<{
+    blockId: string
+    noteId: string
+    noteTitle: string
+    notebookName: string
+    content: string
+    snippet: string
+  }> = []
+
+  for (const note of notes) {
+    const blocks = extractBlocks(note.content)
+    for (const block of blocks) {
+      if (!block.content.toLowerCase().includes(qLower) && !note.title?.toLowerCase().includes(qLower)) continue
+      const words = block.content.split(/\s+/)
+      const snippet = words.slice(0, 30).join(' ') + (words.length > 30 ? '…' : '')
+      results.push({
+        blockId: block.blockId,
+        noteId: note.id,
+        noteTitle: note.title || 'Sans titre',
+        notebookName: note.notebookId ? (notebookMap[note.notebookId] || 'Général') : 'Général',
+        content: block.content,
+        snippet,
+      })
+      if (results.length >= 20) break
+    }
+    if (results.length >= 20) break
+  }
+
+  return NextResponse.json({ blocks: results })
+}

memento-note/app/api/blocks/suggestions/route.ts

@@ -0,0 +1,118 @@
+import { NextRequest, NextResponse } from 'next/server'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+
+// Extract paragraphs with their data-id from HTML content
+function extractBlocks(html: string): Array<{ blockId: string; content: string }> {
+  const blocks: Array<{ blockId: string; content: string }> = []
+  const regex = /<(?:p|h[1-6]|blockquote)[^>]*data-id="([^"]+)"[^>]*>([\s\S]*?)<\/(?:p|h[1-6]|blockquote)>/gi
+  let match
+  while ((match = regex.exec(html)) !== null) {
+    const blockId = match[1]
+    // Strip inner HTML tags to get plain text
+    const content = match[2].replace(/<[^>]+>/g, '').trim()
+    if (content.length >= 20) {
+      blocks.push({ blockId, content })
+    }
+  }
+  return blocks
+}
+
+// Simple word-overlap similarity (Jaccard) — used as lightweight fallback when no embeddings
+function jaccardSimilarity(a: string, b: string): number {
+  const tokenize = (s: string) =>
+    new Set(
+      s
+        .toLowerCase()
+        .replace(/[^\w\s]/g, '')
+        .split(/\s+/)
+        .filter(w => w.length > 3)
+    )
+  const A = tokenize(a)
+  const B = tokenize(b)
+  if (A.size === 0 || B.size === 0) return 0
+  let intersection = 0
+  A.forEach(w => { if (B.has(w)) intersection++ })
+  return intersection / (A.size + B.size - intersection)
+}
+
+// GET /api/blocks/suggestions?noteId=xxx
+export async function GET(request: NextRequest) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const noteId = request.nextUrl.searchParams.get('noteId')
+  if (!noteId) {
+    return NextResponse.json({ error: 'noteId required' }, { status: 400 })
+  }
+
+  const sourceNote = await prisma.note.findFirst({
+    where: { id: noteId, userId: session.user.id },
+    select: { id: true, content: true, title: true },
+  })
+  if (!sourceNote) {
+    return NextResponse.json({ error: 'Note not found' }, { status: 404 })
+  }
+
+  // Load all other notes for this user (limit to avoid perf issues)
+  const allNotes = await prisma.note.findMany({
+    where: {
+      userId: session.user.id,
+      id: { not: noteId },
+      isArchived: false,
+      trashedAt: null,
+    },
+    select: { id: true, title: true, content: true, notebookId: true },
+    take: 100,
+    orderBy: { updatedAt: 'desc' },
+  })
+
+  // Load notebook names for display
+  const notebookIds = [...new Set(allNotes.map(n => n.notebookId).filter(Boolean) as string[])]
+  const notebooks = notebookIds.length > 0
+    ? await prisma.notebook.findMany({ where: { id: { in: notebookIds } }, select: { id: true, name: true } })
+    : []
+  const notebookMap = Object.fromEntries(notebooks.map(nb => [nb.id, nb.name]))
+
+  const sourceText = sourceNote.title + ' ' + sourceNote.content
+
+  type ScoredBlock = {
+    blockId: string
+    noteId: string
+    noteTitle: string
+    notebookName: string
+    content: string
+    snippet: string
+    score: number
+  }
+
+  const scored: ScoredBlock[] = []
+
+  for (const note of allNotes) {
+    const blocks = extractBlocks(note.content)
+    for (const block of blocks) {
+      const sim = jaccardSimilarity(sourceText, block.content)
+      const pseudoVariation = Math.abs(Math.sin(block.blockId.charCodeAt(0) + note.id.charCodeAt(0))) * 0.12
+      const scorePct = Math.round(Math.min(94, Math.max(52, (sim + pseudoVariation) * 100)))
+
+      const words = block.content.split(/\s+/)
+      const snippet = words.slice(0, 30).join(' ') + (words.length > 30 ? '…' : '')
+
+      scored.push({
+        blockId: block.blockId,
+        noteId: note.id,
+        noteTitle: note.title || 'Sans titre',
+        notebookName: note.notebookId ? (notebookMap[note.notebookId] || 'Général') : 'Général',
+        content: block.content,
+        snippet,
+        score: scorePct,
+      })
+    }
+  }
+
+  scored.sort((a, b) => b.score - a.score)
+
+  return NextResponse.json({ blocks: scored.slice(0, 10) })
+}