chore: clean up repo for public release

- Remove BMAD framework, IDE configs, dev screenshots, test files,
  internal docs, and backup files
- Rename keep-notes/ to memento-note/
- Update all references from keep-notes to memento-note
- Add Apache 2.0 license with Commons Clause (non-commercial restriction)
- Add clean .gitignore and .env.docker.example

memento-note/.backup-keep/favorites-section.tsx

@@ -0,0 +1,85 @@
+'use client'
+
+import { useState } from 'react'
+import { Note } from '@/lib/types'
+import { NoteCard } from './note-card'
+import { ChevronDown, ChevronUp, Pin } from 'lucide-react'
+import { useLanguage } from '@/lib/i18n'
+
+interface FavoritesSectionProps {
+  pinnedNotes: Note[]
+  onEdit?: (note: Note, readOnly?: boolean) => void
+  onSizeChange?: (noteId: string, size: 'small' | 'medium' | 'large') => void
+  isLoading?: boolean
+}
+
+export function FavoritesSection({ pinnedNotes, onEdit, onSizeChange, isLoading }: FavoritesSectionProps) {
+  const [isCollapsed, setIsCollapsed] = useState(false)
+  const { t } = useLanguage()
+
+  if (isLoading) {
+    return (
+      <section data-testid="favorites-section" className="mb-8">
+        <div className="flex items-center gap-2 mb-4 px-2 py-2">
+          <Pin className="w-5 h-5 text-muted-foreground animate-pulse" />
+          <div className="h-6 w-32 bg-muted rounded animate-pulse" />
+        </div>
+        <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
+          {[1, 2, 3].map((i) => (
+            <div key={i} className="h-40 bg-muted rounded-2xl animate-pulse" />
+          ))}
+        </div>
+      </section>
+    )
+  }
+
+  if (pinnedNotes.length === 0) {
+    return null
+  }
+
+  return (
+    <section data-testid="favorites-section" className="mb-8">
+      <button
+        onClick={() => setIsCollapsed(!isCollapsed)}
+        onKeyDown={(e) => {
+          if (e.key === 'Enter' || e.key === ' ') {
+            e.preventDefault()
+            setIsCollapsed(!isCollapsed)
+          }
+        }}
+        className="w-full flex items-center justify-between gap-2 mb-4 px-2 py-2 hover:bg-accent rounded-lg transition-colors min-h-[44px]"
+        aria-expanded={!isCollapsed}
+        aria-label={t('favorites.toggleSection') || 'Toggle pinned notes section'}
+      >
+        <div className="flex items-center gap-2">
+          <span className="text-2xl">📌</span>
+          <h2 className="text-lg font-semibold text-foreground">
+            {t('notes.pinnedNotes')}
+            <span className="text-sm font-medium text-muted-foreground ml-2">
+              ({pinnedNotes.length})
+            </span>
+          </h2>
+        </div>
+        {isCollapsed ? (
+          <ChevronDown className="w-5 h-5 text-muted-foreground" />
+        ) : (
+          <ChevronUp className="w-5 h-5 text-muted-foreground" />
+        )}
+      </button>
+
+      {/* Collapsible Content */}
+      {!isCollapsed && (
+        <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
+          {pinnedNotes.map((note) => (
+            <NoteCard
+              key={note.id}
+              note={note}
+              onEdit={onEdit}
+              onSizeChange={(size) => onSizeChange?.(note.id, size)}
+            />
+          ))}
+        </div>
+      )}
+    </section>
+  )
+}

memento-note/.backup-keep/home-client.tsx

@@ -0,0 +1,454 @@
+'use client'
+
+import { useState, useEffect, useCallback } from 'react'
+import { useSearchParams, useRouter } from 'next/navigation'
+import dynamic from 'next/dynamic'
+import { Note } from '@/lib/types'
+import { getAISettings } from '@/app/actions/ai-settings'
+import { getAllNotes, searchNotes } from '@/app/actions/notes'
+import { NoteInput } from '@/components/note-input'
+import { NotesMainSection, type NotesViewMode } from '@/components/notes-main-section'
+import { NotesViewToggle } from '@/components/notes-view-toggle'
+import { MemoryEchoNotification } from '@/components/memory-echo-notification'
+import { NotebookSuggestionToast } from '@/components/notebook-suggestion-toast'
+import { FavoritesSection } from '@/components/favorites-section'
+import { Button } from '@/components/ui/button'
+import { Wand2 } from 'lucide-react'
+import { useLabels } from '@/context/LabelContext'
+import { useNoteRefresh } from '@/context/NoteRefreshContext'
+import { useReminderCheck } from '@/hooks/use-reminder-check'
+import { useAutoLabelSuggestion } from '@/hooks/use-auto-label-suggestion'
+import { useNotebooks } from '@/context/notebooks-context'
+import { Folder, Briefcase, FileText, Zap, BarChart3, Globe, Sparkles, Book, Heart, Crown, Music, Building2, Plane, ChevronRight, Plus } from 'lucide-react'
+import { cn } from '@/lib/utils'
+import { LabelFilter } from '@/components/label-filter'
+import { useLanguage } from '@/lib/i18n'
+import { useHomeView } from '@/context/home-view-context'
+
+// Lazy-load heavy dialogs — uniquement chargés à la demande
+const NoteEditor = dynamic(
+  () => import('@/components/note-editor').then(m => ({ default: m.NoteEditor })),
+  { ssr: false }
+)
+const BatchOrganizationDialog = dynamic(
+  () => import('@/components/batch-organization-dialog').then(m => ({ default: m.BatchOrganizationDialog })),
+  { ssr: false }
+)
+const AutoLabelSuggestionDialog = dynamic(
+  () => import('@/components/auto-label-suggestion-dialog').then(m => ({ default: m.AutoLabelSuggestionDialog })),
+  { ssr: false }
+)
+
+type InitialSettings = {
+  showRecentNotes: boolean
+  notesViewMode: 'masonry' | 'tabs'
+}
+
+interface HomeClientProps {
+  /** Notes pré-chargées côté serveur — hydratées immédiatement sans loading spinner */
+  initialNotes: Note[]
+  initialSettings: InitialSettings
+}
+
+export function HomeClient({ initialNotes, initialSettings }: HomeClientProps) {
+  const searchParams = useSearchParams()
+  const router = useRouter()
+  const { t } = useLanguage()
+
+  const [notes, setNotes] = useState<Note[]>(initialNotes)
+  const [pinnedNotes, setPinnedNotes] = useState<Note[]>(
+    initialNotes.filter(n => n.isPinned)
+  )
+  const [notesViewMode, setNotesViewMode] = useState<NotesViewMode>(initialSettings.notesViewMode)
+  const [editingNote, setEditingNote] = useState<{ note: Note; readOnly?: boolean } | null>(null)
+  const [isLoading, setIsLoading] = useState(false) // false by default — data is pre-loaded
+  const [notebookSuggestion, setNotebookSuggestion] = useState<{ noteId: string; content: string } | null>(null)
+  const [batchOrganizationOpen, setBatchOrganizationOpen] = useState(false)
+  const { refreshKey } = useNoteRefresh()
+  const { labels } = useLabels()
+  const { setControls } = useHomeView()
+
+  const { shouldSuggest: shouldSuggestLabels, notebookId: suggestNotebookId, dismiss: dismissLabelSuggestion } = useAutoLabelSuggestion()
+  const [autoLabelOpen, setAutoLabelOpen] = useState(false)
+
+  useEffect(() => {
+    if (shouldSuggestLabels && suggestNotebookId) {
+      setAutoLabelOpen(true)
+    }
+  }, [shouldSuggestLabels, suggestNotebookId])
+
+  const notebookFilter = searchParams.get('notebook')
+  const isInbox = !notebookFilter
+
+  const handleNoteCreated = useCallback((note: Note) => {
+    setNotes((prevNotes) => {
+      const notebookFilter = searchParams.get('notebook')
+      const labelFilter = searchParams.get('labels')?.split(',').filter(Boolean) || []
+      const colorFilter = searchParams.get('color')
+      const search = searchParams.get('search')?.trim() || null
+
+      if (notebookFilter && note.notebookId !== notebookFilter) return prevNotes
+      if (!notebookFilter && note.notebookId) return prevNotes
+
+      if (labelFilter.length > 0) {
+        const noteLabels = note.labels || []
+        if (!noteLabels.some((label: string) => labelFilter.includes(label))) return prevNotes
+      }
+
+      if (colorFilter) {
+        const labelNamesWithColor = labels
+          .filter((label: any) => label.color === colorFilter)
+          .map((label: any) => label.name)
+        const noteLabels = note.labels || []
+        if (!noteLabels.some((label: string) => labelNamesWithColor.includes(label))) return prevNotes
+      }
+
+      if (search) {
+        router.refresh()
+        return prevNotes
+      }
+
+      const isPinned = note.isPinned || false
+      const pinnedNotes = prevNotes.filter(n => n.isPinned)
+      const unpinnedNotes = prevNotes.filter(n => !n.isPinned)
+
+      if (isPinned) {
+        return [note, ...pinnedNotes, ...unpinnedNotes]
+      } else {
+        return [...pinnedNotes, note, ...unpinnedNotes]
+      }
+    })
+
+    if (!note.notebookId) {
+      const wordCount = (note.content || '').trim().split(/\s+/).filter(w => w.length > 0).length
+      if (wordCount >= 20) {
+        setNotebookSuggestion({ noteId: note.id, content: note.content || '' })
+      }
+    }
+  }, [searchParams, labels, router])
+
+  const handleOpenNote = (noteId: string) => {
+    const note = notes.find(n => n.id === noteId)
+    if (note) setEditingNote({ note, readOnly: false })
+  }
+
+  const handleSizeChange = useCallback((noteId: string, size: 'small' | 'medium' | 'large') => {
+    setNotes(prev => prev.map(n => n.id === noteId ? { ...n, size } : n))
+    setPinnedNotes(prev => prev.map(n => n.id === noteId ? { ...n, size } : n))
+  }, [])
+
+  useReminderCheck(notes)
+
+  // Rechargement uniquement pour les filtres actifs (search, labels, notebook)
+  // Les notes initiales suffisent sans filtre
+  useEffect(() => {
+    const search = searchParams.get('search')?.trim() || null
+    const labelFilter = searchParams.get('labels')?.split(',').filter(Boolean) || []
+    const colorFilter = searchParams.get('color')
+    const notebook = searchParams.get('notebook')
+    const semanticMode = searchParams.get('semantic') === 'true'
+
+    // Pour le refreshKey (mutations), toujours recharger
+    // Pour les filtres, charger depuis le serveur
+    const hasActiveFilter = search || labelFilter.length > 0 || colorFilter
+
+    const load = async () => {
+      setIsLoading(true)
+      let allNotes = search
+        ? await searchNotes(search, semanticMode, notebook || undefined)
+        : await getAllNotes()
+
+      // Filtre notebook côté client
+      if (notebook) {
+        allNotes = allNotes.filter((note: any) => note.notebookId === notebook)
+      } else {
+        allNotes = allNotes.filter((note: any) => !note.notebookId)
+      }
+
+      // Filtre labels
+      if (labelFilter.length > 0) {
+        allNotes = allNotes.filter((note: any) =>
+          note.labels?.some((label: string) => labelFilter.includes(label))
+        )
+      }
+
+      // Filtre couleur
+      if (colorFilter) {
+        const labelNamesWithColor = labels
+          .filter((label: any) => label.color === colorFilter)
+          .map((label: any) => label.name)
+        allNotes = allNotes.filter((note: any) =>
+          note.labels?.some((label: string) => labelNamesWithColor.includes(label))
+        )
+      }
+
+      // Merger avec les tailles locales pour ne pas écraser les modifications
+      setNotes(prev => {
+        const localSizeMap = new Map(prev.map(n => [n.id, n.size]))
+        return allNotes.map(n => ({ ...n, size: localSizeMap.get(n.id) ?? n.size }))
+      })
+      setPinnedNotes(allNotes.filter((n: any) => n.isPinned))
+      setIsLoading(false)
+    }
+
+    // Éviter le rechargement initial si les notes sont déjà chargées sans filtres
+    if (refreshKey > 0 || hasActiveFilter) {
+      const cancelled = { value: false }
+      load().then(() => { if (cancelled.value) return })
+      return () => { cancelled.value = true }
+    } else {
+      // Données initiales : filtrage inbox/notebook côté client seulement
+      let filtered = initialNotes
+      if (notebook) {
+        filtered = initialNotes.filter(n => n.notebookId === notebook)
+      } else {
+        filtered = initialNotes.filter(n => !n.notebookId)
+      }
+      // Merger avec les tailles déjà modifiées localement
+      setNotes(prev => {
+        const localSizeMap = new Map(prev.map(n => [n.id, n.size]))
+        return filtered.map(n => ({ ...n, size: localSizeMap.get(n.id) ?? n.size }))
+      })
+      setPinnedNotes(filtered.filter(n => n.isPinned))
+    }
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [searchParams, refreshKey])
+
+  const { notebooks } = useNotebooks()
+  const currentNotebook = notebooks.find((n: any) => n.id === searchParams.get('notebook'))
+  const [showNoteInput, setShowNoteInput] = useState(false)
+
+  useEffect(() => {
+    setControls({
+      isTabsMode: notesViewMode === 'tabs',
+      openNoteComposer: () => setShowNoteInput(true),
+    })
+    return () => setControls(null)
+  }, [notesViewMode, setControls])
+
+  const getNotebookIcon = (iconName: string) => {
+    const ICON_MAP: Record<string, any> = {
+      'folder': Folder,
+      'briefcase': Briefcase,
+      'document': FileText,
+      'lightning': Zap,
+      'chart': BarChart3,
+      'globe': Globe,
+      'sparkle': Sparkles,
+      'book': Book,
+      'heart': Heart,
+      'crown': Crown,
+      'music': Music,
+      'building': Building2,
+      'flight_takeoff': Plane,
+    }
+    return ICON_MAP[iconName] || Folder
+  }
+
+  const handleNoteCreatedWrapper = (note: any) => {
+    handleNoteCreated(note)
+    setShowNoteInput(false)
+  }
+
+  const Breadcrumbs = ({ notebookName }: { notebookName: string }) => (
+    <div className="flex items-center gap-2 text-sm text-muted-foreground mb-1">
+      <span>{t('nav.notebooks')}</span>
+      <ChevronRight className="w-4 h-4" />
+      <span className="font-medium text-primary">{notebookName}</span>
+    </div>
+  )
+
+  const isTabs = notesViewMode === 'tabs'
+
+  return (
+    <div
+      className={cn(
+        'flex w-full min-h-0 flex-1 flex-col',
+        isTabs ? 'gap-3 py-1' : 'h-full px-2 py-6 sm:px-4 md:px-8'
+      )}
+    >
+      {/* Notebook Specific Header */}
+      {currentNotebook ? (
+        <div
+          className={cn(
+            'flex flex-col animate-in fade-in slide-in-from-top-2 duration-300',
+            isTabs ? 'mb-3 gap-3' : 'mb-8 gap-6'
+          )}
+        >
+          <Breadcrumbs notebookName={currentNotebook.name} />
+          <div className="flex items-start justify-between">
+            <div className="flex items-center gap-5">
+              <div className="p-3 bg-primary/10 dark:bg-primary/20 rounded-xl">
+                {(() => {
+                  const Icon = getNotebookIcon(currentNotebook.icon || 'folder')
+                  return (
+                    <Icon
+                      className={cn("w-8 h-8", !currentNotebook.color && "text-primary dark:text-primary-foreground")}
+                      style={currentNotebook.color ? { color: currentNotebook.color } : undefined}
+                    />
+                  )
+                })()}
+              </div>
+              <h1 className="text-4xl font-bold text-gray-900 dark:text-white tracking-tight">{currentNotebook.name}</h1>
+            </div>
+            <div className="flex flex-wrap items-center gap-3">
+              <NotesViewToggle mode={notesViewMode} onModeChange={setNotesViewMode} />
+              <LabelFilter
+                selectedLabels={searchParams.get('labels')?.split(',').filter(Boolean) || []}
+                onFilterChange={(newLabels) => {
+                  const params = new URLSearchParams(searchParams.toString())
+                  if (newLabels.length > 0) params.set('labels', newLabels.join(','))
+                  else params.delete('labels')
+                  router.push(`/?${params.toString()}`)
+                }}
+                className="border-gray-200"
+              />
+              {!isTabs && (
+                <Button
+                  onClick={() => setShowNoteInput(!showNoteInput)}
+                  className="h-10 px-6 rounded-full bg-primary hover:bg-primary/90 text-primary-foreground font-medium shadow-sm gap-2 transition-all"
+                >
+                  <Plus className="w-5 h-5" />
+                  {t('notes.addNote') || 'Add Note'}
+                </Button>
+              )}
+            </div>
+          </div>
+        </div>
+      ) : (
+        <div
+          className={cn(
+            'flex flex-col animate-in fade-in slide-in-from-top-2 duration-300',
+            isTabs ? 'mb-3 gap-3' : 'mb-8 gap-6'
+          )}
+        >
+          {!isTabs && <div className="mb-1 h-5" />}
+          <div className="flex items-start justify-between">
+            <div className="flex items-center gap-5">
+              <div className="p-3 bg-white border border-gray-100 dark:bg-gray-800 dark:border-gray-700 rounded-xl shadow-sm">
+                <FileText className="w-8 h-8 text-primary" />
+              </div>
+              <h1 className="text-4xl font-bold text-gray-900 dark:text-white tracking-tight">{t('notes.title')}</h1>
+            </div>
+            <div className="flex flex-wrap items-center gap-3">
+              <NotesViewToggle mode={notesViewMode} onModeChange={setNotesViewMode} />
+              <LabelFilter
+                selectedLabels={searchParams.get('labels')?.split(',').filter(Boolean) || []}
+                onFilterChange={(newLabels) => {
+                  const params = new URLSearchParams(searchParams.toString())
+                  if (newLabels.length > 0) params.set('labels', newLabels.join(','))
+                  else params.delete('labels')
+                  router.push(`/?${params.toString()}`)
+                }}
+                className="border-gray-200"
+              />
+              {isInbox && !isLoading && notes.length >= 2 && (
+                <Button
+                  onClick={() => setBatchOrganizationOpen(true)}
+                  variant="outline"
+                  className="h-10 px-4 rounded-full border-gray-200 text-gray-700 hover:bg-gray-50 gap-2 shadow-sm"
+                  title={t('batch.organizeWithAI')}
+                >
+                  <Wand2 className="h-4 w-4 text-purple-600" />
+                  <span className="hidden sm:inline">{t('batch.organize')}</span>
+                </Button>
+              )}
+              {!isTabs && (
+                <Button
+                  onClick={() => setShowNoteInput(!showNoteInput)}
+                  className="h-10 px-6 rounded-full bg-primary hover:bg-primary/90 text-primary-foreground font-medium shadow-sm gap-2 transition-all"
+                >
+                  <Plus className="w-5 h-5" />
+                  {t('notes.newNote')}
+                </Button>
+              )}
+            </div>
+          </div>
+        </div>
+      )}
+
+      {showNoteInput && (
+        <div
+          className={cn(
+            'animate-in fade-in slide-in-from-top-4 duration-300',
+            isTabs ? 'mb-3 w-full shrink-0' : 'mb-8'
+          )}
+        >
+          <NoteInput
+            onNoteCreated={handleNoteCreatedWrapper}
+            forceExpanded={true}
+            fullWidth={isTabs}
+          />
+        </div>
+      )}
+
+      {isLoading ? (
+        <div className="text-center py-8 text-gray-500">{t('general.loading')}</div>
+      ) : (
+        <>
+          <FavoritesSection
+            pinnedNotes={pinnedNotes}
+            onEdit={(note, readOnly) => setEditingNote({ note, readOnly })}
+            onSizeChange={handleSizeChange}
+          />
+
+          {notes.filter((note) => !note.isPinned).length > 0 && (
+            <div className={cn(isTabs && 'flex min-h-0 flex-1 flex-col')}>
+              <NotesMainSection
+                viewMode={notesViewMode}
+                notes={notes.filter((note) => !note.isPinned)}
+                onEdit={(note, readOnly) => setEditingNote({ note, readOnly })}
+                onSizeChange={handleSizeChange}
+                currentNotebookId={searchParams.get('notebook')}
+              />
+            </div>
+          )}
+
+          {notes.filter(note => !note.isPinned).length === 0 && pinnedNotes.length === 0 && (
+            <div className="text-center py-8 text-gray-500">
+              {t('notes.emptyState')}
+            </div>
+          )}
+        </>
+      )}
+
+      <MemoryEchoNotification onOpenNote={handleOpenNote} />
+
+      {notebookSuggestion && (
+        <NotebookSuggestionToast
+          noteId={notebookSuggestion.noteId}
+          noteContent={notebookSuggestion.content}
+          onDismiss={() => setNotebookSuggestion(null)}
+        />
+      )}
+
+      {batchOrganizationOpen && (
+        <BatchOrganizationDialog
+          open={batchOrganizationOpen}
+          onOpenChange={setBatchOrganizationOpen}
+          onNotesMoved={() => router.refresh()}
+        />
+      )}
+
+      {autoLabelOpen && (
+        <AutoLabelSuggestionDialog
+          open={autoLabelOpen}
+          onOpenChange={(open) => {
+            setAutoLabelOpen(open)
+            if (!open) dismissLabelSuggestion()
+          }}
+          notebookId={suggestNotebookId}
+          onLabelsCreated={() => router.refresh()}
+        />
+      )}
+
+      {editingNote && (
+        <NoteEditor
+          note={editingNote.note}
+          readOnly={editingNote.readOnly}
+          onClose={() => setEditingNote(null)}
+        />
+      )}
+    </div>
+  )
+}

memento-note/.backup-keep/masonry-grid.css

@@ -0,0 +1,132 @@
+/**
+ * Masonry Grid — CSS Grid avec tailles visibles
+ * Layout avec espaces minimisés via dense, drag-and-drop via @dnd-kit
+ */
+
+/* ─── Container ──────────────────────────────────── */
+.masonry-container {
+  width: 100%;
+  padding: 0 8px 40px 8px;
+}
+
+/* ─── CSS Grid avec dense pour minimiser les trous ─ */
+.masonry-css-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
+  grid-auto-rows: auto;
+  gap: 12px;
+  align-items: start;
+  grid-auto-flow: dense;
+}
+
+/* ─── Sortable items ─────────────────────────────── */
+.masonry-sortable-item {
+  break-inside: avoid;
+  box-sizing: border-box;
+  will-change: transform;
+  transition: opacity 0.15s ease-out;
+}
+
+/* Taille des notes : small=1 colonne, medium=2 colonnes, large=3 colonnes */
+.masonry-sortable-item[data-size="medium"] {
+  grid-column: span 2;
+}
+
+.masonry-sortable-item[data-size="large"] {
+  grid-column: span 3;
+}
+
+/* ─── Note card base ─────────────────────────────── */
+.note-card {
+  width: 100% !important;
+  min-width: 0;
+  box-sizing: border-box;
+}
+
+/* ─── Drag overlay ───────────────────────────────── */
+.masonry-drag-overlay {
+  cursor: grabbing;
+  box-shadow: 0 20px 40px rgba(0, 0, 0, 0.25), 0 8px 16px rgba(0, 0, 0, 0.15);
+  border-radius: 12px;
+  opacity: 0.95;
+  pointer-events: none;
+}
+
+/* ─── Mobile (< 480px) : 1 colonne ──────────────── */
+@media (max-width: 479px) {
+  .masonry-css-grid {
+    grid-template-columns: 1fr;
+    gap: 10px;
+  }
+  
+  /* Sur mobile tout est 1 colonne */
+  .masonry-sortable-item[data-size="medium"],
+  .masonry-sortable-item[data-size="large"] {
+    grid-column: span 1;
+  }
+  
+  .masonry-container {
+    padding: 0 4px 16px 4px;
+  }
+}
+
+/* ─── Small tablet (480–767px) : 2 colonnes ─────── */
+@media (min-width: 480px) and (max-width: 767px) {
+  .masonry-css-grid {
+    grid-template-columns: repeat(2, 1fr);
+    gap: 10px;
+  }
+  
+  /* Sur 2 colonnes, large prend tout */
+  .masonry-sortable-item[data-size="large"] {
+    grid-column: span 2;
+  }
+  
+  .masonry-container {
+    padding: 0 8px 20px 8px;
+  }
+}
+
+/* ─── Tablet (768–1023px) ────────────────────────── */
+@media (min-width: 768px) and (max-width: 1023px) {
+  .masonry-css-grid {
+    grid-template-columns: repeat(auto-fill, minmax(240px, 1fr));
+    gap: 12px;
+  }
+}
+
+/* ─── Desktop (1024–1279px) ─────────────────────── */
+@media (min-width: 1024px) and (max-width: 1279px) {
+  .masonry-css-grid {
+    grid-template-columns: repeat(auto-fill, minmax(230px, 1fr));
+    gap: 12px;
+  }
+}
+
+/* ─── Large Desktop (1280px+) ───────────────────── */
+@media (min-width: 1280px) {
+  .masonry-css-grid {
+    grid-template-columns: repeat(auto-fill, minmax(240px, 1fr));
+    gap: 14px;
+  }
+  .masonry-container {
+    max-width: 1600px;
+    margin: 0 auto;
+    padding: 0 12px 32px 12px;
+  }
+}
+
+/* ─── Print ──────────────────────────────────────── */
+@media print {
+  .masonry-sortable-item {
+    break-inside: avoid;
+    page-break-inside: avoid;
+  }
+}
+
+/* ─── Reduced motion ─────────────────────────────── */
+@media (prefers-reduced-motion: reduce) {
+  .masonry-sortable-item {
+    transition: none;
+  }
+}

memento-note/.backup-keep/masonry-grid.tsx

@@ -0,0 +1,292 @@
+'use client'
+
+import { useState, useEffect, useCallback, memo, useMemo, useRef } from 'react';
+import {
+  DndContext,
+  DragEndEvent,
+  DragOverlay,
+  DragStartEvent,
+  PointerSensor,
+  TouchSensor,
+  closestCenter,
+  useSensor,
+  useSensors,
+} from '@dnd-kit/core';
+import {
+  SortableContext,
+  arrayMove,
+  rectSortingStrategy,
+  useSortable,
+} from '@dnd-kit/sortable';
+import { CSS } from '@dnd-kit/utilities';
+import { Note } from '@/lib/types';
+import { NoteCard } from './note-card';
+import { updateFullOrderWithoutRevalidation } from '@/app/actions/notes';
+import { useNotebookDrag } from '@/context/notebook-drag-context';
+import { useLanguage } from '@/lib/i18n';
+import dynamic from 'next/dynamic';
+import './masonry-grid.css';
+
+// Lazy-load NoteEditor — uniquement chargé au clic
+const NoteEditor = dynamic(
+  () => import('./note-editor').then(m => ({ default: m.NoteEditor })),
+  { ssr: false }
+);
+
+interface MasonryGridProps {
+  notes: Note[];
+  onEdit?: (note: Note, readOnly?: boolean) => void;
+  onSizeChange?: (noteId: string, size: 'small' | 'medium' | 'large') => void;
+}
+
+// ─────────────────────────────────────────────
+// Sortable Note Item
+// ─────────────────────────────────────────────
+interface SortableNoteProps {
+  note: Note;
+  onEdit: (note: Note, readOnly?: boolean) => void;
+  onSizeChange: (noteId: string, newSize: 'small' | 'medium' | 'large') => void;
+  onDragStartNote?: (noteId: string) => void;
+  onDragEndNote?: () => void;
+  isDragging?: boolean;
+  isOverlay?: boolean;
+}
+
+const SortableNoteItem = memo(function SortableNoteItem({
+  note,
+  onEdit,
+  onSizeChange,
+  onDragStartNote,
+  onDragEndNote,
+  isDragging,
+  isOverlay,
+}: SortableNoteProps) {
+  const {
+    attributes,
+    listeners,
+    setNodeRef,
+    transform,
+    transition,
+    isDragging: isSortableDragging,
+  } = useSortable({ id: note.id });
+
+  const style: React.CSSProperties = {
+    transform: CSS.Transform.toString(transform),
+    transition,
+    opacity: isSortableDragging && !isOverlay ? 0.3 : 1,
+  };
+
+  return (
+    <div
+      ref={setNodeRef}
+      style={style}
+      {...attributes}
+      {...listeners}
+      className="masonry-sortable-item"
+      data-id={note.id}
+      data-size={note.size}
+    >
+      <NoteCard
+        note={note}
+        onEdit={onEdit}
+        onDragStart={onDragStartNote}
+        onDragEnd={onDragEndNote}
+        isDragging={isDragging}
+        onSizeChange={(newSize) => onSizeChange(note.id, newSize)}
+      />
+    </div>
+  );
+})
+
+// ─────────────────────────────────────────────
+// Sortable Grid Section (pinned or others)
+// ─────────────────────────────────────────────
+interface SortableGridSectionProps {
+  notes: Note[];
+  onEdit: (note: Note, readOnly?: boolean) => void;
+  onSizeChange: (noteId: string, newSize: 'small' | 'medium' | 'large') => void;
+  draggedNoteId: string | null;
+  onDragStartNote: (noteId: string) => void;
+  onDragEndNote: () => void;
+}
+
+const SortableGridSection = memo(function SortableGridSection({
+  notes,
+  onEdit,
+  onSizeChange,
+  draggedNoteId,
+  onDragStartNote,
+  onDragEndNote,
+}: SortableGridSectionProps) {
+  const ids = useMemo(() => notes.map(n => n.id), [notes]);
+
+  return (
+    <SortableContext items={ids} strategy={rectSortingStrategy}>
+      <div className="masonry-css-grid">
+        {notes.map(note => (
+          <SortableNoteItem
+            key={note.id}
+            note={note}
+            onEdit={onEdit}
+            onSizeChange={onSizeChange}
+            onDragStartNote={onDragStartNote}
+            onDragEndNote={onDragEndNote}
+            isDragging={draggedNoteId === note.id}
+          />
+        ))}
+      </div>
+    </SortableContext>
+  );
+});
+
+// ─────────────────────────────────────────────
+// Main MasonryGrid component
+// ─────────────────────────────────────────────
+export function MasonryGrid({ notes, onEdit, onSizeChange }: MasonryGridProps) {
+  const { t } = useLanguage();
+  const [editingNote, setEditingNote] = useState<{ note: Note; readOnly?: boolean } | null>(null);
+  const { startDrag, endDrag, draggedNoteId } = useNotebookDrag();
+
+  // Local notes state for optimistic size/order updates
+  const [localNotes, setLocalNotes] = useState<Note[]>(notes);
+
+  useEffect(() => {
+    setLocalNotes(prev => {
+      const localSizeMap = new Map(prev.map(n => [n.id, n.size]))
+      return notes.map(n => ({ ...n, size: localSizeMap.get(n.id) ?? n.size }))
+    })
+  }, [notes]);
+
+  const pinnedNotes = useMemo(() => localNotes.filter(n => n.isPinned), [localNotes]);
+  const othersNotes = useMemo(() => localNotes.filter(n => !n.isPinned), [localNotes]);
+
+  const [activeId, setActiveId] = useState<string | null>(null);
+  const activeNote = useMemo(
+    () => localNotes.find(n => n.id === activeId) ?? null,
+    [localNotes, activeId]
+  );
+
+  const handleEdit = useCallback((note: Note, readOnly?: boolean) => {
+    if (onEdit) {
+      onEdit(note, readOnly);
+    } else {
+      setEditingNote({ note, readOnly });
+    }
+  }, [onEdit]);
+
+  const handleSizeChange = useCallback((noteId: string, newSize: 'small' | 'medium' | 'large') => {
+    setLocalNotes(prev => prev.map(n => n.id === noteId ? { ...n, size: newSize } : n));
+    onSizeChange?.(noteId, newSize);
+  }, [onSizeChange]);
+
+  // @dnd-kit sensors — pointer (desktop) + touch (mobile)
+  const sensors = useSensors(
+    useSensor(PointerSensor, {
+      activationConstraint: { distance: 8 }, // Évite les activations accidentelles
+    }),
+    useSensor(TouchSensor, {
+      activationConstraint: { delay: 200, tolerance: 8 }, // Long-press sur mobile
+    })
+  );
+
+  const localNotesRef = useRef<Note[]>(localNotes)
+  useEffect(() => {
+    localNotesRef.current = localNotes
+  }, [localNotes])
+
+  const handleDragStart = useCallback((event: DragStartEvent) => {
+    setActiveId(event.active.id as string);
+    startDrag(event.active.id as string);
+  }, [startDrag]);
+
+  const handleDragEnd = useCallback(async (event: DragEndEvent) => {
+    const { active, over } = event;
+    setActiveId(null);
+    endDrag();
+
+    if (!over || active.id === over.id) return;
+
+    const reordered = arrayMove(
+      localNotesRef.current,
+      localNotesRef.current.findIndex(n => n.id === active.id),
+      localNotesRef.current.findIndex(n => n.id === over.id),
+    );
+
+    if (reordered.length === 0) return;
+
+    setLocalNotes(reordered);
+    // Persist order outside of setState to avoid "setState in render" warning
+    const ids = reordered.map(n => n.id);
+    updateFullOrderWithoutRevalidation(ids).catch(err => {
+      console.error('Failed to persist order:', err);
+    });
+  }, [endDrag]);
+
+  return (
+    <DndContext
+      id="masonry-dnd"
+      sensors={sensors}
+      collisionDetection={closestCenter}
+      onDragStart={handleDragStart}
+      onDragEnd={handleDragEnd}
+    >
+      <div className="masonry-container">
+        {pinnedNotes.length > 0 && (
+          <div className="mb-8">
+            <h2 className="text-xs font-semibold text-gray-500 uppercase tracking-wide mb-3 px-2">
+              {t('notes.pinned')}
+            </h2>
+            <SortableGridSection
+              notes={pinnedNotes}
+              onEdit={handleEdit}
+              onSizeChange={handleSizeChange}
+              draggedNoteId={draggedNoteId}
+              onDragStartNote={startDrag}
+              onDragEndNote={endDrag}
+            />
+          </div>
+        )}
+
+        {othersNotes.length > 0 && (
+          <div>
+            {pinnedNotes.length > 0 && (
+              <h2 className="text-xs font-semibold text-gray-500 uppercase tracking-wide mb-3 px-2">
+                {t('notes.others')}
+              </h2>
+            )}
+            <SortableGridSection
+              notes={othersNotes}
+              onEdit={handleEdit}
+              onSizeChange={handleSizeChange}
+              draggedNoteId={draggedNoteId}
+              onDragStartNote={startDrag}
+              onDragEndNote={endDrag}
+            />
+          </div>
+        )}
+      </div>
+
+      {/* DragOverlay — montre une copie flottante pendant le drag */}
+      <DragOverlay>
+        {activeNote ? (
+          <div className="masonry-sortable-item masonry-drag-overlay" data-size={activeNote.size}>
+            <NoteCard
+              note={activeNote}
+              onEdit={handleEdit}
+              isDragging={true}
+              onSizeChange={(newSize) => handleSizeChange(activeNote.id, newSize)}
+            />
+          </div>
+        ) : null}
+      </DragOverlay>
+
+      {editingNote && (
+        <NoteEditor
+          note={editingNote.note}
+          readOnly={editingNote.readOnly}
+          onClose={() => setEditingNote(null)}
+        />
+      )}
+    </DndContext>
+  );
+}

memento-note/.backup-keep/note-card.tsx

@@ -0,0 +1,677 @@
+'use client'
+
+import { Note, NOTE_COLORS, NoteColor } from '@/lib/types'
+import { Card } from '@/components/ui/card'
+import { Button } from '@/components/ui/button'
+import { Badge } from '@/components/ui/badge'
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from '@/components/ui/dropdown-menu'
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from '@/components/ui/alert-dialog'
+import { Pin, Bell, GripVertical, X, Link2, FolderOpen, StickyNote, LucideIcon, Folder, Briefcase, FileText, Zap, BarChart3, Globe, Sparkles, Book, Heart, Crown, Music, Building2, LogOut, Trash2 } from 'lucide-react'
+import { useState, useEffect, useTransition, useOptimistic, memo } from 'react'
+import { useSession } from 'next-auth/react'
+import { useRouter, useSearchParams } from 'next/navigation'
+import { deleteNote, toggleArchive, togglePin, updateColor, updateNote, updateSize, getNoteAllUsers, leaveSharedNote, removeFusedBadge } from '@/app/actions/notes'
+import { cn } from '@/lib/utils'
+import { formatDistanceToNow, Locale } from 'date-fns'
+import { enUS } from 'date-fns/locale/en-US'
+import { fr } from 'date-fns/locale/fr'
+import { es } from 'date-fns/locale/es'
+import { de } from 'date-fns/locale/de'
+import { faIR } from 'date-fns/locale/fa-IR'
+import { it } from 'date-fns/locale/it'
+import { pt } from 'date-fns/locale/pt'
+import { ru } from 'date-fns/locale/ru'
+import { zhCN } from 'date-fns/locale/zh-CN'
+import { ja } from 'date-fns/locale/ja'
+import { ko } from 'date-fns/locale/ko'
+import { ar } from 'date-fns/locale/ar'
+import { hi } from 'date-fns/locale/hi'
+import { nl } from 'date-fns/locale/nl'
+import { pl } from 'date-fns/locale/pl'
+import { MarkdownContent } from './markdown-content'
+import { LabelBadge } from './label-badge'
+import { NoteImages } from './note-images'
+import { NoteChecklist } from './note-checklist'
+import { NoteActions } from './note-actions'
+import { CollaboratorDialog } from './collaborator-dialog'
+import { CollaboratorAvatars } from './collaborator-avatars'
+import { ConnectionsBadge } from './connections-badge'
+import { ConnectionsOverlay } from './connections-overlay'
+import { ComparisonModal } from './comparison-modal'
+import { useConnectionsCompare } from '@/hooks/use-connections-compare'
+import { useLabels } from '@/context/LabelContext'
+import { useLanguage } from '@/lib/i18n'
+import { useNotebooks } from '@/context/notebooks-context'
+import { toast } from 'sonner'
+
+// Mapping of supported languages to date-fns locales
+const localeMap: Record<string, Locale> = {
+  en: enUS,
+  fr: fr,
+  es: es,
+  de: de,
+  fa: faIR,
+  it: it,
+  pt: pt,
+  ru: ru,
+  zh: zhCN,
+  ja: ja,
+  ko: ko,
+  ar: ar,
+  hi: hi,
+  nl: nl,
+  pl: pl,
+}
+
+function getDateLocale(language: string): Locale {
+  return localeMap[language] || enUS
+}
+
+// Map icon names to lucide-react components
+const ICON_MAP: Record<string, LucideIcon> = {
+  'folder': Folder,
+  'briefcase': Briefcase,
+  'document': FileText,
+  'lightning': Zap,
+  'chart': BarChart3,
+  'globe': Globe,
+  'sparkle': Sparkles,
+  'book': Book,
+  'heart': Heart,
+  'crown': Crown,
+  'music': Music,
+  'building': Building2,
+}
+
+// Function to get icon component by name
+function getNotebookIcon(iconName: string): LucideIcon {
+  const IconComponent = ICON_MAP[iconName] || Folder
+  return IconComponent
+}
+
+interface NoteCardProps {
+  note: Note
+  onEdit?: (note: Note, readOnly?: boolean) => void
+  isDragging?: boolean
+  isDragOver?: boolean
+  onDragStart?: (noteId: string) => void
+  onDragEnd?: () => void
+  onResize?: () => void
+  onSizeChange?: (newSize: 'small' | 'medium' | 'large') => void
+}
+
+// Helper function to get initials from name
+function getInitials(name: string): string {
+  if (!name) return '??'
+  const trimmedName = name.trim()
+  const parts = trimmedName.split(' ')
+  if (parts.length === 1) {
+    return trimmedName.substring(0, 2).toUpperCase()
+  }
+  return (parts[0][0] + parts[parts.length - 1][0]).toUpperCase()
+}
+
+// Helper function to get avatar color based on name hash
+function getAvatarColor(name: string): string {
+  const colors = [
+    'bg-primary',
+    'bg-purple-500',
+    'bg-green-500',
+    'bg-orange-500',
+    'bg-pink-500',
+    'bg-teal-500',
+    'bg-red-500',
+    'bg-indigo-500',
+  ]
+
+  const hash = name.split('').reduce((acc, char) => acc + char.charCodeAt(0), 0)
+  return colors[hash % colors.length]
+}
+
+export const NoteCard = memo(function NoteCard({
+  note,
+  onEdit,
+  onDragStart,
+  onDragEnd,
+  isDragging,
+  onResize,
+  onSizeChange
+}: NoteCardProps) {
+  const router = useRouter()
+  const searchParams = useSearchParams()
+  const { refreshLabels } = useLabels()
+  const { data: session } = useSession()
+  const { t, language } = useLanguage()
+  const { notebooks, moveNoteToNotebookOptimistic } = useNotebooks()
+  const [, startTransition] = useTransition()
+  const [isDeleting, setIsDeleting] = useState(false)
+  const [showDeleteDialog, setShowDeleteDialog] = useState(false)
+  const [showCollaboratorDialog, setShowCollaboratorDialog] = useState(false)
+  const [collaborators, setCollaborators] = useState<any[]>([])
+  const [owner, setOwner] = useState<any>(null)
+  const [showConnectionsOverlay, setShowConnectionsOverlay] = useState(false)
+  const [comparisonNotes, setComparisonNotes] = useState<string[] | null>(null)
+  const [showNotebookMenu, setShowNotebookMenu] = useState(false)
+
+  // Move note to a notebook
+  const handleMoveToNotebook = async (notebookId: string | null) => {
+    await moveNoteToNotebookOptimistic(note.id, notebookId)
+    setShowNotebookMenu(false)
+    // No need for router.refresh() - triggerRefresh() is already called in moveNoteToNotebookOptimistic
+  }
+
+  // Optimistic UI state for instant feedback
+  const [optimisticNote, addOptimisticNote] = useOptimistic(
+    note,
+    (state, newProps: Partial<Note>) => ({ ...state, ...newProps })
+  )
+
+  // Local color state so color persists after transition ends
+  const [localColor, setLocalColor] = useState(note.color)
+
+  const colorClasses = NOTE_COLORS[(localColor || optimisticNote.color) as NoteColor] || NOTE_COLORS.default
+
+  // Check if this note is currently open in the editor
+  const isNoteOpenInEditor = searchParams.get('note') === note.id
+
+  // Only fetch comparison notes when we have IDs to compare
+  const { notes: comparisonNotesData, isLoading: isLoadingComparison } = useConnectionsCompare(
+    comparisonNotes && comparisonNotes.length > 0 ? comparisonNotes : null
+  )
+
+  const currentUserId = session?.user?.id
+  const canManageCollaborators = currentUserId && note.userId && currentUserId === note.userId
+  const isSharedNote = currentUserId && note.userId && currentUserId !== note.userId
+  const isOwner = currentUserId && note.userId && currentUserId === note.userId
+
+  // Load collaborators only for shared notes (not owned by current user)
+  useEffect(() => {
+    // Skip API call for notes owned by current user — no need to fetch collaborators
+    if (!isSharedNote) {
+      // For own notes, set owner to current user
+      if (currentUserId && session?.user) {
+        setOwner({
+          id: currentUserId,
+          name: session.user.name,
+          email: session.user.email,
+          image: session.user.image,
+        })
+      }
+      return
+    }
+
+    let isMounted = true
+
+    const loadCollaborators = async () => {
+      if (note.userId && isMounted) {
+        try {
+          const users = await getNoteAllUsers(note.id)
+          if (isMounted) {
+            setCollaborators(users)
+            if (users.length > 0) {
+              setOwner(users[0])
+            }
+          }
+        } catch (error) {
+          console.error('Failed to load collaborators:', error)
+          if (isMounted) {
+            setCollaborators([])
+          }
+        }
+      }
+    }
+
+    loadCollaborators()
+
+    return () => {
+      isMounted = false
+    }
+  }, [note.id, note.userId, isSharedNote, currentUserId, session?.user])
+
+  const handleDelete = async () => {
+    setIsDeleting(true)
+    try {
+      await deleteNote(note.id)
+      await refreshLabels()
+    } catch (error) {
+      console.error('Failed to delete note:', error)
+      setIsDeleting(false)
+    }
+  }
+
+  const handleTogglePin = async () => {
+    startTransition(async () => {
+      addOptimisticNote({ isPinned: !note.isPinned })
+      await togglePin(note.id, !note.isPinned)
+
+      if (!note.isPinned) {
+        toast.success(t('notes.pinned') || 'Note pinned')
+      } else {
+        toast.info(t('notes.unpinned') || 'Note unpinned')
+      }
+    })
+  }
+
+  const handleToggleArchive = async () => {
+    startTransition(async () => {
+      addOptimisticNote({ isArchived: !note.isArchived })
+      await toggleArchive(note.id, !note.isArchived)
+    })
+  }
+
+  const handleColorChange = async (color: string) => {
+    setLocalColor(color) // instant visual update, survives transition
+    startTransition(async () => {
+      addOptimisticNote({ color })
+      await updateNote(note.id, { color }, { skipRevalidation: false })
+    })
+  }
+
+  const handleSizeChange = (size: 'small' | 'medium' | 'large') => {
+    // Notifier le parent immédiatement (hors transition) — c'est lui
+    // qui détient la source de vérité via localNotes
+    onSizeChange?.(size)
+    onResize?.()
+
+    // Persister en arrière-plan
+    updateSize(note.id, size).catch(err =>
+      console.error('Failed to update note size:', err)
+    )
+  }
+
+  const handleCheckItem = async (checkItemId: string) => {
+    if (note.type === 'checklist' && Array.isArray(note.checkItems)) {
+      const updatedItems = note.checkItems.map(item =>
+        item.id === checkItemId ? { ...item, checked: !item.checked } : item
+      )
+      startTransition(async () => {
+        addOptimisticNote({ checkItems: updatedItems })
+        await updateNote(note.id, { checkItems: updatedItems })
+        // No router.refresh() — optimistic update is sufficient and avoids grid rebuild
+      })
+    }
+  }
+
+  const handleLeaveShare = async () => {
+    if (confirm(t('notes.confirmLeaveShare'))) {
+      try {
+        await leaveSharedNote(note.id)
+        setIsDeleting(true) // Hide the note from view
+      } catch (error) {
+        console.error('Failed to leave share:', error)
+      }
+    }
+  }
+
+  const handleRemoveFusedBadge = async (e: React.MouseEvent) => {
+    e.stopPropagation() // Prevent opening the note editor
+    startTransition(async () => {
+      addOptimisticNote({ autoGenerated: null })
+      await removeFusedBadge(note.id)
+      // No router.refresh() — optimistic update is sufficient and avoids grid rebuild
+    })
+  }
+
+  if (isDeleting) return null
+
+  const getMinHeight = (size?: string) => {
+    switch (size) {
+      case 'medium': return '350px'
+      case 'large': return '500px'
+      default: return '150px' // small
+    }
+  }
+
+
+
+  return (
+    <Card
+      data-testid="note-card"
+      data-draggable="true"
+      data-note-id={note.id}
+      data-size={optimisticNote.size}
+      style={{ minHeight: getMinHeight(optimisticNote.size) }}
+      draggable={true}
+      onDragStart={(e) => {
+        e.dataTransfer.setData('text/plain', note.id)
+        e.dataTransfer.effectAllowed = 'move'
+        e.dataTransfer.setData('text/html', '') // Prevent ghost image in some browsers
+        onDragStart?.(note.id)
+      }}
+      onDragEnd={() => onDragEnd?.()}
+      className={cn(
+        'note-card group relative rounded-2xl overflow-hidden p-5 border shadow-sm',
+        'transition-all duration-200 ease-out',
+        'hover:shadow-xl hover:-translate-y-1',
+        colorClasses.bg,
+        colorClasses.card,
+        colorClasses.hover,
+        colorClasses.hover,
+        isDragging && 'shadow-2xl' // Removed opacity, scale, and rotation for clean drag
+      )}
+      onClick={(e) => {
+        // Only trigger edit if not clicking on buttons
+        const target = e.target as HTMLElement
+        if (!target.closest('button') && !target.closest('[role="checkbox"]') && !target.closest('.muuri-drag-handle') && !target.closest('.drag-handle')) {
+          // For shared notes, pass readOnly flag
+          onEdit?.(note, !!isSharedNote) // Pass second parameter as readOnly flag (convert to boolean)
+        }
+      }}
+    >
+      {/* Drag Handle - Only visible on mobile/touch devices */}
+      <div
+        className="muuri-drag-handle absolute top-2 left-2 z-20 cursor-grab active:cursor-grabbing p-2 md:hidden"
+        aria-label={t('notes.dragToReorder') || 'Drag to reorder'}
+        title={t('notes.dragToReorder') || 'Drag to reorder'}
+      >
+        <GripVertical className="h-5 w-5 text-muted-foreground" />
+      </div>
+
+      {/* Move to Notebook Dropdown Menu */}
+      <div onClick={(e) => e.stopPropagation()} className="absolute top-2 right-2 z-20">
+        <DropdownMenu open={showNotebookMenu} onOpenChange={setShowNotebookMenu}>
+          <DropdownMenuTrigger asChild>
+            <Button
+              variant="ghost"
+              size="sm"
+              className="h-8 w-8 p-0 bg-primary/10 dark:bg-primary/20 hover:bg-primary/20 dark:hover:bg-primary/30 text-primary dark:text-primary-foreground"
+              title={t('notebookSuggestion.moveToNotebook')}
+            >
+              <FolderOpen className="h-4 w-4" />
+            </Button>
+          </DropdownMenuTrigger>
+          <DropdownMenuContent align="end" className="w-56">
+            <div className="px-2 py-1.5 text-xs font-semibold text-muted-foreground">
+              {t('notebookSuggestion.moveToNotebook')}
+            </div>
+            <DropdownMenuItem onClick={() => handleMoveToNotebook(null)}>
+              <StickyNote className="h-4 w-4 mr-2" />
+              {t('notebookSuggestion.generalNotes')}
+            </DropdownMenuItem>
+            {notebooks.map((notebook: any) => {
+              const NotebookIcon = getNotebookIcon(notebook.icon || 'folder')
+              return (
+                <DropdownMenuItem
+                  key={notebook.id}
+                  onClick={() => handleMoveToNotebook(notebook.id)}
+                >
+                  <NotebookIcon className="h-4 w-4 mr-2" />
+                  {notebook.name}
+                </DropdownMenuItem>
+              )
+            })}
+          </DropdownMenuContent>
+        </DropdownMenu>
+      </div>
+
+      {/* Pin Button - Visible on hover or if pinned */}
+      <Button
+        variant="ghost"
+        size="sm"
+        data-testid="pin-button"
+        className={cn(
+          "absolute top-2 right-12 z-20 min-h-[44px] min-w-[44px] h-8 w-8 p-0 rounded-md transition-opacity",
+          optimisticNote.isPinned ? "opacity-100" : "opacity-0 group-hover:opacity-100"
+        )}
+        onClick={(e) => {
+          e.stopPropagation()
+          handleTogglePin()
+        }}
+      >
+        <Pin
+          className={cn("h-4 w-4", optimisticNote.isPinned ? "fill-current text-primary" : "text-muted-foreground")}
+        />
+      </Button>
+
+
+
+      {/* Reminder Icon - Move slightly if pin button is there */}
+      {note.reminder && new Date(note.reminder) > new Date() && (
+        <Bell
+          className="absolute top-3 right-10 h-4 w-4 text-primary"
+        />
+      )}
+
+      {/* Memory Echo Badges - Fusion + Connections (BEFORE Title) */}
+      <div className="flex flex-wrap gap-1 mb-2">
+        {/* Fusion Badge with remove button */}
+        {note.autoGenerated && (
+          <div className="px-1.5 py-0.5 rounded text-[10px] font-medium bg-purple-100 dark:bg-purple-900/30 text-purple-700 dark:text-purple-400 border border-purple-200 dark:border-purple-800 flex items-center gap-1 group/badge relative">
+            <Link2 className="h-2.5 w-2.5" />
+            {t('memoryEcho.fused')}
+            <button
+              onClick={handleRemoveFusedBadge}
+              className="ml-1 opacity-0 group-hover/badge:opacity-100 hover:opacity-100 transition-opacity"
+              title={t('notes.remove') || 'Remove'}
+            >
+              <Trash2 className="h-2.5 w-2.5" />
+            </button>
+          </div>
+        )}
+
+        {/* Connections Badge */}
+        <ConnectionsBadge
+          noteId={note.id}
+          onClick={() => {
+            // Only open overlay if note is NOT open in editor
+            // (to avoid having 2 Dialogs with 2 close buttons)
+            if (!isNoteOpenInEditor) {
+              setShowConnectionsOverlay(true)
+            }
+          }}
+        />
+      </div>
+
+      {/* Title */}
+      {optimisticNote.title && (
+        <h3 className="text-base font-medium mb-2 pr-10 text-foreground">
+          {optimisticNote.title}
+        </h3>
+      )}
+
+      {/* Search Match Type Badge */}
+      {optimisticNote.matchType && (
+        <Badge
+          variant={optimisticNote.matchType === 'exact' ? 'default' : 'secondary'}
+          className={cn(
+            'mb-2 text-xs',
+            optimisticNote.matchType === 'exact'
+              ? 'bg-green-100 text-green-800 border-green-200 dark:bg-green-900/30 dark:text-green-300 dark:border-green-800'
+              : 'bg-primary/10 text-primary border-primary/20 dark:bg-primary/20 dark:text-primary-foreground'
+          )}
+        >
+          {t(`semanticSearch.${optimisticNote.matchType === 'exact' ? 'exactMatch' : 'related'}`)}
+        </Badge>
+      )}
+
+      {/* Shared badge */}
+      {isSharedNote && owner && (
+        <div className="flex items-center justify-between mb-2">
+          <span className="text-xs text-primary dark:text-primary-foreground font-medium">
+            {t('notes.sharedBy')} {owner.name || owner.email}
+          </span>
+          <Button
+            variant="ghost"
+            size="sm"
+            className="h-6 px-2 text-xs text-gray-500 hover:text-red-600 dark:hover:text-red-400"
+            onClick={(e) => {
+              e.stopPropagation()
+              handleLeaveShare()
+            }}
+          >
+            <LogOut className="h-3 w-3 mr-1" />
+            {t('notes.leaveShare')}
+          </Button>
+        </div>
+      )}
+
+      {/* Images Component */}
+      <NoteImages images={optimisticNote.images || []} title={optimisticNote.title} />
+
+      {/* Link Previews */}
+      {Array.isArray(optimisticNote.links) && optimisticNote.links.length > 0 && (
+        <div className="flex flex-col gap-2 mb-2">
+          {optimisticNote.links.map((link, idx) => (
+            <a
+              key={idx}
+              href={link.url}
+              target="_blank"
+              rel="noopener noreferrer"
+              className="block border rounded-md overflow-hidden bg-white/50 dark:bg-black/20 hover:bg-white/80 dark:hover:bg-black/40 transition-colors"
+              onClick={(e) => e.stopPropagation()}
+            >
+              {link.imageUrl && (
+                <div className="h-24 bg-cover bg-center" style={{ backgroundImage: `url(${link.imageUrl})` }} />
+              )}
+              <div className="p-2">
+                <h4 className="font-medium text-xs truncate text-gray-900 dark:text-gray-100">{link.title || link.url}</h4>
+                {link.description && <p className="text-xs text-gray-500 dark:text-gray-400 line-clamp-2 mt-0.5">{link.description}</p>}
+                <span className="text-[10px] text-primary mt-1 block">
+                  {new URL(link.url).hostname}
+                </span>
+              </div>
+            </a>
+          ))}
+        </div>
+      )}
+
+      {/* Content */}
+      {optimisticNote.type === 'text' ? (
+        <div className="text-sm text-foreground line-clamp-10">
+          <MarkdownContent content={optimisticNote.content} />
+        </div>
+      ) : (
+        <NoteChecklist
+          items={optimisticNote.checkItems || []}
+          onToggleItem={handleCheckItem}
+        />
+      )}
+
+      {/* Labels - using shared LabelBadge component */}
+      {optimisticNote.notebookId && Array.isArray(optimisticNote.labels) && optimisticNote.labels.length > 0 && (
+        <div className="flex flex-wrap gap-1 mt-3">
+          {optimisticNote.labels.map((label) => (
+            <LabelBadge key={label} label={label} />
+          ))}
+        </div>
+      )}
+
+      {/* Footer with Date only */}
+      <div className="mt-3 flex items-center justify-end">
+        {/* Creation Date */}
+        <div className="text-xs text-muted-foreground">
+          {formatDistanceToNow(new Date(note.createdAt), { addSuffix: true, locale: getDateLocale(language) })}
+        </div>
+      </div>
+
+      {/* Owner Avatar - Aligned with action buttons at bottom */}
+      {owner && (
+        <div
+          className={cn(
+            "absolute bottom-2 left-2 z-20",
+            "w-6 h-6 rounded-full text-white text-[10px] font-semibold flex items-center justify-center",
+            getAvatarColor(owner.name || owner.email || 'Unknown')
+          )}
+          title={owner.name || owner.email || 'Unknown'}
+        >
+          {getInitials(owner.name || owner.email || '??')}
+        </div>
+      )}
+
+      {/* Action Bar Component - Always show for now to fix regression */}
+      {true && (
+        <NoteActions
+          isPinned={optimisticNote.isPinned}
+          isArchived={optimisticNote.isArchived}
+          currentColor={optimisticNote.color}
+          currentSize={optimisticNote.size as 'small' | 'medium' | 'large'}
+          onTogglePin={handleTogglePin}
+          onToggleArchive={handleToggleArchive}
+          onColorChange={handleColorChange}
+          onSizeChange={handleSizeChange}
+          onDelete={() => setShowDeleteDialog(true)}
+          onShareCollaborators={() => setShowCollaboratorDialog(true)}
+          className="absolute bottom-0 left-0 right-0 p-2 opacity-100 md:opacity-0 group-hover:opacity-100 transition-opacity"
+        />
+      )}
+
+      {/* Collaborator Dialog */}
+      {currentUserId && note.userId && (
+        <div onClick={(e) => e.stopPropagation()}>
+          <CollaboratorDialog
+            open={showCollaboratorDialog}
+            onOpenChange={setShowCollaboratorDialog}
+            noteId={note.id}
+            noteOwnerId={note.userId}
+            currentUserId={currentUserId}
+          />
+        </div>
+      )}
+
+      {/* Connections Overlay */}
+      <div onClick={(e) => e.stopPropagation()}>
+        <ConnectionsOverlay
+          isOpen={showConnectionsOverlay}
+          onClose={() => setShowConnectionsOverlay(false)}
+          noteId={note.id}
+          onOpenNote={(noteId) => {
+            // Find the note and open it
+            onEdit?.(note, false)
+          }}
+          onCompareNotes={(noteIds) => {
+            setComparisonNotes(noteIds)
+          }}
+        />
+      </div>
+
+      {/* Comparison Modal */}
+      {comparisonNotes && comparisonNotesData.length > 0 && (
+        <div onClick={(e) => e.stopPropagation()}>
+          <ComparisonModal
+            isOpen={!!comparisonNotes}
+            onClose={() => setComparisonNotes(null)}
+            notes={comparisonNotesData}
+            onOpenNote={(noteId) => {
+              const foundNote = comparisonNotesData.find(n => n.id === noteId)
+              if (foundNote) {
+                onEdit?.(foundNote, false)
+              }
+            }}
+          />
+        </div>
+      )}
+
+      {/* Delete Confirmation Dialog */}
+      <AlertDialog open={showDeleteDialog} onOpenChange={setShowDeleteDialog}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>{t('notes.confirmDeleteTitle') || t('notes.delete')}</AlertDialogTitle>
+            <AlertDialogDescription>
+              {t('notes.confirmDelete') || 'Are you sure you want to delete this note?'}
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel>{t('common.cancel') || 'Cancel'}</AlertDialogCancel>
+            <AlertDialogAction variant="destructive" onClick={handleDelete}>
+              {t('notes.delete') || 'Delete'}
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </Card>
+  )
+})

memento-note/.backup-keep/notes-main-section.tsx

@@ -0,0 +1,44 @@
+'use client'
+
+import dynamic from 'next/dynamic'
+import { Note } from '@/lib/types'
+import { NotesTabsView } from '@/components/notes-tabs-view'
+
+const MasonryGridLazy = dynamic(
+  () => import('@/components/masonry-grid').then((m) => m.MasonryGrid),
+  {
+    ssr: false,
+    loading: () => (
+      <div
+        className="min-h-[200px] rounded-xl border border-dashed border-muted-foreground/20 bg-muted/30 animate-pulse"
+        aria-hidden
+      />
+    ),
+  }
+)
+
+export type NotesViewMode = 'masonry' | 'tabs'
+
+interface NotesMainSectionProps {
+  notes: Note[]
+  viewMode: NotesViewMode
+  onEdit?: (note: Note, readOnly?: boolean) => void
+  onSizeChange?: (noteId: string, size: 'small' | 'medium' | 'large') => void
+  currentNotebookId?: string | null
+}
+
+export function NotesMainSection({ notes, viewMode, onEdit, onSizeChange, currentNotebookId }: NotesMainSectionProps) {
+  if (viewMode === 'tabs') {
+    return (
+      <div className="flex min-h-0 flex-1 flex-col" data-testid="notes-grid-tabs-wrap">
+        <NotesTabsView notes={notes} onEdit={onEdit} currentNotebookId={currentNotebookId} />
+      </div>
+    )
+  }
+
+  return (
+    <div data-testid="notes-grid">
+      <MasonryGridLazy notes={notes} onEdit={onEdit} onSizeChange={onSizeChange} />
+    </div>
+  )
+}

memento-note/.dockerignore

@@ -0,0 +1,53 @@
+# Dependencies
+node_modules
+npm-debug.log
+yarn-error.log
+
+# Next.js
+.next
+out
+build
+dist
+
+# Production
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Development files
+.git
+.gitignore
+README.md
+.eslintrc.json
+.prettierrc*
+
+# IDE
+.vscode
+.idea
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Testing
+coverage
+.nyc_output
+playwright-report
+test-results
+
+# Misc
+.turbo
+*.log
+
+# BMAD output (not needed in container)
+_bmad-output
+
+# Docker files
+Dockerfile
+.dockerignore
+docker-compose.yml
+deploy.sh

memento-note/.gitignore

@@ -0,0 +1,47 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files (can opt-in for committing if needed)
+.env*
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
+
+/lib/generated/prisma
+
+# generated
+/prisma/client-generated
+/_backup

memento-note/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "memento": {
+      "type": "http",
+      "url": "http://localhost:4242/mcp"
+    }
+  }
+}

memento-note/Dockerfile

@@ -0,0 +1,64 @@
+# Multi-stage build for Next.js 16 with Webpack + Prisma
+# Using Debian 11 (bullseye) for native OpenSSL 1.1.x support
+
+FROM node:22-bullseye-slim AS base
+
+FROM base AS deps
+WORKDIR /app
+
+# Install OpenSSL (1.1.x native in Debian 11)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    openssl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install dependencies
+COPY package.json package-lock.json* ./
+RUN npm install --legacy-peer-deps
+
+FROM base AS builder
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+
+# Copy Prisma schema and generate client BEFORE Next.js build
+COPY prisma ./prisma
+RUN npx prisma generate
+
+# Build Next.js with Webpack
+ENV NEXT_TELEMETRY_DISABLED=1
+RUN npm run build
+
+FROM base AS runner
+WORKDIR /app
+
+ENV NODE_ENV=production
+ENV NEXT_TELEMETRY_DISABLED=1
+
+RUN addgroup --system --gid 1001 nodejs
+RUN adduser --system --uid 1001 nextjs
+
+COPY --from=builder /app/public ./public
+COPY --from=builder /app/package.json ./package.json
+COPY --from=builder /app/package-lock.json ./package-lock.json
+
+RUN mkdir .next
+RUN chown nextjs:nodejs .next
+
+# Copy Next.js standalone output
+COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
+COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static
+
+# Copy Prisma schema, generated client, and Query Engine binaries
+COPY --from=builder /app/prisma ./prisma
+RUN chown -R nextjs:nodejs /app/prisma
+COPY --from=builder --chown=nextjs:nodejs /app/node_modules/.prisma ./node_modules/.prisma
+COPY --from=builder --chown=nextjs:nodejs /app/node_modules ./node_modules
+
+USER nextjs
+
+EXPOSE 3000
+
+ENV PORT=3000
+ENV HOSTNAME="0.0.0.0"
+
+CMD ["node", "server.js"]

memento-note/README.md

@@ -0,0 +1,69 @@
+# Keep Notes ✨
+
+Keep Notes est une application avancée de prise de notes hybride, combinant la fluidité d'un outil local moderne avec la puissance de l'Intelligence Artificielle. Conçue pour offrir des performances maximales, elle utilise les dernières avancées de l'écosystème React et Next.js.
+
+## 🚀 Fonctionnalités
+
+- **Notes & Carnets** : Organisez vos idées rapidement avec des dossiers, codes couleurs, et épinglage.
+- **Support Markdown & Rendu Riche** : Éditez ou affichez vos notes instantanément.
+- **Disposition Masonry** : Grille CSS ultra-rapide (0 JavaScript) avec drag & drop fluide via `@dnd-kit`.
+- **Intégration de l'Intelligence Artificielle** :
+  - **Memory Echo** : Suggestion automatique et connexions entre notes similaires (RAG / Embeddings).
+  - **Auto-Tagging** : Création automatique d'étiquettes pertinentes.
+  - **Organisation par lots** (Batch Organization) : Tri automatique des notes en vrac.
+  - **Amélioration textuelle** : Reformulation, synthèse, ou traduction propulsés par l'IA.
+- **Haute Performance (RSC & Turbopack)** : Rendu Server Components natif pour une hydratation sans délai et développement accéléré via Turbopack.
+
+## 📄 Licence et Droits d'Auteur
+
+### **Licence Utilisateur Final (Version actuelle - Personnelle & Non-Commerciale)**
+Ce code source est fourni **strictement pour un usage personnel et éducatif**.
+- **Utilisation non-commerciale uniquement** : Il est interdit d'utiliser ce projet (ou tout code dérivé) pour générer des revenus, construire un produit commercial ou l'intégrer dans un service monétisé.
+- **Redistribution sous condition** : Vous ne pouvez pas redistribuer ou publier cette version sans maintenir cette licence restrictive.
+
+*(Inspiré de Creative Commons Attribution-NonCommercial 4.0 International - CC BY-NC 4.0).*
+
+---
+
+## 🗺️ Roadmap & Version SaaS Commerciale Publique
+
+Une version complète de **Keep Notes** destinée au grand public est prévue et en cours de planification. Cette version cloud s'appuiera sur de toutes nouvelles optimisations d'infrastructure :
+
+1. **Migration Base de Données** :
+   - Remplacement de SQLite local par **PostgreSQL** afin de supporter l'architecture multi-tenant (plusieurs utilisateurs avec sécurité accrue des données).
+2. **Système de Monétisation (Features IA)** :
+   - Mise en place d'un modèle d'abonnement SaaS (Stripe).
+   - Intégration d'un système de crédit ("AI Credits") pour réguler l'usage des API d'intelligence artificielle (LLMs, Embeddings) de façon soutenable.
+3. **Optimisations Scalabilité** :
+   - Déploiement distribué.
+
+---
+
+## 🛠️ Stack Technique
+
+- **Framework** : Next.js 15 (App Router, Server Components)
+- **Frontend** : React 19, Tailwind CSS, Radix UI primitives
+- **Drag & Drop** : `@dnd-kit/core` & `sortable`
+- **Base de Données** : Prisma ORM, SQLite en env de développement (bientôt PostgreSQL)
+- **Outillage** : Turbopack, TypeScript
+
+## 💻 Instructions de Développement
+
+### Installation
+```bash
+npm install
+# ou
+yarn install
+```
+
+### Initialisation de la Base de données
+```bash
+npx prisma generate
+npx prisma db push
+```
+
+### Lancement du serveur (avec Turbopack)
+```bash
+npm run dev
+```
+Ouvrez [http://localhost:3000](http://localhost:3000) dans votre navigateur.

memento-note/app/(auth)/forgot-password/page.tsx

@@ -0,0 +1,79 @@
+'use client'
+
+import { useState } from 'react'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from '@/components/ui/card'
+import { forgotPassword } from '@/app/actions/auth-reset'
+import { toast } from 'sonner'
+import Link from 'next/link'
+import { useLanguage } from '@/lib/i18n'
+
+export default function ForgotPasswordPage() {
+  const { t } = useLanguage()
+  const [isSubmitting, setIsSubmitting] = useState(false)
+  const [isDone, setIsSubmittingDone] = useState(false)
+
+  const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
+    e.preventDefault()
+    setIsSubmitting(true)
+    const formData = new FormData(e.currentTarget)
+    const result = await forgotPassword(formData.get('email') as string)
+    setIsSubmitting(false)
+
+    if (result.error) {
+      toast.error(result.error)
+    } else {
+      setIsSubmittingDone(true)
+    }
+  }
+
+  if (isDone) {
+    return (
+      <main className="flex items-center justify-center md:h-screen p-4">
+        <Card className="w-full max-w-[400px]">
+          <CardHeader>
+            <CardTitle>{t('auth.checkYourEmail')}</CardTitle>
+            <CardDescription>
+              {t('auth.resetEmailSent')}
+            </CardDescription>
+          </CardHeader>
+          <CardFooter>
+            <Link href="/login" className="w-full">
+              <Button variant="outline" className="w-full">{t('auth.returnToLogin')}</Button>
+            </Link>
+          </CardFooter>
+        </Card>
+      </main>
+    )
+  }
+
+  return (
+    <main className="flex items-center justify-center md:h-screen p-4">
+      <Card className="w-full max-w-[400px]">
+        <CardHeader>
+          <CardTitle>{t('auth.forgotPasswordTitle')}</CardTitle>
+          <CardDescription>
+            {t('auth.forgotPasswordDescription')}
+          </CardDescription>
+        </CardHeader>
+        <form onSubmit={handleSubmit}>
+          <CardContent className="space-y-4">
+            <div className="space-y-2">
+              <label htmlFor="email" className="text-sm font-medium">{t('auth.email')}</label>
+              <Input id="email" name="email" type="email" required placeholder="name@example.com" />
+            </div>
+          </CardContent>
+          <CardFooter className="flex flex-col gap-4">
+            <Button type="submit" className="w-full" disabled={isSubmitting}>
+              {isSubmitting ? t('auth.sending') : t('auth.sendResetLink')}
+            </Button>
+            <Link href="/login" className="text-sm text-center underline">
+              {t('auth.backToLogin')}
+            </Link>
+          </CardFooter>
+        </form>
+      </Card>
+    </main>
+  )
+}

memento-note/app/(auth)/layout.tsx

@@ -0,0 +1,19 @@
+'use client';
+
+import { LanguageProvider } from '@/lib/i18n/LanguageProvider';
+
+export default function AuthLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <LanguageProvider>
+      <div className="flex min-h-screen items-center justify-center bg-gray-50 dark:bg-zinc-950">
+        <div className="w-full max-w-md p-4">
+          {children}
+        </div>
+      </div>
+    </LanguageProvider>
+  );
+}

memento-note/app/(auth)/login/page.tsx

@@ -0,0 +1,17 @@
+import { LoginForm } from '@/components/login-form';
+import { getSystemConfig } from '@/lib/config';
+ 
+export default async function LoginPage() {
+  const config = await getSystemConfig();
+  
+  // Default to true unless explicitly disabled in DB or Env
+  const allowRegister = config.ALLOW_REGISTRATION !== 'false' && process.env.ALLOW_REGISTRATION !== 'false';
+
+  return (
+    <main className="flex items-center justify-center md:h-screen">
+      <div className="relative mx-auto flex w-full max-w-[400px] flex-col space-y-2.5 p-4 md:-mt-32">
+        <LoginForm allowRegister={allowRegister} />
+      </div>
+    </main>
+  );
+}

memento-note/app/(auth)/register/page.tsx

@@ -0,0 +1,20 @@
+import { RegisterForm } from '@/components/register-form';
+import { getSystemConfig } from '@/lib/config';
+import { redirect } from 'next/navigation';
+ 
+export default async function RegisterPage() {
+  const config = await getSystemConfig();
+  const allowRegister = config.ALLOW_REGISTRATION !== 'false' && process.env.ALLOW_REGISTRATION !== 'false';
+
+  if (!allowRegister) {
+    redirect('/login');
+  }
+
+  return (
+    <main className="flex items-center justify-center md:h-screen">
+      <div className="relative mx-auto flex w-full max-w-[400px] flex-col space-y-2.5 p-4 md:-mt-32">
+        <RegisterForm />
+      </div>
+    </main>
+  );
+}

memento-note/app/(auth)/reset-password/page.tsx

@@ -0,0 +1,98 @@
+'use client'
+
+import { useState, Suspense } from 'react'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from '@/components/ui/card'
+import { resetPassword } from '@/app/actions/auth-reset'
+import { toast } from 'sonner'
+import { useSearchParams, useRouter } from 'next/navigation'
+import Link from 'next/link'
+import { useLanguage } from '@/lib/i18n'
+
+function ResetPasswordForm() {
+  const searchParams = useSearchParams()
+  const router = useRouter()
+  const { t } = useLanguage()
+  const [isSubmitting, setIsSubmitting] = useState(false)
+  
+  const token = searchParams.get('token')
+
+  const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
+    e.preventDefault()
+    if (!token) return
+
+    const formData = new FormData(e.currentTarget)
+    const password = formData.get('password') as string
+    const confirm = formData.get('confirmPassword') as string
+
+    if (password !== confirm) {
+      toast.error(t('resetPassword.passwordMismatch'))
+      return
+    }
+
+    setIsSubmitting(true)
+    const result = await resetPassword(token, password)
+    setIsSubmitting(false)
+    
+    if (result.error) {
+      toast.error(result.error)
+    } else {
+      toast.success(t('resetPassword.success'))
+      router.push('/login')
+    }
+  }
+
+  if (!token) {
+    return (
+      <Card className="w-full max-w-[400px]">
+        <CardHeader>
+          <CardTitle>{t('resetPassword.invalidLinkTitle')}</CardTitle>
+          <CardDescription>{t('resetPassword.invalidLinkDescription')}</CardDescription>
+        </CardHeader>
+        <CardFooter>
+          <Link href="/forgot-password" title="Try again" className="w-full">
+            <Button variant="outline" className="w-full">{t('resetPassword.requestNewLink')}</Button>
+          </Link>
+        </CardFooter>
+      </Card>
+    )
+  }
+
+  return (
+    <Card className="w-full max-w-[400px]">
+      <CardHeader>
+        <CardTitle>{t('resetPassword.title')}</CardTitle>
+        <CardDescription>{t('resetPassword.description')}</CardDescription>
+      </CardHeader>
+      <form onSubmit={handleSubmit}>
+        <CardContent className="space-y-4">
+          <div className="space-y-2">
+            <label htmlFor="password">{t('resetPassword.newPassword')}</label>
+            <Input id="password" name="password" type="password" required minLength={6} autoFocus />
+          </div>
+          <div className="space-y-2">
+            <label htmlFor="confirmPassword">{t('resetPassword.confirmNewPassword')}</label>
+            <Input id="confirmPassword" name="confirmPassword" type="password" required minLength={6} />
+          </div>
+        </CardContent>
+        <CardFooter>
+          <Button type="submit" className="w-full" disabled={isSubmitting}>
+            {isSubmitting ? t('resetPassword.resetting') : t('resetPassword.resetPassword')}
+          </Button>
+        </CardFooter>
+      </form>
+    </Card>
+  )
+}
+
+export default function ResetPasswordPage() {
+  const { t } = useLanguage()
+  return (
+    <main className="flex items-center justify-center md:h-screen p-4">
+      <Suspense fallback={<div>{t('resetPassword.loading')}</div>}>
+        <ResetPasswordForm />
+      </Suspense>
+    </main>
+  )
+}

memento-note/app/(main)/admin/ai-test/ai-tester.tsx

@@ -0,0 +1,259 @@
+'use client'
+
+import { Button } from '@/components/ui/button'
+import { Card, CardContent } from '@/components/ui/card'
+import { Badge } from '@/components/ui/badge'
+import { useState, useEffect } from 'react'
+import { toast } from 'sonner'
+import { Loader2, CheckCircle2, XCircle, Clock, Zap, Info } from 'lucide-react'
+import { useLanguage } from '@/lib/i18n'
+
+interface TestResult {
+  success: boolean
+  provider?: string
+  model?: string
+  responseTime?: number
+  tags?: Array<{ tag: string; confidence: number }>
+  embeddingLength?: number
+  firstValues?: number[]
+  error?: string
+  details?: any
+}
+
+export function AI_TESTER({ type }: { type: 'tags' | 'embeddings' }) {
+  const { t } = useLanguage()
+  const [isLoading, setIsLoading] = useState(false)
+  const [result, setResult] = useState<TestResult | null>(null)
+  const [config, setConfig] = useState<any>(null)
+
+  useEffect(() => {
+    fetchConfig()
+  }, [])
+
+  const fetchConfig = async () => {
+    try {
+      const response = await fetch('/api/ai/config')
+      const data = await response.json()
+      setConfig(data)
+
+      if (data.previousTest) {
+        setResult(data.previousTest[type] || null)
+      }
+    } catch (error) {
+      console.error('Failed to fetch config:', error)
+    }
+  }
+
+  const runTest = async () => {
+    setIsLoading(true)
+    const startTime = Date.now()
+
+    try {
+      const response = await fetch(`/api/ai/test-${type}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' }
+      })
+
+      const endTime = Date.now()
+      const data = await response.json()
+
+      setResult({
+        ...data,
+        responseTime: endTime - startTime
+      })
+
+      if (data.success) {
+        toast.success(
+          `✅ ${t('admin.aiTest.testSuccessToast', { type: type === 'tags' ? 'Tags' : 'Embeddings' })}`,
+          {
+            description: `Provider: ${data.provider} | Time: ${endTime - startTime}ms`
+          }
+        )
+      } else {
+        toast.error(
+          `❌ ${t('admin.aiTest.testFailedToast', { type: type === 'tags' ? 'Tags' : 'Embeddings' })}`,
+          {
+            description: data.error || 'Unknown error'
+          }
+        )
+      }
+    } catch (error: any) {
+      const endTime = Date.now()
+      const errorResult = {
+        success: false,
+        error: error.message || 'Network error',
+        responseTime: endTime - startTime
+      }
+      setResult(errorResult)
+      toast.error(t('admin.aiTest.testError', { error: error.message }))
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const getProviderInfo = () => {
+    if (!config) return { provider: t('admin.aiTest.testing'), model: t('admin.aiTest.testing') }
+
+    if (type === 'tags') {
+      return {
+        provider: config.AI_PROVIDER_TAGS || 'ollama',
+        model: config.AI_MODEL_TAGS || 'granite4:latest'
+      }
+    } else {
+      return {
+        provider: config.AI_PROVIDER_EMBEDDING || 'ollama',
+        model: config.AI_MODEL_EMBEDDING || 'embeddinggemma:latest'
+      }
+    }
+  }
+
+  const providerInfo = getProviderInfo()
+
+  return (
+    <div className="space-y-4">
+      {/* Provider Info */}
+      <div className="space-y-3 p-4 bg-muted/50 rounded-lg">
+        <div className="flex items-center justify-between">
+          <span className="text-sm font-medium">{t('admin.aiTest.provider')}</span>
+          <Badge variant="outline" className="text-xs">
+            {providerInfo.provider.toUpperCase()}
+          </Badge>
+        </div>
+        <div className="flex items-center justify-between">
+          <span className="text-sm font-medium">{t('admin.aiTest.model')}</span>
+          <span className="text-sm text-muted-foreground font-mono">
+            {providerInfo.model}
+          </span>
+        </div>
+      </div>
+
+      {/* Test Button */}
+      <Button
+        onClick={runTest}
+        disabled={isLoading}
+        className="w-full"
+        variant={result?.success ? 'default' : result?.success === false ? 'destructive' : 'default'}
+      >
+        {isLoading ? (
+          <>
+            <Loader2 className="mr-2 h-4 w-4 animate-spin" />
+            {t('admin.aiTest.testing')}
+          </>
+        ) : (
+          <>
+            <Zap className="mr-2 h-4 w-4" />
+            {t('admin.aiTest.runTest')}
+          </>
+        )}
+      </Button>
+
+      {/* Results */}
+      {result && (
+        <Card className={result.success ? 'border-green-200 dark:border-green-900' : 'border-red-200 dark:border-red-900'}>
+          <CardContent className="pt-6">
+            {/* Status */}
+            <div className="flex items-center gap-2 mb-4">
+              {result.success ? (
+                <>
+                  <CheckCircle2 className="h-5 w-5 text-green-600" />
+                  <span className="font-semibold text-green-600 dark:text-green-400">{t('admin.aiTest.testPassed')}</span>
+                </>
+              ) : (
+                <>
+                  <XCircle className="h-5 w-5 text-red-600" />
+                  <span className="font-semibold text-red-600 dark:text-red-400">{t('admin.aiTest.testFailed')}</span>
+                </>
+              )}
+            </div>
+
+            {/* Response Time */}
+            {result.responseTime && (
+              <div className="flex items-center gap-2 text-sm text-muted-foreground mb-4">
+                <Clock className="h-4 w-4" />
+                <span>{t('admin.aiTest.responseTime', { time: result.responseTime })}</span>
+              </div>
+            )}
+
+            {/* Tags Results */}
+            {type === 'tags' && result.success && result.tags && (
+              <div className="space-y-3">
+                <div className="flex items-center gap-2">
+                  <Info className="h-4 w-4 text-primary" />
+                  <span className="text-sm font-medium">{t('admin.aiTest.generatedTags')}</span>
+                </div>
+                <div className="flex flex-wrap gap-2">
+                  {result.tags.map((tag, idx) => (
+                    <Badge
+                      key={idx}
+                      variant="secondary"
+                      className="text-sm"
+                    >
+                      {tag.tag}
+                      <span className="ml-1 text-xs opacity-70">
+                        ({Math.round(tag.confidence * 100)}%)
+                      </span>
+                    </Badge>
+                  ))}
+                </div>
+              </div>
+            )}
+
+            {/* Embeddings Results */}
+            {type === 'embeddings' && result.success && result.embeddingLength && (
+              <div className="space-y-3">
+                <div className="flex items-center gap-2">
+                  <Info className="h-4 w-4 text-green-600" />
+                  <span className="text-sm font-medium">{t('admin.aiTest.embeddingDimensions')}</span>
+                </div>
+                <div className="p-3 bg-muted rounded-lg">
+                  <div className="text-2xl font-bold text-center">
+                    {result.embeddingLength}
+                  </div>
+                  <div className="text-xs text-center text-muted-foreground mt-1">
+                    {t('admin.aiTest.vectorDimensions')}
+                  </div>
+                </div>
+                {result.firstValues && result.firstValues.length > 0 && (
+                  <div className="space-y-1">
+                    <span className="text-xs font-medium">{t('admin.aiTest.first5Values')}</span>
+                    <div className="p-2 bg-muted rounded font-mono text-xs">
+                      [{result.firstValues.slice(0, 5).map((v, i) => v.toFixed(4)).join(', ')}]
+                    </div>
+                  </div>
+                )}
+              </div>
+            )}
+
+            {/* Error Details */}
+            {!result.success && result.error && (
+              <div className="mt-4 p-3 bg-red-50 dark:bg-red-950/20 rounded-lg border border-red-200 dark:border-red-900">
+                <p className="text-sm font-medium text-red-900 dark:text-red-100">{t('admin.aiTest.error')}</p>
+                <p className="text-sm text-red-700 dark:text-red-300 mt-1">{result.error}</p>
+                {result.details && (
+                  <details className="mt-2">
+                    <summary className="text-xs cursor-pointer text-red-600 dark:text-red-400">
+                      {t('admin.aiTest.technicalDetails')}
+                    </summary>
+                    <pre className="mt-2 text-xs overflow-auto p-2 bg-red-100 dark:bg-red-900/30 rounded">
+                      {JSON.stringify(result.details, null, 2)}
+                    </pre>
+                  </details>
+                )}
+              </div>
+            )}
+          </CardContent>
+        </Card>
+      )}
+
+      {/* Loading State */}
+      {isLoading && (
+        <div className="text-center py-4">
+          <Loader2 className="h-8 w-8 animate-spin mx-auto text-primary" />
+          <p className="text-sm text-muted-foreground mt-2">
+            {t('admin.aiTest.testingType', { type: type === 'tags' ? 'tags generation' : 'embeddings' })}
+          </p>
+        </div>
+      )}
+    </div>
+  )
+}

memento-note/app/(main)/admin/ai-test/page.tsx

@@ -0,0 +1,102 @@
+'use client'
+
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Button } from '@/components/ui/button'
+import Link from 'next/link'
+import { ArrowLeft, TestTube } from 'lucide-react'
+import { AI_TESTER } from './ai-tester'
+import { useLanguage } from '@/lib/i18n'
+
+export default function AITestPage() {
+  const { t } = useLanguage()
+
+  return (
+    <div className="container mx-auto py-10 px-4 max-w-6xl">
+      <div className="flex justify-between items-center mb-8">
+        <div className="flex items-center gap-3">
+          <Link href="/admin/settings">
+            <Button variant="outline" size="icon">
+              <ArrowLeft className="h-4 w-4" />
+            </Button>
+          </Link>
+          <div>
+            <h1 className="text-3xl font-bold flex items-center gap-2">
+              <TestTube className="h-8 w-8" />
+              {t('admin.aiTest.title')}
+            </h1>
+            <p className="text-muted-foreground mt-1">
+              {t('admin.aiTest.description')}
+            </p>
+          </div>
+        </div>
+      </div>
+
+      <div className="grid gap-6 md:grid-cols-2">
+        {/* Tags Provider Test */}
+        <Card className="border-primary/20 dark:border-primary/30">
+          <CardHeader className="bg-primary/5 dark:bg-primary/10">
+            <CardTitle className="flex items-center gap-2">
+              <span className="text-2xl">🏷️</span>
+              {t('admin.aiTest.tagsTestTitle')}
+            </CardTitle>
+            <CardDescription>
+              {t('admin.aiTest.tagsTestDescription')}
+            </CardDescription>
+          </CardHeader>
+          <CardContent className="pt-6">
+            <AI_TESTER type="tags" />
+          </CardContent>
+        </Card>
+
+        {/* Embeddings Provider Test */}
+        <Card className="border-green-200 dark:border-green-900">
+          <CardHeader className="bg-green-50/50 dark:bg-green-950/20">
+            <CardTitle className="flex items-center gap-2">
+              <span className="text-2xl">🔍</span>
+              {t('admin.aiTest.embeddingsTestTitle')}
+            </CardTitle>
+            <CardDescription>
+              {t('admin.aiTest.embeddingsTestDescription')}
+            </CardDescription>
+          </CardHeader>
+          <CardContent className="pt-6">
+            <AI_TESTER type="embeddings" />
+          </CardContent>
+        </Card>
+      </div>
+
+      {/* Info Section */}
+      <Card className="mt-6">
+        <CardHeader>
+          <CardTitle>ℹ️ {t('admin.aiTest.howItWorksTitle')}</CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-4 text-sm">
+          <div>
+            <h4 className="font-semibold mb-2">{t('admin.aiTest.tagsGenerationTest')}</h4>
+            <ul className="list-disc list-inside space-y-1 text-muted-foreground">
+              <li>{t('admin.aiTest.tagsStep1')}</li>
+              <li>{t('admin.aiTest.tagsStep2')}</li>
+              <li>{t('admin.aiTest.tagsStep3')}</li>
+              <li>{t('admin.aiTest.tagsStep4')}</li>
+            </ul>
+          </div>
+          <div>
+            <h4 className="font-semibold mb-2">{t('admin.aiTest.embeddingsTestLabel')}</h4>
+            <ul className="list-disc list-inside space-y-1 text-muted-foreground">
+              <li>{t('admin.aiTest.embeddingsStep1')}</li>
+              <li>{t('admin.aiTest.embeddingsStep2')}</li>
+              <li>{t('admin.aiTest.embeddingsStep3')}</li>
+              <li>{t('admin.aiTest.embeddingsStep4')}</li>
+            </ul>
+          </div>
+          <div className="bg-amber-50 dark:bg-amber-950/20 p-4 rounded-lg border border-amber-200 dark:border-amber-900">
+            <p className="font-semibold text-amber-900 dark:text-amber-100">💡 {t('admin.aiTest.tipTitle')}</p>
+            <p className="text-amber-800 dark:text-amber-200 mt-1">
+              {t('admin.aiTest.tipContent')}
+            </p>
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  )
+}

memento-note/app/(main)/admin/ai/page.tsx

@@ -0,0 +1,147 @@
+import { AdminMetrics } from '@/components/admin-metrics'
+import { Button } from '@/components/ui/button'
+import { Zap, Settings, Activity, TrendingUp } from 'lucide-react'
+import Link from 'next/link'
+import { getSystemConfig } from '@/lib/config'
+
+export default async function AdminAIPage() {
+  const config = await getSystemConfig()
+
+  // Determine provider status based on config
+  const openaiKey = config.OPENAI_API_KEY
+  const ollamaUrl = config.OLLAMA_BASE_URL || config.OLLAMA_BASE_URL_TAGS || config.OLLAMA_BASE_URL_EMBEDDING
+
+  const providers = [
+    {
+      name: 'OpenAI',
+      status: openaiKey ? 'Connected' : 'Not Configured',
+      requests: 'N/A' // We don't track request counts yet
+    },
+    {
+      name: 'Ollama',
+      status: ollamaUrl ? 'Available' : 'Not Configured',
+      requests: 'N/A'
+    },
+  ]
+
+  // Mock AI metrics - in a real app, these would come from analytics
+  // TODO: Implement real analytics tracking
+  const aiMetrics = [
+    {
+      title: 'Total Requests',
+      value: '—',
+      trend: { value: 0, isPositive: true },
+      icon: <Zap className="h-5 w-5 text-yellow-600 dark:text-yellow-400" />,
+    },
+    {
+      title: 'Success Rate',
+      value: '100%',
+      trend: { value: 0, isPositive: true },
+      icon: <TrendingUp className="h-5 w-5 text-green-600 dark:text-green-400" />,
+    },
+    {
+      title: 'Avg Response Time',
+      value: '—',
+      trend: { value: 0, isPositive: true },
+      icon: <Activity className="h-5 w-5 text-primary dark:text-primary-foreground" />,
+    },
+    {
+      title: 'Active Features',
+      value: '6',
+      icon: <Settings className="h-5 w-5 text-purple-600 dark:text-purple-400" />,
+    },
+  ]
+
+  return (
+    <div className="space-y-6">
+      <div className="flex justify-between items-center">
+        <div>
+          <h1 className="text-3xl font-bold text-gray-900 dark:text-white">
+            AI Management
+          </h1>
+          <p className="text-gray-600 dark:text-gray-400 mt-1">
+            Monitor and configure AI features
+          </p>
+        </div>
+        <Link href="/admin/settings">
+          <Button variant="outline">
+            <Settings className="mr-2 h-4 w-4" />
+            Configure
+          </Button>
+        </Link>
+      </div>
+
+      <AdminMetrics metrics={aiMetrics} />
+
+      <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
+        <div className="bg-white dark:bg-zinc-900 rounded-lg shadow overflow-hidden border border-gray-200 dark:border-gray-800 p-6">
+          <h2 className="text-lg font-semibold text-gray-900 dark:text-white mb-4">
+            Active AI Features
+          </h2>
+          <div className="space-y-3">
+            {[
+              'Title Suggestions',
+              'Semantic Search',
+              'Paragraph Reformulation',
+              'Memory Echo',
+              'Language Detection',
+              'Auto Labeling',
+            ].map((feature) => (
+              <div
+                key={feature}
+                className="flex items-center justify-between p-3 bg-gray-50 dark:bg-zinc-800 rounded-lg"
+              >
+                <span className="text-sm text-gray-900 dark:text-white">
+                  {feature}
+                </span>
+                <span className="px-2 py-1 text-xs font-medium text-green-700 dark:text-green-400 bg-green-100 dark:bg-green-900 rounded-full">
+                  Active
+                </span>
+              </div>
+            ))}
+          </div>
+        </div>
+
+        <div className="bg-white dark:bg-zinc-900 rounded-lg shadow overflow-hidden border border-gray-200 dark:border-gray-800 p-6">
+          <h2 className="text-lg font-semibold text-gray-900 dark:text-white mb-4">
+            AI Provider Status
+          </h2>
+          <div className="space-y-3">
+            {providers.map((provider) => (
+              <div
+                key={provider.name}
+                className="flex items-center justify-between p-3 bg-gray-50 dark:bg-zinc-800 rounded-lg"
+              >
+                <div>
+                  <p className="text-sm font-medium text-gray-900 dark:text-white">
+                    {provider.name}
+                  </p>
+                  <p className="text-xs text-gray-600 dark:text-gray-400">
+                    {provider.requests} requests
+                  </p>
+                </div>
+                <span
+                  className={`px-2 py-1 text-xs font-medium rounded-full ${provider.status === 'Connected' || provider.status === 'Available'
+                      ? 'text-green-700 dark:text-green-400 bg-green-100 dark:bg-green-900'
+                      : 'text-gray-600 dark:text-gray-400 bg-gray-100 dark:bg-gray-800'
+                    }`}
+                >
+                  {provider.status}
+                </span>
+              </div>
+            ))}
+          </div>
+        </div>
+      </div>
+
+      <div className="bg-white dark:bg-zinc-900 rounded-lg shadow overflow-hidden border border-gray-200 dark:border-gray-800 p-6">
+        <h2 className="text-lg font-semibold text-gray-900 dark:text-white mb-4">
+          Recent AI Requests
+        </h2>
+        <p className="text-gray-600 dark:text-gray-400">
+          Recent AI requests will be displayed here. (Coming Soon)
+        </p>
+      </div>
+    </div>
+  )
+}

memento-note/app/(main)/admin/create-user-dialog.tsx

@@ -0,0 +1,80 @@
+'use client'
+
+import { useState } from 'react'
+import { Button } from '@/components/ui/button'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+  DialogFooter,
+} from '@/components/ui/dialog'
+import { Input } from '@/components/ui/input'
+import { Plus } from 'lucide-react'
+import { createUser } from '@/app/actions/admin'
+import { toast } from 'sonner'
+import { useLanguage } from '@/lib/i18n'
+
+export function CreateUserDialog() {
+  const [open, setOpen] = useState(false)
+  const { t } = useLanguage()
+  
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <DialogTrigger asChild>
+        <Button>
+          <Plus className="mr-2 h-4 w-4" /> {t('admin.users.addUser')}
+        </Button>
+      </DialogTrigger>
+      <DialogContent className="sm:max-w-[425px]">
+        <DialogHeader>
+          <DialogTitle>{t('admin.users.createUser')}</DialogTitle>
+          <DialogDescription>
+            {t('admin.users.createUserDescription')}
+          </DialogDescription>
+        </DialogHeader>
+        <form
+          action={async (formData) => {
+            const result = await createUser(formData)
+            if (result?.error) {
+              toast.error(t('admin.users.createFailed'))
+            } else {
+              toast.success(t('admin.users.createSuccess'))
+              setOpen(false)
+            }
+          }}
+          className="grid gap-4 py-4"
+        >
+          <div className="grid gap-2">
+            <label htmlFor="name">{t('admin.users.name')}</label>
+            <Input id="name" name="name" required />
+          </div>
+          <div className="grid gap-2">
+            <label htmlFor="email">{t('admin.users.email')}</label>
+            <Input id="email" name="email" type="email" required />
+          </div>
+          <div className="grid gap-2">
+            <label htmlFor="password">{t('admin.users.password')}</label>
+            <Input id="password" name="password" type="password" required minLength={6} />
+          </div>
+          <div className="grid gap-2">
+            <label htmlFor="role">{t('admin.users.role')}</label>
+            <select
+              id="role"
+              name="role"
+              className="flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm transition-colors file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50"
+            >
+              <option value="USER">{t('admin.users.roles.user')}</option>
+              <option value="ADMIN">{t('admin.users.roles.admin')}</option>
+            </select>
+          </div>
+          <DialogFooter>
+            <Button type="submit">{t('admin.users.createUser')}</Button>
+          </DialogFooter>
+        </form>
+      </DialogContent>
+    </Dialog>
+  )
+}

memento-note/app/(main)/admin/layout.tsx

@@ -0,0 +1,23 @@
+import { AdminSidebar } from '@/components/admin-sidebar'
+import { AdminContentArea } from '@/components/admin-content-area'
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+
+export default async function AdminLayout({
+  children,
+}: {
+  children: React.ReactNode
+}) {
+  const session = await auth()
+
+  if ((session?.user as any)?.role !== 'ADMIN') {
+    redirect('/')
+  }
+
+  return (
+    <div className="flex h-full bg-gray-50 dark:bg-zinc-950">
+      <AdminSidebar />
+      <AdminContentArea>{children}</AdminContentArea>
+    </div>
+  )
+}

memento-note/app/(main)/admin/loading.tsx

@@ -0,0 +1,20 @@
+export default function AdminLoading() {
+  return (
+    <div className="space-y-6 animate-pulse">
+      <div>
+        <div className="h-9 w-48 bg-muted rounded-md mb-2" />
+        <div className="h-4 w-72 bg-muted rounded-md" />
+      </div>
+      {[1, 2, 3].map((i) => (
+        <div key={i} className="rounded-lg border border-border bg-white dark:bg-zinc-900 p-6 space-y-4">
+          <div className="h-5 w-40 bg-muted rounded" />
+          <div className="h-px bg-border" />
+          <div className="space-y-3">
+            <div className="h-4 w-full bg-muted rounded" />
+            <div className="h-4 w-3/4 bg-muted rounded" />
+          </div>
+        </div>
+      ))}
+    </div>
+  )
+}

memento-note/app/(main)/admin/page.tsx

@@ -0,0 +1,59 @@
+import { getUsers } from '@/app/actions/admin'
+import { AdminMetrics } from '@/components/admin-metrics'
+import { Users, Activity, Database, Zap } from 'lucide-react'
+
+export default async function AdminPage() {
+  const users = await getUsers()
+
+  // Mock metrics data - in a real app, these would come from analytics
+  const metrics = [
+    {
+      title: 'Total Users',
+      value: users.length,
+      trend: { value: 12, isPositive: true },
+      icon: <Users className="h-5 w-5 text-primary dark:text-primary-foreground" />,
+    },
+    {
+      title: 'Active Sessions',
+      value: '24',
+      trend: { value: 8, isPositive: true },
+      icon: <Activity className="h-5 w-5 text-green-600 dark:text-green-400" />,
+    },
+    {
+      title: 'Total Notes',
+      value: '1,234',
+      trend: { value: 24, isPositive: true },
+      icon: <Database className="h-5 w-5 text-purple-600 dark:text-purple-400" />,
+    },
+    {
+      title: 'AI Requests',
+      value: '856',
+      trend: { value: 5, isPositive: false },
+      icon: <Zap className="h-5 w-5 text-yellow-600 dark:text-yellow-400" />,
+    },
+  ]
+
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-3xl font-bold text-gray-900 dark:text-white">
+          Dashboard
+        </h1>
+        <p className="text-gray-600 dark:text-gray-400 mt-1">
+          Overview of your application metrics
+        </p>
+      </div>
+
+      <AdminMetrics metrics={metrics} />
+
+      <div className="bg-white dark:bg-zinc-900 rounded-lg shadow overflow-hidden border border-gray-200 dark:border-gray-800 p-6">
+        <h2 className="text-lg font-semibold text-gray-900 dark:text-white mb-4">
+          Recent Activity
+        </h2>
+        <p className="text-gray-600 dark:text-gray-400">
+          Recent activity will be displayed here.
+        </p>
+      </div>
+    </div>
+  )
+}

memento-note/app/(main)/admin/settings/page.tsx

@@ -0,0 +1,23 @@
+import { getSystemConfig } from '@/app/actions/admin-settings'
+import { AdminSettingsForm } from './admin-settings-form'
+
+export default async function AdminSettingsPage() {
+  const config = await getSystemConfig()
+
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-3xl font-bold text-gray-900 dark:text-white">
+          Settings
+        </h1>
+        <p className="text-gray-600 dark:text-gray-400 mt-1">
+          Configure application-wide settings
+        </p>
+      </div>
+
+      <div className="bg-white dark:bg-zinc-900 rounded-lg shadow overflow-hidden border border-gray-200 dark:border-gray-800 p-6">
+        <AdminSettingsForm config={config} />
+      </div>
+    </div>
+  )
+}

memento-note/app/(main)/admin/user-list.tsx

@@ -0,0 +1,83 @@
+'use client'
+
+import { useState } from 'react'
+import { Button } from '@/components/ui/button'
+import { deleteUser, updateUserRole } from '@/app/actions/admin'
+import { toast } from 'sonner'
+import { Trash2, Shield, ShieldOff } from 'lucide-react'
+import { format } from 'date-fns'
+import { useLanguage } from '@/lib/i18n'
+
+export function UserList({ initialUsers }: { initialUsers: any[] }) {
+  const { t } = useLanguage()
+
+  const handleDelete = async (id: string) => {
+    if (!confirm(t('admin.users.confirmDelete'))) return
+    try {
+      await deleteUser(id)
+      toast.success(t('admin.users.deleteSuccess'))
+    } catch (e) {
+      toast.error(t('admin.users.deleteFailed'))
+    }
+  }
+
+  const handleRoleToggle = async (user: any) => {
+    const newRole = user.role === 'ADMIN' ? 'USER' : 'ADMIN'
+    try {
+      await updateUserRole(user.id, newRole)
+      toast.success(t('admin.users.roleUpdateSuccess', { role: newRole }))
+    } catch (e) {
+      toast.error(t('admin.users.roleUpdateFailed'))
+    }
+  }
+
+  return (
+    <div className="w-full overflow-auto">
+      <table className="w-full caption-bottom text-sm text-left">
+        <thead className="[&_tr]:border-b">
+          <tr className="border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted">
+            <th className="h-12 px-4 align-middle font-medium text-muted-foreground">{t('admin.users.table.name')}</th>
+            <th className="h-12 px-4 align-middle font-medium text-muted-foreground">{t('admin.users.table.email')}</th>
+            <th className="h-12 px-4 align-middle font-medium text-muted-foreground">{t('admin.users.table.role')}</th>
+            <th className="h-12 px-4 align-middle font-medium text-muted-foreground">{t('admin.users.table.createdAt')}</th>
+            <th className="h-12 px-4 align-middle font-medium text-muted-foreground text-right">{t('admin.users.table.actions')}</th>
+          </tr>
+        </thead>
+        <tbody className="[&_tr:last-child]:border-0">
+          {initialUsers.map((user) => (
+            <tr key={user.id} className="border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted">
+              <td className="p-4 align-middle font-medium">{user.name || t('common.notAvailable')}</td>
+              <td className="p-4 align-middle">{user.email}</td>
+              <td className="p-4 align-middle">
+                <span className={`inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 ${user.role === 'ADMIN' ? 'border-transparent bg-primary text-primary-foreground hover:bg-primary/80' : 'border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80'}`}>
+                  {user.role === 'ADMIN' ? t('admin.users.roles.admin') : t('admin.users.roles.user')}
+                </span>
+              </td>
+              <td className="p-4 align-middle">{format(new Date(user.createdAt), 'PP')}</td>
+              <td className="p-4 align-middle text-right">
+                <div className="flex justify-end gap-2">
+                  <Button
+                    variant="ghost"
+                    size="sm"
+                    onClick={() => handleRoleToggle(user)}
+                    title={user.role === 'ADMIN' ? t('admin.users.demote') : t('admin.users.promote')}
+                  >
+                    {user.role === 'ADMIN' ? <ShieldOff className="h-4 w-4" /> : <Shield className="h-4 w-4" />}
+                  </Button>
+                  <Button
+                    variant="ghost"
+                    size="sm"
+                    onClick={() => handleDelete(user.id)}
+                    className="text-red-600 hover:text-red-900"
+                  >
+                    <Trash2 className="h-4 w-4" />
+                  </Button>
+                </div>
+              </td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  )
+}

memento-note/app/(main)/admin/users/page.tsx

@@ -0,0 +1,29 @@
+import { getUsers } from '@/app/actions/admin'
+import { CreateUserDialog } from '../create-user-dialog'
+import { UserList } from '../user-list'
+import { Plus } from 'lucide-react'
+import { Button } from '@/components/ui/button'
+
+export default async function AdminUsersPage() {
+  const users = await getUsers()
+
+  return (
+    <div className="space-y-6">
+      <div className="flex justify-between items-center">
+        <div>
+          <h1 className="text-3xl font-bold text-gray-900 dark:text-white">
+            Users
+          </h1>
+          <p className="text-gray-600 dark:text-gray-400 mt-1">
+            Manage application users and permissions
+          </p>
+        </div>
+        <CreateUserDialog />
+      </div>
+
+      <div className="bg-white dark:bg-zinc-900 rounded-lg shadow overflow-hidden border border-gray-200 dark:border-gray-800">
+        <UserList initialUsers={users} />
+      </div>
+    </div>
+  )
+}

memento-note/app/(main)/agents/agents-page-client.tsx

@@ -0,0 +1,281 @@
+'use client'
+
+/**
+ * Agents Page Client
+ * Main client component for the agents page.
+ */
+
+import { useState, useCallback, useMemo } from 'react'
+import { Plus, Bot, LifeBuoy, Search } from 'lucide-react'
+import { toast } from 'sonner'
+import { useLanguage } from '@/lib/i18n'
+
+import { AgentCard } from '@/components/agents/agent-card'
+import { AgentForm } from '@/components/agents/agent-form'
+import { AgentTemplates } from '@/components/agents/agent-templates'
+import { AgentRunLog } from '@/components/agents/agent-run-log'
+import { AgentHelp } from '@/components/agents/agent-help'
+import {
+  createAgent,
+  updateAgent,
+  getAgents,
+} from '@/app/actions/agent-actions'
+
+// --- Types ---
+
+interface Notebook {
+  id: string
+  name: string
+  icon?: string | null
+}
+
+interface AgentItem {
+  id: string
+  name: string
+  description?: string | null
+  type?: string | null
+  role: string
+  sourceUrls?: string | null
+  sourceNotebookId?: string | null
+  targetNotebookId?: string | null
+  frequency: string
+  isEnabled: boolean
+  lastRun: string | Date | null
+  createdAt: string | Date
+  updatedAt: string | Date
+  tools?: string | null
+  maxSteps?: number
+  notifyEmail?: boolean
+  includeImages?: boolean
+  _count: { actions: number }
+  actions: { id: string; status: string; createdAt: string | Date }[]
+  notebook?: { id: string; name: string; icon?: string | null } | null
+}
+
+interface AgentsPageClientProps {
+  agents: AgentItem[]
+  notebooks: Notebook[]
+}
+
+const typeFilterOptions = [
+  { value: '', labelKey: 'agents.filterAll' },
+  { value: 'scraper', labelKey: 'agents.types.scraper' },
+  { value: 'researcher', labelKey: 'agents.types.researcher' },
+  { value: 'monitor', labelKey: 'agents.types.monitor' },
+  { value: 'custom', labelKey: 'agents.types.custom' },
+] as const
+
+// --- Component ---
+
+export function AgentsPageClient({
+  agents: initialAgents,
+  notebooks,
+}: AgentsPageClientProps) {
+  const { t } = useLanguage()
+  const [agents, setAgents] = useState(initialAgents)
+  const [showForm, setShowForm] = useState(false)
+  const [editingAgent, setEditingAgent] = useState<AgentItem | null>(null)
+  const [logAgent, setLogAgent] = useState<{ id: string; name: string } | null>(null)
+  const [showHelp, setShowHelp] = useState(false)
+  const [searchQuery, setSearchQuery] = useState('')
+  const [typeFilter, setTypeFilter] = useState('')
+
+  const refreshAgents = useCallback(async () => {
+    try {
+      const updated = await getAgents()
+      setAgents(updated)
+    } catch {
+      // Silent
+    }
+  }, [])
+
+  const handleToggle = useCallback((id: string, isEnabled: boolean) => {
+    setAgents(prev => prev.map(a => a.id === id ? { ...a, isEnabled } : a))
+  }, [])
+
+  const handleCreate = useCallback(() => {
+    setEditingAgent(null)
+    setShowForm(true)
+  }, [])
+
+  const handleEdit = useCallback((id: string) => {
+    const agent = agents.find(a => a.id === id)
+    if (agent) {
+      setEditingAgent(agent)
+      setShowForm(true)
+    }
+  }, [agents])
+
+  const handleSave = useCallback(async (formData: FormData) => {
+    const data = {
+      name: formData.get('name') as string,
+      description: (formData.get('description') as string) || undefined,
+      type: formData.get('type') as string,
+      role: formData.get('role') as string,
+      sourceUrls: formData.get('sourceUrls') ? JSON.parse(formData.get('sourceUrls') as string) : undefined,
+      sourceNotebookId: (formData.get('sourceNotebookId') as string) || undefined,
+      targetNotebookId: (formData.get('targetNotebookId') as string) || undefined,
+      frequency: formData.get('frequency') as string,
+      tools: formData.get('tools') ? JSON.parse(formData.get('tools') as string) : undefined,
+      maxSteps: formData.get('maxSteps') ? Number(formData.get('maxSteps')) : undefined,
+      notifyEmail: formData.get('notifyEmail') === 'true',
+      includeImages: formData.get('includeImages') === 'true',
+    }
+
+    if (editingAgent) {
+      await updateAgent(editingAgent.id, data)
+      toast.success(t('agents.toasts.updated'))
+    } else {
+      await createAgent(data)
+      toast.success(t('agents.toasts.created'))
+    }
+
+    setShowForm(false)
+    setEditingAgent(null)
+    await refreshAgents()
+  }, [editingAgent, refreshAgents, t])
+
+  const filteredAgents = useMemo(() => {
+    return agents.filter(agent => {
+      const matchesType = !typeFilter || (agent.type || 'scraper') === typeFilter
+      if (!searchQuery.trim()) return matchesType
+      const q = searchQuery.toLowerCase()
+      const matchesSearch =
+        (agent.name || '').toLowerCase().includes(q) ||
+        (agent.description && agent.description.toLowerCase().includes(q))
+      return matchesType && matchesSearch
+    })
+  }, [agents, searchQuery, typeFilter])
+
+  const existingAgentNames = useMemo(() => agents.map(a => a.name), [agents])
+
+  return (
+    <>
+      {/* Header */}
+      <div className="flex items-center justify-between gap-4 mb-8">
+        <div className="flex items-center gap-4">
+          <div className="p-3 bg-primary/10 rounded-2xl shadow-sm border border-primary/20">
+            <Bot className="h-8 w-8 text-primary" />
+          </div>
+          <div>
+            <h1 className="text-3xl font-bold tracking-tight">{t('agents.title')}</h1>
+            <p className="text-muted-foreground text-sm">{t('agents.subtitle')}</p>
+          </div>
+        </div>
+      </div>
+
+      {/* Action buttons */}
+      <div className="flex items-center justify-between mb-6">
+        <button
+          onClick={() => setShowHelp(true)}
+          className="flex items-center gap-2 px-4 py-2 text-sm font-medium text-primary bg-primary/10 border border-primary/20 rounded-lg hover:bg-primary/15 transition-colors"
+        >
+          <LifeBuoy className="w-4 h-4" />
+          {t('agents.help.btnLabel')}
+        </button>
+        <button
+          onClick={handleCreate}
+          className="flex items-center gap-2 px-4 py-2 text-sm font-medium text-white bg-primary rounded-lg hover:bg-primary/90 transition-colors"
+        >
+          <Plus className="w-4 h-4" />
+          {t('agents.newAgent')}
+        </button>
+      </div>
+
+      {/* Agents grid */}
+      {agents.length > 0 && (
+        <div className="mb-10">
+          <h3 className="text-sm font-semibold text-muted-foreground uppercase tracking-wider mb-3">
+            {t('agents.myAgents')}
+          </h3>
+
+          {/* Search and filter */}
+          <div className="flex flex-col sm:flex-row items-start sm:items-center gap-3 mb-4">
+            <div className="relative flex-1 w-full sm:max-w-xs">
+              <Search className="absolute left-3 top-1/2 -translate-y-1/2 w-4 h-4 text-muted-foreground" />
+              <input
+                type="text"
+                value={searchQuery}
+                onChange={e => setSearchQuery(e.target.value)}
+                placeholder={t('agents.searchPlaceholder')}
+                className="w-full pl-9 pr-3 py-2 text-sm bg-card border border-border rounded-lg outline-none focus:border-primary/40 focus:ring-2 focus:ring-primary/10 transition-all"
+              />
+            </div>
+            <div className="flex items-center gap-1.5 flex-wrap">
+              {typeFilterOptions.map(opt => (
+                <button
+                  key={opt.value}
+                  onClick={() => setTypeFilter(opt.value)}
+                  className={`px-3 py-1.5 text-xs font-medium rounded-full transition-colors ${
+                    typeFilter === opt.value
+                      ? 'bg-primary text-white'
+                      : 'bg-muted text-muted-foreground hover:bg-accent'
+                  }`}
+                >
+                  {t(opt.labelKey)}
+                </button>
+              ))}
+            </div>
+          </div>
+
+          {filteredAgents.length > 0 ? (
+            <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
+              {filteredAgents.map(agent => (
+                <AgentCard
+                  key={agent.id}
+                  agent={agent}
+                  onEdit={handleEdit}
+                  onRefresh={refreshAgents}
+                  onToggle={handleToggle}
+                />
+              ))}
+            </div>
+          ) : (
+            <div className="flex flex-col items-center justify-center py-12 text-center">
+              <Search className="w-10 h-10 text-muted-foreground/30 mb-3" />
+              <p className="text-sm text-muted-foreground">{t('agents.noResults')}</p>
+            </div>
+          )}
+        </div>
+      )}
+
+      {/* Empty state */}
+      {agents.length === 0 && (
+        <div className="flex flex-col items-center justify-center py-16 text-center mb-10">
+          <Bot className="w-16 h-16 text-muted-foreground/30 mb-4" />
+          <h3 className="text-lg font-medium text-muted-foreground mb-2">{t('agents.noAgents')}</h3>
+          <p className="text-sm text-muted-foreground max-w-sm">
+            {t('agents.noAgentsDescription')}
+          </p>
+        </div>
+      )}
+
+      {/* Templates */}
+      <AgentTemplates onInstalled={refreshAgents} existingAgentNames={existingAgentNames} />
+
+      {/* Form modal */}
+      {showForm && (
+        <AgentForm
+          agent={editingAgent}
+          notebooks={notebooks}
+          onSave={handleSave}
+          onCancel={() => { setShowForm(false); setEditingAgent(null) }}
+        />
+      )}
+
+      {/* Run log modal */}
+      {logAgent && (
+        <AgentRunLog
+          agentId={logAgent.id}
+          agentName={logAgent.name}
+          onClose={() => setLogAgent(null)}
+        />
+      )}
+
+      {/* Help modal */}
+      {showHelp && (
+        <AgentHelp onClose={() => setShowHelp(false)} />
+      )}
+    </>
+  )
+}

memento-note/app/(main)/agents/page.tsx

@@ -0,0 +1,33 @@
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+import { prisma } from '@/lib/prisma'
+import { getAgents } from '@/app/actions/agent-actions'
+import { AgentsPageClient } from './agents-page-client'
+
+export default async function AgentsPage() {
+  const session = await auth()
+  if (!session?.user?.id) redirect('/login')
+
+  const userId = session.user.id
+
+  const [agents, notebooks] = await Promise.all([
+    getAgents(),
+    prisma.notebook.findMany({
+      where: { userId },
+      orderBy: { order: 'asc' }
+    })
+  ])
+
+  return (
+    <div className="flex-1 flex flex-col h-full bg-background">
+      <div className="flex-1 p-8 overflow-y-auto">
+        <div className="max-w-6xl mx-auto">
+          <AgentsPageClient
+            agents={agents}
+            notebooks={notebooks}
+          />
+        </div>
+      </div>
+    </div>
+  )
+}

memento-note/app/(main)/archive/page.tsx

@@ -0,0 +1,16 @@
+import { getArchivedNotes } from '@/app/actions/notes'
+import { MasonryGrid } from '@/components/masonry-grid'
+import { ArchiveHeader } from '@/components/archive-header'
+
+export const dynamic = 'force-dynamic'
+
+export default async function ArchivePage() {
+  const notes = await getArchivedNotes()
+
+  return (
+    <main className="container mx-auto px-4 py-8 max-w-7xl">
+      <ArchiveHeader />
+      <MasonryGrid notes={notes} />
+    </main>
+  )
+}

memento-note/app/(main)/chat/page.tsx

@@ -0,0 +1,44 @@
+import { Metadata } from 'next'
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+import { prisma } from '@/lib/prisma'
+import { ChatContainer } from '@/components/chat/chat-container'
+import { getConversations } from '@/app/actions/chat-actions'
+import { getSystemConfig } from '@/lib/config'
+
+export const metadata: Metadata = {
+  title: 'Chat IA | Memento',
+  description: 'Discutez avec vos notes et vos agents IA',
+}
+
+export default async function ChatPage() {
+  const session = await auth()
+  if (!session?.user?.id) redirect('/login')
+
+  const userId = session.user.id
+
+  // Fetch initial data
+  const [conversations, notebooks, config] = await Promise.all([
+    getConversations(),
+    prisma.notebook.findMany({
+      where: { userId },
+      orderBy: { order: 'asc' }
+    }),
+    getSystemConfig(),
+  ])
+
+  // Check if web search tools are configured
+  const webSearchAvailable = !!(
+    config.WEB_SEARCH_PROVIDER || config.BRAVE_SEARCH_API_KEY || config.SEARXNG_URL || config.JINA_API_KEY
+  )
+
+  return (
+    <div className="flex-1 flex flex-col h-full bg-white dark:bg-[#1a1c22]">
+      <ChatContainer
+        initialConversations={conversations}
+        notebooks={notebooks}
+        webSearchAvailable={webSearchAvailable}
+      />
+    </div>
+  )
+}

memento-note/app/(main)/lab/page.tsx

@@ -0,0 +1,56 @@
+import { Metadata } from 'next'
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+import { getCanvases, createCanvas } from '@/app/actions/canvas-actions'
+import { LabHeader } from '@/components/lab/lab-header'
+import { CanvasWrapper } from '@/components/lab/canvas-wrapper'
+
+export const metadata: Metadata = {
+  title: 'Le Lab | Memento',
+  description: 'Visualisez et connectez vos idées sur un canvas interactif',
+}
+
+export const dynamic = 'force-dynamic'
+export const revalidate = 0
+
+export default async function LabPage(props: {
+  searchParams: Promise<{ id?: string }>
+}) {
+  const searchParams = await props.searchParams
+  const id = searchParams.id
+  
+  const session = await auth()
+  if (!session?.user?.id) redirect('/login')
+
+  const canvases = await getCanvases()
+  
+  // Resolve current canvas correctly
+  const currentCanvasId = searchParams.id || (canvases.length > 0 ? canvases[0].id : undefined)
+  const currentCanvas = currentCanvasId ? canvases.find(c => c.id === currentCanvasId) : undefined
+
+  // Wrapper for server action creation
+  async function handleCreate() {
+    'use server'
+    const newCanvas = await createCanvas()
+    redirect(`/lab?id=${newCanvas.id}`)
+  }
+
+  return (
+    <div className="flex-1 flex flex-col h-full bg-slate-50 dark:bg-[#1a1c22] overflow-hidden">
+      <LabHeader 
+        canvases={canvases} 
+        currentCanvasId={currentCanvasId ?? null} 
+        onCreateCanvas={handleCreate}
+      />
+
+      <div className="flex-1 relative">
+        <CanvasWrapper 
+          key={currentCanvasId || 'new'}
+          canvasId={currentCanvas?.id} 
+          name={currentCanvas?.name || "Nouvel Espace de Pensée"}
+          initialData={currentCanvas?.data}
+        />
+      </div>
+    </div>
+  )
+}

memento-note/app/(main)/layout.tsx

@@ -0,0 +1,41 @@
+import { HeaderWrapper } from "@/components/header-wrapper";
+import { Sidebar } from "@/components/sidebar";
+import { ProvidersWrapper } from "@/components/providers-wrapper";
+import { auth } from "@/auth";
+import { detectUserLanguage } from "@/lib/i18n/detect-user-language";
+import { loadTranslations } from "@/lib/i18n/load-translations";
+
+export default async function MainLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  // Run auth + language detection + translation loading in parallel
+  const [session, initialLanguage] = await Promise.all([
+    auth(),
+    detectUserLanguage(),
+  ]);
+
+  // Load initial translations server-side to prevent hydration mismatch
+  const initialTranslations = await loadTranslations(initialLanguage);
+
+  return (
+    <ProvidersWrapper initialLanguage={initialLanguage} initialTranslations={initialTranslations}>
+      <div className="bg-background-light dark:bg-background-dark font-display text-slate-900 dark:text-white overflow-hidden h-screen flex flex-col">
+        {/* Top Navigation - Style Keep */}
+        <HeaderWrapper user={session?.user} />
+
+        {/* Main Layout */}
+        <div className="flex flex-1 overflow-hidden">
+          {/* Sidebar Navigation - Style Keep */}
+          <Sidebar className="w-64 flex-none flex-col bg-white dark:bg-[#1e2128] border-e border-slate-200 dark:border-slate-800 overflow-y-auto hidden md:flex" user={session?.user} />
+
+          {/* Main Content Area */}
+          <main className="flex min-h-0 flex-1 flex-col overflow-y-auto bg-background-light dark:bg-background-dark p-4 scroll-smooth">
+            {children}
+          </main>
+        </div>
+      </div>
+    </ProvidersWrapper>
+  );
+}

memento-note/app/(main)/page.tsx

@@ -0,0 +1,27 @@
+import { getAllNotes } from '@/app/actions/notes'
+import { getAISettings } from '@/app/actions/ai-settings'
+import { HomeClient } from '@/components/home-client'
+
+export default async function HomePage() {
+  const [allNotes, settings] = await Promise.all([
+    getAllNotes(),
+    getAISettings(),
+  ])
+
+  const notesViewMode =
+    settings?.notesViewMode === 'masonry'
+      ? 'masonry' as const
+      : settings?.notesViewMode === 'tabs' || settings?.notesViewMode === 'list'
+        ? 'tabs' as const
+        : 'masonry' as const
+
+  return (
+    <HomeClient
+      initialNotes={allNotes}
+      initialSettings={{
+        showRecentNotes: settings?.showRecentNotes !== false,
+        notesViewMode,
+      }}
+    />
+  )
+}

memento-note/app/(main)/reminders/page.tsx

@@ -0,0 +1,9 @@
+import { getNotesWithReminders } from '@/app/actions/notes'
+import { RemindersPage } from '@/components/reminders-page'
+
+export const dynamic = 'force-dynamic'
+
+export default async function RemindersRoute() {
+  const notes = await getNotesWithReminders()
+  return <RemindersPage notes={notes} />
+}

memento-note/app/(main)/settings/about/page.tsx

@@ -0,0 +1,136 @@
+'use client'
+
+import { SettingsSection } from '@/components/settings'
+import { Card, CardContent } from '@/components/ui/card'
+import { Badge } from '@/components/ui/badge'
+import { useLanguage } from '@/lib/i18n'
+
+export default function AboutSettingsPage() {
+  const { t } = useLanguage()
+  const version = '1.0.0'
+  const buildDate = '2026-01-17'
+
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-3xl font-bold mb-2">{t('about.title')}</h1>
+        <p className="text-gray-600 dark:text-gray-400">
+          {t('about.description')}
+        </p>
+      </div>
+
+      <SettingsSection
+        title={t('about.appName')}
+        icon={<span className="text-2xl">📝</span>}
+        description={t('about.appDescription')}
+      >
+        <Card>
+          <CardContent className="pt-6 space-y-4">
+            <div className="flex justify-between items-center">
+              <span className="font-medium">{t('about.version')}</span>
+              <Badge variant="secondary">{version}</Badge>
+            </div>
+            <div className="flex justify-between items-center">
+              <span className="font-medium">{t('about.buildDate')}</span>
+              <Badge variant="outline">{buildDate}</Badge>
+            </div>
+            <div className="flex justify-between items-center">
+              <span className="font-medium">{t('about.platform')}</span>
+              <Badge variant="outline">{t('about.platformWeb')}</Badge>
+            </div>
+          </CardContent>
+        </Card>
+      </SettingsSection>
+
+      <SettingsSection
+        title={t('about.features.title')}
+        icon={<span className="text-2xl">✨</span>}
+        description={t('about.features.description')}
+      >
+        <Card>
+          <CardContent className="pt-6 space-y-2">
+            <div className="flex items-center gap-2">
+              <span className="text-green-500">✓</span>
+              <span>{t('about.features.titleSuggestions')}</span>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="text-green-500">✓</span>
+              <span>{t('about.features.semanticSearch')}</span>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="text-green-500">✓</span>
+              <span>{t('about.features.paragraphReformulation')}</span>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="text-green-500">✓</span>
+              <span>{t('about.features.memoryEcho')}</span>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="text-green-500">✓</span>
+              <span>{t('about.features.notebookOrganization')}</span>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="text-green-500">✓</span>
+              <span>{t('about.features.dragDrop')}</span>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="text-green-500">✓</span>
+              <span>{t('about.features.labelSystem')}</span>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="text-green-500">✓</span>
+              <span>{t('about.features.multipleProviders')}</span>
+            </div>
+          </CardContent>
+        </Card>
+      </SettingsSection>
+
+      <SettingsSection
+        title={t('about.technology.title')}
+        icon={<span className="text-2xl">⚙️</span>}
+        description={t('about.technology.description')}
+      >
+        <Card>
+          <CardContent className="pt-6 space-y-2 text-sm">
+            <div><strong>{t('about.technology.frontend')}:</strong> Next.js 16, React 19, TypeScript</div>
+            <div><strong>{t('about.technology.backend')}:</strong> Next.js API Routes, Server Actions</div>
+            <div><strong>{t('about.technology.database')}:</strong> SQLite (Prisma ORM)</div>
+            <div><strong>{t('about.technology.authentication')}:</strong> NextAuth 5</div>
+            <div><strong>{t('about.technology.ai')}:</strong> Vercel AI SDK, OpenAI, Ollama</div>
+            <div><strong>{t('about.technology.ui')}:</strong> Radix UI, Tailwind CSS, Lucide Icons</div>
+            <div><strong>{t('about.technology.testing')}:</strong> Playwright (E2E)</div>
+          </CardContent>
+        </Card>
+      </SettingsSection>
+
+      <SettingsSection
+        title={t('about.support.title')}
+        icon={<span className="text-2xl">💬</span>}
+        description={t('about.support.description')}
+      >
+        <Card>
+          <CardContent className="pt-6 space-y-4">
+            <div>
+              <p className="font-medium mb-2">{t('about.support.documentation')}</p>
+              <p className="text-sm text-gray-600 dark:text-gray-400">
+                Check the documentation for detailed guides and tutorials.
+              </p>
+            </div>
+            <div>
+              <p className="font-medium mb-2">{t('about.support.reportIssues')}</p>
+              <p className="text-sm text-gray-600 dark:text-gray-400">
+                Found a bug? Report it in the issue tracker.
+              </p>
+            </div>
+            <div>
+              <p className="font-medium mb-2">{t('about.support.feedback')}</p>
+              <p className="text-sm text-gray-600 dark:text-gray-400">
+                We value your feedback! Share your thoughts and suggestions.
+              </p>
+            </div>
+          </CardContent>
+        </Card>
+      </SettingsSection>
+    </div>
+  )
+}

memento-note/app/(main)/settings/ai/ai-settings-header.tsx

@@ -0,0 +1,16 @@
+'use client'
+
+import { useLanguage } from '@/lib/i18n'
+
+export function AISettingsHeader() {
+  const { t } = useLanguage()
+
+  return (
+    <div className="mb-6">
+      <h1 className="text-3xl font-bold">{t('aiSettings.title')}</h1>
+      <p className="text-gray-600 dark:text-gray-400">
+        {t('aiSettings.description')}
+      </p>
+    </div>
+  )
+}

memento-note/app/(main)/settings/ai/page-new.tsx

@@ -0,0 +1,184 @@
+'use client'
+
+import { useState } from 'react'
+import { SettingsNav, SettingsSection, SettingToggle, SettingSelect, SettingInput } from '@/components/settings'
+import { updateAISettings } from '@/app/actions/ai-settings'
+import { toast } from 'sonner'
+import { useLanguage } from '@/lib/i18n'
+
+export default function AISettingsPage() {
+  const { t } = useLanguage()
+  const [apiKey, setApiKey] = useState('')
+
+  // Mock settings state - in real implementation, load from server
+  const [settings, setSettings] = useState({
+    titleSuggestions: true,
+    semanticSearch: true,
+    paragraphRefactor: true,
+    memoryEcho: true,
+    memoryEchoFrequency: 'daily' as 'daily' | 'weekly' | 'custom',
+    aiProvider: 'auto' as 'auto' | 'openai' | 'ollama',
+    preferredLanguage: 'auto' as 'auto' | 'en' | 'fr' | 'es' | 'de' | 'fa' | 'it' | 'pt' | 'ru' | 'zh' | 'ja' | 'ko' | 'ar' | 'hi' | 'nl' | 'pl',
+    demoMode: false
+  })
+
+  const handleToggle = async (feature: string, value: boolean) => {
+    setSettings(prev => ({ ...prev, [feature]: value }))
+    try {
+      await updateAISettings({ [feature]: value })
+    } catch (error) {
+      toast.error(t('aiSettings.error'))
+      setSettings(settings) // Revert on error
+    }
+  }
+
+  const handleFrequencyChange = async (value: string) => {
+    setSettings(prev => ({ ...prev, memoryEchoFrequency: value as any }))
+    try {
+      await updateAISettings({ memoryEchoFrequency: value as any })
+    } catch (error) {
+      toast.error(t('aiSettings.error'))
+    }
+  }
+
+  const handleProviderChange = async (value: string) => {
+    setSettings(prev => ({ ...prev, aiProvider: value as any }))
+    try {
+      await updateAISettings({ aiProvider: value as any })
+    } catch (error) {
+      toast.error(t('aiSettings.error'))
+    }
+  }
+
+  const handleApiKeyChange = async (value: string) => {
+    setApiKey(value)
+    // TODO: Implement API key persistence
+
+  }
+
+  return (
+    <div className="container mx-auto py-10 px-4 max-w-6xl">
+      <div className="grid grid-cols-1 lg:grid-cols-4 gap-6">
+        {/* Sidebar Navigation */}
+        <aside className="lg:col-span-1">
+          <SettingsNav />
+        </aside>
+
+        {/* Main Content */}
+        <main className="lg:col-span-3 space-y-6">
+          <div>
+            <h1 className="text-3xl font-bold mb-2">{t('aiSettings.title')}</h1>
+            <p className="text-gray-600 dark:text-gray-400">
+              {t('aiSettings.description')}
+            </p>
+          </div>
+
+          {/* AI Provider */}
+          <SettingsSection
+            title={t('aiSettings.provider')}
+            icon={<span className="text-2xl">🤖</span>}
+            description={t('aiSettings.providerDesc')}
+          >
+            <SettingSelect
+              label={t('aiSettings.provider')}
+              description={t('aiSettings.providerDesc')}
+              value={settings.aiProvider}
+              options={[
+                {
+                  value: 'auto',
+                  label: t('aiSettings.providerAuto'),
+                  description: t('aiSettings.providerAutoDesc')
+                },
+                {
+                  value: 'ollama',
+                  label: t('aiSettings.providerOllama'),
+                  description: t('aiSettings.providerOllamaDesc')
+                },
+                {
+                  value: 'openai',
+                  label: t('aiSettings.providerOpenAI'),
+                  description: t('aiSettings.providerOpenAIDesc')
+                },
+              ]}
+              onChange={handleProviderChange}
+            />
+
+            {settings.aiProvider === 'openai' && (
+              <SettingInput
+                label={t('admin.ai.apiKey')}
+                description={t('admin.ai.openAIKeyDescription')}
+                value={apiKey}
+                type="password"
+                placeholder="sk-..."
+                onChange={handleApiKeyChange}
+              />
+            )}
+          </SettingsSection>
+
+          {/* Feature Toggles */}
+          <SettingsSection
+            title={t('aiSettings.features')}
+            icon={<span className="text-2xl">✨</span>}
+            description={t('aiSettings.description')}
+          >
+            <SettingToggle
+              label={t('titleSuggestions.available').replace('💡 ', '')}
+              description={t('aiSettings.titleSuggestionsDesc')}
+              checked={settings.titleSuggestions}
+              onChange={(checked) => handleToggle('titleSuggestions', checked)}
+            />
+
+            <SettingToggle
+              label={t('semanticSearch.exactMatch')}
+              description={t('semanticSearch.searching')}
+              checked={settings.semanticSearch}
+              onChange={(checked) => handleToggle('semanticSearch', checked)}
+            />
+
+            <SettingToggle
+              label={t('paragraphRefactor.title')}
+              description={t('aiSettings.paragraphRefactorDesc')}
+              checked={settings.paragraphRefactor}
+              onChange={(checked) => handleToggle('paragraphRefactor', checked)}
+            />
+
+            <SettingToggle
+              label={t('memoryEcho.title')}
+              description={t('memoryEcho.dailyInsight')}
+              checked={settings.memoryEcho}
+              onChange={(checked) => handleToggle('memoryEcho', checked)}
+            />
+
+            {settings.memoryEcho && (
+              <SettingSelect
+                label={t('aiSettings.frequency')}
+                description={t('aiSettings.frequencyDesc')}
+                value={settings.memoryEchoFrequency}
+                options={[
+                  { value: 'daily', label: t('aiSettings.frequencyDaily') },
+                  { value: 'weekly', label: t('aiSettings.frequencyWeekly') },
+                  { value: 'custom', label: 'Custom' },
+                ]}
+                onChange={handleFrequencyChange}
+              />
+            )}
+          </SettingsSection>
+
+          {/* Demo Mode */}
+          <SettingsSection
+            title={t('demoMode.title')}
+            icon={<span className="text-2xl">🎭</span>}
+            description={t('demoMode.description')}
+          >
+            <SettingToggle
+              label={t('demoMode.title')}
+              description={t('demoMode.description')}
+              checked={settings.demoMode}
+              onChange={(checked) => handleToggle('demoMode', checked)}
+            />
+          </SettingsSection>
+        </main>
+      </div>
+    </div>
+  )
+}

memento-note/app/(main)/settings/ai/page.tsx

@@ -0,0 +1,22 @@
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+import { AISettingsPanel } from '@/components/ai/ai-settings-panel'
+import { getAISettings } from '@/app/actions/ai-settings'
+import { AISettingsHeader } from './ai-settings-header'
+
+export default async function AISettingsPage() {
+  const session = await auth()
+
+  if (!session?.user) {
+    redirect('/api/auth/signin')
+  }
+
+  const settings = await getAISettings()
+
+  return (
+    <div className="space-y-6">
+      <AISettingsHeader />
+      <AISettingsPanel initialSettings={settings} />
+    </div>
+  )
+}

memento-note/app/(main)/settings/appearance/appearance-form.tsx

@@ -0,0 +1,132 @@
+'use client'
+
+import { useRouter } from 'next/navigation'
+import { useState } from 'react'
+import { SettingsSection, SettingSelect } from '@/components/settings'
+import { updateAISettings as updateAI } from '@/app/actions/ai-settings'
+import { updateUserSettings as updateUser } from '@/app/actions/user-settings'
+import { useLanguage } from '@/lib/i18n'
+
+interface AppearanceSettingsFormProps {
+    initialTheme: string
+    initialFontSize: string
+    initialCardSizeMode?: string
+}
+
+export function AppearanceSettingsForm({ initialTheme, initialFontSize, initialCardSizeMode = 'variable' }: AppearanceSettingsFormProps) {
+    const router = useRouter()
+    const [theme, setTheme] = useState(initialTheme)
+    const [fontSize, setFontSize] = useState(initialFontSize)
+    const [cardSizeMode, setCardSizeMode] = useState(initialCardSizeMode)
+    const { t } = useLanguage()
+
+    const handleThemeChange = async (value: string) => {
+        setTheme(value)
+        localStorage.setItem('theme-preference', value)
+
+        // Instant visual update
+        const root = document.documentElement
+        root.removeAttribute('data-theme')
+        root.classList.remove('dark')
+
+        if (value === 'auto') {
+            if (window.matchMedia('(prefers-color-scheme: dark)').matches) root.classList.add('dark')
+        } else if (value === 'dark') {
+            root.classList.add('dark')
+        } else if (value === 'light') {
+            root.setAttribute('data-theme', 'light')
+        } else {
+            root.setAttribute('data-theme', value)
+            if (['midnight', 'blue', 'sepia'].includes(value)) root.classList.add('dark')
+        }
+
+        // Save to DB (no need for router.refresh - localStorage handles immediate visuals)
+        await updateUser({ theme: value as 'light' | 'dark' | 'auto' | 'sepia' | 'midnight' | 'blue' })
+    }
+
+    const handleFontSizeChange = async (value: string) => {
+        setFontSize(value)
+
+        // Instant visual update
+        const fontSizeMap: Record<string, string> = {
+            'small': '14px', 'medium': '16px', 'large': '18px', 'extra-large': '20px'
+        }
+        const root = document.documentElement
+        root.style.setProperty('--user-font-size', fontSizeMap[value] || '16px')
+
+        await updateAI({ fontSize: value as any })
+    }
+
+    const handleCardSizeModeChange = async (value: string) => {
+        setCardSizeMode(value)
+        localStorage.setItem('card-size-mode', value)
+        await updateUser({ cardSizeMode: value as 'variable' | 'uniform' })
+    }
+
+    return (
+        <div className="space-y-6">
+            <div>
+                <h1 className="text-3xl font-bold mb-2">{t('appearance.title')}</h1>
+                <p className="text-gray-600 dark:text-gray-400">
+                    {t('appearance.description')}
+                </p>
+            </div>
+
+            <SettingsSection
+                title={t('settings.theme')}
+                icon={<span className="text-2xl">🎨</span>}
+                description={t('settings.themeLight') + ' / ' + t('settings.themeDark')}
+            >
+                <SettingSelect
+                    label={t('settings.theme')}
+                    description={t('settings.selectLanguage')}
+                    value={theme}
+                    options={[
+                        { value: 'slate', label: t('settings.themeLight') },
+                        { value: 'dark', label: t('settings.themeDark') },
+                        { value: 'sepia', label: 'Sepia' },
+                        { value: 'midnight', label: 'Midnight' },
+                        { value: 'blue', label: 'Blue' },
+                        { value: 'auto', label: t('settings.themeSystem') },
+                    ]}
+                    onChange={handleThemeChange}
+                />
+            </SettingsSection>
+
+            <SettingsSection
+                title={t('profile.fontSize')}
+                icon={<span className="text-2xl">📝</span>}
+                description={t('profile.fontSizeDescription')}
+            >
+                <SettingSelect
+                    label={t('profile.fontSize')}
+                    description={t('profile.selectFontSize')}
+                    value={fontSize}
+                    options={[
+                        { value: 'small', label: t('profile.fontSizeSmall') },
+                        { value: 'medium', label: t('profile.fontSizeMedium') },
+                        { value: 'large', label: t('profile.fontSizeLarge') },
+                    ]}
+                    onChange={handleFontSizeChange}
+                />
+            </SettingsSection>
+
+            <SettingsSection
+                title={t('settings.cardSizeMode')}
+                icon={<span className="text-2xl">📐</span>}
+                description={t('settings.cardSizeModeDescription')}
+            >
+                <SettingSelect
+                    label={t('settings.cardSizeMode')}
+                    description={t('settings.selectCardSizeMode')}
+                    value={cardSizeMode}
+                    options={[
+                        { value: 'variable', label: t('settings.cardSizeVariable') },
+                        { value: 'uniform', label: t('settings.cardSizeUniform') },
+                    ]}
+                    onChange={handleCardSizeModeChange}
+                />
+            </SettingsSection>
+        </div>
+    )
+}

memento-note/app/(main)/settings/appearance/appearance-settings-client.tsx

@@ -0,0 +1,154 @@
+'use client'
+
+import { useState } from 'react'
+import { SettingsSection, SettingSelect } from '@/components/settings'
+import { updateAISettings } from '@/app/actions/ai-settings'
+import { updateUserSettings } from '@/app/actions/user-settings'
+import { useLanguage } from '@/lib/i18n'
+import { toast } from 'sonner'
+
+interface AppearanceSettingsClientProps {
+  initialFontSize: string
+  initialTheme: string
+  initialNotesViewMode: 'masonry' | 'tabs'
+  initialCardSizeMode?: 'variable' | 'uniform'
+}
+
+export function AppearanceSettingsClient({ initialFontSize, initialTheme, initialNotesViewMode, initialCardSizeMode = 'variable' }: AppearanceSettingsClientProps) {
+  const { t } = useLanguage()
+  const [theme, setTheme] = useState(initialTheme || 'light')
+  const [fontSize, setFontSize] = useState(initialFontSize || 'medium')
+  const [notesViewMode, setNotesViewMode] = useState<'masonry' | 'tabs'>(initialNotesViewMode)
+  const [cardSizeMode, setCardSizeMode] = useState<'variable' | 'uniform'>(initialCardSizeMode)
+
+  const handleThemeChange = async (value: string) => {
+    setTheme(value)
+    localStorage.setItem('theme-preference', value)
+
+    const root = document.documentElement
+    root.removeAttribute('data-theme')
+    root.classList.remove('dark')
+
+    if (value === 'auto') {
+      if (window.matchMedia('(prefers-color-scheme: dark)').matches) root.classList.add('dark')
+    } else if (value === 'dark') {
+      root.classList.add('dark')
+    } else {
+      root.setAttribute('data-theme', value)
+      if (['midnight'].includes(value)) root.classList.add('dark')
+    }
+
+    await updateUserSettings({ theme: value as 'light' | 'dark' | 'auto' })
+    toast.success(t('settings.settingsSaved') || 'Saved')
+  }
+
+  const handleFontSizeChange = async (value: string) => {
+    setFontSize(value)
+
+    const fontSizeMap: Record<string, string> = {
+      'small': '14px', 'medium': '16px', 'large': '18px', 'extra-large': '20px'
+    }
+    document.documentElement.style.setProperty('--user-font-size', fontSizeMap[value] || '16px')
+
+    await updateAISettings({ fontSize: value as any })
+    toast.success(t('settings.settingsSaved') || 'Saved')
+  }
+
+  const handleNotesViewChange = async (value: string) => {
+    const mode = value === 'tabs' ? 'tabs' : 'masonry'
+    setNotesViewMode(mode)
+    await updateAISettings({ notesViewMode: mode })
+    toast.success(t('settings.settingsSaved') || 'Saved')
+  }
+
+  const handleCardSizeModeChange = async (value: string) => {
+    const mode = value === 'uniform' ? 'uniform' : 'variable'
+    setCardSizeMode(mode)
+    localStorage.setItem('card-size-mode', mode)
+    await updateUserSettings({ cardSizeMode: mode })
+    toast.success(t('settings.settingsSaved') || 'Saved')
+  }
+
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-3xl font-bold mb-2">{t('appearance.title')}</h1>
+        <p className="text-gray-600 dark:text-gray-400">
+          {t('appearance.description')}
+        </p>
+      </div>
+
+      <SettingsSection
+        title={t('settings.theme')}
+        icon={<span className="text-2xl">🎨</span>}
+        description={t('settings.themeLight') + ' / ' + t('settings.themeDark')}
+      >
+        <SettingSelect
+          label={t('settings.theme')}
+          description={t('appearance.selectTheme')}
+          value={theme}
+          options={[
+            { value: 'light', label: t('settings.themeLight') },
+            { value: 'dark', label: t('settings.themeDark') },
+            { value: 'sepia', label: 'Sepia' },
+            { value: 'midnight', label: 'Midnight' },
+            { value: 'auto', label: t('settings.themeSystem') },
+          ]}
+          onChange={handleThemeChange}
+        />
+      </SettingsSection>
+
+      <SettingsSection
+        title={t('profile.fontSize')}
+        icon={<span className="text-2xl">📝</span>}
+        description={t('profile.fontSizeDescription')}
+      >
+        <SettingSelect
+          label={t('profile.fontSize')}
+          description={t('profile.selectFontSize')}
+          value={fontSize}
+          options={[
+            { value: 'small', label: t('profile.fontSizeSmall') },
+            { value: 'medium', label: t('profile.fontSizeMedium') },
+            { value: 'large', label: t('profile.fontSizeLarge') },
+          ]}
+          onChange={handleFontSizeChange}
+        />
+      </SettingsSection>
+
+      <SettingsSection
+        title={t('appearance.notesViewLabel')}
+        icon={<span className="text-2xl">📋</span>}
+        description={t('appearance.notesViewDescription')}
+      >
+        <SettingSelect
+          label={t('appearance.notesViewLabel')}
+          description={t('appearance.notesViewDescription')}
+          value={notesViewMode}
+          options={[
+            { value: 'masonry', label: t('appearance.notesViewMasonry') },
+            { value: 'tabs', label: t('appearance.notesViewTabs') },
+          ]}
+          onChange={handleNotesViewChange}
+        />
+      </SettingsSection>
+
+      <SettingsSection
+        title={t('settings.cardSizeMode')}
+        icon={<span className="text-2xl">📐</span>}
+        description={t('settings.cardSizeModeDescription')}
+      >
+        <SettingSelect
+          label={t('settings.cardSizeMode')}
+          description={t('settings.selectCardSizeMode')}
+          value={cardSizeMode}
+          options={[
+            { value: 'variable', label: t('settings.cardSizeVariable') },
+            { value: 'uniform', label: t('settings.cardSizeUniform') },
+          ]}
+          onChange={handleCardSizeModeChange}
+        />
+      </SettingsSection>
+    </div>
+  )
+}

memento-note/app/(main)/settings/appearance/page.tsx

@@ -0,0 +1,26 @@
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+import { getAISettings } from '@/app/actions/ai-settings'
+import { getUserSettings } from '@/app/actions/user-settings'
+import { AppearanceSettingsClient } from './appearance-settings-client'
+
+export default async function AppearanceSettingsPage() {
+  const session = await auth()
+  if (!session?.user) {
+    redirect('/api/auth/signin')
+  }
+
+  const [aiSettings, userSettings] = await Promise.all([
+    getAISettings(),
+    getUserSettings()
+  ])
+
+  return (
+    <AppearanceSettingsClient
+      initialFontSize={aiSettings.fontSize}
+      initialTheme={userSettings.theme}
+      initialNotesViewMode={aiSettings.notesViewMode === 'masonry' ? 'masonry' : 'tabs'}
+      initialCardSizeMode={userSettings.cardSizeMode}
+    />
+  )
+}

memento-note/app/(main)/settings/data/page.tsx

@@ -0,0 +1,191 @@
+'use client'
+
+import { useState } from 'react'
+import { SettingsSection } from '@/components/settings'
+import { Button } from '@/components/ui/button'
+import { Download, Upload, Trash2, Loader2 } from 'lucide-react'
+import { toast } from 'sonner'
+import { useLanguage } from '@/lib/i18n'
+import { useRouter } from 'next/navigation'
+
+export default function DataSettingsPage() {
+  const { t } = useLanguage()
+  const router = useRouter()
+  const [isExporting, setIsExporting] = useState(false)
+  const [isImporting, setIsImporting] = useState(false)
+  const [isDeleting, setIsDeleting] = useState(false)
+
+  const handleExport = async () => {
+    setIsExporting(true)
+    try {
+      const response = await fetch('/api/notes/export')
+      if (response.ok) {
+        const blob = await response.blob()
+        const url = window.URL.createObjectURL(blob)
+        const a = document.createElement('a')
+        a.href = url
+        a.download = `memento-note-export-${new Date().toISOString().split('T')[0]}.json`
+        document.body.appendChild(a)
+        a.click()
+        document.body.removeChild(a)
+        window.URL.revokeObjectURL(url)
+        toast.success(t('dataManagement.export.success'))
+      }
+    } catch (error) {
+      console.error('Export error:', error)
+      toast.error(t('dataManagement.export.failed'))
+    } finally {
+      setIsExporting(false)
+    }
+  }
+
+  const handleImport = async (event: React.ChangeEvent<HTMLInputElement>) => {
+    const file = event.target.files?.[0]
+    if (!file) return
+
+    setIsImporting(true)
+    try {
+      const formData = new FormData()
+      formData.append('file', file)
+
+      const response = await fetch('/api/notes/import', {
+        method: 'POST',
+        body: formData
+      })
+
+      if (response.ok) {
+        const result = await response.json()
+        toast.success(t('dataManagement.import.success', { count: result.count }))
+        router.refresh()
+      } else {
+        throw new Error('Import failed')
+      }
+    } catch (error) {
+      console.error('Import error:', error)
+      toast.error(t('dataManagement.import.failed'))
+    } finally {
+      setIsImporting(false)
+      event.target.value = ''
+    }
+  }
+
+  const handleDeleteAll = async () => {
+    if (!confirm(t('dataManagement.delete.confirm'))) {
+      return
+    }
+
+    setIsDeleting(true)
+    try {
+      const response = await fetch('/api/notes/delete-all', { method: 'POST' })
+      if (response.ok) {
+        toast.success(t('dataManagement.delete.success'))
+        router.refresh()
+      }
+    } catch (error) {
+      console.error('Delete error:', error)
+      toast.error(t('dataManagement.delete.failed'))
+    } finally {
+      setIsDeleting(false)
+    }
+  }
+
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-3xl font-bold mb-2">{t('dataManagement.title')}</h1>
+        <p className="text-gray-600 dark:text-gray-400">
+          {t('dataManagement.toolsDescription')}
+        </p>
+      </div>
+
+      <SettingsSection
+        title={`💾 ${t('dataManagement.export.title')}`}
+        icon={<span className="text-2xl">💾</span>}
+        description={t('dataManagement.export.description')}
+      >
+        <div className="flex items-center justify-between py-4">
+          <div>
+            <p className="font-medium">{t('dataManagement.export.title')}</p>
+            <p className="text-sm text-gray-600 dark:text-gray-400">
+              {t('dataManagement.export.description')}
+            </p>
+          </div>
+          <Button
+            onClick={handleExport}
+            disabled={isExporting}
+          >
+            {isExporting ? (
+              <Loader2 className="h-4 w-4 animate-spin mr-2" />
+            ) : (
+              <Download className="h-4 w-4 mr-2" />
+            )}
+            {isExporting ? t('dataManagement.exporting') : t('dataManagement.export.button')}
+          </Button>
+        </div>
+      </SettingsSection>
+
+      <SettingsSection
+        title={`📥 ${t('dataManagement.import.title')}`}
+        icon={<span className="text-2xl">📥</span>}
+        description={t('dataManagement.import.description')}
+      >
+        <div className="flex items-center justify-between py-4">
+          <div>
+            <p className="font-medium">{t('dataManagement.import.title')}</p>
+            <p className="text-sm text-gray-600 dark:text-gray-400">
+              {t('dataManagement.import.description')}
+            </p>
+          </div>
+          <div>
+            <input
+              type="file"
+              accept=".json"
+              onChange={handleImport}
+              disabled={isImporting}
+              className="hidden"
+              id="import-file"
+            />
+            <Button
+              onClick={() => document.getElementById('import-file')?.click()}
+              disabled={isImporting}
+            >
+              {isImporting ? (
+                <Loader2 className="h-4 w-4 animate-spin mr-2" />
+              ) : (
+                <Upload className="h-4 w-4 mr-2" />
+              )}
+              {isImporting ? t('dataManagement.importing') : t('dataManagement.import.button')}
+            </Button>
+          </div>
+        </div>
+      </SettingsSection>
+
+      <SettingsSection
+        title={`⚠️ ${t('dataManagement.dangerZone')}`}
+        icon={<span className="text-2xl">⚠️</span>}
+        description={t('dataManagement.dangerZoneDescription')}
+      >
+        <div className="flex items-center justify-between py-4 border-t border-red-200 dark:border-red-900">
+          <div>
+            <p className="font-medium text-red-600 dark:text-red-400">{t('dataManagement.delete.title')}</p>
+            <p className="text-sm text-gray-600 dark:text-gray-400">
+              {t('dataManagement.delete.description')}
+            </p>
+          </div>
+          <Button
+            variant="destructive"
+            onClick={handleDeleteAll}
+            disabled={isDeleting}
+          >
+            {isDeleting ? (
+              <Loader2 className="h-4 w-4 animate-spin mr-2" />
+            ) : (
+              <Trash2 className="h-4 w-4 mr-2" />
+            )}
+            {isDeleting ? t('dataManagement.deleting') : t('dataManagement.delete.button')}
+          </Button>
+        </div>
+      </SettingsSection>
+    </div>
+  )
+}

memento-note/app/(main)/settings/general/general-settings-client.tsx

@@ -0,0 +1,113 @@
+'use client'
+
+import { useState } from 'react'
+import { SettingsSection, SettingToggle, SettingSelect } from '@/components/settings'
+import { useLanguage } from '@/lib/i18n'
+import { updateAISettings } from '@/app/actions/ai-settings'
+import { toast } from 'sonner'
+import { useRouter } from 'next/navigation'
+
+interface GeneralSettingsClientProps {
+  initialSettings: {
+    preferredLanguage: string
+    emailNotifications: boolean
+    desktopNotifications: boolean
+  }
+}
+
+export function GeneralSettingsClient({ initialSettings }: GeneralSettingsClientProps) {
+  const { t, setLanguage: setContextLanguage } = useLanguage()
+  const router = useRouter()
+  const [language, setLanguage] = useState(initialSettings.preferredLanguage || 'auto')
+  const [emailNotifications, setEmailNotifications] = useState(initialSettings.emailNotifications ?? false)
+  const [desktopNotifications, setDesktopNotifications] = useState(initialSettings.desktopNotifications ?? false)
+
+  const handleLanguageChange = async (value: string) => {
+    setLanguage(value)
+    await updateAISettings({ preferredLanguage: value as any })
+
+    if (value === 'auto') {
+      localStorage.removeItem('user-language')
+      toast.success(t('settings.languageAuto') || 'Language set to Auto')
+    } else {
+      localStorage.setItem('user-language', value)
+      setContextLanguage(value as any)
+      toast.success(t('profile.languageUpdateSuccess') || 'Language updated')
+    }
+
+    setTimeout(() => router.refresh(), 300)
+  }
+
+  const handleEmailNotificationsChange = async (enabled: boolean) => {
+    setEmailNotifications(enabled)
+    await updateAISettings({ emailNotifications: enabled })
+    toast.success(t('settings.settingsSaved') || 'Saved')
+  }
+
+  const handleDesktopNotificationsChange = async (enabled: boolean) => {
+    setDesktopNotifications(enabled)
+    await updateAISettings({ desktopNotifications: enabled })
+    toast.success(t('settings.settingsSaved') || 'Saved')
+  }
+
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-3xl font-bold mb-2">{t('generalSettings.title')}</h1>
+        <p className="text-gray-600 dark:text-gray-400">
+          {t('generalSettings.description')}
+        </p>
+      </div>
+
+      <SettingsSection
+        title={t('settings.language')}
+        icon={<span className="text-2xl">🌍</span>}
+        description={t('profile.languagePreferencesDescription')}
+      >
+        <SettingSelect
+          label={t('settings.language')}
+          description={t('settings.selectLanguage')}
+          value={language}
+          options={[
+            { value: 'auto', label: t('profile.autoDetect') },
+            { value: 'en', label: 'English' },
+            { value: 'fr', label: 'Français' },
+            { value: 'es', label: 'Español' },
+            { value: 'de', label: 'Deutsch' },
+            { value: 'fa', label: 'فارسی' },
+            { value: 'it', label: 'Italiano' },
+            { value: 'pt', label: 'Português' },
+            { value: 'ru', label: 'Русский' },
+            { value: 'zh', label: '中文' },
+            { value: 'ja', label: '日本語' },
+            { value: 'ko', label: '한국어' },
+            { value: 'ar', label: 'العربية' },
+            { value: 'hi', label: 'हिन्दी' },
+            { value: 'nl', label: 'Nederlands' },
+            { value: 'pl', label: 'Polski' },
+          ]}
+          onChange={handleLanguageChange}
+        />
+      </SettingsSection>
+
+      <SettingsSection
+        title={t('settings.notifications')}
+        icon={<span className="text-2xl">🔔</span>}
+        description={t('settings.notificationsDesc')}
+      >
+        <SettingToggle
+          label={t('settings.emailNotifications')}
+          description={t('settings.emailNotificationsDesc')}
+          checked={emailNotifications}
+          onChange={handleEmailNotificationsChange}
+        />
+        <SettingToggle
+          label={t('settings.desktopNotifications')}
+          description={t('settings.desktopNotificationsDesc')}
+          checked={desktopNotifications}
+          onChange={handleDesktopNotificationsChange}
+        />
+      </SettingsSection>
+    </div>
+  )
+}

memento-note/app/(main)/settings/general/page.tsx

@@ -0,0 +1,15 @@
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+import { getAISettings } from '@/app/actions/ai-settings'
+import { GeneralSettingsClient } from './general-settings-client'
+
+export default async function GeneralSettingsPage() {
+  const session = await auth()
+  if (!session?.user) {
+    redirect('/api/auth/signin')
+  }
+
+  const settings = await getAISettings()
+
+  return <GeneralSettingsClient initialSettings={settings} />
+}

memento-note/app/(main)/settings/layout.tsx

@@ -0,0 +1,25 @@
+'use client'
+
+import { SettingsNav } from '@/components/settings'
+
+export default function SettingsLayout({
+    children,
+}: {
+    children: React.ReactNode
+}) {
+    return (
+        <div className="container mx-auto py-10 px-4 max-w-6xl">
+            <div className="grid grid-cols-1 lg:grid-cols-4 gap-6">
+                {/* Sidebar Navigation */}
+                <aside className="lg:col-span-1">
+                    <SettingsNav />
+                </aside>
+
+                {/* Main Content */}
+                <main className="lg:col-span-3 space-y-6">
+                    {children}
+                </main>
+            </div>
+        </div>
+    )
+}

memento-note/app/(main)/settings/loading.tsx

@@ -0,0 +1,26 @@
+export default function SettingsLoading() {
+  return (
+    <div className="space-y-6 animate-pulse">
+      <div>
+        <div className="h-9 w-64 bg-muted rounded-md mb-2" />
+        <div className="h-4 w-96 bg-muted rounded-md" />
+      </div>
+      {[1, 2, 3].map((i) => (
+        <div key={i} className="rounded-lg border border-border p-6 space-y-4">
+          <div className="flex items-center gap-3">
+            <div className="h-8 w-8 bg-muted rounded-full" />
+            <div className="h-5 w-40 bg-muted rounded-md" />
+          </div>
+          <div className="h-px bg-border" />
+          <div className="flex items-center justify-between p-4 rounded-lg bg-muted/30">
+            <div className="space-y-2">
+              <div className="h-4 w-32 bg-muted rounded" />
+              <div className="h-3 w-56 bg-muted rounded" />
+            </div>
+            <div className="h-6 w-11 bg-muted rounded-full" />
+          </div>
+        </div>
+      ))}
+    </div>
+  )
+}

memento-note/app/(main)/settings/mcp/page.tsx

@@ -0,0 +1,23 @@
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+import { McpSettingsPanel } from '@/components/mcp/mcp-settings-panel'
+import { listMcpKeys, getMcpServerStatus } from '@/app/actions/mcp-keys'
+
+export default async function McpSettingsPage() {
+  const session = await auth()
+
+  if (!session?.user) {
+    redirect('/api/auth/signin')
+  }
+
+  const [keys, serverStatus] = await Promise.all([
+    listMcpKeys(),
+    getMcpServerStatus(),
+  ])
+
+  return (
+    <div className="space-y-6">
+      <McpSettingsPanel initialKeys={keys} serverStatus={serverStatus} />
+    </div>
+  )
+}

memento-note/app/(main)/settings/page.tsx

@@ -0,0 +1,7 @@
+import { redirect } from 'next/navigation'
+
+// Immediate redirect to the first settings sub-page
+// This avoids loading the heavy settings/page.tsx client component on first visit
+export default function SettingsIndexPage() {
+  redirect('/settings/general')
+}

memento-note/app/(main)/settings/profile/ai-settings-link-card.tsx

@@ -0,0 +1,33 @@
+'use client'
+
+import { Button } from '@/components/ui/button'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { ArrowRight, Sparkles } from 'lucide-react'
+import Link from 'next/link'
+import { useLanguage } from '@/lib/i18n'
+
+export function AISettingsLinkCard() {
+  const { t } = useLanguage()
+
+  return (
+    <Card className="mt-6">
+      <CardHeader>
+        <CardTitle className="flex items-center gap-2">
+          <Sparkles className="h-5 w-5 text-amber-500" />
+          {t('nav.aiSettings')}
+        </CardTitle>
+        <CardDescription>
+          {t('nav.configureAI')}
+        </CardDescription>
+      </CardHeader>
+      <CardContent>
+        <Link href="/settings/ai">
+          <Button variant="outline" className="w-full justify-between group">
+            <span>{t('nav.manageAISettings')}</span>
+            <ArrowRight className="h-4 w-4 group-hover:translate-x-1 transition-transform" />
+          </Button>
+        </Link>
+      </CardContent>
+    </Card>
+  )
+}

memento-note/app/(main)/settings/profile/page-new.tsx

@@ -0,0 +1,155 @@
+'use client'
+
+import { useState } from 'react'
+import { SettingsNav, SettingsSection, SettingToggle, SettingInput, SettingSelect } from '@/components/settings'
+import { updateAISettings } from '@/app/actions/ai-settings'
+import { toast } from 'sonner'
+import { useLanguage } from '@/lib/i18n'
+
+export default function ProfileSettingsPage() {
+  const { t } = useLanguage()
+
+  // Mock user data - in real implementation, load from server
+  const [user, setUser] = useState({
+    name: 'John Doe',
+    email: 'john@example.com'
+  })
+
+  const [language, setLanguage] = useState('auto')
+  const [showRecentNotes, setShowRecentNotes] = useState(false)
+
+  const handleNameChange = async (value: string) => {
+    setUser(prev => ({ ...prev, name: value }))
+    // TODO: Implement profile update
+
+  }
+
+  const handleEmailChange = async (value: string) => {
+    setUser(prev => ({ ...prev, email: value }))
+    // TODO: Implement email update
+
+  }
+
+  const handleLanguageChange = async (value: string) => {
+    setLanguage(value)
+    try {
+      await updateAISettings({ preferredLanguage: value as any })
+    } catch (error) {
+      console.error('Error updating language:', error)
+      toast.error(t('aiSettings.error'))
+    }
+  }
+
+  const handleRecentNotesChange = async (enabled: boolean) => {
+    setShowRecentNotes(enabled)
+    try {
+      await updateAISettings({ showRecentNotes: enabled })
+    } catch (error) {
+      console.error('Error updating recent notes setting:', error)
+      toast.error(t('aiSettings.error'))
+    }
+  }
+
+  return (
+    <div className="container mx-auto py-10 px-4 max-w-6xl">
+      <div className="grid grid-cols-1 lg:grid-cols-4 gap-6">
+        {/* Sidebar Navigation */}
+        <aside className="lg:col-span-1">
+          <SettingsNav />
+        </aside>
+
+        {/* Main Content */}
+        <main className="lg:col-span-3 space-y-6">
+          <div>
+            <h1 className="text-3xl font-bold mb-2">{t('profile.title')}</h1>
+            <p className="text-gray-600 dark:text-gray-400">
+              {t('profile.description')}
+            </p>
+          </div>
+
+          {/* Profile Information */}
+          <SettingsSection
+            title={t('profile.accountSettings')}
+            icon={<span className="text-2xl">👤</span>}
+            description={t('profile.description')}
+          >
+            <SettingInput
+              label={t('profile.displayName')}
+              description={t('profile.displayName')}
+              value={user.name}
+              onChange={handleNameChange}
+              placeholder={t('auth.namePlaceholder')}
+            />
+
+            <SettingInput
+              label={t('profile.email')}
+              description={t('profile.email')}
+              value={user.email}
+              type="email"
+              onChange={handleEmailChange}
+              placeholder={t('auth.emailPlaceholder')}
+            />
+          </SettingsSection>
+
+          {/* Preferences */}
+          <SettingsSection
+            title={t('settings.language')}
+            icon={<span className="text-2xl">⚙️</span>}
+            description={t('profile.languagePreferencesDescription')}
+          >
+            <SettingSelect
+              label={t('profile.preferredLanguage')}
+              description={t('profile.languageDescription')}
+              value={language}
+              options={[
+                { value: 'auto', label: t('profile.autoDetect') },
+                { value: 'en', label: 'English' },
+                { value: 'fr', label: 'Français' },
+                { value: 'es', label: 'Español' },
+                { value: 'de', label: 'Deutsch' },
+                { value: 'fa', label: 'فارسی' },
+                { value: 'it', label: 'Italiano' },
+                { value: 'pt', label: 'Português' },
+                { value: 'ru', label: 'Русский' },
+                { value: 'zh', label: '中文' },
+                { value: 'ja', label: '日本語' },
+                { value: 'ko', label: '한국어' },
+                { value: 'ar', label: 'العربية' },
+                { value: 'hi', label: 'हिन्दी' },
+                { value: 'nl', label: 'Nederlands' },
+                { value: 'pl', label: 'Polski' },
+              ]}
+              onChange={handleLanguageChange}
+            />
+
+            <SettingToggle
+              label={t('profile.showRecentNotes')}
+              description={t('profile.showRecentNotesDescription')}
+              checked={showRecentNotes}
+              onChange={handleRecentNotesChange}
+            />
+          </SettingsSection>
+
+          {/* AI Settings Link */}
+          <div className="p-6 border rounded-lg bg-gradient-to-r from-purple-50 to-pink-50 dark:from-purple-950 dark:to-pink-950">
+            <div className="flex items-center gap-4">
+              <div className="text-4xl">✨</div>
+              <div className="flex-1">
+                <h3 className="font-semibold text-lg mb-1">{t('aiSettings.title')}</h3>
+                <p className="text-sm text-gray-600 dark:text-gray-400">
+                  {t('aiSettings.description')}
+                </p>
+              </div>
+              <button
+                onClick={() => window.location.href = '/settings/ai'}
+                className="px-4 py-2 bg-purple-600 text-white rounded-lg hover:bg-purple-700 transition-colors"
+              >
+                {t('nav.configureAI')}
+              </button>
+            </div>
+          </div>
+        </main>
+      </div>
+    </div>
+  )
+}

memento-note/app/(main)/settings/profile/page.tsx

@@ -0,0 +1,44 @@
+import { auth } from '@/auth'
+import { redirect } from 'next/navigation'
+import { ProfileForm } from './profile-form'
+import prisma from '@/lib/prisma'
+import { ProfilePageHeader } from '@/components/profile-page-header'
+import { AISettingsLinkCard } from './ai-settings-link-card'
+
+export default async function ProfilePage() {
+  const session = await auth()
+
+  if (!session?.user?.id) {
+    redirect('/login')
+  }
+
+  // Parallel queries
+  const [user, aiSettings] = await Promise.all([
+    prisma.user.findUnique({
+      where: { id: session.user.id },
+      select: { name: true, email: true, role: true }
+    }),
+    prisma.userAISettings.findUnique({
+      where: { userId: session.user.id }
+    })
+  ])
+
+  if (!user) {
+    redirect('/login')
+  }
+
+  const userAISettings = {
+    preferredLanguage: aiSettings?.preferredLanguage || 'auto',
+    showRecentNotes: aiSettings?.showRecentNotes ?? false
+  }
+
+  return (
+    <div className="max-w-2xl">
+      <ProfilePageHeader />
+      <ProfileForm user={user} userAISettings={userAISettings} />
+
+      {/* AI Settings Link */}
+      <AISettingsLinkCard />
+    </div>
+  )
+}

memento-note/app/(main)/settings/profile/profile-form.tsx

@@ -0,0 +1,179 @@
+'use client'
+
+import { useState, useEffect } from 'react'
+import { useRouter } from 'next/navigation'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from '@/components/ui/card'
+import { Label } from '@/components/ui/label'
+import { Switch } from '@/components/ui/switch'
+
+import { updateProfile, changePassword, updateFontSize, updateShowRecentNotes } from '@/app/actions/profile'
+import { toast } from 'sonner'
+import { useLanguage } from '@/lib/i18n'
+
+
+
+export function ProfileForm({ user, userAISettings }: { user: any; userAISettings?: any }) {
+  const router = useRouter()
+
+  const [fontSize, setFontSize] = useState(userAISettings?.fontSize || 'medium')
+  const [isUpdatingFontSize, setIsUpdatingFontSize] = useState(false)
+  const [showRecentNotes, setShowRecentNotes] = useState(userAISettings?.showRecentNotes ?? false)
+  const [isUpdatingRecentNotes, setIsUpdatingRecentNotes] = useState(false)
+  const { t } = useLanguage()
+
+  const FONT_SIZES = [
+    { value: 'small', label: t('profile.fontSizeSmall'), size: '14px' },
+    { value: 'medium', label: t('profile.fontSizeMedium'), size: '16px' },
+    { value: 'large', label: t('profile.fontSizeLarge'), size: '18px' },
+    { value: 'extra-large', label: t('profile.fontSizeExtraLarge'), size: '20px' },
+  ]
+
+  const handleFontSizeChange = async (size: string) => {
+    setIsUpdatingFontSize(true)
+    try {
+      const result = await updateFontSize(size)
+      if (result?.error) {
+        toast.error(t('profile.fontSizeUpdateFailed'))
+      } else {
+        setFontSize(size)
+        // Apply font size immediately
+        applyFontSize(size)
+        toast.success(t('profile.fontSizeUpdateSuccess'))
+      }
+    } catch (error) {
+      toast.error(t('profile.fontSizeUpdateFailed'))
+    } finally {
+      setIsUpdatingFontSize(false)
+    }
+  }
+
+  const applyFontSize = (size: string) => {
+    // Base font size in pixels (16px is standard)
+    const fontSizeMap = {
+      'small': '14px',    // ~87% of 16px
+      'medium': '16px',   // 100% (standard)
+      'large': '18px',    // ~112% of 16px
+      'extra-large': '20px' // 125% of 16px
+    }
+    const fontSizeFactorMap = {
+      'small': 0.95,
+      'medium': 1.0,
+      'large': 1.1,
+      'extra-large': 1.25
+    }
+    const fontSizeValue = fontSizeMap[size as keyof typeof fontSizeMap] || '16px'
+    const fontSizeFactor = fontSizeFactorMap[size as keyof typeof fontSizeFactorMap] || 1.0
+
+    document.documentElement.style.setProperty('--user-font-size', fontSizeValue)
+    document.documentElement.style.setProperty('--user-font-size-factor', fontSizeFactor.toString())
+    localStorage.setItem('user-font-size', size)
+  }
+
+  // Apply saved font size on mount
+  useEffect(() => {
+    const savedFontSize = localStorage.getItem('user-font-size') || userAISettings?.fontSize || 'medium'
+    applyFontSize(savedFontSize as string)
+  }, [])
+
+
+
+  const handleShowRecentNotesChange = async (enabled: boolean) => {
+    setIsUpdatingRecentNotes(true)
+    const previousValue = showRecentNotes
+
+    try {
+      const result = await updateShowRecentNotes(enabled)
+      if (result?.error) {
+        toast.error(result.error)
+      } else {
+        setShowRecentNotes(enabled)
+        toast.success(t('profile.recentNotesUpdateSuccess') || 'Paramètre mis à jour')
+        // Force full page reload to ensure settings are reloaded
+        window.location.href = '/settings/profile'
+      }
+    } catch (error: any) {
+      setShowRecentNotes(previousValue)
+      toast.error(error?.message || 'Erreur')
+    } finally {
+      setIsUpdatingRecentNotes(false)
+    }
+  }
+
+  return (
+    <div className="space-y-6">
+      <Card>
+        <CardHeader>
+          <CardTitle>{t('profile.title')}</CardTitle>
+          <CardDescription>{t('profile.description')}</CardDescription>
+        </CardHeader>
+        <form action={async (formData) => {
+          const result = await updateProfile({ name: formData.get('name') as string })
+          if (result?.error) {
+            toast.error(t('profile.updateFailed'))
+          } else {
+            toast.success(t('profile.updateSuccess'))
+          }
+        }}>
+          <CardContent className="space-y-4">
+            <div className="space-y-2">
+              <label htmlFor="name" className="text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70">{t('profile.displayName')}</label>
+              <Input id="name" name="name" defaultValue={user.name} />
+            </div>
+            <div className="space-y-2">
+              <label htmlFor="email" className="text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70">{t('profile.email')}</label>
+              <Input id="email" value={user.email} disabled className="bg-muted" />
+            </div>
+          </CardContent>
+          <CardFooter>
+            <Button type="submit">{t('general.save')}</Button>
+          </CardFooter>
+        </form>
+      </Card>
+
+
+
+
+
+      <Card>
+        <CardHeader>
+          <CardTitle>{t('profile.changePassword')}</CardTitle>
+          <CardDescription>{t('profile.changePasswordDescription')}</CardDescription>
+        </CardHeader>
+        <form action={async (formData) => {
+          const result = await changePassword(formData)
+          if (result?.error) {
+            const msg = '_form' in result.error
+              ? result.error._form[0]
+              : result.error.currentPassword?.[0] || result.error.newPassword?.[0] || result.error.confirmPassword?.[0] || t('profile.passwordChangeFailed')
+            toast.error(msg)
+          } else {
+            toast.success(t('profile.passwordChangeSuccess'))
+            // Reset form manually or redirect
+            const form = document.querySelector('form#password-form') as HTMLFormElement
+            form?.reset()
+          }
+        }} id="password-form">
+          <CardContent className="space-y-4">
+            <div className="space-y-2">
+              <label htmlFor="currentPassword" className="text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70">{t('profile.currentPassword')}</label>
+              <Input id="currentPassword" name="currentPassword" type="password" required />
+            </div>
+            <div className="space-y-2">
+              <label htmlFor="newPassword" className="text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70">{t('profile.newPassword')}</label>
+              <Input id="newPassword" name="newPassword" type="password" required minLength={6} />
+            </div>
+            <div className="space-y-2">
+              <label htmlFor="confirmPassword" className="text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70">{t('profile.confirmPassword')}</label>
+              <Input id="confirmPassword" name="confirmPassword" type="password" required minLength={6} />
+            </div>
+          </CardContent>
+          <CardFooter>
+            <Button type="submit">{t('profile.updatePassword')}</Button>
+          </CardFooter>
+        </form>
+      </Card>
+    </div>
+  )
+}

memento-note/app/(main)/support/page.tsx

@@ -0,0 +1,156 @@
+'use client'
+
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Button } from '@/components/ui/button';
+import { useLanguage } from '@/lib/i18n';
+
+export default function SupportPage() {
+  const { t } = useLanguage();
+
+  return (
+    <div className="container mx-auto py-10 max-w-4xl">
+      <div className="text-center mb-10">
+        <h1 className="text-4xl font-bold mb-4">
+          {t('support.title')}
+        </h1>
+        <p className="text-muted-foreground text-lg">
+          {t('support.description')}
+        </p>
+      </div>
+
+      <div className="grid gap-6 md:grid-cols-2 mb-10">
+        <Card className="border-2 border-primary">
+          <CardHeader>
+            <CardTitle className="flex items-center gap-2">
+              <span className="text-2xl">☕</span>
+              {t('support.buyMeACoffee')}
+            </CardTitle>
+          </CardHeader>
+          <CardContent>
+            <p className="mb-4">
+              {t('support.donationDescription')}
+            </p>
+            <Button asChild className="w-full">
+              <a href="https://ko-fi.com/yourusername" target="_blank" rel="noopener noreferrer">
+                {t('support.donateOnKofi')}
+              </a>
+            </Button>
+            <p className="text-xs text-muted-foreground mt-2">
+              {t('support.kofiDescription')}
+            </p>
+          </CardContent>
+        </Card>
+
+        <Card className="border-2 border-primary">
+          <CardHeader>
+            <CardTitle className="flex items-center gap-2">
+              <span className="text-2xl">💚</span>
+              {t('support.sponsorOnGithub')}
+            </CardTitle>
+          </CardHeader>
+          <CardContent>
+            <p className="mb-4">
+              {t('support.sponsorDescription')}
+            </p>
+            <Button asChild variant="outline" className="w-full">
+              <a href="https://github.com/sponsors/yourusername" target="_blank" rel="noopener noreferrer">
+                {t('support.sponsorOnGithub')}
+              </a>
+            </Button>
+            <p className="text-xs text-muted-foreground mt-2">
+              {t('support.githubDescription')}
+            </p>
+          </CardContent>
+        </Card>
+      </div>
+
+      <Card className="mb-10">
+        <CardHeader>
+          <CardTitle>{t('support.howSupportHelps')}</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <div className="grid md:grid-cols-2 gap-4">
+            <div>
+              <h3 className="font-semibold mb-2">💰 {t('support.directImpact')}</h3>
+              <ul className="space-y-2 text-sm">
+                <li>☕ Keeps me fueled with coffee</li>
+                <li>🐛 Covers hosting and server costs</li>
+                <li>✨ Funds development of new features</li>
+                <li>📚 Improves documentation</li>
+                <li>🌍 Keeps Memento 100% open-source</li>
+              </ul>
+            </div>
+            <div>
+              <h3 className="font-semibold mb-2">🎁 {t('support.sponsorPerks')}</h3>
+              <ul className="space-y-2 text-sm">
+                <li>🥉 $5/month - Bronze: Name in supporters list</li>
+                <li>🥈 $15/month - Silver: Priority feature requests</li>
+                <li>🥇 $50/month - Gold: Logo in footer, priority support</li>
+                <li>💎 $100/month - Platinum: Custom features, consulting</li>
+              </ul>
+            </div>
+          </div>
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>💡 {t('support.transparency')}</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <p className="text-sm mb-4">
+            {t('support.transparencyDescription')}
+          </p>
+          <div className="space-y-2 text-sm">
+            <div className="flex justify-between">
+              <span>{t('support.hostingServers')}</span>
+              <span className="font-mono">~$20/month</span>
+            </div>
+            <div className="flex justify-between">
+              <span>{t('support.domainSSL')}</span>
+              <span className="font-mono">~$15/year</span>
+            </div>
+            <div className="flex justify-between">
+              <span>{t('support.aiApiCosts')}</span>
+              <span className="font-mono">~$30/month</span>
+            </div>
+            <div className="flex justify-between border-t pt-2">
+              <span className="font-semibold">{t('support.totalExpenses')}</span>
+              <span className="font-mono font-semibold">~$50/month</span>
+            </div>
+          </div>
+          <p className="text-xs text-muted-foreground mt-4">
+            Any amount beyond these costs goes directly into improving Memento
+            and funding new features. Thank you for your support! 💚
+          </p>
+        </CardContent>
+      </Card>
+
+      <div className="mt-10 text-center">
+        <h2 className="text-2xl font-bold mb-4">{t('support.otherWaysTitle')}</h2>
+        <div className="flex flex-wrap justify-center gap-4">
+          <Button variant="outline" asChild>
+            <a href="https://github.com/yourusername/memento" target="_blank" rel="noopener noreferrer">
+              ⭐ {t('support.starGithub')}
+            </a>
+          </Button>
+          <Button variant="outline" asChild>
+            <a href="https://github.com/yourusername/memento/issues" target="_blank" rel="noopener noreferrer">
+              🐛 {t('support.reportBug')}
+            </a>
+          </Button>
+          <Button variant="outline" asChild>
+            <a href="https://github.com/yourusername/memento" target="_blank" rel="noopener noreferrer">
+              📝 {t('support.contributeCode')}
+            </a>
+          </Button>
+          <Button variant="outline" asChild>
+            <a href="https://twitter.com/intent/tweet?text=Check%20out%20Memento%20-%20a%20great%20open-source%20note-taking%20app!%20https://github.com/yourusername/memento" target="_blank" rel="noopener noreferrer">
+              🐦 {t('support.shareTwitter')}
+            </a>
+          </Button>
+        </div>
+      </div>
+    </div>
+  );
+}

memento-note/app/(main)/trash/page.tsx

@@ -0,0 +1,21 @@
+import { getTrashedNotes } from '@/app/actions/notes'
+import { MasonryGrid } from '@/components/masonry-grid'
+import { TrashHeader } from '@/components/trash-header'
+import { TrashEmptyState } from './trash-empty-state'
+
+export const dynamic = 'force-dynamic'
+
+export default async function TrashPage() {
+  const notes = await getTrashedNotes()
+
+  return (
+    <main className="container mx-auto px-4 py-8 max-w-7xl">
+      <TrashHeader noteCount={notes.length} />
+      {notes.length > 0 ? (
+        <MasonryGrid notes={notes} isTrashView />
+      ) : (
+        <TrashEmptyState />
+      )}
+    </main>
+  )
+}

memento-note/app/(main)/trash/trash-empty-state.tsx

@@ -0,0 +1,20 @@
+'use client'
+
+import { Trash2 } from 'lucide-react'
+import { useLanguage } from '@/lib/i18n'
+
+export function TrashEmptyState() {
+  const { t } = useLanguage()
+
+  return (
+    <div className="flex flex-col items-center justify-center min-h-[60vh] text-center text-gray-500">
+      <div className="bg-gray-100 dark:bg-gray-800 p-6 rounded-full mb-4">
+        <Trash2 className="w-12 h-12 text-gray-400" />
+      </div>
+      <h2 className="text-xl font-medium mb-2">{t('trash.empty')}</h2>
+      <p className="max-w-md text-sm opacity-80">
+        {t('trash.emptyDescription')}
+      </p>
+    </div>
+  )
+}

memento-note/app/actions/admin-settings.ts

@@ -0,0 +1,73 @@
+'use server'
+
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+import { sendEmail } from '@/lib/mail'
+import { revalidateTag } from 'next/cache'
+
+async function checkAdmin() {
+  const session = await auth()
+  if (!session?.user?.id || (session.user as any).role !== 'ADMIN') {
+    throw new Error('Unauthorized: Admin access required')
+  }
+  return session
+}
+
+export async function testEmail(provider: 'resend' | 'smtp' = 'smtp') {
+  const session = await checkAdmin()
+  const email = session.user?.email
+
+  if (!email) throw new Error("No admin email found")
+
+  const subject = provider === 'resend'
+    ? "Memento Resend Test"
+    : "Memento SMTP Test"
+
+  const html = provider === 'resend'
+    ? "<p>This is a test email from your Memento instance. <strong>Resend is working!</strong></p>"
+    : "<p>This is a test email from your Memento instance. <strong>SMTP is working!</strong></p>"
+
+  const result = await sendEmail({
+    to: email,
+    subject,
+    html,
+  }, provider)
+
+  return result
+}
+
+export async function getSystemConfig() {
+  await checkAdmin()
+  // Reuse the cached version from lib/config
+  const { getSystemConfig: getCachedConfig } = await import('@/lib/config')
+  return getCachedConfig()
+}
+
+export async function updateSystemConfig(data: Record<string, string>) {
+  await checkAdmin()
+
+  try {
+    // Filter out empty values but keep 'false' as valid
+    const filteredData = Object.fromEntries(
+      Object.entries(data).filter(([key, value]) => value !== '' && value !== null && value !== undefined)
+    )
+
+    const operations = Object.entries(filteredData).map(([key, value]) =>
+      prisma.systemConfig.upsert({
+        where: { key },
+        update: { value },
+        create: { key, value }
+      })
+    )
+
+    await prisma.$transaction(operations)
+
+    // Invalidate cache after update
+    revalidateTag('system-config', '/settings')
+
+    return { success: true }
+  } catch (error) {
+    console.error('Failed to update settings:', error)
+    return { error: 'Failed to update settings' }
+  }
+}

memento-note/app/actions/admin.ts

@@ -0,0 +1,120 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+import bcrypt from 'bcryptjs'
+import { z } from 'zod'
+
+// Schema pour la création d'utilisateur
+const CreateUserSchema = z.object({
+  name: z.string().min(2, "Name must be at least 2 characters"),
+  email: z.string().email("Invalid email address"),
+  password: z.string().min(6, "Password must be at least 6 characters"),
+  role: z.enum(["USER", "ADMIN"]).default("USER"),
+})
+
+async function checkAdmin() {
+  const session = await auth()
+  if (!session?.user?.id || (session.user as any).role !== 'ADMIN') {
+    throw new Error('Unauthorized: Admin access required')
+  }
+  return session
+}
+
+export async function getUsers() {
+  await checkAdmin()
+  try {
+    const users = await prisma.user.findMany({
+      orderBy: { createdAt: 'desc' },
+      select: {
+        id: true,
+        name: true,
+        email: true,
+        role: true,
+        createdAt: true,
+      }
+    })
+    return users
+  } catch (error) {
+    console.error('Failed to fetch users:', error)
+    throw new Error('Failed to fetch users')
+  }
+}
+
+export async function createUser(formData: FormData) {
+  await checkAdmin()
+
+  const rawData = {
+    name: formData.get('name'),
+    email: formData.get('email'),
+    password: formData.get('password'),
+    role: formData.get('role'),
+  }
+
+  const validatedFields = CreateUserSchema.safeParse(rawData)
+
+  if (!validatedFields.success) {
+    return {
+      error: validatedFields.error.flatten().fieldErrors,
+    }
+  }
+
+  const { name, email, password, role } = validatedFields.data
+  const hashedPassword = await bcrypt.hash(password, 10)
+
+  try {
+    await prisma.user.create({
+      data: {
+        name,
+        email: email.toLowerCase(),
+        password: hashedPassword,
+        role,
+      },
+    })
+    revalidatePath('/admin')
+    return { success: true }
+  } catch (error: any) {
+    if (error.code === 'P2002') {
+      return { error: { email: ['Email already exists'] } }
+    }
+    return { error: { _form: ['Failed to create user'] } }
+  }
+}
+
+export async function deleteUser(userId: string) {
+  const session = await checkAdmin()
+  
+  if (session.user?.id === userId) {
+    throw new Error("You cannot delete your own account")
+  }
+
+  try {
+    await prisma.user.delete({
+      where: { id: userId },
+    })
+    revalidatePath('/admin')
+    return { success: true }
+  } catch (error) {
+    throw new Error('Failed to delete user')
+  }
+}
+
+export async function updateUserRole(userId: string, newRole: string) {
+  const session = await checkAdmin()
+
+  if (session.user?.id === userId) {
+    throw new Error("You cannot change your own role")
+  }
+
+  try {
+    await prisma.user.update({
+      where: { id: userId },
+      data: { role: newRole },
+    })
+    revalidatePath('/admin')
+    return { success: true }
+  } catch (error) {
+    throw new Error('Failed to update role')
+  }
+}

memento-note/app/actions/agent-actions.ts

@@ -0,0 +1,235 @@
+'use server'
+
+/**
+ * Agent Server Actions
+ * CRUD operations for agents and execution triggers.
+ */
+
+import { auth } from '@/auth'
+import { prisma } from '@/lib/prisma'
+import { revalidatePath } from 'next/cache'
+
+// --- CRUD ---
+
+export async function createAgent(data: {
+  name: string
+  description?: string
+  type: string
+  role: string
+  sourceUrls?: string[]
+  sourceNotebookId?: string
+  targetNotebookId?: string
+  frequency?: string
+  tools?: string[]
+  maxSteps?: number
+  notifyEmail?: boolean
+  includeImages?: boolean
+}) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Non autorise')
+  }
+
+  try {
+    const agent = await prisma.agent.create({
+      data: {
+        name: data.name,
+        description: data.description,
+        type: data.type,
+        role: data.role,
+        sourceUrls: data.sourceUrls ? JSON.stringify(data.sourceUrls) : null,
+        sourceNotebookId: data.sourceNotebookId || null,
+        targetNotebookId: data.targetNotebookId || null,
+        frequency: data.frequency || 'manual',
+        tools: data.tools ? JSON.stringify(data.tools) : '[]',
+        maxSteps: data.maxSteps || 10,
+        notifyEmail: data.notifyEmail || false,
+        includeImages: data.includeImages || false,
+        userId: session.user.id,
+      }
+    })
+
+    revalidatePath('/agents')
+    return { success: true, agent }
+  } catch (error) {
+    console.error('Error creating agent:', error)
+    throw new Error('Impossible de creer l\'agent')
+  }
+}
+
+export async function updateAgent(id: string, data: {
+  name?: string
+  description?: string
+  type?: string
+  role?: string
+  sourceUrls?: string[]
+  sourceNotebookId?: string | null
+  targetNotebookId?: string | null
+  frequency?: string
+  isEnabled?: boolean
+  tools?: string[]
+  maxSteps?: number
+  notifyEmail?: boolean
+  includeImages?: boolean
+}) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Non autorise')
+  }
+
+  try {
+    const existing = await prisma.agent.findUnique({ where: { id } })
+    if (!existing || existing.userId !== session.user.id) {
+      throw new Error('Agent non trouve')
+    }
+
+    const updateData: Record<string, unknown> = {}
+    if (data.name !== undefined) updateData.name = data.name
+    if (data.description !== undefined) updateData.description = data.description
+    if (data.type !== undefined) updateData.type = data.type
+    if (data.role !== undefined) updateData.role = data.role
+    if (data.sourceUrls !== undefined) updateData.sourceUrls = JSON.stringify(data.sourceUrls)
+    if (data.sourceNotebookId !== undefined) updateData.sourceNotebookId = data.sourceNotebookId
+    if (data.targetNotebookId !== undefined) updateData.targetNotebookId = data.targetNotebookId
+    if (data.frequency !== undefined) updateData.frequency = data.frequency
+    if (data.isEnabled !== undefined) updateData.isEnabled = data.isEnabled
+    if (data.tools !== undefined) updateData.tools = JSON.stringify(data.tools)
+    if (data.maxSteps !== undefined) updateData.maxSteps = data.maxSteps
+    if (data.notifyEmail !== undefined) updateData.notifyEmail = data.notifyEmail
+    if (data.includeImages !== undefined) updateData.includeImages = data.includeImages
+
+    const agent = await prisma.agent.update({
+      where: { id },
+      data: updateData
+    })
+
+    revalidatePath('/agents')
+    return { success: true, agent }
+  } catch (error) {
+    console.error('Error updating agent:', error)
+    throw new Error('Impossible de mettre a jour l\'agent')
+  }
+}
+
+export async function deleteAgent(id: string) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Non autorise')
+  }
+
+  try {
+    const existing = await prisma.agent.findUnique({ where: { id } })
+    if (!existing || existing.userId !== session.user.id) {
+      throw new Error('Agent non trouve')
+    }
+
+    await prisma.agent.delete({ where: { id } })
+    revalidatePath('/agents')
+    return { success: true }
+  } catch (error) {
+    console.error('Error deleting agent:', error)
+    throw new Error('Impossible de supprimer l\'agent')
+  }
+}
+
+export async function getAgents() {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Non autorise')
+  }
+
+  try {
+    const agents = await prisma.agent.findMany({
+      where: { userId: session.user.id },
+      include: {
+        _count: { select: { actions: true } },
+        actions: {
+          orderBy: { createdAt: 'desc' },
+          take: 1,
+        },
+        notebook: {
+          select: { id: true, name: true, icon: true }
+        }
+      },
+      orderBy: { createdAt: 'desc' }
+    })
+
+    return agents
+  } catch (error) {
+    console.error('Error fetching agents:', error)
+    throw new Error('Impossible de charger les agents')
+  }
+}
+
+// --- Execution ---
+
+export async function runAgent(id: string) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Non autorise')
+  }
+
+  try {
+    const { executeAgent } = await import('@/lib/ai/services/agent-executor.service')
+    const result = await executeAgent(id, session.user.id)
+    revalidatePath('/agents')
+    revalidatePath('/')
+    return result
+  } catch (error) {
+    console.error('Error running agent:', error)
+    return {
+      success: false,
+      actionId: '',
+      error: error instanceof Error ? error.message : 'Erreur inconnue'
+    }
+  }
+}
+
+// --- History ---
+
+export async function getAgentActions(agentId: string) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Non autorise')
+  }
+
+  try {
+    const actions = await prisma.agentAction.findMany({
+      where: { agentId },
+      orderBy: { createdAt: 'desc' },
+      take: 20,
+      select: {
+        id: true,
+        status: true,
+        result: true,
+        log: true,
+        input: true,
+        toolLog: true,
+        tokensUsed: true,
+        createdAt: true,
+      }
+    })
+    return actions
+  } catch (error) {
+    console.error('Error fetching agent actions:', error)
+    throw new Error('Impossible de charger l\'historique')
+  }
+}
+
+export async function toggleAgent(id: string, isEnabled: boolean) {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Non autorise')
+  }
+
+  try {
+    const agent = await prisma.agent.update({
+      where: { id },
+      data: { isEnabled }
+    })
+    return { success: true, agent }
+  } catch (error) {
+    console.error('Error toggling agent:', error)
+    throw new Error('Impossible de modifier l\'agent')
+  }
+}

memento-note/app/actions/ai-actions.ts

@@ -0,0 +1,382 @@
+'use server'
+
+/**
+ * AI Server Actions Stub File
+ *
+ * This file provides a centralized location for all AI-related server action interfaces
+ * and serves as documentation for the AI server action architecture.
+ *
+ * IMPLEMENTATION STATUS:
+ * - Title Suggestions: ✅ Implemented (see app/actions/title-suggestions.ts)
+ * - Semantic Search: ✅ Implemented (see app/actions/semantic-search.ts)
+ * - Paragraph Reformulation: ✅ Implemented (see app/actions/paragraph-refactor.ts)
+ * - Memory Echo: ⏳ STUB - To be implemented in Epic 5 (Story 5-1)
+ * - Language Detection: ✅ Implemented (see app/actions/detect-language.ts)
+ * - AI Settings: ✅ Implemented (see app/actions/ai-settings.ts)
+ *
+ * NOTE: This file defines TypeScript interfaces and placeholder functions.
+ * Actual implementations are in separate action files (see references above).
+ */
+
+import { auth } from '@/auth'
+import { prisma } from '@/lib/prisma'
+import { revalidatePath } from 'next/cache'
+
+// ============================================================================
+// TYPESCRIPT INTERFACES
+// ============================================================================
+
+/**
+ * Title Suggestions Interfaces
+ * @see app/actions/title-suggestions.ts for implementation
+ */
+export interface GenerateTitlesRequest {
+  noteId: string
+}
+
+export interface GenerateTitlesResponse {
+  suggestions: Array<{
+    title: string
+    confidence: number
+    reasoning?: string
+  }>
+  noteId: string
+}
+
+/**
+ * Semantic Search Interfaces
+ * @see app/actions/semantic-search.ts for implementation
+ */
+export interface SearchResult {
+  noteId: string
+  title: string | null
+  content: string
+  similarity: number
+  matchType: 'exact' | 'related'
+}
+
+export interface SemanticSearchRequest {
+  query: string
+  options?: {
+    limit?: number
+    threshold?: number
+    notebookId?: string
+  }
+}
+
+export interface SemanticSearchResponse {
+  results: SearchResult[]
+  query: string
+  totalResults: number
+}
+
+/**
+ * Paragraph Reformulation Interfaces
+ * @see app/actions/paragraph-refactor.ts for implementation
+ */
+export type RefactorMode = 'clarify' | 'shorten' | 'improve'
+
+export interface RefactorParagraphRequest {
+  noteId: string
+  selectedText: string
+  option: RefactorMode
+}
+
+export interface RefactorParagraphResponse {
+  originalText: string
+  refactoredText: string
+}
+
+/**
+ * Memory Echo Interfaces
+ * STUB - To be implemented in Epic 5 (Story 5-1)
+ *
+ * This feature will analyze all user notes with embeddings to find
+ * connections with cosine similarity > 0.75 and provide proactive insights.
+ */
+export interface GenerateMemoryEchoRequest {
+  // No params - uses current user session
+}
+
+export interface MemoryEchoInsight {
+  note1Id: string
+  note2Id: string
+  similarityScore: number
+}
+
+export interface GenerateMemoryEchoResponse {
+  success: boolean
+  insight: MemoryEchoInsight | null
+}
+
+/**
+ * Language Detection Interfaces
+ * @see app/actions/detect-language.ts for implementation
+ */
+export interface DetectLanguageRequest {
+  content: string
+}
+
+export interface DetectLanguageResponse {
+  language: string
+  confidence: number
+  method: 'tinyld' | 'ai'
+}
+
+/**
+ * AI Settings Interfaces
+ * @see app/actions/ai-settings.ts for implementation
+ */
+export interface AISettingsConfig {
+  titleSuggestions?: boolean
+  semanticSearch?: boolean
+  paragraphRefactor?: boolean
+  memoryEcho?: boolean
+  memoryEchoFrequency?: 'daily' | 'weekly' | 'custom'
+  aiProvider?: 'auto' | 'openai' | 'ollama'
+  preferredLanguage?: 'auto' | 'en' | 'fr' | 'es' | 'de' | 'fa' | 'it' | 'pt' | 'ru' | 'zh' | 'ja' | 'ko' | 'ar' | 'hi' | 'nl' | 'pl'
+  demoMode?: boolean
+}
+
+export interface UpdateAISettingsRequest {
+  settings: Partial<AISettingsConfig>
+}
+
+export interface UpdateAISettingsResponse {
+  success: boolean
+}
+
+// ============================================================================
+// PLACEHOLDER FUNCTIONS
+// ============================================================================
+
+/**
+ * Generate Title Suggestions
+ *
+ * ALREADY IMPLEMENTED: See app/actions/title-suggestions.ts
+ *
+ * This function generates 3 AI-powered title suggestions for a note when it
+ * reaches 50+ words without a title.
+ *
+ * @see generateTitleSuggestions in app/actions/title-suggestions.ts
+ */
+export async function generateTitles(
+  request: GenerateTitlesRequest
+): Promise<GenerateTitlesResponse> {
+  // TODO: Import and use implementation from title-suggestions.ts
+  // import { generateTitleSuggestions } from './title-suggestions'
+  // return generateTitleSuggestions(request.noteId)
+
+  throw new Error('Not implemented in stub: Use app/actions/title-suggestions.ts')
+}
+
+/**
+ * Semantic Search
+ *
+ * ALREADY IMPLEMENTED: See app/actions/semantic-search.ts
+ *
+ * This function performs hybrid semantic + keyword search across user notes.
+ *
+ * @see semanticSearch in app/actions/semantic-search.ts
+ */
+export async function semanticSearch(
+  request: SemanticSearchRequest
+): Promise<SemanticSearchResponse> {
+  // TODO: Import and use implementation from semantic-search.ts
+  // import { semanticSearch } from './semantic-search'
+  // return semanticSearch(request.query, request.options)
+
+  throw new Error('Not implemented in stub: Use app/actions/semantic-search.ts')
+}
+
+/**
+ * Refactor Paragraph
+ *
+ * ALREADY IMPLEMENTED: See app/actions/paragraph-refactor.ts
+ *
+ * This function refactors a paragraph using AI with specific mode (clarify/shorten/improve).
+ *
+ * @see refactorParagraph in app/actions/paragraph-refactor.ts
+ */
+export async function refactorParagraph(
+  request: RefactorParagraphRequest
+): Promise<RefactorParagraphResponse> {
+  // TODO: Import and use implementation from paragraph-refactor.ts
+  // import { refactorParagraph } from './paragraph-refactor'
+  // return refactorParagraph(request.selectedText, request.option)
+
+  throw new Error('Not implemented in stub: Use app/actions/paragraph-refactor.ts')
+}
+
+/**
+ * Generate Memory Echo Insights
+ *
+ * STUB: To be implemented in Epic 5 (Story 5-1)
+ *
+ * This will analyze all user notes with embeddings to find
+ * connections with cosine similarity > 0.75.
+ *
+ * Implementation Plan:
+ * - Fetch all user notes with embeddings
+ * - Calculate pairwise cosine similarities
+ * - Find top connection with similarity > 0.75
+ * - Store in MemoryEchoInsight table
+ * - Return insight or null if none found
+ *
+ * @see Epic 5 Story 5-1 in planning/epics.md
+ */
+export async function generateMemoryEcho(): Promise<GenerateMemoryEchoResponse> {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Unauthorized')
+  }
+
+  // TODO: Implement Memory Echo background processing
+  // - Fetch all user notes with embeddings from prisma.note
+  // - Calculate pairwise cosine similarities using embedding vectors
+  // - Filter for similarity > 0.75
+  // - Select top insight
+  // - Store in prisma.memoryEchoInsight table (if it exists)
+  // - Return { success: true, insight: {...} }
+
+  throw new Error('Not implemented: See Epic 5 Story 5-1')
+}
+
+/**
+ * Detect Language
+ *
+ * ALREADY IMPLEMENTED: See app/actions/detect-language.ts
+ *
+ * This function detects the language of user content.
+ *
+ * @see getInitialLanguage in app/actions/detect-language.ts
+ */
+export async function detectLanguage(
+  request: DetectLanguageRequest
+): Promise<DetectLanguageResponse> {
+  // TODO: Import and use implementation from detect-language.ts
+  // import { detectUserLanguage } from '@/lib/i18n/detect-user-language'
+  // const language = await detectUserLanguage()
+  // return { language, confidence: 0.95, method: 'tinyld' }
+
+  throw new Error('Not implemented in stub: Use app/actions/detect-language.ts')
+}
+
+/**
+ * Update AI Settings
+ *
+ * ALREADY IMPLEMENTED: See app/actions/ai-settings.ts
+ *
+ * This function updates user AI preferences.
+ *
+ * @see updateAISettings in app/actions/ai-settings.ts
+ */
+export async function updateAISettings(
+  request: UpdateAISettingsRequest
+): Promise<UpdateAISettingsResponse> {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Unauthorized')
+  }
+
+  // TODO: Import and use implementation from ai-settings.ts
+  // import { updateAISettings } from './ai-settings'
+  // return updateAISettings(request.settings)
+
+  throw new Error('Not implemented in stub: Use app/actions/ai-settings.ts')
+}
+
+/**
+ * Get AI Settings
+ *
+ * ALREADY IMPLEMENTED: See app/actions/ai-settings.ts
+ *
+ * This function retrieves user AI preferences.
+ *
+ * @see getAISettings in app/actions/ai-settings.ts
+ */
+export async function getAISettings(): Promise<AISettingsConfig> {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Unauthorized')
+  }
+
+  // TODO: Import and use implementation from ai-settings.ts
+  // import { getAISettings } from './ai-settings'
+  // return getAISettings()
+
+  throw new Error('Not implemented in stub: Use app/actions/ai-settings.ts')
+}
+
+// ============================================================================
+// UTILITY FUNCTIONS
+// ============================================================================
+
+/**
+ * Check if a specific AI feature is enabled for the user
+ *
+ * UTILITY: Helper function to check feature flags
+ *
+ * @param feature - The AI feature to check
+ * @returns Promise<boolean> - Whether the feature is enabled
+ */
+export async function isAIFeatureEnabled(
+  feature: keyof AISettingsConfig
+): Promise<boolean> {
+  const session = await auth()
+  if (!session?.user?.id) {
+    return false
+  }
+
+  try {
+    const settings = await prisma.userAISettings.findUnique({
+      where: { userId: session.user.id }
+    })
+
+    if (!settings) {
+      // Default to enabled for new users
+      return true
+    }
+
+    switch (feature) {
+      case 'titleSuggestions':
+        return settings.titleSuggestions ?? true
+      case 'semanticSearch':
+        return settings.semanticSearch ?? true
+      case 'paragraphRefactor':
+        return settings.paragraphRefactor ?? true
+      case 'memoryEcho':
+        return settings.memoryEcho ?? true
+      default:
+        return true
+    }
+  } catch (error) {
+    console.error('Error checking AI feature enabled:', error)
+    return true
+  }
+}
+
+/**
+ * Get user's preferred AI provider
+ *
+ * UTILITY: Helper function to get provider preference
+ *
+ * @returns Promise<'auto' | 'openai' | 'ollama'> - The AI provider
+ */
+export async function getUserAIPreference(): Promise<'auto' | 'openai' | 'ollama'> {
+  const session = await auth()
+  if (!session?.user?.id) {
+    return 'auto'
+  }
+
+  try {
+    const settings = await prisma.userAISettings.findUnique({
+      where: { userId: session.user.id }
+    })
+
+    return (settings?.aiProvider || 'auto') as 'auto' | 'openai' | 'ollama'
+  } catch (error) {
+    console.error('Error getting user AI preference:', error)
+    return 'auto'
+  }
+}

memento-note/app/actions/ai-settings.ts

@@ -0,0 +1,260 @@
+'use server'
+
+import { auth } from '@/auth'
+import { prisma } from '@/lib/prisma'
+import { revalidatePath, updateTag } from 'next/cache'
+
+export type UserAISettingsData = {
+  titleSuggestions?: boolean
+  semanticSearch?: boolean
+  paragraphRefactor?: boolean
+  memoryEcho?: boolean
+  memoryEchoFrequency?: 'daily' | 'weekly' | 'custom'
+  aiProvider?: 'auto' | 'openai' | 'ollama'
+  preferredLanguage?: 'auto' | 'en' | 'fr' | 'es' | 'de' | 'fa' | 'it' | 'pt' | 'ru' | 'zh' | 'ja' | 'ko' | 'ar' | 'hi' | 'nl' | 'pl'
+  demoMode?: boolean
+  showRecentNotes?: boolean
+  notesViewMode?: 'masonry' | 'tabs' | 'list'
+  emailNotifications?: boolean
+  desktopNotifications?: boolean
+  anonymousAnalytics?: boolean
+  fontSize?: 'small' | 'medium' | 'large'
+}
+
+/** Only fields that exist on `UserAISettings` in Prisma (excludes e.g. `theme`, which lives on `User`). */
+const USER_AI_SETTINGS_PRISMA_KEYS = [
+  'titleSuggestions',
+  'semanticSearch',
+  'paragraphRefactor',
+  'memoryEcho',
+  'memoryEchoFrequency',
+  'aiProvider',
+  'preferredLanguage',
+  'fontSize',
+  'demoMode',
+  'showRecentNotes',
+  'notesViewMode',
+  'emailNotifications',
+  'desktopNotifications',
+  'anonymousAnalytics',
+] as const
+
+type UserAISettingsPrismaKey = (typeof USER_AI_SETTINGS_PRISMA_KEYS)[number]
+
+function pickUserAISettingsForDb(input: UserAISettingsData): Partial<Record<UserAISettingsPrismaKey, unknown>> {
+  const out: Partial<Record<UserAISettingsPrismaKey, unknown>> = {}
+  for (const key of USER_AI_SETTINGS_PRISMA_KEYS) {
+    const v = input[key]
+    if (v !== undefined) {
+      out[key] = v
+    }
+  }
+  if (out.notesViewMode === 'list') {
+    out.notesViewMode = 'tabs'
+  }
+  if (
+    out.notesViewMode != null &&
+    out.notesViewMode !== 'masonry' &&
+    out.notesViewMode !== 'tabs'
+  ) {
+    delete out.notesViewMode
+  }
+  return out
+}
+
+/**
+ * Update AI settings for the current user
+ */
+export async function updateAISettings(settings: UserAISettingsData) {
+
+  const session = await auth()
+
+
+  if (!session?.user?.id) {
+    console.error('[updateAISettings] Unauthorized: No session or user ID')
+    throw new Error('Unauthorized')
+  }
+
+  try {
+    const data = pickUserAISettingsForDb(settings)
+    if (Object.keys(data).length === 0) {
+      return { success: true }
+    }
+
+    // Valeurs scalaires uniquement (pickUserAISettingsForDb) — cast pour éviter UpdateOperations vs create.
+    const payload = data as Record<string, string | boolean | undefined>
+
+    // Upsert settings (create if not exists, update if exists)
+    await prisma.userAISettings.upsert({
+      where: { userId: session.user.id },
+      create: {
+        userId: session.user.id,
+        ...payload,
+      },
+      update: payload,
+    })
+
+    revalidatePath('/settings/ai', 'page')
+    revalidatePath('/settings/appearance', 'page')
+    revalidatePath('/', 'layout')
+    updateTag('ai-settings')
+
+    return { success: true }
+  } catch (error) {
+    console.error('Error updating AI settings:', error)
+    const raw = error instanceof Error ? error.message : String(error)
+    const isSchema =
+      /no such column|notesViewMode|Unknown column|does not exist/i.test(raw) ||
+      (typeof raw === 'string' && raw.includes('UserAISettings') && raw.includes('column'))
+    if (isSchema) {
+      throw new Error(
+        'Schéma base de données obsolète : colonne notesViewMode manquante. Dans le dossier memento-note, exécutez : npx prisma db push (ou appliquez les migrations Prisma).'
+      )
+    }
+    throw new Error('Failed to update AI settings')
+  }
+}
+
+/**
+ * Get AI settings for the current user (Cached)
+ */
+import { unstable_cache } from 'next/cache'
+
+// Internal cached function to fetch settings from DB
+const getCachedAISettings = unstable_cache(
+  async (userId: string) => {
+    try {
+      const settings = await prisma.userAISettings.findUnique({
+        where: { userId }
+      })
+
+      if (!settings) {
+        return {
+          titleSuggestions: true,
+          semanticSearch: true,
+          paragraphRefactor: true,
+          memoryEcho: true,
+          memoryEchoFrequency: 'daily' as const,
+          aiProvider: 'auto' as const,
+          preferredLanguage: 'auto' as const,
+          demoMode: false,
+          showRecentNotes: false,
+          notesViewMode: 'masonry' as const,
+          emailNotifications: false,
+          desktopNotifications: false,
+          anonymousAnalytics: false,
+          theme: 'light' as const,
+          fontSize: 'medium' as const
+        }
+      }
+
+      const raw = settings.notesViewMode
+      const viewMode =
+        raw === 'masonry'
+          ? ('masonry' as const)
+          : raw === 'list' || raw === 'tabs'
+            ? ('tabs' as const)
+            : ('masonry' as const)
+
+      return {
+        titleSuggestions: settings.titleSuggestions,
+        semanticSearch: settings.semanticSearch,
+        paragraphRefactor: settings.paragraphRefactor,
+        memoryEcho: settings.memoryEcho,
+        memoryEchoFrequency: (settings.memoryEchoFrequency || 'daily') as 'daily' | 'weekly' | 'custom',
+        aiProvider: (settings.aiProvider || 'auto') as 'auto' | 'openai' | 'ollama',
+        preferredLanguage: (settings.preferredLanguage || 'auto') as 'auto' | 'en' | 'fr' | 'es' | 'de' | 'fa' | 'it' | 'pt' | 'ru' | 'zh' | 'ja' | 'ko' | 'ar' | 'hi' | 'nl' | 'pl',
+        demoMode: settings.demoMode,
+        showRecentNotes: settings.showRecentNotes,
+        notesViewMode: viewMode,
+        emailNotifications: settings.emailNotifications,
+        desktopNotifications: settings.desktopNotifications,
+        anonymousAnalytics: settings.anonymousAnalytics,
+        // theme: 'light' as const, // REMOVED: Should not be handled here or hardcoded
+        fontSize: (settings.fontSize || 'medium') as 'small' | 'medium' | 'large'
+      }
+    } catch (error) {
+      console.error('Error getting AI settings:', error)
+      // Return defaults on error
+      return {
+        titleSuggestions: true,
+        semanticSearch: true,
+        paragraphRefactor: true,
+        memoryEcho: true,
+        memoryEchoFrequency: 'daily' as const,
+        aiProvider: 'auto' as const,
+        preferredLanguage: 'auto' as const,
+        demoMode: false,
+        showRecentNotes: false,
+        notesViewMode: 'masonry' as const,
+        emailNotifications: false,
+        desktopNotifications: false,
+        anonymousAnalytics: false,
+        theme: 'light' as const,
+        fontSize: 'medium' as const
+      }
+    }
+  },
+  ['user-ai-settings'],
+  { tags: ['ai-settings'] }
+)
+
+export async function getAISettings(userId?: string) {
+  let id = userId
+
+  if (!id) {
+    const session = await auth()
+    id = session?.user?.id
+  }
+
+  // Return defaults for non-logged-in users
+  if (!id) {
+    return {
+      titleSuggestions: true,
+      semanticSearch: true,
+      paragraphRefactor: true,
+      memoryEcho: true,
+      memoryEchoFrequency: 'daily' as const,
+      aiProvider: 'auto' as const,
+      preferredLanguage: 'auto' as const,
+      demoMode: false,
+      showRecentNotes: false,
+      notesViewMode: 'masonry' as const,
+      emailNotifications: false,
+      desktopNotifications: false,
+      anonymousAnalytics: false,
+      theme: 'light' as const,
+      fontSize: 'medium' as const
+    }
+  }
+
+  return getCachedAISettings(id)
+}
+
+/**
+ * Get user's preferred AI provider
+ */
+export async function getUserAIPreference(): Promise<'auto' | 'openai' | 'ollama'> {
+  const settings = await getAISettings()
+  return settings.aiProvider
+}
+
+/**
+ * Check if a specific AI feature is enabled for the user
+ */
+export async function isAIFeatureEnabled(feature: keyof UserAISettingsData): Promise<boolean> {
+  const settings = await getAISettings()
+
+  switch (feature) {
+    case 'titleSuggestions':
+      return settings.titleSuggestions
+    case 'semanticSearch':
+      return settings.semanticSearch
+    case 'paragraphRefactor':
+      return settings.paragraphRefactor
+    case 'memoryEcho':
+      return settings.memoryEcho
+    default:
+      return true
+  }
+}

memento-note/app/actions/auth-reset.ts

@@ -0,0 +1,90 @@
+'use server'
+
+import prisma from '@/lib/prisma'
+import { sendEmail } from '@/lib/mail'
+import { getSystemConfig } from '@/lib/config'
+import bcrypt from 'bcryptjs'
+import { getEmailTemplate } from '@/lib/email-template'
+
+// Helper simple pour générer un token sans dépendance externe lourde
+function generateToken() {
+  const array = new Uint8Array(32);
+  globalThis.crypto.getRandomValues(array);
+  return Array.from(array, byte => byte.toString(16).padStart(2, '0')).join('');
+}
+
+export async function forgotPassword(email: string) {
+  if (!email) return { error: "Email is required" };
+
+  try {
+    const user = await prisma.user.findUnique({ where: { email: email.toLowerCase() } });
+    if (!user) {
+      // Pour des raisons de sécurité, on ne dit pas si l'email existe ou pas
+      return { success: true }; 
+    }
+
+    const token = generateToken();
+    const expiry = new Date(Date.now() + 3600000); // 1 hour
+
+    await prisma.user.update({
+      where: { id: user.id },
+      data: {
+        resetToken: token,
+        resetTokenExpiry: expiry
+      }
+    });
+
+    const resetLink = `${process.env.NEXTAUTH_URL || 'http://localhost:3000'}/reset-password?token=${token}`;
+
+    const html = getEmailTemplate(
+      "Reset your Password",
+      "<p>You requested a password reset for your Memento account.</p><p>Click the button below to set a new password. This link is valid for 1 hour.</p>",
+      resetLink,
+      "Reset Password"
+    );
+
+    const sysConfig = await getSystemConfig()
+    const emailProvider = (sysConfig.EMAIL_PROVIDER || 'auto') as 'resend' | 'smtp' | 'auto'
+
+    await sendEmail({
+      to: user.email,
+      subject: "Reset your Memento password",
+      html
+    }, emailProvider);
+
+    return { success: true };
+  } catch (error) {
+    console.error('Forgot password error:', error);
+    return { error: "Failed to send reset email" };
+  }
+}
+
+export async function resetPassword(token: string, newPassword: string) {
+  if (!token || !newPassword) return { error: "Missing token or password" };
+
+  try {
+    const user = await prisma.user.findUnique({
+      where: { resetToken: token }
+    });
+
+    if (!user || !user.resetTokenExpiry || user.resetTokenExpiry < new Date()) {
+      return { error: "Invalid or expired token" };
+    }
+
+    const hashedPassword = await bcrypt.hash(newPassword, 10);
+
+    await prisma.user.update({
+      where: { id: user.id },
+      data: {
+        password: hashedPassword,
+        resetToken: null,
+        resetTokenExpiry: null
+      }
+    });
+
+    return { success: true };
+  } catch (error) {
+    console.error('Reset password error:', error);
+    return { error: "Failed to reset password" };
+  }
+}

memento-note/app/actions/auth.ts

@@ -0,0 +1,29 @@
+'use server';
+
+import { signIn } from '@/auth';
+import { AuthError } from 'next-auth';
+
+export async function authenticate(
+  prevState: string | undefined,
+  formData: FormData,
+) {
+  try {
+    await signIn('credentials', {
+      email: formData.get('email'),
+      password: formData.get('password'),
+      redirectTo: '/',
+    });
+  } catch (error) {
+    if (error instanceof AuthError) {
+      console.error('AuthError details:', error.type, error.message);
+      switch (error.type) {
+        case 'CredentialsSignin':
+          return 'Invalid credentials.';
+        default:
+          return `Auth error: ${error.type}`;
+      }
+    }
+    // IMPORTANT: Next.js redirects throw a special error that must be rethrown
+    throw error;
+  }
+}

memento-note/app/actions/canvas-actions.ts

@@ -0,0 +1,111 @@
+'use server'
+
+import { auth } from '@/auth'
+import { prisma } from '@/lib/prisma'
+import { revalidatePath } from 'next/cache'
+
+export async function saveCanvas(id: string | null, name: string, data: string) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  if (id) {
+    const canvas = await prisma.canvas.update({
+      where: { id, userId: session.user.id },
+      data: { name, data }
+    })
+    revalidatePath('/lab')
+    return { success: true, canvas }
+  } else {
+    const canvas = await prisma.canvas.create({
+      data: {
+        name,
+        data,
+        userId: session.user.id
+      }
+    })
+    revalidatePath('/lab')
+    return { success: true, canvas }
+  }
+}
+
+export async function getCanvases() {
+  const session = await auth()
+  if (!session?.user?.id) return []
+
+  return prisma.canvas.findMany({
+    where: { userId: session.user.id },
+    orderBy: { createdAt: 'asc' }
+  })
+}
+
+export async function getCanvasDetails(id: string) {
+  const session = await auth()
+  if (!session?.user?.id) return null
+
+  return prisma.canvas.findUnique({
+    where: { id, userId: session.user.id }
+  })
+}
+
+export async function deleteCanvas(id: string) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  await prisma.canvas.delete({
+    where: { id, userId: session.user.id }
+  })
+
+  revalidatePath('/lab')
+  return { success: true }
+}
+
+export async function renameCanvas(id: string, name: string) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  await prisma.canvas.update({
+    where: { id, userId: session.user.id },
+    data: { name }
+  })
+
+  revalidatePath('/lab')
+  return { success: true }
+}
+
+export async function createCanvas(lang?: string) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const count = await prisma.canvas.count({
+    where: { userId: session.user.id }
+  })
+
+  const defaultNames: Record<string, string> = {
+    en: `Space ${count + 1}`,
+    fr: `Espace ${count + 1}`,
+    fa: `فضای ${count + 1}`,
+    es: `Espacio ${count + 1}`,
+    de: `Bereich ${count + 1}`,
+    it: `Spazio ${count + 1}`,
+    pt: `Espaço ${count + 1}`,
+    ru: `Пространство ${count + 1}`,
+    ja: `スペース ${count + 1}`,
+    ko: `공간 ${count + 1}`,
+    zh: `空间 ${count + 1}`,
+    ar: `مساحة ${count + 1}`,
+    hi: `स्थान ${count + 1}`,
+    nl: `Ruimte ${count + 1}`,
+    pl: `Przestrzeń ${count + 1}`,
+  }
+
+  const newCanvas = await prisma.canvas.create({
+    data: {
+      name: defaultNames[lang || 'en'] || defaultNames.en,
+      data: JSON.stringify({}),
+      userId: session.user.id
+    }
+  })
+
+  revalidatePath('/lab')
+  return newCanvas
+}

memento-note/app/actions/chat-actions.ts

@@ -0,0 +1,74 @@
+'use server'
+
+import { chatService } from '@/lib/ai/services'
+import { auth } from '@/auth'
+import { revalidatePath } from 'next/cache'
+import { prisma } from '@/lib/prisma'
+
+/**
+ * Create a new empty conversation and return its id.
+ * Called before streaming so the client knows the conversationId upfront.
+ */
+export async function createConversation(title: string, notebookId?: string) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const conversation = await prisma.conversation.create({
+    data: {
+      userId: session.user.id,
+      notebookId: notebookId || null,
+      title: title.substring(0, 80) + (title.length > 80 ? '...' : ''),
+    },
+  })
+
+  revalidatePath('/chat')
+  return { id: conversation.id, title: conversation.title }
+}
+
+/**
+ * @deprecated Use the streaming API route /api/chat instead.
+ * Kept for backward compatibility with the debug route.
+ */
+export async function sendChatMessage(
+  message: string,
+  conversationId?: string,
+  notebookId?: string
+) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  try {
+    const result = await chatService.chat(message, conversationId, notebookId)
+    revalidatePath('/chat')
+    return { success: true, ...result }
+  } catch (error: any) {
+    console.error('[ChatAction] Error:', error)
+    return { success: false, error: error.message }
+  }
+}
+
+export async function getConversations() {
+  const session = await auth()
+  if (!session?.user?.id) return []
+
+  return chatService.listConversations(session.user.id)
+}
+
+export async function getConversationDetails(id: string) {
+  const session = await auth()
+  if (!session?.user?.id) return null
+
+  return chatService.getHistory(id)
+}
+
+export async function deleteConversation(id: string) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  await prisma.conversation.delete({
+    where: { id, userId: session.user.id }
+  })
+
+  revalidatePath('/chat')
+  return { success: true }
+}

memento-note/app/actions/custom-provider.ts

@@ -0,0 +1,114 @@
+'use server'
+
+interface OpenAIModel {
+  id: string
+  object: string
+  created?: number
+  owned_by?: string
+}
+
+interface OpenAIModelsResponse {
+  object: string
+  data: OpenAIModel[]
+}
+
+async function fetchModelsFromEndpoint(
+  endpoint: string,
+  apiKey?: string
+): Promise<{ success: boolean; models: string[]; error?: string }> {
+  try {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    }
+    if (apiKey) {
+      headers['Authorization'] = `Bearer ${apiKey}`
+    }
+
+    const response = await fetch(endpoint, {
+      method: 'GET',
+      headers,
+      signal: AbortSignal.timeout(8000),
+    })
+
+    if (!response.ok) {
+      throw new Error(`API returned ${response.status}: ${response.statusText}`)
+    }
+
+    const data = await response.json() as OpenAIModelsResponse
+
+    const modelIds = (data.data || [])
+      .map((m) => m.id)
+      .filter(Boolean)
+      .sort()
+
+    return { success: true, models: modelIds }
+  } catch (error: any) {
+    console.error('Failed to fetch provider models:', error)
+    return {
+      success: false,
+      models: [],
+      error: error.message || 'Failed to connect to provider',
+    }
+  }
+}
+
+/**
+ * Fetch all models from a custom OpenAI-compatible provider.
+ * Uses GET /v1/models (standard endpoint).
+ */
+export async function getCustomModels(
+  baseUrl: string,
+  apiKey?: string
+): Promise<{ success: boolean; models: string[]; error?: string }> {
+  if (!baseUrl) {
+    return { success: false, models: [], error: 'Base URL is required' }
+  }
+
+  const cleanUrl = baseUrl.replace(/\/$/, '').replace(/\/v1$/, '')
+  return fetchModelsFromEndpoint(`${cleanUrl}/v1/models`, apiKey)
+}
+
+/**
+ * Fetch embedding-specific models from a custom provider.
+ * Tries GET /v1/embeddings/models first (OpenRouter-specific endpoint that returns
+ * only embedding models). Falls back to GET /v1/models filtered by common
+ * embedding model name patterns if the dedicated endpoint is unavailable.
+ */
+export async function getCustomEmbeddingModels(
+  baseUrl: string,
+  apiKey?: string
+): Promise<{ success: boolean; models: string[]; error?: string }> {
+  if (!baseUrl) {
+    return { success: false, models: [], error: 'Base URL is required' }
+  }
+
+  const cleanUrl = baseUrl.replace(/\/$/, '').replace(/\/v1$/, '')
+
+  // Try the OpenRouter-specific embeddings models endpoint first
+  const embeddingsEndpoint = await fetchModelsFromEndpoint(
+    `${cleanUrl}/v1/embeddings/models`,
+    apiKey
+  )
+
+  if (embeddingsEndpoint.success && embeddingsEndpoint.models.length > 0) {
+    return embeddingsEndpoint
+  }
+
+  // Fallback: fetch all models and filter by common embedding name patterns
+  const allModels = await fetchModelsFromEndpoint(`${cleanUrl}/v1/models`, apiKey)
+
+  if (!allModels.success) {
+    return allModels
+  }
+
+  const embeddingKeywords = ['embed', 'embedding', 'ada', 'e5', 'bge', 'gte', 'minilm']
+  const filtered = allModels.models.filter((id) =>
+    embeddingKeywords.some((kw) => id.toLowerCase().includes(kw))
+  )
+
+  // If the filter finds nothing, return all models so the user can still pick
+  return {
+    success: true,
+    models: filtered.length > 0 ? filtered : allModels.models,
+  }
+}

memento-note/app/actions/detect-language.ts

@@ -0,0 +1,12 @@
+'use server'
+
+import { detectUserLanguage } from '@/lib/i18n/detect-user-language'
+import { SupportedLanguage } from '@/lib/i18n/load-translations'
+
+/**
+ * Server action to detect user's preferred language
+ * Called on app load to set initial language
+ */
+export async function getInitialLanguage(): Promise<SupportedLanguage> {
+  return await detectUserLanguage()
+}

memento-note/app/actions/mcp-keys.ts

@@ -0,0 +1,167 @@
+'use server'
+
+import { auth } from '@/auth'
+import { prisma } from '@/lib/prisma'
+import { revalidatePath } from 'next/cache'
+import { createHash, randomBytes } from 'crypto'
+
+const KEY_PREFIX = 'mcp_key_'
+
+function hashKey(rawKey: string): string {
+  return createHash('sha256').update(rawKey).digest('hex')
+}
+
+export type McpKeyInfo = {
+  shortId: string
+  name: string
+  userId: string
+  userName: string
+  active: boolean
+  createdAt: string
+  lastUsedAt: string | null
+}
+
+/**
+ * List all MCP API keys for the current user.
+ */
+export async function listMcpKeys(): Promise<McpKeyInfo[]> {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const allKeys = await prisma.systemConfig.findMany({
+    where: { key: { startsWith: KEY_PREFIX } },
+  })
+
+  const keys: McpKeyInfo[] = []
+  for (const entry of allKeys) {
+    try {
+      const info = JSON.parse(entry.value)
+      if (info.userId !== session.user.id) continue
+      keys.push({
+        shortId: info.shortId,
+        name: info.name,
+        userId: info.userId,
+        userName: info.userName,
+        active: info.active,
+        createdAt: info.createdAt,
+        lastUsedAt: info.lastUsedAt,
+      })
+    } catch {
+      // skip invalid JSON
+    }
+  }
+
+  return keys
+}
+
+/**
+ * Generate a new MCP API key for the current user.
+ * Returns the raw key (shown only once) and key info.
+ */
+export async function generateMcpKey(name: string): Promise<{ rawKey: string; info: { shortId: string; name: string } }> {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const user = await prisma.user.findUnique({
+    where: { id: session.user.id },
+    select: { id: true, name: true, email: true },
+  })
+  if (!user) throw new Error('User not found')
+
+  const rawBytes = randomBytes(24)
+  const shortId = rawBytes.toString('hex').substring(0, 8)
+  const rawKey = `mcp_sk_${rawBytes.toString('hex')}`
+  const keyHash = hashKey(rawKey)
+
+  const keyInfo = {
+    shortId,
+    name: name || `Key for ${user.name}`,
+    userId: user.id,
+    userName: user.name,
+    userEmail: user.email,
+    keyHash,
+    createdAt: new Date().toISOString(),
+    lastUsedAt: null,
+    active: true,
+  }
+
+  await prisma.systemConfig.create({
+    data: {
+      key: `${KEY_PREFIX}${shortId}`,
+      value: JSON.stringify(keyInfo),
+    },
+  })
+
+  revalidatePath('/settings/mcp')
+
+  return {
+    rawKey,
+    info: { shortId, name: keyInfo.name },
+  }
+}
+
+/**
+ * Revoke (deactivate) an MCP API key. Only the owner can revoke.
+ */
+export async function revokeMcpKey(shortId: string): Promise<boolean> {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const configKey = `${KEY_PREFIX}${shortId}`
+  const entry = await prisma.systemConfig.findUnique({ where: { key: configKey } })
+  if (!entry) throw new Error('Key not found')
+
+  const info = JSON.parse(entry.value)
+  if (info.userId !== session.user.id) throw new Error('Forbidden')
+  if (!info.active) return false
+
+  info.active = false
+  info.revokedAt = new Date().toISOString()
+
+  await prisma.systemConfig.update({
+    where: { key: configKey },
+    data: { value: JSON.stringify(info) },
+  })
+
+  revalidatePath('/settings/mcp')
+  return true
+}
+
+/**
+ * Permanently delete an MCP API key. Only the owner can delete.
+ */
+export async function deleteMcpKey(shortId: string): Promise<boolean> {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const configKey = `${KEY_PREFIX}${shortId}`
+  const entry = await prisma.systemConfig.findUnique({ where: { key: configKey } })
+  if (!entry) throw new Error('Key not found')
+
+  const info = JSON.parse(entry.value)
+  if (info.userId !== session.user.id) throw new Error('Forbidden')
+
+  try {
+    await prisma.systemConfig.delete({ where: { key: configKey } })
+    revalidatePath('/settings/mcp')
+    return true
+  } catch {
+    return false
+  }
+}
+
+export type McpServerStatus = {
+  mode: 'stdio' | 'sse' | 'unknown'
+  url: string | null
+}
+
+/**
+ * Get MCP server status — mode and URL.
+ */
+export async function getMcpServerStatus(): Promise<McpServerStatus> {
+  // Check if SSE mode is configured via env
+  const mode = process.env.MCP_SERVER_MODE === 'sse' ? 'sse' : 'stdio'
+  const url = process.env.MCP_SERVER_URL || null
+
+  return { mode, url }
+}

memento-note/app/actions/ollama.ts

@@ -0,0 +1,57 @@
+'use server'
+
+interface OllamaModel {
+    name: string
+    modified_at: string
+    size: number
+    digest: string
+    details: {
+        format: string
+        family: string
+        families: string[]
+        parameter_size: string
+        quantization_level: string
+    }
+}
+
+interface OllamaTagsResponse {
+    models: OllamaModel[]
+}
+
+export async function getOllamaModels(baseUrl: string): Promise<{ success: boolean; models: string[]; error?: string }> {
+    if (!baseUrl) {
+        return { success: false, models: [], error: 'Base URL is required' }
+    }
+
+    // Ensure URL doesn't end with slash
+    const cleanUrl = baseUrl.replace(/\/$/, '')
+
+    try {
+        const response = await fetch(`${cleanUrl}/api/tags`, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            // Set a reasonable timeout
+            signal: AbortSignal.timeout(5000)
+        })
+
+        if (!response.ok) {
+            throw new Error(`Ollama API returned ${response.status}: ${response.statusText}`)
+        }
+
+        const data = await response.json() as OllamaTagsResponse
+
+        // Extract model names
+        const modelNames = data.models?.map(m => m.name) || []
+
+        return { success: true, models: modelNames }
+    } catch (error: any) {
+        console.error('Failed to fetch Ollama models:', error)
+        return {
+            success: false,
+            models: [],
+            error: error.message || 'Failed to connect to Ollama'
+        }
+    }
+}

memento-note/app/actions/paragraph-refactor.ts

@@ -0,0 +1,49 @@
+'use server'
+
+import { paragraphRefactorService, RefactorMode, RefactorResult } from '@/lib/ai/services/paragraph-refactor.service'
+
+export interface RefactorResponse {
+  result: RefactorResult
+}
+
+/**
+ * Refactor a paragraph with a specific mode
+ */
+export async function refactorParagraph(
+  content: string,
+  mode: RefactorMode
+): Promise<RefactorResponse> {
+  try {
+    const result = await paragraphRefactorService.refactor(content, mode)
+
+    return { result }
+  } catch (error) {
+    console.error('Error refactoring paragraph:', error)
+    throw error
+  }
+}
+
+/**
+ * Get all 3 refactor options at once
+ */
+export async function refactorParagraphAllModes(
+  content: string
+): Promise<{ results: RefactorResult[] }> {
+  try {
+    const results = await paragraphRefactorService.refactorAllModes(content)
+
+    return { results }
+  } catch (error) {
+    console.error('Error refactoring paragraph in all modes:', error)
+    throw error
+  }
+}
+
+/**
+ * Validate word count before refactoring
+ */
+export async function validateRefactorWordCount(
+  content: string
+): Promise<{ valid: boolean; error?: string }> {
+  return paragraphRefactorService.validateWordCount(content)
+}

memento-note/app/actions/profile-broken.ts

@@ -0,0 +1,232 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+import bcrypt from 'bcryptjs'
+import { z } from 'zod'
+
+const ProfileSchema = z.object({
+  name: z.string().min(2, "Name must be at least 2 characters"),
+  email: z.string().email().optional(), // Email change might require verification logic, keeping it simple for now or read-only
+})
+
+const PasswordSchema = z.object({
+  currentPassword: z.string().min(1, "Current password is required"),
+  newPassword: z.string().min(6, "New password must be at least 6 characters"),
+  confirmPassword: z.string().min(6, "Confirm password must be at least 6 characters"),
+}).refine((data) => data.newPassword === data.confirmPassword, {
+  message: "Passwords don't match",
+  path: ["confirmPassword"],
+})
+
+export async function updateProfile(data: { name: string }) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const validated = ProfileSchema.safeParse(data)
+  if (!validated.success) {
+    return { error: validated.error.flatten().fieldErrors }
+  }
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { name: validated.data.name },
+    })
+    revalidatePath('/settings/profile')
+    return { success: true }
+  } catch (error) {
+    return { error: { _form: ['Failed to update profile'] } }
+  }
+}
+
+export async function changePassword(formData: FormData) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const rawData = {
+    currentPassword: formData.get('currentPassword'),
+    newPassword: formData.get('newPassword'),
+    confirmPassword: formData.get('confirmPassword'),
+  }
+
+  const validated = PasswordSchema.safeParse(rawData)
+  if (!validated.success) {
+    return { error: validated.error.flatten().fieldErrors }
+  }
+
+  const { currentPassword, newPassword } = validated.data
+
+  const user = await prisma.user.findUnique({
+    where: { id: session.user.id },
+  })
+
+  if (!user || !user.password) {
+    return { error: { _form: ['User not found'] } }
+  }
+
+  const passwordsMatch = await bcrypt.compare(currentPassword, user.password)
+  if (!passwordsMatch) {
+    return { error: { currentPassword: ['Incorrect current password'] } }
+  }
+
+  const hashedPassword = await bcrypt.hash(newPassword, 10)
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { password: hashedPassword },
+    })
+    return { success: true }
+  } catch (error) {
+    return { error: { _form: ['Failed to change password'] } }
+  }
+}
+
+export async function updateTheme(theme: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { theme },
+    })
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true }
+  } catch (error) {
+    return { error: 'Failed to update theme' }
+  }
+}
+
+export async function updateLanguage(language: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    // Update or create UserAISettings with the preferred language
+    await prisma.userAISettings.upsert({
+      where: { userId: session.user.id },
+      create: {
+        userId: session.user.id,
+        preferredLanguage: language,
+      },
+      update: {
+        preferredLanguage: language,
+      },
+    })
+
+    // Note: The language will be applied on next page load
+    // The client component should handle updating localStorage and reloading
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, language }
+  } catch (error) {
+    console.error('Failed to update language:', error)
+    return { error: 'Failed to update language' }
+  }
+}
+
+export async function updateFontSize(fontSize: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    // Check if UserAISettings exists
+    const existing = await prisma.userAISettings.findUnique({
+      where: { userId: session.user.id }
+    })
+
+    let result
+    if (existing) {
+      // Update existing - only update fontSize field
+      result = await prisma.userAISettings.update({
+        where: { userId: session.user.id },
+        data: { fontSize: fontSize }
+      })
+      } else {
+      // Create new with all required fields
+      result = await prisma.userAISettings.create({
+        data: {
+          userId: session.user.id,
+          fontSize: fontSize,
+          // Set default values for required fields
+          titleSuggestions: true,
+          semanticSearch: true,
+          paragraphRefactor: true,
+          memoryEcho: true,
+          memoryEchoFrequency: 'daily',
+          aiProvider: 'auto',
+          preferredLanguage: 'auto',
+          showRecentNotes: false
+        }
+      })
+      }
+
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, fontSize }
+  } catch (error) {
+    console.error('[updateFontSize] Failed to update font size:', error)
+    return { error: 'Failed to update font size' }
+  }
+}
+
+export async function updateShowRecentNotes(showRecentNotes: boolean) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    // Use EXACT same pattern as updateFontSize which works
+    const existing = await prisma.userAISettings.findUnique({
+      where: { userId: session.user.id }
+    })
+
+    if (existing) {
+      // Try Prisma client first, fallback to raw SQL if field doesn't exist in client
+      try {
+        await prisma.userAISettings.update({
+          where: { userId: session.user.id },
+          data: { showRecentNotes: showRecentNotes } as any
+        })
+      } catch (prismaError: any) {
+        // If Prisma client doesn't know about showRecentNotes, use raw SQL
+        if (prismaError?.message?.includes('Unknown argument') || prismaError?.code === 'P2009') {
+          const value = showRecentNotes ? 1 : 0
+          await prisma.$executeRaw`
+            UPDATE UserAISettings 
+            SET showRecentNotes = ${value}
+            WHERE userId = ${session.user.id}
+          `
+        } else {
+          throw prismaError
+        }
+      }
+    } else {
+      // Create new - same as updateFontSize
+      await prisma.userAISettings.create({
+        data: {
+          userId: session.user.id,
+          titleSuggestions: true,
+          semanticSearch: true,
+          paragraphRefactor: true,
+          memoryEcho: true,
+          memoryEchoFrequency: 'daily',
+          aiProvider: 'auto',
+          preferredLanguage: 'auto',
+          fontSize: 'medium',
+          showRecentNotes: showRecentNotes
+        } as any
+      })
+    }
+
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, showRecentNotes }
+  } catch (error) {
+    console.error('[updateShowRecentNotes] Failed:', error)
+    return { error: 'Failed to update show recent notes setting' }
+  }
+}

memento-note/app/actions/profile-old.ts

@@ -0,0 +1,232 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+import bcrypt from 'bcryptjs'
+import { z } from 'zod'
+
+const ProfileSchema = z.object({
+  name: z.string().min(2, "Name must be at least 2 characters"),
+  email: z.string().email().optional(), // Email change might require verification logic, keeping it simple for now or read-only
+})
+
+const PasswordSchema = z.object({
+  currentPassword: z.string().min(1, "Current password is required"),
+  newPassword: z.string().min(6, "New password must be at least 6 characters"),
+  confirmPassword: z.string().min(6, "Confirm password must be at least 6 characters"),
+}).refine((data) => data.newPassword === data.confirmPassword, {
+  message: "Passwords don't match",
+  path: ["confirmPassword"],
+})
+
+export async function updateProfile(data: { name: string }) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const validated = ProfileSchema.safeParse(data)
+  if (!validated.success) {
+    return { error: validated.error.flatten().fieldErrors }
+  }
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { name: validated.data.name },
+    })
+    revalidatePath('/settings/profile')
+    return { success: true }
+  } catch (error) {
+    return { error: { _form: ['Failed to update profile'] } }
+  }
+}
+
+export async function changePassword(formData: FormData) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const rawData = {
+    currentPassword: formData.get('currentPassword'),
+    newPassword: formData.get('newPassword'),
+    confirmPassword: formData.get('confirmPassword'),
+  }
+
+  const validated = PasswordSchema.safeParse(rawData)
+  if (!validated.success) {
+    return { error: validated.error.flatten().fieldErrors }
+  }
+
+  const { currentPassword, newPassword } = validated.data
+
+  const user = await prisma.user.findUnique({
+    where: { id: session.user.id },
+  })
+
+  if (!user || !user.password) {
+    return { error: { _form: ['User not found'] } }
+  }
+
+  const passwordsMatch = await bcrypt.compare(currentPassword, user.password)
+  if (!passwordsMatch) {
+    return { error: { currentPassword: ['Incorrect current password'] } }
+  }
+
+  const hashedPassword = await bcrypt.hash(newPassword, 10)
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { password: hashedPassword },
+    })
+    return { success: true }
+  } catch (error) {
+    return { error: { _form: ['Failed to change password'] } }
+  }
+}
+
+export async function updateTheme(theme: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { theme },
+    })
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true }
+  } catch (error) {
+    return { error: 'Failed to update theme' }
+  }
+}
+
+export async function updateLanguage(language: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    // Update or create UserAISettings with the preferred language
+    await prisma.userAISettings.upsert({
+      where: { userId: session.user.id },
+      create: {
+        userId: session.user.id,
+        preferredLanguage: language,
+      },
+      update: {
+        preferredLanguage: language,
+      },
+    })
+
+    // Note: The language will be applied on next page load
+    // The client component should handle updating localStorage and reloading
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, language }
+  } catch (error) {
+    console.error('Failed to update language:', error)
+    return { error: 'Failed to update language' }
+  }
+}
+
+export async function updateFontSize(fontSize: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    // Check if UserAISettings exists
+    const existing = await prisma.userAISettings.findUnique({
+      where: { userId: session.user.id }
+    })
+
+    let result
+    if (existing) {
+      // Update existing - only update fontSize field
+      result = await prisma.userAISettings.update({
+        where: { userId: session.user.id },
+        data: { fontSize: fontSize }
+      })
+      } else {
+      // Create new with all required fields
+      result = await prisma.userAISettings.create({
+        data: {
+          userId: session.user.id,
+          fontSize: fontSize,
+          // Set default values for required fields
+          titleSuggestions: true,
+          semanticSearch: true,
+          paragraphRefactor: true,
+          memoryEcho: true,
+          memoryEchoFrequency: 'daily',
+          aiProvider: 'auto',
+          preferredLanguage: 'auto',
+          showRecentNotes: false
+        }
+      })
+      }
+
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, fontSize }
+  } catch (error) {
+    console.error('[updateFontSize] Failed to update font size:', error)
+    return { error: 'Failed to update font size' }
+  }
+}
+
+export async function updateShowRecentNotes(showRecentNotes: boolean) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    // Use EXACT same pattern as updateFontSize which works
+    const existing = await prisma.userAISettings.findUnique({
+      where: { userId: session.user.id }
+    })
+
+    if (existing) {
+      // Try Prisma client first, fallback to raw SQL if field doesn't exist in client
+      try {
+        await prisma.userAISettings.update({
+          where: { userId: session.user.id },
+          data: { showRecentNotes: showRecentNotes } as any
+        })
+      } catch (prismaError: any) {
+        // If Prisma client doesn't know about showRecentNotes, use raw SQL
+        if (prismaError?.message?.includes('Unknown argument') || prismaError?.code === 'P2009') {
+          const value = showRecentNotes ? 1 : 0
+          await prisma.$executeRaw`
+            UPDATE UserAISettings 
+            SET showRecentNotes = ${value}
+            WHERE userId = ${session.user.id}
+          `
+        } else {
+          throw prismaError
+        }
+      }
+    } else {
+      // Create new - same as updateFontSize
+      await prisma.userAISettings.create({
+        data: {
+          userId: session.user.id,
+          titleSuggestions: true,
+          semanticSearch: true,
+          paragraphRefactor: true,
+          memoryEcho: true,
+          memoryEchoFrequency: 'daily',
+          aiProvider: 'auto',
+          preferredLanguage: 'auto',
+          fontSize: 'medium',
+          showRecentNotes: showRecentNotes
+        } as any
+      })
+    }
+
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, showRecentNotes }
+  } catch (error) {
+    console.error('[updateShowRecentNotes] Failed:', error)
+    return { error: 'Failed to update show recent notes setting' }
+  }
+}

memento-note/app/actions/profile.ts

@@ -0,0 +1,201 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+import bcrypt from 'bcryptjs'
+import { z } from 'zod'
+
+const ProfileSchema = z.object({
+  name: z.string().min(2, "Name must be at least 2 characters"),
+  email: z.string().email().optional(), // Email change might require verification logic, keeping it simple for now or read-only
+})
+
+const PasswordSchema = z.object({
+  currentPassword: z.string().min(1, "Current password is required"),
+  newPassword: z.string().min(6, "New password must be at least 6 characters"),
+  confirmPassword: z.string().min(6, "Confirm password must be at least 6 characters"),
+}).refine((data) => data.newPassword === data.confirmPassword, {
+  message: "Passwords don't match",
+  path: ["confirmPassword"],
+})
+
+export async function updateProfile(data: { name: string }) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const validated = ProfileSchema.safeParse(data)
+  if (!validated.success) {
+    return { error: validated.error.flatten().fieldErrors }
+  }
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { name: validated.data.name },
+    })
+    revalidatePath('/settings/profile')
+    return { success: true }
+  } catch (error) {
+    return { error: { _form: ['Failed to update profile'] } }
+  }
+}
+
+export async function changePassword(formData: FormData) {
+  const session = await auth()
+  if (!session?.user?.id) throw new Error('Unauthorized')
+
+  const rawData = {
+    currentPassword: formData.get('currentPassword'),
+    newPassword: formData.get('newPassword'),
+    confirmPassword: formData.get('confirmPassword'),
+  }
+
+  const validated = PasswordSchema.safeParse(rawData)
+  if (!validated.success) {
+    return { error: validated.error.flatten().fieldErrors }
+  }
+
+  const { currentPassword, newPassword } = validated.data
+
+  const user = await prisma.user.findUnique({
+    where: { id: session.user.id },
+  })
+
+  if (!user || !user.password) {
+    return { error: { _form: ['User not found'] } }
+  }
+
+  const passwordsMatch = await bcrypt.compare(currentPassword, user.password)
+  if (!passwordsMatch) {
+    return { error: { currentPassword: ['Incorrect current password'] } }
+  }
+
+  const hashedPassword = await bcrypt.hash(newPassword, 10)
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { password: hashedPassword },
+    })
+    return { success: true }
+  } catch (error) {
+    return { error: { _form: ['Failed to change password'] } }
+  }
+}
+
+export async function updateTheme(theme: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    await prisma.user.update({
+      where: { id: session.user.id },
+      data: { theme },
+    })
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true }
+  } catch (error) {
+    return { error: 'Failed to update theme' }
+  }
+}
+
+export async function updateLanguage(language: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    // Update or create UserAISettings with the preferred language
+    await prisma.userAISettings.upsert({
+      where: { userId: session.user.id },
+      create: {
+        userId: session.user.id,
+        preferredLanguage: language,
+      },
+      update: {
+        preferredLanguage: language,
+      },
+    })
+
+    // Note: The language will be applied on next page load
+    // The client component should handle updating localStorage and reloading
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, language }
+  } catch (error) {
+    console.error('Failed to update language:', error)
+    return { error: 'Failed to update language' }
+  }
+}
+
+export async function updateFontSize(fontSize: string) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    // Check if UserAISettings exists
+    const existing = await prisma.userAISettings.findUnique({
+      where: { userId: session.user.id }
+    })
+
+    let result
+    if (existing) {
+      // Update existing - only update fontSize field
+      result = await prisma.userAISettings.update({
+        where: { userId: session.user.id },
+        data: { fontSize: fontSize }
+      })
+    } else {
+      // Create new with all required fields
+      result = await prisma.userAISettings.create({
+        data: {
+          userId: session.user.id,
+          fontSize: fontSize,
+          // Set default values for required fields
+          titleSuggestions: true,
+          semanticSearch: true,
+          paragraphRefactor: true,
+          memoryEcho: true,
+          memoryEchoFrequency: 'daily',
+          aiProvider: 'auto',
+          preferredLanguage: 'auto',
+          showRecentNotes: false
+        }
+      })
+    }
+
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, fontSize }
+  } catch (error) {
+    console.error('[updateFontSize] Failed to update font size:', error)
+    return { error: 'Failed to update font size' }
+  }
+}
+
+export async function updateShowRecentNotes(showRecentNotes: boolean) {
+  const session = await auth()
+  if (!session?.user?.id) return { error: 'Unauthorized' }
+
+  try {
+    await prisma.userAISettings.upsert({
+      where: { userId: session.user.id },
+      create: {
+        userId: session.user.id,
+        showRecentNotes,
+        // Defaults will be used for other fields
+      },
+      update: {
+        showRecentNotes,
+      },
+    })
+
+    revalidatePath('/')
+    revalidatePath('/settings/profile')
+    return { success: true, showRecentNotes }
+  } catch (error) {
+    console.error('[updateShowRecentNotes] Failed:', error)
+    return { error: 'Failed to update show recent notes setting' }
+  }
+}

memento-note/app/actions/register.ts

@@ -0,0 +1,63 @@
+'use server';
+
+import bcrypt from 'bcryptjs';
+import prisma from '@/lib/prisma';
+import { z } from 'zod';
+import { redirect } from 'next/navigation';
+import { getSystemConfig } from '@/lib/config';
+
+const RegisterSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(6),
+  name: z.string().min(2),
+});
+
+export async function register(prevState: string | undefined, formData: FormData) {
+  // Check if registration is allowed
+  const config = await getSystemConfig();
+  const allowRegister = config.ALLOW_REGISTRATION !== 'false' && process.env.ALLOW_REGISTRATION !== 'false';
+
+  if (!allowRegister) {
+    return 'Registration is currently disabled by the administrator.';
+  }
+
+  const validatedFields = RegisterSchema.safeParse({
+    email: formData.get('email'),
+    password: formData.get('password'),
+    name: formData.get('name'),
+  });
+
+  if (!validatedFields.success) {
+    return 'Invalid fields. Failed to register.';
+  }
+
+  const { email, password, name } = validatedFields.data;
+
+  try {
+    const existingUser = await prisma.user.findUnique({ where: { email: email.toLowerCase() } });
+    if (existingUser) {
+      return 'User already exists.';
+    }
+
+    const hashedPassword = await bcrypt.hash(password, 10);
+
+    await prisma.user.create({
+      data: {
+        email: email.toLowerCase(),
+        password: hashedPassword,
+        name,
+      },
+    });
+    
+    // Attempt to sign in immediately after registration
+    // We cannot import signIn here directly if it causes circular deps or issues, 
+    // but usually it works. If not, redirecting to login is fine.
+    // Let's stick to redirecting to login but with a clear success message?
+    // Or better: lowercase the email to fix the potential bug.
+  } catch (error) {
+    console.error('Registration Error:', error);
+    return 'Database Error: Failed to create user.';
+  }
+
+  redirect('/login');
+}

memento-note/app/actions/scrape.ts

@@ -0,0 +1,59 @@
+'use server'
+
+import * as cheerio from 'cheerio';
+
+export interface LinkMetadata {
+  url: string;
+  title?: string;
+  description?: string;
+  imageUrl?: string;
+  siteName?: string;
+}
+
+export async function fetchLinkMetadata(url: string): Promise<LinkMetadata | null> {
+  try {
+    // Add protocol if missing
+    let targetUrl = url;
+    if (!url.startsWith('http://') && !url.startsWith('https://')) {
+      targetUrl = 'https://' + url;
+    }
+
+    const response = await fetch(targetUrl, {
+      headers: {
+        // Use a real browser User-Agent to avoid 403 Forbidden from strict sites
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+        'Accept-Language': 'en-US,en;q=0.5'
+      },
+      next: { revalidate: 3600 } // Cache for 1 hour
+    });
+
+    if (!response.ok) {
+      return null;
+    }
+
+    const html = await response.text();
+    const $ = cheerio.load(html);
+
+    const getMeta = (prop: string) => 
+      $(`meta[property="${prop}"]`).attr('content') || 
+      $(`meta[name="${prop}"]`).attr('content');
+
+    // Robust extraction with fallbacks
+    const title = getMeta('og:title') || $('title').text() || getMeta('twitter:title') || url;
+    const description = getMeta('og:description') || getMeta('description') || getMeta('twitter:description') || '';
+    const imageUrl = getMeta('og:image') || getMeta('twitter:image') || $('link[rel="image_src"]').attr('href');
+    const siteName = getMeta('og:site_name') || '';
+
+    return {
+      url: targetUrl,
+      title: title.substring(0, 100),
+      description: description.substring(0, 200),
+      imageUrl,
+      siteName
+    };
+  } catch (error) {
+    console.error(`[Scrape] Error fetching ${url}:`, error);
+    return null;
+  }
+}

memento-note/app/actions/semantic-search.ts

@@ -0,0 +1,63 @@
+'use server'
+
+import { semanticSearchService, SearchResult } from '@/lib/ai/services/semantic-search.service'
+
+export interface SemanticSearchResponse {
+  results: SearchResult[]
+  query: string
+  totalResults: number
+}
+
+/**
+ * Perform hybrid semantic + keyword search
+ * Supports contextual search within notebook (IA5)
+ */
+export async function semanticSearch(
+  query: string,
+  options?: {
+    limit?: number
+    threshold?: number
+    notebookId?: string // NEW: Filter by notebook for contextual search (IA5)
+  }
+): Promise<SemanticSearchResponse> {
+  try {
+    const results = await semanticSearchService.search(query, {
+      limit: options?.limit || 20,
+      threshold: options?.threshold || 0.6,
+      notebookId: options?.notebookId // NEW: Pass notebook filter
+    })
+
+    return {
+      results,
+      query,
+      totalResults: results.length
+    }
+  } catch (error) {
+    console.error('Error in semantic search action:', error)
+    throw error
+  }
+}
+
+/**
+ * Index a note for semantic search (generate embedding)
+ */
+export async function indexNote(noteId: string): Promise<void> {
+  try {
+    await semanticSearchService.indexNote(noteId)
+  } catch (error) {
+    console.error('Error indexing note:', error)
+    throw error
+  }
+}
+
+/**
+ * Batch index notes (for initial setup)
+ */
+export async function batchIndexNotes(noteIds: string[]): Promise<void> {
+  try {
+    await semanticSearchService.indexBatchNotes(noteIds)
+  } catch (error) {
+    console.error('Error batch indexing notes:', error)
+    throw error
+  }
+}

memento-note/app/actions/title-suggestions.ts

@@ -0,0 +1,128 @@
+'use server'
+
+import { auth } from '@/auth'
+import { titleSuggestionService } from '@/lib/ai/services/title-suggestion.service'
+import { prisma } from '@/lib/prisma'
+import { revalidatePath } from 'next/cache'
+
+export interface GenerateTitlesResponse {
+  suggestions: Array<{
+    title: string
+    confidence: number
+    reasoning?: string
+  }>
+  noteId: string
+}
+
+/**
+ * Generate title suggestions for a note
+ * Triggered when note reaches 50+ words without a title
+ */
+export async function generateTitleSuggestions(noteId: string): Promise<GenerateTitlesResponse> {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Unauthorized')
+  }
+
+  try {
+    // Fetch note content
+    const note = await prisma.note.findUnique({
+      where: { id: noteId },
+      select: { id: true, content: true, userId: true }
+    })
+
+    if (!note) {
+      throw new Error('Note not found')
+    }
+
+    if (note.userId !== session.user.id) {
+      throw new Error('Forbidden')
+    }
+
+    if (!note.content || note.content.trim().length === 0) {
+      throw new Error('Note content is empty')
+    }
+
+    // Generate suggestions
+    const suggestions = await titleSuggestionService.generateSuggestions(note.content)
+
+    return {
+      suggestions,
+      noteId
+    }
+  } catch (error) {
+    console.error('Error generating title suggestions:', error)
+    throw error
+  }
+}
+
+/**
+ * Apply selected title to note
+ */
+export async function applyTitleSuggestion(
+  noteId: string,
+  selectedTitle: string
+): Promise<void> {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Unauthorized')
+  }
+
+  try {
+    // Update note with selected title
+    await prisma.note.update({
+      where: {
+        id: noteId,
+        userId: session.user.id
+      },
+      data: {
+        title: selectedTitle,
+        autoGenerated: true,
+        lastAiAnalysis: new Date()
+      }
+    })
+
+    revalidatePath('/')
+    revalidatePath(`/note/${noteId}`)
+  } catch (error) {
+    console.error('Error applying title suggestion:', error)
+    throw error
+  }
+}
+
+/**
+ * Record user feedback on title suggestions
+ * (Phase 3 - for improving future suggestions)
+ */
+export async function recordTitleFeedback(
+  noteId: string,
+  selectedTitle: string,
+  allSuggestions: Array<{ title: string; confidence: number }>
+): Promise<void> {
+  const session = await auth()
+  if (!session?.user?.id) {
+    throw new Error('Unauthorized')
+  }
+
+  try {
+    // Save to AiFeedback table for learning
+    await prisma.aiFeedback.create({
+      data: {
+        noteId,
+        userId: session.user.id,
+        feedbackType: 'thumbs_up', // User chose one of our suggestions
+        feature: 'title_suggestion',
+        originalContent: JSON.stringify(allSuggestions),
+        correctedContent: selectedTitle,
+        metadata: JSON.stringify({
+          timestamp: new Date().toISOString(),
+          provider: 'auto' // Will be dynamic based on user settings
+        })
+      }
+    })
+
+  } catch (error) {
+    console.error('Error recording title feedback:', error)
+    // Don't throw - feedback is optional
+  }
+}

memento-note/app/actions/user-settings.ts

@@ -0,0 +1,86 @@
+'use server'
+
+import { auth } from '@/auth'
+import { prisma } from '@/lib/prisma'
+import { revalidatePath, updateTag } from 'next/cache'
+
+export type UserSettingsData = {
+  theme?: 'light' | 'dark' | 'auto' | 'sepia' | 'midnight' | 'blue'
+  cardSizeMode?: 'variable' | 'uniform'
+}
+
+/**
+ * Update user settings (theme, etc.)
+ */
+export async function updateUserSettings(settings: UserSettingsData) {
+
+  const session = await auth()
+
+  if (!session?.user?.id) {
+    console.error('[updateUserSettings] Unauthorized')
+    throw new Error('Unauthorized')
+  }
+
+  try {
+    const result = await prisma.user.update({
+      where: { id: session.user.id },
+      data: settings
+    })
+
+
+    revalidatePath('/', 'layout')
+    updateTag('user-settings')
+
+    return { success: true }
+  } catch (error) {
+    console.error('Error updating user settings:', error)
+    throw new Error('Failed to update user settings')
+  }
+}
+
+/**
+ * Get user settings for current user (Cached)
+ */
+import { unstable_cache } from 'next/cache'
+
+// Internal cached function
+const getCachedUserSettings = unstable_cache(
+  async (userId: string) => {
+    try {
+      const user = await prisma.user.findUnique({
+        where: { id: userId },
+        select: { theme: true, cardSizeMode: true }
+      })
+
+      return {
+        theme: (user?.theme || 'light') as 'light' | 'dark' | 'auto' | 'sepia' | 'midnight' | 'blue',
+        cardSizeMode: (user?.cardSizeMode || 'variable') as 'variable' | 'uniform'
+      }
+    } catch (error) {
+      console.error('Error getting user settings:', error)
+      return {
+        theme: 'light' as const
+      }
+    }
+  },
+  ['user-settings'],
+  { tags: ['user-settings'] }
+)
+
+export async function getUserSettings(userId?: string) {
+  let id = userId
+
+  if (!id) {
+    const session = await auth()
+    id = session?.user?.id
+  }
+
+  if (!id) {
+    return {
+      theme: 'light' as const,
+      cardSizeMode: 'variable' as const
+    }
+  }
+
+  return getCachedUserSettings(id)
+}

memento-note/app/api/admin/embeddings/validate/route.ts

@@ -0,0 +1,101 @@
+import { NextResponse } from 'next/server'
+import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+import { validateEmbedding } from '@/lib/utils'
+
+/**
+ * Admin endpoint to validate all embeddings in the database
+ * Returns a list of notes with invalid embeddings
+ */
+export async function GET() {
+  try {
+    const session = await auth()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    // Check if user is admin
+    const user = await prisma.user.findUnique({
+      where: { id: session.user.id },
+      select: { role: true }
+    })
+
+    if (!user || user.role !== 'ADMIN') {
+      return NextResponse.json({ error: 'Forbidden - Admin only' }, { status: 403 })
+    }
+
+    // Fetch all notes with embeddings
+    const allNotes = await prisma.note.findMany({
+      select: {
+        id: true,
+        title: true,
+        noteEmbedding: true
+      }
+    })
+
+    const invalidNotes: Array<{
+      id: string
+      title: string
+      issues: string[]
+    }> = []
+
+    let validCount = 0
+    let missingCount = 0
+    let invalidCount = 0
+
+    for (const note of allNotes) {
+      // Check if embedding is missing
+      if (!note.noteEmbedding?.embedding) {
+        missingCount++
+        invalidNotes.push({
+          id: note.id,
+          title: note.title || 'Untitled',
+          issues: ['Missing embedding']
+        })
+        continue
+      }
+
+      // Validate embedding
+      try {
+        if (!note.noteEmbedding?.embedding) continue
+        const embedding = JSON.parse(note.noteEmbedding.embedding) as number[]
+        const validation = validateEmbedding(embedding)
+
+        if (!validation.valid) {
+          invalidCount++
+          invalidNotes.push({
+            id: note.id,
+            title: note.title || 'Untitled',
+            issues: validation.issues
+          })
+        } else {
+          validCount++
+        }
+      } catch (error) {
+        invalidCount++
+        invalidNotes.push({
+          id: note.id,
+          title: note.title || 'Untitled',
+          issues: [`Failed to parse embedding: ${error}`]
+        })
+      }
+    }
+
+    return NextResponse.json({
+      success: true,
+      summary: {
+        total: allNotes.length,
+        valid: validCount,
+        missing: missingCount,
+        invalid: invalidCount
+      },
+      invalidNotes
+    })
+  } catch (error) {
+    console.error('[EMBEDDING_VALIDATION] Error:', error)
+    return NextResponse.json(
+      { success: false, error: String(error) },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/admin/randomize-labels/route.ts

@@ -0,0 +1,31 @@
+import { NextResponse } from 'next/server';
+import prisma from '@/lib/prisma';
+import { LABEL_COLORS } from '@/lib/types';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+  try {
+    const labels = await prisma.label.findMany();
+    const colors = Object.keys(LABEL_COLORS).filter(c => c !== 'gray'); // Exclude gray to force colors
+    
+    const updates = labels.map((label: any) => {
+      const randomColor = colors[Math.floor(Math.random() * colors.length)];
+      return prisma.label.update({
+        where: { id: label.id },
+        data: { color: randomColor }
+      });
+    });
+
+    await prisma.$transaction(updates);
+
+    return NextResponse.json({
+      success: true,
+      updated: updates.length,
+      message: "All labels have been assigned a random non-gray color."
+    });
+
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}

memento-note/app/api/admin/sync-labels/route.ts

@@ -0,0 +1,56 @@
+import { NextResponse } from 'next/server';
+import prisma from '@/lib/prisma';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+  try {
+    // 1. Get all notes
+    const notes = await prisma.note.findMany({
+      select: { labels: true }
+    });
+
+    // 2. Extract all unique labels from JSON
+    const uniqueLabels = new Set<string>();
+    notes.forEach((note: any) => {
+      if (note.labels) {
+        try {
+          if (Array.isArray(note.labels)) {
+            (note.labels as string[]).forEach((l: string) => uniqueLabels.add(l));
+          }
+        } catch (e) {
+          // ignore error
+        }
+      }
+    });
+
+    // 3. Get existing labels in DB
+    const existingDbLabels = await prisma.label.findMany();
+    const existingNames = new Set(existingDbLabels.map((l: any) => l.name));
+
+    // 4. Create missing labels
+    const created = [];
+    for (const name of uniqueLabels) {
+      if (!existingNames.has(name)) {
+        const newLabel = await prisma.label.create({
+          data: {
+            name,
+            color: 'gray' // Default color
+          }
+        });
+        created.push(newLabel);
+      }
+    }
+
+    return NextResponse.json({
+      success: true,
+      foundInNotes: uniqueLabels.size,
+      alreadyInDb: existingNames.size,
+      created: created.length,
+      createdLabels: created
+    });
+
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}

memento-note/app/api/ai/auto-labels/route.ts

@@ -0,0 +1,122 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { autoLabelCreationService } from '@/lib/ai/services'
+
+/**
+ * POST /api/ai/auto-labels - Suggest new labels for a notebook
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { success: false, error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const body = await request.json()
+    const { notebookId, language = 'en' } = body
+
+    if (!notebookId || typeof notebookId !== 'string') {
+      return NextResponse.json(
+        { success: false, error: 'Missing required field: notebookId' },
+        { status: 400 }
+      )
+    }
+
+    // Check if notebook belongs to user
+    const { prisma } = await import('@/lib/prisma')
+    const notebook = await prisma.notebook.findFirst({
+      where: {
+        id: notebookId,
+        userId: session.user.id,
+      },
+    })
+
+    if (!notebook) {
+      return NextResponse.json(
+        { success: false, error: 'Notebook not found' },
+        { status: 404 }
+      )
+    }
+
+    // Get label suggestions
+    const suggestions = await autoLabelCreationService.suggestLabels(
+      notebookId,
+      session.user.id,
+      language
+    )
+
+    if (!suggestions) {
+      return NextResponse.json({
+        success: true,
+        data: null,
+        message: 'No suggestions available (notebook may have fewer than 15 notes)',
+      })
+    }
+
+    return NextResponse.json({
+      success: true,
+      data: suggestions,
+    })
+  } catch (error) {
+    return NextResponse.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to get label suggestions',
+      },
+      { status: 500 }
+    )
+  }
+}
+
+/**
+ * PUT /api/ai/auto-labels - Create suggested labels
+ */
+export async function PUT(request: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { success: false, error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const body = await request.json()
+    const { suggestions, selectedLabels } = body
+
+    if (!suggestions || !Array.isArray(selectedLabels)) {
+      return NextResponse.json(
+        { success: false, error: 'Missing required fields: suggestions, selectedLabels' },
+        { status: 400 }
+      )
+    }
+
+    // Create labels
+    const createdCount = await autoLabelCreationService.createLabels(
+      suggestions.notebookId,
+      session.user.id,
+      suggestions,
+      selectedLabels
+    )
+
+    return NextResponse.json({
+      success: true,
+      data: {
+        createdCount,
+      },
+    })
+  } catch (error) {
+    return NextResponse.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to create labels',
+      },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/batch-organize/route.ts

@@ -0,0 +1,102 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { batchOrganizationService } from '@/lib/ai/services'
+
+/**
+ * POST /api/ai/batch-organize - Create organization plan for notes in Inbox
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { success: false, error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    // Get language from request headers or body
+    let language = 'en'
+    try {
+      const body = await request.json()
+      if (body.language) {
+        language = body.language
+      }
+    } catch (e) {
+      // If no body or invalid json, check headers
+      const acceptLanguage = request.headers.get('accept-language')
+      if (acceptLanguage) {
+        language = acceptLanguage.split(',')[0].split('-')[0]
+      }
+    }
+
+    // Create organization plan
+    const plan = await batchOrganizationService.createOrganizationPlan(
+      session.user.id,
+      language
+    )
+
+    return NextResponse.json({
+      success: true,
+      data: plan,
+    })
+  } catch (error) {
+    console.error('[batch-organize POST] Error:', error)
+    return NextResponse.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to create organization plan',
+      },
+      { status: 500 }
+    )
+  }
+}
+
+/**
+ * PUT /api/ai/batch-organize - Apply organization plan
+ */
+export async function PUT(request: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { success: false, error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const body = await request.json()
+    const { plan, selectedNoteIds } = body
+
+    if (!plan || !Array.isArray(selectedNoteIds)) {
+      return NextResponse.json(
+        { success: false, error: 'Missing required fields: plan, selectedNoteIds' },
+        { status: 400 }
+      )
+    }
+
+    // Apply organization plan
+    const movedCount = await batchOrganizationService.applyOrganizationPlan(
+      session.user.id,
+      plan,
+      selectedNoteIds
+    )
+
+    return NextResponse.json({
+      success: true,
+      data: {
+        movedCount,
+      },
+    })
+  } catch (error) {
+    return NextResponse.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to apply organization plan',
+      },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/config/route.ts

@@ -0,0 +1,26 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getSystemConfig } from '@/lib/config'
+
+export async function GET(request: NextRequest) {
+  try {
+    const config = await getSystemConfig()
+
+    return NextResponse.json({
+      AI_PROVIDER_TAGS: config.AI_PROVIDER_TAGS || 'not set',
+      AI_MODEL_TAGS: config.AI_MODEL_TAGS || 'not set',
+      AI_PROVIDER_EMBEDDING: config.AI_PROVIDER_EMBEDDING || 'not set',
+      AI_MODEL_EMBEDDING: config.AI_MODEL_EMBEDDING || 'not set',
+      OPENAI_API_KEY: config.OPENAI_API_KEY ? '***configured***' : '',
+      CUSTOM_OPENAI_API_KEY: config.CUSTOM_OPENAI_API_KEY ? '***configured***' : '',
+      CUSTOM_OPENAI_BASE_URL: config.CUSTOM_OPENAI_BASE_URL || '',
+      OLLAMA_BASE_URL: config.OLLAMA_BASE_URL || 'not set'
+    })
+  } catch (error: any) {
+    return NextResponse.json(
+      {
+        error: error.message || 'Failed to fetch config'
+      },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/echo/connections/route.ts

@@ -0,0 +1,85 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { memoryEchoService } from '@/lib/ai/services/memory-echo.service'
+
+/**
+ * GET /api/ai/echo/connections?noteId={id}&page={page}&limit={limit}
+ * Fetch all connections for a specific note
+ */
+export async function GET(req: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    // Get query parameters
+    const { searchParams } = new URL(req.url)
+    const noteId = searchParams.get('noteId')
+    const page = parseInt(searchParams.get('page') || '1')
+    const limit = parseInt(searchParams.get('limit') || '10')
+
+    // Validate noteId
+    if (!noteId) {
+      return NextResponse.json(
+        { error: 'noteId parameter is required' },
+        { status: 400 }
+      )
+    }
+
+    // Validate pagination parameters
+    if (page < 1 || limit < 1 || limit > 50) {
+      return NextResponse.json(
+        { error: 'Invalid pagination parameters. page >= 1, limit between 1 and 50' },
+        { status: 400 }
+      )
+    }
+
+    // Get all connections for the note
+    const allConnections = await memoryEchoService.getConnectionsForNote(noteId, session.user.id)
+
+    // Calculate pagination
+    const total = allConnections.length
+    const startIndex = (page - 1) * limit
+    const endIndex = startIndex + limit
+    const paginatedConnections = allConnections.slice(startIndex, endIndex)
+
+    // Format connections for response
+    const connections = paginatedConnections.map(conn => {
+      // Determine which note is the "other" note (not the target note)
+      const isNote1Target = conn.note1.id === noteId
+      const otherNote = isNote1Target ? conn.note2 : conn.note1
+
+      return {
+        noteId: otherNote.id,
+        title: otherNote.title,
+        content: otherNote.content,
+        createdAt: otherNote.createdAt,
+        similarity: conn.similarityScore,
+        daysApart: conn.daysApart
+      }
+    })
+
+    return NextResponse.json({
+      connections,
+      pagination: {
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+        hasNext: endIndex < total,
+        hasPrev: page > 1
+      }
+    })
+
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to fetch connections' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/echo/dismiss/route.ts

@@ -0,0 +1,60 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { prisma } from '@/lib/prisma'
+
+/**
+ * POST /api/ai/echo/dismiss
+ * Dismiss a connection for a specific note
+ * Body: { noteId, connectedNoteId }
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const body = await req.json()
+    const { noteId, connectedNoteId } = body
+
+    if (!noteId || !connectedNoteId) {
+      return NextResponse.json(
+        { error: 'noteId and connectedNoteId are required' },
+        { status: 400 }
+      )
+    }
+
+    // Find and mark matching insights as dismissed
+    // We need to find insights where (note1Id = noteId AND note2Id = connectedNoteId) OR (note1Id = connectedNoteId AND note2Id = noteId)
+    await prisma.memoryEchoInsight.updateMany({
+      where: {
+        userId: session.user.id,
+        OR: [
+          {
+            note1Id: noteId,
+            note2Id: connectedNoteId
+          },
+          {
+            note1Id: connectedNoteId,
+            note2Id: noteId
+          }
+        ]
+      },
+      data: {
+        dismissed: true
+      }
+    })
+
+    return NextResponse.json({ success: true })
+
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to dismiss connection' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/echo/fusion/route.ts

@@ -0,0 +1,108 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { getChatProvider } from '@/lib/ai/factory'
+import { getSystemConfig } from '@/lib/config'
+import prisma from '@/lib/prisma'
+
+/**
+ * POST /api/ai/echo/fusion
+ * Generate intelligent fusion of multiple notes
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const body = await req.json()
+    const { noteIds, prompt } = body
+
+    if (!noteIds || !Array.isArray(noteIds) || noteIds.length < 2) {
+      return NextResponse.json(
+        { error: 'At least 2 note IDs are required' },
+        { status: 400 }
+      )
+    }
+
+    // Fetch the notes
+    const notes = await prisma.note.findMany({
+      where: {
+        id: { in: noteIds },
+        userId: session.user.id
+      },
+      select: {
+        id: true,
+        title: true,
+        content: true,
+        createdAt: true
+      }
+    })
+
+    if (notes.length !== noteIds.length) {
+      return NextResponse.json(
+        { error: 'Some notes not found or access denied' },
+        { status: 404 }
+      )
+    }
+
+    // Get AI provider
+    const config = await getSystemConfig()
+    const provider = getChatProvider(config)
+
+    // Build fusion prompt
+    const notesDescriptions = notes.map((note, index) => {
+      return `Note ${index + 1}: "${note.title || 'Untitled'}"
+${note.content}`
+    }).join('\n\n')
+
+    const fusionPrompt = `You are an expert at synthesizing and merging information from multiple sources.
+
+TASK: Create a unified, well-structured note by intelligently combining the following notes.
+
+${prompt ? `ADDITIONAL INSTRUCTIONS: ${prompt}\n` : ''}
+
+NOTES TO MERGE:
+${notesDescriptions}
+
+REQUIREMENTS:
+1. Create a clear, descriptive title that captures the essence of all notes
+2. Merge and consolidate related information
+3. Remove duplicates while preserving unique details from each note
+4. Organize the content logically (use headers, bullet points, etc.)
+5. Maintain the important details and context from all notes
+6. Keep the tone and style consistent
+7. Use markdown formatting for better readability
+
+Output format:
+# [Fused Title]
+
+[Merged and organized content...]
+
+Begin:`
+
+    try {
+      const fusedContent = await provider.generateText(fusionPrompt)
+
+      return NextResponse.json({
+        fusedNote: fusedContent,
+        notesCount: notes.length
+      })
+    } catch (error) {
+      return NextResponse.json(
+        { error: 'Failed to generate fusion' },
+        { status: 500 }
+      )
+    }
+
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to process fusion request' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/echo/route.ts

@@ -0,0 +1,92 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { memoryEchoService } from '@/lib/ai/services/memory-echo.service'
+
+/**
+ * GET /api/ai/echo
+ * Fetch next Memory Echo insight for current user
+ */
+export async function GET(req: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    // Get next insight (respects frequency limits)
+    const insight = await memoryEchoService.getNextInsight(session.user.id)
+
+    if (!insight) {
+      return NextResponse.json(
+        {
+          insight: null,
+          message: 'No new insights available at the moment. Memory Echo will notify you when we discover connections between your notes.'
+        }
+      )
+    }
+
+    return NextResponse.json({ insight })
+
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to fetch Memory Echo insight' },
+      { status: 500 }
+    )
+  }
+}
+
+/**
+ * POST /api/ai/echo
+ * Submit feedback or mark as viewed
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const body = await req.json()
+    const { action, insightId, feedback } = body
+
+    if (action === 'view') {
+      // Mark insight as viewed
+      await memoryEchoService.markAsViewed(insightId)
+
+      return NextResponse.json({ success: true })
+
+    } else if (action === 'feedback') {
+      // Submit feedback (thumbs_up or thumbs_down)
+      if (!feedback || !['thumbs_up', 'thumbs_down'].includes(feedback)) {
+        return NextResponse.json(
+          { error: 'Invalid feedback. Must be thumbs_up or thumbs_down' },
+          { status: 400 }
+        )
+      }
+
+      await memoryEchoService.submitFeedback(insightId, feedback)
+
+      return NextResponse.json({ success: true })
+
+    } else {
+      return NextResponse.json(
+        { error: 'Invalid action. Must be "view" or "feedback"' },
+        { status: 400 }
+      )
+    }
+
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to process request' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/models/route.ts

@@ -0,0 +1,96 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getSystemConfig } from '@/lib/config'
+
+// Modèles populaires pour chaque provider (2025)
+const PROVIDER_MODELS = {
+  ollama: {
+    tags: [
+      'llama3:latest',
+      'llama3.2:latest',
+      'granite4:latest',
+      'mistral:latest',
+      'mixtral:latest',
+      'phi3:latest',
+      'gemma2:latest',
+      'qwen2:latest'
+    ],
+    embeddings: [
+      'embeddinggemma:latest',
+      'mxbai-embed-large:latest',
+      'nomic-embed-text:latest'
+    ]
+  },
+  openai: {
+    tags: [
+      'gpt-4o',
+      'gpt-4o-mini',
+      'gpt-4-turbo',
+      'gpt-4',
+      'gpt-3.5-turbo'
+    ],
+    embeddings: [
+      'text-embedding-3-small',
+      'text-embedding-3-large',
+      'text-embedding-ada-002'
+    ]
+  },
+  custom: {
+    tags: [], // Will be loaded dynamically
+    embeddings: [] // Will be loaded dynamically
+  }
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const config = await getSystemConfig()
+    const provider = (config.AI_PROVIDER || 'ollama').toLowerCase()
+
+    let models = PROVIDER_MODELS[provider as keyof typeof PROVIDER_MODELS] || { tags: [], embeddings: [] }
+
+    // Pour Ollama, essayer de récupérer la liste réelle depuis l'API locale
+    if (provider === 'ollama') {
+      try {
+        const ollamaBaseUrl = config.OLLAMA_BASE_URL || process.env.OLLAMA_BASE_URL || 'http://localhost:11434'
+        const response = await fetch(`${ollamaBaseUrl}/api/tags`, {
+          method: 'GET',
+          headers: { 'Content-Type': 'application/json' }
+        })
+
+        if (response.ok) {
+          const data = await response.json()
+          const allModels = data.models || []
+
+          // Séparer les modèles de tags et d'embeddings
+          const tagModels = allModels
+            .filter((m: any) => !m.name.includes('embed') && !m.name.includes('Embedding'))
+            .map((m: any) => m.name)
+            .slice(0, 20) // Limiter à 20 modèles
+
+          const embeddingModels = allModels
+            .filter((m: any) => m.name.includes('embed') || m.name.includes('Embedding'))
+            .map((m: any) => m.name)
+
+          models = {
+            tags: tagModels.length > 0 ? tagModels : models.tags,
+            embeddings: embeddingModels.length > 0 ? embeddingModels : models.embeddings
+          }
+        }
+      } catch (error) {
+        // Garder les modèles par défaut
+      }
+    }
+
+    return NextResponse.json({
+      provider,
+      models: models || { tags: [], embeddings: [] }
+    })
+  } catch (error: any) {
+    return NextResponse.json(
+      {
+        error: error.message || 'Failed to fetch models',
+        models: { tags: [], embeddings: [] }
+      },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/notebook-summary/route.ts

@@ -0,0 +1,73 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { notebookSummaryService } from '@/lib/ai/services'
+
+/**
+ * POST /api/ai/notebook-summary - Generate summary for a notebook
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json(
+        { success: false, error: 'Unauthorized' },
+        { status: 401 }
+      )
+    }
+
+    const body = await request.json()
+    const { notebookId, language = 'en' } = body
+
+    if (!notebookId || typeof notebookId !== 'string') {
+      return NextResponse.json(
+        { success: false, error: 'Missing required field: notebookId' },
+        { status: 400 }
+      )
+    }
+
+    // Check if notebook belongs to user
+    const { prisma } = await import('@/lib/prisma')
+    const notebook = await prisma.notebook.findFirst({
+      where: {
+        id: notebookId,
+        userId: session.user.id,
+      },
+    })
+
+    if (!notebook) {
+      return NextResponse.json(
+        { success: false, error: 'Notebook not found' },
+        { status: 404 }
+      )
+    }
+
+    // Generate summary
+    const summary = await notebookSummaryService.generateSummary(
+      notebookId,
+      session.user.id,
+      language
+    )
+
+    if (!summary) {
+      return NextResponse.json({
+        success: true,
+        data: null,
+        message: 'No summary available (notebook may be empty)',
+      })
+    }
+
+    return NextResponse.json({
+      success: true,
+      data: summary,
+    })
+  } catch (error) {
+    return NextResponse.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to generate notebook summary',
+      },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/reformulate/route.ts

@@ -0,0 +1,57 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { paragraphRefactorService } from '@/lib/ai/services/paragraph-refactor.service'
+
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const { text, option } = await request.json()
+
+    // Validation
+    if (!text || typeof text !== 'string') {
+      return NextResponse.json({ error: 'Text is required' }, { status: 400 })
+    }
+
+    // Map option to refactor mode
+    const modeMap: Record<string, 'clarify' | 'shorten' | 'improveStyle'> = {
+      'clarify': 'clarify',
+      'shorten': 'shorten',
+      'improve': 'improveStyle'
+    }
+
+    const mode = modeMap[option]
+    if (!mode) {
+      return NextResponse.json(
+        { error: 'Invalid option. Use: clarify, shorten, or improve' },
+        { status: 400 }
+      )
+    }
+
+    // Validate word count
+    const validation = paragraphRefactorService.validateWordCount(text)
+    if (!validation.valid) {
+      return NextResponse.json({ error: validation.error }, { status: 400 })
+    }
+
+    // Use the ParagraphRefactorService
+    const result = await paragraphRefactorService.refactor(text, mode)
+
+    return NextResponse.json({
+      originalText: result.original,
+      reformulatedText: result.refactored,
+      option: option,
+      language: result.language,
+      wordCountChange: result.wordCountChange
+    })
+  } catch (error: any) {
+    return NextResponse.json(
+      { error: error.message || 'Failed to reformulate text' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/suggest-notebook/route.ts

@@ -0,0 +1,46 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { notebookSuggestionService } from '@/lib/ai/services/notebook-suggestion.service'
+
+export async function POST(req: NextRequest) {
+  try {
+    const session = await auth()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const body = await req.json()
+    const { noteContent, language = 'en' } = body
+
+    if (!noteContent || typeof noteContent !== 'string') {
+      return NextResponse.json({ error: 'noteContent is required' }, { status: 400 })
+    }
+
+    // Minimum content length for suggestion (20 words as per specs)
+    const wordCount = noteContent.trim().split(/\s+/).length
+    if (wordCount < 20) {
+      return NextResponse.json({
+        suggestion: null,
+        reason: 'content_too_short',
+        message: 'Note content too short for meaningful suggestion'
+      })
+    }
+
+    // Get suggestion from AI service
+    const suggestedNotebook = await notebookSuggestionService.suggestNotebook(
+      noteContent,
+      session.user.id,
+      language
+    )
+
+    return NextResponse.json({
+      suggestion: suggestedNotebook,
+      confidence: suggestedNotebook ? 0.8 : 0 // Placeholder confidence score
+    })
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Failed to generate suggestion' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/tags/route.ts

@@ -0,0 +1,62 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/auth';
+import { contextualAutoTagService } from '@/lib/ai/services/contextual-auto-tag.service';
+import { getAIProvider } from '@/lib/ai/factory';
+import { getSystemConfig } from '@/lib/config';
+import { z } from 'zod';
+
+const requestSchema = z.object({
+  content: z.string().min(1, "Le contenu ne peut pas être vide"),
+  notebookId: z.string().optional(),
+  language: z.string().default('en'),
+});
+
+export async function POST(req: NextRequest) {
+  try {
+    const session = await auth();
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const body = await req.json();
+    const { content, notebookId, language } = requestSchema.parse(body);
+
+    // If notebookId is provided, use contextual suggestions (IA2)
+    if (notebookId) {
+      const suggestions = await contextualAutoTagService.suggestLabels(
+        content,
+        notebookId,
+        session.user.id,
+        language
+      );
+
+      // Convert label → tag to match TagSuggestion interface
+      const convertedTags = suggestions.map(s => ({
+        tag: s.label, // Convert label to tag
+        confidence: s.confidence,
+        // Keep additional properties for client-side use
+        ...(s.reasoning && { reasoning: s.reasoning }),
+        ...(s.isNewLabel !== undefined && { isNewLabel: s.isNewLabel })
+      }));
+
+      return NextResponse.json({ tags: convertedTags });
+    }
+
+    // Otherwise, use legacy auto-tagging (generates new tags)
+    const config = await getSystemConfig();
+    const provider = getAIProvider(config);
+    const tags = await provider.generateTags(content, language);
+
+    return NextResponse.json({ tags });
+  } catch (error: any) {
+
+    if (error instanceof z.ZodError) {
+      return NextResponse.json({ error: error.issues }, { status: 400 });
+    }
+
+    return NextResponse.json(
+      { error: error.message || 'Erreur lors de la génération des tags' },
+      { status: 500 }
+    );
+  }
+}

memento-note/app/api/ai/test-embeddings/route.ts

@@ -0,0 +1,90 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getEmbeddingsProvider } from '@/lib/ai/factory'
+import { getSystemConfig } from '@/lib/config'
+
+function getProviderDetails(config: Record<string, string>, providerType: string) {
+  const provider = providerType.toLowerCase()
+
+  switch (provider) {
+    case 'ollama':
+      return {
+        provider: 'Ollama',
+        baseUrl: config.OLLAMA_BASE_URL || 'http://localhost:11434',
+        model: config.AI_MODEL_EMBEDDING || 'embeddinggemma:latest'
+      }
+    case 'openai':
+      return {
+        provider: 'OpenAI',
+        baseUrl: 'https://api.openai.com/v1',
+        model: config.AI_MODEL_EMBEDDING || 'text-embedding-3-small'
+      }
+    case 'custom':
+      return {
+        provider: 'Custom OpenAI',
+        baseUrl: config.CUSTOM_OPENAI_BASE_URL || 'Not configured',
+        model: config.AI_MODEL_EMBEDDING || 'text-embedding-3-small'
+      }
+    default:
+      return {
+        provider: provider,
+        baseUrl: 'unknown',
+        model: config.AI_MODEL_EMBEDDING || 'unknown'
+      }
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const config = await getSystemConfig()
+    const provider = getEmbeddingsProvider(config)
+
+    const testText = 'test'
+    const startTime = Date.now()
+    const embeddings = await provider.getEmbeddings(testText)
+    const endTime = Date.now()
+
+    if (!embeddings || embeddings.length === 0) {
+      const providerType = config.AI_PROVIDER_EMBEDDING || 'ollama'
+      const details = getProviderDetails(config, providerType)
+      return NextResponse.json(
+        {
+          success: false,
+          error: 'No embeddings returned',
+          provider: providerType,
+          model: config.AI_MODEL_EMBEDDING || 'embeddinggemma:latest',
+          details
+        },
+        { status: 500 }
+      )
+    }
+
+    const providerType = config.AI_PROVIDER_EMBEDDING || 'ollama'
+    const details = getProviderDetails(config, providerType)
+
+    return NextResponse.json({
+      success: true,
+      provider: providerType,
+      model: config.AI_MODEL_EMBEDDING || 'embeddinggemma:latest',
+      embeddingLength: embeddings.length,
+      firstValues: embeddings.slice(0, 5),
+      responseTime: endTime - startTime,
+      details
+    })
+  } catch (error: any) {
+    const config = await getSystemConfig()
+    const providerType = config.AI_PROVIDER_EMBEDDING || 'ollama'
+    const details = getProviderDetails(config, providerType)
+
+    return NextResponse.json(
+      {
+        success: false,
+        error: error.message || 'Unknown error',
+        provider: providerType,
+        model: config.AI_MODEL_EMBEDDING || 'embeddinggemma:latest',
+        details,
+        stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
+      },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/test-tags/route.ts

@@ -0,0 +1,49 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getTagsProvider } from '@/lib/ai/factory'
+import { getSystemConfig } from '@/lib/config'
+
+export async function POST(request: NextRequest) {
+  try {
+    const config = await getSystemConfig()
+    const provider = getTagsProvider(config)
+
+    const testContent = "This is a test note about artificial intelligence and machine learning. It contains keywords like AI, ML, neural networks, and deep learning."
+
+    const startTime = Date.now()
+    const tags = await provider.generateTags(testContent)
+    const endTime = Date.now()
+
+    if (!tags || tags.length === 0) {
+      return NextResponse.json(
+        {
+          success: false,
+          error: 'No tags generated',
+          provider: config.AI_PROVIDER_TAGS || 'ollama',
+          model: config.AI_MODEL_TAGS || 'granite4:latest'
+        },
+        { status: 500 }
+      )
+    }
+
+    return NextResponse.json({
+      success: true,
+      provider: config.AI_PROVIDER_TAGS || 'ollama',
+      model: config.AI_MODEL_TAGS || 'granite4:latest',
+      tags: tags,
+      responseTime: endTime - startTime
+    })
+  } catch (error: any) {
+    const config = await getSystemConfig()
+
+    return NextResponse.json(
+      {
+        success: false,
+        error: error.message || 'Unknown error',
+        provider: config.AI_PROVIDER_TAGS || 'ollama',
+        model: config.AI_MODEL_TAGS || 'granite4:latest',
+        stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
+      },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/test/route.ts

@@ -0,0 +1,89 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getTagsProvider, getEmbeddingsProvider } from '@/lib/ai/factory'
+import { getSystemConfig } from '@/lib/config'
+
+function getProviderDetails(config: Record<string, string>, providerType: string) {
+  const provider = providerType.toLowerCase()
+
+  switch (provider) {
+    case 'ollama':
+      return {
+        provider: 'Ollama',
+        baseUrl: config.OLLAMA_BASE_URL || process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
+        model: config.AI_MODEL_EMBEDDING || 'embeddinggemma:latest'
+      }
+    case 'openai':
+      return {
+        provider: 'OpenAI',
+        baseUrl: 'https://api.openai.com/v1',
+        model: config.AI_MODEL_EMBEDDING || 'text-embedding-3-small'
+      }
+    case 'custom':
+      return {
+        provider: 'Custom OpenAI',
+        baseUrl: config.CUSTOM_OPENAI_BASE_URL || process.env.CUSTOM_OPENAI_BASE_URL || 'Not configured',
+        model: config.AI_MODEL_EMBEDDING || 'text-embedding-3-small'
+      }
+    default:
+      return {
+        provider: provider,
+        baseUrl: 'unknown',
+        model: config.AI_MODEL_EMBEDDING || 'unknown'
+      }
+  }
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const config = await getSystemConfig()
+    const tagsProvider = getTagsProvider(config)
+    const embeddingsProvider = getEmbeddingsProvider(config)
+
+    const testText = 'test'
+
+    // Test embeddings provider
+    const embeddings = await embeddingsProvider.getEmbeddings(testText)
+
+    if (!embeddings || embeddings.length === 0) {
+      const providerType = config.AI_PROVIDER_EMBEDDING || 'ollama'
+      const details = getProviderDetails(config, providerType)
+      return NextResponse.json(
+        {
+          success: false,
+          tagsProvider: config.AI_PROVIDER_TAGS || 'ollama',
+          embeddingsProvider: providerType,
+          error: 'No embeddings returned',
+          details
+        },
+        { status: 500 }
+      )
+    }
+
+    const tagsProviderType = config.AI_PROVIDER_TAGS || 'ollama'
+    const embeddingsProviderType = config.AI_PROVIDER_EMBEDDING || 'ollama'
+    const details = getProviderDetails(config, embeddingsProviderType)
+
+    return NextResponse.json({
+      success: true,
+      tagsProvider: tagsProviderType,
+      embeddingsProvider: embeddingsProviderType,
+      embeddingLength: embeddings.length,
+      firstValues: embeddings.slice(0, 5),
+      details
+    })
+  } catch (error: any) {
+    const config = await getSystemConfig()
+    const providerType = config.AI_PROVIDER_EMBEDDING || 'ollama'
+    const details = getProviderDetails(config, providerType)
+
+    return NextResponse.json(
+      {
+        success: false,
+        error: error.message || 'Unknown error',
+        stack: process.env.NODE_ENV === 'development' ? error.stack : undefined,
+        details
+      },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/title-suggestions/route.ts

@@ -0,0 +1,107 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getAIProvider } from '@/lib/ai/factory'
+import { getSystemConfig } from '@/lib/config'
+import { z } from 'zod'
+
+const requestSchema = z.object({
+  content: z.string().min(1, "Le contenu ne peut pas être vide"),
+})
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json()
+    const { content } = requestSchema.parse(body)
+
+    // Vérifier qu'il y a au moins 10 mots
+    const wordCount = content.split(/\s+/).length
+
+    if (wordCount < 10) {
+      return NextResponse.json(
+        { error: 'Le contenu doit avoir au moins 10 mots' },
+        { status: 400 }
+      )
+    }
+
+    const config = await getSystemConfig()
+    const provider = getAIProvider(config)
+
+    // Détecter la langue du contenu (simple détection basée sur les caractères et mots)
+    const hasNonLatinChars = /[\u0400-\u04FF\u0600-\u06FF\u4E00-\u9FFF\u0E00-\u0E7F]/.test(content)
+    const isPersian = /[\u0600-\u06FF]/.test(content)
+    const isChinese = /[\u4E00-\u9FFF]/.test(content)
+    const isRussian = /[\u0400-\u04FF]/.test(content)
+    const isArabic = /[\u0600-\u06FF]/.test(content)
+    
+    // Détection du français par des mots et caractères caractéristiques
+    const frenchWords = /\b(le|la|les|un|une|des|et|ou|mais|donc|pour|dans|sur|avec|sans|très|plus|moins|tout|tous|toute|toutes|ce|cette|ces|mon|ma|mes|ton|ta|tes|son|sa|ses|notre|nos|votre|vos|leur|leurs|je|tu|il|elle|nous|vous|ils|elles|est|sont|été|être|avoir|faire|aller|venir|voir|savoir|pouvoir|vouloir|falloir|comme|que|qui|dont|où|quand|pourquoi|comment|quel|quelle|quels|quelles)\b/i
+    const frenchAccents = /[éèêàâôûùïüç]/i
+    const isFrench = frenchWords.test(content) || frenchAccents.test(content)
+
+    // Déterminer la langue du prompt système
+    let promptLanguage = 'en'
+    let responseLanguage = 'English'
+
+    if (isFrench) {
+      promptLanguage = 'fr'  // Français
+      responseLanguage = 'French'
+    } else if (isPersian) {
+      promptLanguage = 'fa'  // Persan
+      responseLanguage = 'Persian'
+    } else if (isChinese) {
+      promptLanguage = 'zh'  // Chinois
+      responseLanguage = 'Chinese'
+    } else if (isRussian) {
+      promptLanguage = 'ru'  // Russe
+      responseLanguage = 'Russian'
+    } else if (isArabic) {
+      promptLanguage = 'ar'  // Arabe
+      responseLanguage = 'Arabic'
+    }
+
+    // Générer des titres appropriés basés sur le contenu
+    const titlePrompt = promptLanguage === 'en'
+      ? `You are a title generator. Generate 3 concise, descriptive titles for the following content.
+
+IMPORTANT INSTRUCTIONS:
+- Use ONLY the content provided below between the CONTENT_START and CONTENT_END markers
+- Do NOT use any external knowledge or training data
+- Focus on the main topics and themes in THIS SPECIFIC content
+- Be specific to what is actually discussed
+
+CONTENT_START: ${content.substring(0, 500)} CONTENT_END
+
+Respond ONLY with a JSON array: [{"title": "title1", "confidence": 0.95}, {"title": "title2", "confidence": 0.85}, {"title": "title3", "confidence": 0.75}]`
+      : `Tu es un générateur de titres. Génère 3 titres concis et descriptifs pour le contenu suivant en ${responseLanguage}.
+
+INSTRUCTIONS IMPORTANTES :
+- Utilise SEULEMENT le contenu fourni entre les marqueurs CONTENT_START et CONTENT_END
+- N'utilise AUCUNE connaissance externe ou données d'entraînement
+- Concentre-toi sur les sujets principaux et thèmes de CE CONTENU SPÉCIFIQUE
+- Sois spécifique à ce qui est réellement discuté
+
+CONTENT_START: ${content.substring(0, 500)} CONTENT_END
+
+Réponds SEULEMENT avec un tableau JSON: [{"title": "titre1", "confidence": 0.95}, {"title": "titre2", "confidence": 0.85}, {"title": "titre3", "confidence": 0.75}]`
+
+    const titles = await provider.generateTitles(titlePrompt)
+
+    // Créer les suggestions
+    const suggestions = titles.map((t: any) => ({
+      title: t.title,
+      confidence: Math.round(t.confidence * 100),
+      reasoning: `Basé sur le contenu`
+    }))
+
+    return NextResponse.json({ suggestions })
+  } catch (error: any) {
+
+    if (error instanceof z.ZodError) {
+      return NextResponse.json({ error: error.issues }, { status: 400 })
+    }
+
+    return NextResponse.json(
+      { error: error.message || 'Erreur lors de la génération des titres' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/transform-markdown/route.ts

@@ -0,0 +1,90 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { getAIProvider } from '@/lib/ai/factory'
+import { getSystemConfig } from '@/lib/config'
+
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth()
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const { text } = await request.json()
+
+    // Validation
+    if (!text || typeof text !== 'string') {
+      return NextResponse.json({ error: 'Text is required' }, { status: 400 })
+    }
+
+    // Validate word count
+    const wordCount = text.split(/\s+/).length
+    if (wordCount < 10) {
+      return NextResponse.json(
+        { error: 'Text must have at least 10 words to transform' },
+        { status: 400 }
+      )
+    }
+
+    if (wordCount > 500) {
+      return NextResponse.json(
+        { error: 'Text must have maximum 500 words to transform' },
+        { status: 400 }
+      )
+    }
+
+    const config = await getSystemConfig()
+    const provider = getAIProvider(config)
+
+    // Detect language from text
+    const hasFrench = /[àâäéèêëïîôùûüÿç]/i.test(text)
+    const responseLanguage = hasFrench ? 'French' : 'English'
+
+    // Build prompt to transform text to Markdown
+    const prompt = hasFrench
+      ? `Tu es un expert en Markdown. Transforme ce texte ${responseLanguage} en Markdown bien formaté.
+
+IMPORTANT :
+- Ajoute des titres avec ## pour les sections principales
+- Utilise des listes à puces (-) ou numérotées (1.) quand approprié
+- Ajoute de l'emphase (gras **texte**, italique *texte*) pour les mots clés
+- Utilise des blocs de code pour le code ou les commandes
+- Présente l'information de manière claire et structurée
+- GARDE le même sens et le contenu, seul le format change
+
+Texte à transformer :
+${text}
+
+Réponds SEULEMENT avec le texte transformé en Markdown, sans explications.`
+      : `You are a Markdown expert. Transform this ${responseLanguage} text into well-formatted Markdown.
+
+IMPORTANT:
+- Add headings with ## for main sections
+- Use bullet lists (-) or numbered lists (1.) when appropriate
+- Add emphasis (bold **text**, italic *text*) for key terms
+- Use code blocks for code or commands
+- Present information clearly and structured
+- KEEP the same meaning and content, only change the format
+
+Text to transform:
+${text}
+
+Respond ONLY with the transformed Markdown text, no explanations.`
+
+    
+    const transformedText = await provider.generateText(prompt)
+
+    
+    return NextResponse.json({
+      originalText: text,
+      transformedText: transformedText,
+      language: responseLanguage
+    })
+  } catch (error: any) {
+    return NextResponse.json(
+      { error: error.message || 'Failed to transform text to Markdown' },
+      { status: 500 }
+    )
+  }
+}

memento-note/app/api/ai/translate/route.ts

@@ -0,0 +1,30 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@/auth'
+import { getTagsProvider } from '@/lib/ai/factory'
+import { getSystemConfig } from '@/lib/config'
+
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const { text, targetLanguage } = await request.json()
+
+    if (!text || !targetLanguage) {
+      return NextResponse.json({ error: 'text and targetLanguage are required' }, { status: 400 })
+    }
+
+    const config = await getSystemConfig()
+    const provider = getTagsProvider(config)
+
+    const prompt = `Translate the following text to ${targetLanguage}. Return ONLY the translated text, no explanation, no preamble, no quotes:\n\n${text}`
+
+    const translatedText = await provider.generateText(prompt)
+
+    return NextResponse.json({ translatedText: translatedText.trim() })
+  } catch (error: any) {
+    return NextResponse.json({ error: error.message || 'Translation failed' }, { status: 500 })
+  }
+}