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

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-1.0.4.dist-info → cite_agent-1.0.5.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: cite-agent
-Version: 1.0.4
-Summary: AI Research Assistant - Backend-Only Distribution
+Version: 1.0.5
+Summary: Terminal AI assistant for academic research with citation verification
 Home-page: https://github.com/Spectating101/cite-agent
 Author: Cite-Agent Team
 Author-email: contact@citeagent.dev
@@ -15,8 +15,9 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests>=2.31.0
 Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: groq>=0.4.0
+Requires-Dist: requests>=2.31.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: pydantic>=2.5.0
 Requires-Dist: rich>=13.7.0

cite_agent-1.0.5.dist-info/RECORD

@@ -0,0 +1,50 @@
+cite_agent/__init__.py,sha256=wAXV2v8nNOmIAd0rh8196ItBl9hHWBVOBl5Re4VB77I,1645
+cite_agent/account_client.py,sha256=yLuzhIJoIZuXHXGbaVMzDxRATQwcy-wiaLnUrDuwUhI,5725
+cite_agent/agent_backend_only.py,sha256=H4DH4hmKhT0T3rQLAb2xnnJVjxl3pOZaljL9r6JndFY,6314
+cite_agent/ascii_plotting.py,sha256=lk8BaECs6fmjtp4iH12G09-frlRehAN7HLhHt2crers,8570
+cite_agent/auth.py,sha256=CYBNv8r1_wfdhsx-YcWOiXCiKvPBymaMca6w7JV__FQ,9809
+cite_agent/backend_only_client.py,sha256=WqLF8x7aXTro2Q3ehqKMsdCg53s6fNk9Hy86bGxqmmw,2561
+cite_agent/cli.py,sha256=ddZNtv8NPWlzTsipFZ1dgbgUAK7BrpY9GJP9jGkqs_I,18704
+cite_agent/cli_conversational.py,sha256=RAmgRNRyB8gQ8QLvWU-Tt23j2lmA34rQNT5F3_7SOq0,11141
+cite_agent/cli_enhanced.py,sha256=EAaSw9qtiYRWUXF6_05T19GCXlz9cCSz6n41ASnXIPc,7407
+cite_agent/dashboard.py,sha256=VGV5XQU1PnqvTsxfKMcue3j2ri_nvm9Be6O5aVays_w,10502
+cite_agent/enhanced_ai_agent.py,sha256=uDAchU26IfGtmAhzhwsxZ_oOQTCB8za-wfPkKRdaibQ,121739
+cite_agent/rate_limiter.py,sha256=-0fXx8Tl4zVB4O28n9ojU2weRo-FBF1cJo9Z5jC2LxQ,10908
+cite_agent/setup_config.py,sha256=kNZNr5cZmCXr43rGWNenNJXZ1Kfz7PrdLXpAqxM7WgM,16404
+cite_agent/streaming_ui.py,sha256=N6TWOo7GVQ_Ynfw73JCfrdGcLIU-PwbS3GbsHQHegmg,7810
+cite_agent/telemetry.py,sha256=55kXdHvI24ZsEkbFtihcjIfJt2oiSXcEpLzTxQ3KCdQ,2916
+cite_agent/ui.py,sha256=r1OAeY3NSeqhAjJYmEBH9CaennBuibFAz1Mur6YF80E,6134
+cite_agent/updater.py,sha256=kL2GYL1AKoZ9JoTXxFT5_AkvYvObcCrO2sIVyBw9JgU,7057
+cite_agent/web_search.py,sha256=j-BRhT8EBC6BEPgACQPeVwB1SVGKDz4XLM7sowacvSc,6587
+cite_agent-1.0.5.dist-info/licenses/LICENSE,sha256=XJkyO4IymhSUniN1ENY6lLrL2729gn_rbRlFK6_Hi9M,1074
+src/__init__.py,sha256=0eEpjRfjRjOTilP66y-AbGNslBsVYr_clE-bZUzsX7s,40
+src/services/__init__.py,sha256=pTGLCH_84mz4nGtYMwQES5w-LzoSulUtx_uuNM6r-LA,4257
+src/services/simple_enhanced_main.py,sha256=IJoOplCqcVUg3GvN_BRyAhpGrLm_WEPy2jmHcNCY6R0,9257
+src/services/auth_service/__init__.py,sha256=VVFfBUr_GMJuxVH_553D2PZmZ9vhHeab9_qiJEf-g6Q,38
+src/services/auth_service/auth_manager.py,sha256=MJdWFE36R_htoyBbjgGSTSx2Py61sTM3lhBjXBZ4Bog,873
+src/services/graph/__init__.py,sha256=jheRQ-x652RZ68fKyUqUNGXmTAJsp5URVMhlOauFRO0,29
+src/services/graph/knowledge_graph.py,sha256=ips2IpVpxDFkdPku4XKgZNRnoR2NjZqZk3xbIArJaaM,7348
+src/services/llm_service/__init__.py,sha256=eNAsQpJtVXpJENb-gHtpKzWpncnHHAMB05EI48wrugQ,122
+src/services/llm_service/llm_manager.py,sha256=6o5KN-3wJ0hT8PS9hPMpTGS6G9SlleSzYsXZQRjj_vI,21027
+src/services/paper_service/__init__.py,sha256=0ONhTf_3H81l5y6EqHMRZd5dCXLAXDa-gbYwge84zKA,142
+src/services/paper_service/openalex.py,sha256=pPhPcHMK2gQJCUVPB4ujE8xya0UqUvfcN95cy5ooP68,8801
+src/services/performance_service/__init__.py,sha256=48bYfW4pzf-FG9644kTnNwGyD1tJJ7tVn3cD3r_ZAbk,65
+src/services/performance_service/rust_performance.py,sha256=n-FzJ98XslmpUAkmmuaunYDTPz-9ZY-qL4oWAoBAaoA,15558
+src/services/research_service/__init__.py,sha256=ZCBzSUdstHqwMmJ1x0kJK4PkRlv9OrSOEFeQFoVM-7M,813
+src/services/research_service/chatbot.py,sha256=12pVAoe_fd2RXi6_cP-fxfRnWyJStsyn8znVu5cy9qo,91153
+src/services/research_service/citation_manager.py,sha256=vzyVivBS0_9IiFE-wOH9hiLiC-fpHmiaZpR1084DenE,16586
+src/services/research_service/context_manager.py,sha256=FGbeylLWKvgoA5fElyiqg5IhnMBIZ-t3w0oDHN4Zy1E,61332
+src/services/research_service/conversation_manager.py,sha256=-rdzURzu-SiqozyeQLid5a5lS-KzIqGDozdE8BG-DTs,22854
+src/services/research_service/critical_paper_detector.py,sha256=gc3oZHB8RqDhxFqJx21NoKLcHmmqHXRo0eXY-AL5KSc,21941
+src/services/research_service/enhanced_research.py,sha256=5B8zZjJ2iSLEgnjfyDKow5x_MLRANLJdMbLmmPR5Lc0,4268
+src/services/research_service/enhanced_synthesizer.py,sha256=puJg2C10KXryCMPkec-chC4rxbIJdFFswo7w4rbaXkc,16603
+src/services/research_service/query_generator.py,sha256=LcFTGsewE6l2LRgUI2E6fXAcpy4vaYaUFFfZhI_WlYU,30707
+src/services/research_service/synthesizer.py,sha256=lCcu37PWhWVNphHKaJJDIC-JQ5OINAN7OJ7iV9BWAvM,52557
+src/services/search_service/__init__.py,sha256=UZFXdd7r6wietQ2kESXEyGffdfBbpghquecQde7auF4,137
+src/services/search_service/indexer.py,sha256=u3-uwdAfmahWWsdebDF9i8XIyp7YtUMIHzlmBLBnPPM,7252
+src/services/search_service/search_engine.py,sha256=S9HqQ_mk-8W4d4MUOgBbEGQGV29-eSuceSFvVb4Xk-k,12500
+cite_agent-1.0.5.dist-info/METADATA,sha256=MuIZ15aNJBnahJSKtmW6kqNHIZVUVtCb_XLjz4Voc0w,6904
+cite_agent-1.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cite_agent-1.0.5.dist-info/entry_points.txt,sha256=bJ0u28nFIxQKH1PWQ2ak4PV-FAjhoxTC7YADEdDenFw,83
+cite_agent-1.0.5.dist-info/top_level.txt,sha256=TgOFqJTIy8vDZuOoYA2QgagkqZtfhM5Acvt_IsWzAKo,15
+cite_agent-1.0.5.dist-info/RECORD,,

{cite_agent-1.0.4.dist-info → cite_agent-1.0.5.dist-info}/top_level.txt

@@ -1 +1,2 @@
 cite_agent
+src

src/__init__.py

@@ -0,0 +1 @@
+"""Project root package initializer."""

src/services/__init__.py

@@ -0,0 +1,132 @@
+"""
+Main services package for AI services layer
+Provides unified access to all service components
+"""
+
+# Import all major service classes for easy access
+from .llm_service.llm_manager import LLMManager
+from .research_service.enhanced_research import EnhancedResearchService  
+from .context_manager.advanced_context import AdvancedContextManager
+from .tool_framework.tool_manager import ToolManager
+from .auth_service.auth_manager import auth_manager
+
+# Service registry for dependency injection
+SERVICE_REGISTRY = {}
+
+def register_service(name: str, service_instance):
+    """Register a service instance in the global registry"""
+    SERVICE_REGISTRY[name] = service_instance
+
+def get_service(name: str):
+    """Get a service instance from the registry"""
+    return SERVICE_REGISTRY.get(name)
+
+def initialize_services(config: dict = None):
+    """Initialize all core services with configuration"""
+    config = config or {}
+    
+    # Initialize services (with minimal config for testing)
+    services = {}
+    
+    try:
+        # LLM Manager (needs redis_url but we'll handle gracefully)
+        redis_url = config.get('redis_url', 'redis://localhost:6379')
+        llm_manager = LLMManager(redis_url=redis_url)
+        services['llm_manager'] = llm_manager
+        register_service('llm_manager', llm_manager)
+    except Exception as e:
+        # Graceful fallback for testing
+        print(f"LLM Manager initialization skipped: {e}")
+    
+    try:
+        # Research Service
+        research_service = EnhancedResearchService()
+        services['research_service'] = research_service
+        register_service('research_service', research_service)
+    except Exception as e:
+        print(f"Research Service initialization skipped: {e}")
+    
+    try:
+        # Context Manager  
+        context_manager = AdvancedContextManager()
+        services['context_manager'] = context_manager
+        register_service('context_manager', context_manager)
+    except Exception as e:
+        print(f"Context Manager initialization skipped: {e}")
+    
+    try:
+        # Tool Manager
+        tool_manager = ToolManager()
+        services['tool_manager'] = tool_manager
+        register_service('tool_manager', tool_manager)
+    except Exception as e:
+        print(f"Tool Manager initialization skipped: {e}")
+    
+    return services
+
+class ServiceLayer:
+    """Unified service layer for easy access to all AI services"""
+    
+    def __init__(self, config: dict = None):
+        self.config = config or {}
+        self.services = {}
+        self._initialized = False
+    
+    def initialize(self):
+        """Initialize all services"""
+        if self._initialized:
+            return
+            
+        self.services = initialize_services(self.config)
+        self._initialized = True
+    
+    @property
+    def llm_manager(self) -> LLMManager:
+        """Get LLM Manager service"""
+        return self.services.get('llm_manager')
+    
+    @property 
+    def research_service(self) -> EnhancedResearchService:
+        """Get Research service"""
+        return self.services.get('research_service')
+    
+    @property
+    def context_manager(self) -> AdvancedContextManager:
+        """Get Context Manager service"""
+        return self.services.get('context_manager')
+    
+    @property
+    def tool_manager(self) -> ToolManager:
+        """Get Tool Manager service"""
+        return self.services.get('tool_manager')
+    
+    def get_health_status(self) -> dict:
+        """Get health status of all services"""
+        status = {
+            "services_initialized": self._initialized,
+            "total_services": len(self.services),
+            "available_services": list(self.services.keys())
+        }
+        return status
+
+# Global service layer instance
+_service_layer = None
+
+def get_service_layer(config: dict = None) -> ServiceLayer:
+    """Get the global service layer instance"""
+    global _service_layer
+    if _service_layer is None:
+        _service_layer = ServiceLayer(config)
+    return _service_layer
+
+# Export key classes and functions
+__all__ = [
+    'LLMManager',
+    'EnhancedResearchService', 
+    'AdvancedContextManager',
+    'ToolManager',
+    'ServiceLayer',
+    'get_service_layer',
+    'initialize_services',
+    'auth_manager'
+]

src/services/auth_service/__init__.py

@@ -0,0 +1,3 @@
+"""
+Authentication service package
+"""

src/services/auth_service/auth_manager.py

@@ -0,0 +1,33 @@
+"""
+Basic authentication manager for testing
+"""
+from typing import Dict, Any, Optional
+
+
+class AuthManager:
+    """Basic auth manager for testing purposes"""
+    
+    def __init__(self):
+        self.test_user = {
+            "id": "test_user_123",
+            "username": "test_user",
+            "email": "test@example.com"
+        }
+    
+    async def get_current_user(self) -> Dict[str, Any]:
+        """Return test user for testing"""
+        return self.test_user
+    
+    def verify_token(self, token: str) -> Optional[Dict[str, Any]]:
+        """Verify token (test implementation)"""
+        if token == "test_token":
+            return self.test_user
+        return None
+    
+    def create_token(self, user_data: Dict[str, Any]) -> str:
+        """Create token (test implementation)"""
+        return "test_token"
+
+
+# Global instance
+auth_manager = AuthManager()

src/services/graph/__init__.py

@@ -0,0 +1 @@
+"""Graph service package."""