update

.gitignore

@@ -0,0 +1,63 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Project specific
+*.db
+papers_cache.db
+workdir/
+data/pdfs/
+.env
+.env.local
+.env.*.local
+.env.example
+
+# Logs
+*.log
+logs/
+
+# Temporary files
+*.tmp
+*.temp

DEPLOYMENT.md

@@ -0,0 +1,107 @@
+# PaperIndex Deployment Guide
+
+## Hugging Face Spaces Deployment
+
+### 1. Create Space
+
+1. Visit [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Click "Create new Space"
+3. Select "Docker" as SDK
+4. Set Space name (e.g., "paperindex")
+5. Choose "Public" or "Private"
+
+### 2. Secure API Key Configuration
+
+**Important: Never hardcode API keys in your code!**
+
+#### Method 1: Use HF Spaces Secrets (Recommended)
+
+1. On your Space page, click the "Settings" tab
+2. Find "Repository secrets" in the left menu
+3. Click "New secret"
+4. Add the following secret:
+   - **Name**: `ANTHROPIC_API_KEY`
+   - **Value**: Your Anthropic API key
+
+#### Method 2: Use Environment Variables (Local Development Only)
+
+Create a `.env` file (do not commit to Git):
+```bash
+ANTHROPIC_API_KEY=your_api_key_here
+```
+
+### 3. Push Code
+
+```bash
+# Ensure database files use Git LFS
+git lfs track "*.db"
+git add .gitattributes
+
+# Commit and push
+git add .
+git commit -m "Update deployment configuration"
+git push origin main
+```
+
+### 4. Verify Deployment
+
+1. Wait for HF Spaces to auto-build (usually 2-5 minutes)
+2. Visit your Space URL: `https://huggingface.co/spaces/your-username/paperindex`
+3. Check if the application is running properly
+
+## Local Docker Deployment
+
+### 1. Build Image
+
+```bash
+docker build -t paperindex .
+```
+
+### 2. Run Container
+
+```bash
+# Using environment variables
+docker run -d -p 7860:7860 \
+  -e ANTHROPIC_API_KEY=your_api_key_here \
+  --name paperindex-app paperindex
+
+# Or using .env file
+docker run -d -p 7860:7860 \
+  --env-file .env \
+  --name paperindex-app paperindex
+```
+
+### 3. Access Application
+
+Open browser and visit: `http://localhost:7860`
+
+## Security Considerations
+
+1. **Never** hardcode API keys in your code
+2. **Never** commit `.env` files to Git repository
+3. Use HF Spaces Secrets to store sensitive information
+4. Regularly rotate API keys
+5. Monitor API usage
+
+## Troubleshooting
+
+### Common Issues
+
+1. **API Key Error**
+   - Check if HF Spaces Secrets are set correctly
+   - Verify API key is valid
+
+2. **Build Failure**
+   - Check Dockerfile syntax
+   - View build logs
+
+3. **Application Won't Start**
+   - Check port configuration
+   - View container logs: `docker logs paperindex-app`
+
+### Getting Help
+
+If you encounter issues:
+1. Check HF Spaces build logs
+2. View application logs
+3. Report issues in GitHub Issues

README.md

@@ -1,11 +1,146 @@
----
-title: Paperindex
-emoji: 📈
-colorFrom: pink
-colorTo: blue
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# PaperIndex
+
+A beautiful web application for browsing and evaluating daily papers from Hugging Face, featuring a modern UI inspired by Hugging Face's design.
+
+## Features
+
+- 📰 **Daily Papers**: Browse the latest papers from Hugging Face
+- 🎨 **Beautiful UI**: Modern design with day/night theme switching
+- 📊 **Paper Evaluation**: Detailed evaluation pages with radar charts
+- 🔄 **Smart Caching**: Intelligent caching system for better performance
+- 📱 **Responsive**: Works perfectly on desktop and mobile devices
+
+## Live Demo
+
+🌐 **Hugging Face Spaces**: [PaperIndex Demo](https://huggingface.co/spaces/your-username/paperindex)
+
+## Local Development
+
+### Prerequisites
+
+- Python 3.8+
+- pip
+
+### Installation
+
+1. Clone the repository:
+```bash
+git clone https://github.com/your-username/PaperIndex.git
+cd PaperIndex
+```
+
+2. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+3. Run the development server:
+```bash
+python -m uvicorn server:app --reload --host 0.0.0.0 --port 8000
+```
+
+4. Open your browser and visit: `http://localhost:8000`
+
+## Deployment
+
+### Hugging Face Spaces (Recommended) - FREE!
+
+**Hugging Face Spaces 完全免费，包含：**
+- ✅ 无限个人项目
+- ✅ 自动 HTTPS
+- ✅ 全球 CDN
+- ✅ 自动部署
+- ✅ 自定义域名支持
+
+#### 部署步骤：
+
+1. **创建 Space**：
+   - 访问 [Hugging Face Spaces](https://huggingface.co/spaces)
+   - 点击 "Create new Space"
+   - 选择 "Gradio" 作为 SDK
+   - 设置 Space 名称（如 "paperindex"）
+   - 选择 "Public" 或 "Private"
+
+2. **配置访问令牌**：
+   ```bash
+   # 复制环境变量模板
+   cp env.example .env
+   
+   # 编辑 .env 文件，添加你的 Hugging Face 访问令牌
+   # 获取令牌：https://huggingface.co/settings/tokens
+   # 确保选择 "Write" 权限
+   ```
+
+3. **一键部署**：
+   ```bash
+   # 使用部署脚本
+   ./deploy_to_hf.sh your-username paperindex
+   ```
+
+4. **自动部署**：
+   - Spaces 会自动检测 `app.py` 作为入口点
+   - 自动安装 `requirements.txt` 中的依赖
+   - 自动启动服务
+
+5. **访问你的应用**：
+   - 你的应用将在以下地址可用：`https://huggingface.co/spaces/your-username/paperindex`
+   - 部署完成后，你可以分享这个链接给任何人
+
+#### 重要文件说明：
+
+- `app.py` - Spaces 的入口点文件
+- `requirements.txt` - Python 依赖
+- `server.py` - 主要的 FastAPI 应用
+- `frontend/` - 静态前端文件
+
+### Alternative Deployment Options
+
+- **Vercel**: 免费计划，无限个人项目
+- **Railway**: 简单部署，$5/月免费额度
+- **Render**: 免费层级可用
+
+## Project Structure
+
+```
+PaperIndex/
+├── frontend/           # Static frontend files
+│   ├── index.html     # Main page
+│   ├── paper.html     # Paper evaluation page
+│   ├── main.js        # Main page JavaScript
+│   ├── paper.js       # Evaluation page JavaScript
+│   └── styles.css     # Shared styles
+├── agents/            # AI evaluation agents
+├── workdir/           # Evaluation data storage
+├── data/              # Data files
+├── server.py          # FastAPI backend
+├── app.py             # Hugging Face Spaces entry point
+├── requirements.txt   # Python dependencies
+└── README.md         # This file
+```
+
+## API Endpoints
+
+- `GET /` - Main page
+- `GET /paper.html?id={paper_id}` - Paper evaluation page
+- `GET /api/daily?date_str={date}` - Get daily papers
+- `GET /api/eval/{paper_id}` - Get paper evaluation
+- `GET /api/cache/status` - Get cache status
+- `POST /api/cache/clear` - Clear cache
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Submit a pull request
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Acknowledgments
+
+- Inspired by Hugging Face's beautiful paper browsing interface
+- Built with FastAPI and modern web technologies
+
+

agents/__init__.py

@@ -0,0 +1,2 @@
+
+

agents/evaluator.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import base64
+import os
+import json
+import asyncio
+from typing import Any, Dict, List, Optional
+from pathlib import Path
+from datetime import datetime
+
+from anthropic import Anthropic
+from langgraph.graph import END, StateGraph
+from pydantic import BaseModel, Field
+from agents.prompt import REVIEWER_SYSTEM_PROMPT, EVALUATION_PROMPT_TEMPLATE, TOOLS, TOOL_CHOICE
+
+# Import API key function from server module
+import sys
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from server import get_anthropic_api_key
+
+
+class ConversationState(BaseModel):
+    """State for the conversation graph"""
+    messages: List[Dict[str, Any]] = Field(default_factory=list)
+    response_text: str = ""
+    tool_result: Optional[Dict[str, Any]] = None
+
+
+def _load_pdf_as_content(pdf_path: str) -> Dict[str, Any]:
+    if os.path.exists(pdf_path):
+        with open(pdf_path, "rb") as f:
+            data_b64 = base64.b64encode(f.read()).decode("utf-8")
+        return {
+            "type": "document",
+            "source": {
+                "type": "base64",
+                "media_type": "application/pdf",
+                "data": data_b64,
+            },
+        }
+    if pdf_path.startswith("http"):
+        return {
+            "type": "document",
+            "source": {
+                "type": "url",
+                "url": pdf_path,
+            },
+        }
+    raise FileNotFoundError(f"PDF not found or invalid path: {pdf_path}")
+
+
+class Evaluator:
+    def __init__(self, api_key: Optional[str] = None):
+        api_key = api_key or get_anthropic_api_key()
+        if not api_key:
+            raise ValueError("Anthropic API key is required. Please set HF_SECRET_ANTHROPIC_API_KEY in Hugging Face Spaces secrets or ANTHROPIC_API_KEY environment variable.")
+        self.client = Anthropic(api_key=api_key)
+        self.system_prompt = REVIEWER_SYSTEM_PROMPT
+        self.eval_template = EVALUATION_PROMPT_TEMPLATE
+
+    async def __call__(self, state: ConversationState) -> ConversationState:
+        """Evaluate the paper using the conversation state"""
+        # Prepare messages for the API call
+        messages = [{"role": "system", "content": self.system_prompt}]
+        messages.extend(state.messages)
+        
+        # Add the evaluation prompt
+        messages.append({
+            "role": "user", 
+            "content": self.eval_template
+        })
+        
+        try:
+            # Call Anthropic API with tools
+            response = await self.client.messages.create(
+                model="claude-3-5-sonnet-20241022",
+                max_tokens=4000,
+                messages=messages,
+                tools=TOOLS,
+                tool_choice=TOOL_CHOICE
+            )
+            
+            # Process the response
+            state.messages.append({
+                "role": "assistant",
+                "content": response.content[0].text if response.content else ""
+            })
+            
+            # Extract tool result if present
+            tool_result = None
+            if response.content and hasattr(response.content[0], 'tool_use'):
+                tool_use = response.content[0].tool_use
+                if tool_use:
+                    tool_result = json.loads(tool_use.input)
+            
+            # Prefer tool JSON; if absent, fall back to raw text
+            if tool_result is not None:
+                state.response_text = json.dumps(tool_result, ensure_ascii=False, indent=2)
+            else:
+                state.response_text = response.content[0].text if response.content else ""
+                
+        except Exception as e:
+            state.response_text = f"Error during evaluation: {str(e)}"
+        
+        return state
+
+
+async def save_node(state: ConversationState) -> ConversationState:
+    """Save the evaluation result to a file"""
+    try:
+        # Create workdir if it doesn't exist
+        workdir = os.getenv("WORKDIR", "workdir")
+        os.makedirs(workdir, exist_ok=True)
+        
+        # Generate filename based on timestamp
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"evaluation_{timestamp}.json"
+        filepath = os.path.join(workdir, filename)
+        
+        # Save the evaluation result
+        with open(filepath, 'w', encoding='utf-8') as f:
+            json.dump({
+                "timestamp": timestamp,
+                "response": state.response_text,
+                "tool_result": state.tool_result
+            }, f, ensure_ascii=False, indent=2)
+        
+        state.response_text += f"\n\nEvaluation saved to: {filename}"
+        
+    except Exception as e:
+        state.response_text += f"\n\nError saving evaluation: {str(e)}"
+    
+    return state
+
+
+def build_graph(api_key: Optional[str] = None):
+    """Build the evaluation graph"""
+    graph = StateGraph(ConversationState)
+    evaluator = Evaluator(api_key=api_key)
+    graph.add_node("evaluate", evaluator)
+    graph.add_node("save", save_node)
+    
+    # Define the flow
+    graph.set_entry_point("evaluate")
+    graph.add_edge("evaluate", "save")
+    graph.add_edge("save", END)
+    
+    return graph.compile()
+
+
+def run_evaluation(pdf_path: str, output_file: Optional[str] = None, api_key: Optional[str] = None) -> str:
+    app = build_graph(api_key=api_key)
+    initial = ConversationState(pdf_path=pdf_path, output_file=output_file)
+    # Ensure compatibility with LangGraph's dict-based state
+    final_state = app.invoke(initial.model_dump())
+    if isinstance(final_state, dict):
+        return str(final_state.get("response_text", ""))
+    if isinstance(final_state, ConversationState):
+        return final_state.response_text
+    return str(getattr(final_state, "response_text", ""))
+
+

agents/prompt.py

@@ -0,0 +1,397 @@
+# Prompts moved from test_pdf_parser.py to make the agent self-contained
+REVIEWER_SYSTEM_PROMPT = """You are a senior AI research expert and technology assessment consultant, specializing in evaluating the potential for scientific research work to be automated by current or near-future AI systems.
+Your assessment should be:
+1. Systematic and evidence-based using the 12-dimensional framework
+2. Objective in analyzing current AI capability boundaries
+3. Realistic in predicting technology development trends
+4. Comprehensive in considering automation barriers and societal impacts
+
+Maintain critical thinking and provide detailed justifications for each score. Your evaluation will influence research directions and resource allocation decisions."""
+
+EVALUATION_PROMPT_TEMPLATE = """
+# Systematic AI Automation Assessment Framework
+
+Please conduct a comprehensive evaluation of the provided academic work using the following 12-dimensional framework. For each dimension, provide detailed analysis and justification for your scoring.
+
+## 12-Dimensional Evaluation Framework
+
+### 1. **Task Formalization** (Score: 0-4)
+**What to Evaluate**: Whether the task has clear rules/mathematical objectives
+**Score Anchors**: 
+- 0: Ill-defined
+- 1: Partly formal
+- 2: Mostly formal
+- 3: Fully formal with minor caveats
+- 4: Mathematically exact
+
+**Analysis Required**: Examine the clarity of problem definition, mathematical formulation, and objective functions.
+
+### 2. **Data & Resource Availability** (Score: 0-4)
+**What to Evaluate**: Public data, simulators, tool chains availability
+**Score Anchors**:
+- 0: None
+- 1: Sparse/private
+- 2: Moderate
+- 3: Rich
+- 4: Abundant & public
+
+**Analysis Required**: Assess the availability and quality of datasets, existing tools, and computational resources.
+
+### 3. **Input-Output Complexity** (Score: 0-4)
+**What to Evaluate**: Modal diversity, structure and length complexity
+**Score Anchors**:
+- 0: Chaotic
+- 1: High complexity
+- 2: Moderate complexity
+- 3: Low complexity
+- 4: Highly regular
+
+**Analysis Required**: Evaluate the complexity of input processing and output generation requirements.
+
+### 4. **Real-World Interaction** (Score: 0-4)
+**What to Evaluate**: Need for physical/social/online feedback
+**Score Anchors**:
+- 0: Constant interaction needed
+- 1: Frequent interaction
+- 2: Occasional interaction
+- 3: Rare interaction
+- 4: None (offline)
+
+**Analysis Required**: Determine the extent of real-world interaction and feedback requirements.
+
+### 5. **Existing AI Coverage** (Score: 0-4)
+**What to Evaluate**: Proportion of work already completed by existing AI models
+**Score Anchors**:
+- 0: < 5%
+- 1: ≈ 25%
+- 2: ≈ 50%
+- 3: ≈ 75%
+- 4: > 95%
+
+**Analysis Required**: Identify specific existing AI tools/models and quantify coverage percentage.
+
+### 6. **Automation Barriers** (Qualitative Analysis - No Score)
+**What to Evaluate**: Major obstacles like creativity, common sense, legal issues
+**Analysis Required**: List and explain key barriers preventing full automation:
+- Creativity requirements
+- Common sense reasoning
+- Domain expertise
+- Legal/ethical constraints
+- Tacit knowledge
+- Other specific barriers
+
+### 7. **Human Originality/Irreplaceability** (Score: 0-4)
+**What to Evaluate**: Dependence on human creativity and originality
+**Score Anchors**:
+- 0: Routine work
+- 1: Incremental innovation
+- 2: Moderately novel
+- 3: Clearly novel
+- 4: Paradigm-shifting
+
+**Analysis Required**: Assess the level of human creativity, insight, and original thinking required.
+
+### 8. **Safety & Ethical Criticality** (Score: 0-4, Reverse Scoring)
+**What to Evaluate**: Consequences of failure/misuse
+**Score Anchors**:
+- 0: Catastrophic consequences
+- 1: Serious consequences
+- 2: Manageable consequences
+- 3: Minor consequences
+- 4: Negligible consequences
+
+**Analysis Required**: Evaluate risks and potential negative impacts of automation.
+
+### 9. **Societal/Economic Impact** (Qualitative Analysis - No Score)
+**What to Evaluate**: Net impact after full automation
+**Analysis Required**: Describe comprehensive societal and economic implications:
+- Job displacement effects
+- Research quality changes
+- Innovation ecosystem impacts
+- Economic benefits/costs
+- Social implications
+
+### 10. **Technical Maturity Needed** (Score: 0-4)
+**What to Evaluate**: Required R&D depth for automation
+**Score Anchors**:
+- 0: Multiple breakthroughs needed
+- 1: One major breakthrough needed
+- 2: Cutting-edge R&D required
+- 3: Incremental work needed
+- 4: Already solved
+
+**Analysis Required**: Identify specific technical advances needed and their feasibility.
+
+### 11. **3-Year Feasibility** (Probability: 0-100%)
+**What to Evaluate**: Probability of AI reaching expert level within 3 years
+**Analysis Required**: Provide realistic probability estimate with detailed justification considering:
+- Current AI development pace
+- Required technical breakthroughs
+- Resource availability
+- Market incentives
+
+### 12. **Overall Automatability** (Score: 0-4)
+**What to Evaluate**: Comprehensive automation feasibility
+**Score Anchors**:
+- 0: Not automatable
+- 1: Hard to automate
+- 2: Moderately automatable
+- 3: Highly automatable
+- 4: Already automatable
+
+**Analysis Required**: Synthesize all dimensions into overall assessment.
+
+## Output Format Requirements
+
+Please structure your response as follows:
+
+# AI Automation Assessment Report
+
+## Executive Summary
+[Provide a concise 150-word summary of key findings and overall assessment]
+
+## Detailed Dimensional Analysis
+
+### 1. Task Formalization
+**Score: X/4**
+[Detailed analysis and justification]
+
+### 2. Data & Resource Availability
+**Score: X/4**
+[Detailed analysis and justification]
+
+### 3. Input-Output Complexity
+**Score: X/4**
+[Detailed analysis and justification]
+
+### 4. Real-World Interaction
+**Score: X/4**
+[Detailed analysis and justification]
+
+### 5. Existing AI Coverage
+**Score: X/4**
+[Detailed analysis with specific tools/models and coverage percentage]
+
+### 6. Automation Barriers
+[Comprehensive list and explanation of key barriers]
+
+### 7. Human Originality/Irreplaceability
+**Score: X/4**
+[Detailed analysis and justification]
+
+### 8. Safety & Ethical Criticality
+**Score: X/4**
+[Detailed risk analysis and justification]
+
+### 9. Societal/Economic Impact
+[Comprehensive impact analysis]
+
+### 10. Technical Maturity Needed
+**Score: X/4**
+[Detailed analysis of required advances]
+
+### 11. 3-Year Feasibility
+**Probability: X%**
+[Detailed probability assessment with reasoning]
+
+### 12. Overall Automatability
+**Score: X/4**
+[Synthesis of all dimensions with final assessment]
+
+## Summary Scorecard
+
+| Dimension | Score | Key Insight |
+|-----------|-------|-------------|
+| Task Formalization | X/4 | [Brief insight] |
+| Data & Resource Availability | X/4 | [Brief insight] |
+| Input-Output Complexity | X/4 | [Brief insight] |
+| Real-World Interaction | X/4 | [Brief insight] |
+| Existing AI Coverage | X/4 | [Brief insight] |
+| Human Originality | X/4 | [Brief insight] |
+| Safety & Ethics | X/4 | [Brief insight] |
+| Technical Maturity | X/4 | [Brief insight] |
+| 3-Year Feasibility | X% | [Brief insight] |
+| **Overall Automatability** | **X/4** | **[Key conclusion]** |
+
+## Strategic Recommendations
+
+### For Researchers
+[Specific recommendations for researchers in this field]
+
+### For Institutions
+[Recommendations for research institutions and funding bodies]
+
+### For AI Development
+[Recommendations for AI researchers and developers]
+
+## Assessment Limitations and Uncertainties
+[List key limitations, assumptions, and areas of uncertainty in the assessment]
+
+---
+
+**Instructions**: 
+- Provide specific evidence and examples for each score
+- Be conservative in scoring when uncertain
+- Consider both current capabilities and realistic near-term developments
+- Justify all numerical scores with detailed reasoning
+- For qualitative dimensions, provide comprehensive analysis
+
+Now please begin the systematic evaluation of the provided academic work.
+"""
+
+# Tools schema for function calling (Anthropic tools)
+# The model must call `return_assessment` to output a strict JSON object
+TOOLS = [
+    {
+        "name": "return_assessment",
+        "description": "Return the complete 12D AI automation assessment as a single JSON object.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "metadata": {
+                    "type": "object",
+                    "properties": {
+                        "assessed_at": {"type": "string"},
+                        "model": {"type": "string"},
+                        "version": {"type": "string"},
+                        "paper_path": {"type": "string"},
+                    },
+                    "required": ["assessed_at", "model", "version", "paper_path"],
+                },
+                "executive_summary": {"type": "string"},
+                "dimensions": {
+                    "type": "object",
+                    "properties": {
+                        "task_formalization": {
+                            "type": "object",
+                            "properties": {"score": {"type": "number"}, "analysis": {"type": "string"}},
+                            "required": ["score", "analysis"],
+                        },
+                        "data_resource_availability": {
+                            "type": "object",
+                            "properties": {"score": {"type": "number"}, "analysis": {"type": "string"}},
+                            "required": ["score", "analysis"],
+                        },
+                        "input_output_complexity": {
+                            "type": "object",
+                            "properties": {"score": {"type": "number"}, "analysis": {"type": "string"}},
+                            "required": ["score", "analysis"],
+                        },
+                        "real_world_interaction": {
+                            "type": "object",
+                            "properties": {"score": {"type": "number"}, "analysis": {"type": "string"}},
+                            "required": ["score", "analysis"],
+                        },
+                        "existing_ai_coverage": {
+                            "type": "object",
+                            "properties": {
+                                "score": {"type": "number"},
+                                "analysis": {"type": "string"},
+                                "tools_models": {"type": "array", "items": {"type": "string"}},
+                                "coverage_pct_estimate": {"type": "number"},
+                            },
+                            "required": ["score", "analysis"],
+                        },
+                        "automation_barriers": {
+                            "type": "object",
+                            "properties": {"analysis": {"type": "string"}},
+                            "required": ["analysis"],
+                        },
+                        "human_originality": {
+                            "type": "object",
+                            "properties": {"score": {"type": "number"}, "analysis": {"type": "string"}},
+                            "required": ["score", "analysis"],
+                        },
+                        "safety_ethics": {
+                            "type": "object",
+                            "properties": {"score": {"type": "number"}, "analysis": {"type": "string"}},
+                            "required": ["score", "analysis"],
+                        },
+                        "societal_economic_impact": {
+                            "type": "object",
+                            "properties": {"analysis": {"type": "string"}},
+                            "required": ["analysis"],
+                        },
+                        "technical_maturity_needed": {
+                            "type": "object",
+                            "properties": {"score": {"type": "number"}, "analysis": {"type": "string"}},
+                            "required": ["score", "analysis"],
+                        },
+                        "three_year_feasibility": {
+                            "type": "object",
+                            "properties": {"probability_pct": {"type": "number"}, "analysis": {"type": "string"}},
+                            "required": ["probability_pct", "analysis"],
+                        },
+                        "overall_automatability": {
+                            "type": "object",
+                            "properties": {"score": {"type": "number"}, "analysis": {"type": "string"}},
+                            "required": ["score", "analysis"],
+                        },
+                    },
+                    "required": [
+                        "task_formalization",
+                        "data_resource_availability",
+                        "input_output_complexity",
+                        "real_world_interaction",
+                        "existing_ai_coverage",
+                        "automation_barriers",
+                        "human_originality",
+                        "safety_ethics",
+                        "societal_economic_impact",
+                        "technical_maturity_needed",
+                        "three_year_feasibility",
+                        "overall_automatability",
+                    ],
+                },
+                "scorecard": {
+                    "type": "object",
+                    "properties": {
+                        "task_formalization": {"type": "number"},
+                        "data_resource_availability": {"type": "number"},
+                        "input_output_complexity": {"type": "number"},
+                        "real_world_interaction": {"type": "number"},
+                        "existing_ai_coverage": {"type": "number"},
+                        "human_originality": {"type": "number"},
+                        "safety_ethics": {"type": "number"},
+                        "technical_maturity_needed": {"type": "number"},
+                        "three_year_feasibility_pct": {"type": "number"},
+                        "overall_automatability": {"type": "number"},
+                    },
+                    "required": [
+                        "task_formalization",
+                        "data_resource_availability",
+                        "input_output_complexity",
+                        "real_world_interaction",
+                        "existing_ai_coverage",
+                        "human_originality",
+                        "safety_ethics",
+                        "technical_maturity_needed",
+                        "three_year_feasibility_pct",
+                        "overall_automatability",
+                    ],
+                },
+                "recommendations": {
+                    "type": "object",
+                    "properties": {
+                        "for_researchers": {"type": "array", "items": {"type": "string"}},
+                        "for_institutions": {"type": "array", "items": {"type": "string"}},
+                        "for_ai_development": {"type": "array", "items": {"type": "string"}},
+                    },
+                    "required": ["for_researchers", "for_institutions", "for_ai_development"],
+                },
+                "limitations_uncertainties": {"type": "array", "items": {"type": "string"}},
+            },
+            "required": [
+                "metadata",
+                "executive_summary",
+                "dimensions",
+                "scorecard",
+                "recommendations",
+                "limitations_uncertainties",
+            ],
+            "additionalProperties": False,
+        },
+    }
+]
+
+TOOL_CHOICE = {"type": "tool", "name": "return_assessment"}

app.py

@@ -0,0 +1,13 @@
+import os
+import sys
+from pathlib import Path
+
+# Add the current directory to Python path
+sys.path.insert(0, str(Path(__file__).parent))
+
+# Import and run the FastAPI app from server.py
+from server import app
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

cli.py

@@ -0,0 +1,65 @@
+import argparse
+import os
+import sys
+from typing import Optional
+from dotenv import load_dotenv
+load_dotenv()
+
+from rich.console import Console
+from rich.panel import Panel
+
+from agents.evaluator import run_evaluation
+
+
+console = Console()
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="AI Automation Evaluator (LangGraph) — evaluate a paper PDF or arXiv URL",
+        epilog="Example: python cli.py https://arxiv.org/pdf/2507.14683 -o /abs/path/save_dir/eval_2507_14683",
+    )
+    parser.add_argument("pdf", help="Local PDF absolute path or URL (e.g., https://arxiv.org/pdf/xxxx)")
+    parser.add_argument(
+        "-o",
+        "--output-prefix",
+        dest="output_prefix",
+        help="Output file prefix (if provided, will save as <prefix>_YYYYMMDD_HHMMSS.md)",
+    )
+    parser.add_argument(
+        "--api-key",
+        dest="api_key",
+        default=os.getenv("ANTHROPIC_API_KEY"),
+        help="Anthropic API key (overrides ANTHROPIC_API_KEY env)",
+    )
+    return parser
+
+
+def main(argv: Optional[list[str]] = None):
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    pdf_path: str = args.pdf
+    output_prefix: Optional[str] = args.output_prefix
+    api_key: Optional[str] = args.api_key or os.getenv("ANTHROPIC_API_KEY")
+
+    if not api_key:
+        console.print("[yellow]Warning:[/yellow] ANTHROPIC_API_KEY not set and --api-key not provided.", highlight=False)
+
+    console.print(Panel.fit(f"Evaluating: {pdf_path}"))
+    try:
+        result = run_evaluation(pdf_path=pdf_path, output_file=output_prefix, api_key=api_key)
+        console.print("\n[bold green]Done.[/bold green]\n")
+        if output_prefix:
+            console.print(f"Saved to prefix: {output_prefix}_<timestamp>.md")
+        else:
+            console.print(result)
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+        sys.exit(2)
+
+
+if __name__ == "__main__":
+    main()
+
+

frontend/index.html

@@ -0,0 +1,88 @@
+<!doctype html>
+<html lang="en" data-theme="light">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>PaperIndex — Daily Papers</title>
+    <link rel="stylesheet" href="/styles.css?v=9" />
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
+  </head>
+  <body>
+    <!-- Navigation Bar -->
+    <nav class="navbar">
+      <div class="nav-container">
+        <div class="nav-left">
+          <div class="logo">
+            <i class="fas fa-book-open"></i>
+            <span>PaperIndex</span>
+          </div>
+        </div>
+        
+        <div class="nav-center">
+          <div class="search-container">
+            <i class="fas fa-search search-icon"></i>
+            <input type="text" placeholder="Search papers..." class="search-input">
+            <i class="fas fa-magic search-magic"></i>
+          </div>
+        </div>
+        
+        <div class="nav-right">
+          <button class="theme-toggle" id="themeToggle">
+            <i class="fas fa-sun light-icon"></i>
+            <i class="fas fa-moon dark-icon"></i>
+          </button>
+        </div>
+      </div>
+    </nav>
+
+    <!-- Main Header -->
+    <header class="main-header">
+      <div class="header-container">
+        <div class="header-left">
+          <h1>Daily Papers</h1>
+          <p class="subtitle">by PaperIndex and the research community</p>
+        </div>
+        
+        <div class="header-center">
+          <div class="ai-search-container">
+            <i class="fas fa-sparkles"></i>
+            <input type="text" placeholder="Search any paper with AI..." class="ai-search-input">
+            <i class="fas fa-cube"></i>
+          </div>
+        </div>
+        
+        <div class="header-right">
+          <div class="filter-buttons">
+            <button class="filter-btn active">Daily</button>
+            <button class="filter-btn">Weekly</button>
+            <button class="filter-btn">Monthly</button>
+            <button class="filter-btn star-btn">
+              <i class="fas fa-star"></i>
+            </button>
+          </div>
+          
+          <div class="date-navigation">
+            <button class="nav-btn" id="prevDate">
+              <i class="fas fa-chevron-left"></i>
+            </button>
+            <span class="date-display" id="dateDisplay"></span>
+            <button class="nav-btn" id="nextDate">
+              <i class="fas fa-chevron-right"></i>
+            </button>
+          </div>
+        </div>
+      </div>
+    </header>
+
+    <!-- Main Content -->
+    <main class="main-content">
+      <div class="content-container">
+        <section id="cards" class="cards-grid"></section>
+      </div>
+    </main>
+
+    <script src="/main.js"></script>
+  </body>
+</html>
+
+

frontend/main.js

@@ -0,0 +1,459 @@
+// Theme Management
+class ThemeManager {
+  constructor() {
+    this.theme = localStorage.getItem('theme') || 'light';
+    this.init();
+  }
+
+  init() {
+    document.documentElement.setAttribute('data-theme', this.theme);
+    this.updateThemeIcon();
+  }
+
+  toggle() {
+    this.theme = this.theme === 'light' ? 'dark' : 'light';
+    document.documentElement.setAttribute('data-theme', this.theme);
+    localStorage.setItem('theme', this.theme);
+    this.updateThemeIcon();
+  }
+
+  updateThemeIcon() {
+    const lightIcon = document.querySelector('.light-icon');
+    const darkIcon = document.querySelector('.dark-icon');
+    
+    if (this.theme === 'light') {
+      lightIcon.style.display = 'block';
+      darkIcon.style.display = 'none';
+    } else {
+      lightIcon.style.display = 'none';
+      darkIcon.style.display = 'block';
+    }
+  }
+}
+
+// Date Management
+class DateManager {
+  constructor() {
+    // Start with today's date, but it will be updated when we get the actual available date
+    this.currentDate = new Date();
+    this.init();
+  }
+
+  init() {
+    this.updateDateDisplay();
+    this.bindEvents();
+  }
+
+  formatDate(date) {
+    const options = { 
+      year: 'numeric', 
+      month: 'short', 
+      day: 'numeric' 
+    };
+    return date.toLocaleDateString('en-US', options);
+  }
+
+  updateDateDisplay() {
+    const dateDisplay = document.getElementById('dateDisplay');
+    dateDisplay.textContent = this.formatDate(this.currentDate);
+  }
+
+  navigateDate(direction) {
+    const newDate = new Date(this.currentDate);
+    newDate.setDate(newDate.getDate() + direction);
+    this.currentDate = newDate;
+    this.updateDateDisplay();
+    this.loadDaily();
+  }
+
+  bindEvents() {
+    document.getElementById('prevDate').addEventListener('click', () => {
+      this.navigateDate(-1);
+    });
+
+    document.getElementById('nextDate').addEventListener('click', () => {
+      this.navigateDate(1);
+    });
+  }
+
+  getDateString() {
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${this.currentDate.getFullYear()}-${pad(this.currentDate.getMonth()+1)}-${pad(this.currentDate.getDate())}`;
+  }
+}
+
+// Search Management
+class SearchManager {
+  constructor() {
+    this.init();
+  }
+
+  init() {
+    this.bindEvents();
+  }
+
+  bindEvents() {
+    const searchInput = document.querySelector('.search-input');
+    const aiSearchInput = document.querySelector('.ai-search-input');
+    
+    searchInput.addEventListener('input', (e) => {
+      this.handleSearch(e.target.value);
+    });
+
+    aiSearchInput.addEventListener('input', (e) => {
+      this.handleAISearch(e.target.value);
+    });
+  }
+
+  handleSearch(query) {
+    // Implement search functionality
+    console.log('Search query:', query);
+  }
+
+  handleAISearch(query) {
+    // Implement AI search functionality
+    console.log('AI search query:', query);
+  }
+}
+
+// Paper Card Renderer
+class PaperCardRenderer {
+  constructor() {
+    this.cardsContainer = document.getElementById('cards');
+  }
+
+  generateThumbnail(title) {
+    // Generate a simple thumbnail based on title
+    const canvas = document.createElement('canvas');
+    canvas.width = 400;
+    canvas.height = 120;
+    const ctx = canvas.getContext('2d');
+    
+    // Create gradient background
+    const gradient = ctx.createLinearGradient(0, 0, 400, 120);
+    gradient.addColorStop(0, '#3b82f6');
+    gradient.addColorStop(1, '#06b6d4');
+    ctx.fillStyle = gradient;
+    ctx.fillRect(0, 0, 400, 120);
+    
+    // Add text
+    ctx.fillStyle = 'rgba(255, 255, 255, 0.9)';
+    ctx.font = 'bold 16px -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif';
+    ctx.textAlign = 'center';
+    ctx.textBaseline = 'middle';
+    
+    const words = title.split(' ');
+    const lines = [];
+    let currentLine = '';
+    
+    for (const word of words) {
+      const testLine = currentLine + word + ' ';
+      const metrics = ctx.measureText(testLine);
+      if (metrics.width > 350 && currentLine !== '') {
+        lines.push(currentLine);
+        currentLine = word + ' ';
+      } else {
+        currentLine = testLine;
+      }
+    }
+    lines.push(currentLine);
+    
+    const yStart = 60 - (lines.length * 20) / 2;
+    lines.forEach((line, index) => {
+      ctx.fillText(line.trim(), 200, yStart + index * 20);
+    });
+    
+    return canvas.toDataURL();
+  }
+
+  generateAuthorAvatars(authorCount) {
+    const avatars = [];
+    const count = Math.min(authorCount, 5);
+    
+    for (let i = 0; i < count; i++) {
+      avatars.push(`<li title="Author ${i + 1}"></li>`);
+    }
+    
+    return avatars.join('');
+  }
+
+  renderCard(paper) {
+    const title = paper.title || 'Untitled Paper';
+    const abstract = paper.abstract || 'No abstract available';
+    const authors = paper.authors || [];
+    const authorCount = paper.author_count || authors.length || 0;
+    const upvotes = paper.upvotes || 0;
+    const githubStars = paper.github_stars || 0;
+    const comments = paper.comments || 0;
+    const submitter = paper.submitter || 'Anonymous';
+    
+    // Generate thumbnail URL - try to use HF thumbnail if available
+    const arxivId = paper.arxiv_id;
+    const thumbnailUrl = arxivId ? 
+      `https://cdn-thumbnails.huggingface.co/social-thumbnails/papers/${arxivId}.png` : 
+      this.generateThumbnail(title);
+    
+    const authorAvatars = this.generateAuthorAvatars(authorCount);
+    
+    const card = document.createElement('article');
+    card.className = 'hf-paper-card';
+    card.innerHTML = `
+      <a href="${paper.huggingface_url || '#'}" class="paper-thumbnail-link" target="_blank" rel="noreferrer">
+        <img src="${thumbnailUrl}" loading="lazy" decoding="async" alt="" class="paper-thumbnail-img">
+      </a>
+      
+      <div class="submitted-by-badge">
+        <span>Submitted by</span>
+        <div class="submitter-avatar-placeholder">
+          <i class="fas fa-user"></i>
+        </div>
+        ${submitter}
+      </div>
+      
+      <div class="card-content">
+        <div class="upvote-section">
+          <label class="upvote-button">
+            <input type="checkbox" class="upvote-checkbox">
+            <svg class="upvote-icon" xmlns="http://www.w3.org/2000/svg" aria-hidden="true" role="img" width="1em" height="1em" preserveAspectRatio="xMidYMid meet" viewBox="0 0 12 12">
+              <path fill="currentColor" d="M5.19 2.67a.94.94 0 0 1 1.62 0l3.31 5.72a.94.94 0 0 1-.82 1.4H2.7a.94.94 0 0 1-.82-1.4l3.31-5.7v-.02Z"></path>
+            </svg>
+            <div class="upvote-count">${upvotes}</div>
+          </label>
+        </div>
+        
+        <div class="paper-info">
+          <h3 class="paper-title">
+            <a href="${paper.huggingface_url || '#'}" class="title-link">
+              ${title}
+            </a>
+          </h3>
+          
+          <div class="paper-meta">
+            <div class="authors-section">
+              <a href="${paper.huggingface_url || '#'}" class="authors-link">
+                <ul class="author-avatars-list">
+                  ${authorAvatars}
+                </ul>
+                <div class="author-count">· ${authorCount} authors</div>
+              </a>
+            </div>
+            
+            <div class="engagement-metrics">
+              <a href="${paper.huggingface_url || '#'}" class="metric-link">
+                <svg class="github-icon" xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" role="img" width="1.03em" height="1em" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 250">
+                  <path d="M128.001 0C57.317 0 0 57.307 0 128.001c0 56.554 36.676 104.535 87.535 121.46c6.397 1.185 8.746-2.777 8.746-6.158c0-3.052-.12-13.135-.174-23.83c-35.61 7.742-43.124-15.103-43.124-15.103c-5.823-14.795-14.213-18.73-14.213-18.73c-11.613-7.944.876-7.78.876-7.78c12.853.902 19.621 13.19 19.621 13.19c11.417 19.568 29.945 13.911 37.249 10.64c1.149-8.272 4.466-13.92 8.127-17.116c-28.431-3.236-58.318-14.212-58.318-63.258c0-13.975 5-25.394 13.188-34.358c-1.329-3.224-5.71-16.242 1.24-33.874c0 0 10.749-3.44 35.21 13.121c10.21-2.836 21.16-4.258 32.038-4.307c10.878.049 21.837 1.47 32.066 4.307c24.431-16.56 35.165-13.12 35.165-13.12c6.967 17.63 2.584 30.65 1.255 33.873c8.207 8.964 13.173 20.383 13.173 34.358c0 49.163-29.944 59.988-58.447 63.157c4.591 3.972 8.682 11.762 8.682 23.704c0 17.126-.148 30.91-.148 35.126c0 3.407 2.304 7.398 8.792 6.14C219.37 232.5 256 184.537 256 128.002C256 57.307 198.691 0 128.001 0zm-80.06 182.34c-.282.636-1.283.827-2.194.39c-.929-.417-1.45-1.284-1.15-1.922c.276-.655 1.279-.838 2.205-.399c.93.418 1.46 1.293 1.139 1.931zm6.296 5.618c-.61.566-1.804.303-2.614-.591c-.837-.892-.994-2.086-.375-2.66c.63-.566 1.787-.301 2.626.591c.838.903 1 2.088.363 2.66zm4.32 7.188c-.785.545-2.067.034-2.86-1.104c-.784-1.138-.784-2.503.017-3.05c.795-.547 2.058-.055 2.861 1.075c.782 1.157.782 2.522-.019 3.08zm7.304 8.325c-.701.774-2.196.566-3.29-.49c-1.119-1.032-1.43-2.496-.726-3.27c.71-.776 2.213-.558 3.315.49c1.11 1.03 1.45 2.505.701 3.27zm9.442 2.81c-.31 1.003-1.75 1.459-3.199 1.033c-1.448-.439-2.395-1.613-2.103-2.626c.301-1.01 1.747-1.484 3.207-1.028c1.446.436 2.396 1.602 2.095 2.622zm10.744 1.193c.036 1.055-1.193 1.93-2.715 1.95c-1.53.034-2.769-.82-2.786-1.86c0-1.065 1.202-1.932 2.733-1.958c1.522-.03 2.768.818 2.768 1.868zm10.555-.405c.182 1.03-.875 2.088-2.387 2.37c-1.485.271-2.861-.365-3.05-1.386c-.184-1.056.893-2.114 2.376-2.387c1.514-.263 2.868.356 3.061 1.403z" fill="currentColor"></path>
+                </svg>
+                <span>${githubStars}</span>
+              </a>
+              <a href="${paper.huggingface_url || '#'}" class="metric-link">
+                <svg class="comment-icon" xmlns="http://www.w3.org/2000/svg" aria-hidden="true" role="img" width="1em" height="1em" preserveAspectRatio="xMidYMid meet" viewBox="0 0 24 24">
+                  <path fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path>
+                </svg>
+                <span>${comments}</span>
+              </a>
+            </div>
+          </div>
+        </div>
+      </div>
+      
+      ${paper.arxiv_id ? `
+        <div class="card-actions">
+          <a href="/paper.html?id=${encodeURIComponent(paper.arxiv_id)}" class="eval-button">
+            <i class="fas fa-chart-line"></i>Evaluation
+          </a>
+        </div>
+      ` : ''}
+    `;
+
+    return card;
+  }
+
+  renderCards(papers) {
+    this.cardsContainer.innerHTML = '';
+    
+    if (!papers || papers.length === 0) {
+      this.cardsContainer.innerHTML = `
+        <div style="grid-column: 1 / -1; text-align: center; padding: 48px; color: var(--text-muted);">
+          <i class="fas fa-search" style="font-size: 48px; margin-bottom: 16px; opacity: 0.5;"></i>
+          <h3>No papers found</h3>
+          <p>Try selecting a different date or check back later.</p>
+        </div>
+      `;
+      return;
+    }
+
+    papers.forEach(paper => {
+      const card = this.renderCard(paper);
+      this.cardsContainer.appendChild(card);
+    });
+  }
+}
+
+// Main Application
+class PaperIndexApp {
+  constructor() {
+    this.themeManager = new ThemeManager();
+    this.dateManager = new DateManager();
+    this.searchManager = new SearchManager();
+    this.cardRenderer = new PaperCardRenderer();
+    this.init();
+  }
+
+  init() {
+    this.bindEvents();
+    this.loadDaily();
+  }
+
+  bindEvents() {
+    // Theme toggle
+    document.getElementById('themeToggle').addEventListener('click', () => {
+      this.themeManager.toggle();
+    });
+
+    // Filter buttons
+    document.querySelectorAll('.filter-btn').forEach(btn => {
+      btn.addEventListener('click', (e) => {
+        document.querySelectorAll('.filter-btn').forEach(b => b.classList.remove('active'));
+        e.target.classList.add('active');
+      });
+    });
+  }
+
+  async loadDaily() {
+    const dateStr = this.dateManager.getDateString();
+    
+    try {
+      const response = await fetch(`/api/daily?date_str=${encodeURIComponent(dateStr)}`);
+      
+      if (!response.ok) {
+        throw new Error('Failed to load daily papers');
+      }
+      
+      const data = await response.json();
+      
+      console.log('API Response:', {
+        requested_date: data.requested_date,
+        actual_date: data.date,
+        fallback_used: data.fallback_used,
+        cards_count: data.cards?.length
+      });
+      
+      // Update the date display if a fallback was used or if we got a different date than requested
+      if (data.date && data.requested_date && data.date !== data.requested_date) {
+        console.log('Updating date display from', data.requested_date, 'to', data.date);
+        const fallbackDate = new Date(data.date);
+        this.dateManager.currentDate = fallbackDate;
+        this.dateManager.updateDateDisplay();
+        
+        // Show a notification about the fallback
+        this.showFallbackNotification(data.requested_date, data.date);
+      }
+      
+      // Show cache status if available
+      if (data.cached) {
+        this.showCacheNotification(data.cached_at);
+      }
+      
+      this.cardRenderer.renderCards(data.cards || []);
+      
+    } catch (error) {
+      console.error('Error loading papers:', error);
+      this.cardRenderer.renderCards([]);
+      
+      // Show fallback message
+      this.cardRenderer.cardsContainer.innerHTML = `
+        <div style="grid-column: 1 / -1; text-align: center; padding: 48px; color: var(--text-muted);">
+          <i class="fas fa-exclamation-triangle" style="font-size: 48px; margin-bottom: 16px; opacity: 0.5;"></i>
+          <h3>Unable to load papers</h3>
+          <p>Backend unavailable on static hosting. Try opening the daily page on Hugging Face:</p>
+          <a class="action-btn primary" href="https://huggingface.co/papers/date/${encodeURIComponent(dateStr)}" target="_blank" rel="noreferrer">
+            <i class="fas fa-external-link-alt"></i>Open on Hugging Face
+          </a>
+        </div>
+      `;
+    }
+  }
+
+  showFallbackNotification(requestedDate, actualDate) {
+    // Create a temporary notification
+    const notification = document.createElement('div');
+    notification.style.cssText = `
+      position: fixed;
+      top: 20px;
+      right: 20px;
+      background: var(--bg-primary);
+      border: 1px solid var(--border-medium);
+      border-radius: 8px;
+      padding: 16px;
+      box-shadow: var(--shadow-lg);
+      z-index: 1000;
+      max-width: 300px;
+      color: var(--text-primary);
+    `;
+    
+    notification.innerHTML = `
+      <div style="display: flex; align-items: center; gap: 8px; margin-bottom: 8px;">
+        <i class="fas fa-info-circle" style="color: var(--accent-primary);"></i>
+        <strong>Date Updated</strong>
+      </div>
+      <p style="margin: 0; font-size: 14px; color: var(--text-secondary);">
+        Papers for ${requestedDate} not available. Showing latest available: ${actualDate}
+      </p>
+    `;
+    
+    document.body.appendChild(notification);
+    
+    // Remove notification after 5 seconds
+    setTimeout(() => {
+      if (notification.parentNode) {
+        notification.parentNode.removeChild(notification);
+      }
+    }, 5000);
+  }
+
+  showCacheNotification(cachedAt) {
+    // Create a temporary notification
+    const notification = document.createElement('div');
+    notification.style.cssText = `
+      position: fixed;
+      top: 20px;
+      right: 20px;
+      background: var(--bg-primary);
+      border: 1px solid var(--border-medium);
+      border-radius: 8px;
+      padding: 16px;
+      box-shadow: var(--shadow-lg);
+      z-index: 1000;
+      max-width: 300px;
+      color: var(--text-primary);
+    `;
+    
+    const cacheTime = new Date(cachedAt).toLocaleString();
+    
+    notification.innerHTML = `
+      <div style="display: flex; align-items: center; gap: 8px; margin-bottom: 8px;">
+        <i class="fas fa-database" style="color: var(--accent-success);"></i>
+        <strong>Cached Data</strong>
+      </div>
+      <p style="margin: 0; font-size: 14px; color: var(--text-secondary);">
+        Showing cached data from ${cacheTime}
+      </p>
+    `;
+    
+    document.body.appendChild(notification);
+    
+    // Remove notification after 3 seconds
+    setTimeout(() => {
+      if (notification.parentNode) {
+        notification.parentNode.removeChild(notification);
+      }
+    }, 3000);
+  }
+}
+
+// Initialize the application when DOM is loaded
+document.addEventListener('DOMContentLoaded', () => {
+  new PaperIndexApp();
+});
+
+

frontend/paper.html

@@ -0,0 +1,88 @@
+<!doctype html>
+<html lang="en" data-theme="light">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Paper Evaluation</title>
+    <link rel="stylesheet" href="/styles.css?v=9" />
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
+  </head>
+  <body>
+    <!-- Navigation Bar -->
+    <nav class="navbar">
+      <div class="nav-container">
+        <div class="nav-left">
+          <a href="/" class="back-link">
+            <i class="fas fa-arrow-left"></i>
+            <span>Back to Daily Papers</span>
+          </a>
+        </div>
+        
+        <div class="nav-center">
+          <div class="page-title">
+            <i class="fas fa-chart-line"></i>
+            <span>Paper Evaluation</span>
+          </div>
+        </div>
+        
+        <div class="nav-right">
+          <button class="theme-toggle" id="themeToggle">
+            <i class="fas fa-sun light-icon"></i>
+            <i class="fas fa-moon dark-icon"></i>
+          </button>
+        </div>
+      </div>
+    </nav>
+
+    <!-- Main Content -->
+    <main class="paper-main">
+      <div class="paper-container">
+        <!-- Paper Header -->
+        <div class="paper-header">
+          <div class="paper-meta">
+            <h1 id="title">Paper Evaluation</h1>
+            <div class="meta-grid" id="metaGrid">
+              <!-- Meta information will be populated by JavaScript -->
+            </div>
+          </div>
+        </div>
+
+        <!-- Content Layout -->
+        <div class="content-layout">
+          <!-- Main Content -->
+          <div class="main-content">
+            <article id="content" class="evaluation-content">
+              <!-- Content will be populated by JavaScript -->
+            </article>
+          </div>
+
+          <!-- Sidebar -->
+          <aside class="sidebar">
+            <div class="scorecard-panel">
+              <div class="panel-header">
+                <h2><i class="fas fa-radar"></i> Scorecard</h2>
+                <div class="overall-score" id="overallScore">
+                  <span class="score-number">-</span>
+                  <span class="score-label">Overall</span>
+                </div>
+              </div>
+              <div class="radar-container">
+                <canvas id="radar" width="280" height="280"></canvas>
+              </div>
+              <div class="radar-legend">
+                <h3>Dimensions</h3>
+                <ul id="radar-legend" class="legend-list">
+                  <!-- Legend will be populated by JavaScript -->
+                </ul>
+              </div>
+            </div>
+          </aside>
+        </div>
+      </div>
+    </main>
+
+    <script src="/paper.js"></script>
+  </body>
+</html>
+
+

frontend/paper.js

@@ -0,0 +1,578 @@
+// Theme Management
+class ThemeManager {
+  constructor() {
+    this.theme = localStorage.getItem('theme') || 'light';
+    this.init();
+  }
+
+  init() {
+    document.documentElement.setAttribute('data-theme', this.theme);
+    this.updateThemeIcon();
+  }
+
+  toggle() {
+    this.theme = this.theme === 'light' ? 'dark' : 'light';
+    document.documentElement.setAttribute('data-theme', this.theme);
+    localStorage.setItem('theme', this.theme);
+    this.updateThemeIcon();
+  }
+
+  updateThemeIcon() {
+    const lightIcon = document.querySelector('.light-icon');
+    const darkIcon = document.querySelector('.dark-icon');
+    
+    if (this.theme === 'light') {
+      lightIcon.style.display = 'block';
+      darkIcon.style.display = 'none';
+    } else {
+      lightIcon.style.display = 'none';
+      darkIcon.style.display = 'block';
+    }
+  }
+}
+
+// Utility functions
+function getParam(name) {
+  const url = new URL(window.location.href);
+  return url.searchParams.get(name);
+}
+
+function esc(s) {
+  return String(s).replace(/[&<>"]/g, (c) => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c]));
+}
+
+function parseMaybeJSON(str) {
+  if (typeof str !== 'string') return str;
+  try {
+    return JSON.parse(str);
+  } catch (e) {
+    const start = str.indexOf('{');
+    const end = str.lastIndexOf('}');
+    if (start !== -1 && end !== -1 && end > start) {
+      const sliced = str.slice(start, end + 1);
+      try { return JSON.parse(sliced); } catch {}
+    }
+  }
+  return str;
+}
+
+// Paper Evaluation Renderer
+class PaperEvaluationRenderer {
+  constructor() {
+    this.themeManager = new ThemeManager();
+    this.init();
+  }
+
+  init() {
+    this.bindEvents();
+  }
+
+  bindEvents() {
+    // Theme toggle
+    const themeToggle = document.getElementById('themeToggle');
+    if (themeToggle) {
+      themeToggle.addEventListener('click', () => {
+        this.themeManager.toggle();
+      });
+    }
+  }
+
+  renderMetaGrid(meta) {
+    const metaGrid = document.getElementById('metaGrid');
+    if (!metaGrid) return;
+    
+    const metaItems = [
+      { label: 'Assessed At', value: meta.assessed_at || '-', icon: 'fas fa-calendar' },
+      { label: 'Model', value: meta.model || '-', icon: 'fas fa-robot' },
+      { label: 'Version', value: meta.version || '-', icon: 'fas fa-tag' },
+      { label: 'Paper Path', value: meta.paper_path || '-', icon: 'fas fa-file-pdf', isLink: true }
+    ];
+
+    metaGrid.innerHTML = metaItems.map(item => `
+      <div class="meta-item">
+        <span class="meta-label">
+          <i class="${item.icon}"></i>
+          ${item.label}
+        </span>
+        <span class="meta-value">
+          ${item.isLink && item.value !== '-' ? 
+            `<a href="${esc(item.value)}" target="_blank">${esc(item.value)}</a>` : 
+            esc(item.value)
+          }
+        </span>
+      </div>
+    `).join('');
+  }
+
+  renderDimensionCard(label, key, data, icon = 'fas fa-chart-bar') {
+    const item = data[key] || {};
+    const score = item.score !== undefined ? item.score : null;
+    const probability = item.probability_pct !== undefined ? item.probability_pct : null;
+    const analysis = item.analysis || '';
+    
+    const extras = [];
+    if (Array.isArray(item.tools_models)) {
+      extras.push(`<span class="meta-item"><i class="fas fa-tools"></i> Tools/Models: ${item.tools_models.map(esc).join(', ')}</span>`);
+    }
+    if (item.coverage_pct_estimate !== undefined) {
+      extras.push(`<span class="meta-item"><i class="fas fa-percentage"></i> Coverage: ${esc(item.coverage_pct_estimate)}%</span>`);
+    }
+
+    return `
+      <div class="dimension-card">
+        <div class="dimension-header">
+          <div class="dimension-title">
+            <i class="${icon}"></i>
+            ${esc(label)}
+          </div>
+          <div class="dimension-score">
+            ${score !== null ? `<span class="score-badge">${score}</span>` : ''}
+            ${probability !== null ? `<span class="score-badge probability">${probability}%</span>` : ''}
+          </div>
+        </div>
+        ${extras.length > 0 ? `<div class="dimension-meta">${extras.join('')}</div>` : ''}
+        ${analysis ? `<div class="dimension-analysis">${esc(analysis).replace(/\n/g, '<br/>')}</div>` : ''}
+      </div>
+    `;
+  }
+
+  renderContent(json) {
+    const contentEl = document.getElementById('content');
+    const titleEl = document.getElementById('title');
+    if (!contentEl || !titleEl) return;
+    
+    const meta = json.metadata || {};
+    const paperId = getParam('id');
+    
+    // Update title with paper ID
+    titleEl.textContent = `Paper Evaluation - ${paperId}`;
+    
+    // Render meta grid
+    this.renderMetaGrid(meta);
+
+    // Executive Summary - styled like Hugging Face abstract
+    const execSummary = json.executive_summary ? `
+      <section class="evaluation-section">
+        <div class="section-header">
+          <h2><i class="fas fa-chart-pie"></i> Executive Summary</h2>
+        </div>
+        <div class="section-content">
+          <div class="summary-card">
+            <p class="summary-text">${esc(json.executive_summary)}</p>
+          </div>
+        </div>
+      </section>
+    ` : '';
+
+    // Dimensions - create beautiful cards
+    const d = parseMaybeJSON(json.dimensions) || {};
+    const dims = [
+      ['Task Formalization', 'task_formalization', 'fas fa-tasks'],
+      ['Data & Resource Availability', 'data_resource_availability', 'fas fa-database'],
+      ['Input-Output Complexity', 'input_output_complexity', 'fas fa-exchange-alt'],
+      ['Real-World Interaction', 'real_world_interaction', 'fas fa-globe'],
+      ['Existing AI Coverage', 'existing_ai_coverage', 'fas fa-robot'],
+      ['Automation Barriers', 'automation_barriers', 'fas fa-shield-alt'],
+      ['Human Originality', 'human_originality', 'fas fa-lightbulb'],
+      ['Safety & Ethics', 'safety_ethics', 'fas fa-balance-scale'],
+      ['Societal/Economic Impact', 'societal_economic_impact', 'fas fa-chart-line'],
+      ['Technical Maturity Needed', 'technical_maturity_needed', 'fas fa-cogs'],
+      ['3-Year Feasibility', 'three_year_feasibility', 'fas fa-calendar-alt'],
+      ['Overall Automatability', 'overall_automatability', 'fas fa-magic'],
+    ];
+
+    const dimensionsHtml = dims.map(([label, key, icon]) => 
+      this.renderDimensionCard(label, key, d, icon)
+    ).join('');
+
+    // Recommendations - styled sections
+    const rec = json.recommendations || {};
+    const renderList = (arr) => {
+      return Array.isArray(arr) && arr.length ? 
+        `<ul class="recommendation-list">${arr.map(x => `<li>${esc(x)}</li>`).join('')}</ul>` : 
+        '<p class="no-data">No recommendations available.</p>';
+    };
+
+    const recommendationsHtml = `
+      <section class="evaluation-section">
+        <div class="section-header">
+          <h2><i class="fas fa-lightbulb"></i> Recommendations</h2>
+        </div>
+        <div class="section-content">
+          <div class="recommendations-grid">
+            <div class="recommendation-card">
+              <h3><i class="fas fa-user-graduate"></i> For Researchers</h3>
+              ${renderList(rec.for_researchers)}
+            </div>
+            <div class="recommendation-card">
+              <h3><i class="fas fa-university"></i> For Institutions</h3>
+              ${renderList(rec.for_institutions)}
+            </div>
+            <div class="recommendation-card">
+              <h3><i class="fas fa-cogs"></i> For AI Development</h3>
+              ${renderList(rec.for_ai_development)}
+            </div>
+          </div>
+        </div>
+      </section>
+    `;
+
+    // Limitations
+    const lim = Array.isArray(json.limitations_uncertainties) ? json.limitations_uncertainties : [];
+    const limitationsHtml = `
+      <section class="evaluation-section">
+        <div class="section-header">
+          <h2><i class="fas fa-exclamation-triangle"></i> Limitations & Uncertainties</h2>
+        </div>
+        <div class="section-content">
+          <div class="limitations-card">
+            ${lim.length ? `<ul class="limitations-list">${lim.map(x => `<li>${esc(x)}</li>`).join('')}</ul>` : '<p class="no-data">No limitations documented.</p>'}
+          </div>
+        </div>
+      </section>
+    `;
+
+    contentEl.innerHTML = execSummary + 
+      `<section class="evaluation-section">
+        <div class="section-header">
+          <h2><i class="fas fa-chart-bar"></i> Detailed Dimensional Analysis</h2>
+        </div>
+        <div class="section-content">
+          <div class="dimensions-grid">
+            ${dimensionsHtml}
+          </div>
+        </div>
+      </section>` + 
+      recommendationsHtml + 
+      limitationsHtml;
+  }
+
+  updateRadarChart(json) {
+    const radarEl = document.getElementById('radar');
+    const legendEl = document.getElementById('radar-legend');
+    const overallScoreEl = document.getElementById('overallScore');
+    
+    if (!radarEl) return;
+    
+    try {
+      const score = json.scorecard || {};
+      const d = parseMaybeJSON(json.dimensions) || {};
+      
+      const labels = [
+        'Task Formalization',
+        'Data & Resources',
+        'Input-Output Complexity',
+        'Real-World Interaction',
+        'Existing AI Coverage',
+        'Human Originality',
+        'Safety & Ethics',
+        'Technical Maturity',
+        '3-Year Feasibility',
+        'Overall Automatability',
+      ];
+      
+      const values = [
+        Number(score.task_formalization ?? d.task_formalization?.score ?? 0),
+        Number(score.data_resource_availability ?? d.data_resource_availability?.score ?? 0),
+        Number(score.input_output_complexity ?? d.input_output_complexity?.score ?? 0),
+        Number(score.real_world_interaction ?? d.real_world_interaction?.score ?? 0),
+        Number(score.existing_ai_coverage ?? d.existing_ai_coverage?.score ?? 0),
+        Number(score.human_originality ?? d.human_originality?.score ?? 0),
+        Number(score.safety_ethics ?? d.safety_ethics?.score ?? 0),
+        Number(score.technical_maturity_needed ?? d.technical_maturity_needed?.score ?? 0),
+        Number((score.three_year_feasibility_pct ?? d.three_year_feasibility?.probability_pct ?? 0) / 25),
+        Number(score.overall_automatability ?? d.overall_automatability?.score ?? 0),
+      ];
+
+      // Calculate overall score
+      const validScores = values.filter(v => v > 0);
+      const overallScore = validScores.length > 0 ? 
+        (validScores.reduce((a, b) => a + b, 0) / validScores.length).toFixed(1) : '-';
+      
+      if (overallScoreEl) {
+        overallScoreEl.innerHTML = `
+          <span class="score-number">${overallScore}</span>
+          <span class="score-label">Overall</span>
+        `;
+      }
+
+      this.drawRadar(radarEl, labels, values, 4);
+      this.setupRadarInteractions(radarEl);
+      
+      if (legendEl) {
+        const labelConfig = [
+          { abbr: 'TASK', color: '#3b82f6', full: 'Task Formalization' },
+          { abbr: 'DATA', color: '#10b981', full: 'Data & Resources' },
+          { abbr: 'I/O', color: '#f59e0b', full: 'Input-Output Complexity' },
+          { abbr: 'REAL', color: '#8b5cf6', full: 'Real-World Interaction' },
+          { abbr: 'AI', color: '#ef4444', full: 'Existing AI Coverage' },
+          { abbr: 'HUMAN', color: '#06b6d4', full: 'Human Originality' },
+          { abbr: 'SAFETY', color: '#84cc16', full: 'Safety & Ethics' },
+          { abbr: 'TECH', color: '#f97316', full: 'Technical Maturity' },
+          { abbr: '3YR', color: '#ec4899', full: '3-Year Feasibility' },
+          { abbr: 'AUTO', color: '#6366f1', full: 'Overall Automatability' }
+        ];
+        
+        legendEl.innerHTML = `
+          <ul class="legend-list">
+            ${labelConfig.map(config => `
+              <li>
+                <span class="legend-color" style="background-color: ${config.color}"></span>
+                <span class="legend-abbr" style="color: ${config.color}; font-weight: bold;">${config.abbr}</span>
+                <span class="legend-full">${esc(config.full)}</span>
+              </li>
+            `).join('')}
+          </ul>
+        `;
+      }
+    } catch (error) {
+      console.error('Error updating radar chart:', error);
+    }
+  }
+
+  setupRadarInteractions(canvas) {
+    if (!canvas || !this.dotPositions) return;
+    
+    // Create tooltip element
+    let tooltip = document.getElementById('radar-tooltip');
+    if (!tooltip) {
+      tooltip = document.createElement('div');
+      tooltip.id = 'radar-tooltip';
+      tooltip.className = 'radar-tooltip';
+      document.body.appendChild(tooltip);
+    }
+    
+    const handleMouseMove = (e) => {
+      const rect = canvas.getBoundingClientRect();
+      const x = e.clientX - rect.left;
+      const y = e.clientY - rect.top;
+      
+      // Check if mouse is near any dot
+      let hoveredDot = null;
+      const hoverRadius = 15;
+      
+      for (const dot of this.dotPositions) {
+        const distance = Math.sqrt((x - dot.x) ** 2 + (y - dot.y) ** 2);
+        if (distance <= hoverRadius) {
+          hoveredDot = dot;
+          break;
+        }
+      }
+      
+      if (hoveredDot) {
+        tooltip.style.display = 'block';
+        tooltip.style.left = e.clientX + 10 + 'px';
+        tooltip.style.top = e.clientY - 30 + 'px';
+        tooltip.innerHTML = `
+          <div class="tooltip-content">
+            <span class="tooltip-abbr" style="color: ${hoveredDot.config.color}">${hoveredDot.config.abbr}</span>
+            <span class="tooltip-full">${hoveredDot.config.full || ''}</span>
+          </div>
+        `;
+        canvas.style.cursor = 'pointer';
+      } else {
+        tooltip.style.display = 'none';
+        canvas.style.cursor = 'default';
+      }
+    };
+    
+    const handleMouseLeave = () => {
+      tooltip.style.display = 'none';
+      canvas.style.cursor = 'default';
+    };
+    
+    // Remove existing listeners
+    canvas.removeEventListener('mousemove', handleMouseMove);
+    canvas.removeEventListener('mouseleave', handleMouseLeave);
+    
+    // Add new listeners
+    canvas.addEventListener('mousemove', handleMouseMove);
+    canvas.addEventListener('mouseleave', handleMouseLeave);
+  }
+
+  drawRadar(canvas, labels, values, maxValue) {
+    if (!canvas || !canvas.getContext) return;
+    
+    const ctx = canvas.getContext('2d');
+    const w = canvas.width, h = canvas.height;
+    ctx.clearRect(0, 0, w, h);
+    
+    const cx = w / 2, cy = h / 2, radius = Math.min(w, h) * 0.42;
+    const n = values.length;
+    const angleStep = (Math.PI * 2) / n;
+
+    // Get theme colors
+    const isDark = document.documentElement.getAttribute('data-theme') === 'dark';
+    const gridColor = isDark ? '#475569' : '#e2e8f0';
+    const axisColor = isDark ? '#64748b' : '#cbd5e1';
+    const fillColor = isDark ? 'rgba(34, 211, 238, 0.2)' : 'rgba(59, 130, 246, 0.2)';
+    const strokeColor = isDark ? '#22d3ee' : '#3b82f6';
+    const textColor = isDark ? '#e2e8f0' : '#475569';
+    
+    // Define colors and abbreviations for each dimension
+    const labelConfig = [
+      { color: '#3b82f6', abbr: 'TASK' },      // Task Formalization
+      { color: '#10b981', abbr: 'DATA' },      // Data & Resources
+      { color: '#f59e0b', abbr: 'I/O' },       // Input-Output Complexity
+      { color: '#8b5cf6', abbr: 'REAL' },      // Real-World Interaction
+      { color: '#ef4444', abbr: 'AI' },        // Existing AI Coverage
+      { color: '#06b6d4', abbr: 'HUMAN' },     // Human Originality
+      { color: '#84cc16', abbr: 'SAFETY' },    // Safety & Ethics
+      { color: '#f97316', abbr: 'TECH' },      // Technical Maturity
+      { color: '#ec4899', abbr: '3YR' },       // 3-Year Feasibility
+      { color: '#6366f1', abbr: 'AUTO' }       // Overall Automatability
+    ];
+
+    // Store dot positions for mouse interaction
+    this.dotPositions = [];
+
+    // Draw grid (5 rings)
+    ctx.strokeStyle = gridColor;
+    ctx.lineWidth = 1;
+    for (let r = 1; r <= 5; r++) {
+      const rr = (radius * r) / 5;
+      ctx.beginPath();
+      for (let i = 0; i < n; i++) {
+        const ang = i * angleStep - Math.PI / 2;
+        const x = cx + rr * Math.cos(ang);
+        const y = cy + rr * Math.sin(ang);
+        if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
+      }
+      ctx.closePath();
+      ctx.stroke();
+    }
+
+    // Draw axes
+    ctx.strokeStyle = axisColor;
+    for (let i = 0; i < n; i++) {
+      const ang = i * angleStep - Math.PI / 2;
+      const x = cx + radius * Math.cos(ang);
+      const y = cy + radius * Math.sin(ang);
+      ctx.beginPath();
+      ctx.moveTo(cx, cy);
+      ctx.lineTo(x, y);
+      ctx.stroke();
+    }
+
+    // Draw polygon
+    ctx.fillStyle = fillColor;
+    ctx.strokeStyle = strokeColor;
+    ctx.lineWidth = 2;
+    ctx.beginPath();
+    for (let i = 0; i < n; i++) {
+      const v = Math.max(0, Math.min(maxValue, Number(values[i] || 0)));
+      const r = (v / maxValue) * radius;
+      const ang = i * angleStep - Math.PI / 2;
+      const x = cx + r * Math.cos(ang);
+      const y = cy + r * Math.sin(ang);
+      if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
+    }
+    ctx.closePath();
+    ctx.fill();
+    ctx.stroke();
+
+    // Draw axis endpoints with colored dots and store positions
+    for (let i = 0; i < n; i++) {
+      const ang = i * angleStep - Math.PI / 2;
+      const x = cx + radius * Math.cos(ang);
+      const y = cy + radius * Math.sin(ang);
+      
+      // Store position for mouse interaction
+      this.dotPositions[i] = { x, y, index: i, config: labelConfig[i] };
+      
+      // Draw colored dot at the end of each axis
+      const dotRadius = 6; // Slightly larger for better hover detection
+      ctx.fillStyle = labelConfig[i]?.color || textColor;
+      ctx.beginPath();
+      ctx.arc(x, y, dotRadius, 0, Math.PI * 2);
+      ctx.fill();
+      
+      // Draw white border around dot
+      ctx.strokeStyle = isDark ? '#1e293b' : '#ffffff';
+      ctx.lineWidth = 2;
+      ctx.stroke();
+    }
+  }
+
+  render(json) {
+    this.renderContent(json);
+    this.updateRadarChart(json);
+  }
+}
+
+// Main Application
+class PaperEvaluationApp {
+  constructor() {
+    this.renderer = new PaperEvaluationRenderer();
+    this.init();
+  }
+
+  async init() {
+    const id = getParam('id');
+    console.log('PaperEvaluationApp init with ID:', id);
+    
+    if (!id) {
+      const contentEl = document.getElementById('content');
+      if (contentEl) {
+        contentEl.innerHTML = `
+          <div style="text-align: center; padding: 48px; color: var(--text-muted);">
+            <i class="fas fa-exclamation-triangle" style="font-size: 48px; margin-bottom: 16px; opacity: 0.5;"></i>
+            <h3>Missing Paper ID</h3>
+            <p>Please provide a valid paper ID in the URL.</p>
+          </div>
+        `;
+      }
+      return;
+    }
+
+    try {
+      console.log('Fetching evaluation for ID:', id);
+      const response = await fetch(`/api/eval/${encodeURIComponent(id)}`);
+      console.log('Response status:', response.status);
+      
+      if (!response.ok) {
+        throw new Error(`Evaluation not found: ${response.status}`);
+      }
+      
+      const json = await response.json();
+      console.log('Received JSON data:', Object.keys(json));
+      
+      // Fix stringified dimensions
+      if (json && typeof json.dimensions === 'string') {
+        try { 
+          json.dimensions = JSON.parse(json.dimensions); 
+          console.log('Successfully parsed dimensions JSON');
+        } catch (e) {
+          console.warn('Failed to parse dimensions JSON:', e);
+        }
+      }
+      
+      console.log('Rendering evaluation...');
+      this.renderer.render(json);
+      console.log('Evaluation rendered successfully');
+      
+    } catch (error) {
+      console.error('Error loading evaluation:', error);
+      const contentEl = document.getElementById('content');
+      if (contentEl) {
+        contentEl.innerHTML = `
+          <div style="text-align: center; padding: 48px; color: var(--text-muted);">
+            <i class="fas fa-exclamation-triangle" style="font-size: 48px; margin-bottom: 16px; opacity: 0.5;"></i>
+            <h3>Evaluation Not Found</h3>
+            <p>The requested evaluation could not be loaded: ${error.message}</p>
+            <a href="/" class="action-btn primary" style="margin-top: 16px; display: inline-flex; align-items: center; gap: 8px;">
+              <i class="fas fa-arrow-left"></i>Back to Daily Papers
+            </a>
+          </div>
+        `;
+      }
+    }
+  }
+}
+
+// Initialize the application when DOM is loaded
+document.addEventListener('DOMContentLoaded', () => {
+  new PaperEvaluationApp();
+});
+
+

frontend/styles.css

@@ -0,0 +1,1375 @@
+/* CSS Variables for Theme Switching */
+:root {
+  /* Light Theme */
+  --bg-primary: #ffffff;
+  --bg-secondary: #f8fafc;
+  --bg-tertiary: #f1f5f9;
+  --text-primary: #0f172a;
+  --text-secondary: #475569;
+  --text-muted: #64748b;
+  --border-light: #e2e8f0;
+  --border-medium: #cbd5e1;
+  --accent-primary: #3b82f6;
+  --accent-secondary: #06b6d4;
+  --accent-success: #10b981;
+  --accent-warning: #f59e0b;
+  --accent-danger: #ef4444;
+  --shadow-sm: 0 1px 2px 0 rgb(0 0 0 / 0.05);
+  --shadow-md: 0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1);
+  --shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1);
+  --shadow-xl: 0 20px 25px -5px rgb(0 0 0 / 0.1), 0 8px 10px -6px rgb(0 0 0 / 0.1);
+}
+
+[data-theme="dark"] {
+  /* Dark Theme */
+  --bg-primary: #0f172a;
+  --bg-secondary: #1e293b;
+  --bg-tertiary: #334155;
+  --text-primary: #f8fafc;
+  --text-secondary: #cbd5e1;
+  --text-muted: #94a3b8;
+  --border-light: #334155;
+  --border-medium: #475569;
+  --accent-primary: #60a5fa;
+  --accent-secondary: #22d3ee;
+  --accent-success: #34d399;
+  --accent-warning: #fbbf24;
+  --accent-danger: #f87171;
+  --shadow-sm: 0 1px 2px 0 rgb(0 0 0 / 0.3);
+  --shadow-md: 0 4px 6px -1px rgb(0 0 0 / 0.3), 0 2px 4px -2px rgb(0 0 0 / 0.3);
+  --shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.3), 0 4px 6px -4px rgb(0 0 0 / 0.3);
+  --shadow-xl: 0 20px 25px -5px rgb(0 0 0 / 0.3), 0 8px 10px -6px rgb(0 0 0 / 0.3);
+}
+
+/* Reset and Base Styles */
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+  background-color: var(--bg-primary);
+  color: var(--text-primary);
+  line-height: 1.6;
+  transition: background-color 0.3s ease, color 0.3s ease;
+}
+
+/* Navigation Bar */
+.navbar {
+  background-color: var(--bg-primary);
+  border-bottom: 1px solid var(--border-light);
+  position: sticky;
+  top: 0;
+  z-index: 1000;
+  box-shadow: var(--shadow-sm);
+}
+
+.nav-container {
+  max-width: 1400px;
+  margin: 0 auto;
+  padding: 0 24px;
+  height: 64px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+
+.nav-left .logo {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  font-size: 20px;
+  font-weight: 700;
+  color: var(--text-primary);
+}
+
+.logo i {
+  color: var(--accent-primary);
+  font-size: 24px;
+}
+
+.nav-center {
+  flex: 1;
+  max-width: 600px;
+  margin: 0 48px;
+}
+
+.search-container {
+  position: relative;
+  width: 100%;
+}
+
+.search-input {
+  width: 100%;
+  padding: 12px 48px;
+  border: 1px solid var(--border-medium);
+  border-radius: 12px;
+  background-color: var(--bg-secondary);
+  color: var(--text-primary);
+  font-size: 14px;
+  transition: all 0.2s ease;
+}
+
+.search-input:focus {
+  outline: none;
+  border-color: var(--accent-primary);
+  box-shadow: 0 0 0 3px rgb(59 130 246 / 0.1);
+}
+
+.search-icon {
+  position: absolute;
+  left: 16px;
+  top: 50%;
+  transform: translateY(-50%);
+  color: var(--text-muted);
+  font-size: 14px;
+}
+
+.search-magic {
+  position: absolute;
+  right: 16px;
+  top: 50%;
+  transform: translateY(-50%);
+  color: var(--accent-secondary);
+  font-size: 14px;
+  cursor: pointer;
+}
+
+.theme-toggle {
+  background: none;
+  border: none;
+  padding: 8px;
+  border-radius: 8px;
+  cursor: pointer;
+  color: var(--text-secondary);
+  transition: all 0.2s ease;
+  position: relative;
+  width: 40px;
+  height: 40px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.theme-toggle:hover {
+  background-color: var(--bg-secondary);
+  color: var(--text-primary);
+}
+
+.theme-toggle .light-icon {
+  display: block;
+}
+
+.theme-toggle .dark-icon {
+  display: none;
+}
+
+[data-theme="dark"] .theme-toggle .light-icon {
+  display: none;
+}
+
+[data-theme="dark"] .theme-toggle .dark-icon {
+  display: block;
+}
+
+/* Main Header */
+.main-header {
+  background-color: var(--bg-primary);
+  border-bottom: 1px solid var(--border-light);
+  padding: 32px 0;
+}
+
+.header-container {
+  max-width: 1400px;
+  margin: 0 auto;
+  padding: 0 24px;
+  display: grid;
+  grid-template-columns: 1fr 2fr 1fr;
+  gap: 32px;
+  align-items: center;
+}
+
+.header-left h1 {
+  font-size: 32px;
+  font-weight: 800;
+  color: var(--text-primary);
+  margin-bottom: 8px;
+}
+
+.subtitle {
+  color: var(--text-secondary);
+  font-size: 16px;
+}
+
+.ai-search-container {
+  position: relative;
+  width: 100%;
+}
+
+.ai-search-input {
+  width: 100%;
+  padding: 16px 48px;
+  border: 1px solid var(--border-medium);
+  border-radius: 16px;
+  background-color: var(--bg-secondary);
+  color: var(--text-primary);
+  font-size: 16px;
+  transition: all 0.2s ease;
+}
+
+.ai-search-input:focus {
+  outline: none;
+  border-color: var(--accent-primary);
+  box-shadow: 0 0 0 3px rgb(59 130 246 / 0.1);
+}
+
+.ai-search-container i:first-child {
+  position: absolute;
+  left: 16px;
+  top: 50%;
+  transform: translateY(-50%);
+  color: var(--accent-secondary);
+  font-size: 16px;
+}
+
+.ai-search-container i:last-child {
+  position: absolute;
+  right: 16px;
+  top: 50%;
+  transform: translateY(-50%);
+  color: var(--text-muted);
+  font-size: 16px;
+}
+
+.header-right {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  align-items: flex-end;
+}
+
+.filter-buttons {
+  display: flex;
+  gap: 8px;
+}
+
+.filter-btn {
+  padding: 8px 16px;
+  border: 1px solid var(--border-medium);
+  border-radius: 8px;
+  background-color: var(--bg-secondary);
+  color: var(--text-secondary);
+  font-size: 14px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: all 0.2s ease;
+}
+
+.filter-btn:hover {
+  background-color: var(--bg-tertiary);
+  color: var(--text-primary);
+}
+
+.filter-btn.active {
+  background-color: var(--accent-primary);
+  color: white;
+  border-color: var(--accent-primary);
+}
+
+.star-btn {
+  padding: 8px;
+  color: var(--accent-warning);
+}
+
+.date-navigation {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+
+.nav-btn {
+  background: none;
+  border: 1px solid var(--border-medium);
+  border-radius: 8px;
+  padding: 8px 12px;
+  color: var(--text-secondary);
+  cursor: pointer;
+  transition: all 0.2s ease;
+}
+
+.nav-btn:hover {
+  background-color: var(--bg-secondary);
+  color: var(--text-primary);
+}
+
+.date-display {
+  font-weight: 600;
+  color: var(--text-primary);
+  min-width: 80px;
+  text-align: center;
+}
+
+/* Main Content */
+.main-content {
+  background-color: var(--bg-secondary);
+  min-height: calc(100vh - 200px);
+  padding: 32px 0;
+}
+
+.content-container {
+  max-width: 1400px;
+  margin: 0 auto;
+  padding: 0 24px;
+}
+
+.cards-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(350px, 1fr));
+  gap: 24px;
+}
+
+/* Hugging Face Style Paper Cards */
+.hf-paper-card {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  border-radius: 12px;
+  border: 1px solid var(--border-light);
+  background-color: var(--bg-primary);
+  transition: all 0.2s ease;
+}
+
+.hf-paper-card:hover {
+  border-color: var(--border-medium);
+  box-shadow: var(--shadow-md);
+}
+
+/* Paper Thumbnail */
+.paper-thumbnail-link {
+  position: relative;
+  display: block;
+  height: 224px;
+  width: 100%;
+  cursor: pointer;
+  overflow: hidden;
+  border-radius: 12px;
+  background-color: var(--bg-secondary);
+}
+
+.paper-thumbnail-img {
+  height: 100%;
+  width: 100%;
+  object-fit: cover;
+  object-position: top;
+  opacity: 0.8;
+  transition: opacity 0.2s ease;
+}
+
+[data-theme="dark"] .paper-thumbnail-img {
+  opacity: 0.7;
+  filter: invert(1);
+}
+
+.paper-thumbnail-link:hover .paper-thumbnail-img {
+  opacity: 1;
+}
+
+/* Submitted by badge */
+.submitted-by-badge {
+  position: absolute;
+  right: 8px;
+  top: 216px;
+  margin-top: -32px;
+  display: flex;
+  height: 24px;
+  align-items: center;
+  gap: 4px;
+  align-self: flex-end;
+  white-space: nowrap;
+  border-radius: 6px;
+  border: 1px solid var(--border-light);
+  background-color: var(--bg-primary);
+  padding: 0 8px;
+  font-size: 12px;
+  line-height: 1;
+  color: var(--text-secondary);
+}
+
+.submitter-avatar-img {
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+
+.submitter-avatar-placeholder {
+  width: 16px;
+  height: 16px;
+  border-radius: 50%;
+  background-color: var(--accent-primary);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+  margin-right: 8px;
+}
+
+.submitter-avatar-placeholder i {
+  font-size: 10px;
+  color: white;
+}
+
+/* Card Content */
+.card-content {
+  background: linear-gradient(to bottom, var(--bg-secondary), var(--bg-primary));
+  margin-top: -8px;
+  display: flex;
+  padding: 32px 24px 24px 24px;
+  gap: 24px;
+}
+
+/* Upvote Section */
+.upvote-section {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 10px;
+  padding-top: 4px;
+  z-index: 1;
+}
+
+.upvote-button {
+  display: flex;
+  height: 56px;
+  width: 48px;
+  gap: 4px;
+  border-radius: 12px;
+  flex-shrink: 0;
+  cursor: pointer;
+  user-select: none;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  align-self: flex-start;
+  border: 1px solid var(--border-medium);
+  background-color: var(--bg-primary);
+  box-shadow: var(--shadow-sm);
+  transition: all 0.2s ease;
+}
+
+.upvote-button:hover {
+  border-color: var(--accent-primary);
+  box-shadow: var(--shadow-md);
+}
+
+.upvote-checkbox {
+  display: none;
+}
+
+.upvote-checkbox:checked + .upvote-icon {
+  color: var(--accent-primary);
+}
+
+.upvote-icon {
+  font-size: 14px;
+  color: var(--text-muted);
+  transition: color 0.2s ease;
+}
+
+.upvote-count {
+  font-size: 14px;
+  font-weight: 600;
+  line-height: 1;
+  color: var(--text-primary);
+}
+
+/* Paper Info */
+.paper-info {
+  width: 100%;
+}
+
+.paper-title {
+  margin-bottom: 4px;
+  font-size: 18px;
+  line-height: 1.5;
+  font-weight: 600;
+}
+
+.title-link {
+  display: -webkit-box;
+  -webkit-line-clamp: 3;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+  cursor: pointer;
+  text-decoration: none;
+  color: var(--text-primary);
+  transition: color 0.2s ease;
+}
+
+.title-link:hover {
+  text-decoration: underline;
+}
+
+/* Paper Meta */
+.paper-meta {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.authors-section {
+  display: flex;
+  align-items: center;
+}
+
+.authors-link {
+  display: flex;
+  text-decoration: none;
+  color: inherit;
+}
+
+.author-avatars-list {
+  display: flex;
+  align-items: center;
+  flex-direction: row-reverse;
+  font-size: 14px;
+  list-style: none;
+  padding: 0;
+  margin: 0;
+}
+
+.author-avatars-list li {
+  margin-right: -8px;
+  height: 16px;
+  width: 16px;
+  background: linear-gradient(to bottom right, var(--bg-tertiary), var(--bg-secondary));
+  display: block;
+  flex-shrink: 0;
+  border-radius: 50%;
+  border: 2px solid var(--bg-primary);
+}
+
+@media (min-width: 768px) {
+  .author-avatars-list li {
+    height: 20px;
+    width: 20px;
+  }
+}
+
+.author-count {
+  margin-left: 12px;
+  color: var(--text-muted);
+  font-size: 14px;
+}
+
+/* Engagement Metrics */
+.engagement-metrics {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.metric-link {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  border-radius: 6px;
+  border: 1px solid var(--border-light);
+  padding: 2px 4px;
+  font-size: 12px;
+  color: var(--text-muted);
+  text-decoration: none;
+  transition: all 0.2s ease;
+}
+
+@media (min-width: 640px) {
+  .metric-link {
+    padding: 4px 8px;
+    font-size: 14px;
+  }
+}
+
+.metric-link:hover {
+  border-color: var(--border-medium);
+  color: var(--text-primary);
+}
+
+.github-icon {
+  width: 12px;
+  height: 12px;
+  color: var(--text-primary);
+}
+
+.comment-icon {
+  width: 14px;
+  height: 14px;
+  color: var(--text-primary);
+}
+
+/* Card Actions */
+.card-actions {
+  padding: 0 24px 24px 24px;
+  display: flex;
+  gap: 8px;
+}
+
+.eval-button {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 8px 16px;
+  border: 1px solid var(--border-medium);
+  border-radius: 8px;
+  background-color: var(--bg-secondary);
+  color: var(--text-secondary);
+  font-size: 12px;
+  font-weight: 500;
+  text-decoration: none;
+  cursor: pointer;
+  transition: all 0.2s ease;
+}
+
+.eval-button:hover {
+  background-color: var(--bg-tertiary);
+  color: var(--text-primary);
+  border-color: var(--border-medium);
+}
+
+.badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  background-color: var(--bg-tertiary);
+  color: var(--accent-warning);
+  border: 1px solid var(--border-medium);
+  padding: 4px 8px;
+  border-radius: 999px;
+  font-size: 12px;
+  font-weight: 500;
+}
+
+/* Responsive Design */
+@media (max-width: 1024px) {
+  .header-container {
+    grid-template-columns: 1fr;
+    gap: 24px;
+  }
+  
+  .header-right {
+    align-items: flex-start;
+  }
+  
+  .cards-grid {
+    grid-template-columns: repeat(auto-fill, minmax(350px, 1fr));
+  }
+}
+
+@media (max-width: 768px) {
+  .nav-container {
+    padding: 0 16px;
+  }
+  
+  .nav-center {
+    margin: 0 16px;
+  }
+  
+  .header-container {
+    padding: 0 16px;
+  }
+  
+  .content-container {
+    padding: 0 16px;
+  }
+  
+  .cards-grid {
+    grid-template-columns: 1fr;
+  }
+  
+  .paper-card {
+    padding: 20px;
+  }
+  
+  .filter-buttons {
+    flex-wrap: wrap;
+  }
+}
+
+@media (max-width: 480px) {
+  .nav-left .logo span {
+    display: none;
+  }
+  
+  .nav-center {
+    margin: 0 8px;
+  }
+  
+  .paper-card {
+    padding: 16px;
+  }
+  
+  .card-header {
+    flex-direction: column;
+    gap: 12px;
+  }
+  
+  .upvote-section {
+    flex-direction: row;
+    justify-content: center;
+  }
+}
+
+/* Paper Evaluation Page Styles */
+.back-link {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  color: var(--text-secondary);
+  text-decoration: none;
+  font-weight: 500;
+  transition: all 0.2s ease;
+}
+
+.back-link:hover {
+  color: var(--text-primary);
+}
+
+.page-title {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  font-size: 18px;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.page-title i {
+  color: var(--accent-primary);
+}
+
+.paper-main {
+  background-color: var(--bg-secondary);
+  min-height: calc(100vh - 64px);
+  padding: 32px 0;
+}
+
+.paper-container {
+  max-width: 1400px;
+  margin: 0 auto;
+  padding: 0 24px;
+}
+
+.paper-header {
+  background-color: var(--bg-primary);
+  border: 1px solid var(--border-light);
+  border-radius: 16px;
+  padding: 32px;
+  margin-bottom: 24px;
+  box-shadow: var(--shadow-sm);
+}
+
+.paper-meta h1 {
+  font-size: 28px;
+  font-weight: 800;
+  color: var(--text-primary);
+  margin-bottom: 24px;
+}
+
+.meta-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+  gap: 16px;
+}
+
+.meta-item {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.meta-label {
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+}
+
+.meta-value {
+  font-size: 14px;
+  color: var(--text-primary);
+  font-weight: 500;
+}
+
+.meta-value a {
+  color: var(--accent-primary);
+  text-decoration: none;
+}
+
+.meta-value a:hover {
+  text-decoration: underline;
+}
+
+.content-layout {
+  display: grid;
+  grid-template-columns: 1fr 320px;
+  gap: 24px;
+  align-items: start;
+}
+
+.main-content {
+  background-color: var(--bg-primary);
+  border: 1px solid var(--border-light);
+  border-radius: 16px;
+  padding: 32px;
+  box-shadow: var(--shadow-sm);
+}
+
+.evaluation-content {
+  color: var(--text-primary);
+}
+
+.evaluation-content section {
+  margin-bottom: 32px;
+}
+
+.evaluation-content h2 {
+  font-size: 24px;
+  font-weight: 700;
+  color: var(--text-primary);
+  margin-bottom: 16px;
+  padding-bottom: 8px;
+  border-bottom: 2px solid var(--border-light);
+}
+
+.evaluation-content h3 {
+  font-size: 18px;
+  font-weight: 600;
+  color: var(--text-primary);
+  margin: 24px 0 12px 0;
+}
+
+.evaluation-content p {
+  font-size: 16px;
+  line-height: 1.6;
+  color: var(--text-secondary);
+  margin-bottom: 16px;
+}
+
+.evaluation-content ul {
+  list-style: none;
+  padding: 0;
+  margin: 16px 0;
+}
+
+.evaluation-content li {
+  padding: 8px 0;
+  border-bottom: 1px solid var(--border-light);
+  color: var(--text-secondary);
+  position: relative;
+  padding-left: 20px;
+}
+
+.evaluation-content li:before {
+  content: '•';
+  color: var(--accent-primary);
+  font-weight: bold;
+  position: absolute;
+  left: 0;
+}
+
+.dimension-card {
+  background-color: var(--bg-secondary);
+  border: 1px solid var(--border-light);
+  border-radius: 12px;
+  padding: 20px;
+  margin-bottom: 16px;
+  transition: all 0.2s ease;
+}
+
+.dimension-card:hover {
+  border-color: var(--border-medium);
+  box-shadow: var(--shadow-sm);
+}
+
+.dimension-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 12px;
+}
+
+.dimension-title {
+  font-size: 16px;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.dimension-score {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.score-badge {
+  background-color: var(--accent-primary);
+  color: white;
+  padding: 4px 12px;
+  border-radius: 12px;
+  font-size: 14px;
+  font-weight: 600;
+}
+
+.dimension-meta {
+  display: flex;
+  gap: 16px;
+  margin-bottom: 12px;
+  font-size: 14px;
+  color: var(--text-muted);
+}
+
+.dimension-meta span {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+}
+
+.dimension-analysis {
+  color: var(--text-secondary);
+  line-height: 1.5;
+}
+
+.sidebar {
+  position: sticky;
+  top: 100px;
+}
+
+.scorecard-panel {
+  background-color: var(--bg-primary);
+  border: 1px solid var(--border-light);
+  border-radius: 16px;
+  padding: 24px;
+  box-shadow: var(--shadow-sm);
+}
+
+.panel-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 20px;
+}
+
+.panel-header h2 {
+  font-size: 18px;
+  font-weight: 600;
+  color: var(--text-primary);
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.overall-score {
+  text-align: center;
+}
+
+.score-number {
+  display: block;
+  font-size: 24px;
+  font-weight: 800;
+  color: var(--accent-primary);
+}
+
+.score-label {
+  font-size: 12px;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+}
+
+.radar-container {
+  display: flex;
+  justify-content: center;
+  margin-bottom: 20px;
+}
+
+.radar-legend h3 {
+  font-size: 14px;
+  font-weight: 600;
+  color: var(--text-primary);
+  margin-bottom: 12px;
+}
+
+.legend-list {
+  list-style: none;
+  padding: 0;
+  margin: 0;
+}
+
+.legend-list li {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 6px 0;
+  font-size: 12px;
+  color: var(--text-secondary);
+}
+
+.legend-color {
+  width: 12px;
+  height: 12px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+
+.legend-abbr {
+  font-weight: 600;
+  min-width: 40px;
+  text-align: center;
+}
+
+.legend-full {
+  color: var(--text-secondary);
+  font-size: 11px;
+}
+
+/* Responsive Design for Paper Page */
+@media (max-width: 1024px) {
+  .content-layout {
+    grid-template-columns: 1fr;
+    gap: 16px;
+  }
+  
+  .sidebar {
+    position: static;
+  }
+  
+  .scorecard-panel {
+    order: -1;
+  }
+}
+
+@media (max-width: 768px) {
+  .paper-container {
+    padding: 0 16px;
+  }
+  
+  .paper-header {
+    padding: 24px;
+  }
+  
+  .main-content {
+    padding: 24px;
+  }
+  
+  .meta-grid {
+    grid-template-columns: 1fr;
+  }
+}
+
+@media (max-width: 480px) {
+  .paper-header {
+    padding: 20px;
+  }
+  
+  .main-content {
+    padding: 20px;
+  }
+  
+  .scorecard-panel {
+    padding: 20px;
+  }
+  
+  .dimension-header {
+    flex-direction: column;
+    align-items: flex-start;
+    gap: 8px;
+  }
+}
+
+/* Enhanced Evaluation Page Styles */
+.evaluation-section {
+  margin-bottom: 48px;
+  background: var(--bg-primary);
+  border-radius: 12px;
+  border: 1px solid var(--border-light);
+  overflow: hidden;
+  box-shadow: var(--shadow-sm);
+}
+
+.section-header {
+  background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
+  color: white;
+  padding: 24px 32px;
+  border-bottom: 1px solid var(--border-light);
+}
+
+.section-header h2 {
+  margin: 0;
+  font-size: 24px;
+  font-weight: 600;
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+
+.section-header h2 i {
+  font-size: 20px;
+  opacity: 0.9;
+}
+
+.section-content {
+  padding: 32px;
+}
+
+/* Summary Card */
+.summary-card {
+  background: var(--bg-secondary);
+  border-radius: 8px;
+  padding: 24px;
+  border-left: 4px solid var(--accent-primary);
+}
+
+.summary-text {
+  font-size: 16px;
+  line-height: 1.7;
+  color: var(--text-primary);
+  margin: 0;
+}
+
+/* Dimensions Grid */
+.dimensions-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(400px, 1fr));
+  gap: 24px;
+}
+
+.dimension-card {
+  background: var(--bg-secondary);
+  border-radius: 12px;
+  padding: 24px;
+  border: 1px solid var(--border-light);
+  transition: all 0.2s ease;
+}
+
+.dimension-card:hover {
+  transform: translateY(-2px);
+  box-shadow: var(--shadow-md);
+  border-color: var(--accent-primary);
+}
+
+.dimension-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  margin-bottom: 16px;
+}
+
+.dimension-title {
+  font-size: 18px;
+  font-weight: 600;
+  color: var(--text-primary);
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex: 1;
+}
+
+.dimension-title i {
+  color: var(--accent-primary);
+  font-size: 16px;
+}
+
+.dimension-score {
+  display: flex;
+  gap: 8px;
+  flex-shrink: 0;
+}
+
+.score-badge {
+  background: var(--accent-primary);
+  color: white;
+  padding: 4px 12px;
+  border-radius: 20px;
+  font-size: 14px;
+  font-weight: 600;
+  min-width: 32px;
+  text-align: center;
+}
+
+.score-badge.probability {
+  background: var(--accent-secondary);
+}
+
+.dimension-meta {
+  margin-bottom: 16px;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 12px;
+}
+
+.meta-item {
+  background: var(--bg-tertiary);
+  padding: 6px 12px;
+  border-radius: 6px;
+  font-size: 12px;
+  color: var(--text-secondary);
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.dimension-analysis {
+  color: var(--text-secondary);
+  line-height: 1.6;
+  font-size: 14px;
+}
+
+/* Recommendations Grid */
+.recommendations-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+  gap: 24px;
+}
+
+.recommendation-card {
+  background: var(--bg-secondary);
+  border-radius: 12px;
+  padding: 24px;
+  border: 1px solid var(--border-light);
+  transition: all 0.2s ease;
+}
+
+.recommendation-card:hover {
+  transform: translateY(-2px);
+  box-shadow: var(--shadow-md);
+  border-color: var(--accent-secondary);
+}
+
+.recommendation-card h3 {
+  color: var(--accent-secondary);
+  font-size: 18px;
+  font-weight: 600;
+  margin: 0 0 16px 0;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.recommendation-list {
+  list-style: none;
+  padding: 0;
+  margin: 0;
+}
+
+.recommendation-list li {
+  padding: 8px 0;
+  border-bottom: 1px solid var(--border-light);
+  position: relative;
+  padding-left: 20px;
+}
+
+.recommendation-list li:before {
+  content: "→";
+  color: var(--accent-secondary);
+  position: absolute;
+  left: 0;
+  font-weight: bold;
+}
+
+.recommendation-list li:last-child {
+  border-bottom: none;
+}
+
+/* Limitations Card */
+.limitations-card {
+  background: var(--bg-secondary);
+  border-radius: 12px;
+  padding: 24px;
+  border: 1px solid var(--border-light);
+  border-left: 4px solid var(--accent-warning);
+}
+
+.limitations-list {
+  list-style: none;
+  padding: 0;
+  margin: 0;
+}
+
+.limitations-list li {
+  padding: 12px 0;
+  border-bottom: 1px solid var(--border-light);
+  position: relative;
+  padding-left: 24px;
+}
+
+.limitations-list li:before {
+  content: "⚠";
+  color: var(--accent-warning);
+  position: absolute;
+  left: 0;
+  font-weight: bold;
+}
+
+.limitations-list li:last-child {
+  border-bottom: none;
+}
+
+/* No Data Styling */
+.no-data {
+  color: var(--text-muted);
+  font-style: italic;
+  text-align: center;
+  padding: 24px;
+  background: var(--bg-tertiary);
+  border-radius: 8px;
+  border: 2px dashed var(--border-medium);
+}
+
+/* Radar Chart Tooltip */
+.radar-tooltip {
+  position: fixed;
+  display: none;
+  z-index: 1000;
+  pointer-events: none;
+  background: var(--bg-primary);
+  border: 1px solid var(--border-light);
+  border-radius: 8px;
+  padding: 8px 12px;
+  box-shadow: var(--shadow-lg);
+  backdrop-filter: blur(8px);
+  animation: tooltip-fade-in 0.2s ease-out;
+}
+
+.tooltip-content {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.tooltip-abbr {
+  font-weight: 700;
+  font-size: 14px;
+  line-height: 1;
+}
+
+.tooltip-full {
+  font-size: 11px;
+  color: var(--text-secondary);
+  line-height: 1;
+}
+
+@keyframes tooltip-fade-in {
+  from {
+    opacity: 0;
+    transform: translateY(4px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+

requirements.txt

@@ -0,0 +1,11 @@
+anthropic>=0.38.0
+langgraph>=0.2.43
+pydantic>=2.7.0
+python-dotenv>=1.0.1
+rich>=13.7.1
+fastapi>=0.112.0
+uvicorn[standard]>=0.30.5
+httpx>=0.27.0
+beautifulsoup4>=4.12.3
+lxml>=5.2.2
+

server.py

@@ -0,0 +1,731 @@
+import os
+import re
+import glob
+import json
+import sqlite3
+from datetime import date, datetime, timedelta
+from typing import Any, Dict, List, Optional
+from contextlib import contextmanager
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from dotenv import load_dotenv
+import httpx
+from bs4 import BeautifulSoup
+
+
+# Load environment variables
+load_dotenv()
+
+# Get API key from HF Spaces secrets
+def get_anthropic_api_key() -> Optional[str]:
+    """Get Anthropic API key, prioritize HF Spaces secrets"""
+    # First try to get from HF Spaces secrets
+    hf_secret = os.getenv("HF_SECRET_ANTHROPIC_API_KEY")
+    if hf_secret:
+        return hf_secret
+    
+    # Then try to get from environment variables
+    env_key = os.getenv("ANTHROPIC_API_KEY")
+    if env_key:
+        return env_key
+    
+    return None
+
+
+def get_project_root() -> str:
+    return os.path.dirname(os.path.abspath(__file__))
+
+
+PROJECT_ROOT = get_project_root()
+DEFAULT_WORKDIR = os.getenv("WORKDIR", os.path.join(PROJECT_ROOT, "workdir"))
+DB_PATH = os.path.join(PROJECT_ROOT, "papers_cache.db")
+
+# Database management
+class PapersDatabase:
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        self.init_database()
+    
+    def init_database(self):
+        """Initialize the database with required tables"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            
+            # Create papers cache table
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS papers_cache (
+                    date_str TEXT PRIMARY KEY,
+                    html_content TEXT NOT NULL,
+                    parsed_cards TEXT NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            ''')
+            
+            # Create latest_date table to track the most recent available date
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS latest_date (
+                    id INTEGER PRIMARY KEY CHECK (id = 1),
+                    date_str TEXT NOT NULL,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            ''')
+            
+            # Insert default latest_date record if it doesn't exist
+            cursor.execute('''
+                INSERT OR IGNORE INTO latest_date (id, date_str) 
+                VALUES (1, ?)
+            ''', (date.today().isoformat(),))
+            
+            conn.commit()
+    
+    @contextmanager
+    def get_connection(self):
+        """Context manager for database connections"""
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row  # Enable dict-like access
+        try:
+            yield conn
+        finally:
+            conn.close()
+    
+    def get_cached_papers(self, date_str: str) -> Optional[Dict[str, Any]]:
+        """Get cached papers for a specific date"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT parsed_cards, created_at 
+                FROM papers_cache 
+                WHERE date_str = ?
+            ''', (date_str,))
+            
+            row = cursor.fetchone()
+            if row:
+                return {
+                    'cards': json.loads(row['parsed_cards']),
+                    'cached_at': row['created_at']
+                }
+            return None
+    
+    def cache_papers(self, date_str: str, html_content: str, parsed_cards: List[Dict[str, Any]]):
+        """Cache papers for a specific date"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                INSERT OR REPLACE INTO papers_cache 
+                (date_str, html_content, parsed_cards, updated_at) 
+                VALUES (?, ?, ?, CURRENT_TIMESTAMP)
+            ''', (date_str, html_content, json.dumps(parsed_cards)))
+            conn.commit()
+    
+    def get_latest_cached_date(self) -> Optional[str]:
+        """Get the latest cached date"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute('SELECT date_str FROM latest_date WHERE id = 1')
+            row = cursor.fetchone()
+            return row['date_str'] if row else None
+    
+    def update_latest_date(self, date_str: str):
+        """Update the latest available date"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                UPDATE latest_date 
+                SET date_str = ?, updated_at = CURRENT_TIMESTAMP 
+                WHERE id = 1
+            ''', (date_str,))
+            conn.commit()
+    
+    def is_cache_fresh(self, date_str: str, max_age_hours: int = 24) -> bool:
+        """Check if cache is fresh (within max_age_hours)"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT updated_at 
+                FROM papers_cache 
+                WHERE date_str = ?
+            ''', (date_str,))
+            
+            row = cursor.fetchone()
+            if not row:
+                return False
+            
+            cached_time = datetime.fromisoformat(row['updated_at'].replace('Z', '+00:00'))
+            age = datetime.now(cached_time.tzinfo) - cached_time
+            return age.total_seconds() < max_age_hours * 3600
+    
+    def cleanup_old_cache(self, days_to_keep: int = 7):
+        """Clean up old cache entries"""
+        cutoff_date = (datetime.now() - timedelta(days=days_to_keep)).isoformat()
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                DELETE FROM papers_cache 
+                WHERE updated_at < ?
+            ''', (cutoff_date,))
+            conn.commit()
+
+
+# Initialize database
+db = PapersDatabase(DB_PATH)
+
+
+app = FastAPI(title="PaperIndex Web")
+
+# Local development: allow same-origin and localhost
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# --- Utility functions ---
+
+def ensure_workdir() -> str:
+    os.makedirs(DEFAULT_WORKDIR, exist_ok=True)
+    return DEFAULT_WORKDIR
+
+
+def extract_arxiv_id(url: str) -> Optional[str]:
+    if not url:
+        return None
+    # Matches /abs/2508.05629, /pdf/2508.05629.pdf
+    m = re.search(r"arxiv\.org/(abs|pdf)/([0-9]{4}\.\d{4,5})(?:\.pdf)?", url)
+    if m:
+        return m.group(2)
+    return None
+
+def extract_json_data(html: str) -> Dict[str, Any]:
+    """Extract JSON data from the HTML page to get GitHub stars and other metadata."""
+    try:
+        soup = BeautifulSoup(html, "lxml")
+        
+        # Look for GitHub stars in the HTML structure
+        # Based on the user's description, GitHub stars are displayed with SVG icons
+        # Look for SVG elements that might represent GitHub stars
+        svg_elements = soup.find_all("svg")
+        
+        github_stars_map = {}
+        
+        for svg in svg_elements:
+            # Look for GitHub-related SVG (usually has specific viewBox or path)
+            svg_html = str(svg)
+            if "github" in svg_html.lower() or "256 250" in svg_html:  # GitHub icon viewBox
+                # Look for the star count near this SVG
+                parent = svg.parent
+                if parent:
+                    # Look for numbers that might be star counts
+                    text_content = parent.get_text()
+                    numbers = re.findall(r'\b(\d+)\b', text_content)
+                    if numbers:
+                        # The number near a GitHub SVG is likely the star count
+                        star_count = int(numbers[0])
+                        # Try to find the paper title or ID to associate with
+                        # Look for the closest article or card container
+                        article = svg.find_parent("article")
+                        if article:
+                            title_elem = article.find("h3")
+                            if title_elem:
+                                paper_title = title_elem.get_text(strip=True)
+                                github_stars_map[paper_title] = star_count
+        
+        # Also look for any elements with GitHub-related text
+        github_text_elements = soup.find_all(string=lambda text: text and "github" in text.lower())
+        for text_elem in github_text_elements:
+            parent = text_elem.parent
+            if parent:
+                text_content = parent.get_text()
+                numbers = re.findall(r'\b(\d+)\b', text_content)
+                if numbers:
+                    star_count = int(numbers[0])
+                    # Try to find the paper title
+                    article = parent.find_parent("article")
+                    if article:
+                        title_elem = article.find("h3")
+                        if title_elem:
+                            paper_title = title_elem.get_text(strip=True)
+                            if paper_title not in github_stars_map:
+                                github_stars_map[paper_title] = star_count
+        
+        return {"github_stars_map": github_stars_map}
+            
+    except Exception as e:
+        print(f"Error extracting JSON data: {e}")
+    
+    return {"github_stars_map": {}}
+
+
+def find_eval_file_for_id(arxiv_id: str) -> Optional[str]:
+    workdir = ensure_workdir()
+    # Look for any json containing the id substring
+    candidates = glob.glob(os.path.join(workdir, f"**/*{arxiv_id}*.json"), recursive=True)
+    return candidates[0] if candidates else None
+
+
+async def fetch_daily_html(target_date: str) -> tuple[str, str]:
+    """Fetch daily papers HTML, with fallback to find the latest available date"""
+    async with httpx.AsyncClient(timeout=20, follow_redirects=False) as client:
+        # First try the requested date
+        url = f"https://huggingface.co/papers/date/{target_date}"
+        try:
+            r = await client.get(url)
+            
+            # Check if we got redirected
+            if r.status_code in [301, 302, 303, 307, 308]:
+                # We got redirected, extract the actual date from the redirect location
+                location = r.headers.get('location', '')
+                print(f"Got redirect to: {location}")
+                
+                # Extract date from redirect URL (e.g., /papers/date/2025-08-08)
+                import re
+                date_match = re.search(r'/papers/date/(\d{4}-\d{2}-\d{2})', location)
+                if date_match:
+                    actual_date = date_match.group(1)
+                    print(f"Redirected from {target_date} to {actual_date}")
+                    
+                    # Fetch the actual page
+                    actual_url = f"https://huggingface.co{location}"
+                    r = await client.get(actual_url)
+                    if r.status_code == 200:
+                        return actual_date, r.text
+                    else:
+                        raise Exception(f"Failed to fetch redirected page: {r.status_code}")
+                else:
+                    # Couldn't extract date from redirect, use fallback
+                    raise Exception("Could not extract date from redirect")
+            
+            elif r.status_code == 200:
+                # Direct success, check if the page actually contains the requested date
+                if target_date in r.text or "Daily Papers" in r.text:
+                    return target_date, r.text
+                else:
+                    # Page exists but doesn't contain expected content
+                    raise Exception("Page exists but doesn't contain expected content")
+            else:
+                # Other error status
+                raise Exception(f"Status code {r.status_code}")
+                
+        except Exception as e:
+            print(f"Failed to fetch {target_date}: {e}")
+            # If the requested date fails, try to find the latest available date
+            actual_date, html = await find_latest_available_date(client)
+            return actual_date, html
+
+async def find_latest_available_date(client: httpx.AsyncClient) -> tuple[str, str]:
+    """Find the latest available date by checking recent dates"""
+    
+    # Start from today and go backwards up to 30 days
+    today = datetime.now()
+    for i in range(30):
+        check_date = today - timedelta(days=i)
+        date_str = check_date.strftime("%Y-%m-%d")
+        url = f"https://huggingface.co/papers/date/{date_str}"
+        
+        try:
+            r = await client.get(url)
+            if r.status_code == 200:
+                # Check if the page actually has content (not just a 404 or empty page)
+                if "Daily Papers" in r.text and len(r.text) > 1000:
+                    print(f"Found latest available date: {date_str}")
+                    return date_str, r.text
+        except Exception:
+            continue
+    
+    # If no date found, return a default page or raise an error
+    raise Exception("No available daily papers found in the last 30 days")
+
+
+def parse_daily_cards(html: str) -> List[Dict[str, Any]]:
+    soup = BeautifulSoup(html, "lxml")
+    
+    # First, extract JSON data from the page to get GitHub stars
+    json_data = extract_json_data(html)
+    
+    # Find all article elements that contain paper cards
+    cards: List[Dict[str, Any]] = []
+    
+    # Look for article elements with the specific class structure from Hugging Face
+    for article in soup.select("article.relative.flex.flex-col.overflow-hidden.rounded-xl.border"):
+        try:
+            card_data = {}
+            
+            # Extract title and link
+            title_link = article.select_one("h3 a")
+            if title_link:
+                card_data["title"] = title_link.get_text(strip=True)
+                href = title_link.get("href")
+                if href:
+                    if href.startswith("http"):
+                        card_data["huggingface_url"] = href
+                    else:
+                        card_data["huggingface_url"] = f"https://huggingface.co{href}"
+            
+            # Extract upvote count
+            upvote_div = article.select_one("div.shadow-alternate div.leading-none")
+            if upvote_div:
+                upvote_text = upvote_div.get_text(strip=True)
+                try:
+                    card_data["upvotes"] = int(upvote_text)
+                except ValueError:
+                    card_data["upvotes"] = 0
+            
+            # Extract author count - look for the author count text
+            author_count_div = article.select_one("div.flex.truncate.text-sm")
+            if author_count_div:
+                author_text = author_count_div.get_text(strip=True)
+                # Extract number from "· 10 authors"
+                author_match = re.search(r'(\d+)\s*authors?', author_text)
+                if author_match:
+                    card_data["author_count"] = int(author_match.group(1))
+                else:
+                    card_data["author_count"] = 0
+            
+            # Extract GitHub stars from JSON data in the page
+            # This will be handled later when we parse the JSON data
+            card_data["github_stars"] = 0  # Default value
+            
+            # Extract comments count - look for comment icon and number
+            comment_links = article.select("a[href*='#community']")
+            for comment_link in comment_links:
+                comment_text = comment_link.get_text(strip=True)
+                try:
+                    card_data["comments"] = int(comment_text)
+                    break
+                except ValueError:
+                    continue
+            
+            # Extract submitter information
+            submitted_div = article.select_one("div.shadow-xs")
+            if submitted_div:
+                submitter_text = submitted_div.get_text(strip=True)
+                # Extract submitter name from "Submitted byLiang0223" (no space)
+                submitter_match = re.search(r'Submitted by(\S+)', submitter_text)
+                if submitter_match:
+                    card_data["submitter"] = submitter_match.group(1)
+            
+            # Extract arXiv ID from the URL
+            if card_data.get("huggingface_url"):
+                arxiv_id = extract_arxiv_id(card_data["huggingface_url"])
+                if arxiv_id:
+                    card_data["arxiv_id"] = arxiv_id
+            
+            # Try to get GitHub stars from the extracted data
+            # Look for GitHub stars by matching paper title
+            paper_title = card_data.get("title", "")
+            if paper_title in json_data.get("github_stars_map", {}):
+                card_data["github_stars"] = json_data["github_stars_map"][paper_title]
+            
+            # Only add cards that have at least a title
+            if card_data.get("title"):
+                cards.append(card_data)
+                
+        except Exception as e:
+            print(f"Error parsing card: {e}")
+            continue
+    
+    # If the above method didn't work, fall back to the old method
+    if not cards:
+        print("Falling back to old parsing method")
+        for h3 in soup.select("h3"):
+            # Title and Hugging Face paper link (if present)
+            a = h3.find("a")
+            title = h3.get_text(strip=True)
+            hf_link = None
+            if a and a.get("href"):
+                href = a.get("href")
+                # Absolute URL to huggingface
+                if href.startswith("http"):
+                    hf_link = href
+                else:
+                    hf_link = f"https://huggingface.co{href}"
+
+            # Try to capture sibling info (authors, votes, etc.) as a small snippet
+            meta_text = None
+            parent = h3.parent
+            if parent:
+                # Join immediate text content following h3
+                collected: List[str] = []
+                for sib in parent.find_all(text=True, recursive=False):
+                    t = (sib or "").strip()
+                    if t:
+                        collected.append(t)
+                if collected:
+                    meta_text = " ".join(collected)
+
+            # Try to discover any arXiv link inside nearby anchors
+            arxiv_id: Optional[str] = None
+            container = parent if parent else h3
+            for link in container.find_all("a", href=True):
+                possible = extract_arxiv_id(link["href"])
+                if possible:
+                    arxiv_id = possible
+                    break
+
+            cards.append(
+                {
+                    "title": title,
+                    "huggingface_url": hf_link,
+                    "meta": meta_text,
+                    "arxiv_id": arxiv_id,
+                }
+            )
+
+    # Deduplicate by title
+    seen = set()
+    unique_cards: List[Dict[str, Any]] = []
+    for c in cards:
+        key = c.get("title") or ""
+        if key and key not in seen:
+            seen.add(key)
+            unique_cards.append(c)
+    
+    print(f"Parsed {len(unique_cards)} cards")
+    return unique_cards
+
+
+# --- API Routes ---
+
+@app.get("/api/daily")
+async def get_daily(date_str: Optional[str] = None) -> Dict[str, Any]:
+    target_date = date_str or date.today().isoformat()
+    
+    # First, check if we have fresh cache for the requested date
+    cached_data = db.get_cached_papers(target_date)
+    if cached_data and db.is_cache_fresh(target_date):
+        print(f"Using cached data for {target_date}")
+        return {
+            "date": target_date,
+            "requested_date": target_date,
+            "cards": cached_data['cards'],
+            "fallback_used": False,
+            "cached": True,
+            "cached_at": cached_data['cached_at']
+        }
+    
+    # If no cache or stale cache, try to fetch fresh data
+    try:
+        actual_date, html = await fetch_daily_html(target_date)
+        print(f"Fetched fresh data for {actual_date} (requested {target_date})")
+        
+        # Check if we got redirected to a different date, and if that date has fresh cache
+        if actual_date != target_date:
+            cached_data = db.get_cached_papers(actual_date)
+            if cached_data and db.is_cache_fresh(actual_date):
+                print(f"Using cached data for redirected date {actual_date}")
+                return {
+                    "date": actual_date,
+                    "requested_date": target_date,
+                    "cards": cached_data['cards'],
+                    "fallback_used": True,
+                    "cached": True,
+                    "cached_at": cached_data['cached_at']
+                }
+        
+    except Exception as e:
+        print(f"Failed to fetch {target_date}, trying to find latest available date")
+        # If the requested date fails, try to find the latest available date
+        async with httpx.AsyncClient(timeout=20) as client:
+            try:
+                actual_date, html = await find_latest_available_date(client)
+                print(f"Using fallback date: {actual_date}")
+                
+                # Check if the fallback date has fresh cache
+                cached_data = db.get_cached_papers(actual_date)
+                if cached_data and db.is_cache_fresh(actual_date):
+                    print(f"Using cached data for fallback date {actual_date}")
+                    return {
+                        "date": actual_date,
+                        "requested_date": target_date,
+                        "cards": cached_data['cards'],
+                        "fallback_used": True,
+                        "cached": True,
+                        "cached_at": cached_data['cached_at']
+                    }
+                    
+            except Exception as fallback_error:
+                print(f"Fallback also failed: {fallback_error}")
+                # If everything fails, return cached data if available
+                cached_data = db.get_cached_papers(target_date)
+                if cached_data:
+                    return {
+                        "date": target_date,
+                        "requested_date": target_date,
+                        "cards": cached_data['cards'],
+                        "fallback_used": False,
+                        "cached": True,
+                        "cached_at": cached_data['cached_at']
+                    }
+                # If no cache available, return error
+                raise HTTPException(status_code=503, detail="Unable to fetch papers and no cache available")
+    
+    # Parse the HTML and process cards
+    cards = parse_daily_cards(html)
+    
+    # Attempt to resolve missing arXiv ids by scraping the HF paper page
+    async with httpx.AsyncClient(timeout=15) as client:
+        async def resolve_card(card: Dict[str, Any]) -> None:
+            if card.get("arxiv_id") or not card.get("huggingface_url"):
+                return
+            try:
+                r = await client.get(card["huggingface_url"])
+                if r.status_code == 200:
+                    soup = BeautifulSoup(r.text, "lxml")
+                    for a in soup.select("a[href]"):
+                        aid = extract_arxiv_id(a.get("href") or "")
+                        if aid:
+                            card["arxiv_id"] = aid
+                            break
+            except Exception:
+                pass
+
+        # Resolve sequentially for compatibility/simplicity
+        for c in cards:
+            await resolve_card(c)
+
+    # Fallback HF link to the daily page when missing
+    for c in cards:
+        if not c.get("huggingface_url"):
+            c["huggingface_url"] = f"https://huggingface.co/papers/date/{actual_date}"
+
+    # Attach has_eval flag
+    for c in cards:
+        arxiv_id = c.get("arxiv_id")
+        c["has_eval"] = bool(arxiv_id and find_eval_file_for_id(arxiv_id))
+    
+    # Cache the results
+    db.cache_papers(actual_date, html, cards)
+    db.update_latest_date(actual_date)
+    
+    # Clean up old cache entries (run occasionally)
+    if datetime.now().hour == 2:  # Run cleanup at 2 AM
+        db.cleanup_old_cache()
+    
+    return {
+        "date": actual_date, 
+        "requested_date": target_date,
+        "cards": cards,
+        "fallback_used": actual_date != target_date,
+        "cached": False
+    }
+
+
+@app.get("/api/evals")
+def list_evals() -> Dict[str, Any]:
+    workdir = ensure_workdir()
+    files = sorted(glob.glob(os.path.join(workdir, "**/*.json"), recursive=True))
+    items: List[Dict[str, Any]] = []
+    for f in files:
+        base = os.path.basename(f)
+        # Extract arxiv-like id from filename if present
+        m = re.search(r"([0-9]{4}\.\d{4,5})", base)
+        arxiv_id = m.group(1) if m else None
+        items.append({"file": f, "name": base, "arxiv_id": arxiv_id})
+    return {"count": len(items), "items": items}
+
+
+@app.get("/api/has-eval/{paper_id}")
+def has_eval(paper_id: str) -> Dict[str, bool]:
+    exists = find_eval_file_for_id(paper_id) is not None
+    return {"exists": exists}
+
+
+@app.get("/api/eval/{paper_id}")
+def get_eval(paper_id: str) -> Any:
+    path = find_eval_file_for_id(paper_id)
+    if not path:
+        raise HTTPException(status_code=404, detail="Evaluation not found")
+    return FileResponse(path, media_type="application/json")
+
+
+@app.get("/api/cache/status")
+def get_cache_status() -> Dict[str, Any]:
+    """Get cache status and statistics"""
+    with db.get_connection() as conn:
+        cursor = conn.cursor()
+        
+        # Get total cached dates
+        cursor.execute('SELECT COUNT(*) as count FROM papers_cache')
+        total_cached = cursor.fetchone()['count']
+        
+        # Get latest cached date
+        cursor.execute('SELECT date_str, updated_at FROM latest_date WHERE id = 1')
+        latest_info = cursor.fetchone()
+        
+        # Get cache age distribution
+        cursor.execute('''
+            SELECT 
+                CASE 
+                    WHEN updated_at > datetime('now', '-1 hour') THEN '1 hour'
+                    WHEN updated_at > datetime('now', '-24 hours') THEN '24 hours'
+                    WHEN updated_at > datetime('now', '-7 days') THEN '7 days'
+                    ELSE 'older'
+                END as age_group,
+                COUNT(*) as count
+            FROM papers_cache 
+            GROUP BY age_group
+        ''')
+        age_distribution = {row['age_group']: row['count'] for row in cursor.fetchall()}
+        
+        return {
+            "total_cached_dates": total_cached,
+            "latest_cached_date": latest_info['date_str'] if latest_info else None,
+            "latest_updated": latest_info['updated_at'] if latest_info else None,
+            "age_distribution": age_distribution
+        }
+
+
+@app.post("/api/cache/clear")
+def clear_cache() -> Dict[str, str]:
+    """Clear all cached data"""
+    with db.get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute('DELETE FROM papers_cache')
+        conn.commit()
+    return {"message": "Cache cleared successfully"}
+
+
+@app.post("/api/cache/refresh/{date_str}")
+async def refresh_cache(date_str: str) -> Dict[str, Any]:
+    """Force refresh cache for a specific date"""
+    try:
+        # Force fetch fresh data
+        html = await fetch_daily_html(date_str)
+        cards = parse_daily_cards(html)
+        
+        # Cache the results
+        db.cache_papers(date_str, html, cards)
+        
+        return {
+            "message": f"Cache refreshed for {date_str}",
+            "cards_count": len(cards)
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to refresh cache: {str(e)}")
+
+
+@app.get("/styles.css")
+async def get_styles():
+    """Serve CSS with no-cache headers to prevent caching issues during development"""
+    response = FileResponse("frontend/styles.css", media_type="text/css")
+    response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
+    response.headers["Pragma"] = "no-cache"
+    response.headers["Expires"] = "0"
+    return response
+
+# --- Static Frontend ---
+
+FRONTEND_DIR = os.path.join(PROJECT_ROOT, "frontend")
+os.makedirs(FRONTEND_DIR, exist_ok=True)
+app.mount("/", StaticFiles(directory=FRONTEND_DIR, html=True), name="static")
+
+# Initialize database
+db = PapersDatabase(DB_PATH)
+
+