Add missing API endpoints for contributor, messaging, and RAG

scripts/migrate-data.ts

@@ -0,0 +1,949 @@
+/**
+ * MongoDB to Turso Data Migration Script
+ * 
+ * Migrates all data from MongoDB Atlas to Turso (SQLite).
+ * MongoDB remains READ-ONLY - no deletions or modifications.
+ * 
+ * Usage:
+ *   npm run migrate:data
+ *   npm run migrate:data -- --dry-run
+ * 
+ * Required env vars:
+ *   MONGO_URL, TURSO_DATABASE_URL, TURSO_AUTH_TOKEN
+ */
+
+import { MongoClient, ObjectId } from "mongodb";
+import { createClient } from "@libsql/client";
+import { drizzle } from "drizzle-orm/libsql";
+import { sql } from "drizzle-orm";
+import * as schema from "../src/db/schema";
+import { v4 as uuidv4 } from "uuid";
+import * as dotenv from "dotenv";
+
+dotenv.config({ path: ".env.local" });
+
+// =============================================================================
+// Types
+// =============================================================================
+
+interface MongoUser {
+    _id?: ObjectId;
+    id?: string;
+    githubId: number;
+    username: string;
+    avatarUrl: string;
+    role?: string;
+    repositories?: string[];
+    githubAccessToken?: string;
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+}
+
+interface MongoRepository {
+    _id?: ObjectId;
+    id?: string;
+    githubRepoId: number;
+    name: string;
+    owner: string;
+    userId: string;
+    createdAt?: Date | string;
+}
+
+interface MongoIssue {
+    _id?: ObjectId;
+    id?: string;
+    githubIssueId: number;
+    number: number;
+    title: string;
+    body?: string;
+    authorName: string;
+    repoId: string;
+    repoName: string;
+    owner?: string;
+    repo?: string;
+    htmlUrl?: string;
+    state?: string;
+    isPR?: boolean;
+    createdAt?: Date | string;
+}
+
+interface MongoMessage {
+    _id?: ObjectId;
+    id?: string;
+    senderId: string;
+    receiverId: string;
+    content: string;
+    read?: boolean;
+    timestamp?: Date | string;
+}
+
+interface MongoProfile {
+    _id?: ObjectId;
+    user_id: string;
+    username: string;
+    avatar_url?: string;
+    bio?: string;
+    skills?: string[];
+    location?: string;
+    website?: string;
+    twitter?: string;
+    available_for_mentoring?: boolean;
+    mentoring_topics?: string[];
+    connected_repos?: string[];
+    profile_visibility?: string;
+    show_email?: boolean;
+    github_stats?: object;
+    stats_updated_at?: Date | string;
+    created_at?: Date | string;
+    updated_at?: Date | string;
+}
+
+interface MongoTriageData {
+    _id?: ObjectId;
+    id?: string;
+    issueId: string;
+    classification: string;
+    summary: string;
+    suggestedLabel: string;
+    sentiment: string;
+    analyzedAt?: Date | string;
+}
+
+interface MongoTemplate {
+    _id?: ObjectId;
+    id?: string;
+    name: string;
+    body: string;
+    ownerId: string;
+    triggerClassification?: string;
+    createdAt?: Date | string;
+}
+
+interface MongoChatMessage {
+    role: string;
+    content: string;
+    timestamp?: Date | string;
+    githubCommentId?: string;
+    githubCommentUrl?: string;
+}
+
+interface MongoChatHistory {
+    _id?: ObjectId;
+    id?: string;
+    userId: string;
+    sessionId: string;
+    messages?: MongoChatMessage[];
+    createdAt?: Date | string;
+}
+
+interface MongoMentor {
+    _id?: ObjectId;
+    id?: string;
+    userId: string;
+    username: string;
+    expertiseLevel?: string;
+    availabilityHoursPerWeek?: number;
+    timezone?: string;
+    isActive?: boolean;
+    bio?: string;
+    avatarUrl?: string;
+    techStack?: string[];
+    languages?: string[];
+    frameworks?: string[];
+    preferredTopics?: string[];
+    menteeCount?: number;
+    sessionsCompleted?: number;
+    avgRating?: number;
+    totalRatings?: number;
+    maxMentees?: number;
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+}
+
+interface MongoTrophy {
+    _id?: ObjectId;
+    id?: string;
+    userId: string;
+    username: string;
+    trophyType: string;
+    name: string;
+    description: string;
+    icon: string;
+    color: string;
+    rarity: string;
+    svgData?: string;
+    isPublic?: boolean;
+    shareUrl?: string;
+    earnedFor?: string;
+    milestoneValue?: number;
+    awardedAt?: Date | string;
+}
+
+interface MongoIssueChat {
+    _id?: ObjectId;
+    id?: string;
+    issueId: string;
+    userId: string;
+    sessionId: string;
+    messages?: MongoChatMessage[];
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+}
+
+interface MongoResource {
+    _id?: ObjectId;
+    id?: string;
+    repoName: string;
+    sourceType?: string;
+    sourceId?: string;
+    resourceType: string;
+    title: string;
+    content: string;
+    description?: string;
+    language?: string;
+    sharedBy: string;
+    sharedById: string;
+    tags?: string[];
+    saveCount?: number;
+    helpfulCount?: number;
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+}
+
+// =============================================================================
+// Utilities
+// =============================================================================
+
+function toIsoString(date: Date | string | undefined): string {
+    if (!date) return new Date().toISOString();
+    if (typeof date === "string") return date;
+    return date.toISOString();
+}
+
+function extractId(doc: { _id?: ObjectId; id?: string }): string {
+    if (doc.id) return doc.id;
+    if (doc._id) return doc._id.toString();
+    return uuidv4();
+}
+
+function log(message: string, type: "info" | "success" | "error" | "warn" = "info") {
+    const icons = { info: "ℹ️", success: "✅", error: "❌", warn: "⚠️" };
+    const time = new Date().toISOString().split("T")[1].split(".")[0];
+    console.log(`[${time}] ${icons[type]} ${message}`);
+}
+
+// =============================================================================
+// Migration Functions
+// =============================================================================
+
+async function migrateUsers(
+    mongoDb: ReturnType<MongoClient["db"]>,
+    tursoDb: ReturnType<typeof drizzle>,
+    isDryRun: boolean
+): Promise<Map<string, string>> {
+    log("Migrating Users...");
+    const userIdMap = new Map<string, string>();
+    const users = await mongoDb.collection<MongoUser>("users").find().toArray();
+    log(`Found ${users.length} users`);
+
+    let success = 0, skipped = 0;
+    for (const mongoUser of users) {
+        const userId = extractId(mongoUser);
+        const originalId = mongoUser._id?.toString() || mongoUser.id || "";
+        userIdMap.set(originalId, userId);
+
+        if (!isDryRun) {
+            try {
+                await tursoDb.insert(schema.users).values({
+                    id: userId,
+                    githubId: mongoUser.githubId,
+                    username: mongoUser.username,
+                    avatarUrl: mongoUser.avatarUrl,
+                    role: mongoUser.role || null,
+                    githubAccessToken: mongoUser.githubAccessToken || null,
+                    createdAt: toIsoString(mongoUser.createdAt),
+                    updatedAt: toIsoString(mongoUser.updatedAt),
+                }).onConflictDoNothing();
+
+                // Migrate user repositories array
+                if (mongoUser.repositories?.length) {
+                    for (const repoName of mongoUser.repositories) {
+                        await tursoDb.insert(schema.userRepositories).values({
+                            id: uuidv4(),
+                            userId: userId,
+                            repoFullName: repoName,
+                            addedAt: toIsoString(mongoUser.createdAt),
+                        }).onConflictDoNothing();
+                    }
+                }
+                success++;
+            } catch (e) {
+                skipped++;
+            }
+        } else {
+            log(`[DRY] User: ${mongoUser.username}`);
+            success++;
+        }
+    }
+    log(`Users: ${success} migrated, ${skipped} skipped`, "success");
+    return userIdMap;
+}
+
+async function migrateRepositories(
+    mongoDb: ReturnType<MongoClient["db"]>,
+    tursoDb: ReturnType<typeof drizzle>,
+    userIdMap: Map<string, string>,
+    isDryRun: boolean
+): Promise<Map<string, string>> {
+    log("Migrating Repositories...");
+    const repoIdMap = new Map<string, string>();
+    const repos = await mongoDb.collection<MongoRepository>("repositories").find().toArray();
+    log(`Found ${repos.length} repositories`);
+
+    let success = 0, skipped = 0;
+    for (const repo of repos) {
+        const repoId = extractId(repo);
+        const originalId = repo._id?.toString() || repo.id || "";
+        repoIdMap.set(originalId, repoId);
+
+        const mappedUserId = userIdMap.get(repo.userId) || repo.userId;
+
+        if (!isDryRun) {
+            try {
+                await tursoDb.insert(schema.repositories).values({
+                    id: repoId,
+                    githubRepoId: repo.githubRepoId,
+                    name: repo.name,
+                    owner: repo.owner,
+                    userId: mappedUserId,
+                    createdAt: toIsoString(repo.createdAt),
+                }).onConflictDoNothing();
+                success++;
+            } catch (e) {
+                skipped++;
+            }
+        } else {
+            log(`[DRY] Repo: ${repo.owner}/${repo.name}`);
+            success++;
+        }
+    }
+    log(`Repositories: ${success} migrated, ${skipped} skipped`, "success");
+    return repoIdMap;
+}
+
+async function migrateIssues(
+    mongoDb: ReturnType<MongoClient["db"]>,
+    tursoDb: ReturnType<typeof drizzle>,
+    repoIdMap: Map<string, string>,
+    isDryRun: boolean
+): Promise<Map<string, string>> {
+    log("Migrating Issues...");
+    const issueIdMap = new Map<string, string>();
+    const issues = await mongoDb.collection<MongoIssue>("issues").find().toArray();
+    log(`Found ${issues.length} issues`);
+
+    let success = 0, skipped = 0;
+    for (const issue of issues) {
+        const issueId = extractId(issue);
+        const originalId = issue._id?.toString() || issue.id || "";
+        issueIdMap.set(originalId, issueId);
+
+        const mappedRepoId = repoIdMap.get(issue.repoId) || issue.repoId;
+
+        if (!isDryRun) {
+            try {
+                await tursoDb.insert(schema.issues).values({
+                    id: issueId,
+                    githubIssueId: issue.githubIssueId,
+                    number: issue.number,
+                    title: issue.title,
+                    body: issue.body || null,
+                    authorName: issue.authorName,
+                    repoId: mappedRepoId,
+                    repoName: issue.repoName,
+                    owner: issue.owner || null,
+                    repo: issue.repo || null,
+                    htmlUrl: issue.htmlUrl || null,
+                    state: issue.state || "open",
+                    isPR: issue.isPR || false,
+                    createdAt: toIsoString(issue.createdAt),
+                }).onConflictDoNothing();
+                success++;
+            } catch (e) {
+                skipped++;
+            }
+        } else {
+            log(`[DRY] Issue: #${issue.number} - ${issue.title.substring(0, 30)}...`);
+            success++;
+        }
+    }
+    log(`Issues: ${success} migrated, ${skipped} skipped`, "success");
+    return issueIdMap;
+}
+
+async function migrateMessages(
+    mongoDb: ReturnType<MongoClient["db"]>,
+    tursoDb: ReturnType<typeof drizzle>,
+    userIdMap: Map<string, string>,
+    isDryRun: boolean
+): Promise<void> {
+    log("Migrating Messages...");
+    const messages = await mongoDb.collection<MongoMessage>("messages").find().toArray();
+    log(`Found ${messages.length} messages`);
+
+    let success = 0, skipped = 0;
+    for (const msg of messages) {
+        const msgId = extractId(msg);
+        const senderId = userIdMap.get(msg.senderId) || msg.senderId;
+        const receiverId = userIdMap.get(msg.receiverId) || msg.receiverId;
+
+        if (!isDryRun) {
+            try {
+                await tursoDb.insert(schema.messages).values({
+                    id: msgId,
+                    senderId: senderId,
+                    receiverId: receiverId,
+                    content: msg.content,
+                    read: msg.read || false,
+                    timestamp: toIsoString(msg.timestamp),
+                }).onConflictDoNothing();
+                success++;
+            } catch (e) {
+                skipped++;
+            }
+        } else {
+            success++;
+        }
+    }
+    log(`Messages: ${success} migrated, ${skipped} skipped`, "success");
+}
+
+async function migrateProfiles(
+    mongoDb: ReturnType<MongoClient["db"]>,
+    tursoDb: ReturnType<typeof drizzle>,
+    userIdMap: Map<string, string>,
+    isDryRun: boolean
+): Promise<void> {
+    log("Migrating Profiles...");
+    const profiles = await mongoDb.collection<MongoProfile>("profiles").find().toArray();
+    log(`Found ${profiles.length} profiles`);
+
+    let success = 0, skipped = 0;
+    for (const profile of profiles) {
+        const userId = userIdMap.get(profile.user_id) || profile.user_id;
+
+        if (!isDryRun) {
+            try {
+                await tursoDb.insert(schema.profiles).values({
+                    userId: userId,
+                    username: profile.username,
+                    avatarUrl: profile.avatar_url || null,
+                    bio: profile.bio || null,
+                    location: profile.location || null,
+                    website: profile.website || null,
+                    twitter: profile.twitter || null,
+                    availableForMentoring: profile.available_for_mentoring || false,
+                    profileVisibility: profile.profile_visibility || "public",
+                    showEmail: profile.show_email || false,
+                    githubStats: profile.github_stats ? JSON.stringify(profile.github_stats) : null,
+                    statsUpdatedAt: profile.stats_updated_at ? toIsoString(profile.stats_updated_at) : null,
+                    createdAt: toIsoString(profile.created_at),
+                    updatedAt: toIsoString(profile.updated_at),
+                }).onConflictDoNothing();
+
+                // Migrate skills
+                if (profile.skills?.length) {
+                    for (const skill of profile.skills) {
+                        await tursoDb.insert(schema.profileSkills).values({
+                            profileId: userId,
+                            skill: skill,
+                        }).onConflictDoNothing();
+                    }
+                }
+
+                // Migrate mentoring topics
+                if (profile.mentoring_topics?.length) {
+                    for (const topic of profile.mentoring_topics) {
+                        await tursoDb.insert(schema.profileMentoringTopics).values({
+                            profileId: userId,
+                            topic: topic,
+                        }).onConflictDoNothing();
+                    }
+                }
+
+                // Migrate connected repos
+                if (profile.connected_repos?.length) {
+                    for (const repo of profile.connected_repos) {
+                        await tursoDb.insert(schema.profileConnectedRepos).values({
+                            profileId: userId,
+                            repoName: repo,
+                        }).onConflictDoNothing();
+                    }
+                }
+                success++;
+            } catch (e) {
+                skipped++;
+            }
+        } else {
+            success++;
+        }
+    }
+    log(`Profiles: ${success} migrated, ${skipped} skipped`, "success");
+}
+
+async function migrateTriageData(
+    mongoDb: ReturnType<MongoClient["db"]>,
+    tursoDb: ReturnType<typeof drizzle>,
+    issueIdMap: Map<string, string>,
+    isDryRun: boolean
+): Promise<void> {
+    log("Migrating Triage Data...");
+    const triageData = await mongoDb.collection<MongoTriageData>("triageData").find().toArray();
+    log(`Found ${triageData.length} triage records`);
+
+    let success = 0, skipped = 0;
+    for (const triage of triageData) {
+        const triageId = extractId(triage);
+        const issueId = issueIdMap.get(triage.issueId) || triage.issueId;
+
+        if (!isDryRun) {
+            try {
+                await tursoDb.insert(schema.triageData).values({
+                    id: triageId,
+                    issueId: issueId,
+                    classification: triage.classification,
+                    summary: triage.summary,
+                    suggestedLabel: triage.suggestedLabel,
+                    sentiment: triage.sentiment,
+                    analyzedAt: toIsoString(triage.analyzedAt),
+                }).onConflictDoNothing();
+                success++;
+            } catch (e) {
+                skipped++;
+            }
+        } else {
+            success++;
+        }
+    }
+    log(`Triage Data: ${success} migrated, ${skipped} skipped`, "success");
+}
+
+async function migrateTemplates(
+    mongoDb: ReturnType<MongoClient["db"]>,
+    tursoDb: ReturnType<typeof drizzle>,
+    userIdMap: Map<string, string>,
+    isDryRun: boolean
+): Promise<void> {
+    log("Migrating Templates...");
+    const templates = await mongoDb.collection<MongoTemplate>("templates").find().toArray();
+    log(`Found ${templates.length} templates`);
+
+    let success = 0, skipped = 0;
+    for (const template of templates) {
+        const templateId = extractId(template);
+        const ownerId = userIdMap.get(template.ownerId) || template.ownerId;
+
+        if (!isDryRun) {
+            try {
+                await tursoDb.insert(schema.templates).values({
+                    id: templateId,
+                    name: template.name,
+                    body: template.body,
+                    ownerId: ownerId,
+                    triggerClassification: template.triggerClassification || null,
+                    createdAt: toIsoString(template.createdAt),
+                }).onConflictDoNothing();
+                success++;
+            } catch (e) {
+                skipped++;
+            }
+        } else {
+            success++;
+        }
+    }
+    log(`Templates: ${success} migrated, ${skipped} skipped`, "success");
+}
+
+async function migrateChatHistory(
+    mongoDb: ReturnType<MongoClient["db"]>,
+    tursoDb: ReturnType<typeof drizzle>,
+    userIdMap: Map<string, string>,
+    isDryRun: boolean
+): Promise<void> {
+    log("Migrating Chat History...");
+    const chatHistories = await mongoDb.collection<MongoChatHistory>("chat_history").find().toArray();
+    log(`Found ${chatHistories.length} chat histories`);
+
+    let historySuccess = 0, historySkipped = 0;
+    let messageSuccess = 0, messageSkipped = 0;
+
+    for (const history of chatHistories) {
+        const historyId = extractId(history);
+        const userId = userIdMap.get(history.userId) || history.userId;
+
+        if (!isDryRun) {
+            try {
+                // Insert chat history record
+                await tursoDb.insert(schema.chatHistory).values({
+                    id: historyId,
+                    userId: userId,
+                    sessionId: history.sessionId,
+                    createdAt: toIsoString(history.createdAt),
+                }).onConflictDoNothing();
+                historySuccess++;
+
+                // Insert related messages
+                if (history.messages?.length) {
+                    for (const msg of history.messages) {
+                        const msgId = uuidv4();
+                        try {
+                            await tursoDb.insert(schema.chatHistoryMessages).values({
+                                id: msgId,
+                                chatHistoryId: historyId,
+                                role: msg.role,
+                                content: msg.content,
+                                timestamp: toIsoString(msg.timestamp),
+                                githubCommentId: msg.githubCommentId || null,
+                                githubCommentUrl: msg.githubCommentUrl || null,
+                            }).onConflictDoNothing();
+                            messageSuccess++;
+                        } catch (e) {
+                            messageSkipped++;
+                        }
+                    }
+                }
+            } catch (e) {
+                historySkipped++;
+            }
+        } else {
+            log(`[DRY] Chat History: ${historyId} with ${history.messages?.length || 0} messages`);
+            historySuccess++;
+            messageSuccess += history.messages?.length || 0;
+        }
+    }
+    log(`Chat History: ${historySuccess} migrated, ${historySkipped} skipped`, "success");
+    log(`Chat Messages: ${messageSuccess} migrated, ${messageSkipped} skipped`, "success");
+}
+
+async function migrateMentors(
+    mongoDb: ReturnType<MongoClient["db"]>,
+    tursoDb: ReturnType<typeof drizzle>,
+    userIdMap: Map<string, string>,
+    isDryRun: boolean
+): Promise<Map<string, string>> {
+    log("Migrating Mentors...");
+    const mentorIdMap = new Map<string, string>();
+    const mentors = await mongoDb.collection<MongoMentor>("mentors").find().toArray();
+    log(`Found ${mentors.length} mentors`);
+
+    let success = 0, skipped = 0;
+    for (const mentor of mentors) {
+        const mentorId = extractId(mentor);
+        const originalId = mentor._id?.toString() || mentor.id || "";
+        mentorIdMap.set(originalId, mentorId);
+
+        const mappedUserId = userIdMap.get(mentor.userId) || mentor.userId;
+
+        if (!isDryRun) {
+            try {
+                await tursoDb.insert(schema.mentors).values({
+                    id: mentorId,
+                    userId: mappedUserId,
+                    username: mentor.username,
+                    expertiseLevel: mentor.expertiseLevel || "intermediate",
+                    availabilityHoursPerWeek: mentor.availabilityHoursPerWeek || 5,
+                    timezone: mentor.timezone || null,
+                    isActive: mentor.isActive ?? true,
+                    bio: mentor.bio || null,
+                    avatarUrl: mentor.avatarUrl || null,
+                    menteeCount: mentor.menteeCount || 0,
+                    sessionsCompleted: mentor.sessionsCompleted || 0,
+                    avgRating: mentor.avgRating || 0,
+                    totalRatings: mentor.totalRatings || 0,
+                    maxMentees: mentor.maxMentees || 3,
+                    createdAt: toIsoString(mentor.createdAt),
+                    updatedAt: toIsoString(mentor.updatedAt),
+                }).onConflictDoNothing();
+
+                // Migrate tech stack
+                if (mentor.techStack?.length) {
+                    for (const tech of mentor.techStack) {
+                        await tursoDb.insert(schema.mentorTechStack).values({
+                            mentorId: mentorId,
+                            tech: tech,
+                        }).onConflictDoNothing();
+                    }
+                }
+
+                // Migrate languages
+                if (mentor.languages?.length) {
+                    for (const lang of mentor.languages) {
+                        await tursoDb.insert(schema.mentorLanguages).values({
+                            mentorId: mentorId,
+                            language: lang,
+                        }).onConflictDoNothing();
+                    }
+                }
+
+                // Migrate frameworks
+                if (mentor.frameworks?.length) {
+                    for (const fw of mentor.frameworks) {
+                        await tursoDb.insert(schema.mentorFrameworks).values({
+                            mentorId: mentorId,
+                            framework: fw,
+                        }).onConflictDoNothing();
+                    }
+                }
+
+                // Migrate preferred topics
+                if (mentor.preferredTopics?.length) {
+                    for (const topic of mentor.preferredTopics) {
+                        await tursoDb.insert(schema.mentorPreferredTopics).values({
+                            mentorId: mentorId,
+                            topic: topic,
+                        }).onConflictDoNothing();
+                    }
+                }
+                success++;
+            } catch (e) {
+                skipped++;
+            }
+        } else {
+            log(`[DRY] Mentor: ${mentor.username}`);
+            success++;
+        }
+    }
+    log(`Mentors: ${success} migrated, ${skipped} skipped`, "success");
+    return mentorIdMap;
+}
+
+async function migrateTrophies(
+    mongoDb: ReturnType<MongoClient["db"]>,
+    tursoDb: ReturnType<typeof drizzle>,
+    userIdMap: Map<string, string>,
+    isDryRun: boolean
+): Promise<void> {
+    log("Migrating Trophies...");
+    const trophies = await mongoDb.collection<MongoTrophy>("trophies").find().toArray();
+    log(`Found ${trophies.length} trophies`);
+
+    let success = 0, skipped = 0;
+    for (const trophy of trophies) {
+        const trophyId = extractId(trophy);
+        const mappedUserId = userIdMap.get(trophy.userId) || trophy.userId;
+
+        if (!isDryRun) {
+            try {
+                await tursoDb.insert(schema.trophies).values({
+                    id: trophyId,
+                    userId: mappedUserId,
+                    username: trophy.username,
+                    trophyType: trophy.trophyType,
+                    name: trophy.name,
+                    description: trophy.description,
+                    icon: trophy.icon,
+                    color: trophy.color,
+                    rarity: trophy.rarity,
+                    svgData: trophy.svgData || null,
+                    isPublic: trophy.isPublic ?? true,
+                    shareUrl: trophy.shareUrl || null,
+                    earnedFor: trophy.earnedFor || null,
+                    milestoneValue: trophy.milestoneValue || null,
+                    awardedAt: toIsoString(trophy.awardedAt),
+                }).onConflictDoNothing();
+                success++;
+            } catch (e) {
+                skipped++;
+            }
+        } else {
+            log(`[DRY] Trophy: ${trophy.name} for ${trophy.username}`);
+            success++;
+        }
+    }
+    log(`Trophies: ${success} migrated, ${skipped} skipped`, "success");
+}
+
+async function migrateIssueChats(
+    mongoDb: ReturnType<MongoClient["db"]>,
+    tursoDb: ReturnType<typeof drizzle>,
+    userIdMap: Map<string, string>,
+    issueIdMap: Map<string, string>,
+    isDryRun: boolean
+): Promise<void> {
+    log("Migrating Issue Chats...");
+    const issueChats = await mongoDb.collection<MongoIssueChat>("issue_chats").find().toArray();
+    log(`Found ${issueChats.length} issue chats`);
+
+    let chatSuccess = 0, chatSkipped = 0;
+    let msgSuccess = 0, msgSkipped = 0;
+
+    for (const chat of issueChats) {
+        const chatId = extractId(chat);
+        const mappedUserId = userIdMap.get(chat.userId) || chat.userId;
+        const mappedIssueId = issueIdMap.get(chat.issueId) || chat.issueId;
+
+        if (!isDryRun) {
+            try {
+                await tursoDb.insert(schema.issueChats).values({
+                    id: chatId,
+                    issueId: mappedIssueId,
+                    userId: mappedUserId,
+                    sessionId: chat.sessionId,
+                    createdAt: toIsoString(chat.createdAt),
+                    updatedAt: toIsoString(chat.updatedAt),
+                }).onConflictDoNothing();
+                chatSuccess++;
+
+                // Migrate messages
+                if (chat.messages?.length) {
+                    for (const msg of chat.messages) {
+                        const msgId = uuidv4();
+                        try {
+                            await tursoDb.insert(schema.issueChatMessages).values({
+                                id: msgId,
+                                issueChatId: chatId,
+                                role: msg.role,
+                                content: msg.content,
+                                timestamp: toIsoString(msg.timestamp),
+                                githubCommentId: msg.githubCommentId || null,
+                                githubCommentUrl: msg.githubCommentUrl || null,
+                            }).onConflictDoNothing();
+                            msgSuccess++;
+                        } catch (e) {
+                            msgSkipped++;
+                        }
+                    }
+                }
+            } catch (e) {
+                chatSkipped++;
+            }
+        } else {
+            log(`[DRY] Issue Chat: ${chatId} with ${chat.messages?.length || 0} messages`);
+            chatSuccess++;
+            msgSuccess += chat.messages?.length || 0;
+        }
+    }
+    log(`Issue Chats: ${chatSuccess} migrated, ${chatSkipped} skipped`, "success");
+    log(`Issue Chat Messages: ${msgSuccess} migrated, ${msgSkipped} skipped`, "success");
+}
+
+async function migrateResources(
+    mongoDb: ReturnType<MongoClient["db"]>,
+    tursoDb: ReturnType<typeof drizzle>,
+    userIdMap: Map<string, string>,
+    isDryRun: boolean
+): Promise<void> {
+    log("Migrating Resources...");
+    const resources = await mongoDb.collection<MongoResource>("resources").find().toArray();
+    log(`Found ${resources.length} resources`);
+
+    let success = 0, skipped = 0;
+    for (const resource of resources) {
+        const resourceId = extractId(resource);
+        const mappedUserId = userIdMap.get(resource.sharedById) || resource.sharedById;
+
+        if (!isDryRun) {
+            try {
+                await tursoDb.insert(schema.resources).values({
+                    id: resourceId,
+                    repoName: resource.repoName,
+                    sourceType: resource.sourceType || "chat",
+                    sourceId: resource.sourceId || null,
+                    resourceType: resource.resourceType,
+                    title: resource.title,
+                    content: resource.content,
+                    description: resource.description || null,
+                    language: resource.language || null,
+                    sharedBy: resource.sharedBy,
+                    sharedById: mappedUserId,
+                    saveCount: resource.saveCount || 0,
+                    helpfulCount: resource.helpfulCount || 0,
+                    createdAt: toIsoString(resource.createdAt),
+                    updatedAt: toIsoString(resource.updatedAt),
+                }).onConflictDoNothing();
+
+                // Migrate tags
+                if (resource.tags?.length) {
+                    for (const tag of resource.tags) {
+                        await tursoDb.insert(schema.resourceTags).values({
+                            resourceId: resourceId,
+                            tag: tag,
+                        }).onConflictDoNothing();
+                    }
+                }
+                success++;
+            } catch (e) {
+                skipped++;
+            }
+        } else {
+            log(`[DRY] Resource: ${resource.title}`);
+            success++;
+        }
+    }
+    log(`Resources: ${success} migrated, ${skipped} skipped`, "success");
+}
+
+// =============================================================================
+// Main
+// =============================================================================
+
+async function main() {
+    const args = process.argv.slice(2);
+    const isDryRun = args.includes("--dry-run");
+
+    if (isDryRun) {
+        log("=== DRY RUN MODE ===", "warn");
+    }
+
+    const mongoUri = process.env.MONGO_URL || process.env.MONGODB_URI;
+    const tursoUrl = process.env.TURSO_DATABASE_URL;
+    const tursoToken = process.env.TURSO_AUTH_TOKEN;
+
+    if (!mongoUri) {
+        log("Missing MONGO_URL or MONGODB_URI", "error");
+        process.exit(1);
+    }
+    if (!tursoUrl) {
+        log("Missing TURSO_DATABASE_URL", "error");
+        process.exit(1);
+    }
+
+    log("Connecting to MongoDB...");
+    const mongoClient = new MongoClient(mongoUri);
+    await mongoClient.connect();
+    const dbName = process.env.DB_NAME || "opentriage_db";
+    const mongoDb = mongoClient.db(dbName);
+    log(`Connected to MongoDB (${dbName})`, "success");
+
+    log("Connecting to Turso...");
+    const tursoClient = createClient({ url: tursoUrl, authToken: tursoToken });
+    const tursoDb = drizzle(tursoClient, { schema });
+    log("Connected to Turso", "success");
+
+    try {
+        // Migrate in order (respecting foreign keys)
+        const userIdMap = await migrateUsers(mongoDb, tursoDb, isDryRun);
+        const repoIdMap = await migrateRepositories(mongoDb, tursoDb, userIdMap, isDryRun);
+        const issueIdMap = await migrateIssues(mongoDb, tursoDb, repoIdMap, isDryRun);
+        await migrateMessages(mongoDb, tursoDb, userIdMap, isDryRun);
+        await migrateProfiles(mongoDb, tursoDb, userIdMap, isDryRun);
+        await migrateTriageData(mongoDb, tursoDb, issueIdMap, isDryRun);
+        await migrateTemplates(mongoDb, tursoDb, userIdMap, isDryRun);
+        await migrateChatHistory(mongoDb, tursoDb, userIdMap, isDryRun);
+
+        // New migrations for complete feature support
+        const mentorIdMap = await migrateMentors(mongoDb, tursoDb, userIdMap, isDryRun);
+        await migrateTrophies(mongoDb, tursoDb, userIdMap, isDryRun);
+        await migrateIssueChats(mongoDb, tursoDb, userIdMap, issueIdMap, isDryRun);
+        await migrateResources(mongoDb, tursoDb, userIdMap, isDryRun);
+
+        log("=== Migration Complete ===", "success");
+        if (isDryRun) {
+            log("Run without --dry-run to perform actual migration", "info");
+        }
+    } finally {
+        await mongoClient.close();
+    }
+}
+
+main().catch(console.error);

src/app/api/ai/chat/route.ts

@@ -0,0 +1,41 @@
+/**
+ * AI Chat Proxy Route
+ * 
+ * Forwards requests to AI_ENGINE_URL/chat
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { chat } from "@/lib/ai-client";
+import { getCurrentUser } from "@/lib/auth";
+
+export async function POST(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const body = await request.json();
+        const { message, history, context } = body;
+
+        if (!message) {
+            return NextResponse.json({ error: "Message is required" }, { status: 400 });
+        }
+
+        const result = await chat(message, history, {
+            ...context,
+            userId: user.id,
+            username: user.username,
+            role: user.role,
+        });
+
+        if (!result.success) {
+            return NextResponse.json({ error: result.error }, { status: 502 });
+        }
+
+        return NextResponse.json(result.data);
+    } catch (error) {
+        console.error("AI Chat error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/ai/mentor-match/route.ts

@@ -0,0 +1,32 @@
+/**
+ * AI Mentor Match Proxy Route
+ * 
+ * Forwards requests to AI_ENGINE_URL/mentor-match
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { findMentorMatches } from "@/lib/ai-client";
+import { getCurrentUser } from "@/lib/auth";
+
+export async function POST(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const body = await request.json();
+        const { limit = 5 } = body;
+
+        const result = await findMentorMatches(user.id, user.username, limit);
+
+        if (!result.success) {
+            return NextResponse.json({ error: result.error }, { status: 502 });
+        }
+
+        return NextResponse.json(result.data);
+    } catch (error) {
+        console.error("AI Mentor Match error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/ai/rag/route.ts

@@ -0,0 +1,36 @@
+/**
+ * AI RAG Proxy Route
+ * 
+ * Forwards requests to AI_ENGINE_URL/rag/chat
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { ragQuery } from "@/lib/ai-client";
+import { getCurrentUser } from "@/lib/auth";
+
+export async function POST(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const body = await request.json();
+        const { question, repoName } = body;
+
+        if (!question) {
+            return NextResponse.json({ error: "Question is required" }, { status: 400 });
+        }
+
+        const result = await ragQuery(question, repoName);
+
+        if (!result.success) {
+            return NextResponse.json({ error: result.error }, { status: 502 });
+        }
+
+        return NextResponse.json(result.data);
+    } catch (error) {
+        console.error("AI RAG error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/ai/triage/route.ts

@@ -0,0 +1,41 @@
+/**
+ * AI Triage Proxy Route
+ * 
+ * Forwards requests to AI_ENGINE_URL/triage
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { triageIssue } from "@/lib/ai-client";
+import { getCurrentUser } from "@/lib/auth";
+
+export async function POST(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const body = await request.json();
+        const { title, body: issueBody, authorName, isPR } = body;
+
+        if (!title) {
+            return NextResponse.json({ error: "Title is required" }, { status: 400 });
+        }
+
+        const result = await triageIssue({
+            title,
+            body: issueBody,
+            authorName: authorName || "unknown",
+            isPR: isPR || false,
+        });
+
+        if (!result.success) {
+            return NextResponse.json({ error: result.error }, { status: 502 });
+        }
+
+        return NextResponse.json(result.data);
+    } catch (error) {
+        console.error("AI Triage error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/auth/github/callback/route.ts

@@ -0,0 +1,101 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/db";
+import { users } from "@/db/schema";
+import { createJwtToken } from "@/lib/auth";
+import { generateId, now } from "@/lib/utils";
+import { eq } from "drizzle-orm";
+
+const GITHUB_CLIENT_ID = process.env.GITHUB_CLIENT_ID!;
+const GITHUB_CLIENT_SECRET = process.env.GITHUB_CLIENT_SECRET!;
+const FRONTEND_URL = process.env.FRONTEND_URL || "http://localhost:5173";
+
+/**
+ * GET /api/auth/github/callback
+ * Handle GitHub OAuth callback and create user session.
+ */
+export async function GET(request: NextRequest) {
+    const { searchParams } = new URL(request.url);
+    const code = searchParams.get("code");
+
+    if (!code) {
+        return NextResponse.redirect(`${FRONTEND_URL}/?error=no_code`);
+    }
+
+    try {
+        // Exchange code for access token
+        const tokenResponse = await fetch(
+            "https://github.com/login/oauth/access_token",
+            {
+                method: "POST",
+                headers: {
+                    Accept: "application/json",
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    client_id: GITHUB_CLIENT_ID,
+                    client_secret: GITHUB_CLIENT_SECRET,
+                    code,
+                }),
+            }
+        );
+
+        const tokenData = await tokenResponse.json();
+        const accessToken = tokenData.access_token;
+
+        if (!accessToken) {
+            console.error("No access token:", tokenData);
+            return NextResponse.redirect(`${FRONTEND_URL}/?error=no_token`);
+        }
+
+        // Get user info from GitHub
+        const userResponse = await fetch("https://api.github.com/user", {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+
+        const githubUser = await userResponse.json();
+
+        // Check if user exists
+        const existingUsers = await db
+            .select()
+            .from(users)
+            .where(eq(users.githubId, githubUser.id))
+            .limit(1);
+
+        let userData;
+
+        if (existingUsers.length > 0) {
+            // Update existing user with new GitHub token
+            await db
+                .update(users)
+                .set({ githubAccessToken: accessToken, updatedAt: now() })
+                .where(eq(users.githubId, githubUser.id));
+
+            userData = { ...existingUsers[0], githubAccessToken: accessToken };
+        } else {
+            // Create new user
+            const newUser = {
+                id: generateId(),
+                githubId: githubUser.id,
+                username: githubUser.login,
+                avatarUrl: githubUser.avatar_url,
+                role: null,
+                githubAccessToken: accessToken,
+                createdAt: now(),
+                updatedAt: now(),
+            };
+
+            await db.insert(users).values(newUser);
+            userData = newUser;
+        }
+
+        // Create JWT token
+        const token = createJwtToken(userData.id, userData.role);
+
+        return NextResponse.redirect(`${FRONTEND_URL}/?token=${token}`);
+    } catch (error) {
+        console.error("GitHub auth error:", error);
+        return NextResponse.redirect(`${FRONTEND_URL}/?error=auth_failed`);
+    }
+}

src/app/api/auth/github/route.ts

@@ -0,0 +1,15 @@
+import { NextRequest, NextResponse } from "next/server";
+
+const GITHUB_CLIENT_ID = process.env.GITHUB_CLIENT_ID!;
+const API_URL = process.env.API_URL || "http://localhost:3000";
+
+/**
+ * GET /api/auth/github
+ * Redirect to GitHub OAuth authorization page.
+ */
+export async function GET(request: NextRequest) {
+    const callbackUrl = `${API_URL}/api/auth/github/callback`;
+    const githubUrl = `https://github.com/login/oauth/authorize?client_id=${GITHUB_CLIENT_ID}&redirect_uri=${callbackUrl}&scope=user:email,repo`;
+
+    return NextResponse.redirect(githubUrl);
+}

src/app/api/auth/me/route.ts

@@ -0,0 +1,22 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requireAuth } from "@/lib/auth";
+
+/**
+ * GET /api/auth/me
+ * Get current authenticated user information.
+ */
+export async function GET(request: NextRequest) {
+    const { user, error } = await requireAuth(request);
+
+    if (error) {
+        return error;
+    }
+
+    return NextResponse.json({
+        id: user!.id,
+        username: user!.username,
+        avatarUrl: user!.avatarUrl,
+        role: user!.role,
+        githubId: user!.githubId,
+    });
+}

src/app/api/auth/select-role/route.ts

@@ -0,0 +1,51 @@
+/**
+ * Role Selection Route
+ * 
+ * POST /api/auth/select-role
+ * Allows authenticated users to select their role (MAINTAINER or CONTRIBUTOR)
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { requireAuth, createJwtToken } from "@/lib/auth";
+import { updateUserRole } from "@/lib/db/queries/users";
+
+export async function POST(request: NextRequest) {
+    const { user, error } = await requireAuth(request);
+
+    if (error) {
+        return error;
+    }
+
+    try {
+        const body = await request.json();
+        const { role } = body;
+
+        // Validate role
+        if (!role || !["MAINTAINER", "CONTRIBUTOR"].includes(role.toUpperCase())) {
+            return NextResponse.json(
+                { error: "Invalid role. Must be MAINTAINER or CONTRIBUTOR" },
+                { status: 400 }
+            );
+        }
+
+        const normalizedRole = role.toUpperCase();
+
+        // Update user role in database
+        await updateUserRole(user!.id, normalizedRole);
+
+        // Generate new token with updated role
+        const newToken = createJwtToken(user!.id, normalizedRole);
+
+        return NextResponse.json({
+            success: true,
+            role: normalizedRole,
+            token: newToken,
+        });
+    } catch (error) {
+        console.error("Role selection error:", error);
+        return NextResponse.json(
+            { error: "Failed to update role" },
+            { status: 500 }
+        );
+    }
+}

src/app/api/chat/route.ts

@@ -0,0 +1,43 @@
+/**
+ * Chat Route
+ * 
+ * POST /api/chat
+ * Proxy to /api/ai/chat for convenience
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { chat } from "@/lib/ai-client";
+import { getCurrentUser } from "@/lib/auth";
+
+export async function POST(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const body = await request.json();
+        const { message, sessionId, history, context } = body;
+
+        if (!message) {
+            return NextResponse.json({ error: "Message is required" }, { status: 400 });
+        }
+
+        const result = await chat(message, history, {
+            ...context,
+            sessionId,
+            userId: user.id,
+            username: user.username,
+            role: user.role,
+        });
+
+        if (!result.success) {
+            return NextResponse.json({ error: result.error }, { status: 502 });
+        }
+
+        return NextResponse.json(result.data);
+    } catch (error) {
+        console.error("Chat error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/contributor/claim-activity/[issueId]/route.ts

@@ -0,0 +1,32 @@
+/**
+ * Claim Activity Route
+ * 
+ * POST /api/contributor/claim-activity/[issueId]
+ * Update activity timestamp for a claimed issue
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+
+export async function POST(
+    request: NextRequest,
+    { params }: { params: Promise<{ issueId: string }> }
+) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const { issueId } = await params;
+
+        // TODO: Implement with claimed_issues table
+        return NextResponse.json({
+            message: "Activity updated successfully (stub)",
+            issueId,
+        });
+    } catch (error) {
+        console.error("Claim activity error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/contributor/claim-issue/[issueId]/route.ts

@@ -0,0 +1,32 @@
+/**
+ * Unclaim Issue Route
+ * 
+ * DELETE /api/contributor/claim-issue/[issueId]
+ * Unclaim a previously claimed issue
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+
+export async function DELETE(
+    request: NextRequest,
+    { params }: { params: Promise<{ issueId: string }> }
+) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const { issueId } = await params;
+
+        // TODO: Implement full unclaiming logic with claimed_issues table
+        return NextResponse.json({
+            message: "Issue unclaimed successfully (stub)",
+            issueId,
+        });
+    } catch (error) {
+        console.error("Unclaim issue error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/contributor/claim-issue/route.ts

@@ -0,0 +1,38 @@
+/**
+ * Issue Claiming Routes
+ * 
+ * POST /api/contributor/claim-issue
+ * Claim an issue to work on
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+
+// Note: Full implementation requires adding claimed_issues table to schema
+// This is a stub that prevents 404 errors
+
+export async function POST(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const body = await request.json();
+        const { issueId } = body;
+
+        if (!issueId) {
+            return NextResponse.json({ error: "issueId is required" }, { status: 400 });
+        }
+
+        // TODO: Implement full claiming logic with claimed_issues table
+        return NextResponse.json({
+            message: "Issue claim registered (stub)",
+            issueId,
+            claimedAt: new Date().toISOString(),
+        });
+    } catch (error) {
+        console.error("Claim issue error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/contributor/dashboard-summary/route.ts

@@ -0,0 +1,44 @@
+/**
+ * Contributor Dashboard Summary Route
+ * 
+ * GET /api/contributor/dashboard-summary
+ * Get dashboard statistics for the contributor
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { getIssuesWithTriage } from "@/lib/db/queries/issues";
+import { getContributorRepositories } from "@/lib/db/queries/repositories";
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        // Get all contributor's issues (no pagination for stats)
+        const [repos, issuesData] = await Promise.all([
+            getContributorRepositories(user.id, user.username),
+            getIssuesWithTriage({ authorName: user.username }, 1, 1000), // Get all for accurate stats
+        ]);
+
+        const allIssues = issuesData.issues;
+        const myIssues = allIssues.filter(i => !i.isPR);
+        const myPRs = allIssues.filter(i => i.isPR);
+
+        return NextResponse.json({
+            totalContributions: allIssues.length,
+            totalPRs: myPRs.length,
+            openPRs: myPRs.filter(i => i.state === "open").length,
+            mergedPRs: myPRs.filter(i => i.state === "closed").length,
+            totalIssues: myIssues.length,
+            openIssues: myIssues.filter(i => i.state === "open").length,
+            closedIssues: myIssues.filter(i => i.state === "closed").length,
+            repositoriesContributed: repos.length,
+        });
+    } catch (error) {
+        console.error("Contributor dashboard-summary error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/contributor/my-claimed-issues/route.ts

@@ -0,0 +1,27 @@
+/**
+ * My Claimed Issues Route
+ * 
+ * GET /api/contributor/my-claimed-issues
+ * Get all issues claimed by the current user
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        // TODO: Implement with claimed_issues table
+        return NextResponse.json({
+            claims: [],
+            count: 0,
+        });
+    } catch (error) {
+        console.error("My claimed issues error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/contributor/my-issues/route.ts

@@ -0,0 +1,36 @@
+/**
+ * Contributor My Issues Route
+ * 
+ * GET /api/contributor/my-issues
+ * Get paginated list of contributor's issues and PRs
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { getIssuesWithTriage } from "@/lib/db/queries/issues";
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const { searchParams } = new URL(request.url);
+        const page = parseInt(searchParams.get("page") || "1");
+        const limit = parseInt(searchParams.get("limit") || "10");
+
+        const issuesData = await getIssuesWithTriage({ authorName: user.username }, page, limit);
+
+        return NextResponse.json({
+            items: issuesData.issues,
+            total: issuesData.total,
+            page: issuesData.page,
+            pages: issuesData.totalPages,
+            limit: issuesData.limit,
+        });
+    } catch (error) {
+        console.error("Contributor my-issues error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/contributor/route.ts

@@ -0,0 +1,54 @@
+/**
+ * Contributor Dashboard Route
+ * 
+ * Get dashboard stats and issues for contributors.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { getIssuesWithTriage } from "@/lib/db/queries/issues";
+import { getContributorRepositories } from "@/lib/db/queries/repositories";
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const { searchParams } = new URL(request.url);
+        const page = parseInt(searchParams.get("page") || "1");
+        const limit = parseInt(searchParams.get("limit") || "10");
+
+        // Get contributor's issues
+        const [repos, issuesData] = await Promise.all([
+            getContributorRepositories(user.id, user.username),
+            getIssuesWithTriage({ authorName: user.username }, page, limit),
+        ]);
+
+        // Calculate stats
+        const myIssues = issuesData.issues.filter(i => !i.isPR);
+        const myPRs = issuesData.issues.filter(i => i.isPR);
+
+        return NextResponse.json({
+            stats: {
+                totalIssues: myIssues.length,
+                totalPRs: myPRs.length,
+                openIssues: myIssues.filter(i => i.state === "open").length,
+                openPRs: myPRs.filter(i => i.state === "open").length,
+                repositoriesContributed: repos.length,
+            },
+            repositories: repos,
+            issues: issuesData.issues,
+            pagination: {
+                page: issuesData.page,
+                limit: issuesData.limit,
+                total: issuesData.total,
+                totalPages: issuesData.totalPages,
+            }
+        });
+    } catch (error) {
+        console.error("Contributor dashboard error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/issues/[id]/messages/route.ts

@@ -0,0 +1,139 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/db";
+import { chatMessages, issues } from "@/db/schema";
+import { requireAuth } from "@/lib/auth";
+import { generateId, now } from "@/lib/utils";
+import { eq, desc, gt, and } from "drizzle-orm";
+
+type RouteContext = {
+    params: Promise<{ id: string }>;
+};
+
+/**
+ * GET /api/issues/[id]/messages
+ * Get chat messages for an issue.
+ */
+export async function GET(
+    request: NextRequest,
+    context: RouteContext
+) {
+    const { id: issueId } = await context.params;
+    const { searchParams } = new URL(request.url);
+    const afterId = searchParams.get("afterId");
+    const limit = parseInt(searchParams.get("limit") || "50", 10);
+
+    try {
+        // Verify issue exists
+        const issueRecords = await db
+            .select()
+            .from(issues)
+            .where(eq(issues.id, issueId))
+            .limit(1);
+
+        if (issueRecords.length === 0) {
+            return NextResponse.json(
+                { error: "Issue not found" },
+                { status: 404 }
+            );
+        }
+
+        // Build query for messages
+        // Note: We use sessionId to associate messages with issues
+        // In a proper implementation, you'd have a session per issue
+        let messagesQuery = db
+            .select()
+            .from(chatMessages)
+            .where(eq(chatMessages.sessionId, issueId))
+            .orderBy(desc(chatMessages.timestamp))
+            .limit(limit);
+
+        const messages = await messagesQuery;
+
+        // Reverse to show oldest first
+        messages.reverse();
+
+        return NextResponse.json({
+            messages,
+            count: messages.length,
+            issueId,
+        });
+    } catch (error) {
+        console.error("GET /api/issues/[id]/messages error:", error);
+        return NextResponse.json(
+            { error: "Failed to fetch messages" },
+            { status: 500 }
+        );
+    }
+}
+
+/**
+ * POST /api/issues/[id]/messages
+ * Send a chat message for an issue.
+ *
+ * Request body: { content: string, messageType?: string }
+ */
+export async function POST(
+    request: NextRequest,
+    context: RouteContext
+) {
+    const { user, error } = await requireAuth(request);
+    if (error) return error;
+
+    const { id: issueId } = await context.params;
+
+    try {
+        const body = await request.json();
+        const { content, messageType = "text" } = body;
+
+        if (!content || typeof content !== "string") {
+            return NextResponse.json(
+                { error: "content is required" },
+                { status: 400 }
+            );
+        }
+
+        // Verify issue exists
+        const issueRecords = await db
+            .select()
+            .from(issues)
+            .where(eq(issues.id, issueId))
+            .limit(1);
+
+        if (issueRecords.length === 0) {
+            return NextResponse.json(
+                { error: "Issue not found" },
+                { status: 404 }
+            );
+        }
+
+        // Create the message
+        const message = {
+            id: generateId(),
+            sessionId: issueId, // Using issueId as sessionId for issue-based chats
+            senderId: user!.id,
+            senderUsername: user!.username,
+            isMentor: false,
+            content,
+            messageType,
+            language: null,
+            isAiGenerated: false,
+            containsResource: false,
+            extractedResourceId: null,
+            timestamp: now(),
+            editedAt: null,
+        };
+
+        await db.insert(chatMessages).values(message);
+
+        return NextResponse.json({
+            message: "Message sent",
+            data: message,
+        }, { status: 201 });
+    } catch (error) {
+        console.error("POST /api/issues/[id]/messages error:", error);
+        return NextResponse.json(
+            { error: "Failed to send message" },
+            { status: 500 }
+        );
+    }
+}

src/app/api/issues/route.ts

@@ -0,0 +1,142 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/db";
+import { issues, triageData, repositories } from "@/db/schema";
+import { generateId, now } from "@/lib/utils";
+import { eq, and, desc } from "drizzle-orm";
+
+// =============================================================================
+// GET /api/issues - Get issues for a repository
+// =============================================================================
+// 
+// Python equivalent (from routes/repository.py):
+//   repos = await db.issues.find({"repoId": repo_id}, {"_id": 0}).to_list(1000)
+//
+export async function GET(request: NextRequest) {
+    try {
+        const { searchParams } = new URL(request.url);
+        const repoId = searchParams.get("repoId");
+        const state = searchParams.get("state"); // open, closed, all
+        const isPR = searchParams.get("isPR"); // true, false
+
+        // Build query conditions
+        const conditions = [];
+        if (repoId) {
+            conditions.push(eq(issues.repoId, repoId));
+        }
+        if (state && state !== "all") {
+            conditions.push(eq(issues.state, state));
+        }
+        if (isPR !== null && isPR !== undefined) {
+            conditions.push(eq(issues.isPR, isPR === "true"));
+        }
+
+        // Execute query with Drizzle
+        const result = await db
+            .select()
+            .from(issues)
+            .where(conditions.length > 0 ? and(...conditions) : undefined)
+            .orderBy(desc(issues.createdAt))
+            .limit(100);
+
+        return NextResponse.json(result, { status: 200 });
+    } catch (error) {
+        console.error("GET /api/issues error:", error);
+        return NextResponse.json(
+            { error: "Failed to fetch issues" },
+            { status: 500 }
+        );
+    }
+}
+
+// =============================================================================
+// POST /api/issues - Create a new issue
+// =============================================================================
+//
+// Python equivalent (from routes/repository.py):
+//   issue = Issue(
+//       githubIssueId=gh_issue['id'],
+//       number=gh_issue['number'],
+//       title=gh_issue['title'],
+//       body=gh_issue.get('body') or '',
+//       authorName=gh_issue['user']['login'],
+//       repoId=repository.id,
+//       repoName=repository.name,
+//       ...
+//   )
+//   issue_dict = issue.model_dump()
+//   issue_dict['createdAt'] = issue_dict['createdAt'].isoformat()
+//   await db.issues.insert_one(issue_dict)
+//
+export async function POST(request: NextRequest) {
+    try {
+        const body = await request.json();
+
+        // Validate required fields
+        const { githubIssueId, number, title, authorName, repoId, repoName } = body;
+        if (!githubIssueId || !number || !title || !authorName || !repoId || !repoName) {
+            return NextResponse.json(
+                { error: "Missing required fields" },
+                { status: 400 }
+            );
+        }
+
+        // Check if repository exists
+        const repo = await db
+            .select()
+            .from(repositories)
+            .where(eq(repositories.id, repoId))
+            .limit(1);
+
+        if (repo.length === 0) {
+            return NextResponse.json(
+                { error: "Repository not found" },
+                { status: 404 }
+            );
+        }
+
+        // Check if issue already exists
+        const existingIssue = await db
+            .select()
+            .from(issues)
+            .where(eq(issues.githubIssueId, githubIssueId))
+            .limit(1);
+
+        if (existingIssue.length > 0) {
+            return NextResponse.json(
+                { error: "Issue already exists", issue: existingIssue[0] },
+                { status: 409 }
+            );
+        }
+
+        // Create new issue
+        const newIssue = {
+            id: generateId(),
+            githubIssueId,
+            number,
+            title,
+            body: body.body || "",
+            authorName,
+            repoId,
+            repoName,
+            owner: body.owner || "",
+            repo: body.repo || "",
+            htmlUrl: body.htmlUrl || "",
+            state: body.state || "open",
+            isPR: body.isPR || false,
+            createdAt: now(),
+        };
+
+        await db.insert(issues).values(newIssue);
+
+        return NextResponse.json(
+            { message: "Issue created", issue: newIssue },
+            { status: 201 }
+        );
+    } catch (error) {
+        console.error("POST /api/issues error:", error);
+        return NextResponse.json(
+            { error: "Failed to create issue" },
+            { status: 500 }
+        );
+    }
+}

src/app/api/maintainer/dashboard-summary/route.ts

@@ -0,0 +1,39 @@
+/**
+ * Maintainer Dashboard Summary Route
+ * 
+ * GET /api/maintainer/dashboard-summary
+ * Get dashboard statistics for maintainers
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { getDashboardStats } from "@/lib/db/queries/issues";
+import { getMaintainerRepositories } from "@/lib/db/queries/repositories";
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        if (user.role !== "MAINTAINER" && user.role !== "maintainer") {
+            return NextResponse.json({ error: "Maintainer access required" }, { status: 403 });
+        }
+
+        // Get dashboard stats
+        const [stats, repos] = await Promise.all([
+            getDashboardStats(user.id),
+            getMaintainerRepositories(user.id),
+        ]);
+
+        return NextResponse.json({
+            ...stats,
+            repositoriesCount: repos.length,
+            repositories: repos,
+        });
+    } catch (error) {
+        console.error("Maintainer dashboard-summary error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/maintainer/issues/route.ts

@@ -0,0 +1,44 @@
+/**
+ * Maintainer Issues Route
+ * 
+ * GET /api/maintainer/issues
+ * Fetch issues for a maintainer with filtering and pagination.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { getIssues, getIssuesWithTriage, IssueFilters } from "@/lib/db/queries/issues";
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const { searchParams } = new URL(request.url);
+        const page = parseInt(searchParams.get("page") || "1");
+        const limit = parseInt(searchParams.get("limit") || "10");
+        const state = searchParams.get("state") || undefined;
+        const repoId = searchParams.get("repoId") || undefined;
+        const search = searchParams.get("search") || undefined;
+        const withTriage = searchParams.get("withTriage") === "true";
+
+        const filters: IssueFilters = {
+            userId: user.id, // Filter by user's repos
+            state,
+            repoId,
+            search,
+            isPR: false, // Only fetch issues, not PRs
+        };
+
+        const result = withTriage
+            ? await getIssuesWithTriage(filters, page, limit)
+            : await getIssues(filters, page, limit);
+
+        return NextResponse.json(result);
+    } catch (error) {
+        console.error("GET /api/maintainer/issues error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/maintainer/route.ts

@@ -0,0 +1,49 @@
+/**
+ * Maintainer Dashboard Route
+ * 
+ * Get dashboard stats, issues, and templates for maintainers.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { getDashboardStats, getIssuesWithTriage } from "@/lib/db/queries/issues";
+import { getMaintainerRepositories, getRepositoryStats } from "@/lib/db/queries/repositories";
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        if (user.role !== "MAINTAINER" && user.role !== "maintainer") {
+            return NextResponse.json({ error: "Maintainer access required" }, { status: 403 });
+        }
+
+        const { searchParams } = new URL(request.url);
+        const page = parseInt(searchParams.get("page") || "1");
+        const limit = parseInt(searchParams.get("limit") || "10");
+
+        // Get dashboard data
+        const [stats, repos, issuesData] = await Promise.all([
+            getDashboardStats(user.id),
+            getMaintainerRepositories(user.id),
+            getIssuesWithTriage({ userId: user.id, state: "open" }, page, limit),
+        ]);
+
+        return NextResponse.json({
+            stats,
+            repositories: repos,
+            issues: issuesData.issues,
+            pagination: {
+                page: issuesData.page,
+                limit: issuesData.limit,
+                total: issuesData.total,
+                totalPages: issuesData.totalPages,
+            }
+        });
+    } catch (error) {
+        console.error("Maintainer dashboard error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/maintainer/templates/route.ts

@@ -0,0 +1,25 @@
+/**
+ * Maintainer Templates Route
+ * 
+ * GET /api/maintainer/templates
+ * Fetch templates for a maintainer.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { getTemplatesByOwnerId } from "@/lib/db/queries/templates";
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const templates = await getTemplatesByOwnerId(user.id);
+        return NextResponse.json(templates);
+    } catch (error) {
+        console.error("GET /api/maintainer/templates error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/messages/route.ts

@@ -0,0 +1,63 @@
+/**
+ * Messages Route
+ * 
+ * Get conversations and send messages.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { getConversations, getChatHistory, sendMessage, markMessagesAsRead, getUnreadCount } from "@/lib/db/queries/messages";
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const { searchParams } = new URL(request.url);
+        const otherUserId = searchParams.get("with");
+
+        if (otherUserId) {
+            // Get chat history with specific user
+            const history = await getChatHistory(user.id, otherUserId);
+            await markMessagesAsRead(user.id, otherUserId);
+            return NextResponse.json({ messages: history });
+        } else {
+            // Get all conversations
+            const conversations = await getConversations(user.id);
+            const unreadCount = await getUnreadCount(user.id);
+            return NextResponse.json({ conversations, unreadCount });
+        }
+    } catch (error) {
+        console.error("Messages fetch error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}
+
+export async function POST(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const body = await request.json();
+        const { receiverId, content } = body;
+
+        if (!receiverId || !content) {
+            return NextResponse.json({ error: "receiverId and content are required" }, { status: 400 });
+        }
+
+        const message = await sendMessage({
+            senderId: user.id,
+            receiverId,
+            content,
+        });
+
+        return NextResponse.json(message);
+    } catch (error) {
+        console.error("Message send error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/messaging/conversations/route.ts

@@ -0,0 +1,36 @@
+/**
+ * Messaging Conversations Route
+ * 
+ * GET /api/messaging/conversations
+ * Get list of all conversations for the current user
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { getConversations } from "@/lib/db/queries/messages";
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const conversations = await getConversations(user.id);
+
+        // Format to match frontend expectations
+        return NextResponse.json({
+            conversations: conversations.map(c => ({
+                user_id: c.partnerId,
+                username: c.partnerUsername,
+                avatar_url: c.partnerAvatar,
+                last_message: c.lastMessage?.content?.substring(0, 50) || "",
+                last_timestamp: c.lastMessage?.timestamp || null,
+                unread_count: c.unreadCount
+            }))
+        });
+    } catch (error) {
+        console.error("Conversations error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/messaging/history/[userId]/route.ts

@@ -0,0 +1,35 @@
+/**
+ * Messaging History Route
+ * 
+ * GET /api/messaging/history/[userId]
+ * Get chat history with a specific user
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { getChatHistory, markMessagesAsRead } from "@/lib/db/queries/messages";
+
+export async function GET(
+    request: NextRequest,
+    { params }: { params: Promise<{ userId: string }> }
+) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const { userId: otherUserId } = await params;
+
+        // Get chat history
+        const history = await getChatHistory(user.id, otherUserId);
+
+        // Mark messages as read
+        await markMessagesAsRead(user.id, otherUserId);
+
+        return NextResponse.json(history);
+    } catch (error) {
+        console.error("Chat history error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/messaging/mark-read/[userId]/route.ts

@@ -0,0 +1,31 @@
+/**
+ * Messaging Mark Read Route
+ * 
+ * POST /api/messaging/mark-read/[userId]
+ * Mark all messages from a user as read
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { markMessagesAsRead } from "@/lib/db/queries/messages";
+
+export async function POST(
+    request: NextRequest,
+    { params }: { params: Promise<{ userId: string }> }
+) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const { userId: otherUserId } = await params;
+
+        await markMessagesAsRead(user.id, otherUserId);
+
+        return NextResponse.json({ success: true, message: "Messages marked as read" });
+    } catch (error) {
+        console.error("Mark read error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/messaging/poll/[userId]/route.ts

@@ -0,0 +1,33 @@
+/**
+ * Messaging Poll Route
+ * 
+ * GET /api/messaging/poll/[userId]
+ * Poll for new messages from a specific user
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { pollNewMessages } from "@/lib/db/queries/messages";
+
+export async function GET(
+    request: NextRequest,
+    { params }: { params: Promise<{ userId: string }> }
+) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const { userId: otherUserId } = await params;
+        const { searchParams } = new URL(request.url);
+        const lastMessageId = searchParams.get("last_message_id") || undefined;
+
+        const newMessages = await pollNewMessages(user.id, otherUserId, lastMessageId);
+
+        return NextResponse.json(newMessages);
+    } catch (error) {
+        console.error("Poll messages error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/messaging/route.ts

@@ -0,0 +1,34 @@
+/**
+ * Messaging Routes
+ * 
+ * Full messaging API for the frontend
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import {
+    getConversations,
+    getChatHistory,
+    sendMessage,
+    markMessagesAsRead,
+    getUnreadCount,
+    pollNewMessages
+} from "@/lib/db/queries/messages";
+
+// GET /api/messaging - Get conversations list
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const conversations = await getConversations(user.id);
+        const unreadCount = await getUnreadCount(user.id);
+
+        return NextResponse.json({ conversations, unreadCount });
+    } catch (error) {
+        console.error("Messaging error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/messaging/send/route.ts

@@ -0,0 +1,40 @@
+/**
+ * Messaging Send Route
+ * 
+ * POST /api/messaging/send
+ * Send a message to another user
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { sendMessage } from "@/lib/db/queries/messages";
+
+export async function POST(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const body = await request.json();
+        const { receiver_id, content } = body;
+
+        if (!receiver_id || !content) {
+            return NextResponse.json(
+                { error: "receiver_id and content are required" },
+                { status: 400 }
+            );
+        }
+
+        const message = await sendMessage({
+            senderId: user.id,
+            receiverId: receiver_id,
+            content,
+        });
+
+        return NextResponse.json(message);
+    } catch (error) {
+        console.error("Send message error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/messaging/unread-count/route.ts

@@ -0,0 +1,26 @@
+/**
+ * Messaging Unread Count Route
+ * 
+ * GET /api/messaging/unread-count
+ * Get the count of unread messages for the authenticated user
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { getUnreadCount } from "@/lib/db/queries/messages";
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const count = await getUnreadCount(user.id);
+
+        return NextResponse.json({ count });
+    } catch (error) {
+        console.error("Unread count error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/profile/[id]/connected-repos/route.ts

@@ -0,0 +1,23 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/db";
+import { profileConnectedRepos } from "@/db/schema";
+import { eq } from "drizzle-orm";
+
+export async function GET(
+    request: NextRequest,
+    context: { params: Promise<{ id: string }> }
+) {
+    try {
+        const { id } = await context.params;
+        // 'id' here corresponds to the profile's userId (since userId is PK for profiles)
+        const repos = await db
+            .select()
+            .from(profileConnectedRepos)
+            .where(eq(profileConnectedRepos.profileId, id));
+
+        return NextResponse.json(repos);
+    } catch (error) {
+        console.error("GET /api/profile/:id/connected-repos error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/profile/[username]/featured-badges/route.ts

@@ -0,0 +1,20 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getUserBadges } from "@/lib/db/queries/gamification";
+
+export async function GET(
+    request: NextRequest,
+    context: { params: Promise<{ username: string }> }
+) {
+    try {
+        const { username } = await context.params;
+        const badges = await getUserBadges(username);
+        // For now, just return top 5 badges as "featured"
+        // In the future, we could add a "featured" flag to the trophy table
+        const featured = badges.slice(0, 5);
+
+        return NextResponse.json(featured);
+    } catch (error) {
+        console.error("GET /api/profile/:username/featured-badges error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/profile/[username]/repos/route.ts

@@ -0,0 +1,31 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/db";
+import { repositories, users } from "@/db/schema";
+import { eq, desc } from "drizzle-orm";
+
+export async function GET(
+    request: NextRequest,
+    context: { params: Promise<{ username: string }> }
+) {
+    try {
+        const { username } = await context.params;
+
+        // Find user first to get ID
+        const user = await db.select().from(users).where(eq(users.username, username)).limit(1);
+
+        if (!user[0]) {
+            return NextResponse.json({ error: "User not found" }, { status: 404 });
+        }
+
+        const repos = await db
+            .select()
+            .from(repositories)
+            .where(eq(repositories.userId, user[0].id))
+            .orderBy(desc(repositories.createdAt));
+
+        return NextResponse.json(repos);
+    } catch (error) {
+        console.error("GET /api/profile/:username/repos error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/profile/[username]/route.ts

@@ -0,0 +1,19 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getProfileByUsername } from "@/lib/db/queries/users";
+
+export async function GET(
+    request: NextRequest,
+    context: { params: Promise<{ username: string }> }
+) {
+    try {
+        const { username } = await context.params;
+        const profile = await getProfileByUsername(username);
+        if (!profile) {
+            return NextResponse.json({ error: "Profile not found" }, { status: 404 });
+        }
+        return NextResponse.json(profile);
+    } catch (error) {
+        console.error("GET /api/profile/:username error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/profile/route.ts

@@ -0,0 +1,59 @@
+/**
+ * Profile Route
+ * 
+ * Get and update user profiles.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { getProfileByUsername, createOrUpdateProfile } from "@/lib/db/queries/users";
+
+export async function GET(request: NextRequest) {
+    try {
+        const { searchParams } = new URL(request.url);
+        const username = searchParams.get("username");
+
+        if (!username) {
+            return NextResponse.json({ error: "Username is required" }, { status: 400 });
+        }
+
+        const profile = await getProfileByUsername(username);
+        if (!profile) {
+            return NextResponse.json({ error: "Profile not found" }, { status: 404 });
+        }
+
+        return NextResponse.json(profile);
+    } catch (error) {
+        console.error("Profile fetch error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}
+
+export async function PUT(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const body = await request.json();
+        const { bio, location, website, twitter, skills, availableForMentoring, mentoringTopics } = body;
+
+        const profile = await createOrUpdateProfile(user.id, {
+            username: user.username,
+            avatarUrl: user.avatarUrl,
+            bio,
+            location,
+            website,
+            twitter,
+            skills,
+            availableForMentoring,
+            mentoringTopics,
+        });
+
+        return NextResponse.json(profile);
+    } catch (error) {
+        console.error("Profile update error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/rag/chat/route.ts

@@ -0,0 +1,37 @@
+/**
+ * RAG Chat Route
+ * 
+ * POST /api/rag/chat
+ * Answer questions using RAG (Retrieval-Augmented Generation)
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { ragChat } from "@/lib/ai-client";
+
+export async function POST(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const body = await request.json();
+        const { question, repo_name, top_k } = body;
+
+        if (!question) {
+            return NextResponse.json({ error: "question is required" }, { status: 400 });
+        }
+
+        const result = await ragChat(question, repo_name, top_k || 5);
+
+        if (!result.success) {
+            return NextResponse.json({ error: result.error }, { status: 502 });
+        }
+
+        return NextResponse.json(result.data);
+    } catch (error) {
+        console.error("RAG chat error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/rag/index/route.ts

@@ -0,0 +1,37 @@
+/**
+ * RAG Index Route
+ * 
+ * POST /api/rag/index
+ * Index a repository for RAG search
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { ragIndex } from "@/lib/ai-client";
+
+export async function POST(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const body = await request.json();
+        const { repo_name } = body;
+
+        if (!repo_name) {
+            return NextResponse.json({ error: "repo_name is required" }, { status: 400 });
+        }
+
+        const result = await ragIndex(repo_name);
+
+        if (!result.success) {
+            return NextResponse.json({ error: result.error }, { status: 502 });
+        }
+
+        return NextResponse.json(result.data);
+    } catch (error) {
+        console.error("RAG index error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/rag/search/route.ts

@@ -0,0 +1,37 @@
+/**
+ * RAG Search Route
+ * 
+ * POST /api/rag/search
+ * Search documents using RAG
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { ragSearch } from "@/lib/ai-client";
+
+export async function POST(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const body = await request.json();
+        const { query, repo_name, limit } = body;
+
+        if (!query) {
+            return NextResponse.json({ error: "query is required" }, { status: 400 });
+        }
+
+        const result = await ragSearch(query, repo_name, limit || 10);
+
+        if (!result.success) {
+            return NextResponse.json({ error: result.error }, { status: 502 });
+        }
+
+        return NextResponse.json(result.data);
+    } catch (error) {
+        console.error("RAG search error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/rag/suggestions/route.ts

@@ -0,0 +1,40 @@
+/**
+ * RAG Suggestions Route
+ * 
+ * GET /api/rag/suggestions
+ * Get suggested questions for RAG chatbot
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { callAIEngine } from "@/lib/ai-client";
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const { searchParams } = new URL(request.url);
+        const repoName = searchParams.get("repo_name");
+
+        // Call AI engine with empty body for suggestions
+        const AI_ENGINE_URL = process.env.AI_ENGINE_URL || "http://localhost:7860";
+        const url = repoName
+            ? `${AI_ENGINE_URL}/rag/suggestions?repo_name=${encodeURIComponent(repoName)}`
+            : `${AI_ENGINE_URL}/rag/suggestions`;
+
+        const response = await fetch(url);
+
+        if (!response.ok) {
+            return NextResponse.json({ error: "Failed to get suggestions" }, { status: 502 });
+        }
+
+        const data = await response.json();
+        return NextResponse.json(data);
+    } catch (error) {
+        console.error("RAG suggestions error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/repositories/contributor/route.ts

@@ -0,0 +1,98 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/db";
+import { issues, repositories } from "@/db/schema";
+import { eq, and, ne, desc, sql, count, max, inArray } from "drizzle-orm";
+
+// =============================================================================
+// GET /api/repositories/contributor - Get repos where user has PRs
+// =============================================================================
+//
+// This is the most complex query in the original Python backend.
+// It uses a MongoDB aggregation pipeline to find unique repos where
+// the user has contributed PRs but is NOT the owner.
+//
+// Original Python aggregation pipeline (from routes/repository.py):
+// 
+//   pipeline = [
+//       {"$match": {"authorName": username, "isPR": True}},
+//       {"$group": {
+//           "_id": {"repoId": "$repoId", "repoName": "$repoName", "owner": "$owner", "repo": "$repo"},
+//           "pr_count": {"$sum": 1},
+//           "last_pr_at": {"$max": "$createdAt"}
+//       }},
+//       {"$project": {...}},
+//       {"$sort": {"pr_count": -1}}
+//   ]
+//   contributed_repos = await db.issues.aggregate(pipeline).to_list(1000)
+//
+// Drizzle SQL equivalent using GROUP BY:
+//
+export async function GET(request: NextRequest) {
+    try {
+        const { searchParams } = new URL(request.url);
+        const username = searchParams.get("username");
+        const userId = searchParams.get("userId");
+
+        if (!username || !userId) {
+            return NextResponse.json(
+                { error: "username and userId are required" },
+                { status: 400 }
+            );
+        }
+
+        // Step 1: Get user's own repo IDs to exclude
+        const ownRepos = await db
+            .select({ id: repositories.id })
+            .from(repositories)
+            .where(eq(repositories.userId, userId));
+
+        const ownRepoIds = ownRepos.map(r => r.id);
+
+        // Step 2: Aggregate PRs by repo - equivalent to MongoDB $group
+        // SQL: SELECT repo_id, repo_name, COUNT(*) as pr_count, MAX(created_at) as last_pr_at
+        //      FROM issues WHERE author_name = ? AND is_pr = 1 GROUP BY repo_id, repo_name, owner, repo
+        const contributedRepos = await db
+            .select({
+                repoId: issues.repoId,
+                repoName: issues.repoName,
+                owner: issues.owner,
+                repo: issues.repo,
+                prCount: count().as("pr_count"),
+                lastPrAt: max(issues.createdAt).as("last_pr_at"),
+            })
+            .from(issues)
+            .where(
+                and(
+                    eq(issues.authorName, username),
+                    eq(issues.isPR, true)
+                )
+            )
+            .groupBy(issues.repoId, issues.repoName, issues.owner, issues.repo)
+            .orderBy(desc(sql`pr_count`));
+
+        // Step 3: Filter out user's own repos
+        const result = contributedRepos
+            .filter(repo => !ownRepoIds.includes(repo.repoId))
+            .map(repo => ({
+                repoId: repo.repoId,
+                repoName: repo.repoName,
+                owner: repo.owner,
+                repo: repo.repo,
+                pr_count: repo.prCount,
+                last_pr_at: repo.lastPrAt,
+                role: "contributor",
+                name: repo.repoName || `${repo.owner}/${repo.repo}`,
+            }));
+
+        return NextResponse.json(
+            { repos: result, count: result.length },
+            { status: 200 }
+        );
+    } catch (error) {
+        console.error("GET /api/repositories/contributor error:", error);
+        return NextResponse.json(
+            { error: "Failed to fetch contributor repositories" },
+            { status: 500 }
+        );
+    }
+}

src/app/api/repositories/route.ts

@@ -0,0 +1,122 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/db";
+import { repositories, issues, triageData } from "@/db/schema";
+import { generateId, now } from "@/lib/utils";
+import { eq, and, desc, count, sql } from "drizzle-orm";
+
+// =============================================================================
+// GET /api/repositories - Get user's repositories
+// =============================================================================
+//
+// Python equivalent (from routes/repository.py):
+//   repos = await db.repositories.find({"userId": user['id']}, {"_id": 0}).to_list(1000)
+//
+import { getCurrentUser } from "@/lib/auth";
+
+// ...
+
+export async function GET(request: NextRequest) {
+    try {
+        const { searchParams } = new URL(request.url);
+        let userId = searchParams.get("userId");
+
+        // If no userId provided, try to get the current authenticated user
+        if (!userId) {
+            const currentUser = await getCurrentUser(request);
+            if (currentUser) {
+                userId = currentUser.id;
+            } else {
+                return NextResponse.json(
+                    { error: "userId is required or you must be logged in" },
+                    { status: 401 }
+                );
+            }
+        }
+
+        const repos = await db
+            .select()
+            .from(repositories)
+            .where(eq(repositories.userId, userId))
+            .orderBy(desc(repositories.createdAt));
+
+        return NextResponse.json(repos, { status: 200 });
+    } catch (error) {
+        console.error("GET /api/repositories error:", error);
+        return NextResponse.json(
+            { error: "Failed to fetch repositories" },
+            { status: 500 }
+        );
+    }
+}
+
+// =============================================================================
+// POST /api/repositories - Add a new repository
+// =============================================================================
+//
+// Python equivalent (from routes/repository.py):
+//   repository = Repository(
+//       githubRepoId=repo_data['id'],
+//       name=request.repoFullName,
+//       owner=owner,
+//       userId=user['id']
+//   )
+//   repo_dict = repository.model_dump()
+//   repo_dict['createdAt'] = repo_dict['createdAt'].isoformat()
+//   await db.repositories.insert_one(repo_dict)
+//
+export async function POST(request: NextRequest) {
+    try {
+        const body = await request.json();
+        const { githubRepoId, name, owner, userId } = body;
+
+        // Validate required fields
+        if (!githubRepoId || !name || !owner || !userId) {
+            return NextResponse.json(
+                { error: "Missing required fields: githubRepoId, name, owner, userId" },
+                { status: 400 }
+            );
+        }
+
+        // Check if repository already exists for this user
+        const existing = await db
+            .select()
+            .from(repositories)
+            .where(
+                and(
+                    eq(repositories.githubRepoId, githubRepoId),
+                    eq(repositories.userId, userId)
+                )
+            )
+            .limit(1);
+
+        if (existing.length > 0) {
+            return NextResponse.json(
+                { error: "Repository already added", repository: existing[0] },
+                { status: 409 }
+            );
+        }
+
+        // Create new repository
+        const newRepo = {
+            id: generateId(),
+            githubRepoId,
+            name,
+            owner,
+            userId,
+            createdAt: now(),
+        };
+
+        await db.insert(repositories).values(newRepo);
+
+        return NextResponse.json(
+            { message: "Repository added!", repository: newRepo },
+            { status: 201 }
+        );
+    } catch (error) {
+        console.error("POST /api/repositories error:", error);
+        return NextResponse.json(
+            { error: "Failed to add repository" },
+            { status: 500 }
+        );
+    }
+}

src/app/api/spark/badges/user/[username]/route.ts

@@ -0,0 +1,16 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getUserBadges } from "@/lib/db/queries/gamification";
+
+export async function GET(
+    request: NextRequest,
+    context: { params: Promise<{ username: string }> }
+) {
+    try {
+        const { username } = await context.params;
+        const badges = await getUserBadges(username);
+        return NextResponse.json(badges);
+    } catch (error) {
+        console.error("GET /api/spark/badges/user/:username error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/spark/gamification/calendar/[username]/route.ts

@@ -0,0 +1,16 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getUserCalendar } from "@/lib/db/queries/gamification";
+
+export async function GET(
+    request: NextRequest,
+    context: { params: Promise<{ username: string }> }
+) {
+    try {
+        const { username } = await context.params;
+        const calendar = await getUserCalendar(username);
+        return NextResponse.json(calendar);
+    } catch (error) {
+        console.error("GET /api/spark/gamification/calendar/:username error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/spark/gamification/streak/[username]/route.ts

@@ -0,0 +1,16 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getUserStreak } from "@/lib/db/queries/gamification";
+
+export async function GET(
+    request: NextRequest,
+    context: { params: Promise<{ username: string }> }
+) {
+    try {
+        const { username } = await context.params;
+        const streak = await getUserStreak(username);
+        return NextResponse.json(streak);
+    } catch (error) {
+        console.error("GET /api/spark/gamification/streak/:username error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/triage/route.ts

@@ -0,0 +1,181 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/db";
+import { issues, triageData } from "@/db/schema";
+import { requireAuth } from "@/lib/auth";
+import { generateId, now } from "@/lib/utils";
+import { eq } from "drizzle-orm";
+
+// OpenRouter API for AI classification
+const OPENROUTER_API_KEY = process.env.OPENROUTER_API_KEY!;
+
+/**
+ * Classifications matching the Python backend
+ */
+const CLASSIFICATIONS = [
+    "CRITICAL_BUG", "BUG", "FEATURE_REQUEST", "QUESTION",
+    "DOCS", "DUPLICATE", "NEEDS_INFO", "SPAM"
+] as const;
+
+const SENTIMENTS = ["POSITIVE", "NEUTRAL", "NEGATIVE", "FRUSTRATED"] as const;
+
+/**
+ * POST /api/triage
+ * Classify an issue using AI.
+ *
+ * Request body: { issueId: string }
+ */
+export async function POST(request: NextRequest) {
+    const { user, error } = await requireAuth(request);
+    if (error) return error;
+
+    try {
+        const body = await request.json();
+        const { issueId } = body;
+
+        if (!issueId) {
+            return NextResponse.json(
+                { error: "issueId is required" },
+                { status: 400 }
+            );
+        }
+
+        // Fetch the issue
+        const issueRecords = await db
+            .select()
+            .from(issues)
+            .where(eq(issues.id, issueId))
+            .limit(1);
+
+        if (issueRecords.length === 0) {
+            return NextResponse.json(
+                { error: "Issue not found" },
+                { status: 404 }
+            );
+        }
+
+        const issue = issueRecords[0];
+
+        // Check if already triaged
+        const existingTriage = await db
+            .select()
+            .from(triageData)
+            .where(eq(triageData.issueId, issueId))
+            .limit(1);
+
+        if (existingTriage.length > 0) {
+            return NextResponse.json({
+                message: "Issue already triaged",
+                triage: existingTriage[0],
+            });
+        }
+
+        // Build AI prompt for classification
+        const prompt = `Analyze this GitHub issue and provide a classification.
+
+Title: ${issue.title}
+Body: ${issue.body || "(empty)"}
+
+Respond with valid JSON only:
+{
+  "classification": "BUG" | "CRITICAL_BUG" | "FEATURE_REQUEST" | "QUESTION" | "DOCS" | "DUPLICATE" | "NEEDS_INFO" | "SPAM",
+  "sentiment": "POSITIVE" | "NEUTRAL" | "NEGATIVE" | "FRUSTRATED",
+  "summary": "One-line summary of the issue",
+  "suggestedLabel": "Suggested GitHub label (lowercase, hyphenated)"
+}`;
+
+        // Call OpenRouter API
+        const aiResponse = await fetch(
+            "https://openrouter.ai/api/v1/chat/completions",
+            {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${OPENROUTER_API_KEY}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    model: "anthropic/claude-3-haiku",
+                    messages: [{ role: "user", content: prompt }],
+                    max_tokens: 500,
+                }),
+            }
+        );
+
+        const aiData = await aiResponse.json();
+        const aiContent = aiData.choices?.[0]?.message?.content || "{}";
+
+        // Parse AI response
+        let classification = "NEEDS_INFO";
+        let sentiment = "NEUTRAL";
+        let summary = issue.title;
+        let suggestedLabel = "needs-triage";
+
+        try {
+            const parsed = JSON.parse(aiContent);
+            classification = CLASSIFICATIONS.includes(parsed.classification)
+                ? parsed.classification
+                : "NEEDS_INFO";
+            sentiment = SENTIMENTS.includes(parsed.sentiment)
+                ? parsed.sentiment
+                : "NEUTRAL";
+            summary = parsed.summary || issue.title;
+            suggestedLabel = parsed.suggestedLabel || "needs-triage";
+        } catch {
+            console.error("Failed to parse AI response:", aiContent);
+        }
+
+        // Save triage data
+        const triage = {
+            id: generateId(),
+            issueId,
+            classification,
+            summary,
+            suggestedLabel,
+            sentiment,
+            analyzedAt: now(),
+        };
+
+        await db.insert(triageData).values(triage);
+
+        return NextResponse.json({
+            message: "Issue triaged successfully",
+            triage,
+        });
+    } catch (error) {
+        console.error("POST /api/triage error:", error);
+        return NextResponse.json(
+            { error: "Failed to triage issue" },
+            { status: 500 }
+        );
+    }
+}
+
+/**
+ * GET /api/triage?issueId=xxx
+ * Get triage data for an issue.
+ */
+export async function GET(request: NextRequest) {
+    const { searchParams } = new URL(request.url);
+    const issueId = searchParams.get("issueId");
+
+    if (!issueId) {
+        return NextResponse.json(
+            { error: "issueId is required" },
+            { status: 400 }
+        );
+    }
+
+    const triageRecords = await db
+        .select()
+        .from(triageData)
+        .where(eq(triageData.issueId, issueId))
+        .limit(1);
+
+    if (triageRecords.length === 0) {
+        return NextResponse.json(
+            { error: "Triage data not found" },
+            { status: 404 }
+        );
+    }
+
+    return NextResponse.json(triageRecords[0]);
+}

src/app/globals.css

@@ -0,0 +1,26 @@
+@import "tailwindcss";
+
+:root {
+  --background: #ffffff;
+  --foreground: #171717;
+}
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --font-sans: var(--font-geist-sans);
+  --font-mono: var(--font-geist-mono);
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --background: #0a0a0a;
+    --foreground: #ededed;
+  }
+}
+
+body {
+  background: var(--background);
+  color: var(--foreground);
+  font-family: Arial, Helvetica, sans-serif;
+}

src/app/layout.tsx

@@ -0,0 +1,34 @@
+import type { Metadata } from "next";
+import { Geist, Geist_Mono } from "next/font/google";
+import "./globals.css";
+
+const geistSans = Geist({
+  variable: "--font-geist-sans",
+  subsets: ["latin"],
+});
+
+const geistMono = Geist_Mono({
+  variable: "--font-geist-mono",
+  subsets: ["latin"],
+});
+
+export const metadata: Metadata = {
+  title: "Create Next App",
+  description: "Generated by create next app",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en">
+      <body
+        className={`${geistSans.variable} ${geistMono.variable} antialiased`}
+      >
+        {children}
+      </body>
+    </html>
+  );
+}

src/app/page.tsx

@@ -0,0 +1,65 @@
+import Image from "next/image";
+
+export default function Home() {
+  return (
+    <div className="flex min-h-screen items-center justify-center bg-zinc-50 font-sans dark:bg-black">
+      <main className="flex min-h-screen w-full max-w-3xl flex-col items-center justify-between py-32 px-16 bg-white dark:bg-black sm:items-start">
+        <Image
+          className="dark:invert"
+          src="/next.svg"
+          alt="Next.js logo"
+          width={100}
+          height={20}
+          priority
+        />
+        <div className="flex flex-col items-center gap-6 text-center sm:items-start sm:text-left">
+          <h1 className="max-w-xs text-3xl font-semibold leading-10 tracking-tight text-black dark:text-zinc-50">
+            To get started, edit the page.tsx file.
+          </h1>
+          <p className="max-w-md text-lg leading-8 text-zinc-600 dark:text-zinc-400">
+            Looking for a starting point or more instructions? Head over to{" "}
+            <a
+              href="https://vercel.com/templates?framework=next.js&utm_source=create-next-app&utm_medium=appdir-template-tw&utm_campaign=create-next-app"
+              className="font-medium text-zinc-950 dark:text-zinc-50"
+            >
+              Templates
+            </a>{" "}
+            or the{" "}
+            <a
+              href="https://nextjs.org/learn?utm_source=create-next-app&utm_medium=appdir-template-tw&utm_campaign=create-next-app"
+              className="font-medium text-zinc-950 dark:text-zinc-50"
+            >
+              Learning
+            </a>{" "}
+            center.
+          </p>
+        </div>
+        <div className="flex flex-col gap-4 text-base font-medium sm:flex-row">
+          <a
+            className="flex h-12 w-full items-center justify-center gap-2 rounded-full bg-foreground px-5 text-background transition-colors hover:bg-[#383838] dark:hover:bg-[#ccc] md:w-[158px]"
+            href="https://vercel.com/new?utm_source=create-next-app&utm_medium=appdir-template-tw&utm_campaign=create-next-app"
+            target="_blank"
+            rel="noopener noreferrer"
+          >
+            <Image
+              className="dark:invert"
+              src="/vercel.svg"
+              alt="Vercel logomark"
+              width={16}
+              height={16}
+            />
+            Deploy Now
+          </a>
+          <a
+            className="flex h-12 w-full items-center justify-center rounded-full border border-solid border-black/[.08] px-5 transition-colors hover:border-transparent hover:bg-black/[.04] dark:border-white/[.145] dark:hover:bg-[#1a1a1a] md:w-[158px]"
+            href="https://nextjs.org/docs?utm_source=create-next-app&utm_medium=appdir-template-tw&utm_campaign=create-next-app"
+            target="_blank"
+            rel="noopener noreferrer"
+          >
+            Documentation
+          </a>
+        </div>
+      </main>
+    </div>
+  );
+}