cite-agent 1.0.4__py3-none-any.whl → 1.2.3__py3-none-any.whl

cite_agent/session_manager.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+"""
+User-Friendly Session Manager for Cite-Agent
+Handles session detection, user choices, and authentication flow
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Optional, Dict, Any
+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
+
+class SessionManager:
+    """User-friendly session management for Cite-Agent"""
+    
+    def __init__(self):
+        self.console = Console()
+        self.session_file = Path.home() / ".nocturnal_archive" / "session.json"
+        self.config_file = Path.home() / ".nocturnal_archive" / "config.env"
+        self.session_data: Optional[Dict[str, Any]] = None
+    
+    def detect_existing_session(self) -> bool:
+        """Detect if there's an existing session and load it"""
+        if not self.session_file.exists():
+            return False
+        
+        try:
+            with open(self.session_file, 'r') as f:
+                self.session_data = json.load(f)
+                return True
+        except Exception as e:
+            self.console.print(f"[red]⚠️ Session file corrupted: {e}[/red]")
+            return False
+    
+    def show_session_info(self):
+        """Display existing session information in a user-friendly way"""
+        if not self.session_data:
+            return
+        
+        email = self.session_data.get('email', 'Unknown')
+        user_id = self.session_data.get('user_id', 'Unknown')[:8] + "..."
+        expires_at = self.session_data.get('expires_at', 'Unknown')
+        daily_limit = self.session_data.get('daily_token_limit', 0)
+        
+        # Create a nice table
+        table = Table(title="🔑 Existing Session Found", show_header=True, header_style="bold green")
+        table.add_column("Property", style="cyan", width=15)
+        table.add_column("Value", style="white")
+        
+        table.add_row("Email", email)
+        table.add_row("User ID", user_id)
+        table.add_row("Daily Limit", f"{daily_limit:,} queries")
+        table.add_row("Expires", expires_at)
+        
+        self.console.print()
+        self.console.print(table)
+        self.console.print()
+    
+    def ask_session_choice(self) -> str:
+        """Ask user what they want to do with the existing session"""
+        self.console.print("[bold cyan]What would you like to do?[/bold cyan]")
+        self.console.print()
+        
+        # Create a nice menu
+        menu_table = Table(show_header=False, box=None, padding=(0, 1))
+        menu_table.add_column("Choice", style="bold green", width=3)
+        menu_table.add_column("Action", style="white", width=20)
+        menu_table.add_column("Description", style="dim", width=40)
+        
+        menu_table.add_row("1", "Resume", "Continue with this session")
+        menu_table.add_row("2", "Switch", "Login with different account")
+        menu_table.add_row("3", "Logout", "Clear session and start fresh")
+        menu_table.add_row("4", "Help", "Show session management help")
+        
+        self.console.print(menu_table)
+        self.console.print()
+        
+        while True:
+            choice = Prompt.ask(
+                "Choose an option",
+                choices=["1", "2", "3", "4", "resume", "switch", "logout", "help"],
+                default="1"
+            ).lower()
+            
+            if choice in ["1", "resume"]:
+                return "resume"
+            elif choice in ["2", "switch"]:
+                return "switch"
+            elif choice in ["3", "logout"]:
+                return "logout"
+            elif choice in ["4", "help"]:
+                self.show_help()
+                continue
+            else:
+                self.console.print("[red]Invalid choice. Please try again.[/red]")
+    
+    def show_help(self):
+        """Show help for session management"""
+        help_text = """
+[bold cyan]Session Management Help[/bold cyan]
+
+[bold green]Resume:[/bold green] Continue with your existing session
+• Use your current login and settings
+• No need to re-authenticate
+• All your data and preferences are preserved
+
+[bold yellow]Switch:[/bold yellow] Login with a different account
+• Logout from current session
+• Start fresh with new account
+• Previous session data will be cleared
+
+[bold red]Logout:[/bold red] Clear session and start fresh
+• Remove all saved login information
+• Start completely fresh
+• You'll need to login again
+
+[bold blue]Session Files:[/bold blue]
+• Session: ~/.nocturnal_archive/session.json
+• Config: ~/.nocturnal_archive/config.env
+
+[bold blue]Manual Session Management:[/bold blue]
+• To clear session manually: rm ~/.nocturnal_archive/session.json
+• To clear config: rm ~/.nocturnal_archive/config.env
+        """
+        
+        self.console.print(Panel(help_text, title="Help", border_style="blue"))
+        self.console.print()
+    
+    def clear_session(self) -> bool:
+        """Clear the existing session"""
+        try:
+            if self.session_file.exists():
+                self.session_file.unlink()
+            if self.config_file.exists():
+                self.config_file.unlink()
+            self.console.print("[green]✅ Session cleared successfully[/green]")
+            return True
+        except Exception as e:
+            self.console.print(f"[red]❌ Error clearing session: {e}[/red]")
+            return False
+    
+    def handle_session_affirmation(self) -> str:
+        """Main function to handle session affirmation with user-friendly interface"""
+        # Check for existing session
+        has_session = self.detect_existing_session()
+        
+        if not has_session:
+            self.console.print("[yellow]No existing session found. Starting fresh...[/yellow]")
+            return "fresh"
+        
+        # Show session information
+        self.show_session_info()
+        
+        # Ask user what to do
+        choice = self.ask_session_choice()
+        
+        if choice == "resume":
+            self.console.print("[green]✅ Resuming existing session...[/green]")
+            return "resume"
+        elif choice == "switch":
+            self.console.print("[yellow]🔄 Switching to different account...[/yellow]")
+            if self.clear_session():
+                return "fresh"
+            else:
+                return "error"
+        elif choice == "logout":
+            self.console.print("[red]🚪 Logging out...[/red]")
+            if self.clear_session():
+                return "fresh"
+            else:
+                return "error"
+        
+        return "error"
+    
+    def setup_environment_variables(self):
+        """Set up environment variables for backend mode"""
+        # PRODUCTION MODE: Force backend, ensure monetization
+        # NEVER load user's .env files in production
+        
+        # Set backend URL if not already set
+        if "NOCTURNAL_API_URL" not in os.environ:
+            os.environ["NOCTURNAL_API_URL"] = "https://cite-agent-api-720dfadd602c.herokuapp.com/api"
+        
+        # SECURITY: Default to backend mode (USE_LOCAL_KEYS=false)
+        # This ensures users MUST authenticate and pay
+        if "USE_LOCAL_KEYS" not in os.environ:
+            os.environ["USE_LOCAL_KEYS"] = "false"
+    
+    def get_session_status(self) -> Dict[str, Any]:
+        """Get current session status for debugging"""
+        return {
+            "session_file_exists": self.session_file.exists(),
+            "config_file_exists": self.config_file.exists(),
+            "session_data": self.session_data,
+            "use_local_keys": os.environ.get("USE_LOCAL_KEYS", "not set"),
+            "api_url": os.environ.get("NOCTURNAL_API_URL", "not set")
+        }
+
+def main():
+    """Test the session manager"""
+    sm = SessionManager()
+    result = sm.handle_session_affirmation()
+    print(f"Result: {result}")
+    
+    # Show status
+    status = sm.get_session_status()
+    print(f"Status: {status}")
+
+if __name__ == "__main__":
+    main()

cite_agent/setup_config.py

@@ -63,18 +63,6 @@ class NocturnalConfig:
         print("You'll use your institution-issued account to sign in. No invite codes or manual API keys required.")
         print()
 
-        # Ask if new user or returning user
-        print("Are you a new user or returning user?")
-        print("  1. New user (register)")
-        print("  2. Returning user (login)")
-        choice = input("Enter choice (1 or 2): ").strip()
-
-        is_new_user = choice == "1"
-        action = "Registration" if is_new_user else "Login"
-
-        print(f"\n{action}")
-        print("-" * 40)
-
         email = self._prompt_academic_email()
         if not email:
             return False
@@ -83,18 +71,14 @@ class NocturnalConfig:
         if not password:
             return False
 
-        if is_new_user and not self._confirm_beta_terms():
+        if not self._confirm_beta_terms():
             print("❌ Terms must be accepted to continue")
             return False
 
         try:
-            credentials = self._provision_account(email, password, is_new_user=is_new_user)
-            if is_new_user:
-                print(f"\n✅ Account created successfully for {email}")
-            else:
-                print(f"\n✅ Logged in successfully as {email}")
+            credentials = self._provision_account(email, password)
         except AccountProvisioningError as exc:
-            print(f"❌ {action} failed: {exc}")
+            print(f"❌ Could not verify your account: {exc}")
             return False
 
         print("\n🛡️  Recap of beta limitations:")
@@ -179,9 +163,9 @@ class NocturnalConfig:
         print("❌ Could not confirm password after multiple attempts")
         return None
 
-    def _provision_account(self, email: str, password: str, is_new_user: bool = False) -> AccountCredentials:
+    def _provision_account(self, email: str, password: str) -> AccountCredentials:
         client = AccountClient()
-        return client.provision(email=email, password=password, is_new_user=is_new_user)
+        return client.provision(email=email, password=password)
 
     def _is_academic_email(self, email: str) -> bool:
         if "@" not in email:

cite_agent/streaming_ui.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""
+Streaming Chat UI - Cursor/Claude Style Interface
+Minimal, clean, conversational interface for data analysis assistant
+"""
+
+import sys
+import time
+import asyncio
+from typing import Optional, AsyncGenerator
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.text import Text
+from rich.live import Live
+from rich.spinner import Spinner
+
+console = Console()
+
+
+class StreamingChatUI:
+    """
+    Clean, minimal chat interface matching Cursor/Claude aesthetics
+    - Simple header (just app name)
+    - "You:" / "Agent:" conversation labels
+    - Streaming character-by-character output
+    - Transient action indicators
+    - Markdown rendering for rich text
+    """
+    
+    def __init__(self, app_name: str = "Nocturnal Archive", working_dir: Optional[str] = None):
+        self.app_name = app_name
+        self.working_dir = working_dir
+        self.console = Console()
+        self.typing_speed = 0.015  # ~60 chars/sec
+        
+    def show_header(self):
+        """Display minimal header on startup"""
+        self.console.print(f"\n[bold cyan]{self.app_name}[/bold cyan]")
+        if self.working_dir:
+            self.console.print(f"[dim]Connected to: {self.working_dir}[/dim]")
+        self.console.print("─" * 70)
+        self.console.print()
+    
+    def show_user_message(self, message: str):
+        """Display user message with 'You:' prefix"""
+        self.console.print(f"[bold]You:[/bold] {message}")
+        self.console.print()
+    
+    async def stream_agent_response(
+        self, 
+        content_generator: AsyncGenerator[str, None],
+        show_markdown: bool = True
+    ):
+        """
+        Stream agent response character-by-character
+        
+        Args:
+            content_generator: Async generator yielding text chunks
+            show_markdown: Whether to render as markdown (default True)
+        """
+        # No prefix for agent - just stream naturally
+        buffer = ""
+        
+        async for chunk in content_generator:
+            buffer += chunk
+            # Stream character by character for natural feel
+            for char in chunk:
+                self.console.print(char, end="", style="white")
+                await asyncio.sleep(self.typing_speed)
+        
+        self.console.print()  # Newline after response
+        self.console.print()  # Extra space for readability
+        
+        return buffer
+    
+    async def stream_markdown_response(self, markdown_text: str):
+        """
+        Stream a markdown response with proper formatting
+        Used for final rendering after streaming is complete
+        """
+        # Render markdown with Rich
+        md = Markdown(markdown_text)
+        self.console.print(md)
+        self.console.print()
+    
+    def show_action_indicator(self, action: str) -> Live:
+        """
+        Show a transient action indicator (e.g., [reading file...])
+        Returns Live object that should be stopped when action completes
+        
+        Usage:
+            indicator = ui.show_action_indicator("analyzing data")
+            # ... do work ...
+            indicator.stop()
+        """
+        spinner = Spinner("dots", text=f"[dim]{action}[/dim]")
+        live = Live(spinner, console=self.console, transient=True)
+        live.start()
+        return live
+    
+    def show_error(self, error_message: str):
+        """Display error message"""
+        self.console.print(f"[red]Error:[/red] {error_message}")
+        self.console.print()
+    
+    def show_info(self, message: str):
+        """Display info message"""
+        self.console.print(f"[dim]{message}[/dim]")
+        self.console.print()
+    
+    def show_rate_limit_message(
+        self, 
+        limit_type: str = "Archive API",
+        remaining_capabilities: Optional[list] = None
+    ):
+        """
+        Show soft degradation message when rate limited
+        
+        Args:
+            limit_type: What service is limited (e.g., "Archive API")
+            remaining_capabilities: List of what's still available
+        """
+        self.console.print(
+            f"\n[yellow]I've reached the daily limit for {limit_type} queries.[/yellow]\n"
+        )
+        
+        if remaining_capabilities:
+            self.console.print("[bold]However, I can still assist you with:[/bold]")
+            for capability in remaining_capabilities:
+                self.console.print(f"  • {capability}")
+            self.console.print()
+        
+        self.console.print(
+            "[dim]For unlimited access, consider upgrading to Pro.[/dim]\n"
+        )
+    
+    def get_user_input(self, prompt: str = "You: ") -> str:
+        """Get user input with custom prompt"""
+        try:
+            user_input = self.console.input(f"[bold]{prompt}[/bold]")
+            self.console.print()
+            return user_input.strip()
+        except (KeyboardInterrupt, EOFError):
+            self.console.print("\n[dim]Goodbye![/dim]")
+            sys.exit(0)
+    
+    def clear_screen(self):
+        """Clear terminal screen"""
+        self.console.clear()
+
+
+# Utility functions for streaming from Groq API
+
+async def groq_stream_to_generator(stream) -> AsyncGenerator[str, None]:
+    """
+    Convert Groq streaming response to async generator
+    
+    Args:
+        stream: Groq stream object from client.chat.completions.create(stream=True)
+    
+    Yields:
+        Text chunks from the stream
+    """
+    for chunk in stream:
+        if chunk.choices and chunk.choices[0].delta.content:
+            yield chunk.choices[0].delta.content
+
+
+async def simulate_streaming(text: str, chunk_size: int = 5) -> AsyncGenerator[str, None]:
+    """
+    Simulate streaming for testing purposes
+    
+    Args:
+        text: Full text to stream
+        chunk_size: Characters per chunk
+    
+    Yields:
+        Text chunks
+    """
+    for i in range(0, len(text), chunk_size):
+        chunk = text[i:i + chunk_size]
+        yield chunk
+        await asyncio.sleep(0.05)  # Simulate network delay
+
+
+# Example usage
+async def example_usage():
+    """Example of how to use the streaming UI"""
+    
+    ui = StreamingChatUI(
+        app_name="Nocturnal Archive",
+        working_dir="/home/researcher/project"
+    )
+    
+    # Show header on startup
+    ui.show_header()
+    
+    # Simulate conversation
+    ui.show_user_message("hello")
+    
+    # Simulate streaming response
+    response_text = (
+        "Good evening. I'm ready to assist with your analysis. "
+        "What would you like to work on today?"
+    )
+    
+    async def response_generator():
+        async for chunk in simulate_streaming(response_text):
+            yield chunk
+    
+    await ui.stream_agent_response(response_generator())
+    
+    # Get next user input
+    user_input = ui.get_user_input()
+    ui.show_user_message(user_input)
+    
+    # Show action indicator
+    indicator = ui.show_action_indicator("reading file")
+    await asyncio.sleep(2)  # Simulate work
+    indicator.stop()
+    
+    # Stream another response with markdown
+    markdown_response = """
+I can see you have several data files here:
+
+• **gdp_data_2020_2024.csv** (245 KB)
+• **unemployment_rates.xlsx** (89 KB)
+
+Which dataset would you like me to analyze first?
+"""
+    
+    async def md_generator():
+        async for chunk in simulate_streaming(markdown_response):
+            yield chunk
+    
+    await ui.stream_agent_response(md_generator())
+    
+    # Show rate limit message
+    ui.show_rate_limit_message(
+        limit_type="Archive API",
+        remaining_capabilities=[
+            "Local data analysis (unlimited)",
+            "Web searches (unlimited)",
+            "Financial data (5 queries remaining)",
+            "Conversation and file reading"
+        ]
+    )
+
+
+if __name__ == "__main__":
+    # Run example
+    asyncio.run(example_usage())

cite_agent/updater.py

@@ -12,18 +12,29 @@ from pathlib import Path
 from typing import Optional, Dict, Any
 
 try:
-    import pkg_resources
+    # Use modern importlib.metadata instead of deprecated pkg_resources
+    from importlib.metadata import version as get_version
+    pkg_resources = None  # Not needed anymore
 except ImportError:
-    pkg_resources = None
+    # Fallback for Python < 3.8
+    try:
+        import warnings
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=DeprecationWarning)
+            warnings.filterwarnings("ignore", category=UserWarning)
+            import pkg_resources
+    except ImportError:
+        pkg_resources = None
+        get_version = None
 
 class NocturnalUpdater:
     """Handles automatic updates for Nocturnal Archive"""
     
     def __init__(self):
         self.current_version = self.get_current_version()
-        self.package_name = "nocturnal-archive"
+        self.package_name = "cite-agent"  # Fixed: was "nocturnal-archive"
         self.pypi_url = f"https://pypi.org/pypi/{self.package_name}/json"
-        self.kill_switch_url = "https://api.nocturnal.dev/api/admin/status"
+        self.kill_switch_url = "https://cite-agent-api-720dfadd602c.herokuapp.com/api/health"
     
     def check_kill_switch(self) -> Dict[str, Any]:
         """Check if kill switch is activated"""
@@ -37,16 +48,23 @@ class NocturnalUpdater:
     
     def get_current_version(self) -> str:
         """Get current installed version"""
+        # Try modern importlib.metadata first
+        try:
+            return get_version(self.package_name)
+        except Exception:
+            pass
+        
+        # Fallback to pkg_resources (deprecated)
         if pkg_resources:
             try:
                 return pkg_resources.get_distribution(self.package_name).version
-            except (pkg_resources.DistributionNotFound, Exception):
+            except Exception:
                 pass
         
-        # Fallback: try to get version from installed package
+        # Last resort: try to get version from installed package
         try:
-            import nocturnal_archive
-            return getattr(nocturnal_archive, '__version__', '1.0.0')
+            import cite_agent
+            return getattr(cite_agent, '__version__', '1.0.0')
         except ImportError:
             return "1.0.0"
     
@@ -103,32 +121,47 @@ class NocturnalUpdater:
         except:
             return False
     
-    def update_package(self, force: bool = False) -> bool:
+    def update_package(self, force: bool = False, silent: bool = False) -> bool:
         """Update the package to latest version"""
         try:
-            print("🔄 Updating Nocturnal Archive...")
+            if not silent:
+                print("🔄 Updating cite-agent...")
             
             # Check if update is needed
             if not force:
                 update_info = self.check_for_updates()
                 if not update_info or not update_info["available"]:
-                    print("✅ No updates available")
+                    if not silent:
+                        print("✅ No updates available")
                     return True
             
-            # Perform update
-            cmd = [sys.executable, "-m", "pip", "install", "--upgrade", self.package_name]
+            # Perform update with user flag to avoid system package conflicts
+            cmd = [sys.executable, "-m", "pip", "install", "--upgrade", "--user", self.package_name]
             result = subprocess.run(cmd, capture_output=True, text=True)
             
             if result.returncode == 0:
-                new_version = self.get_current_version()
-                print(f"✅ Updated to version {new_version}")
+                # Create flag file to notify next launch
+                try:
+                    from pathlib import Path
+                    update_flag = Path.home() / ".nocturnal_archive" / ".updated"
+                    update_flag.parent.mkdir(exist_ok=True)
+                    update_flag.write_text(self.get_current_version())
+                except:
+                    pass
+                
+                if not silent:
+                    new_version = self.get_current_version()
+                    print(f"✅ Updated to version {new_version}")
+                    print("🔄 Restart cite-agent to use the new version")
                 return True
             else:
-                print(f"❌ Update failed: {result.stderr}")
+                if not silent:
+                    print(f"❌ Update failed: {result.stderr}")
                 return False
                 
         except Exception as e:
-            print(f"❌ Update error: {e}")
+            if not silent:
+                print(f"❌ Update error: {e}")
             return False
     
     def show_update_status(self):