@synsci/cli-darwin-x64 1.1.70 → 1.1.72

package/bin/skills/venue-templates/scripts/query_template.py

@@ -0,0 +1,266 @@
+#!/usr/bin/env python3
+"""
+Query Template Script
+Search and retrieve venue-specific templates by name, type, or keywords.
+
+Usage:
+    python query_template.py --venue "Nature" --type "article"
+    python query_template.py --keyword "machine learning"
+    python query_template.py --list-all
+    python query_template.py --venue "NeurIPS" --requirements
+"""
+
+import argparse
+import json
+from pathlib import Path
+
+
+# Template database
+TEMPLATES = {
+    "journals": {
+        "nature": {
+            "file": "nature_article.tex",
+            "full_name": "Nature",
+            "description": "Top-tier multidisciplinary science journal",
+            "page_limit": "~3000 words",
+            "citation_style": "Superscript numbered",
+            "format": "Single column",
+        },
+        "neurips": {
+            "file": "neurips_article.tex",
+            "full_name": "NeurIPS (Neural Information Processing Systems)",
+            "description": "Top-tier machine learning conference",
+            "page_limit": "8 pages + unlimited refs",
+            "citation_style": "Numbered [1]",
+            "format": "Two column",
+            "anonymization": "Required (double-blind)",
+        },
+        "plos_one": {
+            "file": "plos_one.tex",
+            "full_name": "PLOS ONE",
+            "description": "Open-access multidisciplinary journal",
+            "page_limit": "No limit",
+            "citation_style": "Vancouver [1]",
+            "format": "Single column",
+        },
+    },
+    "posters": {
+        "beamerposter": {
+            "file": "beamerposter_academic.tex",
+            "full_name": "Beamerposter Academic",
+            "description": "Classic academic conference poster using beamerposter",
+            "size": "A0, customizable",
+            "package": "beamerposter",
+        }
+    },
+    "grants": {
+        "nsf": {
+            "file": "nsf_proposal_template.tex",
+            "full_name": "NSF Standard Grant",
+            "description": "National Science Foundation research proposal",
+            "page_limit": "15 pages (project description)",
+            "key_sections": "Project Summary, Project Description, Broader Impacts",
+        },
+        "nih_specific_aims": {
+            "file": "nih_specific_aims.tex",
+            "full_name": "NIH Specific Aims Page",
+            "description": "Most critical page of NIH proposals",
+            "page_limit": "1 page (strictly enforced)",
+            "key_sections": "Hook, Hypothesis, 3 Aims, Payoff",
+        },
+    },
+}
+
+
+def get_skill_path():
+    """Get the path to the venue-templates skill directory."""
+    # Assume script is in .claude/skills/venue-templates/scripts/
+    script_dir = Path(__file__).parent
+    skill_dir = script_dir.parent
+    return skill_dir
+
+
+def search_templates(venue=None, template_type=None, keyword=None):
+    """Search for templates matching criteria."""
+    results = []
+
+    for cat_name, category in TEMPLATES.items():
+        # Filter by type if specified
+        if template_type and cat_name != template_type and template_type != "all":
+            continue
+
+        for temp_id, template in category.items():
+            # Filter by venue name
+            if venue:
+                venue_lower = venue.lower()
+                if venue_lower not in temp_id and venue_lower not in template.get("full_name", "").lower():
+                    continue
+
+            # Filter by keyword
+            if keyword:
+                keyword_lower = keyword.lower()
+                search_text = json.dumps(template).lower()
+                if keyword_lower not in search_text:
+                    continue
+
+            results.append(
+                {
+                    "id": temp_id,
+                    "category": cat_name,
+                    "file": template["file"],
+                    "full_name": template.get("full_name", temp_id),
+                    "description": template.get("description", ""),
+                    "details": template,
+                }
+            )
+
+    return results
+
+
+def list_all_templates():
+    """List all available templates."""
+    print("\n=== AVAILABLE TEMPLATES ===\n")
+
+    for cat_name, category in TEMPLATES.items():
+        print(f"\n{cat_name.upper()}:")
+        for temp_id, template in category.items():
+            print(f"  • {template.get('full_name', temp_id)}")
+            print(f"    File: {template['file']}")
+            if "description" in template:
+                print(f"    Description: {template['description']}")
+        print()
+
+
+def print_template_info(template):
+    """Print detailed information about a template."""
+    print(f"\n{'=' * 60}")
+    print(f"Template: {template['full_name']}")
+    print(f"{'=' * 60}")
+    print(f"Category: {template['category']}")
+    print(f"File: {template['file']}")
+
+    details = template['details']
+
+    print(f"\nDescription: {details.get('description', 'N/A')}")
+
+    if 'page_limit' in details:
+        print(f"Page Limit: {details['page_limit']}")
+    if 'citation_style' in details:
+        print(f"Citation Style: {details['citation_style']}")
+    if 'format' in details:
+        print(f"Format: {details['format']}")
+    if 'anonymization' in details:
+        print(f"⚠️  Anonymization: {details['anonymization']}")
+    if 'size' in details:
+        print(f"Poster Size: {details['size']}")
+    if 'package' in details:
+        print(f"LaTeX Package: {details['package']}")
+    if 'key_sections' in details:
+        print(f"Key Sections: {details['key_sections']}")
+
+    # Print full path to template
+    skill_path = get_skill_path()
+    template_path = skill_path / "assets" / template['category'] / template['file']
+    print(f"\nFull Path: {template_path}")
+
+    if template_path.exists():
+        print("✓ Template file exists")
+    else:
+        print("✗ Template file not found")
+
+    print()
+
+
+def print_requirements(venue):
+    """Print formatting requirements for a venue."""
+    results = search_templates(venue=venue)
+
+    if not results:
+        print(f"No templates found for venue: {venue}")
+        return
+
+    template = results[0]  # Take first match
+    details = template['details']
+
+    print(f"\n{'=' * 60}")
+    print(f"FORMATTING REQUIREMENTS: {template['full_name']}")
+    print(f"{'=' * 60}\n")
+
+    if 'page_limit' in details:
+        print(f"📄 Page Limit: {details['page_limit']}")
+    if 'format' in details:
+        print(f"📐 Format: {details['format']}")
+    if 'citation_style' in details:
+        print(f"📚 Citation Style: {details['citation_style']}")
+    if 'anonymization' in details:
+        print(f"🔒 Anonymization: {details['anonymization']}")
+    if 'size' in details:
+        print(f"📏 Size: {details['size']}")
+
+    print("\n💡 For detailed requirements, see:")
+    skill_path = get_skill_path()
+
+    if template['category'] == "journals":
+        print(f"   {skill_path}/references/journals_formatting.md")
+    elif template['category'] == "posters":
+        print(f"   {skill_path}/references/posters_guidelines.md")
+    elif template['category'] == "grants":
+        print(f"   {skill_path}/references/grants_requirements.md")
+
+    print()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Query venue-specific LaTeX templates",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s --list-all
+  %(prog)s --venue "Nature" --type journals
+  %(prog)s --keyword "machine learning"
+  %(prog)s --venue "NeurIPS" --requirements
+        """,
+    )
+
+    parser.add_argument('--venue', type=str, help='Venue name (e.g., "Nature", "NeurIPS")')
+    parser.add_argument('--type', type=str, choices=['journals', 'posters', 'grants', 'all'], help='Template type')
+    parser.add_argument('--keyword', type=str, help='Search keyword')
+    parser.add_argument('--list-all', action='store_true', help='List all available templates')
+    parser.add_argument('--requirements', action='store_true', help='Show formatting requirements for venue')
+
+    args = parser.parse_args()
+
+    # List all templates
+    if args.list_all:
+        list_all_templates()
+        return
+
+    # Show requirements
+    if args.requirements:
+        if not args.venue:
+            print("Error: --requirements requires --venue")
+            parser.print_help()
+            return
+        print_requirements(args.venue)
+        return
+
+    # Search for templates
+    if not any([args.venue, args.type, args.keyword]):
+        parser.print_help()
+        return
+
+    results = search_templates(venue=args.venue, template_type=args.type, keyword=args.keyword)
+
+    if not results:
+        print("No templates found matching your criteria.")
+        return
+
+    print(f"\nFound {len(results)} template(s):\n")
+
+    for result in results:
+        print_template_info(result)
+
+
+if __name__ == "__main__":
+    main()

package/bin/skills/venue-templates/scripts/validate_format.py

@@ -0,0 +1,250 @@
+#!/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
+
+
+# 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("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()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synsci/cli-darwin-x64",
-  "version": "1.1.70",
+  "version": "1.1.72",
   "os": [
     "darwin"
   ],

package/bin/skills/unsloth/references/index.md

@@ -1,7 +0,0 @@
-# Unsloth Documentation Index
-
-## Categories
-
-### Llms-Txt
-**File:** `llms-txt.md`
-**Pages:** 136