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

cite_agent/workflow.py

@@ -0,0 +1,427 @@
+#!/usr/bin/env python3
+"""
+Workflow Integration Module - Reduces context switching for scholars
+Features:
+- BibTeX export for citation managers
+- Local paper library management
+- Clipboard integration
+- Markdown export for note-taking apps
+- Session history and replay
+"""
+
+import hashlib
+import json
+import os
+import re
+import subprocess
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass, asdict
+
+
+@dataclass
+class Paper:
+    """Represents an academic paper"""
+    title: str
+    authors: List[str]
+    year: int
+    doi: Optional[str] = None
+    url: Optional[str] = None
+    abstract: Optional[str] = None
+    venue: Optional[str] = None
+    citation_count: int = 0
+    paper_id: Optional[str] = None
+    added_date: Optional[str] = None
+    notes: Optional[str] = None
+    tags: List[str] = None
+
+    def __post_init__(self):
+        if self.tags is None:
+            self.tags = []
+        if self.added_date is None:
+            self.added_date = datetime.now().isoformat()
+
+    def to_bibtex(self, citation_key: Optional[str] = None) -> str:
+        """Convert paper to BibTeX format"""
+        if not citation_key:
+            # Generate citation key: FirstAuthorYearTitleWord
+            first_author = self.authors[0].split()[-1] if self.authors else "Unknown"
+            title_word = self.title.split()[0] if self.title else "Paper"
+            citation_key = f"{first_author}{self.year}{title_word}".replace(" ", "")
+        
+        bibtex = f"@article{{{citation_key},\n"
+        bibtex += f"  title = {{{self.title}}},\n"
+        
+        if self.authors:
+            authors_str = " and ".join(self.authors)
+            bibtex += f"  author = {{{authors_str}}},\n"
+        
+        bibtex += f"  year = {{{self.year}}},\n"
+        
+        if self.venue:
+            bibtex += f"  journal = {{{self.venue}}},\n"
+        
+        if self.doi:
+            bibtex += f"  doi = {{{self.doi}}},\n"
+        
+        if self.url:
+            bibtex += f"  url = {{{self.url}}},\n"
+        
+        if self.abstract:
+            # Clean abstract for BibTeX
+            clean_abstract = self.abstract.replace("\n", " ").replace("{", "").replace("}", "")
+            bibtex += f"  abstract = {{{clean_abstract}}},\n"
+        
+        bibtex += "}\n"
+        return bibtex
+
+    def to_apa_citation(self) -> str:
+        """Convert paper to APA format citation"""
+        authors_part = ""
+        if len(self.authors) == 1:
+            authors_part = self.authors[0]
+        elif len(self.authors) == 2:
+            authors_part = f"{self.authors[0]} & {self.authors[1]}"
+        elif len(self.authors) > 2:
+            authors_part = f"{self.authors[0]} et al."
+        
+        citation = f"{authors_part} ({self.year}). {self.title}."
+        
+        if self.venue:
+            citation += f" {self.venue}."
+        
+        if self.doi:
+            citation += f" https://doi.org/{self.doi}"
+        elif self.url:
+            citation += f" {self.url}"
+        
+        return citation
+
+    def to_markdown(self) -> str:
+        """Convert paper to markdown format"""
+        md = f"# {self.title}\n\n"
+        
+        if self.authors:
+            md += f"**Authors:** {', '.join(self.authors)}\n\n"
+        
+        md += f"**Year:** {self.year}\n\n"
+        
+        if self.venue:
+            md += f"**Venue:** {self.venue}\n\n"
+        
+        if self.citation_count:
+            md += f"**Citations:** {self.citation_count}\n\n"
+        
+        if self.doi:
+            md += f"**DOI:** [{self.doi}](https://doi.org/{self.doi})\n\n"
+        elif self.url:
+            md += f"**URL:** {self.url}\n\n"
+        
+        if self.abstract:
+            md += f"## Abstract\n\n{self.abstract}\n\n"
+        
+        if self.notes:
+            md += f"## Notes\n\n{self.notes}\n\n"
+        
+        if self.tags:
+            md += f"**Tags:** {', '.join(self.tags)}\n\n"
+        
+        md += f"*Added: {self.added_date}*\n"
+        
+        return md
+
+
+class WorkflowManager:
+    """Manages scholar workflow integrations"""
+    
+    def __init__(self):
+        self.config_dir = Path.home() / ".cite_agent"
+        self.library_dir = self.config_dir / "library"
+        self.exports_dir = self.config_dir / "exports"
+        self.history_dir = self.config_dir / "history"
+        self.bibtex_file = self.exports_dir / "references.bib"
+        
+        # Create directories
+        self.config_dir.mkdir(exist_ok=True)
+        self.library_dir.mkdir(exist_ok=True)
+        self.exports_dir.mkdir(exist_ok=True)
+        self.history_dir.mkdir(exist_ok=True)
+    
+    def add_paper(self, paper: Paper) -> bool:
+        """Add paper to local library"""
+        try:
+            # Generate paper ID if not provided
+            if not paper.paper_id:
+                paper.paper_id = self._generate_paper_id(paper)
+            
+            # Save paper as JSON
+            paper_file = self.library_dir / f"{paper.paper_id}.json"
+            with open(paper_file, 'w') as f:
+                json.dump(asdict(paper), f, indent=2)
+            
+            return True
+        except Exception as e:
+            print(f"Error adding paper: {e}")
+            return False
+    
+    def get_paper(self, paper_id: str) -> Optional[Paper]:
+        """Retrieve paper from library"""
+        try:
+            paper_file = self.library_dir / f"{paper_id}.json"
+            if not paper_file.exists():
+                return None
+            
+            with open(paper_file, 'r') as f:
+                data = json.load(f)
+                return Paper(**data)
+        except Exception as e:
+            print(f"Error retrieving paper: {e}")
+            return None
+    
+    def list_papers(self, tag: Optional[str] = None) -> List[Paper]:
+        """List all papers in library, optionally filtered by tag"""
+        papers = []
+        for paper_file in self.library_dir.glob("*.json"):
+            try:
+                with open(paper_file, 'r') as f:
+                    data = json.load(f)
+                    paper = Paper(**data)
+                    
+                    if tag is None or tag in paper.tags:
+                        papers.append(paper)
+            except Exception as e:
+                print(f"Error reading {paper_file}: {e}")
+        
+        # Sort by added date (newest first)
+        papers.sort(key=lambda p: p.added_date or "", reverse=True)
+        return papers
+    
+    def export_to_bibtex(self, papers: Optional[List[Paper]] = None, append: bool = True) -> bool:
+        """Export papers to BibTeX file"""
+        try:
+            if papers is None:
+                # Export all papers from library
+                papers = self.list_papers()
+            
+            mode = 'a' if append else 'w'
+            with open(self.bibtex_file, mode) as f:
+                if not append:
+                    f.write("% Generated by Cite-Agent\n")
+                    f.write(f"% Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+                
+                for paper in papers:
+                    f.write(paper.to_bibtex())
+                    f.write("\n")
+            
+            return True
+        except Exception as e:
+            print(f"Error exporting to BibTeX: {e}")
+            return False
+    
+    def export_to_markdown(self, papers: Optional[List[Paper]] = None, output_file: Optional[Path] = None) -> bool:
+        """Export papers to markdown file"""
+        try:
+            if papers is None:
+                papers = self.list_papers()
+            
+            if output_file is None:
+                output_file = self.exports_dir / f"papers_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
+            
+            with open(output_file, 'w') as f:
+                f.write(f"# Research Library Export\n\n")
+                f.write(f"*Exported: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*\n\n")
+                f.write(f"Total papers: {len(papers)}\n\n")
+                f.write("---\n\n")
+                
+                for i, paper in enumerate(papers, 1):
+                    f.write(f"## {i}. {paper.title}\n\n")
+                    f.write(paper.to_markdown())
+                    f.write("\n---\n\n")
+            
+            return True
+        except Exception as e:
+            print(f"Error exporting to markdown: {e}")
+            return False
+    
+    def copy_to_clipboard(self, text: str) -> bool:
+        """Copy text to system clipboard"""
+        try:
+            # Try multiple clipboard commands based on platform
+            commands = [
+                ['xclip', '-selection', 'clipboard'],  # Linux X11
+                ['xsel', '--clipboard', '--input'],     # Linux alternative
+                ['wl-copy'],                             # Linux Wayland
+                ['pbcopy'],                              # macOS
+                ['clip'],                                # Windows
+            ]
+            
+            for cmd in commands:
+                try:
+                    subprocess.run(
+                        cmd,
+                        input=text.encode('utf-8'),
+                        check=True,
+                        stdout=subprocess.DEVNULL,
+                        stderr=subprocess.DEVNULL
+                    )
+                    return True
+                except (FileNotFoundError, subprocess.CalledProcessError):
+                    continue
+            
+            # If all commands fail, save to temp file as fallback
+            temp_file = self.config_dir / "clipboard.txt"
+            with open(temp_file, 'w') as f:
+                f.write(text)
+            print(f"⚠️  Clipboard unavailable. Saved to: {temp_file}")
+            return False
+            
+        except Exception as e:
+            print(f"Error copying to clipboard: {e}")
+            return False
+    
+    def save_query_result(self, query: str, response: str, metadata: Optional[Dict[str, Any]] = None) -> bool:
+        """Save query and response to history"""
+        try:
+            timestamp = datetime.now()
+            history_file = self.history_dir / f"{timestamp.strftime('%Y%m%d')}.jsonl"
+            
+            entry = {
+                "timestamp": timestamp.isoformat(),
+                "query": query,
+                "response": response,
+                "metadata": metadata or {}
+            }
+            
+            with open(history_file, 'a') as f:
+                f.write(json.dumps(entry) + '\n')
+            
+            return True
+        except Exception as e:
+            print(f"Error saving query result: {e}")
+            return False
+    
+    def get_history(self, days: int = 7) -> List[Dict[str, Any]]:
+        """Retrieve query history from last N days"""
+        history = []
+        cutoff = datetime.now()
+        
+        for history_file in sorted(self.history_dir.glob("*.jsonl"), reverse=True):
+            try:
+                with open(history_file, 'r') as f:
+                    for line in f:
+                        entry = json.loads(line)
+                        history.append(entry)
+            except Exception as e:
+                print(f"Error reading history: {e}")
+        
+        return history[:100]  # Limit to last 100 queries
+    
+    def search_library(self, query: str) -> List[Paper]:
+        """Search papers in library by title, author, or abstract"""
+        query_lower = query.lower()
+        results = []
+        
+        for paper in self.list_papers():
+            # Search in title
+            if query_lower in paper.title.lower():
+                results.append(paper)
+                continue
+            
+            # Search in authors
+            if any(query_lower in author.lower() for author in paper.authors):
+                results.append(paper)
+                continue
+            
+            # Search in abstract
+            if paper.abstract and query_lower in paper.abstract.lower():
+                results.append(paper)
+                continue
+        
+        return results
+    
+    def add_note_to_paper(self, paper_id: str, note: str) -> bool:
+        """Add note to a paper in the library"""
+        paper = self.get_paper(paper_id)
+        if not paper:
+            return False
+        
+        if paper.notes:
+            paper.notes += f"\n\n{note}"
+        else:
+            paper.notes = note
+        
+        return self.add_paper(paper)
+    
+    def tag_paper(self, paper_id: str, tags: List[str]) -> bool:
+        """Add tags to a paper"""
+        paper = self.get_paper(paper_id)
+        if not paper:
+            return False
+        
+        paper.tags = list(set(paper.tags + tags))
+        return self.add_paper(paper)
+    
+    def _generate_paper_id(self, paper: Paper) -> str:
+        """Generate unique paper ID"""
+        # Use DOI if available
+        if paper.doi:
+            return paper.doi.replace('/', '_').replace('.', '_')
+        
+        # Otherwise use hash of title + first author + year
+        content = f"{paper.title}{paper.authors[0] if paper.authors else ''}{paper.year}"
+        return hashlib.sha256(content.encode()).hexdigest()[:12]
+
+
+def parse_paper_from_response(response_text: str) -> Optional[Paper]:
+    """
+    Extract paper information from agent response text
+    This is a helper to convert agent responses into Paper objects
+    """
+    # This is a simple parser - could be enhanced with more sophisticated NLP
+    try:
+        # Try to extract common patterns
+        title_match = re.search(r'(?:title|Title):\s*["\']?([^"\'\n]+)["\']?', response_text)
+        authors_match = re.search(r'(?:author|Author)s?:\s*(.+?)(?:\n|Year)', response_text, re.IGNORECASE)
+        year_match = re.search(r'(?:year|Year):\s*(\d{4})', response_text)
+        doi_match = re.search(r'(?:doi|DOI):\s*(10\.\d+/[^\s\n]+)', response_text)
+        
+        if not title_match:
+            return None
+        
+        title = title_match.group(1).strip()
+        
+        authors = []
+        if authors_match:
+            author_text = authors_match.group(1)
+            # Split by common delimiters
+            authors = [a.strip() for a in re.split(r'[,&]|\sand\s', author_text)]
+        
+        year = int(year_match.group(1)) if year_match else datetime.now().year
+        doi = doi_match.group(1) if doi_match else None
+        
+        return Paper(
+            title=title,
+            authors=authors,
+            year=year,
+            doi=doi
+        )
+    except Exception as e:
+        print(f"Error parsing paper: {e}")
+        return None
+
+
+# Convenience function for quick exports
+def quick_export_bibtex(paper_data: Dict[str, Any]) -> str:
+    """Quick convert dict to BibTeX format"""
+    paper = Paper(
+        title=paper_data.get('title', ''),
+        authors=paper_data.get('authors', []),
+        year=paper_data.get('year', datetime.now().year),
+        doi=paper_data.get('doi'),
+        url=paper_data.get('url'),
+        venue=paper_data.get('venue'),
+        abstract=paper_data.get('abstract')
+    )
+    return paper.to_bibtex()
+

cite_agent/workflow_integration.py

@@ -0,0 +1,275 @@
+"""
+Workflow Integration Module
+Reduces context switching for scholars by providing integrated tools
+"""
+
+import json
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+class WorkflowIntegration:
+    """Handles workflow integration features to reduce context switching"""
+    
+    def __init__(self, data_dir: str = "~/.cite_agent"):
+        self.data_dir = Path(data_dir).expanduser()
+        self.data_dir.mkdir(exist_ok=True)
+        
+        # Initialize subdirectories
+        (self.data_dir / "papers").mkdir(exist_ok=True)
+        (self.data_dir / "citations").mkdir(exist_ok=True)
+        (self.data_dir / "sessions").mkdir(exist_ok=True)
+        
+    def save_paper_to_library(self, paper: Dict[str, Any], user_id: str) -> str:
+        """Save a paper to user's local library"""
+        paper_id = str(uuid.uuid4())
+        paper_data = {
+            "id": paper_id,
+            "user_id": user_id,
+            "saved_at": datetime.now().isoformat(),
+            "paper": paper,
+            "tags": [],
+            "notes": ""
+        }
+        
+        # Save to user's paper library
+        paper_file = self.data_dir / "papers" / f"{user_id}_{paper_id}.json"
+        with open(paper_file, 'w') as f:
+            json.dump(paper_data, f, indent=2)
+            
+        logger.info("Paper saved to library", paper_id=paper_id, user_id=user_id)
+        return paper_id
+    
+    def export_to_bibtex(self, papers: List[Dict[str, Any]], filename: str = None) -> str:
+        """Export papers to BibTeX format"""
+        if not filename:
+            filename = f"citations_{datetime.now().strftime('%Y%m%d_%H%M%S')}.bib"
+            
+        bibtex_file = self.data_dir / "citations" / filename
+        
+        bibtex_entries = []
+        for paper in papers:
+            entry = self._format_bibtex_entry(paper)
+            bibtex_entries.append(entry)
+        
+        with open(bibtex_file, 'w', encoding='utf-8') as f:
+            f.write('\n\n'.join(bibtex_entries))
+            
+        logger.info("BibTeX exported", filename=filename, count=len(papers))
+        return str(bibtex_file)
+    
+    def _format_bibtex_entry(self, paper: Dict[str, Any]) -> str:
+        """Format a paper as BibTeX entry"""
+        # Extract key information
+        title = paper.get('title', 'Unknown Title')
+        authors = paper.get('authors', [])
+        year = paper.get('year', '2024')
+        venue = paper.get('venue', paper.get('journal', 'Unknown Venue'))
+        doi = paper.get('doi', '')
+        
+        # Generate citation key
+        first_author = authors[0].get('name', 'Unknown') if authors else 'Unknown'
+        citation_key = f"{first_author.split()[-1].lower()}{year}"
+        
+        # Format authors
+        author_list = " and ".join([author.get('name', 'Unknown') for author in authors])
+        
+        # Create BibTeX entry
+        entry = f"""@article{{{citation_key},
+    title = {{{title}}},
+    author = {{{author_list}}},
+    journal = {{{venue}}},
+    year = {{{year}}}"""
+        
+        if doi:
+            entry += f",\n    doi = {{{doi}}}"
+            
+        entry += "\n}"
+        
+        return entry
+    
+    def save_session_history(self, user_id: str, query: str, response: Dict[str, Any]) -> str:
+        """Save query and response to session history"""
+        session_id = str(uuid.uuid4())
+        session_data = {
+            "session_id": session_id,
+            "user_id": user_id,
+            "timestamp": datetime.now().isoformat(),
+            "query": query,
+            "response": response,
+            "papers_found": len(response.get('papers', [])),
+            "tools_used": response.get('tools_used', [])
+        }
+        
+        session_file = self.data_dir / "sessions" / f"{user_id}_{session_id}.json"
+        with open(session_file, 'w') as f:
+            json.dump(session_data, f, indent=2)
+            
+        logger.info("Session saved", session_id=session_id, user_id=user_id)
+        return session_id
+    
+    def get_user_library(self, user_id: str) -> List[Dict[str, Any]]:
+        """Get user's saved paper library"""
+        library = []
+        papers_dir = self.data_dir / "papers"
+        
+        for paper_file in papers_dir.glob(f"{user_id}_*.json"):
+            try:
+                with open(paper_file, 'r') as f:
+                    paper_data = json.load(f)
+                    library.append(paper_data)
+            except Exception as e:
+                logger.error("Error loading paper", file=paper_file, error=str(e))
+                
+        # Sort by saved date
+        library.sort(key=lambda x: x.get('saved_at', ''), reverse=True)
+        return library
+    
+    def search_library(self, user_id: str, query: str) -> List[Dict[str, Any]]:
+        """Search user's saved paper library"""
+        library = self.get_user_library(user_id)
+        results = []
+        
+        query_lower = query.lower()
+        for paper_data in library:
+            paper = paper_data.get('paper', {})
+            
+            # Search in title, authors, abstract
+            title = paper.get('title', '').lower()
+            authors = ' '.join([author.get('name', '') for author in paper.get('authors', [])]).lower()
+            abstract = paper.get('abstract', '').lower()
+            
+            if (query_lower in title or 
+                query_lower in authors or 
+                query_lower in abstract):
+                results.append(paper_data)
+                
+        return results
+    
+    def generate_citation_suggestions(self, paper: Dict[str, Any]) -> List[str]:
+        """Generate citation suggestions for a paper"""
+        suggestions = []
+        
+        # Suggest related papers based on keywords
+        title = paper.get('title', '')
+        abstract = paper.get('abstract', '')
+        
+        # Extract potential keywords
+        keywords = self._extract_keywords(title + ' ' + abstract)
+        
+        for keyword in keywords[:5]:  # Top 5 keywords
+            suggestions.append(f"Find papers related to: {keyword}")
+            
+        # Suggest citation format options
+        suggestions.append("Format citation in APA style")
+        suggestions.append("Format citation in MLA style")
+        suggestions.append("Format citation in Chicago style")
+        
+        # Suggest verification
+        if paper.get('doi'):
+            suggestions.append(f"Verify DOI: {paper['doi']}")
+            
+        return suggestions
+    
+    def _extract_keywords(self, text: str) -> List[str]:
+        """Extract potential keywords from text"""
+        # Simple keyword extraction (could be enhanced with NLP)
+        words = text.lower().split()
+        
+        # Filter out common words
+        stop_words = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'is', 'are', 'was', 'were', 'be', 'been', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might', 'can', 'this', 'that', 'these', 'those'}
+        
+        keywords = [word for word in words if len(word) > 3 and word not in stop_words]
+        
+        # Count frequency and return top keywords
+        from collections import Counter
+        keyword_counts = Counter(keywords)
+        return [word for word, count in keyword_counts.most_common(10)]
+    
+    def export_to_markdown(self, papers: List[Dict[str, Any]], filename: str = None) -> str:
+        """Export papers to Markdown format for Obsidian/Notion"""
+        if not filename:
+            filename = f"papers_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
+            
+        markdown_file = self.data_dir / "citations" / filename
+        
+        markdown_content = "# Research Papers\n\n"
+        markdown_content += f"Generated on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
+        
+        for i, paper in enumerate(papers, 1):
+            markdown_content += f"## {i}. {paper.get('title', 'Unknown Title')}\n\n"
+            
+            # Authors
+            authors = paper.get('authors', [])
+            if authors:
+                author_names = [author.get('name', 'Unknown') for author in authors]
+                markdown_content += f"**Authors:** {', '.join(author_names)}\n\n"
+            
+            # Venue and year
+            venue = paper.get('venue', paper.get('journal', 'Unknown Venue'))
+            year = paper.get('year', 'Unknown Year')
+            markdown_content += f"**Venue:** {venue} ({year})\n\n"
+            
+            # DOI
+            if paper.get('doi'):
+                markdown_content += f"**DOI:** {paper['doi']}\n\n"
+            
+            # Abstract
+            if paper.get('abstract'):
+                markdown_content += f"**Abstract:** {paper['abstract']}\n\n"
+            
+            # Citation count
+            if paper.get('citation_count'):
+                markdown_content += f"**Citations:** {paper['citation_count']}\n\n"
+            
+            markdown_content += "---\n\n"
+        
+        with open(markdown_file, 'w', encoding='utf-8') as f:
+            f.write(markdown_content)
+            
+        logger.info("Markdown exported", filename=filename, count=len(papers))
+        return str(markdown_file)
+    
+    def get_session_history(self, user_id: str, limit: int = 10) -> List[Dict[str, Any]]:
+        """Get user's recent session history"""
+        sessions = []
+        sessions_dir = self.data_dir / "sessions"
+        
+        for session_file in sessions_dir.glob(f"{user_id}_*.json"):
+            try:
+                with open(session_file, 'r') as f:
+                    session_data = json.load(f)
+                    sessions.append(session_data)
+            except Exception as e:
+                logger.error("Error loading session", file=session_file, error=str(e))
+                
+        # Sort by timestamp and limit
+        sessions.sort(key=lambda x: x.get('timestamp', ''), reverse=True)
+        return sessions[:limit]
+    
+    def create_citation_network(self, papers: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Create a citation network visualization data"""
+        network = {
+            "nodes": [],
+            "edges": []
+        }
+        
+        for paper in papers:
+            # Add paper as node
+            node = {
+                "id": paper.get('id', str(uuid.uuid4())),
+                "label": paper.get('title', 'Unknown Title'),
+                "year": paper.get('year', 2024),
+                "citations": paper.get('citation_count', 0),
+                "venue": paper.get('venue', 'Unknown Venue')
+            }
+            network["nodes"].append(node)
+            
+            # Add edges based on citations (simplified)
+            # In a real implementation, you'd analyze actual citation relationships
+            
+        return network