Merge branch 'main' of https://huggingface.co/spaces/gaurv007/ClauseGuard

web/app/api/analyze/route.ts

@@ -1,12 +1,11 @@
 import { NextRequest, NextResponse } from "next/server";
-import { createClient } from "@/lib/supabase/server";
 
-const API_URL = process.env.CLAUSEGUARD_API_URL || "https://gaurv007-clauseguard-api.hf.space";
+const GRADIO_URL = process.env.CLAUSEGUARD_GRADIO_URL || "https://gaurv007-clauseguard.hf.space";
 
 export async function POST(req: NextRequest) {
   try {
     const body = await req.json();
-    const { text, source_url } = body;
+    const { text } = body;
 
     if (!text || typeof text !== "string" || text.trim().length < 50) {
       return NextResponse.json(
@@ -15,34 +14,157 @@ export async function POST(req: NextRequest) {
       );
     }
 
-    // Forward auth token to backend
-    const headers: Record<string, string> = { "Content-Type": "application/json" };
+    // Step 1: Submit to Gradio Space
+    const submitRes = await fetch(`${GRADIO_URL}/gradio_api/call/_analysis_and_index`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ data: [text] }),
+    });
+
+    if (!submitRes.ok) {
+      throw new Error(`Gradio submit failed: ${submitRes.status}`);
+    }
+
+    const { event_id } = await submitRes.json();
+    if (!event_id) throw new Error("No event_id from Gradio");
+
+    // Step 2: Poll for result (SSE)
+    // The Gradio API streams but we need the full response
+    let resultText = "";
+    let attempts = 0;
+    const maxAttempts = 60; // 60 seconds max
+
+    while (attempts < maxAttempts) {
+      const resultRes = await fetch(
+        `${GRADIO_URL}/gradio_api/call/_analysis_and_index/${event_id}`,
+        { headers: { Accept: "text/event-stream" } }
+      );
+
+      resultText = await resultRes.text();
+
+      if (resultText.includes("event: complete")) break;
+      if (resultText.includes("event: error")) {
+        const errMatch = resultText.match(/data:\s*(.+)/);
+        throw new Error(errMatch ? errMatch[1] : "Analysis failed in backend");
+      }
+
+      // Wait 1 second and retry
+      await new Promise(r => setTimeout(r, 1000));
+      attempts++;
+    }
+
+    if (!resultText.includes("event: complete")) {
+      throw new Error("Analysis timed out");
+    }
+
+    // Step 3: Parse the SSE data
+    // Format: "event: complete\ndata: [...]"
+    // The data contains HTML with literal newlines, so we need to find 'data: ' after 'event: complete'
+    const completeIdx = resultText.indexOf("event: complete");
+    const dataIdx = resultText.indexOf("data: ", completeIdx);
+    if (dataIdx === -1) throw new Error("No data in response");
+
+    const dataStr = resultText.substring(dataIdx + 6).trim();
+
+    // Parse JSON — the HTML strings contain control characters so we need to handle that
+    // In JS, JSON.parse is more lenient with control chars in strings than Python's strict mode
+    let gradioData: any[];
     try {
-      const supabase = await createClient();
-      const { data: { session } } = await supabase.auth.getSession();
-      if (session?.access_token) {
-        headers["Authorization"] = `Bearer ${session.access_token}`;
+      gradioData = JSON.parse(dataStr);
+    } catch {
+      // If direct parse fails, try replacing problematic control characters
+      const cleaned = dataStr.replace(/[\x00-\x1f]/g, (ch: string) => {
+        if (ch === "\n") return "\\n";
+        if (ch === "\r") return "\\r";
+        if (ch === "\t") return "\\t";
+        return "";
+      });
+      gradioData = JSON.parse(cleaned);
+    }
+
+    // Step 4: Download the JSON report file (structured data)
+    // gradioData[8] is the JSON file object with { url, path, ... }
+    const jsonFileObj = gradioData[8];
+    if (!jsonFileObj?.url) {
+      throw new Error("No JSON report generated");
+    }
+
+    // Download immediately (temp files expire quickly)
+    const jsonRes = await fetch(jsonFileObj.url);
+    if (!jsonRes.ok) throw new Error("Failed to download analysis JSON");
+    const analysisData = await jsonRes.json();
+
+    // Step 5: Transform to frontend format
+    const riskScore = analysisData.risk?.score ?? 0;
+    const grade = analysisData.risk?.grade ?? "A";
+    const totalClauses = analysisData.metadata?.total_clauses ?? 0;
+    const flaggedCount = analysisData.metadata?.flagged_clauses ?? 0;
+
+    // Group clauses by text (multiple labels per clause)
+    const clauseMap = new Map<string, any>();
+    for (const cr of (analysisData.clauses || [])) {
+      if (!clauseMap.has(cr.text)) {
+        clauseMap.set(cr.text, { text: cr.text, categories: [] });
       }
-    } catch {}
+      clauseMap.get(cr.text)!.categories.push({
+        name: cr.label,
+        severity: cr.risk,
+        confidence: cr.confidence,
+        description: cr.description,
+      });
+    }
+    const results = Array.from(clauseMap.values());
 
-    const response = await fetch(`${API_URL}/api/analyze`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({ text, source_url }),
-    });
+    // Parse redlines from HTML (gradioData[7])
+    const redlines: any[] = [];
+    const redlineHtml = typeof gradioData[7] === "string" ? gradioData[7] : "";
+    if (redlineHtml.includes("Clause Redlining")) {
+      // Split by redline card borders
+      const blocks = redlineHtml.split(/border-left:4px solid #/);
+      for (let i = 1; i < blocks.length; i++) {
+        const block = blocks[i];
+        const labelMatch = block.match(/font-weight:600[^>]*>([^<]+)<\/span>\s*<span[^>]*font-weight:600[^>]*>([^<]+)/);
+        const origMatch = block.match(/<del>([^<]*)<\/del>/);
+        const safeBlock = block.match(/Suggested Alternative[\s\S]*?<div[^>]*color:#166534[^>]*>([\s\S]*?)<\/div>/);
+        const legalMatch = block.match(/Legal Basis<\/div>\s*<div[^>]*>([^<]+)/);
+        const consumerMatch = block.match(/Consumer Standard<\/div>\s*<div[^>]*>([^<]+)/);
+        const isLLM = block.includes("LLM Refined");
 
-    if (!response.ok) {
-      const errText = await response.text().catch(() => "");
-      console.error(`Backend error ${response.status}: ${errText}`);
-      throw new Error(`Backend API error: ${response.status}`);
+        if (labelMatch) {
+          redlines.push({
+            clause_label: labelMatch[1].trim(),
+            risk_level: labelMatch[2].trim(),
+            original_text: origMatch ? origMatch[1].trim() : "",
+            safe_alternative: safeBlock ? safeBlock[1].replace(/<[^>]+>/g, "").trim() : "",
+            legal_basis: legalMatch ? legalMatch[1].trim() : "",
+            consumer_standard: consumerMatch ? consumerMatch[1].trim() : "",
+            tier: isLLM ? "llm_refined" : "template",
+          });
+        }
+      }
     }
 
-    const results = await response.json();
-    return NextResponse.json(results);
+    const modelStatus = analysisData.metadata?.model || "";
+
+    return NextResponse.json({
+      risk_score: riskScore,
+      grade,
+      total_clauses: totalClauses,
+      flagged_count: flaggedCount,
+      results,
+      entities: analysisData.entities || [],
+      contradictions: analysisData.contradictions || [],
+      obligations: analysisData.obligations || [],
+      compliance: analysisData.compliance || {},
+      redlines,
+      model: modelStatus.includes("loaded") ? "ml" : "regex",
+      latency_ms: 0,
+      session_id: null,
+    });
   } catch (error: any) {
     console.error("Analyze error:", error.message);
     return NextResponse.json(
-      { error: "Analysis failed. The backend may be starting up — try again in 30 seconds." },
+      { error: "Analysis failed: " + (error.message || "Try again in 30 seconds.") },
       { status: 500 }
     );
   }

web/app/api/chat/route.ts

@@ -1,36 +1,68 @@
 import { NextRequest, NextResponse } from "next/server";
 
-const API_URL = process.env.CLAUSEGUARD_API_URL || "https://gaurv007-clauseguard-api.hf.space";
+const GRADIO_URL = process.env.CLAUSEGUARD_GRADIO_URL || "https://gaurv007-clauseguard.hf.space";
 
 export async function POST(req: NextRequest) {
   try {
     const body = await req.json();
-    const { message, session_id, history } = body;
+    const { message, history } = body;
 
-    if (!message || !session_id) {
+    if (!message) {
       return NextResponse.json(
-        { error: "message and session_id are required" },
+        { error: "message is required" },
         { status: 400 }
       );
     }
 
-    const response = await fetch(`${API_URL}/api/chat`, {
+    // The Gradio ChatInterface endpoint is /chat
+    // It accepts: message (str), then the additional_inputs are handled by Gradio state
+    // We need to call the Gradio API with the message
+    const submitRes = await fetch(`${GRADIO_URL}/gradio_api/call/chat`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ message, session_id, history: history || [] }),
+      body: JSON.stringify({ data: [message] }),
     });
 
-    if (!response.ok) {
-      const err = await response.text().catch(() => "");
-      throw new Error(err || `Backend error: ${response.status}`);
+    if (!submitRes.ok) {
+      const errText = await submitRes.text().catch(() => "");
+      throw new Error(`Chat submit failed (${submitRes.status}): ${errText}`);
     }
 
-    const result = await response.json();
-    return NextResponse.json(result);
+    const { event_id } = await submitRes.json();
+    if (!event_id) throw new Error("No event_id from Gradio chat");
+
+    // Poll for streaming result
+    const resultRes = await fetch(
+      `${GRADIO_URL}/gradio_api/call/chat/${event_id}`,
+      { headers: { Accept: "text/event-stream" } }
+    );
+
+    if (!resultRes.ok) {
+      throw new Error(`Chat result failed: ${resultRes.status}`);
+    }
+
+    const resultText = await resultRes.text();
+
+    // Find the complete event data
+    const dataMatch = resultText.match(/event:\s*complete\s*\ndata:\s*(.+)/);
+    if (!dataMatch) {
+      // Check for error
+      const errMatch = resultText.match(/event:\s*error\s*\ndata:\s*(.+)/);
+      if (errMatch) {
+        throw new Error(`Chat error: ${errMatch[1]}`);
+      }
+      throw new Error("No response from chatbot. Analyze a contract first in the Gradio Space, then try chatting.");
+    }
+
+    const responseData = JSON.parse(dataMatch[1]);
+    // The ChatInterface returns the response as a string
+    const responseText = typeof responseData === "string" ? responseData : responseData[0] || "";
+
+    return NextResponse.json({ response: responseText });
   } catch (error: any) {
     console.error("Chat error:", error.message);
     return NextResponse.json(
-      { error: error.message || "Chat failed. Try again." },
+      { error: error.message || "Chat failed. Make sure you analyzed a contract in the Gradio Space first." },
       { status: 500 }
     );
   }

web/app/api/compare/route.ts

@@ -1,6 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
 
-const API_URL = process.env.CLAUSEGUARD_API_URL || "https://gaurv007-clauseguard-api.hf.space";
+const GRADIO_URL = process.env.CLAUSEGUARD_GRADIO_URL || "https://gaurv007-clauseguard.hf.space";
 
 export async function POST(req: NextRequest) {
   try {
@@ -14,18 +14,49 @@ export async function POST(req: NextRequest) {
       );
     }
 
-    const response = await fetch(`${API_URL}/api/compare`, {
+    // Call Gradio Space API
+    const submitRes = await fetch(`${GRADIO_URL}/gradio_api/call/run_comparison`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ text_a, text_b }),
+      body: JSON.stringify({ data: [text_a, text_b] }),
     });
 
-    if (!response.ok) {
-      throw new Error(`Backend error: ${response.status}`);
+    if (!submitRes.ok) {
+      throw new Error(`Gradio submit failed: ${submitRes.status}`);
     }
 
-    const result = await response.json();
-    return NextResponse.json(result);
+    const { event_id } = await submitRes.json();
+    if (!event_id) throw new Error("No event_id from Gradio");
+
+    // Poll for result
+    const resultRes = await fetch(
+      `${GRADIO_URL}/gradio_api/call/run_comparison/${event_id}`,
+      { headers: { Accept: "text/event-stream" } }
+    );
+
+    if (!resultRes.ok) {
+      throw new Error(`Gradio result failed: ${resultRes.status}`);
+    }
+
+    const resultText = await resultRes.text();
+    const dataMatch = resultText.match(/event:\s*complete\s*\ndata:\s*(.+)/);
+    if (!dataMatch) throw new Error("No complete event from Gradio");
+
+    const gradioData = JSON.parse(dataMatch[1]);
+    // gradioData[0] = comparison HTML
+    // gradioData[1] = raw JSON comparison data
+
+    const comparisonResult = gradioData[1];
+    if (typeof comparisonResult === "object" && comparisonResult !== null) {
+      return NextResponse.json(comparisonResult);
+    }
+
+    // If it's a string (JSON stringified), parse it
+    if (typeof comparisonResult === "string") {
+      return NextResponse.json(JSON.parse(comparisonResult));
+    }
+
+    throw new Error("Unexpected comparison result format");
   } catch (error: any) {
     console.error("Compare error:", error.message);
     return NextResponse.json({ error: error.message || "Comparison failed" }, { status: 500 });