Add BMAD framework, authentication, and new features

keep-notes/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 });
+  }
+}

keep-notes/app/api/admin/sync-labels/route.ts

@@ -0,0 +1,57 @@
+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 {
+          const parsed = JSON.parse(note.labels);
+          if (Array.isArray(parsed)) {
+            parsed.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 });
+  }
+}

keep-notes/app/api/auth/[...nextauth]/route.ts

@@ -0,0 +1,2 @@
+import { handlers } from "@/auth"
+export const { GET, POST } = handlers

keep-notes/app/api/cron/reminders/route.ts

@@ -0,0 +1,62 @@
+import { NextResponse } from 'next/server';
+import prisma from '@/lib/prisma';
+
+export const dynamic = 'force-dynamic'; // No caching
+
+export async function POST(request: Request) {
+  try {
+    const now = new Date();
+
+    // 1. Find all due reminders that haven't been processed
+    const dueNotes = await prisma.note.findMany({
+      where: {
+        reminder: {
+          lte: now, // Less than or equal to now
+        },
+        isReminderDone: false,
+        isArchived: false, // Optional: exclude archived notes
+      },
+      select: {
+        id: true,
+        title: true,
+        content: true,
+        reminder: true,
+        // Add other fields useful for notification
+      },
+    });
+
+    if (dueNotes.length === 0) {
+      return NextResponse.json({ 
+        success: true, 
+        count: 0, 
+        message: 'No due reminders found' 
+      });
+    }
+
+    // 2. Mark them as done (Atomic operation logic would be better but simple batch update is fine here)
+    const noteIds = dueNotes.map((n: any) => n.id);
+    
+    await prisma.note.updateMany({
+      where: {
+        id: { in: noteIds }
+      },
+      data: {
+        isReminderDone: true
+      }
+    });
+
+    // 3. Return the notes to N8N so it can send emails/messages
+    return NextResponse.json({
+      success: true,
+      count: dueNotes.length,
+      reminders: dueNotes
+    });
+
+  } catch (error) {
+    console.error('Error processing cron reminders:', error);
+    return NextResponse.json(
+      { success: false, error: 'Internal Server Error' },
+      { status: 500 }
+    );
+  }
+}

keep-notes/app/api/labels/route.ts

@@ -1,10 +1,19 @@
 import { NextRequest, NextResponse } from 'next/server'
 import prisma from '@/lib/prisma'
+import { auth } from '@/auth'
+
+const COLORS = ['red', 'orange', 'yellow', 'green', 'teal', 'blue', 'purple', 'pink', 'gray'];
 
 // GET /api/labels - Get all labels
 export async function GET(request: NextRequest) {
+  const session = await auth();
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+
   try {
     const labels = await prisma.label.findMany({
+      where: { userId: session.user.id },
       orderBy: { name: 'asc' }
     })
 
@@ -23,6 +32,11 @@ export async function GET(request: NextRequest) {
 
 // POST /api/labels - Create a new label
 export async function POST(request: NextRequest) {
+  const session = await auth();
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+
   try {
     const body = await request.json()
     const { name, color } = body
@@ -34,9 +48,14 @@ export async function POST(request: NextRequest) {
       )
     }
 
-    // Check if label already exists
+    // Check if label already exists for this user
     const existing = await prisma.label.findUnique({
-      where: { name: name.trim() }
+      where: {
+        name_userId: {
+          name: name.trim(),
+          userId: session.user.id
+        }
+      }
     })
 
     if (existing) {
@@ -49,7 +68,8 @@ export async function POST(request: NextRequest) {
     const label = await prisma.label.create({
       data: {
         name: name.trim(),
-        color: color || 'gray'
+        color: color || COLORS[Math.floor(Math.random() * COLORS.length)],
+        userId: session.user.id
       }
     })
 

keep-notes/app/api/notes/[id]/route.ts

@@ -13,11 +13,12 @@ function parseNote(dbNote: any) {
 // GET /api/notes/[id] - Get a single note
 export async function GET(
   request: NextRequest,
-  { params }: { params: { id: string } }
+  { params }: { params: Promise<{ id: string }> }
 ) {
   try {
+    const { id } = await params
     const note = await prisma.note.findUnique({
-      where: { id: params.id }
+      where: { id }
     })
 
     if (!note) {
@@ -43,9 +44,10 @@ export async function GET(
 // PUT /api/notes/[id] - Update a note
 export async function PUT(
   request: NextRequest,
-  { params }: { params: { id: string } }
+  { params }: { params: Promise<{ id: string }> }
 ) {
   try {
+    const { id } = await params
     const body = await request.json()
     const updateData: any = { ...body }
 
@@ -59,7 +61,7 @@ export async function PUT(
     updateData.updatedAt = new Date()
 
     const note = await prisma.note.update({
-      where: { id: params.id },
+      where: { id },
       data: updateData
     })
 
@@ -79,11 +81,12 @@ export async function PUT(
 // DELETE /api/notes/[id] - Delete a note
 export async function DELETE(
   request: NextRequest,
-  { params }: { params: { id: string } }
+  { params }: { params: Promise<{ id: string }> }
 ) {
   try {
+    const { id } = await params
     await prisma.note.delete({
-      where: { id: params.id }
+      where: { id }
     })
 
     return NextResponse.json({

keep-notes/app/api/upload/route.ts

@@ -0,0 +1,39 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { writeFile, mkdir } from 'fs/promises'
+import path from 'path'
+import { randomUUID } from 'crypto'
+
+export async function POST(request: NextRequest) {
+  try {
+    const formData = await request.formData()
+    const file = formData.get('file') as File
+
+    if (!file) {
+      return NextResponse.json(
+        { error: 'No file uploaded' },
+        { status: 400 }
+      )
+    }
+
+    const buffer = Buffer.from(await file.arrayBuffer())
+    const filename = `${randomUUID()}${path.extname(file.name)}`
+    
+    // Ensure directory exists
+    const uploadDir = path.join(process.cwd(), 'public/uploads/notes')
+    await mkdir(uploadDir, { recursive: true })
+    
+    const filePath = path.join(uploadDir, filename)
+    await writeFile(filePath, buffer)
+
+    return NextResponse.json({ 
+      success: true, 
+      url: `/uploads/notes/${filename}` 
+    })
+  } catch (error) {
+    console.error('Upload error:', error)
+    return NextResponse.json(
+      { error: 'Failed to upload file' },
+      { status: 500 }
+    )
+  }
+}