arionxiv 1.0.32__py3-none-any.whl

arionxiv/cli/commands/preferences.py

@@ -0,0 +1,426 @@
+"""Preferences command for ArionXiv CLI - Paper preferences management"""
+
+import sys
+import asyncio
+import logging
+from pathlib import Path
+
+# Add backend to Python path
+backend_path = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(backend_path))
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt, Confirm
+from rich.table import Table
+from rich.text import Text
+
+from ..utils.db_config_manager import db_config_manager
+from ..ui.theme import create_themed_console, print_header, style_text, print_success, print_warning, print_error, get_theme_colors
+from ...services.unified_user_service import unified_user_service
+
+console = create_themed_console()
+logger = logging.getLogger(__name__)
+
+@click.command()
+@click.option('--categories', '-c', is_flag=True, help='Configure preferred categories')
+@click.option('--keywords', '-k', is_flag=True, help='Configure keywords')
+@click.option('--authors', '-a', is_flag=True, help='Configure preferred authors')
+@click.option('--schedule', '-t', is_flag=True, help='Configure daily dose schedule')
+@click.option('--show', '-s', is_flag=True, help='Show current preferences')
+@click.option('--reset', '-r', is_flag=True, help='Reset to default preferences')
+def preferences_command(categories: bool, keywords: bool, authors: bool, schedule: bool, show: bool, reset: bool):
+    """
+    Configure your paper preferences for daily dose
+    
+    Examples:
+    \b
+        arionxiv preferences --show
+        arionxiv preferences --categories
+        arionxiv preferences --keywords
+        arionxiv preferences --authors
+        arionxiv preferences --schedule
+        arionxiv preferences --reset
+    """
+    
+    async def _handle_preferences():
+        # Lazy import to avoid circular dependencies
+        from ...services.unified_config_service import unified_config_service
+        
+        print_header(console, "Paper Preferences")
+        
+        # Check authentication
+        if not unified_user_service.is_authenticated():
+            print_error(console, "ERROR: You must be logged in to manage preferences")
+            return
+        
+        user = unified_user_service.get_current_user()
+        user_id = user["id"]
+        
+        if show:
+            await _show_preferences(user_id)
+        elif categories:
+            await _configure_categories(user_id)
+        elif keywords:
+            await _configure_keywords(user_id)
+        elif authors:
+            await _configure_authors(user_id)
+        elif schedule:
+            await _configure_schedule(user_id)
+        elif reset:
+            await _reset_preferences(user_id)
+        else:
+            await _show_preferences_menu(user_id)
+    
+    # Run async function
+    asyncio.run(_handle_preferences())
+
+async def _show_preferences(user_id: str):
+    """Show current user preferences"""
+    # Import here to avoid circular dependencies
+    from ...services.unified_config_service import unified_config_service
+    
+    console.print(f"\n{style_text('Current Paper Preferences', 'primary')}")
+    console.rule(style=f"bold {get_theme_colors()['primary']}")
+    
+    result = await unified_config_service.get_user_preferences(user_id)
+    
+    if not result["success"]:
+        print_error(console, f"Failed to load preferences: {result['message']}")
+        return
+    
+    prefs = result["preferences"]
+    
+    # Categories
+    console.print(f"\n{style_text('Preferred Categories:', 'accent')}")
+    if prefs["categories"]:
+        available_cats = unified_config_service.get_available_categories()
+        for cat in prefs["categories"]:
+            cat_name = available_cats.get(cat, cat)
+            console.print(f"  • {cat} - {cat_name}")
+    else:
+        console.print("  No categories selected")
+    
+    # Keywords
+    console.print(f"\n{style_text('Keywords:', 'accent')}")
+    if prefs["keywords"]:
+        for keyword in prefs["keywords"]:
+            console.print(f"  • {keyword}")
+    else:
+        console.print("  No keywords set")
+    
+    # Authors
+    console.print(f"\n{style_text('Preferred Authors:', 'accent')}")
+    if prefs["authors"]:
+        for author in prefs["authors"]:
+            console.print(f"  • {author}")
+    else:
+        console.print("  No preferred authors")
+    
+    # Exclude keywords
+    console.print(f"\n{style_text('Exclude Keywords:', 'accent')}")
+    if prefs["exclude_keywords"]:
+        for keyword in prefs["exclude_keywords"]:
+            console.print(f"  • {keyword}")
+    else:
+        console.print("  No exclusions")
+    
+    # Settings
+    console.print(f"\n{style_text('Settings:', 'accent')}")
+    console.print(f"  • Minimum relevance score: {prefs['min_relevance_score']}")
+    console.print(f"  • Maximum papers per day: {prefs['max_papers_per_day']}")
+    
+    # Daily dose schedule
+    console.print(f"\n{style_text('Daily Dose Schedule:', 'accent')}")
+    console.print(f"  • Enabled: {'Yes' if prefs.get('daily_dose_enabled', False) else 'No'}")
+    console.print(f"  • Time: {prefs.get('daily_dose_time', '08:00')} UTC")
+
+async def _configure_categories(user_id: str):
+    """Configure preferred categories"""
+    # Import here to avoid circular dependencies
+    from ...services.unified_config_service import unified_config_service
+    
+    console.print(f"\n{style_text('Configure Preferred Categories', 'primary')}")
+    console.rule(style=f"bold {get_theme_colors()['primary']}")
+    
+    # Get current preferences
+    result = await unified_config_service.get_user_preferences(user_id)
+    if not result["success"]:
+        print_error(console, f"Failed to load preferences: {result['message']}")
+        return
+    
+    current_categories = result["preferences"]["categories"]
+    available_categories = unified_config_service.get_available_categories()
+    colors = get_theme_colors()
+    
+    # Show available categories in a table
+    console.print(f"\n{style_text('Available Categories:', 'info')}")
+    
+    table = Table(show_header=True, header_style=f"bold {colors['primary']}")
+    table.add_column("ID", style="bold white", width=15)
+    table.add_column("Category", style="white")
+    table.add_column("Selected", style="white", width=10)
+    
+    for cat_id, cat_name in available_categories.items():
+        selected = "[X]" if cat_id in current_categories else "[ ]"
+        table.add_row(cat_id, cat_name, selected)
+    
+    console.print(table)
+    
+    # Get user selections
+    console.print(f"\n{style_text('Current selections:', 'accent')} {', '.join(current_categories) if current_categories else 'None'}")
+    
+    console.print(f"\n{style_text('Instructions:', 'info')}")
+    console.print("• Enter category IDs separated by commas (e.g., cs.AI, cs.LG, cs.CV)")
+    console.print("• Leave empty to clear all selections")
+    console.print("• Type 'cancel' to abort")
+    
+    while True:
+        selection = Prompt.ask(
+            "\n[bold]Enter category IDs[/bold]",
+            default=", ".join(current_categories)
+        )
+        
+        if selection.lower() == "cancel":
+            print_warning(console, "Category configuration cancelled")
+            return
+        
+        if not selection.strip():
+            new_categories = []
+            break
+        
+        # Parse and validate categories
+        entered_cats = [cat.strip() for cat in selection.split(",")]
+        invalid_cats = [cat for cat in entered_cats if cat not in available_categories]
+        
+        if invalid_cats:
+            print_error(console, f"Invalid categories: {', '.join(invalid_cats)}")
+            console.print("Please check the category IDs from the table above")
+            continue
+        
+        new_categories = entered_cats
+        break
+    
+    # Update preferences
+    current_prefs = result["preferences"]
+    current_prefs["categories"] = new_categories
+    
+    save_result = await unified_config_service.save_user_preferences(user_id, current_prefs)
+    
+    if save_result["success"]:
+        print_success(console, "Categories updated successfully!")
+        if new_categories:
+            console.print(f"Selected: {', '.join(new_categories)}")
+        else:
+            console.print("All categories cleared")
+    else:
+        print_error(console, f"Failed to save: {save_result['message']}")
+
+async def _configure_keywords(user_id: str):
+    """Configure keywords"""
+    # Import here to avoid circular dependencies
+    from ...services.unified_config_service import unified_config_service
+    
+    console.print(f"\n{style_text('Configure Keywords', 'primary')}")
+    console.rule(style=f"bold {get_theme_colors()['primary']}")
+    
+    # Get current preferences
+    result = await unified_config_service.get_user_preferences(user_id)
+    if not result["success"]:
+        print_error(console, f"Failed to load preferences: {result['message']}")
+        return
+    
+    current_prefs = result["preferences"]
+    
+    console.print(f"\n{style_text('Current keywords:', 'accent')} {', '.join(current_prefs['keywords']) if current_prefs['keywords'] else 'None'}")
+    console.print(f"{style_text('Current exclusions:', 'accent')} {', '.join(current_prefs['exclude_keywords']) if current_prefs['exclude_keywords'] else 'None'}")
+    
+    console.print(f"\n{style_text('Instructions:', 'info')}")
+    console.print("• Keywords help find relevant papers in titles and abstracts")
+    console.print("• Enter keywords separated by commas")
+    console.print("• Use specific terms like 'neural networks', 'deep learning', 'transformer'")
+    
+    # Configure include keywords
+    include_keywords = Prompt.ask(
+        "\n[bold]Include keywords[/bold]",
+        default=", ".join(current_prefs["keywords"])
+    )
+    
+    # Configure exclude keywords
+    exclude_keywords = Prompt.ask(
+        "\n[bold]Exclude keywords (papers with these will be filtered out)[/bold]",
+        default=", ".join(current_prefs["exclude_keywords"])
+    )
+    
+    # Process keywords
+    new_include = [kw.strip() for kw in include_keywords.split(",") if kw.strip()] if include_keywords else []
+    new_exclude = [kw.strip() for kw in exclude_keywords.split(",") if kw.strip()] if exclude_keywords else []
+    
+    # Update preferences
+    current_prefs["keywords"] = new_include
+    current_prefs["exclude_keywords"] = new_exclude
+    
+    save_result = await unified_config_service.save_user_preferences(user_id, current_prefs)
+    
+    if save_result["success"]:
+        print_success(console, "Keywords updated successfully!")
+        if new_include:
+            console.print(f"Include: {', '.join(new_include)}")
+        if new_exclude:
+            console.print(f"Exclude: {', '.join(new_exclude)}")
+    else:
+        print_error(console, f"Failed to save: {save_result['message']}")
+
+async def _configure_authors(user_id: str):
+    """Configure preferred authors"""
+    from ...services.unified_config_service import unified_config_service
+    
+    console.print(f"\n{style_text('Configure Preferred Authors', 'primary')}")
+    console.rule(style=f"bold {get_theme_colors()['primary']}")
+    
+    result = await unified_config_service.get_user_preferences(user_id)
+    if not result["success"]:
+        print_error(console, f"Failed to load preferences: {result['message']}")
+        return
+    
+    current_prefs = result["preferences"]
+    
+    console.print(f"\n{style_text('Current authors:', 'accent')} {', '.join(current_prefs['authors']) if current_prefs['authors'] else 'None'}")
+    
+    console.print(f"\n{style_text('Instructions:', 'info')}")
+    console.print("• Add authors whose papers you want to prioritize")
+    console.print("• Enter names separated by commas")
+    console.print("• Use last names or full names (e.g., 'Hinton', 'Geoffrey Hinton')")
+    
+    authors_input = Prompt.ask(
+        "\n[bold]Preferred authors[/bold]",
+        default=", ".join(current_prefs["authors"])
+    )
+    
+    new_authors = [auth.strip() for auth in authors_input.split(",") if auth.strip()] if authors_input else []
+    
+    current_prefs["authors"] = new_authors
+    
+    save_result = await unified_config_service.save_user_preferences(user_id, current_prefs)
+    
+    if save_result["success"]:
+        print_success(console, "Authors updated successfully!")
+        if new_authors:
+            console.print(f"Preferred authors: {', '.join(new_authors)}")
+    else:
+        print_error(console, f"Failed to save: {save_result['message']}")
+
+async def _configure_schedule(user_id: str):
+    """Configure daily dose schedule"""
+    from ...services.unified_config_service import unified_config_service
+    
+    console.print(f"\n{style_text('Configure Daily Dose Schedule', 'primary')}")
+    console.rule(style=f"bold {get_theme_colors()['primary']}")
+    
+    result = await unified_config_service.get_user_preferences(user_id)
+    if not result["success"]:
+        print_error(console, f"Failed to load preferences: {result['message']}")
+        return
+    
+    current_prefs = result["preferences"]
+    current_enabled = current_prefs.get('daily_dose_enabled', False)
+    current_time = current_prefs.get('daily_dose_time', '08:00')
+    
+    console.print(f"\n{style_text('Current settings:', 'accent')}")
+    console.print(f"  • Status: {'Enabled' if current_enabled else 'Disabled'}")
+    console.print(f"  • Time: {current_time} UTC")
+    
+    console.print(f"\n{style_text('Note:', 'info')}")
+    console.print("• The scheduler daemon must be running in the cloud for this to work")
+    console.print("• See DEPLOYMENT.txt for deployment instructions")
+    console.print("• Time is in UTC timezone (24-hour format)")
+    
+    enable_schedule = Confirm.ask(
+        "\n[bold]Enable daily dose schedule?[/bold]",
+        default=current_enabled
+    )
+    
+    if enable_schedule:
+        console.print(f"\n{style_text('Time format:', 'info')} HH:MM (e.g., 08:00 for 8 AM, 14:30 for 2:30 PM)")
+        
+        while True:
+            time_input = Prompt.ask(
+                "\n[bold]Daily dose time (UTC)[/bold]",
+                default=current_time
+            )
+            
+            if len(time_input.split(":")) == 2:
+                try:
+                    hour, minute = map(int, time_input.split(":"))
+                    if 0 <= hour <= 23 and 0 <= minute <= 59:
+                        current_prefs["daily_dose_time"] = time_input
+                        break
+                    else:
+                        print_error(console, "Hour must be 0-23, minute must be 0-59")
+                except ValueError:
+                    print_error(console, "Invalid time format. Use HH:MM (e.g., 08:00)")
+            else:
+                print_error(console, "Invalid time format. Use HH:MM (e.g., 08:00)")
+    
+    current_prefs["daily_dose_enabled"] = enable_schedule
+    
+    save_result = await unified_config_service.save_user_preferences(user_id, current_prefs)
+    
+    if save_result["success"]:
+        print_success(console, "Schedule updated successfully!")
+        if enable_schedule:
+            console.print(f"Daily dose will be delivered at {current_prefs['daily_dose_time']} UTC")
+            console.print("\n[yellow]Make sure the scheduler daemon is deployed to the cloud[/yellow]")
+        else:
+            console.print("Daily dose schedule disabled")
+    else:
+        print_error(console, f"Failed to save: {save_result['message']}")
+
+async def _reset_preferences(user_id: str):
+    """Reset preferences to default"""
+    # Import here to avoid circular dependencies
+    from ...services.unified_config_service import unified_config_service
+    
+    if Confirm.ask("\n[bold red]Are you sure you want to reset all preferences to default?[/bold red]"):
+        default_prefs = unified_config_service._get_default_preferences()
+        result = await unified_config_service.save_user_preferences(user_id, default_prefs)
+        
+        if result["success"]:
+            print_success(console, "Preferences reset to default!")
+        else:
+            print_error(console, f"Failed to reset: {result['message']}")
+    else:
+        print_warning(console, "Reset cancelled")
+
+async def _show_preferences_menu(user_id: str):
+    """Show interactive preferences menu"""
+    await _show_preferences(user_id)
+    
+    console.print(f"\n{style_text('Preferences Menu', 'primary')}")
+    console.rule(style=f"bold {get_theme_colors()['primary']}")
+    
+    choices = [
+        ("1", "Configure Categories"),
+        ("2", "Configure Keywords"),
+        ("3", "Configure Authors"),
+        ("4", "Configure Schedule"),
+        ("5", "Reset to Defaults"),
+        ("q", "Quit")
+    ]
+    
+    for key, desc in choices:
+        console.print(f"  [{key}] {desc}")
+    
+    choice = Prompt.ask("\n[bold]Select an option[/bold]", choices=[c[0] for c in choices], default="q")
+    
+    if choice == "1":
+        await _configure_categories(user_id)
+    elif choice == "2":
+        await _configure_keywords(user_id)
+    elif choice == "3":
+        await _configure_authors(user_id)
+    elif choice == "4":
+        await _configure_schedule(user_id)
+    elif choice == "5":
+        await _reset_preferences(user_id)

arionxiv/cli/commands/search.py

@@ -0,0 +1,254 @@
+"""Search command for ArionXiv CLI"""
+
+import sys
+import asyncio
+import subprocess
+import logging
+from pathlib import Path
+
+# Add backend to Python path
+backend_path = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(backend_path))
+
+import click
+from rich.console import Console
+
+logger = logging.getLogger(__name__)
+from rich.table import Table
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.panel import Panel
+from rich.prompt import Prompt
+from typing import Optional
+
+from ...arxiv_operations.searcher import arxiv_searcher
+from ..ui.theme import create_themed_console, create_themed_table, print_header, style_text, print_success, print_error, print_warning, get_theme_colors
+from ..utils.animations import *
+from ..utils.command_suggestions import show_command_suggestions
+
+console = create_themed_console()
+colors = get_theme_colors()
+
+
+@click.command()
+@click.argument('keywords', required=False, default=None)
+@click.option('--category', '-c', help='Filter by category (e.g., cs.AI, cs.LG)')
+@click.option('--author', '-a', help='Filter by author name')
+def search_command(keywords: Optional[str], category: Optional[str], author: Optional[str]):
+    """
+    Search for research papers on arXiv.
+    
+    Returns the top 10 matching papers for you to select from.
+    
+    Examples:
+    \b
+        arionxiv search "transformer attention"
+        arionxiv search "neural networks" --category cs.LG
+        arionxiv search "deep learning" --author "Hinton"
+    """
+    # Check if keywords are provided
+    if not keywords and not author:
+        console.print(f"\n[bold {colors['primary']}]ArionXiv Paper Search[/bold {colors['primary']}]")
+        console.rule(style=f"bold {colors['primary']}")
+        console.print(f"\n[bold {colors['primary']}]Enter keywords to search for papers on arXiv.[/bold {colors['primary']}]")
+        console.print(f"[bold {colors['primary']}]Example: transformer attention, neural networks, deep learning[/bold {colors['primary']}]\n")
+        
+        keywords = Prompt.ask(f"[bold {colors['primary']}]Search keywords[/bold {colors['primary']}]")
+        
+        if not keywords.strip():
+            console.print(f"\n[bold {colors['warning']}]No keywords provided. Exiting.[/bold {colors['warning']}]")
+            return
+    
+    asyncio.run(_search_papers(keywords or "", category, author))
+
+
+async def _search_papers(keywords: str, category: Optional[str], author: Optional[str]):
+    """Execute the paper search"""
+    
+    logger.info(f"Starting paper search: keywords='{keywords}', category={category}, author={author}")
+    left_to_right_reveal(console, f"Search: [bold {colors['primary']}]{keywords}[/bold {colors['primary']}]", style="bold", duration=1.0)
+    
+    with Progress(
+        TextColumn(f"[bold {colors['primary']}]Searching arXiv...[/bold {colors['primary']}]"),
+        "[progress.bar]",
+        console=console
+    ) as progress:
+        task = progress.add_task("", total=100)
+        for i in range(100):
+            await asyncio.sleep(0.01)
+            progress.update(task, advance=1)
+        
+        try:
+            # Perform search based on filters
+            if author:
+                logger.debug(f"Searching by author: {author}")
+                results = await arxiv_searcher.search_by_author(author=author, max_results=10)
+            elif category:
+                logger.debug(f"Searching by category: {category}")
+                results = await arxiv_searcher.search_by_category(query=keywords, category=category, max_results=10)
+            else:
+                logger.debug(f"Searching by keywords: {keywords}")
+                results = await arxiv_searcher.search(query=keywords, max_results=10)
+            
+            progress.remove_task(task)
+            
+            if not results["success"]:
+                logger.error(f"Search failed: {results.get('error', 'Unknown error')}")
+                print_error(console, f"Search failed: {results.get('error', 'Unknown error')}")
+                return
+            
+            papers = results["papers"]
+            logger.info(f"Search completed: found {len(papers)} papers")
+            
+            if not papers:
+                logger.warning(f"No papers found for: {keywords}")
+                print_warning(console, f"No papers found for: {keywords}")
+                return
+            
+        except Exception as e:
+            logger.error(f"Search error: {str(e)}", exc_info=True)
+            progress.remove_task(task)
+            print_error(console, f"Search error: {str(e)}")
+            return
+    
+    # Display results with animation
+    left_to_right_reveal(console, f"Found {len(papers)} papers", style=f"bold {colors['primary']}", duration=1.0)
+    console.print()
+    
+    # Show results table with row-by-row animation
+    await _display_papers_table_animated(papers)
+    
+    # Interactive selection
+    _show_selection_menu(papers)
+
+
+async def _display_papers_table_animated(papers):
+    """Display papers table with row-by-row animation"""
+    
+    def create_table_with_rows(num_rows: int) -> Table:
+        table = create_themed_table("Results")
+        table.expand = True
+        table.add_column("#", style=f"bold {colors['primary']}", width=4)
+        table.add_column("Title", style=f"bold {colors['primary']}")
+        table.add_column("Authors", style=f"bold {colors['primary']}", width=30)
+        table.add_column("Date", style=f"bold {colors['primary']}", width=12)
+        
+        for i in range(num_rows):
+            paper = papers[i]
+            title = paper.get("title", "Unknown")
+            authors = paper.get("authors", [])
+            author_str = authors[0] + (f" +{len(authors)-1}" if len(authors) > 1 else "") if authors else "Unknown"
+            pub_date = paper.get("published", "")
+            if pub_date:
+                try:
+                    from datetime import datetime
+                    date_obj = datetime.fromisoformat(pub_date.replace('Z', '+00:00'))
+                    date_str = date_obj.strftime("%Y-%m-%d")
+                except:
+                    date_str = pub_date[:10] if len(pub_date) >= 10 else "Unknown"
+            else:
+                date_str = "Unknown"
+            table.add_row(str(i + 1), title, author_str, date_str)
+        return table
+    
+    await row_by_row_table_reveal(console, create_table_with_rows, len(papers))
+
+
+def _show_selection_menu(papers):
+    """Show selection menu for papers"""
+    
+    left_to_right_reveal(console, f"Select a paper (1-{len(papers)}) or press Enter to exit:", style=f"bold {colors['primary']}", duration=1.0)
+    console.print()
+    
+    choice = Prompt.ask("Paper number", default="")
+    
+    if not choice:
+        return
+    
+    try:
+        idx = int(choice) - 1
+        if idx < 0 or idx >= len(papers):
+            print_error(console, "Invalid selection")
+            return
+    except ValueError:
+        print_error(console, "Enter a valid number")
+        return
+    
+    selected = papers[idx]
+    paper_id = selected.get("arxiv_id", "")
+    
+    if not paper_id:
+        print_error(console, "Paper ID not available")
+        return
+    
+    # Show selected paper details
+    console.print()
+    _display_paper_details(selected)
+    
+    # Show actions
+    left_to_right_reveal(console, f"\nActions:", style=f"bold {colors['primary']}", duration=0.5)
+    left_to_right_reveal(console, f"1. Fetch (download PDF)", style=f"bold {colors['primary']}", duration=0.5)
+    left_to_right_reveal(console, f"2. Analyze (AI analysis)", style=f"bold {colors['primary']}", duration=0.5)
+    left_to_right_reveal(console, f"3. Chat (discuss the paper)", style=f"bold {colors['primary']}", duration=0.5)
+    left_to_right_reveal(console, f"4. Exit", style=f"bold {colors['primary']}", duration=0.5)
+    
+    console.print()
+    action = Prompt.ask(f"[bold {colors['primary']}]Action[/bold {colors['primary']}]", choices=["1", "2", "3", "4"], default="4")
+    
+    if action == "1":
+        left_to_right_reveal(console, f"\nFetching paper...", style=f"bold {colors['primary']}")
+        subprocess.run([sys.executable, "-m", "arionxiv", "fetch", paper_id])
+    elif action == "2":
+        left_to_right_reveal(console, f"\nAnalyzing paper...", style=f"bold {colors['primary']}")
+        subprocess.run([sys.executable, "-m", "arionxiv", "analyze", paper_id])
+    elif action == "3":
+        left_to_right_reveal(console, f"\nStarting chat...", style=f"bold {colors['primary']}")
+        subprocess.run([sys.executable, "-m", "arionxiv", "chat", "--paper-id", paper_id])
+    elif action == "4":
+        show_command_suggestions(console, context='search')
+
+
+def _display_paper_details(paper):
+    """Display paper details"""
+    
+    title = paper.get("title", "Unknown Title")
+    
+    # Authors
+    authors = paper.get("authors", [])
+    author_str = ", ".join(authors) if isinstance(authors, list) else str(authors)
+    
+    # Categories
+    categories = paper.get("categories", [])
+    categories_str = ', '.join(categories) if categories else ""
+    
+    # Date
+    pub_date = paper.get("published", "Unknown")
+    if pub_date and len(pub_date) >= 10:
+        pub_date = pub_date[:10]
+    
+    # arXiv ID
+    arxiv_id = paper.get("arxiv_id", "")
+    
+    # Abstract
+    abstract = paper.get("abstract", "No abstract available")
+    
+    # Build content for panel
+    content_lines = [
+        f"[bold {colors['primary']}]{title}[/bold {colors['primary']}]\n",
+        f"[bold {colors['primary']}]Authors:[/bold {colors['primary']}] {author_str}",
+    ]
+    
+    if categories_str:
+        content_lines.append(f"[bold {colors['primary']}]Categories:[/bold {colors['primary']}] {categories_str}")
+    
+    content_lines.append(f"[bold {colors['primary']}]Published:[/bold {colors['primary']}] {pub_date}")
+    
+    if arxiv_id:
+        content_lines.append(f"[bold {colors['primary']}]arXiv ID:[/bold {colors['primary']}] {arxiv_id}")
+        content_lines.append(f"[bold {colors['primary']}]URL:[/bold {colors['primary']}] https://arxiv.org/abs/{arxiv_id}")
+    
+    content_lines.append(f"\n[bold {colors['primary']}]Abstract:[/bold {colors['primary']}]")
+    content_lines.append(abstract)
+    
+    content = "\n".join(content_lines)
+    
+    console.print(Panel(content, title=f"[bold {colors['primary']}]Selected Paper[/bold {colors['primary']}]", border_style=f"bold {colors['primary']}"))