Add missing API endpoints for contributor, messaging, and RAG

scripts/migrate-data.ts

@@ -1,949 +0,0 @@
-/**
- * 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

@@ -1,41 +0,0 @@
-/**
- * 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

@@ -1,32 +0,0 @@
-/**
- * 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

@@ -1,36 +0,0 @@
-/**
- * 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

@@ -1,41 +0,0 @@
-/**
- * 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

@@ -1,101 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,51 +0,0 @@
-/**
- * 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

@@ -1,43 +0,0 @@
-/**
- * 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

@@ -1,32 +0,0 @@
-/**
- * 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

@@ -1,32 +0,0 @@
-/**
- * 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

@@ -1,38 +0,0 @@
-/**
- * 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

@@ -1,44 +0,0 @@
-/**
- * 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

@@ -1,27 +0,0 @@
-/**
- * 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

@@ -1,36 +0,0 @@
-/**
- * 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

@@ -1,54 +0,0 @@
-/**
- * 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

@@ -1,139 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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

@@ -1,39 +0,0 @@
-/**
- * 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

@@ -1,44 +0,0 @@
-/**
- * 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

@@ -1,49 +0,0 @@
-/**
- * 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

@@ -1,25 +0,0 @@
-/**
- * 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

@@ -1,63 +0,0 @@
-/**
- * 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

@@ -1,36 +0,0 @@
-/**
- * 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

@@ -1,35 +0,0 @@
-/**
- * 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

@@ -1,31 +0,0 @@
-/**
- * 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

@@ -1,33 +0,0 @@
-/**
- * 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

@@ -1,34 +0,0 @@
-/**
- * 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

@@ -1,40 +0,0 @@
-/**
- * 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

@@ -1,26 +0,0 @@
-/**
- * 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

@@ -1,23 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,59 +0,0 @@
-/**
- * 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

@@ -1,37 +0,0 @@
-/**
- * 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

@@ -1,37 +0,0 @@
-/**
- * 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

@@ -1,37 +0,0 @@
-/**
- * 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

@@ -1,40 +0,0 @@
-/**
- * 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

@@ -1,98 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,181 +0,0 @@
-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

@@ -1,26 +0,0 @@
-@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

@@ -1,34 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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>
-  );
-}