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

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())

cite_agent/cli_workflow.py

@@ -0,0 +1,276 @@
+"""
+Enhanced CLI with workflow integration features
+Reduces context switching for scholars
+"""
+
+import asyncio
+import json
+import os
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+try:
+    import structlog
+except ImportError:
+    import logging
+    structlog = logging
+
+from .enhanced_ai_agent import EnhancedNocturnalAgent, ChatRequest
+from .workflow_integration import WorkflowIntegration
+
+logger = structlog.getLogger(__name__)
+
+class WorkflowCLI:
+    """Enhanced CLI with workflow integration"""
+    
+    def __init__(self):
+        self.agent = None
+        self.workflow = WorkflowIntegration()
+        self.session_id = f"workflow_{os.getpid()}"
+        
+    async def initialize(self):
+        """Initialize the agent and workflow"""
+        self.agent = EnhancedNocturnalAgent()
+        await self.agent.initialize()
+        
+    async def close(self):
+        """Clean up resources"""
+        if self.agent:
+            await self.agent.close()
+    
+    async def search_and_save(self, query: str, user_id: str = "default") -> Dict[str, Any]:
+        """Search papers and save to library"""
+        try:
+            # Search for papers
+            request = ChatRequest(
+                question=f"Find academic papers about: {query}",
+                user_id=user_id,
+                conversation_id=self.session_id
+            )
+            
+            response = await self.agent.process_request(request)
+            
+            # Extract papers from response
+            papers = self._extract_papers_from_response(response)
+            
+            # Save papers to library
+            saved_papers = []
+            for paper in papers:
+                paper_id = self.workflow.save_paper_to_library(paper, user_id)
+                saved_papers.append({
+                    "id": paper_id,
+                    "title": paper.get("title", "Unknown Title")
+                })
+            
+            # Save session
+            session_id = self.workflow.save_session_history(
+                user_id, 
+                query, 
+                {
+                    "response": response.response,
+                    "papers": papers,
+                    "tools_used": response.tools_used
+                }
+            )
+            
+            return {
+                "success": True,
+                "papers_found": len(papers),
+                "papers_saved": len(saved_papers),
+                "session_id": session_id,
+                "saved_papers": saved_papers
+            }
+            
+        except Exception as e:
+            logger.error("Error in search_and_save", error=str(e))
+            return {"success": False, "error": str(e)}
+    
+    def _extract_papers_from_response(self, response) -> List[Dict[str, Any]]:
+        """Extract paper data from agent response"""
+        papers = []
+        
+        # Try to extract from execution_results
+        if hasattr(response, 'execution_results') and response.execution_results:
+            for result in response.execution_results.values():
+                if isinstance(result, dict) and 'papers' in result:
+                    papers.extend(result['papers'])
+        
+        # Try to extract from api_results
+        if hasattr(response, 'api_results') and response.api_results:
+            for result in response.api_results.values():
+                if isinstance(result, dict) and 'papers' in result:
+                    papers.extend(result['papers'])
+        
+        return papers
+    
+    async def export_library(self, user_id: str, format: str = "bibtex") -> str:
+        """Export user's library in specified format"""
+        try:
+            library = self.workflow.get_user_library(user_id)
+            papers = [paper_data.get('paper', {}) for paper_data in library]
+            
+            if format == "bibtex":
+                filename = f"library_{user_id}.bib"
+                file_path = self.workflow.export_to_bibtex(papers, filename)
+            elif format == "markdown":
+                filename = f"library_{user_id}.md"
+                file_path = self.workflow.export_to_markdown(papers, filename)
+            else:
+                raise ValueError(f"Unsupported format: {format}")
+            
+            return file_path
+            
+        except Exception as e:
+            logger.error("Error exporting library", error=str(e))
+            raise
+    
+    def search_library(self, user_id: str, query: str) -> List[Dict[str, Any]]:
+        """Search user's saved library"""
+        return self.workflow.search_library(user_id, query)
+    
+    def get_library_stats(self, user_id: str) -> Dict[str, Any]:
+        """Get library statistics"""
+        library = self.workflow.get_user_library(user_id)
+        sessions = self.workflow.get_session_history(user_id, 100)
+        
+        # Calculate stats
+        total_papers = len(library)
+        
+        # Papers by year
+        papers_by_year = {}
+        for paper_data in library:
+            paper = paper_data.get('paper', {})
+            year = paper.get('year', 'Unknown')
+            papers_by_year[year] = papers_by_year.get(year, 0) + 1
+        
+        # Most used tools
+        tools_used = {}
+        for session in sessions:
+            for tool in session.get('tools_used', []):
+                tools_used[tool] = tools_used.get(tool, 0) + 1
+        
+        return {
+            "total_papers": total_papers,
+            "total_sessions": len(sessions),
+            "papers_by_year": papers_by_year,
+            "most_used_tools": dict(sorted(tools_used.items(), key=lambda x: x[1], reverse=True)[:5])
+        }
+    
+    async def get_citation_suggestions(self, paper: Dict[str, Any]) -> List[str]:
+        """Get citation suggestions for a paper"""
+        return self.workflow.generate_citation_suggestions(paper)
+    
+    def get_session_history(self, user_id: str, limit: int = 10) -> List[Dict[str, Any]]:
+        """Get recent session history"""
+        return self.workflow.get_session_history(user_id, limit)
+    
+    async def interactive_workflow(self, user_id: str = "default"):
+        """Interactive workflow mode"""
+        print("🔬 Cite-Agent Workflow Mode")
+        print("=" * 50)
+        print("Commands:")
+        print("  search <query>     - Search and save papers")
+        print("  library            - Show saved papers")
+        print("  export <format>    - Export library (bibtex/markdown)")
+        print("  stats              - Show library statistics")
+        print("  history            - Show recent searches")
+        print("  suggest <title>    - Get citation suggestions")
+        print("  quit               - Exit workflow mode")
+        print()
+        
+        while True:
+            try:
+                command = input("workflow> ").strip()
+                
+                if command.lower() in ['quit', 'exit', 'q']:
+                    break
+                elif command.startswith('search '):
+                    query = command[7:].strip()
+                    if query:
+                        result = await self.search_and_save(query, user_id)
+                        if result['success']:
+                            print(f"✅ Found {result['papers_found']} papers, saved {result['papers_saved']}")
+                        else:
+                            print(f"❌ Error: {result.get('error', 'Unknown error')}")
+                    else:
+                        print("❌ Please provide a search query")
+                
+                elif command == 'library':
+                    library = self.workflow.get_user_library(user_id)
+                    if library:
+                        print(f"📚 Library ({len(library)} papers):")
+                        for i, paper_data in enumerate(library[:10], 1):
+                            paper = paper_data.get('paper', {})
+                            title = paper.get('title', 'Unknown Title')[:60]
+                            year = paper.get('year', 'Unknown')
+                            print(f"  {i}. {title}... ({year})")
+                        if len(library) > 10:
+                            print(f"  ... and {len(library) - 10} more")
+                    else:
+                        print("📚 Library is empty")
+                
+                elif command.startswith('export '):
+                    format = command[7:].strip().lower()
+                    if format in ['bibtex', 'markdown']:
+                        try:
+                            file_path = await self.export_library(user_id, format)
+                            print(f"✅ Exported to: {file_path}")
+                        except Exception as e:
+                            print(f"❌ Export error: {e}")
+                    else:
+                        print("❌ Supported formats: bibtex, markdown")
+                
+                elif command == 'stats':
+                    stats = self.get_library_stats(user_id)
+                    print("📊 Library Statistics:")
+                    print(f"  Total papers: {stats['total_papers']}")
+                    print(f"  Total sessions: {stats['total_sessions']}")
+                    print("  Papers by year:")
+                    for year, count in sorted(stats['papers_by_year'].items()):
+                        print(f"    {year}: {count}")
+                    print("  Most used tools:")
+                    for tool, count in stats['most_used_tools'].items():
+                        print(f"    {tool}: {count}")
+                
+                elif command == 'history':
+                    history = self.get_session_history(user_id, 5)
+                    if history:
+                        print("🕒 Recent Searches:")
+                        for i, session in enumerate(history, 1):
+                            query = session.get('query', 'Unknown')[:50]
+                            timestamp = session.get('timestamp', 'Unknown')[:19]
+                            papers = session.get('papers_found', 0)
+                            print(f"  {i}. {query}... ({papers} papers) - {timestamp}")
+                    else:
+                        print("🕒 No search history")
+                
+                elif command.startswith('suggest '):
+                    title = command[8:].strip()
+                    if title:
+                        # Find paper in library
+                        library = self.workflow.get_user_library(user_id)
+                        paper = None
+                        for paper_data in library:
+                            if title.lower() in paper_data.get('paper', {}).get('title', '').lower():
+                                paper = paper_data.get('paper', {})
+                                break
+                        
+                        if paper:
+                            suggestions = await self.get_citation_suggestions(paper)
+                            print(f"💡 Suggestions for '{paper.get('title', 'Unknown')}':")
+                            for suggestion in suggestions:
+                                print(f"  • {suggestion}")
+                        else:
+                            print(f"❌ Paper not found in library: {title}")
+                    else:
+                        print("❌ Please provide a paper title")
+                
+                else:
+                    print("❌ Unknown command. Type 'quit' to exit.")
+                
+            except KeyboardInterrupt:
+                print("\n👋 Goodbye!")
+                break
+            except Exception as e:
+                print(f"❌ Error: {e}")
+        
+        print("👋 Workflow mode ended")