scientific-writer 2.3.1__py3-none-any.whl

scientific_writer/utils.py

@@ -0,0 +1,289 @@
+"""Utility functions for scientific writer."""
+
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+import re
+
+
+def find_existing_papers(output_folder: Path) -> List[Dict[str, Any]]:
+    """
+    Get all existing paper directories with their metadata.
+    
+    Args:
+        output_folder: Path to the paper outputs folder.
+        
+    Returns:
+        List of dicts with path, name, and timestamp info.
+    """
+    papers = []
+    if not output_folder.exists():
+        return papers
+    
+    for paper_dir in output_folder.iterdir():
+        if paper_dir.is_dir():
+            papers.append({
+                'path': paper_dir,
+                'name': paper_dir.name,
+                'mtime': paper_dir.stat().st_mtime
+            })
+    
+    # Sort by modification time (most recent first)
+    papers.sort(key=lambda x: x['mtime'], reverse=True)
+    return papers
+
+
+def detect_paper_reference(user_input: str, existing_papers: List[Dict[str, Any]]) -> Optional[Path]:
+    """
+    Try to detect if the user is referring to an existing paper.
+    
+    Args:
+        user_input: User's input text.
+        existing_papers: List of existing paper dictionaries.
+        
+    Returns:
+        The paper path if found, None otherwise.
+    """
+    if not existing_papers:
+        return None
+    
+    user_input_lower = user_input.lower()
+    
+    # Keywords that suggest continuing with existing work
+    continuation_keywords = [
+        "continue", "update", "edit", "revise", "modify", "change",
+        "add to", "fix", "improve", "review", "the paper", "this paper",
+        "my paper", "current paper", "previous paper", "last paper",
+        "poster", "the poster", "my poster", "compile", "generate pdf"
+    ]
+    
+    # Keywords that suggest searching for/looking up an existing paper
+    search_keywords = [
+        "look for", "find", "search for", "where is", "which paper",
+        "show me", "open", "locate", "get"
+    ]
+    
+    # Keywords that explicitly indicate a new paper
+    new_paper_keywords = [
+        "new paper", "start fresh", "start afresh", "create new",
+        "different paper", "another paper", "write a new"
+    ]
+    
+    # If user explicitly wants a new paper, return None
+    if any(keyword in user_input_lower for keyword in new_paper_keywords):
+        return None
+    
+    # Check if user mentions continuation or search keywords
+    has_continuation_keyword = any(keyword in user_input_lower for keyword in continuation_keywords)
+    has_search_keyword = any(keyword in user_input_lower for keyword in search_keywords)
+    
+    # Try to find paper by name/topic keywords
+    best_match = None
+    best_match_score = 0
+    
+    for paper in existing_papers:
+        paper_name = paper['name'].lower()
+        # Extract topic from directory name (format: YYYYMMDD_HHMMSS_topic)
+        parts = paper_name.split('_', 2)
+        if len(parts) >= 3:
+            topic = parts[2].replace('_', ' ')
+            # Check if topic words appear in user input
+            topic_words = topic.split()
+            matches = sum(1 for word in topic_words if len(word) > 3 and word in user_input_lower)
+            
+            # Keep track of best match
+            if matches > best_match_score:
+                best_match_score = matches
+                best_match = paper['path']
+            
+            # If we have a strong match (2+ topic words), return it
+            # This is especially important for search keywords
+            if matches >= 2 and (has_search_keyword or has_continuation_keyword):
+                return paper['path']
+    
+    # If we found any match with search keywords, return the best one
+    if has_search_keyword and best_match_score > 0:
+        return best_match
+    
+    # If user used continuation keywords but no specific match, use most recent paper
+    if has_continuation_keyword and existing_papers:
+        return existing_papers[0]['path']
+    
+    return None
+
+
+def scan_paper_directory(paper_dir: Path) -> Dict[str, Any]:
+    """
+    Scan a paper directory and collect all file information.
+    
+    Args:
+        paper_dir: Path to the paper directory.
+        
+    Returns:
+        Dictionary with comprehensive file information.
+    """
+    result = {
+        'pdf_final': None,
+        'tex_final': None,
+        'pdf_drafts': [],
+        'tex_drafts': [],
+        'bibliography': None,
+        'figures': [],
+        'data': [],
+        'progress_log': None,
+        'summary': None,
+    }
+    
+    if not paper_dir.exists():
+        return result
+    
+    # Scan final/ directory
+    final_dir = paper_dir / "final"
+    if final_dir.exists():
+        for file in final_dir.iterdir():
+            if file.is_file():
+                if file.suffix == '.pdf':
+                    result['pdf_final'] = str(file)
+                elif file.suffix == '.tex':
+                    result['tex_final'] = str(file)
+    
+    # Scan drafts/ directory
+    drafts_dir = paper_dir / "drafts"
+    if drafts_dir.exists():
+        for file in sorted(drafts_dir.iterdir()):
+            if file.is_file():
+                if file.suffix == '.pdf':
+                    result['pdf_drafts'].append(str(file))
+                elif file.suffix == '.tex':
+                    result['tex_drafts'].append(str(file))
+    
+    # Scan references/ directory
+    references_dir = paper_dir / "references"
+    if references_dir.exists():
+        bib_file = references_dir / "references.bib"
+        if bib_file.exists():
+            result['bibliography'] = str(bib_file)
+    
+    # Scan figures/ directory
+    figures_dir = paper_dir / "figures"
+    if figures_dir.exists():
+        for file in sorted(figures_dir.iterdir()):
+            if file.is_file():
+                result['figures'].append(str(file))
+    
+    # Scan data/ directory
+    data_dir = paper_dir / "data"
+    if data_dir.exists():
+        for file in sorted(data_dir.iterdir()):
+            if file.is_file():
+                result['data'].append(str(file))
+    
+    # Check for progress.md and SUMMARY.md
+    progress_file = paper_dir / "progress.md"
+    if progress_file.exists():
+        result['progress_log'] = str(progress_file)
+    
+    summary_file = paper_dir / "SUMMARY.md"
+    if summary_file.exists():
+        result['summary'] = str(summary_file)
+    
+    return result
+
+
+def count_citations_in_bib(bib_file: Optional[str]) -> int:
+    """
+    Count the number of citations in a BibTeX file.
+    
+    Args:
+        bib_file: Path to the .bib file.
+        
+    Returns:
+        Number of citations found.
+    """
+    if not bib_file or not Path(bib_file).exists():
+        return 0
+    
+    try:
+        with open(bib_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+            # Count @article, @book, @inproceedings, etc.
+            matches = re.findall(r'@\w+\s*{', content)
+            return len(matches)
+    except Exception:
+        return 0
+
+
+def extract_citation_style(bib_file: Optional[str]) -> str:
+    """
+    Try to extract citation style from BibTeX file or paper metadata.
+    
+    Args:
+        bib_file: Path to the .bib file.
+        
+    Returns:
+        Citation style name (default: "BibTeX").
+    """
+    # This is a simple heuristic - in practice, the style might be
+    # specified in the LaTeX file or progress log
+    return "BibTeX"
+
+
+def count_words_in_tex(tex_file: Optional[str]) -> Optional[int]:
+    """
+    Estimate word count in a LaTeX file.
+    
+    Args:
+        tex_file: Path to the .tex file.
+        
+    Returns:
+        Estimated word count, or None if file doesn't exist.
+    """
+    if not tex_file or not Path(tex_file).exists():
+        return None
+    
+    try:
+        with open(tex_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+            
+            # Remove LaTeX commands
+            content = re.sub(r'\\[a-zA-Z]+(\[.*?\])?(\{.*?\})?', '', content)
+            # Remove comments
+            content = re.sub(r'%.*', '', content)
+            # Remove special characters
+            content = re.sub(r'[{}$\\]', '', content)
+            
+            # Count words
+            words = content.split()
+            return len(words)
+    except Exception:
+        return None
+
+
+def extract_title_from_tex(tex_file: Optional[str]) -> Optional[str]:
+    """
+    Extract title from a LaTeX file.
+    
+    Args:
+        tex_file: Path to the .tex file.
+        
+    Returns:
+        Title string, or None if not found.
+    """
+    if not tex_file or not Path(tex_file).exists():
+        return None
+    
+    try:
+        with open(tex_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+            
+            # Look for \title{...}
+            match = re.search(r'\\title\s*\{([^}]+)\}', content)
+            if match:
+                title = match.group(1)
+                # Clean up LaTeX commands in title
+                title = re.sub(r'\\[a-zA-Z]+(\[.*?\])?(\{.*?\})?', '', title)
+                return title.strip()
+    except Exception:
+        pass
+    
+    return None
+

scientific_writer-2.3.1.dist-info/METADATA

@@ -0,0 +1,272 @@
+Metadata-Version: 2.4
+Name: scientific-writer
+Version: 2.3.1
+Summary: AI-powered scientific writing with programmatic API and CLI - powered by Claude Sonnet 4.5 and the Claude Agents SDK
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: claude-agent-sdk>=0.1.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: requests>=2.31.0
+Description-Content-Type: text/markdown
+
+# Claude Scientific Writer
+
+[![PyPI version](https://img.shields.io/pypi/v/scientific-writer.svg)](https://pypi.org/project/scientific-writer/)
+[![Total Downloads](https://static.pepy.tech/badge/scientific-writer)](https://pepy.tech/project/scientific-writer)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A Python package and CLI for generating publication-ready scientific papers, reports, posters, grant proposals, and more academic documents with Claude Sonnet 4.5. Features real-time research lookup, intelligent paper detection, and comprehensive document conversion. Version 2.0 adds a fully typed, programmatic API while keeping the CLI 100% backward compatible.
+
+**✨ What's New in v2.0+**
+- Programmatic Python API with async support
+- Research lookup with Perplexity Sonar Pro
+- Intelligent paper detection (auto-resume editing)
+- Clinical reports (case reports, diagnostic reports, trial reports, HIPAA compliance)
+- Grant proposal generation (NSF, NIH, DOE, DARPA)
+- Research posters with LaTeX
+- Scientific schematics (CONSORT, circuits, pathways)
+- Document conversion (15+ formats with MarkItDown)
+- ScholarEval peer review framework
+
+## Quick Start
+
+### Prerequisites
+- Python 3.10-3.12
+- ANTHROPIC_API_KEY (required), OPENROUTER_API_KEY (optional for research lookup)
+
+### Install
+
+#### Option 1: Install from PyPI (Recommended)
+```bash
+pip install scientific-writer
+```
+
+#### Option 2: Install from source with uv
+```bash
+git clone https://github.com/yourusername/claude-scientific-writer.git
+cd claude-scientific-writer
+uv sync
+```
+
+### Configure API keys
+```bash
+# .env file (recommended)
+echo "ANTHROPIC_API_KEY=your_key" > .env
+echo "OPENROUTER_API_KEY=your_openrouter_key" >> .env
+# or export in your shell
+export ANTHROPIC_API_KEY='your_key'
+```
+
+### Use the CLI
+```bash
+# If installed via pip
+scientific-writer
+
+# If installed from source with uv
+uv run scientific-writer
+```
+
+### Use the Python API
+```python
+import asyncio
+from scientific_writer import generate_paper
+
+async def main():
+    async for update in generate_paper("Create a Nature paper on CRISPR gene editing"):
+        if update["type"] == "progress":
+            print(f"[{update['percentage']}%] {update['message']}")
+        else:
+            print(f"PDF: {update['files']['pdf_final']}")
+
+asyncio.run(main())
+```
+
+## Features
+
+### 📝 Document Generation
+- **Scientific papers** with IMRaD structure (Nature, Science, NeurIPS, etc.)
+- **Clinical reports** (case reports, diagnostic reports, trial reports, patient documentation)
+- **Research posters** using LaTeX (beamerposter, tikzposter, baposter)
+- **Grant proposals** (NSF, NIH, DOE, DARPA) with agency-specific formatting
+- **Literature reviews** with systematic citation management
+- **Scientific schematics** (CONSORT diagrams, circuit diagrams, biological pathways)
+
+### 🤖 AI-Powered Capabilities
+- **Real-time research lookup** using Perplexity Sonar Pro (via OpenRouter)
+- **Intelligent paper detection** - automatically identifies references to existing papers
+- **Peer review feedback** with quantitative ScholarEval framework (8-dimension scoring)
+- **Iterative editing** with context-aware revision suggestions
+
+### 🔧 Developer-Friendly
+- **Programmatic API** - Full async Python API with type hints
+- **CLI interface** - Interactive command-line tool with progress tracking
+- **Progress streaming** - Real-time updates during generation
+- **Comprehensive results** - JSON output with metadata, file paths, citations
+
+### 📦 Data & File Integration
+- **Automatic data handling** - Drop files in `data/`, auto-sorted to `figures/` or `data/`
+- **Document conversion** - PDF, DOCX, PPTX, XLSX to Markdown with MarkItDown
+- **Bibliography management** - Automatic BibTeX generation and citation formatting
+- **Figure integration** - Images automatically referenced and organized
+
+## Typical Workflow
+
+### CLI Usage
+1. Place figures and data in `data/` at the project root (images → `figures/`, files → `data/` automatically)
+2. Run `scientific-writer` and describe what you want
+3. Follow progress updates; outputs saved to `paper_outputs/<timestamp>_<topic>/`
+
+```bash
+# Start a new paper
+> Create a Nature paper on CRISPR gene editing with 5 key references
+
+# Continue editing (automatically detected)
+> Add a methods section about the experimental setup
+
+# Reference existing paper by topic
+> Find the acoustics paper and add a conclusion section
+
+# Generate a grant proposal
+> Write an NSF proposal for quantum computing research
+
+# Create a research poster
+> Generate a conference poster from my paper
+```
+
+### API Usage
+```python
+import asyncio
+from scientific_writer import generate_paper
+
+async def main():
+    async for update in generate_paper(
+        query="Create a NeurIPS paper on transformers",
+        data_files=["results.csv", "figure.png"],
+        output_dir="./my_papers"
+    ):
+        if update["type"] == "progress":
+            print(f"[{update['percentage']}%] {update['message']}")
+        else:
+            print(f"✓ PDF: {update['files']['pdf_final']}")
+
+asyncio.run(main())
+```
+
+## Quick Reference
+
+### Common Commands
+
+| Task | Command Example |
+|------|----------------|
+| **Scientific Paper** | `> Create a Nature paper on CRISPR gene editing` |
+| **Clinical Report** | `> Create a clinical case report for rare disease presentation` |
+| **Grant Proposal** | `> Write an NSF proposal for quantum computing research` |
+| **Research Poster** | `> Generate a conference poster from my paper` |
+| **Literature Review** | `> Create a literature review on machine learning in healthcare` |
+| **Peer Review** | `> Evaluate this paper using the ScholarEval framework` |
+| **Continue Editing** | `> Add a methods section` (automatically continues current paper) |
+| **Find Existing Paper** | `> Find the acoustics paper and add a conclusion` |
+| **New Paper** | `> new paper on climate change` (explicitly start fresh) |
+
+### Research Lookup Examples
+
+```bash
+# Recent research (auto-triggers research lookup)
+> Create a paper on recent advances in quantum computing (2024)
+
+# Fact verification
+> What are the current success rates for CAR-T therapy?
+
+# Literature search
+> Find 10 recent papers on transformer architectures from 2023-2024
+```
+
+### Document Types
+
+| Type | Example |
+|------|---------|
+| **Papers** | Nature, Science, NeurIPS, ICML, IEEE, ACM |
+| **Clinical Reports** | Case reports, diagnostic reports, trial reports, patient notes |
+| **Grants** | NSF, NIH R01/R21/K, DOE, DARPA |
+| **Posters** | Conference posters (A0, A1, custom sizes) |
+| **Reviews** | Systematic literature reviews |
+| **Schematics** | CONSORT diagrams, circuits, biological pathways |
+
+### File Handling
+
+```bash
+# 1. Drop files in data/ folder
+cp results.csv ~/Documents/claude-scientific-writer/data/
+cp figure.png ~/Documents/claude-scientific-writer/data/
+
+# 2. Files are auto-sorted:
+#    Images (png, jpg, svg) → figures/
+#    Data (csv, json, txt) → data/
+
+# 3. Reference in paper
+> Create a paper analyzing the experimental results in results.csv
+```
+
+### API Quick Start
+
+```python
+import asyncio
+from scientific_writer import generate_paper
+
+# Simple usage
+async for update in generate_paper("Create a Nature paper on CRISPR"):
+    if update["type"] == "result":
+        print(f"PDF: {update['files']['pdf_final']}")
+
+# With data files
+async for update in generate_paper(
+    query="Analyze experimental results",
+    data_files=["results.csv", "figure.png"],
+    output_dir="./papers"
+):
+    if update["type"] == "progress":
+        print(f"[{update['percentage']}%] {update['message']}")
+```
+
+## Documentation
+
+### User Guides
+- [📖 Complete Features Guide](docs/FEATURES.md) - Comprehensive overview of all capabilities
+- [🔧 API Reference](docs/API.md) - Full programmatic API documentation
+- [🎯 Skills Overview](docs/SKILLS.md) - All available skills and tools
+- [🐛 Troubleshooting](docs/TROUBLESHOOTING.md) - Common issues and solutions
+
+### Developer Resources
+- [💻 Development Guide](docs/DEVELOPMENT.md) - Contributing and development setup
+- [📦 Releasing Guide](docs/RELEASING.md) - Versioning and publishing
+- [📋 Release Notes](CHANGELOG.md) - Version history and updates
+- [🤖 System Instructions](CLAUDE.md) - Agent instructions (advanced)
+
+## Versioning and Publishing (short)
+Use `uv` and the helper scripts:
+- Bump version (keeps pyproject + __init__ in sync): `uv run scripts/bump_version.py [patch|minor|major]`
+- Build and publish: `uv run scripts/publish.py` (or `--bump patch|minor|major`)
+See [docs/RELEASING.md](docs/RELEASING.md) for prerequisites, dry runs, tagging, and verification.
+
+## Migration (v1.x -> v2.0)
+- CLI remains unchanged (scientific-writer).
+- New programmatic API: from scientific_writer import generate_paper.
+- Legacy single-file script is replaced by a proper package; no action needed for CLI users.
+
+## License
+MIT - see LICENSE.
+
+## Support
+- Open an issue on GitHub
+- See [docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md) for common problems
+
+## ⭐ Show Your Support
+
+If you find this project helpful for your research or work, please consider giving it a star on GitHub! It helps others discover the tool and motivates continued development. Thank you! 🙏
+
+![GitHub stars](https://img.shields.io/github/stars/K-Dense-AI/claude-scientific-writer?style=social)
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=K-Dense-AI/claude-scientific-writer&type=Date)](https://star-history.com/#K-Dense-AI/claude-scientific-writer&Date)