cite-agent 1.3.8__tar.gz → 1.3.9__tar.gz

{cite_agent-1.3.8/cite_agent.egg-info → cite_agent-1.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cite-agent
-Version: 1.3.8
+Version: 1.3.9
 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.9/cite_agent/__version__.py

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

{cite_agent-1.3.8 → cite_agent-1.3.9}/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()
 
@@ -196,6 +232,92 @@ class NocturnalCLI:
             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."""
@@ -309,25 +431,43 @@ 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 typing effect for natural feel
                     self.console.print("[bold violet]🤖 Agent[/]: ", end="", highlight=False)
                     
-                    # Character-by-character streaming (like ChatGPT)
+                    # Character-by-character streaming (like ChatGPT) - faster for long responses
                     import time
                     for char in response.response:
                         self.console.print(char, end="", style="white")
-                        time.sleep(0.008)  # 8ms per character (~125 chars/sec)
+                        time.sleep(0.003)  # 3ms per character (~333 chars/sec) - faster than before
                     
                     self.console.print()  # Newline after response
 
@@ -732,6 +872,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',
@@ -772,6 +930,21 @@ Examples:
         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()

cite_agent-1.3.9/cite_agent/conversation_archive.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""Lightweight persistent archive for conversation summaries."""
+
+from __future__ import annotations
+
+import json
+import hashlib
+import os
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+
+
+@dataclass
+class ArchiveEntry:
+    """Serialized representation of a conversation turn summary."""
+
+    timestamp: str
+    question: str
+    summary: str
+    tools_used: List[str]
+    citations: Optional[List[str]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        data: Dict[str, Any] = {
+            "timestamp": self.timestamp,
+            "question": self.question,
+            "summary": self.summary,
+            "tools_used": list(self.tools_used),
+        }
+        if self.citations:
+            data["citations"] = list(self.citations)
+        return data
+
+    @staticmethod
+    def from_dict(payload: Dict[str, Any]) -> "ArchiveEntry":
+        return ArchiveEntry(
+            timestamp=payload.get("timestamp", datetime.now(timezone.utc).isoformat()),
+            question=payload.get("question", ""),
+            summary=payload.get("summary", ""),
+            tools_used=list(payload.get("tools_used", [])),
+            citations=list(payload.get("citations", [])) or None,
+        )
+
+
+class ConversationArchive:
+    """Stores compact conversation summaries for long-running research threads."""
+
+    def __init__(
+        self,
+        root: Optional[Path] = None,
+        enabled: Optional[bool] = None,
+        max_entries: int = 30,
+    ) -> None:
+        self.enabled = True if enabled is None else bool(enabled)
+        self.max_entries = max(1, max_entries)
+        env_root = os.getenv("CITE_AGENT_ARCHIVE_DIR")
+        final_root = root or Path(env_root) if env_root else root
+        self.root = Path(final_root or (Path.home() / ".cite_agent" / "conversation_archive"))
+        if self.enabled:
+            self.root.mkdir(parents=True, exist_ok=True)
+
+    @staticmethod
+    def _hash_identifier(identifier: str) -> str:
+        digest = hashlib.sha256(identifier.encode("utf-8")).hexdigest()
+        return digest[:16]
+
+    def _conversation_path(self, user_id: str, conversation_id: str) -> Path:
+        user_hash = self._hash_identifier(user_id or "anonymous")
+        convo_hash = self._hash_identifier(conversation_id or "default")
+        return self.root / f"{user_hash}-{convo_hash}.json"
+
+    def record_entry(
+        self,
+        user_id: str,
+        conversation_id: str,
+        question: str,
+        summary: str,
+        tools_used: Optional[List[str]] = None,
+        citations: Optional[List[str]] = None,
+    ) -> None:
+        if not self.enabled:
+            return
+
+        entry = ArchiveEntry(
+            timestamp=datetime.now(timezone.utc).isoformat(),
+            question=question.strip(),
+            summary=summary.strip(),
+            tools_used=list(tools_used or []),
+            citations=list(citations or []) or None,
+        )
+
+        path = self._conversation_path(user_id, conversation_id)
+        entries: List[ArchiveEntry] = []
+        if path.exists():
+            try:
+                data = json.loads(path.read_text(encoding="utf-8"))
+                entries = [ArchiveEntry.from_dict(item) for item in data]
+            except Exception:
+                entries = []
+
+        entries.append(entry)
+        entries = entries[-self.max_entries:]
+
+        serialized = [item.to_dict() for item in entries]
+        path.write_text(json.dumps(serialized, indent=2), encoding="utf-8")
+
+    def get_recent_context(
+        self,
+        user_id: str,
+        conversation_id: str,
+        limit: int = 3,
+    ) -> str:
+        if not self.enabled:
+            return ""
+
+        path = self._conversation_path(user_id, conversation_id)
+        if not path.exists():
+            return ""
+
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except Exception:
+            return ""
+
+        if not isinstance(data, list):
+            return ""
+
+        entries = [ArchiveEntry.from_dict(item) for item in data][-max(1, limit):]
+        if not entries:
+            return ""
+
+        lines = ["Archived context from previous sessions:"]
+        for item in entries:
+            snippet = item.summary.strip().replace("\n", " ")
+            if len(snippet) > 220:
+                snippet = snippet[:217].rstrip() + "..."
+            lines.append(f"• {item.timestamp[:19]} — {snippet}")
+        return "\n".join(lines)
+
+    def clear_conversation(self, user_id: str, conversation_id: str) -> None:
+        if not self.enabled:
+            return
+        path = self._conversation_path(user_id, conversation_id)
+        if path.exists():
+            path.unlink()
+
+    def list_conversations(self) -> List[str]:
+        if not self.enabled or not self.root.exists():
+            return []
+        return [p.name for p in self.root.glob("*.json")]