cite-agent 1.2.9__tar.gz → 1.4.1__tar.gz

{cite_agent-1.2.9/cite_agent.egg-info → cite_agent-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cite-agent
-Version: 1.2.9
+Version: 1.4.1
 Summary: Terminal AI assistant for academic research with citation verification
 Home-page: https://github.com/Spectating101/cite-agent
 Author: Cite-Agent Team
@@ -194,6 +194,11 @@ cite-agent "我的p值是0.05，這顯著嗎？"
 cite-agent "天空是藍色的嗎？"
 ```
 
+#### Runtime Controls
+
+- Responses render immediately—there’s no artificial typing delay.
+- Press `Ctrl+C` while the agent is thinking or streaming to interrupt and ask a different question on the spot.
+
 ### Python API Reference
 
 #### EnhancedNocturnalAgent

{cite_agent-1.2.9 → cite_agent-1.4.1}/README.md

@@ -157,6 +157,11 @@ cite-agent "我的p值是0.05，這顯著嗎？"
 cite-agent "天空是藍色的嗎？"
 ```
 
+#### Runtime Controls
+
+- Responses render immediately—there’s no artificial typing delay.
+- Press `Ctrl+C` while the agent is thinking or streaming to interrupt and ask a different question on the spot.
+
 ### Python API Reference
 
 #### EnhancedNocturnalAgent
@@ -427,4 +432,4 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 ---
 
-**Made with ❤️ for the research community**
+**Made with ❤️ for the research community**

{cite_agent-1.2.9 → cite_agent-1.4.1}/cite_agent/__init__.py

@@ -7,9 +7,9 @@ prior stacks preserved only in Git history, kept out of the runtime footprint.
 
 from .enhanced_ai_agent import EnhancedNocturnalAgent, ChatRequest, ChatResponse
 
-__version__ = "0.9.0b1"
-__author__ = "Nocturnal Archive Team"
-__email__ = "contact@nocturnal.dev"
+__version__ = "1.4.0"
+__author__ = "Cite Agent Team"
+__email__ = "contact@citeagent.dev"
 
 __all__ = [
     "EnhancedNocturnalAgent",
@@ -18,10 +18,10 @@ __all__ = [
 ]
 
 # Package metadata
-PACKAGE_NAME = "nocturnal-archive"
+PACKAGE_NAME = "cite-agent"
 PACKAGE_VERSION = __version__
-PACKAGE_DESCRIPTION = "Beta CLI agent for finance + research workflows"
-PACKAGE_URL = "https://github.com/Spectating101/nocturnal-archive"
+PACKAGE_DESCRIPTION = "Research and finance CLI copilot with shell, Archive, and FinSight tools"
+PACKAGE_URL = "https://github.com/Spectating101/cite-agent"
 
 def get_version():
     """Get the package version"""
@@ -30,22 +30,22 @@ def get_version():
 def quick_start():
     """Print quick start instructions"""
     print("""
-🚀 Nocturnal Archive Quick Start
-================================
+🚀 Cite Agent Quick Start
+=========================
 
 1. Install the package and CLI:
-   pip install nocturnal-archive
+   pip install cite-agent
 
-2. Configure your Groq key:
-   nocturnal --setup
+2. Configure your account or local keys:
+   cite-agent --setup
 
 3. Ask a question:
-   nocturnal "Compare Apple and Microsoft net income this quarter"
+   cite-agent "Compare Apple and Microsoft net income this quarter"
 
 4. Prefer embedding in code? Minimal example:
    ```python
    import asyncio
-   from nocturnal_archive import EnhancedNocturnalAgent, ChatRequest
+   from cite_agent import EnhancedNocturnalAgent, ChatRequest
 
    async def main():
        agent = EnhancedNocturnalAgent()

cite_agent-1.4.1/cite_agent/__version__.py

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

{cite_agent-1.2.9 → cite_agent-1.4.1}/cite_agent/cli.py

@@ -6,13 +6,15 @@ Provides a terminal interface similar to cursor-agent
 
 import argparse
 import asyncio
+import json
 import os
 import random
 import sys
 import time
+import hashlib
 from datetime import datetime
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Dict
 
 from rich import box
 from rich.console import Console
@@ -28,6 +30,26 @@ from .cli_workflow import WorkflowCLI
 from .workflow import WorkflowManager, Paper, parse_paper_from_response
 from .session_manager import SessionManager
 
+PRESET_SCENARIOS: Dict[str, Dict[str, str]] = {
+    "Research sprint": {
+        "prompt": "Run a literature review on retrieval-augmented generation, summarise three key papers and cite sources.",
+        "highlight": "Archive API + guardrails"
+    },
+    "Data audit": {
+        "prompt": "Inspect sales_data.csv, perform exploratory stats, and flag any anomalies worth investigating.",
+        "highlight": "Shell analytics + guardrails"
+    },
+    "Financial briefing": {
+        "prompt": "Compare NVDA and AMD revenue and margin trends for the last 4 quarters using FinSight.",
+        "highlight": "FinSight multi-ticker"
+    },
+    "Team handoff": {
+        "prompt": "Summarise our last session and note any follow-up tasks saved in the archive for project alpha.",
+        "highlight": "Archive memory"
+    },
+}
+
+
 class NocturnalCLI:
     """Command Line Interface for Cite Agent"""
     
@@ -53,6 +75,18 @@ class NocturnalCLI:
             "Remember the sandbox: prefix shell commands with [bold]![/] to execute safe utilities only.",
             "If you see an auto-update notice, the CLI will restart itself to load the latest build.",
         ]
+        self._default_artifacts = Path("artifacts_autonomy.json")
+
+    def _record_session_event(self, success: bool) -> None:
+        try:
+            manager = TelemetryManager.get()
+            email = os.getenv("NOCTURNAL_ACCOUNT_EMAIL", "")
+            payload = {"success": bool(success)}
+            if email:
+                payload["user"] = hashlib.sha256(email.encode("utf-8")).hexdigest()[:16]
+            manager.record("session_login", payload)
+        except Exception:
+            pass
     
     def handle_user_friendly_session(self):
         """Handle session management with user-friendly interface"""
@@ -78,7 +112,9 @@ class NocturnalCLI:
         # Handle user-friendly session management (skip prompts in non-interactive mode)
         if not non_interactive:
             if not self.handle_user_friendly_session():
+                self._record_session_event(False)
                 return False
+            self._record_session_event(True)
         
         self._show_intro_panel()
 
@@ -189,13 +225,100 @@ class NocturnalCLI:
     def _show_ready_panel(self):
         panel = Panel(
             "Systems check complete.\n"
-            "Type [bold]help[/] for commands or [bold]tips[/] for power moves.",
+            "Type [bold]help[/] for commands or [bold]tips[/] for power moves.\n"
+            "[dim]Press Ctrl+C while the agent is thinking to interrupt and ask something else.[/dim]",
             title="✅ Cite Agent ready!",
             border_style="green",
             padding=(1, 2),
             box=box.ROUNDED,
         )
         self.console.print(panel)
+
+    def show_presets(self) -> None:
+        table = Table(title="🚀 Beta Showcase Presets", box=box.ROUNDED, show_edge=True)
+        table.add_column("Scenario", style="bold cyan")
+        table.add_column("Prompt", style="white")
+        table.add_column("Highlights", style="magenta")
+        for name, payload in PRESET_SCENARIOS.items():
+            table.add_row(name, payload["prompt"], payload["highlight"])
+        self.console.print(table)
+        self.console.print("[dim]Tip: run [/dim][bold]nocturnal \"<prompt>\"[/bold][dim] to execute a preset immediately.[/dim]")
+
+    def show_metrics(self, artifacts: Optional[Path] = None) -> None:
+        artifacts_path = artifacts or self._default_artifacts
+        if not artifacts_path.exists():
+            self.console.print(
+                "[warning]No metrics file found.[/warning] Run [bold]python3 scripts/run_beta_showcase.py[/bold] first."
+            )
+            return
+
+        try:
+            payload = json.loads(artifacts_path.read_text())
+        except Exception as exc:
+            self.console.print(f"[error]Failed to parse {artifacts_path}: {exc}[/error]")
+            return
+
+        metrics = payload.get("_metrics")
+        if not metrics:
+            self.console.print(
+                "[warning]Metrics summary missing. Regenerate the file with [/warning]"
+                "[bold]python3 scripts/run_beta_showcase.py[/bold]."
+            )
+            return
+
+        table = Table(title="📊 Beta Harness Summary", box=box.ROUNDED)
+        table.add_column("Metric", style="bold green")
+        table.add_column("Value", style="white")
+        table.add_row("Scenarios", str(metrics.get("scenario_count", "-")))
+        elapsed = metrics.get("total_elapsed", 0.0)
+        table.add_row("Total elapsed", f"{elapsed:.2f}s")
+        guard = metrics.get("guardrail_pass_rate", 0.0)
+        table.add_row("Guardrail pass rate", f"{guard:.1%}")
+
+        tool_usage = metrics.get("tool_usage", {})
+        if tool_usage:
+            usage_lines = [f"{tool}: {count}" for tool, count in tool_usage.items()]
+            table.add_row("Tool invocations", "\n".join(usage_lines))
+
+        self.console.print(table)
+
+        guardrail_findings = []
+        for name, scenario in payload.items():
+            if not isinstance(scenario, dict) or name.startswith("_"):
+                continue
+            quality = scenario.get("quality_checks")
+            if not quality:
+                continue
+            if not all(quality.values()):
+                guardrail_findings.append((name, quality))
+
+        if guardrail_findings:
+            warn_table = Table(title="⚠️ Guardrails needing attention", box=box.ROUNDED, style="yellow")
+            warn_table.add_column("Scenario", style="bold")
+            warn_table.add_column("Checks", style="white")
+            for scenario, checks in guardrail_findings:
+                failed = [f"{key}={val}" for key, val in checks.items()]
+                warn_table.add_row(scenario, ", ".join(failed))
+            self.console.print(warn_table)
+        else:
+            self.console.print("[success]All guardrails passed.[/success]")
+
+    def show_token_report(self) -> None:
+        try:
+            from scripts.token_report import build_token_report
+        except Exception as exc:  # pragma: no cover - import convenience
+            self.console.print(f"[error]Failed to import token report tool: {exc}[/error]")
+            return
+
+        root = Path(os.getenv("NOCTURNAL_HOME", str(Path.home() / ".nocturnal_archive")))
+        report = build_token_report(root)
+        table = Table(title="🪙 Token Usage", box=box.ROUNDED)
+        table.add_column("User (hashed)", style="cyan")
+        table.add_column("Tokens", style="white", justify="right")
+        for user, tokens in report["per_user"].items():
+            table.add_row(user, f"{tokens:.0f}")
+        self.console.print(table)
+        self.console.print(f"[dim]Total tokens: {report['total_tokens']:.0f}[/dim]")
     
     def _enforce_latest_build(self):
         """Ensure the CLI is running the most recent published build."""
@@ -256,6 +379,19 @@ class NocturnalCLI:
         if not await self.initialize():
             return
         
+        # Detect if user is in a project directory (R, Python, Node, Jupyter, etc.)
+        try:
+            from .project_detector import ProjectDetector
+            detector = ProjectDetector()
+            project_info = detector.detect_project()
+            
+            if project_info:
+                # Show project banner
+                banner = detector.format_project_banner(project_info)
+                self.console.print(banner, style="dim")
+        except:
+            pass  # Silently skip if detection fails
+        
         self.console.print("\n[bold]🤖 Interactive Mode[/] — Type your questions or 'quit' to exit")
         self.console.rule(style="magenta")
         
@@ -296,18 +432,36 @@ class NocturnalCLI:
                 try:
                     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):
+
+                    # Show detailed progress indicator
+                    spinner = Spinner("dots", text="[dim]Processing query...[/dim]")
+                    live = Live(spinner, console=self.console, transient=True)
+                    live.start()
+
+                    try:
                         request = ChatRequest(
                             question=user_input,
                             user_id="cli_user",
                             conversation_id=self.session_id
                         )
-                        
+
+                        # Update spinner based on query type
+                        if any(kw in user_input.lower() for kw in ['read', 'show', 'file', 'cat']):
+                            spinner.update(text="[cyan]📄 Reading file...[/cyan]")
+                        elif any(kw in user_input.lower() for kw in ['list', 'ls', 'find', 'search']):
+                            spinner.update(text="[cyan]🔍 Searching files...[/cyan]")
+                        elif any(kw in user_input.lower() for kw in ['python', 'calculate', 'run', 'execute']):
+                            spinner.update(text="[cyan]⚙️  Executing code...[/cyan]")
+                        elif any(kw in user_input.lower() for kw in ['research', 'paper', 'find', 'archive']):
+                            spinner.update(text="[cyan]🔬 Searching research database...[/cyan]")
+                        else:
+                            spinner.update(text="[cyan]🤖 Thinking...[/cyan]")
+
                         response = await self.agent.process_request(request)
+                    finally:
+                        live.stop()
 
-                    # Print response with proper formatting
+                    # Print response immediately (no artificial typing delay)
                     self.console.print("[bold violet]🤖 Agent[/]: ", end="", highlight=False)
                     self.console.print(response.response)
 
@@ -322,12 +476,10 @@ class NocturnalCLI:
                         }
                     )
 
-                    # Show usage stats occasionally
-                    if hasattr(self.agent, 'daily_token_usage') and self.agent.daily_token_usage > 0:
-                        stats = self.agent.get_usage_stats()
-                        if stats['usage_percentage'] > 10:  # Show if >10% used
-                            self.console.print(f"\n📊 Usage: {stats['usage_percentage']:.1f}% of daily limit")
-                
+                except KeyboardInterrupt:
+                    live.stop()
+                    self.console.print("\n[dim]⏹️  Interrupted. Ask another question when ready.[/dim]")
+                    continue
                 except Exception as e:
                     self.console.print(f"\n[error]❌ Error: {e}[/error]")
         
@@ -712,6 +864,24 @@ Examples:
         action='store_true',
         help='Show recent query history'
     )
+
+    parser.add_argument(
+        '--presets',
+        action='store_true',
+        help='Show curated beta showcase prompts'
+    )
+
+    parser.add_argument(
+        '--metrics',
+        action='store_true',
+        help='Display the latest autonomy harness metrics summary'
+    )
+
+    parser.add_argument(
+        '--token-report',
+        action='store_true',
+        help='Print aggregated token usage from telemetry logs'
+    )
     
     parser.add_argument(
         '--search-library',
@@ -747,10 +917,26 @@ Examples:
     
     # Handle version
     if args.version:
-        print("Cite Agent v1.2.9")
+        from cite_agent.__version__ import __version__
+        print(f"Cite Agent v{__version__}")
         print("AI Research Assistant with real data integration")
         return
 
+    if args.presets:
+        cli = NocturnalCLI()
+        cli.show_presets()
+        return
+
+    if args.metrics:
+        cli = NocturnalCLI()
+        cli.show_metrics()
+        return
+
+    if args.token_report:
+        cli = NocturnalCLI()
+        cli.show_token_report()
+        return
+
     if args.tips or (args.query and args.query.lower() == "tips" and not args.interactive):
         cli = NocturnalCLI()
         cli.show_tips()
@@ -820,6 +1006,72 @@ Examples:
             updater.show_update_status()
             sys.exit(0)
     
+    # Auto-upgrade on startup (silent, non-blocking)
+    def auto_upgrade_if_needed():
+        """Automatically upgrade to latest version if available"""
+        try:
+            # Only check once per day to avoid API spam
+            from pathlib import Path
+            import time
+            import subprocess
+            
+            check_file = Path.home() / ".cite_agent" / ".last_update_check"
+            check_file.parent.mkdir(exist_ok=True)
+            
+            # Check if we've checked recently (within 24 hours)
+            if check_file.exists():
+                last_check = float(check_file.read_text().strip())
+                if time.time() - last_check < 86400:  # 24 hours
+                    return  # Skip check
+            
+            updater = NocturnalUpdater()
+            update_info = updater.check_for_updates()
+            
+            # Save check timestamp
+            check_file.write_text(str(time.time()))
+            
+            if update_info and update_info.get("available"):
+                current = update_info["current"]
+                latest = update_info["latest"]
+                
+                print(f"\n🔄 Updating Cite Agent: v{current} → v{latest}...")
+                
+                # Detect if installed via pipx or pip
+                import shutil
+                if shutil.which("pipx"):
+                    # Try pipx upgrade first
+                    result = subprocess.run(
+                        ["pipx", "upgrade", "cite-agent"],
+                        capture_output=True,
+                        text=True,
+                        timeout=60
+                    )
+                    if result.returncode == 0:
+                        print(f"✅ Updated to v{latest} (via pipx)")
+                        print("🔄 Restart cite-agent to use the new version\n")
+                        return
+                
+                # Fall back to pip install --user
+                result = subprocess.run(
+                    [sys.executable, "-m", "pip", "install", "--upgrade", "--user", "cite-agent"],
+                    capture_output=True,
+                    text=True,
+                    timeout=60
+                )
+                
+                if result.returncode == 0:
+                    print(f"✅ Updated to v{latest}")
+                    print("🔄 Restart cite-agent to use the new version\n")
+                else:
+                    # Silent fail - don't show errors to users
+                    pass
+        except:
+            pass  # Silently fail, don't block startup
+    
+    # Run auto-upgrade in background (doesn't delay startup)
+    import threading
+    threading.Thread(target=auto_upgrade_if_needed, daemon=True).start()
+    
     # Handle query or interactive mode
     async def run_cli():
         cli_instance = NocturnalCLI()

{cite_agent-1.2.9 → cite_agent-1.4.1}/cite_agent/cli_conversational.py

@@ -8,7 +8,7 @@ import asyncio
 import os
 import sys
 from pathlib import Path
-from typing import Optional
+from typing import List, Optional
 
 # Add nocturnal_archive to path
 sys.path.insert(0, str(Path(__file__).parent))
@@ -93,6 +93,85 @@ Remember:
         
         # Store this for when we make requests
         self.jarvis_prompt = jarvis_system_prompt
+
+    async def _build_environment_snapshot(self, limit: int = 8) -> Optional[str]:
+        """Return a short summary of the current workspace."""
+        if not self.agent:
+            return None
+
+        try:
+            listing = await self.agent._get_workspace_listing(limit=limit)  # type: ignore[attr-defined]
+        except Exception:
+            listing = {"base": self.working_dir, "items": []}
+
+        base = listing.get("base") or self.working_dir
+        items = listing.get("items") or listing.get("entries") or []
+
+        lines: List[str] = [f"📂 Working directory: {base}"]
+
+        if items:
+            preview_count = min(len(items), 6)
+            preview_lines = [
+                f"  • {item.get('name')} ({item.get('type', 'item')})"
+                for item in items[:preview_count]
+            ]
+            if len(items) > preview_count:
+                preview_lines.append(f"  • … {len(items) - preview_count} more")
+            lines.append("Contents snapshot:\n" + "\n".join(preview_lines))
+
+        if listing.get("error"):
+            lines.append(f"⚠️ Workspace note: {listing['error']}")
+
+        note = listing.get("note")
+        if note:
+            lines.append(note)
+
+        return "\n\n".join(lines)
+
+    @staticmethod
+    def _looks_like_grounding_question(text: str) -> bool:
+        lowered = text.lower().strip()
+        if not lowered:
+            return False
+        grounding_phrases = [
+            "where are we",
+            "where am i",
+            "what directory",
+            "current directory",
+            "pwd",
+            "show files",
+            "list files",
+            "where is this",
+        ]
+        return any(phrase in lowered for phrase in grounding_phrases)
+
+    @staticmethod
+    def _is_small_talk_probe(text: str) -> bool:
+        lowered = text.lower().strip()
+        return lowered in {"test", "hi", "hello", "hey", "ping"}
+
+    async def _respond_with_grounding(self) -> None:
+        snapshot = await self._build_environment_snapshot()
+        if not snapshot:
+            snapshot = "I can’t access the workspace details right now, but I’m ready to help."
+
+        async def snapshot_gen():
+            async for chunk in simulate_streaming(snapshot, chunk_size=4):
+                yield chunk
+
+        await self.ui.stream_agent_response(snapshot_gen())
+
+    async def _respond_with_acknowledgement(self) -> None:
+        message = (
+            "Ready when you are. Try `help` for guidance or ask me to summarise a file like "
+            "`summarize README.md`."
+        )
+
+        async def ack_gen():
+            async for chunk in simulate_streaming(message, chunk_size=4):
+                yield chunk
+
+        await self.ui.stream_agent_response(ack_gen())
     
     async def run(self):
         """Main conversation loop"""
@@ -121,6 +200,24 @@ Remember:
                     yield chunk
             
             await self.ui.stream_agent_response(welcome_gen())
+
+            snapshot = await self._build_environment_snapshot()
+            if snapshot:
+                async def snapshot_gen():
+                    async for chunk in simulate_streaming(snapshot, chunk_size=4):
+                        yield chunk
+                await self.ui.stream_agent_response(snapshot_gen())
+
+            quick_tips = (
+                "Quick tips: `help` for options • `read_file README.md` to inspect docs • "
+                "`summarize docs/…` or `analyze data.csv` to get started."
+            )
+
+            async def tips_gen():
+                async for chunk in simulate_streaming(quick_tips, chunk_size=4):
+                    yield chunk
+
+            await self.ui.stream_agent_response(tips_gen())
             
             # Main conversation loop
             while self.conversation_active:
@@ -160,15 +257,28 @@ Remember:
         - Use appropriate tools
         - Stream response naturally
         """
+
+        stripped = user_input.strip()
+        if not stripped:
+            return
+
+        lowered = stripped.lower()
+
+        if self._is_small_talk_probe(stripped):
+            await self._respond_with_acknowledgement()
+            return
+        if self._looks_like_grounding_question(stripped):
+            await self._respond_with_grounding()
+            return
         
         # Determine if this is a web search request
-        is_web_search = any(keyword in user_input.lower() for keyword in [
+        is_web_search = any(keyword in lowered 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 [
+        is_data_analysis = any(keyword in lowered for keyword in [
             'analyze', 'data', 'csv', 'plot', 'graph', 'test', 'regression',
             'correlation', 'statistics', 'mean', 'median', 'distribution'
         ])