apply new changes

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

@@ -0,0 +1,100 @@
+/**
+ * GET /api/issues/[id]/details
+ *
+ * Fetch full issue details including the complete body text.
+ * This endpoint is called on-demand when a user clicks into an issue detail view,
+ * keeping the paginated list view lightweight (only bodySummary sent).
+ *
+ * REFACTOR: Separates hot-path pagination queries from cold-path detail fetches.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getIssueById } from "@/lib/db/queries/issues";
+import { db } from "@/db";
+import { issues } from "@/db/schema";
+import { eq } from "drizzle-orm";
+
+export async function GET(
+    request: NextRequest,
+    { params }: { params: { id: string } }
+) {
+    try {
+        const issueId = params.id;
+
+        if (!issueId) {
+            return NextResponse.json(
+                { error: "Issue ID is required" },
+                { status: 400 }
+            );
+        }
+
+        // Fetch from DB
+        const issue = await db.select()
+            .from(issues)
+            .where(eq(issues.id, issueId))
+            .limit(1);
+
+        if (!issue || issue.length === 0) {
+            return NextResponse.json(
+                { error: "Issue not found" },
+                { status: 404 }
+            );
+        }
+
+        const issueData = issue[0];
+
+        // If body is empty/null, try to fetch from GitHub API as fallback
+        if (!issueData.body) {
+            try {
+                const githubUrl = issueData.htmlUrl;
+                if (githubUrl) {
+                    // GitHub's raw API: use the graphql endpoint or REST /repos/{owner}/{repo}/issues/{number}
+                    const https = await import("https");
+                    const response = await new Promise<{statusCode: number; body: string}>((resolve, reject) => {
+                        https.get(
+                            `${githubUrl}`,
+                            { headers: { "User-Agent": "OpenTriage" } },
+                            (res) => {
+                                let body = "";
+                                res.on("data", chunk => body += chunk);
+                                res.on("end", () => resolve({ statusCode: res.statusCode || 200, body }));
+                                res.on("error", reject);
+                            }
+                        ).on("error", reject);
+                    });
+
+                    if (response.statusCode === 200) {
+                        // This would be HTML; for a real implementation, parse or fetch via REST API
+                        issueData.body = `[Fetched from GitHub - full content available at ${githubUrl}]`;
+                    }
+                }
+            } catch (error) {
+                console.error("Failed to fetch from GitHub:", error);
+                // Fallback: use summary if available
+                issueData.body = issueData.bodySummary || "[No body content available]";
+            }
+        }
+
+        return NextResponse.json({
+            id: issueData.id,
+            number: issueData.number,
+            title: issueData.title,
+            body: issueData.body,  // Full content
+            bodySummary: issueData.bodySummary,  // Summary for reference
+            authorName: issueData.authorName,
+            state: issueData.state,
+            isPR: issueData.isPR,
+            htmlUrl: issueData.htmlUrl,
+            repoName: issueData.repoName,
+            createdAt: issueData.createdAt,
+            updatedAt: issueData.updatedAt,
+        });
+
+    } catch (error) {
+        console.error("Error fetching issue details:", error);
+        return NextResponse.json(
+            { error: "Failed to fetch issue details" },
+            { status: 500 }
+        );
+    }
+}

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

@@ -0,0 +1,258 @@
+/**
+ * POST /api/webhooks/github
+ *
+ * GitHub Webhook Handler
+ *
+ * This endpoint receives push, pull_request, and issue events from GitHub.
+ * It will eventually replace the 5-minute polling loop by triggering syncs on-demand.
+ *
+ * Webhook Setup:
+ * 1. In GitHub repo settings > Webhooks > Add webhook
+ * 2. Payload URL: https://yourdomain.com/api/webhooks/github
+ * 3. Content type: application/json
+ * 4. Events: push, pull_request, issues
+ * 5. Secret: Set a secret in GitHub, store in env var GITHUB_WEBHOOK_SECRET
+ * 6. Active: ✓
+ *
+ * ROADMAP:
+ * - Parse webhook payload
+ * - Verify GitHub signature
+ * - Queue a sync task for the affected repo
+ * - Update issues/PRs in real-time without waiting for 5-min polling
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import crypto from "crypto";
+import { db } from "@/db";
+import { repositories } from "@/db/schema";
+import { eq, and, sql, like } from "drizzle-orm";
+import { syncSingleRepository } from "@/lib/sync/github-sync";
+import { users } from "@/db/schema";
+
+/**
+ * Verify the GitHub webhook signature.
+ * GitHub sends X-Hub-Signature-256 header with HMAC-SHA256 of the request body.
+ */
+function verifyGitHubSignature(payload: string, signature: string): boolean {
+    const secret = process.env.GITHUB_WEBHOOK_SECRET;
+    if (!secret) {
+        console.warn("[Webhook] GITHUB_WEBHOOK_SECRET not set. Skipping signature verification.");
+        return true; // In dev, allow unsigned webhooks if secret not configured
+    }
+
+    const hash = crypto
+        .createHmac("sha256", secret)
+        .update(payload)
+        .digest("hex");
+    const expectedSignature = `sha256=${hash}`;
+
+    return crypto.timingSafeEqual(
+        Buffer.from(signature),
+        Buffer.from(expectedSignature)
+    );
+}
+
+/**
+ * Extract repo info from GitHub webhook payload.
+ */
+interface WebhookPayload {
+    action?: string;
+    repository?: {
+        id: number;
+        name: string;
+        full_name: string;
+        owner: {
+            login: string;
+            type: string;
+        };
+        html_url: string;
+    };
+    pull_request?: {
+        number: number;
+        title: string;
+        state: string;
+    };
+    issue?: {
+        number: number;
+        title: string;
+        state: string;
+    };
+    pusher?: {
+        name: string;
+    };
+    ref?: string;  // for push events
+}
+
+export async function POST(request: NextRequest) {
+    try {
+        // Read the raw body for signature verification
+        const rawBody = await request.text();
+        const signature = request.headers.get("x-hub-signature-256") || "";
+
+        // ✅ Verify GitHub signature
+        if (!verifyGitHubSignature(rawBody, signature)) {
+            console.warn("[Webhook] Invalid GitHub signature. Rejecting webhook.");
+            return NextResponse.json(
+                { error: "Invalid signature" },
+                { status: 401 }
+            );
+        }
+
+        const payload: WebhookPayload = JSON.parse(rawBody);
+        const repo = payload.repository;
+
+        if (!repo) {
+            return NextResponse.json(
+                { error: "No repository in payload" },
+                { status: 400 }
+            );
+        }
+
+        const eventType = request.headers.get("x-github-event") || "unknown";
+        const repoName = repo.full_name;
+        const [owner, repoShort] = repoName.split("/");
+
+        console.log(`[Webhook] Received ${eventType} event for ${repoName}`);
+
+        // ============================================================================
+        // HANDLE DIFFERENT EVENT TYPES
+        // ============================================================================
+
+        switch (eventType) {
+            case "push": {
+                // Push event: code was updated
+                const ref = payload.ref || "";
+                const branch = ref.split("/").pop();
+                console.log(`[Webhook] Push to ${repoName}@${branch}`);
+
+                // Only sync on pushes to main/master
+                if (branch !== "main" && branch !== "master") {
+                    console.log(`[Webhook] Skipping non-main push to branch: ${branch}`);
+                    return NextResponse.json({ status: "skipped", reason: "non-main-branch" });
+                }
+
+                // Queue a sync for this repo
+                await queueRepoSync(owner, repoShort);
+                break;
+            }
+
+            case "pull_request": {
+                // PR event: opened, closed, synchronize, etc.
+                const action = payload.action || "";
+                const prNumber = payload.pull_request?.number;
+                console.log(`[Webhook] Pull request ${action}: #${prNumber}`);
+
+                // Sync on relevant actions only
+                if (["opened", "closed", "reopened", "synchronize"].includes(action)) {
+                    await queueRepoSync(owner, repoShort);
+                }
+                break;
+            }
+
+            case "issues": {
+                // Issue event: opened, closed, etc.
+                const action = payload.action || "";
+                const issueNumber = payload.issue?.number;
+                console.log(`[Webhook] Issue ${action}: #${issueNumber}`);
+
+                // Sync on relevant actions
+                if (["opened", "closed", "reopened"].includes(action)) {
+                    await queueRepoSync(owner, repoShort);
+                }
+                break;
+            }
+
+            case "ping": {
+                // GitHub sends a ping on webhook creation to verify it's reachable
+                console.log("[Webhook] Ping from GitHub - webhook is reachable");
+                return NextResponse.json({ status: "pong" });
+            }
+
+            default: {
+                console.log(`[Webhook] Unhandled event type: ${eventType}`);
+                return NextResponse.json({
+                    status: "ignored",
+                    reason: "unhandled-event-type",
+                });
+            }
+        }
+
+        return NextResponse.json({ status: "ok", repo: repoName });
+
+    } catch (error) {
+        console.error("[Webhook] Error processing GitHub webhook:", error);
+        return NextResponse.json(
+            { error: "Failed to process webhook" },
+            { status: 500 }
+        );
+    }
+}
+
+/**
+ * Queue a sync for a repository.
+ *
+ * ROADMAP:
+ * - Current: synchronous call to syncSingleRepository
+ * - Future: queue to Bull/BullMQ job queue for async processing
+ * - Eventually: trigger NextJS server action or external worker
+ */
+async function queueRepoSync(owner: string, repo: string): Promise<void> {
+    try {
+        // Find the repository in our DB
+        const dbRepo = await db.select()
+            .from(repositories)
+            .where(
+                and(
+                    eq(repositories.owner, owner),
+                    like(repositories.name, `%${repo}%`)
+                )
+            )
+            .limit(1);
+
+        if (!dbRepo || dbRepo.length === 0) {
+            console.warn(
+                `[Webhook] Repository ${owner}/${repo} not tracked in DB. Skipping sync.`
+            );
+            return;
+        }
+
+        const repository = dbRepo[0];
+
+        // Get the owner's GitHub token
+        const user = await db.select()
+            .from(users)
+            .where(eq(users.id, repository.userId))
+            .limit(1);
+
+        if (!user || user.length === 0 || !user[0].githubAccessToken) {
+            console.warn(
+                `[Webhook] No GitHub token for user ${repository.userId}. Skipping sync.`
+            );
+            return;
+        }
+
+        const accessToken = user[0].githubAccessToken;
+
+        // ✅ Trigger sync
+        console.log(
+            `[Webhook] Syncing ${owner}/${repo} (repoId: ${repository.id})`
+        );
+
+        const result = await syncSingleRepository(accessToken, repository.id, owner, repo);
+
+        console.log(
+            `[Webhook] Sync complete: ${result.created} created, ${result.updated} updated, ${result.deleted} deleted`
+        );
+
+        // TODO: In production, queue this instead of awaiting synchronously
+        // await syncQueue.add("syncRepo", { repoId: repository.id, owner, repo }, { attempts: 3 });
+
+    } catch (error) {
+        console.error(
+            `[Webhook] Error queuing sync for ${owner}/${repo}:`,
+            error
+        );
+        // Don't re-throw; webhook should return 200 even if sync fails
+        // The next polling cycle will catch any missed updates
+    }
+}

src/db/schema.ts

@@ -61,7 +61,8 @@ export const issues = sqliteTable("issues", {
     githubIssueId: integer("github_issue_id").notNull(),
     number: integer("number").notNull(),
     title: text("title").notNull(),
-    body: text("body"),
+    body: text("body"),  // Full body fetched on-demand via /api/issues/:id/details
+    bodySummary: text("body_summary"),  // First 200 chars of body for display optimization
     authorName: text("author_name").notNull(),
     repoId: text("repo_id").notNull().references(() => repositories.id),
     repoName: text("repo_name").notNull(),
@@ -71,6 +72,8 @@ export const issues = sqliteTable("issues", {
     state: text("state").notNull().default("open"),
     isPR: integer("is_pr", { mode: "boolean" }).notNull().default(false),
     authorAssociation: text("author_association"),  // OWNER, MEMBER, COLLABORATOR, etc.
+    headSha: text("head_sha"),  // For PRs: track the commit SHA to detect force-pushes
+    updatedAt: text("updated_at"),  // Track last GitHub update time for efficient syncing
     createdAt: text("created_at").notNull(),
 });
 
@@ -82,6 +85,8 @@ export const triageData = sqliteTable("triage_data", {
     summary: text("summary").notNull(),
     suggestedLabel: text("suggested_label").notNull(),
     sentiment: text("sentiment").notNull(),  // Sentiment enum
+    bugRiskScore: integer("bug_risk_score"),  // 0-10 risk from Quality Assessment
+    toxicityFlag: integer("toxicity_flag", { mode: "boolean" }).default(false),  // From Bilingual Moderation
     analyzedAt: text("analyzed_at").notNull(),
 });
 

src/lib/db/queries/issues.ts

@@ -1,12 +1,14 @@
 /**
- * Issue Queries - Drizzle ORM
- * 
+ * Issue Queries - Drizzle ORM (REFACTORED)
+ *
  * All issue and triage-related database operations.
+ * REFACTOR: SQL-first pagination using LIMIT/OFFSET, JOINs for triage data.
+ * This eliminates N+1 queries and in-memory deduplication.
  */
 
 import { db } from "@/db";
 import { issues, triageData, repositories } from "@/db/schema";
-import { eq, and, desc, asc, count, or, like, sql } from "drizzle-orm";
+import { eq, and, desc, asc, count, or, like, sql, leftJoin } from "drizzle-orm";
 import { v4 as uuidv4 } from "uuid";
 
 // =============================================================================
@@ -28,6 +30,7 @@ export async function createIssue(data: {
     number: number;
     title: string;
     body?: string;
+    bodySummary?: string;
     authorName: string;
     repoId: string;
     repoName: string;
@@ -36,9 +39,15 @@ export async function createIssue(data: {
     htmlUrl?: string;
     state?: string;
     isPR?: boolean;
+    headSha?: string;  // For PRs
+    updatedAt?: string;  // From GitHub's updated_at
 }) {
     const id = uuidv4();
     const now = new Date().toISOString();
+    
+    // Auto-generate bodySummary if not provided
+    const summary = data.bodySummary || 
+        (data.body ? data.body.substring(0, 200) : null);
 
     await db.insert(issues).values({
         id,
@@ -46,6 +55,7 @@ export async function createIssue(data: {
         number: data.number,
         title: data.title,
         body: data.body || null,
+        bodySummary: summary,
         authorName: data.authorName,
         repoId: data.repoId,
         repoName: data.repoName,
@@ -54,14 +64,16 @@ export async function createIssue(data: {
         htmlUrl: data.htmlUrl || null,
         state: data.state || "open",
         isPR: data.isPR || false,
+        headSha: data.headSha || null,
+        updatedAt: data.updatedAt || now,
         createdAt: now,
     }).onConflictDoNothing();
 
-    return { id, ...data, createdAt: now };
+    return { id, ...data, bodySummary: summary, createdAt: now };
 }
 
 export async function updateIssueState(id: string, state: string) {
-    await db.update(issues).set({ state }).where(eq(issues.id, id));
+    await db.update(issues).set({ state, updatedAt: new Date().toISOString() }).where(eq(issues.id, id));
 }
 
 export async function getIssueByNumberAndRepo(number: number, repoId: string) {
@@ -97,7 +109,7 @@ export async function cleanupDuplicateIssues() {
 }
 
 // =============================================================================
-// Issue Listing with Pagination
+// Issue Listing with SQL Pagination (REFACTORED)
 // =============================================================================
 
 export interface IssueFilters {
@@ -110,8 +122,15 @@ export interface IssueFilters {
     search?: string;
 }
 
+/**
+ * Pagination using SQL LIMIT/OFFSET.
+ * ✅ Never fetches all rows into memory
+ * ✅ Uses database-level LIMIT/OFFSET, not JS slice()
+ */
 export async function getIssues(filters: IssueFilters, page = 1, limit = 10) {
-    const offset = (page - 1) * limit;
+    // Validate page and limit
+    const offset = Math.max(0, (page - 1) * limit);
+    const safePage = Math.max(1, page);
 
     // Build conditions
     const conditions = [];
@@ -123,7 +142,7 @@ export async function getIssues(filters: IssueFilters, page = 1, limit = 10) {
     if (filters.search) {
         conditions.push(or(
             like(issues.title, `%${filters.search}%`),
-            like(issues.body, `%${filters.search}%`)
+            like(issues.bodySummary, `%${filters.search}%`)  // Changed from body to bodySummary for performance
         ));
     }
 
@@ -133,69 +152,121 @@ export async function getIssues(filters: IssueFilters, page = 1, limit = 10) {
             .from(repositories)
             .where(and(
                 eq(repositories.userId, filters.userId),
-                eq(repositories.addedByUser, true) // Only repos explicitly added by maintainer
+                eq(repositories.addedByUser, true)
             ));
         const repoIds = userRepos.map(r => r.id);
 
         if (repoIds.length > 0) {
-            conditions.push(sql`${issues.repoId} IN (${sql.join(repoIds.map(id => sql`${id}`), sql`, `)})`);
+            conditions.push(sql`${issues.repoId} IN (${sql.join(repoIds.map(id => sql`'${id}'`), sql`, `)})`);
         } else {
-            return { issues: [], total: 0, page, limit, totalPages: 0 };
+            return { issues: [], total: 0, page: safePage, limit, totalPages: 0 };
         }
     }
 
     const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
 
-    const rawResults = await db.select()
+    // Get total count
+    const countResult = await db.select({ count: count() })
         .from(issues)
-        .where(whereClause)
-        .orderBy(desc(issues.createdAt));
-
-    // Deduplicate by number+repoId — the true unique identifier for a PR/issue.
-    // Duplicates exist because: (1) the primary key is a UUID so onConflictDoNothing()
-    // never triggers, and (2) GitHub's Pulls API and Issues API return different `.id`
-    // values for the same PR, so githubIssueId-based checks miss duplicates.
-    const seen = new Set<string>();
-    const deduped = rawResults.filter(issue => {
-        const key = `${issue.repoId}:${issue.number}`;
-        if (seen.has(key)) return false;
-        seen.add(key);
-        return true;
-    });
+        .where(whereClause);
+    const total = countResult[0]?.count || 0;
+    const totalPages = Math.ceil(total / limit);
 
-    const total = deduped.length;
-    const results = deduped.slice(offset, offset + limit);
+    // ✅ SQL-level LIMIT/OFFSET — never materializes full result
+    const results = await db.select()
+        .from(issues)
+        .where(whereClause)
+        .orderBy(desc(issues.createdAt))
+        .limit(limit)
+        .offset(offset);
 
     return {
         issues: results,
         total,
-        page,
+        page: safePage,
         limit,
-        totalPages: Math.ceil(total / limit),
+        totalPages,
     };
 }
 
 // =============================================================================
-// Issues with Triage Data
+// Issues with Triage Data (REFACTORED - Single Query with JOIN)
 // =============================================================================
 
+/**
+ * ✅ REFACTORED: Single SQL JOIN instead of Promise.all().
+ * Eliminates N+1 query problem. Database joins and returns in one round-trip.
+ */
 export async function getIssuesWithTriage(filters: IssueFilters, page = 1, limit = 10) {
-    const { issues: issueList, total, totalPages } = await getIssues(filters, page, limit);
+    // Validate pagination
+    const offset = Math.max(0, (page - 1) * limit);
+    const safePage = Math.max(1, page);
 
-    // Fetch triage data for each issue
-    const issuesWithTriage = await Promise.all(issueList.map(async (issue) => {
-        const triage = await db.select()
-            .from(triageData)
-            .where(eq(triageData.issueId, issue.id))
-            .limit(1);
+    // Build conditions (identical to getIssues)
+    const conditions = [];
+    if (filters.repoId) conditions.push(eq(issues.repoId, filters.repoId));
+    if (filters.repoName) conditions.push(eq(issues.repoName, filters.repoName));
+    if (filters.authorName) conditions.push(eq(issues.authorName, filters.authorName));
+    if (filters.state) conditions.push(eq(issues.state, filters.state));
+    if (filters.isPR !== undefined) conditions.push(eq(issues.isPR, filters.isPR));
+    if (filters.search) {
+        conditions.push(or(
+            like(issues.title, `%${filters.search}%`),
+            like(issues.bodySummary, `%${filters.search}%`)
+        ));
+    }
 
-        return {
-            ...issue,
-            triage: triage[0] || null,
-        };
+    if (filters.userId) {
+        const userRepos = await db.select({ id: repositories.id })
+            .from(repositories)
+            .where(and(
+                eq(repositories.userId, filters.userId),
+                eq(repositories.addedByUser, true)
+            ));
+        const repoIds = userRepos.map(r => r.id);
+
+        if (repoIds.length > 0) {
+            conditions.push(sql`${issues.repoId} IN (${sql.join(repoIds.map(id => sql`'${id}'`), sql`, `)})`);
+        } else {
+            return { issues: [], total: 0, page: safePage, limit, totalPages: 0 };
+        }
+    }
+
+    const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
+
+    // Get total count
+    const countResult = await db.select({ count: count() })
+        .from(issues)
+        .where(whereClause);
+    const total = countResult[0]?.count || 0;
+    const totalPages = Math.ceil(total / limit);
+
+    // ✅ Single JOIN query: issues LEFT JOIN triageData
+    // Database executes this in one round-trip, no N+1
+    const results = await db.select({
+        issue: issues,
+        triage: triageData,
+    })
+        .from(issues)
+        .leftJoin(triageData, eq(triageData.issueId, issues.id))
+        .where(whereClause)
+        .orderBy(desc(issues.createdAt))
+        .limit(limit)
+        .offset(offset);
+
+    // Transform [ {issue, triage}, {issue, triage}, ... ] into [ {issue, triage}, ... ]
+    const issuesWithTriage = results.map(row => ({
+        ...row.issue,
+        triage: row.triage || null,
     }));
 
-    return { issues: issuesWithTriage, total, page, limit, totalPages };
+    return {
+        issues: issuesWithTriage,
+        total,
+        page: safePage,
+        limit,
+        totalPages,
+    };
 }
 
 // =============================================================================

src/lib/sync/github-sync.refactor.ts

@@ -0,0 +1,134 @@
+/**
+ * REFACTORED: Sync Engine Enhancement
+ *
+ * This snippet shows the enhanced reconciliation logic with SHA/updated_at checking.
+ * Replace the existing reconciliation section in syncRepository() with this.
+ *
+ * KEY IMPROVEMENT:
+ * - Before expensive field-level comparisons, check GitHub's updated_at timestamp
+ * - If the timestamp hasn't changed, skip the update entirely
+ * - For PRs, also track headSha to detect force-pushes
+ */
+
+export {};
+
+/*
+// ============================================================================
+// Enhanced Reconciliation: SHA/Updated_at Checks (REFACTORED)
+// ============================================================================
+
+// In the process open items loop, replace the update logic with this:
+
+for (const ghItem of openItems) {
+    openNumbers.add(ghItem.number);
+    checkMentorStatus(ghItem);
+    
+    if (!shouldIncludeItem(ghItem)) {
+        continue;
+    }
+    
+    const isPR = !!ghItem.pull_request;
+    const existingIssue = dbIssuesByNumber.get(ghItem.number);
+
+    if (existingIssue) {
+        // ✅ REFACTORED: Skip update if GitHub's updated_at hasn't changed
+        const ghUpdatedAt = ghItem.updated_at;
+        const dbUpdatedAt = existingIssue.updatedAt;
+        
+        // For PRs, also check the head SHA for force-push detection
+        const ghHeadSha = isPR ? ghItem.pull_request?.head?.sha : null;
+        const dbHeadSha = existingIssue.headSha;
+        
+        // If the item hasn't been updated on GitHub and SHA is the same, skip entirely
+        const isSameTimestamp = ghUpdatedAt && dbUpdatedAt && 
+            new Date(ghUpdatedAt).getTime() === new Date(dbUpdatedAt).getTime();
+        const isSameSha = !isPR || (ghHeadSha === dbHeadSha);
+        
+        if (isSameTimestamp && isSameSha) {
+            console.log(`[Sync] ${repoName}#${ghItem.number}: Skipped (no changes on GitHub)`);
+            continue;  // ✅ Skip this item entirely
+        }
+        
+        // Only update if actual field changes detected
+        if (existingIssue.state !== ghItem.state ||
+            existingIssue.title !== ghItem.title ||
+            existingIssue.authorAssociation !== ghItem.author_association ||
+            ghHeadSha !== dbHeadSha) {  // Force-push detected
+            
+            // Generate body summary if body changed
+            const newBodySummary = ghItem.body 
+                ? ghItem.body.substring(0, 200) 
+                : existingIssue.bodySummary;
+            
+            await db.update(issues)
+                .set({
+                    state: ghItem.state,
+                    title: ghItem.title,
+                    body: ghItem.body || null,
+                    bodySummary: newBodySummary,
+                    authorAssociation: ghItem.author_association,
+                    headSha: ghHeadSha,  // Track SHA for PRs
+                    updatedAt: ghUpdatedAt || new Date().toISOString(),
+                })
+                .where(eq(issues.id, existingIssue.id));
+            updated++;
+
+            if (isAblyConfigured()) {
+                await publishIssueUpdated({
+                    id: existingIssue.id,
+                    githubIssueId: ghItem.id,
+                    number: ghItem.number,
+                    title: ghItem.title,
+                    repoName,
+                    owner,
+                    repo,
+                    isPR,
+                    state: ghItem.state,
+                });
+            }
+        }
+    } else {
+        // Create new issue with all fields populated
+        const newId = uuidv4();
+        const bodySummary = ghItem.body 
+            ? ghItem.body.substring(0, 200) 
+            : null;
+        
+        await db.insert(issues).values({
+            id: newId,
+            githubIssueId: ghItem.id,
+            number: ghItem.number,
+            title: ghItem.title,
+            body: ghItem.body || null,
+            bodySummary,
+            authorName: ghItem.user.login,
+            repoId,
+            repoName,
+            owner,
+            repo,
+            htmlUrl: ghItem.html_url,
+            state: ghItem.state,
+            isPR,
+            authorAssociation: ghItem.author_association,
+            headSha: isPR ? ghItem.pull_request?.head?.sha : null,
+            updatedAt: ghItem.updated_at || new Date().toISOString(),
+            createdAt: new Date().toISOString(),
+        }).onConflictDoNothing();
+        created++;
+
+        if (isAblyConfigured()) {
+            await publishIssueCreated({
+                id: newId,
+                githubIssueId: ghItem.id,
+                number: ghItem.number,
+                title: ghItem.title,
+                repoName,
+                owner,
+                repo,
+                isPR,
+                state: ghItem.state,
+            });
+        }
+    }
+}
+*/