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

cite_agent/__init__.py

@@ -7,7 +7,7 @@ prior stacks preserved only in Git history, kept out of the runtime footprint.
 
 from .enhanced_ai_agent import EnhancedNocturnalAgent, ChatRequest, ChatResponse
 
-__version__ = "1.0.4"
+__version__ = "0.9.0b1"
 __author__ = "Nocturnal Archive Team"
 __email__ = "contact@nocturnal.dev"
 

cite_agent/account_client.py

@@ -63,28 +63,14 @@ class AccountClient:
         )
         self.timeout = timeout
 
-    def provision(self, email: str, password: str, is_new_user: bool = False) -> AccountCredentials:
-        """
-        Provision account credentials (login or register).
-
-        Args:
-            email: User email address
-            password: User password
-            is_new_user: True for registration, False for login
-
-        Returns:
-            AccountCredentials object
-
-        Raises:
-            AccountProvisioningError: If authentication fails
-        """
+    def provision(self, email: str, password: str) -> AccountCredentials:
         if self.base_url:
-            payload = self._request_credentials(email, password, is_new_user=is_new_user)
+            payload = self._request_credentials(email, password)
             return AccountCredentials.from_payload(email=email, payload=payload)
         return self._generate_offline_credentials(email, password)
 
     # -- internal helpers -------------------------------------------------
-    def _request_credentials(self, email: str, password: str, is_new_user: bool = False) -> Dict[str, Any]:
+    def _request_credentials(self, email: str, password: str) -> Dict[str, Any]:
         try:  # pragma: no cover - requires network
             import requests  # type: ignore
         except Exception as exc:  # pragma: no cover - executed when requests missing
@@ -92,42 +78,29 @@ class AccountClient:
                 "The 'requests' package is required for control-plane authentication"
             ) from exc
 
-        # Choose endpoint based on is_new_user flag
-        if is_new_user:
-            endpoint = self.base_url.rstrip("/") + "/api/auth/register"
-            operation = "registration"
-        else:
-            endpoint = self.base_url.rstrip("/") + "/api/auth/login"
-            operation = "login"
-
+        # Try login first
+        login_endpoint = self.base_url.rstrip("/") + "/api/auth/login"
         body = {"email": email, "password": password}
 
         try:
-            response = requests.post(endpoint, json=body, timeout=self.timeout)
+            response = requests.post(login_endpoint, json=body, timeout=self.timeout)
         except Exception as exc:  # pragma: no cover - network failure
-            raise AccountProvisioningError(f"Failed to reach control plane for {operation}") from exc
+            raise AccountProvisioningError("Failed to reach control plane") from exc
 
-        # Handle errors
+        # If login fails with 401 (user doesn't exist), try registration
+        if response.status_code == 401:
+            register_endpoint = self.base_url.rstrip("/") + "/api/auth/register"
+            try:
+                response = requests.post(register_endpoint, json=body, timeout=self.timeout)
+            except Exception as exc:
+                raise AccountProvisioningError("Failed to register account") from exc
+
+        # If still failing, raise error
         if response.status_code >= 400:
             detail = self._extract_error_detail(response)
-
-            # Provide helpful error messages
-            if response.status_code == 401 and not is_new_user:
-                raise AccountProvisioningError(
-                    f"Login failed: Invalid email or password. If you're a new user, please register first."
-                )
-            elif response.status_code == 409:
-                raise AccountProvisioningError(
-                    f"Registration failed: This email is already registered. Please log in instead."
-                )
-            elif response.status_code == 400 and "academic" in detail.lower():
-                raise AccountProvisioningError(
-                    f"Registration requires an academic email address (.edu, .ac.uk, etc.)"
-                )
-            else:
-                raise AccountProvisioningError(
-                    f"{operation.capitalize()} failed (status {response.status_code}): {detail}"
-                )
+            raise AccountProvisioningError(
+                f"Authentication failed (status {response.status_code}): {detail}"
+            )
 
         try:
             payload = response.json()

cite_agent/agent_backend_only.py

@@ -24,6 +24,7 @@ class ChatResponse:
     tools_used: list = None
     model: str = "backend"
     timestamp: str = None
+    tokens_used: int = 0
 
     def __post_init__(self):
         if self.timestamp is None:
@@ -45,6 +46,7 @@ class EnhancedNocturnalAgent:
             or "https://cite-agent-api-720dfadd602c.herokuapp.com"
         )
         self.auth_token = None
+        self.daily_token_usage = 0
         self._load_auth()
 
     def _load_auth(self):
@@ -66,10 +68,8 @@ class EnhancedNocturnalAgent:
     async def initialize(self):
         """Initialize agent"""
         if not self.auth_token:
-            raise RuntimeError(
-                "Not authenticated. Please run 'cite-agent --setup' first."
-            )
-        print(f"✅ Connected to backend: {self.backend_url}")
+            return False
+        return True
 
     async def chat(self, request: ChatRequest) -> ChatResponse:
         """
@@ -170,3 +170,29 @@ class EnhancedNocturnalAgent:
             "tokens_remaining": data.get("tokens_remaining", 0),
             "daily_limit": 25000,
         }
+
+    async def process_request(self, request: ChatRequest) -> ChatResponse:
+        """Process request (alias for chat method for CLI compatibility)"""
+        return await self.chat(request)
+
+    def get_usage_stats(self) -> Dict[str, Any]:
+        """Get usage statistics for CLI display"""
+        try:
+            quota = self.check_quota()
+            tokens_used = quota.get("tokens_used", 0)
+            daily_limit = quota.get("daily_limit", 50000)
+            usage_pct = (tokens_used / daily_limit * 100) if daily_limit > 0 else 0
+
+            return {
+                "daily_tokens_used": tokens_used,
+                "daily_token_limit": daily_limit,
+                "usage_percentage": usage_pct,
+                "tokens_remaining": quota.get("tokens_remaining", 0)
+            }
+        except Exception:
+            return {
+                "daily_tokens_used": 0,
+                "daily_token_limit": 50000,
+                "usage_percentage": 0,
+                "tokens_remaining": 50000
+            }

cite_agent/cli.py

@@ -63,15 +63,26 @@ class NocturnalCLI:
         self.telemetry = TelemetryManager.get()
 
         if not config.check_setup():
-            self.console.print("\n[warning]👋 Hey there, looks like this machine hasn't met Nocturnal yet.[/warning]")
-            self.console.print("[banner]Let's get you signed in — this only takes a minute.[/banner]")
-            try:
-                if not config.interactive_setup():
-                    self.console.print("[error]❌ Setup was cancelled. Exiting without starting the agent.[/error]")
+            # Check if we have env vars or session file (non-interactive mode)
+            import os
+            from pathlib import Path
+            session_file = Path.home() / ".nocturnal_archive" / "session.json"
+            has_env_creds = os.getenv("NOCTURNAL_ACCOUNT_EMAIL") and os.getenv("NOCTURNAL_ACCOUNT_PASSWORD")
+            
+            if session_file.exists() or has_env_creds:
+                # Skip interactive setup if session exists or env vars present
+                self.console.print("[success]⚙️  Using saved credentials.[/success]")
+            else:
+                # Need interactive setup
+                self.console.print("\n[warning]👋 Hey there, looks like this machine hasn't met Nocturnal yet.[/warning]")
+                self.console.print("[banner]Let's get you signed in — this only takes a minute.[/banner]")
+                try:
+                    if not config.interactive_setup():
+                        self.console.print("[error]❌ Setup was cancelled. Exiting without starting the agent.[/error]")
+                        return False
+                except (KeyboardInterrupt, EOFError):
+                    self.console.print("\n[error]❌ Setup interrupted. Exiting without starting the agent.[/error]")
                     return False
-            except (KeyboardInterrupt, EOFError):
-                self.console.print("\n[error]❌ Setup interrupted. Exiting without starting the agent.[/error]")
-                return False
             config.setup_environment()
             TelemetryManager.refresh()
             self.telemetry = TelemetryManager.get()
@@ -146,22 +157,9 @@ class NocturnalCLI:
     
     def _enforce_latest_build(self):
         """Ensure the CLI is running the most recent published build."""
-        try:
-            updater = NocturnalUpdater()
-            update_info = updater.check_for_updates()
-        except Exception:
-            return
-
-        if not update_info or not update_info.get("available"):
-            return
-
-        latest_version = update_info.get("latest", "latest")
-        self.console.print(f"[banner]⬆️  Updating Nocturnal Archive to {latest_version} before launch...[/banner]")
-
-        if updater.update_package():
-            self._save_update_notification(latest_version)
-            self.console.print("[warning]♻️  Restarting to finish applying the update...[/warning]")
-            self._restart_cli()
+        # Skip update check for beta - not published to PyPI yet
+        # TODO: Re-enable after PyPI publication
+        return
 
     def _restart_cli(self):
         """Re-exec the CLI using the current interpreter and arguments."""
@@ -442,8 +440,8 @@ Examples:
     
     # Handle version
     if args.version:
-        print("Cite-Agent v1.0.4")
-        print("AI Research Assistant - Backend-Only Distribution")
+        print("Nocturnal Archive v1.0.0")
+        print("AI Research Assistant with real data integration")
         return
 
     if args.tips or (args.query and args.query.lower() == "tips" and not args.interactive):

cite_agent/cli_conversational.py

@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+"""
+Nocturnal Archive - Conversational Data Analysis Assistant
+Main CLI with streaming UI, Jarvis personality, and full capabilities
+"""
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+# Add nocturnal_archive to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from streaming_ui import StreamingChatUI, simulate_streaming
+from web_search import WebSearchIntegration
+from enhanced_ai_agent import EnhancedNocturnalAgent
+
+
+class NocturnalArchiveCLI:
+    """
+    Main CLI orchestrator bringing together:
+    - Streaming chat UI (Cursor/Claude style)
+    - Enhanced AI agent (with APIs)
+    - Web search capability
+    - Jarvis-like professional personality
+    """
+    
+    def __init__(self):
+        self.ui = None
+        self.agent = None
+        self.web_search = None
+        self.working_dir = os.getcwd()
+        self.conversation_active = True
+        
+    async def initialize(self):
+        """Initialize all components"""
+        # Initialize UI
+        self.ui = StreamingChatUI(
+            app_name="Nocturnal Archive",
+            working_dir=self.working_dir
+        )
+        
+        # Initialize agent
+        self.agent = EnhancedNocturnalAgent()
+        await self.agent.initialize()
+        
+        # Initialize web search
+        self.web_search = WebSearchIntegration()
+        
+        # Update agent personality to Jarvis-like professional tone
+        await self._configure_jarvis_personality()
+    
+    async def _configure_jarvis_personality(self):
+        """Configure the agent with Jarvis-like professional personality"""
+        # This will update the system prompts in the agent
+        # The agent already has conversation memory, we just adjust tone
+        
+        jarvis_system_prompt = """You are a professional research and data analysis assistant with a refined, helpful demeanor similar to Jarvis from Iron Man.
+
+Your communication style:
+- Professional and intelligent, never casual or overly friendly
+- Verbose when explaining complex topics, but always clear
+- Use complete sentences and proper grammar
+- Greet users formally: "Good evening" / "Good morning" (based on time)
+- Ask clarifying questions when needed
+- Acknowledge tasks before executing: "Understood. Let me..." or "Certainly, I'll..."
+- Show intermediate progress: "I can see..." / "The data indicates..."
+- Offer next steps conversationally: "Would you like me to..."
+
+Your capabilities:
+- Analyze local data files (CSV, Excel, Stata, etc.)
+- Run statistical tests and data transformations
+- Search academic papers (Archive API)
+- Fetch financial data (FinSight API)
+- Browse the web for current information
+- Execute shell commands safely
+- Generate visualizations
+
+Primary role: You're a DATA ANALYSIS assistant first, research assistant second.
+- When users mention data files, offer to analyze them
+- Proactively suggest relevant statistical tests
+- Explain results in context, not just numbers
+- Synthesize information naturally, avoid bullet-point lists unless specifically listing items
+
+Remember:
+- Never invent data or citations
+- Be honest about limitations
+- Offer alternatives when rate-limited
+- Maintain conversation flow naturally
+"""
+        
+        # Store this for when we make requests
+        self.jarvis_prompt = jarvis_system_prompt
+    
+    async def run(self):
+        """Main conversation loop"""
+        try:
+            # Show welcome
+            self.ui.show_header()
+            
+            # Jarvis-style greeting based on time of day
+            from datetime import datetime
+            hour = datetime.now().hour
+            if hour < 12:
+                greeting = "Good morning."
+            elif hour < 18:
+                greeting = "Good afternoon."
+            else:
+                greeting = "Good evening."
+            
+            welcome_message = (
+                f"{greeting} I'm ready to assist with your analysis. "
+                "What would you like to work on today?"
+            )
+            
+            # Stream the welcome message
+            async def welcome_gen():
+                async for chunk in simulate_streaming(welcome_message, chunk_size=3):
+                    yield chunk
+            
+            await self.ui.stream_agent_response(welcome_gen())
+            
+            # Main conversation loop
+            while self.conversation_active:
+                try:
+                    # Get user input
+                    user_input = self.ui.get_user_input()
+                    
+                    if not user_input:
+                        continue
+                    
+                    # Check for exit commands
+                    if user_input.lower() in ['exit', 'quit', 'bye', 'goodbye']:
+                        farewell = "Goodbye. Feel free to return whenever you need assistance."
+                        async def farewell_gen():
+                            async for chunk in simulate_streaming(farewell, chunk_size=3):
+                                yield chunk
+                        await self.ui.stream_agent_response(farewell_gen())
+                        break
+                    
+                    # Process the request
+                    await self._process_user_request(user_input)
+                    
+                except KeyboardInterrupt:
+                    self.ui.show_info("\nInterrupted. Goodbye.")
+                    break
+                except Exception as e:
+                    self.ui.show_error(f"An error occurred: {str(e)}")
+                    continue
+        
+        finally:
+            await self.cleanup()
+    
+    async def _process_user_request(self, user_input: str):
+        """
+        Process user request with full capabilities:
+        - Detect intent (data analysis, web search, research, etc.)
+        - Use appropriate tools
+        - Stream response naturally
+        """
+        
+        # Determine if this is a web search request
+        is_web_search = any(keyword in user_input.lower() for keyword in [
+            'google', 'search for', 'browse', 'look up', 'find on the web',
+            'what does', 'who is', 'recent news'
+        ])
+        
+        # Determine if this is a data analysis request
+        is_data_analysis = any(keyword in user_input.lower() for keyword in [
+            'analyze', 'data', 'csv', 'plot', 'graph', 'test', 'regression',
+            'correlation', 'statistics', 'mean', 'median', 'distribution'
+        ])
+        
+        # For now, let's handle web search directly as an example
+        if is_web_search and 'google' in user_input.lower():
+            # Extract search query
+            query = user_input.lower().replace('google', '').replace('search for', '').strip()
+            
+            # Show indicator
+            indicator = self.ui.show_action_indicator(f"browsing web for '{query}'")
+            
+            try:
+                # Perform web search
+                result = await self.web_search.search_web(query, num_results=5)
+                indicator.stop()
+                
+                # Stream the response
+                response_text = result.get('formatted_response', 'No results found.')
+                async def response_gen():
+                    async for chunk in simulate_streaming(response_text, chunk_size=4):
+                        yield chunk
+                
+                await self.ui.stream_agent_response(response_gen())
+                
+            except Exception as e:
+                indicator.stop()
+                self.ui.show_error(f"Web search failed: {str(e)}")
+        
+        else:
+            # For other requests, use the enhanced agent
+            indicator = self.ui.show_action_indicator("processing your request")
+            
+            try:
+                # Call the agent with REAL Groq streaming
+                from enhanced_ai_agent import ChatRequest
+                from streaming_ui import groq_stream_to_generator
+                
+                request = ChatRequest(
+                    question=user_input,
+                    user_id="cli_user",
+                    conversation_id="main_session"
+                )
+                
+                # Get streaming response from agent
+                try:
+                    # Check if agent has streaming support
+                    if hasattr(self.agent, 'process_request_streaming'):
+                        # Use real streaming
+                        stream = await self.agent.process_request_streaming(request)
+                        indicator.stop()
+                        await self.ui.stream_agent_response(groq_stream_to_generator(stream))
+                    else:
+                        # Fallback to non-streaming
+                        response = await self.agent.process_request(request)
+                        indicator.stop()
+                        
+                        # Check for rate limiting
+                        if response.error_message and 'limit' in response.error_message.lower():
+                            self.ui.show_rate_limit_message(
+                                limit_type="API queries",
+                                remaining_capabilities=[
+                                    "Local data analysis (unlimited)",
+                                    "Web searches (unlimited)",
+                                    "General conversation",
+                                    "File operations"
+                                ]
+                            )
+                        
+                        # Stream the response (simulated for now)
+                        response_text = response.response
+                        async def response_gen():
+                            for char in response_text:
+                                yield char
+                        
+                        await self.ui.stream_agent_response(response_gen())
+                        
+                except Exception as e:
+                    indicator.stop()
+                    self.ui.show_error(f"Error: {str(e)}")
+                
+            except Exception as e:
+                indicator.stop()
+                self.ui.show_error(f"Request processing failed: {str(e)}")
+    
+    async def cleanup(self):
+        """Clean up resources"""
+        if self.agent:
+            await self.agent.close()
+        if self.web_search:
+            await self.web_search.close()
+
+
+async def main():
+    """Main entry point"""
+    cli = NocturnalArchiveCLI()
+    
+    try:
+        await cli.initialize()
+        await cli.run()
+    except KeyboardInterrupt:
+        print("\n\nGoodbye!")
+    except Exception as e:
+        print(f"\n❌ Fatal error: {e}")
+        import traceback
+        traceback.print_exc()
+    finally:
+        await cli.cleanup()
+
+
+if __name__ == "__main__":
+    # Check dependencies
+    try:
+        import rich
+        import groq
+        import aiohttp
+    except ImportError as e:
+        print(f"❌ Missing dependency: {e}")
+        print("Install requirements: pip install -r requirements.txt")
+        sys.exit(1)
+    
+    # Run the CLI
+    asyncio.run(main())