fix: /api/eligible 404 - add HF Space endpoint + proxy

- HuggingFace Space: added GET /api/eligible endpoint
- Next.js: proxy /api/eligible to HF Space on production
- Reads paper_trading/bist100_scan_results.json
- Returns eligible stocks sorted by Sharpe ratio
- Fixes auto-trading page 'Tek Döngü Çalıştır' button

huggingface-space/app.py

@@ -1051,6 +1051,91 @@ def trading_action(req: TradingActionRequest):
         raise HTTPException(status_code=400, detail=f"Unknown action: {req.action}")
 
 
+@app.get("/api/eligible")
+def get_eligible_stocks():
+    """
+    GET /api/eligible
+    Returns list of eligible stocks from BIST100 scan results
+    """
+    scan_file = Path("paper_trading/bist100_scan_results.json")
+    
+    if not scan_file.exists():
+        return {
+            "ok": False,
+            "error": "Scan results not found. Run BIST100 scan first.",
+            "eligible": [],
+            "excluded": [],
+            "stage1Failures": [],
+            "stage1PassedCount": 0,
+            "summary": {
+                "eligibleCount": 0,
+                "excludedCount": 0,
+                "stage1FailedCount": 0,
+                "avgSharpe": 0,
+                "avgReturn": 0,
+                "avgHitRate": 0,
+            },
+        }
+    
+    try:
+        with open(scan_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        
+        stage2 = data.get("stage2", {})
+        eligible = []
+        excluded = []
+        
+        for symbol, info in stage2.items():
+            if info.get("eligible"):
+                eligible.append({
+                    "symbol": symbol,
+                    "eligible": True,
+                    "sharpe": info.get("sharpe", 0),
+                    "annual_return": info.get("annual_return", 0),
+                    "hit_rate": info.get("hit_rate", 0),
+                    "quality": info.get("quality", ""),
+                })
+            else:
+                excluded.append({
+                    "symbol": symbol,
+                    "reason": info.get("reason", info.get("quality", "Yetersiz kalite")),
+                    "sharpe": info.get("sharpe"),
+                })
+        
+        # Sort eligible by sharpe descending
+        eligible.sort(key=lambda x: x.get("sharpe", 0), reverse=True)
+        excluded.sort(key=lambda x: x["symbol"])
+        
+        stage1_failures = [
+            {"symbol": sym, "reason": reason}
+            for sym, reason in data.get("stage1", {}).get("failed", {}).items()
+        ]
+        
+        avg_sharpe = sum(e.get("sharpe", 0) for e in eligible) / len(eligible) if eligible else 0
+        avg_return = sum(e.get("annual_return", 0) for e in eligible) / len(eligible) if eligible else 0
+        avg_hit_rate = sum(e.get("hit_rate", 0) for e in eligible) / len(eligible) if eligible else 0
+        
+        return {
+            "ok": True,
+            "eligible": eligible,
+            "excluded": excluded,
+            "stage1Failures": stage1_failures,
+            "stage1PassedCount": len(data.get("stage1", {}).get("passed", [])),
+            "summary": {
+                "eligibleCount": len(eligible),
+                "excludedCount": len(excluded),
+                "stage1FailedCount": len(stage1_failures),
+                "avgSharpe": round(avg_sharpe, 3),
+                "avgReturn": round(avg_return, 2),
+                "avgHitRate": round(avg_hit_rate, 2),
+            },
+            "timestamp": data.get("timestamp"),
+        }
+    
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
+
+
 # For Hugging Face Spaces
 if __name__ == "__main__":
     import uvicorn

nextjs-app/src/app/api/eligible/route.ts

@@ -1,10 +1,15 @@
 import { NextResponse } from 'next/server'
-import { readFile } from 'fs/promises'
-import { join } from 'path'
+import { apiUrl, API_BASE } from '@/lib/runtime-config'
 import { requireAuth } from '@/lib/api-auth'
 
 export const dynamic = 'force-dynamic'
 
+/**
+ * On production (Netlify), proxy to HuggingFace Space.
+ * On local dev, fall back to filesystem-based logic.
+ */
+const isProduction = !!API_BASE
+
 interface ScanStage2 {
   eligible: boolean
   sharpe: number
@@ -23,18 +28,54 @@ interface ScanResults {
   timestamp?: string
 }
 
-export async function GET() {
-  const auth = await requireAuth()
+export async function GET(request: Request) {
+  const auth = await requireAuth(request)
   if (!auth.authenticated) return auth.response
 
+  // Production: proxy to HuggingFace Space
+  if (isProduction) {
+    try {
+      const controller = new AbortController()
+      const timeout = setTimeout(() => controller.abort(), 30000)
+
+      try {
+        const resp = await fetch(apiUrl('/api/eligible'), {
+          headers: { accept: 'application/json' },
+          signal: controller.signal,
+        })
+
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => '')
+          return NextResponse.json(
+            { ok: false, error: `Eligible backend error (HTTP ${resp.status}): ${text}` },
+            { status: 502 }
+          )
+        }
+
+        const data = await resp.json()
+        return NextResponse.json(data)
+      } finally {
+        clearTimeout(timeout)
+      }
+    } catch (e: unknown) {
+      const msg = e instanceof Error ? e.message : 'Unknown'
+      return NextResponse.json({ ok: false, error: `Eligible proxy failed: ${msg}` }, { status: 502 })
+    }
+  }
+
+  // Local dev: read from filesystem
   try {
+    /* eslint-disable */
+    const { readFile } = require('fs/promises')
+    const { join } = require('path')
+    /* eslint-enable */
+
     const filePath = join(process.cwd(), '..', 'paper_trading', 'bist100_scan_results.json')
     let raw: string
 
     try {
       raw = await readFile(filePath, 'utf-8')
     } catch {
-      // Try alternative path
       const altPath = join(process.cwd(), 'paper_trading', 'bist100_scan_results.json')
       try {
         raw = await readFile(altPath, 'utf-8')