scientific-writer 2.3.1__py3-none-any.whl

scientific_writer/.claude/skills/venue-templates/scripts/validate_format.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""
+Validate Format Script
+Check if document meets venue-specific formatting requirements.
+
+Usage:
+    python validate_format.py --file my_paper.pdf --venue "Nature" --check-all
+    python validate_format.py --file my_paper.pdf --venue "NeurIPS" --check page-count,margins
+    python validate_format.py --file my_paper.pdf --venue "PLOS ONE" --report validation_report.txt
+"""
+
+import argparse
+import subprocess
+from pathlib import Path
+import re
+
+# Venue requirements database
+VENUE_REQUIREMENTS = {
+    "nature": {
+        "page_limit": 5,  # Approximate for ~3000 words
+        "margins": {"top": 2.5, "bottom": 2.5, "left": 2.5, "right": 2.5},  # cm
+        "font_size": 12,  # pt
+        "font_family": "Times",
+        "line_spacing": "double"
+    },
+    "neurips": {
+        "page_limit": 8,  # Excluding refs
+        "margins": {"top": 2.54, "bottom": 2.54, "left": 2.54, "right": 2.54},  # cm (1 inch)
+        "font_size": 10,
+        "font_family": "Times",
+        "format": "two-column"
+    },
+    "plos_one": {
+        "page_limit": None,  # No limit
+        "margins": {"top": 2.54, "bottom": 2.54, "left": 2.54, "right": 2.54},
+        "font_size": 10,
+        "font_family": "Arial",
+        "line_spacing": "double"
+    },
+    "nsf": {
+        "page_limit": 15,  # Project description
+        "margins": {"top": 2.54, "bottom": 2.54, "left": 2.54, "right": 2.54},  # 1 inch required
+        "font_size": 11,  # Minimum
+        "font_family": "Times Roman",
+        "line_spacing": "single or double"
+    },
+    "nih": {
+        "page_limit": 12,  # Research strategy
+        "margins": {"top": 1.27, "bottom": 1.27, "left": 1.27, "right": 1.27},  # 0.5 inch minimum
+        "font_size": 11,  # Arial 11pt minimum
+        "font_family": "Arial",
+        "line_spacing": "any"
+    }
+}
+
+def get_pdf_info(pdf_path):
+    """Extract information from PDF using pdfinfo."""
+    try:
+        result = subprocess.run(
+            ['pdfinfo', str(pdf_path)],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        info = {}
+        for line in result.stdout.split('\n'):
+            if ':' in line:
+                key, value = line.split(':', 1)
+                info[key.strip()] = value.strip()
+        
+        return info
+    except FileNotFoundError:
+        print("⚠️  pdfinfo not found. Install poppler-utils for full PDF analysis.")
+        print("   macOS: brew install poppler")
+        print("   Linux: sudo apt-get install poppler-utils")
+        return None
+    except subprocess.CalledProcessError as e:
+        print(f"Error running pdfinfo: {e}")
+        return None
+
+def check_page_count(pdf_path, venue_reqs):
+    """Check if page count is within limit."""
+    pdf_info = get_pdf_info(pdf_path)
+    
+    if not pdf_info:
+        return {"status": "skip", "message": "Could not determine page count"}
+    
+    pages = int(pdf_info.get('Pages', 0))
+    limit = venue_reqs.get('page_limit')
+    
+    if limit is None:
+        return {"status": "pass", "message": f"No page limit. Document has {pages} pages."}
+    
+    if pages <= limit:
+        return {"status": "pass", "message": f"✓ Page count OK: {pages}/{limit} pages"}
+    else:
+        return {"status": "fail", "message": f"✗ Page count exceeded: {pages}/{limit} pages"}
+
+def check_margins(pdf_path, venue_reqs):
+    """Check if margins meet requirements."""
+    # Note: This is a simplified check. Full margin analysis requires more sophisticated tools.
+    req_margins = venue_reqs.get('margins', {})
+    
+    if not req_margins:
+        return {"status": "skip", "message": "No margin requirements specified"}
+    
+    # This is a placeholder - accurate margin checking requires parsing PDF content
+    return {
+        "status": "info",
+        "message": f"ℹ️  Required margins: {req_margins} cm (manual verification recommended)"
+    }
+
+def check_fonts(pdf_path, venue_reqs):
+    """Check fonts in PDF."""
+    try:
+        result = subprocess.run(
+            ['pdffonts', str(pdf_path)],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        fonts_found = []
+        for line in result.stdout.split('\n')[2:]:  # Skip header
+            if line.strip():
+                parts = line.split()
+                if parts:
+                    fonts_found.append(parts[0])
+        
+        req_font = venue_reqs.get('font_family', '')
+        req_size = venue_reqs.get('font_size')
+        
+        message = f"ℹ️  Fonts found: {', '.join(set(fonts_found))}\n"
+        message += f"   Required: {req_font}"
+        if req_size:
+            message += f" {req_size}pt minimum"
+        
+        return {"status": "info", "message": message}
+        
+    except FileNotFoundError:
+        return {"status": "skip", "message": "pdffonts not available"}
+    except subprocess.CalledProcessError:
+        return {"status": "skip", "message": "Could not extract font information"}
+
+def validate_document(pdf_path, venue, checks):
+    """Validate document against venue requirements."""
+    
+    venue_key = venue.lower().replace(" ", "_")
+    
+    if venue_key not in VENUE_REQUIREMENTS:
+        print(f"❌ Unknown venue: {venue}")
+        print(f"Available venues: {', '.join(VENUE_REQUIREMENTS.keys())}")
+        return
+    
+    venue_reqs = VENUE_REQUIREMENTS[venue_key]
+    
+    print(f"\n{'='*60}")
+    print(f"VALIDATING: {pdf_path.name}")
+    print(f"VENUE: {venue}")
+    print(f"{'='*60}\n")
+    
+    results = {}
+    
+    # Run requested checks
+    if 'page-count' in checks or 'all' in checks:
+        results['page-count'] = check_page_count(pdf_path, venue_reqs)
+    
+    if 'margins' in checks or 'all' in checks:
+        results['margins'] = check_margins(pdf_path, venue_reqs)
+    
+    if 'fonts' in checks or 'all' in checks:
+        results['fonts'] = check_fonts(pdf_path, venue_reqs)
+    
+    # Print results
+    for check_name, result in results.items():
+        print(f"{check_name.upper()}:")
+        print(f"  {result['message']}\n")
+    
+    # Summary
+    failures = sum(1 for r in results.values() if r['status'] == 'fail')
+    passes = sum(1 for r in results.values() if r['status'] == 'pass')
+    
+    print(f"{'='*60}")
+    if failures == 0:
+        print(f"✓ VALIDATION PASSED ({passes} checks)")
+    else:
+        print(f"✗ VALIDATION FAILED ({failures} issues)")
+    print(f"{'='*60}\n")
+    
+    return results
+
+def generate_report(pdf_path, venue, results, report_path):
+    """Generate validation report."""
+    
+    with open(report_path, 'w') as f:
+        f.write(f"Validation Report\n")
+        f.write(f"{'='*60}\n\n")
+        f.write(f"File: {pdf_path}\n")
+        f.write(f"Venue: {venue}\n")
+        f.write(f"Date: {Path.ctime(pdf_path)}\n\n")
+        
+        for check_name, result in results.items():
+            f.write(f"{check_name.upper()}:\n")
+            f.write(f"  Status: {result['status']}\n")
+            f.write(f"  {result['message']}\n\n")
+        
+        failures = sum(1 for r in results.values() if r['status'] == 'fail')
+        f.write(f"\nSummary: {'PASSED' if failures == 0 else 'FAILED'}\n")
+    
+    print(f"Report saved to: {report_path}")
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Validate document formatting for venue requirements",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s --file my_paper.pdf --venue "Nature" --check-all
+  %(prog)s --file my_paper.pdf --venue "NeurIPS" --check page-count,fonts
+  %(prog)s --file proposal.pdf --venue "NSF" --report validation.txt
+        """
+    )
+    
+    parser.add_argument('--file', type=str, required=True, help='PDF file to validate')
+    parser.add_argument('--venue', type=str, required=True, help='Target venue')
+    parser.add_argument('--check', type=str, default='all',
+                      help='Checks to perform: page-count, margins, fonts, all (comma-separated)')
+    parser.add_argument('--check-all', action='store_true', help='Perform all checks')
+    parser.add_argument('--report', type=str, help='Save report to file')
+    
+    args = parser.parse_args()
+    
+    # Check file exists
+    pdf_path = Path(args.file)
+    if not pdf_path.exists():
+        print(f"Error: File not found: {pdf_path}")
+        return
+    
+    # Parse checks
+    if args.check_all:
+        checks = ['all']
+    else:
+        checks = [c.strip() for c in args.check.split(',')]
+    
+    # Validate
+    results = validate_document(pdf_path, args.venue, checks)
+    
+    # Generate report if requested
+    if args.report and results:
+        generate_report(pdf_path, args.venue, results, Path(args.report))
+
+if __name__ == "__main__":
+    main()
+

scientific_writer/__init__.py

@@ -0,0 +1,43 @@
+"""
+Scientific Writer - AI-powered scientific writing assistant.
+
+A powerful Python package for generating scientific papers, literature reviews,
+and academic documents using Claude Sonnet 4.5.
+
+Example:
+    Generate a paper programmatically::
+
+        import asyncio
+        from scientific_writer import generate_paper
+
+        async def main():
+            async for update in generate_paper("Create a Nature paper on CRISPR"):
+                if update["type"] == "progress":
+                    print(f"[{update['percentage']}%] {update['message']}")
+                else:
+                    print(f"Paper created: {update['paper_directory']}")
+                    print(f"PDF: {update['files']['pdf_final']}")
+
+        asyncio.run(main())
+
+    Use the CLI::
+
+        $ scientific-writer
+        > Create a NeurIPS paper on transformer attention mechanisms
+"""
+
+from .api import generate_paper
+from .models import ProgressUpdate, PaperResult, PaperMetadata, PaperFiles
+
+__version__ = "2.3.1"
+__author__ = "K-Dense"
+__license__ = "MIT"
+
+__all__ = [
+    "generate_paper",
+    "ProgressUpdate",
+    "PaperResult",
+    "PaperMetadata",
+    "PaperFiles",
+]
+

scientific_writer/api.py

@@ -0,0 +1,393 @@
+"""Async API for programmatic scientific paper generation."""
+
+import asyncio
+import time
+from pathlib import Path
+from typing import Optional, List, Dict, Any, AsyncGenerator, Union
+from datetime import datetime
+from dotenv import load_dotenv
+
+from claude_agent_sdk import query, ClaudeAgentOptions
+
+from .core import (
+    get_api_key,
+    load_system_instructions,
+    ensure_output_folder,
+    get_data_files,
+    process_data_files,
+    create_data_context_message,
+    setup_claude_skills,
+)
+from .models import ProgressUpdate, PaperResult, PaperMetadata, PaperFiles
+from .utils import (
+    scan_paper_directory,
+    count_citations_in_bib,
+    extract_citation_style,
+    count_words_in_tex,
+    extract_title_from_tex,
+)
+
+
+async def generate_paper(
+    query: str,
+    output_dir: Optional[str] = None,
+    api_key: Optional[str] = None,
+    model: str = "claude-sonnet-4-20250514",
+    data_files: Optional[List[str]] = None,
+    cwd: Optional[str] = None,
+) -> AsyncGenerator[Dict[str, Any], None]:
+    """
+    Generate a scientific paper asynchronously with progress updates.
+    
+    This is a stateless async generator that yields progress updates during
+    execution and a final comprehensive result with all paper details.
+    
+    Args:
+        query: The paper generation request (e.g., "Create a Nature paper on CRISPR")
+        output_dir: Optional custom output directory (defaults to cwd/paper_outputs)
+        api_key: Optional Anthropic API key (defaults to ANTHROPIC_API_KEY env var)
+        model: Claude model to use (default: claude-sonnet-4-20250514)
+        data_files: Optional list of data file paths to include
+        cwd: Optional working directory (defaults to package parent directory)
+    
+    Yields:
+        Progress updates (dict with type="progress") during execution
+        Final result (dict with type="result") containing all paper information
+        
+    Example:
+        ```python
+        async for update in generate_paper("Create a NeurIPS paper on transformers"):
+            if update["type"] == "progress":
+                print(f"[{update['percentage']}%] {update['message']}")
+            else:
+                print(f"Paper created: {update['paper_directory']}")
+                print(f"PDF: {update['files']['pdf_final']}")
+        ```
+    """
+    # Initialize
+    start_time = time.time()
+    
+    # Explicitly load .env file from working directory
+    # Determine working directory first
+    if cwd:
+        work_dir = Path(cwd).resolve()
+    else:
+        work_dir = Path.cwd().resolve()
+    
+    # Load .env from working directory
+    env_file = work_dir / ".env"
+    if env_file.exists():
+        load_dotenv(dotenv_path=env_file, override=True)
+    
+    # Get API key
+    try:
+        api_key_value = get_api_key(api_key)
+    except ValueError as e:
+        yield _create_error_result(str(e))
+        return
+    
+    # Get package directory for copying skills to working directory
+    package_dir = Path(__file__).parent.absolute()  # scientific_writer/ directory
+    
+    # Set up Claude skills in the working directory (includes WRITER.md)
+    setup_claude_skills(package_dir, work_dir)
+    
+    # Ensure output folder exists in user's directory
+    output_folder = ensure_output_folder(work_dir, output_dir)
+    
+    # Initial progress update
+    yield ProgressUpdate(
+        message="Initializing paper generation",
+        stage="initialization",
+        percentage=0,
+    ).to_dict()
+    
+    # Load system instructions from .claude/WRITER.md in working directory
+    system_instructions = load_system_instructions(work_dir)
+    
+    # Add conversation continuity instruction
+    system_instructions += "\n\n" + f"""
+IMPORTANT - WORKING DIRECTORY:
+- Your working directory is: {work_dir}
+- ALWAYS create paper_outputs folder in this directory: {work_dir}/paper_outputs/
+- NEVER write to /tmp/ or any other temporary directory
+- All paper outputs MUST go to: {work_dir}/paper_outputs/<timestamp>_<description>/
+
+IMPORTANT - CONVERSATION CONTINUITY:
+- This is a NEW paper request - create a new paper directory
+- Create a unique timestamped directory in the paper_outputs folder
+- Do NOT assume there's an existing paper unless explicitly told in the prompt context
+"""
+    
+    # Process data files if provided
+    data_context = ""
+    temp_paper_path = None
+    
+    if data_files:
+        data_file_paths = get_data_files(work_dir, data_files)
+        if data_file_paths:
+            # We'll need to process these after the paper directory is created
+            yield ProgressUpdate(
+                message=f"Found {len(data_file_paths)} data file(s) to process",
+                stage="initialization",
+                percentage=5,
+            ).to_dict()
+    
+    # Configure Claude agent options
+    options = ClaudeAgentOptions(
+        system_prompt=system_instructions,
+        model=model,
+        allowed_tools=["Read", "Write", "Edit", "Bash", "research-lookup"],
+        permission_mode="bypassPermissions",
+        setting_sources=["project"],  # Load skills from project .claude directory
+        cwd=str(work_dir),  # User's working directory
+    )
+    
+    # Track progress through message analysis
+    current_stage = "initialization"
+    current_percentage = 10
+    paper_directory = None
+    
+    yield ProgressUpdate(
+        message="Starting paper generation with Claude",
+        stage="initialization",
+        percentage=10,
+    ).to_dict()
+    
+    # Execute query with Claude
+    try:
+        accumulated_text = ""
+        async for message in query(prompt=query, options=options):
+            if hasattr(message, "content") and message.content:
+                for block in message.content:
+                    if hasattr(block, "text"):
+                        text = block.text
+                        accumulated_text += text
+                        
+                        # Analyze text for progress indicators
+                        stage, percentage, msg = _analyze_progress(accumulated_text, current_stage, current_percentage)
+                        
+                        if stage != current_stage or percentage != current_percentage:
+                            current_stage = stage
+                            current_percentage = percentage
+                            
+                            yield ProgressUpdate(
+                                message=msg,
+                                stage=stage,
+                                percentage=percentage,
+                            ).to_dict()
+        
+        # Paper generation complete - now scan for results
+        yield ProgressUpdate(
+            message="Scanning paper output directory",
+            stage="complete",
+            percentage=95,
+        ).to_dict()
+        
+        # Find the most recently created paper directory
+        paper_directory = _find_most_recent_paper(output_folder, start_time)
+        
+        if not paper_directory:
+            yield _create_error_result("Paper directory not found after generation")
+            return
+        
+        # Process any data files now if we have a paper directory
+        if data_files:
+            data_file_paths = get_data_files(work_dir, data_files)
+            if data_file_paths:
+                processed_info = process_data_files(
+                    work_dir, 
+                    data_file_paths, 
+                    str(paper_directory),
+                    delete_originals=False  # Don't delete when using programmatic API
+                )
+                if processed_info:
+                    manuscript_count = len(processed_info.get('manuscript_files', []))
+                    message = f"Processed {len(processed_info['all_files'])} file(s)"
+                    if manuscript_count > 0:
+                        message += f" ({manuscript_count} manuscript(s) copied to drafts/)"
+                    yield ProgressUpdate(
+                        message=message,
+                        stage="complete",
+                        percentage=97,
+                    ).to_dict()
+        
+        # Scan the paper directory for all files
+        file_info = scan_paper_directory(paper_directory)
+        
+        # Build comprehensive result
+        result = _build_paper_result(paper_directory, file_info)
+        
+        yield ProgressUpdate(
+            message="Paper generation complete",
+            stage="complete",
+            percentage=100,
+        ).to_dict()
+        
+        # Final result
+        yield result.to_dict()
+        
+    except Exception as e:
+        yield _create_error_result(f"Error during paper generation: {str(e)}")
+
+
+def _analyze_progress(text: str, current_stage: str, current_percentage: int) -> tuple:
+    """
+    Analyze accumulated text to determine current progress stage.
+    
+    Returns:
+        Tuple of (stage, percentage, message)
+    """
+    text_lower = text.lower()
+    
+    # Check for various progress indicators
+    if "research" in text_lower or "literature" in text_lower or "searching" in text_lower:
+        if current_stage != "research":
+            return "research", 30, "Conducting literature research"
+    
+    if "writing" in text_lower or "introduction" in text_lower or "methods" in text_lower:
+        if current_stage != "writing":
+            return "writing", 50, "Writing paper sections"
+        elif current_percentage < 70:
+            return "writing", min(current_percentage + 10, 70), "Writing paper sections"
+    
+    if "compil" in text_lower or "latex" in text_lower or "pdf" in text_lower:
+        if current_stage != "compilation":
+            return "compilation", 80, "Compiling LaTeX to PDF"
+    
+    if "complete" in text_lower or "finished" in text_lower or "done" in text_lower:
+        return "complete", 90, "Finalizing paper"
+    
+    # No change detected
+    return current_stage, current_percentage, "Processing..."
+
+
+def _find_most_recent_paper(output_folder: Path, start_time: float) -> Optional[Path]:
+    """
+    Find the most recently created/modified paper directory.
+    
+    Args:
+        output_folder: Path to paper_outputs folder
+        start_time: Start time of generation (to filter relevant directories)
+    
+    Returns:
+        Path to paper directory or None
+    """
+    try:
+        paper_dirs = [d for d in output_folder.iterdir() if d.is_dir()]
+        if not paper_dirs:
+            return None
+        
+        # Filter to only directories modified after start_time
+        recent_dirs = [
+            d for d in paper_dirs 
+            if d.stat().st_mtime >= start_time - 5  # 5 second buffer
+        ]
+        
+        if not recent_dirs:
+            # Fallback to most recent directory overall
+            recent_dirs = paper_dirs
+        
+        # Return the most recent
+        most_recent = max(recent_dirs, key=lambda d: d.stat().st_mtime)
+        return most_recent
+    except Exception:
+        return None
+
+
+def _build_paper_result(paper_dir: Path, file_info: Dict[str, Any]) -> PaperResult:
+    """
+    Build a comprehensive PaperResult from scanned files.
+    
+    Args:
+        paper_dir: Path to paper directory
+        file_info: Dictionary of file information from scan_paper_directory
+    
+    Returns:
+        PaperResult object
+    """
+    # Extract metadata
+    tex_file = file_info['tex_final'] or (file_info['tex_drafts'][0] if file_info['tex_drafts'] else None)
+    
+    title = extract_title_from_tex(tex_file)
+    word_count = count_words_in_tex(tex_file)
+    
+    # Extract topic from directory name
+    topic = ""
+    parts = paper_dir.name.split('_', 2)
+    if len(parts) >= 3:
+        topic = parts[2].replace('_', ' ')
+    
+    metadata = PaperMetadata(
+        title=title,
+        created_at=datetime.fromtimestamp(paper_dir.stat().st_ctime).isoformat() + "Z",
+        topic=topic,
+        word_count=word_count,
+    )
+    
+    # Build files object
+    files = PaperFiles(
+        pdf_final=file_info['pdf_final'],
+        tex_final=file_info['tex_final'],
+        pdf_drafts=file_info['pdf_drafts'],
+        tex_drafts=file_info['tex_drafts'],
+        bibliography=file_info['bibliography'],
+        figures=file_info['figures'],
+        data=file_info['data'],
+        progress_log=file_info['progress_log'],
+        summary=file_info['summary'],
+    )
+    
+    # Citations info
+    citation_count = count_citations_in_bib(file_info['bibliography'])
+    citation_style = extract_citation_style(file_info['bibliography'])
+    
+    citations = {
+        'count': citation_count,
+        'style': citation_style,
+        'file': file_info['bibliography'],
+    }
+    
+    # Determine status
+    status = "success"
+    compilation_success = file_info['pdf_final'] is not None
+    
+    if not compilation_success:
+        if file_info['tex_final']:
+            status = "partial"  # TeX created but PDF failed
+        else:
+            status = "failed"
+    
+    result = PaperResult(
+        status=status,
+        paper_directory=str(paper_dir),
+        paper_name=paper_dir.name,
+        metadata=metadata,
+        files=files,
+        citations=citations,
+        figures_count=len(file_info['figures']),
+        compilation_success=compilation_success,
+        errors=[],
+    )
+    
+    return result
+
+
+def _create_error_result(error_message: str) -> Dict[str, Any]:
+    """
+    Create an error result dictionary.
+    
+    Args:
+        error_message: Error message string
+    
+    Returns:
+        Dictionary with error information
+    """
+    result = PaperResult(
+        status="failed",
+        paper_directory="",
+        paper_name="",
+        errors=[error_message],
+    )
+    return result.to_dict()
+