bug fix 15

src/app/api/sync/reconcile/route.ts

@@ -0,0 +1,86 @@
+/**
+ * Issue Reconciliation API Route
+ * 
+ * POST /api/sync/reconcile - Reconcile a specific issue's state
+ * 
+ * Checks the issue state on GitHub and updates the database accordingly.
+ * Use this to immediately sync a specific issue without running full sync.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { reconcileSingleIssue, reconcileOpenTriageIssue1 } from "@/lib/sync/github-sync";
+
+export async function POST(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        if (!user.githubAccessToken) {
+            return NextResponse.json({ error: "GitHub access token not found" }, { status: 400 });
+        }
+
+        // Parse request body
+        const body = await request.json().catch(() => ({}));
+        const { owner, repo, issueNumber, reconcileOpenTriage } = body;
+
+        // Option 1: Reconcile the specific openTriage#1 issue
+        if (reconcileOpenTriage) {
+            const result = await reconcileOpenTriageIssue1(user.githubAccessToken);
+            return NextResponse.json({
+                success: result.success,
+                message: result.message,
+                result,
+            });
+        }
+
+        // Option 2: Reconcile a specific issue by owner/repo/number
+        if (owner && repo && issueNumber) {
+            const result = await reconcileSingleIssue(
+                user.githubAccessToken,
+                owner,
+                repo,
+                Number(issueNumber)
+            );
+            return NextResponse.json({
+                success: result.success,
+                message: result.message,
+                result,
+            });
+        }
+
+        return NextResponse.json({
+            error: "Missing required parameters. Provide either { reconcileOpenTriage: true } or { owner, repo, issueNumber }",
+        }, { status: 400 });
+
+    } catch (error) {
+        console.error("POST /api/sync/reconcile error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}
+
+export async function GET() {
+    return NextResponse.json({
+        description: "Issue Reconciliation API",
+        usage: {
+            reconcileOpenTriage: {
+                method: "POST",
+                body: { reconcileOpenTriage: true },
+                description: "Reconcile cosmicMagnetar/openTriage#1 specifically",
+            },
+            reconcileSpecific: {
+                method: "POST",
+                body: { owner: "string", repo: "string", issueNumber: "number" },
+                description: "Reconcile any specific issue by owner/repo/number",
+            },
+        },
+        behavior: [
+            "Fetches the issue state directly from GitHub API",
+            "If issue is closed/not found on GitHub, removes it from database",
+            "If issue is open, updates database to match GitHub state",
+            "Publishes real-time events via Ably if configured",
+        ],
+    });
+}

src/app/api/sync/run/route.ts

@@ -7,7 +7,7 @@
 
 import { NextRequest, NextResponse } from "next/server";
 import { getCurrentUser } from "@/lib/auth";
-import { runFullSync, runMaintainerSync, runContributorSync, SYNC_INTERVAL_MS } from "@/lib/sync/github-sync";
+import { runFullSync, runMaintainerSync, runContributorSync, reconcileOpenTriageIssue1, SYNC_INTERVAL_MS } from "@/lib/sync/github-sync";
 
 export async function POST(request: NextRequest) {
     try {
@@ -32,11 +32,17 @@ export async function POST(request: NextRequest) {
             stats = await runContributorSync(user.id, user.username, user.githubAccessToken);
         }
 
+        // Always reconcile the critical openTriage#1 issue to ensure immediate state sync
+        const reconcileResult = await reconcileOpenTriageIssue1(user.githubAccessToken);
+
         return NextResponse.json({
             success: true,
             message: "Sync completed",
             role: userRole,
             stats,
+            reconcile: {
+                openTriageIssue1: reconcileResult,
+            },
             nextSyncIntervalMs: SYNC_INTERVAL_MS,
         });
     } catch (error) {

src/lib/sync/github-sync.ts

@@ -588,3 +588,160 @@ export async function runMaintainerSync(
         role: 'MAINTAINER',
     });
 }
+
+// =============================================================================
+// Reconcile Single Issue - Check specific issue state on GitHub
+// =============================================================================
+
+interface IssueReconcileResult {
+    success: boolean;
+    owner: string;
+    repo: string;
+    issueNumber: number;
+    githubState: 'open' | 'closed' | 'not_found';
+    dbState: 'open' | 'closed' | 'not_found';
+    action: 'none' | 'deleted' | 'updated' | 'created';
+    message: string;
+}
+
+/**
+ * Reconcile a specific issue by checking its state on GitHub
+ * and updating the database accordingly.
+ * 
+ * This is useful for immediately syncing a specific issue
+ * (e.g., cosmicMagnetar/openTriage#1) without waiting for full sync.
+ */
+export async function reconcileSingleIssue(
+    accessToken: string,
+    owner: string,
+    repo: string,
+    issueNumber: number
+): Promise<IssueReconcileResult> {
+    const octokit = new Octokit({ auth: accessToken });
+    const repoName = `${owner}/${repo}`;
+    
+    try {
+        // 1. Check issue state on GitHub
+        let githubIssue: GitHubIssue | null = null;
+        let githubState: 'open' | 'closed' | 'not_found' = 'not_found';
+        
+        try {
+            const response = await octokit.issues.get({
+                owner,
+                repo,
+                issue_number: issueNumber,
+            });
+            githubIssue = response.data as GitHubIssue;
+            githubState = githubIssue.state as 'open' | 'closed';
+        } catch (error: any) {
+            if (error.status === 404) {
+                githubState = 'not_found';
+            } else {
+                throw error;
+            }
+        }
+
+        // 2. Check current state in database
+        const dbIssue = await db.select()
+            .from(issues)
+            .where(
+                and(
+                    eq(issues.owner, owner),
+                    eq(issues.repo, repo),
+                    eq(issues.number, issueNumber)
+                )
+            )
+            .limit(1);
+
+        const existingIssue = dbIssue[0];
+        const dbState: 'open' | 'closed' | 'not_found' = existingIssue 
+            ? (existingIssue.state as 'open' | 'closed') 
+            : 'not_found';
+
+        // 3. Reconcile based on states
+        let action: 'none' | 'deleted' | 'updated' | 'created' = 'none';
+        let message = '';
+
+        if (githubState === 'closed' || githubState === 'not_found') {
+            // Issue is closed or doesn't exist on GitHub - delete from DB
+            if (existingIssue) {
+                await db.delete(issues).where(eq(issues.id, existingIssue.id));
+                action = 'deleted';
+                message = `Issue #${issueNumber} is ${githubState} on GitHub - removed from database`;
+                
+                // Publish deletion event
+                if (isAblyConfigured()) {
+                    await publishIssueDeleted({
+                        id: existingIssue.id,
+                        githubIssueId: existingIssue.githubIssueId,
+                        number: issueNumber,
+                        title: existingIssue.title,
+                        repoName,
+                        owner,
+                        repo,
+                        isPR: existingIssue.isPR,
+                        state: 'closed',
+                    });
+                }
+                
+                console.log(`[Reconcile] ${repoName}#${issueNumber}: Deleted (${githubState} on GitHub)`);
+            } else {
+                message = `Issue #${issueNumber} is ${githubState} on GitHub and not in database - no action needed`;
+            }
+        } else if (githubState === 'open' && githubIssue) {
+            // Issue is open on GitHub
+            if (existingIssue) {
+                // Update existing issue
+                if (existingIssue.state !== 'open' || existingIssue.title !== githubIssue.title) {
+                    await db.update(issues)
+                        .set({
+                            state: 'open',
+                            title: githubIssue.title,
+                            body: githubIssue.body || null,
+                        })
+                        .where(eq(issues.id, existingIssue.id));
+                    action = 'updated';
+                    message = `Issue #${issueNumber} updated to match GitHub state`;
+                } else {
+                    message = `Issue #${issueNumber} is already in sync`;
+                }
+            } else {
+                // Issue is open on GitHub but not in DB - would need repo context to create
+                message = `Issue #${issueNumber} is open on GitHub but not tracked. Run full sync to add it.`;
+            }
+        }
+
+        return {
+            success: true,
+            owner,
+            repo,
+            issueNumber,
+            githubState,
+            dbState,
+            action,
+            message,
+        };
+
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`[Reconcile] Error for ${repoName}#${issueNumber}:`, errorMessage);
+        return {
+            success: false,
+            owner,
+            repo,
+            issueNumber,
+            githubState: 'not_found',
+            dbState: 'not_found',
+            action: 'none',
+            message: `Error reconciling issue: ${errorMessage}`,
+        };
+    }
+}
+
+/**
+ * Reconcile the critical tracked issue: cosmicMagnetar/openTriage#1
+ * This ensures the issue state is immediately synced from GitHub.
+ */
+export async function reconcileOpenTriageIssue1(accessToken: string): Promise<IssueReconcileResult> {
+    return reconcileSingleIssue(accessToken, 'cosmicMagnetar', 'openTriage', 1);
+}