cite-agent 1.3.0__tar.gz → 1.3.1__tar.gz

{cite_agent-1.3.0/cite_agent.egg-info → cite_agent-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cite-agent
-Version: 1.3.0
+Version: 1.3.1
 Summary: Terminal AI assistant for academic research with citation verification
 Home-page: https://github.com/Spectating101/cite-agent
 Author: Cite-Agent Team

cite_agent-1.3.1/cite_agent/__version__.py

@@ -0,0 +1 @@
+__version__ = "1.3.1"

{cite_agent-1.3.0 → cite_agent-1.3.1}/cite_agent/enhanced_ai_agent.py

@@ -2594,23 +2594,125 @@ class EnhancedNocturnalAgent:
             if workflow_response:
                 return workflow_response
             
-            # Analyze request to determine what APIs to call
-            request_analysis = await self._analyze_request_type(request.question)
-            
-            # Debug: Check what was detected
+            # Initialize
+            api_results = {}
+            tools_used = []
             debug_mode = os.getenv("NOCTURNAL_DEBUG", "").lower() == "1"
+            
+            # ========================================================================
+            # PRIORITY 1: SHELL PLANNING (Reasoning Layer - Runs FIRST for ALL modes)
+            # ========================================================================
+            # This determines USER INTENT before fetching any data
+            # Prevents waste: "find cm522" won't trigger Archive API, "look into it" won't web search
+            # Works in BOTH production and dev modes
+            
+            shell_action = "none"  # Will be: pwd|ls|find|none
+            
+            # Quick check if query might need shell
+            question_lower = request.question.lower()
+            might_need_shell = any(word in question_lower for word in [
+                'directory', 'folder', 'where', 'find', 'list', 'files', 'look', 'search', 'check', 'into'
+            ])
+            
+            if might_need_shell and self.shell_session:
+                # Ask LLM planner: What shell command should we run?
+                planner_prompt = f"""You are a shell command planner. Determine what shell command to run.
+
+User query: "{request.question}"
+Previous conversation: {json.dumps(self.conversation_history[-2:]) if self.conversation_history else "None"}
+
+Respond ONLY with JSON:
+{{
+  "action": "pwd|ls|find|none",
+  "search_target": "cm522" (if find),
+  "search_path": "~/Downloads" (if find),
+  "target_path": "/full/path" (if ls on previous result)
+}}
+
+Examples:
+"where am i?" → {{"action": "pwd"}}
+"what files here?" → {{"action": "ls"}}
+"find cm522 in downloads" → {{"action": "find", "search_target": "cm522", "search_path": "~/Downloads"}}
+"look into it" + Previous: "Found /path/to/dir" → {{"action": "ls", "target_path": "/path/to/dir"}}
+"Tesla revenue" → {{"action": "none"}}
+
+JSON:"""
+
+                try:
+                    plan_response = await self.call_backend_query(
+                        query=planner_prompt,
+                        conversation_history=[],
+                        api_results={},
+                        tools_used=[]
+                    )
+                    
+                    plan_text = plan_response.response.strip()
+                    if '```' in plan_text:
+                        plan_text = plan_text.split('```')[1].replace('json', '').strip()
+                    
+                    plan = json.loads(plan_text)
+                    shell_action = plan.get("action", "none")
+                    
+                    if debug_mode:
+                        print(f"🔍 SHELL PLAN: {plan}")
+                    
+                    # Execute shell command based on plan
+                    if shell_action == "pwd":
+                        pwd_output = self.execute_command("pwd")
+                        api_results["shell_info"] = {"current_directory": pwd_output.strip()}
+                        tools_used.append("shell_execution")
+                    
+                    elif shell_action == "ls":
+                        target = plan.get("target_path")
+                        if target:
+                            ls_output = self.execute_command(f"ls -lah {target}")
+                            api_results["shell_info"] = {
+                                "directory_contents": ls_output,
+                                "target_path": target
+                            }
+                        else:
+                            ls_output = self.execute_command("ls -lah")
+                            api_results["shell_info"] = {"directory_contents": ls_output}
+                        tools_used.append("shell_execution")
+                    
+                    elif shell_action == "find":
+                        search_target = plan.get("search_target", "")
+                        search_path = plan.get("search_path", "~")
+                        if search_target:
+                            find_cmd = f"find {search_path} -maxdepth 4 -type d -iname '*{search_target}*' 2>/dev/null | head -20"
+                            find_output = self.execute_command(find_cmd)
+                            if debug_mode:
+                                print(f"🔍 FIND: {find_cmd}")
+                                print(f"🔍 OUTPUT: {repr(find_output)}")
+                            if find_output.strip():
+                                api_results["shell_info"] = {
+                                    "search_results": f"Searched for '*{search_target}*' in {search_path}:\n{find_output}"
+                                }
+                            else:
+                                api_results["shell_info"] = {
+                                    "search_results": f"No directories matching '{search_target}' found in {search_path}"
+                                }
+                            tools_used.append("shell_execution")
+                
+                except Exception as e:
+                    if debug_mode:
+                        print(f"🔍 Shell planner failed: {e}, continuing without shell")
+                    shell_action = "none"
+            
+            # ========================================================================
+            # PRIORITY 2: DATA APIs (Only if shell didn't fully handle the query)
+            # ========================================================================
+            # If shell_action = pwd/ls/find, we might still want data APIs
+            # But we skip vague queries to save tokens
+            
+            # Analyze what data APIs are needed (only if not pure shell command)
+            request_analysis = await self._analyze_request_type(request.question)
             if debug_mode:
                 print(f"🔍 Request analysis: {request_analysis}")
             
-            # Check if query is too vague - skip EXPENSIVE API calls to save tokens
-            # But still allow web search (cheap and flexible)
             is_vague = self._is_query_too_vague_for_apis(request.question)
             if debug_mode and is_vague:
-                print(f"🔍 Query detected as VAGUE - skipping Archive/FinSight, but may use web search")
-            
-            # Call appropriate APIs (Archive, FinSight) - BOTH production and dev mode
-            api_results = {}
-            tools_used = []
+                print(f"🔍 Query is VAGUE - skipping expensive APIs")
             
             # Skip Archive/FinSight if query is too vague, but still allow web search later
             if not is_vague:
@@ -2629,202 +2731,141 @@ class EnhancedNocturnalAgent:
                         api_results["research"] = result
                         tools_used.append("archive_api")
                 
-                # FinSight API for financial data
+                # FinSight API for financial data - Use LLM for ticker/metric extraction
                 if "finsight" in request_analysis.get("apis", []):
-                    tickers = self._extract_tickers_from_text(request.question)
-                    if not tickers:
-                        # Try common company name mappings
-                        question_lower = request.question.lower()
-                        if "apple" in question_lower:
-                            tickers = ["AAPL"]
-                        elif "tesla" in question_lower:
-                            tickers = ["TSLA"]
-                        elif "microsoft" in question_lower:
-                            tickers = ["MSFT"]
-                        elif "google" in question_lower or "alphabet" in question_lower:
-                            tickers = ["GOOGL"]
-                    
-                    if debug_mode:
-                        print(f"🔍 Extracted tickers: {tickers}")
-                    
-                    if tickers:
-                        # Detect what metric user is asking for
-                        question_lower = request.question.lower()
-                        metric = "revenue"  # Default
-                        
-                        if any(word in question_lower for word in ['market cap', 'marketcap', 'market value', 'valuation']):
-                            metric = "marketCap"
-                        elif any(word in question_lower for word in ['stock price', 'share price', 'current price', 'trading at']):
-                            metric = "price"
-                        elif 'profit' in question_lower and 'gross' not in question_lower:
-                            metric = "netIncome"
-                        elif 'earnings' in question_lower or 'eps' in question_lower:
-                            metric = "eps"
-                        elif any(word in question_lower for word in ['cash flow', 'cashflow']):
-                            metric = "freeCashFlow"
-                        
-                        # Call FinSight with detected metric
-                        if debug_mode:
-                            print(f"🔍 Calling FinSight API: calc/{tickers[0]}/{metric}")
-                        financial_data = await self._call_finsight_api(f"calc/{tickers[0]}/{metric}")
-                        if debug_mode:
-                            print(f"🔍 FinSight returned: {list(financial_data.keys()) if financial_data else None}")
-                        if financial_data and "error" not in financial_data:
-                            api_results["financial"] = financial_data
-                            tools_used.append("finsight_api")
-                        else:
-                            if debug_mode and financial_data:
-                                print(f"🔍 FinSight error: {financial_data.get('error')}")
-            
-            # Web Search fallback - ALWAYS available even for vague queries
-            # Use for: market share, industry data, current events, prices, anything not in APIs
-            if self.web_search:
-                question_lower = request.question.lower()
-                # Only search if query needs data and APIs didn't provide it
-                needs_web_search = (
-                    ('market share' in question_lower) or
-                    ('market size' in question_lower) or
-                    ('industry' in question_lower and not api_results.get('research')) or
-                    ('price' in question_lower and ('today' in question_lower or 'current' in question_lower or 'now' in question_lower)) or
-                    ('bitcoin' in question_lower or 'btc' in question_lower or 'crypto' in question_lower) or
-                    ('exchange rate' in question_lower or 'forex' in question_lower) or
-                    (not api_results and 'latest' in question_lower)  # Latest news/data
-                )
-                
-                if needs_web_search or (not api_results and len(request.question.split()) > 5):
-                    try:
-                        if debug_mode:
-                            print(f"🔍 Using web search for: {request.question[:50]}...")
-                        web_results = await self.web_search.search_web(request.question, num_results=3)
-                        if web_results and "results" in web_results:
-                            api_results["web_search"] = web_results
-                            tools_used.append("web_search")
-                            if debug_mode:
-                                print(f"🔍 Web search returned: {len(web_results.get('results', []))} results")
-                    except Exception as e:
-                        if debug_mode:
-                            print(f"🔍 Web search failed: {e}")
-            
-            # PRODUCTION MODE: Use small LLM to plan shell commands (smarter than hardcoded patterns)
-            if self.client is None:
-                # Ask small LLM: What shell command should we run?
-                planner_prompt = f"""You are a shell command planner. Given the user's query, determine what shell command(s) to run.
+                    # LLM extracts ticker + metric (more accurate than regex)
+                    finance_prompt = f"""Extract financial query details from user's question.
 
 User query: "{request.question}"
-Previous conversation context: {json.dumps(self.conversation_history[-2:]) if self.conversation_history else "None"}
 
 Respond with JSON:
 {{
-  "action": "pwd|ls|find|none",
-  "search_target": "directory/file name to search for (if action=find)",
-  "search_path": "~/Downloads or ~/Documents or ~ (if action=find)",
-  "target_path": "/full/path (if referring to previous result)"
+  "tickers": ["AAPL", "TSLA"] (stock symbols - infer from company names if needed),
+  "metric": "revenue|marketCap|price|netIncome|eps|freeCashFlow|grossProfit"
 }}
 
 Examples:
-Query: "where am i?" → {{"action": "pwd"}}
-Query: "what files are here?" → {{"action": "ls"}}
-Query: "find cm522 in downloads" → {{"action": "find", "search_target": "cm522", "search_path": "~/Downloads"}}
-Query: "can you look into it?" + Previous: "Found /home/user/Downloads/cm522-main" → {{"action": "ls", "target_path": "/home/user/Downloads/cm522-main"}}
-Query: "what's the capital of France?" → {{"action": "none"}}
+- "Tesla revenue" → {{"tickers": ["TSLA"], "metric": "revenue"}}
+- "What's Apple worth?" → {{"tickers": ["AAPL"], "metric": "marketCap"}}
+- "tsla stock price" → {{"tickers": ["TSLA"], "metric": "price"}}
+- "Microsoft profit" → {{"tickers": ["MSFT"], "metric": "netIncome"}}
 
 JSON:"""
 
-                question_lower = request.question.lower()
-                needs_shell = any(word in question_lower for word in [
-                    'directory', 'folder', 'where', 'find', 'list', 'files', 'look', 'search', 'check'
-                ])
-                
-                if needs_shell and self.shell_session:
                     try:
-                        # Use small LLM to plan shell command (smarter than regex)
-                        plan_response = await self.call_backend_query(
-                            query=planner_prompt,
+                        finance_response = await self.call_backend_query(
+                            query=finance_prompt,
                             conversation_history=[],
                             api_results={},
                             tools_used=[]
                         )
                         
-                        # Parse JSON plan
                         import json as json_module
-                        plan_text = plan_response.response.strip()
-                        # Extract JSON if wrapped in markdown
-                        if '```' in plan_text:
-                            plan_text = plan_text.split('```')[1].replace('json', '').strip()
+                        finance_text = finance_response.response.strip()
+                        if '```' in finance_text:
+                            finance_text = finance_text.split('```')[1].replace('json', '').strip()
                         
-                        plan = json_module.loads(plan_text)
+                        finance_plan = json_module.loads(finance_text)
+                        tickers = finance_plan.get("tickers", [])
+                        metric = finance_plan.get("metric", "revenue")
                         
-                        debug_mode = os.getenv("NOCTURNAL_DEBUG", "").lower() == "1"
                         if debug_mode:
-                            print(f"🔍 LLM PLAN: {plan}")
-                        
-                        api_results["shell_info"] = {}
-                        
-                        # Execute based on plan
-                        action = plan.get("action", "none")
+                            print(f"🔍 LLM FINANCE PLAN: tickers={tickers}, metric={metric}")
                         
-                        if action == "pwd":
-                            pwd_output = self.execute_command("pwd")
-                            api_results["shell_info"]["current_directory"] = pwd_output.strip()
-                            tools_used.append("shell_execution")
-                        
-                        elif action == "ls":
-                            target = plan.get("target_path")
-                            if target:
-                                # List specific directory
-                                ls_output = self.execute_command(f"ls -lah {target}")
-                            else:
-                                # List current directory
-                                ls_output = self.execute_command("ls -lah")
-                            api_results["shell_info"]["directory_contents"] = ls_output
-                            if target:
-                                api_results["shell_info"]["target_path"] = target
-                            tools_used.append("shell_execution")
-                        
-                        elif action == "find":
-                            search_target = plan.get("search_target", "")
-                            search_path = plan.get("search_path", "~")
-                            
-                            if search_target:
-                                find_cmd = f"find {search_path} -maxdepth 4 -type d -iname '*{search_target}*' 2>/dev/null | head -20"
-                                find_output = self.execute_command(find_cmd)
-                                
-                                if debug_mode:
-                                    print(f"🔍 FIND EXECUTED: {find_cmd}")
-                                    print(f"🔍 FIND OUTPUT: {repr(find_output)}")
-                                
-                                if find_output.strip():
-                                    api_results["shell_info"]["search_results"] = f"Searched for '*{search_target}*' in {search_path}:\n{find_output}"
-                                else:
-                                    api_results["shell_info"]["search_results"] = f"No directories matching '{search_target}' found in {search_path}"
-                                tools_used.append("shell_execution")
-                        
-                        # Always include current directory
-                        pwd_output = self.execute_command("pwd")
-                        api_results["shell_info"]["current_directory"] = pwd_output.strip()
+                        if tickers:
+                            # Call FinSight with extracted ticker + metric
+                            financial_data = await self._call_finsight_api(f"calc/{tickers[0]}/{metric}")
+                            if debug_mode:
+                                print(f"🔍 FinSight returned: {list(financial_data.keys()) if financial_data else None}")
+                            if financial_data and "error" not in financial_data:
+                                api_results["financial"] = financial_data
+                                tools_used.append("finsight_api")
                     
                     except Exception as e:
-                        # LLM planner failed, skip shell execution
-                        debug_mode = os.getenv("NOCTURNAL_DEBUG", "").lower() == "1"
                         if debug_mode:
-                            print(f"🔍 Shell planner failed: {e}")
-                
+                            print(f"🔍 Finance LLM extraction failed: {e}")
+            
+            # ========================================================================
+            # PRIORITY 3: WEB SEARCH (Fallback - only if shell didn't handle AND no data yet)
+            # ========================================================================
+            # Only web search if:
+            # - Shell said "none" (not a directory/file operation)
+            # - We don't have enough data from Archive/FinSight
+            
+            if self.web_search and shell_action == "none":
+                # Ask LLM: Should we web search for this?
+                web_decision_prompt = f"""Should we use web search for this query?
+
+User query: "{request.question}"
+Data already available: {list(api_results.keys())}
+Shell action: {shell_action}
+
+Respond with JSON:
+{{
+  "use_web_search": true/false,
+  "reason": "why or why not"
+}}
+
+Use web search for:
+- Market share/size (not in SEC filings)
+- Current prices (Bitcoin, commodities, real-time data)
+- Industry data, statistics
+- Recent events, news
+- Questions not answered by existing data
+
+Don't use if:
+- Shell already handled it (pwd/ls/find)
+- Question answered by research/financial APIs
+- Pure opinion question
+
+JSON:"""
+
+                try:
+                    web_decision_response = await self.call_backend_query(
+                        query=web_decision_prompt,
+                        conversation_history=[],
+                        api_results={},
+                        tools_used=[]
+                    )
+                    
+                    import json as json_module
+                    decision_text = web_decision_response.response.strip()
+                    if '```' in decision_text:
+                        decision_text = decision_text.split('```')[1].replace('json', '').strip()
+                    
+                    decision = json_module.loads(decision_text)
+                    needs_web_search = decision.get("use_web_search", False)
+                    
+                    if debug_mode:
+                        print(f"🔍 WEB SEARCH DECISION: {needs_web_search}, reason: {decision.get('reason')}")
+                    
+                    if needs_web_search:
+                        web_results = await self.web_search.search_web(request.question, num_results=3)
+                        if web_results and "results" in web_results:
+                            api_results["web_search"] = web_results
+                            tools_used.append("web_search")
+                            if debug_mode:
+                                print(f"🔍 Web search returned: {len(web_results.get('results', []))} results")
                 
-                # DEBUG: Log exactly what we're sending to backend
-                debug_mode = os.getenv("NOCTURNAL_DEBUG", "").lower() == "1"
-                if debug_mode and api_results.get("shell_info", {}).get("search_results"):
-                    print(f"🔍 SENDING TO BACKEND:")
-                    print(f"🔍 shell_info.search_results = {repr(api_results['shell_info']['search_results'])}")
+                except Exception as e:
+                    if debug_mode:
+                        print(f"🔍 Web search decision failed: {e}")
+            
+            # PRODUCTION MODE: Call backend LLM with all gathered data
+            if self.client is None:
+                # DEBUG: Log what we're sending
+                if debug_mode and api_results.get("shell_info"):
+                    print(f"🔍 SENDING TO BACKEND: shell_info keys = {list(api_results.get('shell_info', {}).keys())}")
                 
                 # Call backend and UPDATE CONVERSATION HISTORY
                 response = await self.call_backend_query(
                     query=request.question,
                     conversation_history=self.conversation_history[-10:],
-                    api_results=api_results,  # Include the data!
-                    tools_used=tools_used  # Pass tools list for history
+                    api_results=api_results,
+                    tools_used=tools_used
                 )
                 
-                # CRITICAL: Save to conversation history for context
+                # CRITICAL: Save to conversation history
                 self.conversation_history.append({"role": "user", "content": request.question})
                 self.conversation_history.append({"role": "assistant", "content": response.response})
                 

{cite_agent-1.3.0 → cite_agent-1.3.1/cite_agent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cite-agent
-Version: 1.3.0
+Version: 1.3.1
 Summary: Terminal AI assistant for academic research with citation verification
 Home-page: https://github.com/Spectating101/cite-agent
 Author: Cite-Agent Team

{cite_agent-1.3.0 → cite_agent-1.3.1}/setup.py

@@ -7,7 +7,7 @@ long_description = readme_path.read_text() if readme_path.exists() else "Termina
 
 setup(
     name="cite-agent",
-    version="1.3.0",
+    version="1.3.1",
     author="Cite-Agent Team",
     author_email="contact@citeagent.dev",
     description="Terminal AI assistant for academic research with citation verification",

cite_agent-1.3.0/cite_agent/__version__.py

@@ -1 +0,0 @@
-__version__ = "1.3.0"