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

cite_agent/cli.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Nocturnal Archive CLI - Command Line Interface
+Cite Agent CLI - Command Line Interface
 Provides a terminal interface similar to cursor-agent
 """
 
@@ -24,14 +24,19 @@ from .enhanced_ai_agent import EnhancedNocturnalAgent, ChatRequest
 from .setup_config import NocturnalConfig, DEFAULT_QUERY_LIMIT, MANAGED_SECRETS
 from .telemetry import TelemetryManager
 from .updater import NocturnalUpdater
+from .cli_workflow import WorkflowCLI
+from .workflow import WorkflowManager, Paper, parse_paper_from_response
+from .session_manager import SessionManager
 
 class NocturnalCLI:
-    """Command Line Interface for Nocturnal Archive"""
+    """Command Line Interface for Cite Agent"""
     
     def __init__(self):
         self.agent: Optional[EnhancedNocturnalAgent] = None
         self.session_id = f"cli_{os.getpid()}"
         self.telemetry = None
+        self.workflow = WorkflowManager()
+        self.workflow_cli = WorkflowCLI()
         self.console = Console(theme=Theme({
             "banner": "bold magenta",
             "success": "bold green",
@@ -49,10 +54,32 @@ class NocturnalCLI:
             "If you see an auto-update notice, the CLI will restart itself to load the latest build.",
         ]
     
-    async def initialize(self):
+    def handle_user_friendly_session(self):
+        """Handle session management with user-friendly interface"""
+        session_manager = SessionManager()
+        
+        # Set up environment variables for backend mode
+        session_manager.setup_environment_variables()
+        
+        # Handle session affirmation
+        result = session_manager.handle_session_affirmation()
+        
+        if result == "error":
+            self.console.print("[red]❌ Session management failed. Please try again.[/red]")
+            return False
+        
+        return True
+    
+    async def initialize(self, non_interactive: bool = False):
         """Initialize the agent with automatic updates"""
         # Check for update notifications from previous runs
         self._check_update_notification()
+        
+        # Handle user-friendly session management (skip prompts in non-interactive mode)
+        if not non_interactive:
+            if not self.handle_user_friendly_session():
+                return False
+        
         self._show_intro_panel()
 
         self._enforce_latest_build()
@@ -63,15 +90,30 @@ 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
+                if non_interactive:
+                    self.console.print("[error]❌ Not authenticated. Run 'cite-agent --setup' to configure.[/error]")
+                    return False
+                
+                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()
@@ -90,8 +132,10 @@ class NocturnalCLI:
             self.console.print("   • Check your internet connection to the backend")
             return False
         
-        self._show_ready_panel()
-        self._show_beta_banner()
+        # Only show panels in debug mode or interactive mode
+        if not non_interactive or os.getenv("NOCTURNAL_DEBUG", "").lower() == "1":
+            self._show_ready_panel()
+            # Beta banner removed for production
         return True
 
     def _show_beta_banner(self):
@@ -120,13 +164,18 @@ class NocturnalCLI:
         self.console.print(panel)
 
     def _show_intro_panel(self):
+        # Only show in debug mode or interactive mode
+        debug_mode = os.getenv("NOCTURNAL_DEBUG", "").lower() == "1"
+        if not debug_mode:
+            return
+        
         message = (
             "Warming up your research cockpit…\n"
             "[dim]Loading config, telemetry, and background update checks.[/dim]"
         )
         panel = Panel(
             message,
-            title="🌙  Initializing Nocturnal Archive",
+            title="🤖  Initializing Cite Agent",
             border_style="magenta",
             padding=(1, 2),
             box=box.ROUNDED,
@@ -137,7 +186,7 @@ class NocturnalCLI:
         panel = Panel(
             "Systems check complete.\n"
             "Type [bold]help[/] for commands or [bold]tips[/] for power moves.",
-            title="✅ Nocturnal Archive ready!",
+            title="✅ Cite Agent ready!",
             border_style="green",
             padding=(1, 2),
             box=box.ROUNDED,
@@ -146,22 +195,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."""
@@ -232,27 +268,56 @@ class NocturnalCLI:
                     if user_input.lower() == 'feedback':
                         self.collect_feedback()
                         continue
-                    
+
+                    # Handle workflow commands
+                    if user_input.lower() in ['show my library', 'library', 'list library']:
+                        self.list_library()
+                        continue
+                    if user_input.lower() in ['show history', 'history']:
+                        self.show_history()
+                        continue
+                    if user_input.lower().startswith('export bibtex'):
+                        self.export_library_bibtex()
+                        continue
+                    if user_input.lower().startswith('export markdown'):
+                        self.export_library_markdown()
+                        continue
+
                     if not user_input:
                         continue
                 except (EOFError, KeyboardInterrupt):
                     self.console.print("\n[warning]👋 Goodbye![/warning]")
                     break
                 
-                self.console.print("[bold violet]🤖 Agent[/]: ", end="", highlight=False)
-                
                 try:
-                    request = ChatRequest(
-                        question=user_input,
-                        user_id="cli_user",
-                        conversation_id=self.session_id
-                    )
-                    
-                    response = await self.agent.process_request(request)
+                    from rich.spinner import Spinner
+                    from rich.live import Live
                     
+                    # Show loading indicator while processing
+                    with Live(Spinner("dots", text="[dim]Thinking...[/dim]"), console=self.console, transient=True):
+                        request = ChatRequest(
+                            question=user_input,
+                            user_id="cli_user",
+                            conversation_id=self.session_id
+                        )
+                        
+                        response = await self.agent.process_request(request)
+
                     # Print response with proper formatting
+                    self.console.print("[bold violet]🤖 Agent[/]: ", end="", highlight=False)
                     self.console.print(response.response)
-                    
+
+                    # Save to history automatically
+                    self.workflow.save_query_result(
+                        query=user_input,
+                        response=response.response,
+                        metadata={
+                            "tools_used": response.tools_used,
+                            "tokens_used": response.tokens_used,
+                            "confidence_score": response.confidence_score
+                        }
+                    )
+
                     # Show usage stats occasionally
                     if hasattr(self.agent, 'daily_token_usage') and self.agent.daily_token_usage > 0:
                         stats = self.agent.get_usage_stats()
@@ -268,25 +333,26 @@ class NocturnalCLI:
     
     async def single_query(self, question: str):
         """Process a single query"""
-        if not await self.initialize():
+        if not await self.initialize(non_interactive=True):
             return
         
         try:
-            self.console.print(f"🤖 [bold]Processing[/]: {question}")
-            self.console.rule(style="magenta")
-            
-            request = ChatRequest(
-                question=question,
-                user_id="cli_user",
-                conversation_id=self.session_id
-            )
+            from rich.spinner import Spinner
+            from rich.live import Live
             
-            response = await self.agent.process_request(request)
+            # Show clean loading indicator
+            with Live(Spinner("dots", text=f"[cyan]{question}[/cyan]"), console=self.console, transient=True):
+                request = ChatRequest(
+                    question=question,
+                    user_id="cli_user",
+                    conversation_id=self.session_id
+                )
+                
+                response = await self.agent.process_request(request)
             
             self.console.print(f"\n📝 [bold]Response[/]:\n{response.response}")
             
-            if response.tools_used:
-                self.console.print(f"\n🔧 Tools used: {', '.join(response.tools_used)}")
+            # Tools used removed for cleaner output
             
             if response.tokens_used > 0:
                 stats = self.agent.get_usage_stats()
@@ -319,7 +385,7 @@ class NocturnalCLI:
         """Collect feedback from the user and store it locally"""
         self.console.print(
             Panel(
-                "Share what’s working, what feels rough, or any paper/finance workflows you wish existed.\n"
+                "Share what's working, what feels rough, or any paper/finance workflows you wish existed.\n"
                 "Press Enter on an empty line to finish.",
                 title="📝 Beta Feedback",
                 border_style="cyan",
@@ -350,7 +416,7 @@ class NocturnalCLI:
 
         content = "\n".join(lines)
         with open(feedback_path, "w", encoding="utf-8") as handle:
-            handle.write("# Nocturnal Archive Beta Feedback\n")
+            handle.write("# Cite Agent Feedback\n")
             handle.write(f"timestamp = {timestamp}Z\n")
             handle.write("\n")
             handle.write(content)
@@ -362,10 +428,184 @@ class NocturnalCLI:
         self.console.print("[dim]Attach that file when you send feedback to the team.[/dim]")
         return 0
 
+    def list_library(self, tag: Optional[str] = None):
+        """List papers in local library"""
+        papers = self.workflow.list_papers(tag=tag)
+        
+        if not papers:
+            self.console.print("[warning]No papers in library yet.[/warning]")
+            self.console.print("[dim]Use --save-paper after a search to add papers.[/dim]")
+            return
+        
+        table = Table(title=f"📚 Library ({len(papers)} papers)", box=box.ROUNDED)
+        table.add_column("ID", style="cyan")
+        table.add_column("Title", style="bold")
+        table.add_column("Authors", style="dim")
+        table.add_column("Year", justify="right")
+        table.add_column("Tags", style="yellow")
+        
+        for paper in papers[:20]:  # Show first 20
+            authors_str = paper.authors[0] if paper.authors else "Unknown"
+            if len(paper.authors) > 1:
+                authors_str += " et al."
+            
+            tags_str = ", ".join(paper.tags) if paper.tags else ""
+            
+            table.add_row(
+                paper.paper_id[:8],
+                paper.title[:50] + "..." if len(paper.title) > 50 else paper.title,
+                authors_str,
+                str(paper.year),
+                tags_str
+            )
+        
+        self.console.print(table)
+        
+        if len(papers) > 20:
+            self.console.print(f"[dim]... and {len(papers) - 20} more papers[/dim]")
+
+    def export_library_bibtex(self):
+        """Export library to BibTeX"""
+        success = self.workflow.export_to_bibtex()
+        if success:
+            self.console.print(f"[success]✅ Exported to:[/success] [bold]{self.workflow.bibtex_file}[/bold]")
+            self.console.print("[dim]Import this file into Zotero, Mendeley, or any citation manager.[/dim]")
+        else:
+            self.console.print("[error]❌ Failed to export BibTeX[/error]")
+
+    def export_library_markdown(self):
+        """Export library to Markdown"""
+        success = self.workflow.export_to_markdown()
+        if success:
+            export_file = self.workflow.exports_dir / f"papers_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
+            self.console.print(f"[success]✅ Exported to:[/success] [bold]{export_file}[/bold]")
+            self.console.print("[dim]Open in Obsidian, Notion, or any markdown editor.[/dim]")
+        else:
+            self.console.print("[error]❌ Failed to export Markdown[/error]")
+
+    def show_history(self, limit: int = 10):
+        """Show recent query history"""
+        history = self.workflow.get_history()[:limit]
+        
+        if not history:
+            self.console.print("[warning]No query history yet.[/warning]")
+            return
+        
+        table = Table(title=f"📜 Recent Queries", box=box.ROUNDED)
+        table.add_column("Time", style="cyan")
+        table.add_column("Query", style="bold")
+        table.add_column("Tools", style="dim")
+        
+        for entry in history:
+            timestamp = datetime.fromisoformat(entry['timestamp'])
+            time_str = timestamp.strftime("%m/%d %H:%M")
+            query_str = entry['query'][:60] + "..." if len(entry['query']) > 60 else entry['query']
+            tools_str = ", ".join(entry.get('metadata', {}).get('tools_used', []))
+            
+            table.add_row(time_str, query_str, tools_str)
+        
+        self.console.print(table)
+
+    def search_library_interactive(self, query: str):
+        """Search papers in library"""
+        results = self.workflow.search_library(query)
+        
+        if not results:
+            self.console.print(f"[warning]No papers found matching '{query}'[/warning]")
+            return
+        
+        self.console.print(f"[success]Found {len(results)} paper(s)[/success]\n")
+        
+        for i, paper in enumerate(results, 1):
+            self.console.print(f"[bold cyan]{i}. {paper.title}[/bold cyan]")
+            authors_str = ", ".join(paper.authors) if paper.authors else "Unknown"
+            self.console.print(f"   Authors: {authors_str}")
+            self.console.print(f"   Year: {paper.year} | ID: {paper.paper_id[:8]}")
+            if paper.tags:
+                self.console.print(f"   Tags: {', '.join(paper.tags)}")
+            self.console.print()
+
+    async def single_query_with_workflow(self, question: str, save_to_library: bool = False, 
+                                         copy_to_clipboard: bool = False, export_format: Optional[str] = None):
+        """Process a single query with workflow integration"""
+        if not await self.initialize(non_interactive=True):
+            return
+        
+        try:
+            self.console.print(f"🤖 [bold]Processing[/]: {question}")
+            self.console.rule(style="magenta")
+            
+            request = ChatRequest(
+                question=question,
+                user_id="cli_user",
+                conversation_id=self.session_id
+            )
+            
+            response = await self.agent.process_request(request)
+            
+            self.console.print(f"\n📝 [bold]Response[/]:\n{response.response}")
+            
+            # Tools used removed for cleaner output
+            
+            if response.tokens_used > 0:
+                stats = self.agent.get_usage_stats()
+                self.console.print(
+                    f"\n📊 Tokens used: {response.tokens_used} "
+                    f"(Daily usage: {stats['usage_percentage']:.1f}%)"
+                )
+            
+            # Workflow integrations
+            if copy_to_clipboard:
+                if self.workflow.copy_to_clipboard(response.response):
+                    self.console.print("[success]📋 Copied to clipboard[/success]")
+            
+            if export_format:
+                if export_format == "bibtex":
+                    # Try to parse paper from response
+                    paper = parse_paper_from_response(response.response)
+                    if paper:
+                        bibtex = paper.to_bibtex()
+                        self.console.print(f"\n[bold]BibTeX:[/bold]\n{bibtex}")
+                        if copy_to_clipboard:
+                            self.workflow.copy_to_clipboard(bibtex)
+                    else:
+                        self.console.print("[warning]Could not extract paper info for BibTeX[/warning]")
+                
+                elif export_format == "apa":
+                    paper = parse_paper_from_response(response.response)
+                    if paper:
+                        apa = paper.to_apa_citation()
+                        self.console.print(f"\n[bold]APA Citation:[/bold]\n{apa}")
+                        if copy_to_clipboard:
+                            self.workflow.copy_to_clipboard(apa)
+            
+            # Save to history
+            self.workflow.save_query_result(
+                query=question,
+                response=response.response,
+                metadata={
+                    "tools_used": response.tools_used,
+                    "tokens_used": response.tokens_used,
+                    "confidence_score": response.confidence_score
+                }
+            )
+            
+            if save_to_library:
+                paper = parse_paper_from_response(response.response)
+                if paper:
+                    if self.workflow.add_paper(paper):
+                        self.console.print(f"[success]✅ Saved to library (ID: {paper.paper_id[:8]})[/success]")
+                    else:
+                        self.console.print("[error]❌ Failed to save to library[/error]")
+        
+        finally:
+            if self.agent:
+                await self.agent.close()
+
 def main():
     """Main CLI entry point"""
     parser = argparse.ArgumentParser(
-        description="Nocturnal Archive - AI Research Assistant",
+        description="Cite Agent - AI Research Assistant with real data",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
 Examples:
@@ -421,10 +661,16 @@ Examples:
     )
 
     parser.add_argument(
-        '--feedback',
-        action='store_true',
+        '--feedback', 
+        action='store_true', 
         help='Capture beta feedback and save it locally'
     )
+    
+    parser.add_argument(
+        '--workflow', 
+        action='store_true', 
+        help='Start workflow mode for integrated research management'
+    )
 
     parser.add_argument(
         '--import-secrets',
@@ -438,12 +684,67 @@ Examples:
         help='Fail secret import if keyring is unavailable'
     )
     
+    # Workflow integration arguments
+    parser.add_argument(
+        '--library',
+        action='store_true',
+        help='List all papers in local library'
+    )
+    
+    parser.add_argument(
+        '--export-bibtex',
+        action='store_true',
+        help='Export library to BibTeX format'
+    )
+    
+    parser.add_argument(
+        '--export-markdown',
+        action='store_true',
+        help='Export library to Markdown format'
+    )
+    
+    parser.add_argument(
+        '--history',
+        action='store_true',
+        help='Show recent query history'
+    )
+    
+    parser.add_argument(
+        '--search-library',
+        metavar='QUERY',
+        help='Search papers in local library'
+    )
+    
+    parser.add_argument(
+        '--save',
+        action='store_true',
+        help='Save query results to library (use with query)'
+    )
+    
+    parser.add_argument(
+        '--copy',
+        action='store_true',
+        help='Copy results to clipboard (use with query)'
+    )
+    
+    parser.add_argument(
+        '--format',
+        choices=['bibtex', 'apa', 'markdown'],
+        help='Export format for citations (use with query)'
+    )
+    
+    parser.add_argument(
+        '--tag',
+        metavar='TAG',
+        help='Filter library by tag'
+    )
+    
     args = parser.parse_args()
     
     # Handle version
     if args.version:
-        print("Cite-Agent v1.0.4")
-        print("AI Research Assistant - Backend-Only Distribution")
+        print("Cite Agent v1.2.2")
+        print("AI Research Assistant with real data integration")
         return
 
     if args.tips or (args.query and args.query.lower() == "tips" and not args.interactive):
@@ -456,6 +757,29 @@ Examples:
         exit_code = cli.collect_feedback()
         sys.exit(exit_code)
     
+    # Handle workflow commands (no agent initialization needed)
+    cli = NocturnalCLI()
+    
+    if args.library:
+        cli.list_library(tag=args.tag)
+        sys.exit(0)
+    
+    if args.export_bibtex:
+        cli.export_library_bibtex()
+        sys.exit(0)
+    
+    if args.export_markdown:
+        cli.export_library_markdown()
+        sys.exit(0)
+    
+    if args.history:
+        cli.show_history(limit=20)
+        sys.exit(0)
+    
+    if args.search_library:
+        cli.search_library_interactive(args.search_library)
+        sys.exit(0)
+    
     # Handle secret import before setup as it can be used non-interactively
     if args.import_secrets:
         config = NocturnalConfig()
@@ -494,12 +818,21 @@ Examples:
     
     # Handle query or interactive mode
     async def run_cli():
-        cli = NocturnalCLI()
+        cli_instance = NocturnalCLI()
         
         if args.query and not args.interactive:
-            await cli.single_query(args.query)
+            # Check if workflow flags are set
+            if args.save or args.copy or args.format:
+                await cli_instance.single_query_with_workflow(
+                    args.query,
+                    save_to_library=args.save,
+                    copy_to_clipboard=args.copy,
+                    export_format=args.format
+                )
+            else:
+                await cli_instance.single_query(args.query)
         else:
-            await cli.interactive_mode()
+            await cli_instance.interactive_mode()
     
     try:
         asyncio.run(run_cli())