apply changes

src/app/api/triage/route.ts

@@ -69,21 +69,64 @@ export async function POST(request: NextRequest) {
             });
         }
 
-        // Build AI prompt for classification
-        const prompt = `Analyze this GitHub issue and provide a classification.
+        // ===== NEW: Get RAG context from project history =====
+        let ragContext = "";
+        let ragSources: any[] = [];
 
+        if (issue.repoName) {
+            try {
+                const aiEngineUrl = process.env.AI_ENGINE_URL || "http://localhost:7860";
+                const ragResponse = await fetch(`${aiEngineUrl}/rag/chat`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "X-API-Key": process.env.API_KEY || "",
+                    },
+                    body: JSON.stringify({
+                        question: `What is the context for this ${issue.isPR ? "pull request" : "issue"}: "${issue.title}"? ${issue.body?.slice(0, 500) || ""}`,
+                        repo_name: issue.repoName,
+                        top_k: 5,
+                    }),
+                    signal: AbortSignal.timeout(10000), // 10s timeout
+                });
+
+                if (ragResponse.ok) {
+                    const ragData = await ragResponse.json();
+                    ragContext = ragData.answer || "";
+                    ragSources = ragData.sources || [];
+                    console.log(`[Triage] RAG provided ${ragSources.length} sources for context`);
+                } else {
+                    console.warn(`[Triage] RAG query failed with status ${ragResponse.status}`);
+                }
+            } catch (err) {
+                console.error("[Triage] RAG query error:", err);
+                // Continue without RAG context
+            }
+        }
+
+        // Build ENHANCED AI prompt with RAG context
+        const enhancedPrompt = `You are an expert GitHub ${issue.isPR ? "pull request" : "issue"} triaging assistant with access to project history and documentation.
+
+${ragContext ? `**Project Context from Documentation & Past Issues:**\n${ragContext}\n\n---\n\n` : ""}
+
+**Current ${issue.isPR ? "Pull Request" : "Issue"} to Classify:**
 Title: ${issue.title}
 Body: ${issue.body || "(empty)"}
+Author: ${issue.authorName || "unknown"}
+Type: ${issue.isPR ? "Pull Request" : "Issue"}
+
+Using the project context above (if available), provide a precise classification.
 
 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)"
+  "summary": "One-line summary explaining the classification",
+  "suggestedLabel": "Suggested GitHub label (lowercase, hyphenated)",
+  "confidence": 0.0-1.0
 }`;
 
-        // Call OpenRouter API
+        // Call OpenRouter API with upgraded model
         const aiResponse = await fetch(
             "https://openrouter.ai/api/v1/chat/completions",
             {
@@ -93,9 +136,10 @@ Respond with valid JSON only:
                     "Content-Type": "application/json",
                 },
                 body: JSON.stringify({
-                    model: "anthropic/claude-3-haiku",
-                    messages: [{ role: "user", content: prompt }],
+                    model: "meta-llama/llama-3.3-70b-instruct:free", // Upgraded from claude-haiku
+                    messages: [{ role: "user", content: enhancedPrompt }],
                     max_tokens: 500,
+                    temperature: 0.3, // Lower temp for more deterministic classification
                 }),
             }
         );
@@ -108,6 +152,7 @@ Respond with valid JSON only:
         let sentiment = "NEUTRAL";
         let summary = issue.title;
         let suggestedLabel = "needs-triage";
+        let confidence = 0.5;
 
         try {
             const parsed = JSON.parse(aiContent);
@@ -119,11 +164,31 @@ Respond with valid JSON only:
                 : "NEUTRAL";
             summary = parsed.summary || issue.title;
             suggestedLabel = parsed.suggestedLabel || "needs-triage";
+            confidence = parsed.confidence || 0.5;
         } catch {
             console.error("Failed to parse AI response:", aiContent);
         }
 
-        // Save triage data
+        // ===== NEW: Quality Assessment for PRs (estimate bug risk) =====
+        let bugRiskScore: number | null = null;
+
+        if (issue.isPR) {
+            // Estimate bug risk based on classification
+            // TODO: Ideally we'd use QualityAssessmentService with actual PR diff
+            // For now, use classification as a heuristic
+            if (classification === "CRITICAL_BUG") {
+                bugRiskScore = 9;
+            } else if (classification === "BUG") {
+                bugRiskScore = 6;
+            } else {
+                // Even non-bug PRs have some risk
+                bugRiskScore = Math.max(3, Math.floor((1 - confidence) * 5));
+            }
+
+            console.log(`[Triage] Assigned bug risk score: ${bugRiskScore} for PR #${issue.number}`);
+        }
+
+        // Save triage data with new fields
         const triage = {
             id: generateId(),
             issueId,
@@ -131,14 +196,50 @@ Respond with valid JSON only:
             summary,
             suggestedLabel,
             sentiment,
+            bugRiskScore, // NEW
             analyzedAt: now(),
         };
 
         await db.insert(triageData).values(triage);
 
+        // ===== NEW: Auto-dispatch Agent for CRITICAL_BUG =====
+        let agentDispatched = false;
+
+        if (classification === "CRITICAL_BUG" && user.githubAccessToken && issue.owner && issue.repo) {
+            console.log(`[Triage] CRITICAL_BUG detected, auto-dispatching Agent for ${issue.repoName}#${issue.number}`);
+
+            try {
+                // Fire-and-forget Agent analysis (don't await)
+                const baseUrl = process.env.NEXTAUTH_URL || "http://localhost:3001";
+                fetch(`${baseUrl}/api/agent/analyze`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: request.headers.get("Authorization") || "",
+                    },
+                    body: JSON.stringify({
+                        owner: issue.owner,
+                        repo: issue.repo,
+                        issueNumber: issue.isPR ? undefined : issue.number,
+                        prNumber: issue.isPR ? issue.number : undefined,
+                        goalType: issue.isPR ? "bug_hunt" : "issue_triage",
+                        sessionId: `auto-${issueId}-${Date.now()}`,
+                    }),
+                }).catch((err) => {
+                    console.error("[Triage] Agent auto-dispatch failed:", err.message);
+                });
+
+                agentDispatched = true;
+            } catch (err) {
+                console.error("[Triage] Agent dispatch setup failed:", err);
+            }
+        }
+
         return NextResponse.json({
             message: "Issue triaged successfully",
             triage,
+            ragSources, // NEW: return sources used for transparency
+            agentDispatched, // NEW: indicate if Agent was triggered
         });
     } catch (error) {
         console.error("POST /api/triage error:", error);

src/lib/sync/github-sync.ts

@@ -453,7 +453,57 @@ export async function syncSingleRepository(
     options: SyncOptions = {}
 ): Promise<SyncResult> {
     const octokit = new Octokit({ auth: accessToken });
-    return syncRepository(octokit, repoId, owner, repo, options);
+    const result = await syncRepository(octokit, repoId, owner, repo, options);
+    
+    // ===== Auto-trigger RAG indexing after successful sync =====
+    if (result.success && (result.created > 0 || result.updated > 0)) {
+        try {
+            const aiEngineUrl = process.env.AI_ENGINE_URL || "http://localhost:7860";
+            const repoName = `${owner}/${repo}`;
+            
+            // Check if we need to index (avoid redundant indexing)
+            const checkResponse = await fetch(
+                `${aiEngineUrl}/rag/check-index?repo_name=${encodeURIComponent(repoName)}`,
+                {
+                    headers: { 
+                        "X-API-Key": process.env.API_KEY || "",
+                        "Content-Type": "application/json"
+                    }
+                }
+            );
+            
+            if (checkResponse.ok) {
+                const checkData = await checkResponse.json();
+                const chunkCount = checkData.chunk_count || 0;
+                
+                if (chunkCount < 100) {
+                    console.log(`[Sync] Triggering RAG indexing for ${repoName} (current chunks: ${chunkCount})`);
+                    
+                    // Fire-and-forget indexing (don't await to avoid blocking sync)
+                    fetch(`${aiEngineUrl}/rag/index`, {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                            "X-API-Key": process.env.API_KEY || "",
+                        },
+                        body: JSON.stringify({
+                            repo_name: repoName,
+                            github_access_token: accessToken,
+                        }),
+                    }).catch((err) => {
+                        console.error(`[Sync] RAG indexing failed for ${repoName}:`, err.message);
+                    });
+                } else {
+                    console.log(`[Sync] Skipping RAG indexing for ${repoName}, already has ${chunkCount} chunks`);
+                }
+            }
+        } catch (err) {
+            // Log but don't fail the sync if RAG indexing check errors
+            console.error("[Sync] RAG index check failed:", err);
+        }
+    }
+    
+    return result;
 }
 
 // =============================================================================