@synsci/cli-darwin-x64 1.1.70 → 1.1.72

package/bin/skills/research-lookup/examples.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""
+Example usage of the Research Lookup skill with automatic model selection.
+
+This script demonstrates:
+1. Automatic model selection based on query complexity
+2. Manual model override options
+3. Batch query processing
+4. Integration with scientific writing workflows
+"""
+
+import os
+
+from research_lookup import ResearchLookup
+
+
+def example_automatic_selection():
+    """Demonstrate automatic model selection."""
+    print("=" * 80)
+    print("EXAMPLE 1: Automatic Model Selection")
+    print("=" * 80)
+    print()
+
+    research = ResearchLookup()
+
+    # Simple lookup - will use Sonar Pro Search
+    query1 = "Recent advances in CRISPR gene editing 2024"
+    print(f"Query: {query1}")
+    print("Expected model: Sonar Pro Search (fast lookup)")
+    result1 = research.lookup(query1)
+    print(f"Actual model: {result1.get('model')}")
+    print()
+
+    # Complex analysis - will use Sonar Reasoning Pro
+    query2 = "Compare and contrast the efficacy of mRNA vaccines versus traditional vaccines"
+    print(f"Query: {query2}")
+    print("Expected model: Sonar Reasoning Pro (analytical)")
+    result2 = research.lookup(query2)
+    print(f"Actual model: {result2.get('model')}")
+    print()
+
+
+def example_manual_override():
+    """Demonstrate manual model override."""
+    print("=" * 80)
+    print("EXAMPLE 2: Manual Model Override")
+    print("=" * 80)
+    print()
+
+    # Force Sonar Pro Search for budget-constrained rapid lookup
+    research_pro = ResearchLookup(force_model='pro')
+    query = "Explain the mechanism of CRISPR-Cas9"
+    print(f"Query: {query}")
+    print("Forced model: Sonar Pro Search")
+    result = research_pro.lookup(query)
+    print(f"Model used: {result.get('model')}")
+    print()
+
+    # Force Sonar Reasoning Pro for critical analysis
+    research_reasoning = ResearchLookup(force_model='reasoning')
+    print(f"Query: {query}")
+    print("Forced model: Sonar Reasoning Pro")
+    result = research_reasoning.lookup(query)
+    print(f"Model used: {result.get('model')}")
+    print()
+
+
+def example_batch_queries():
+    """Demonstrate batch query processing."""
+    print("=" * 80)
+    print("EXAMPLE 3: Batch Query Processing")
+    print("=" * 80)
+    print()
+
+    research = ResearchLookup()
+
+    # Mix of simple and complex queries
+    queries = [
+        "Recent clinical trials for Alzheimer's disease",  # Sonar Pro Search
+        "Compare deep learning vs traditional ML in drug discovery",  # Sonar Reasoning Pro
+        "Statistical power analysis methods",  # Sonar Pro Search
+    ]
+
+    print("Processing batch queries...")
+    print("Each query will automatically select the appropriate model")
+    print()
+
+    results = research.batch_lookup(queries, delay=1.0)
+
+    for i, result in enumerate(results):
+        print(f"Query {i + 1}: {result['query'][:50]}...")
+        print(f"  Model: {result.get('model')}")
+        print(f"  Type: {result.get('model_type')}")
+        print()
+
+
+def example_scientific_writing_workflow():
+    """Demonstrate integration with scientific writing workflow."""
+    print("=" * 80)
+    print("EXAMPLE 4: Scientific Writing Workflow")
+    print("=" * 80)
+    print()
+
+    research = ResearchLookup()
+
+    # Literature review phase - use Pro for breadth
+    print("PHASE 1: Literature Review (Breadth)")
+    lit_queries = [
+        "Recent papers on machine learning in genomics 2024",
+        "Clinical applications of AI in radiology",
+        "RNA sequencing analysis methods",
+    ]
+
+    for query in lit_queries:
+        print(f"  - {query}")
+        # These will automatically use Sonar Pro Search
+    print()
+
+    # Discussion phase - use Reasoning Pro for synthesis
+    print("PHASE 2: Discussion (Synthesis & Analysis)")
+    discussion_queries = [
+        "Compare the advantages and limitations of different ML approaches in genomics",
+        "Explain the relationship between model interpretability and clinical adoption",
+        "Analyze the ethical implications of AI in medical diagnosis",
+    ]
+
+    for query in discussion_queries:
+        print(f"  - {query}")
+        # These will automatically use Sonar Reasoning Pro
+    print()
+
+
+def main():
+    """Run all examples (requires OPENROUTER_API_KEY to be set)."""
+
+    if not os.getenv("OPENROUTER_API_KEY"):
+        print("Note: Set OPENROUTER_API_KEY environment variable to run live queries")
+        print("These examples show the structure without making actual API calls")
+        print()
+
+    # Uncomment to run examples (requires API key)
+    # example_automatic_selection()
+    # example_manual_override()
+    # example_batch_queries()
+    # example_scientific_writing_workflow()
+
+    # Show complexity assessment without API calls
+    print("=" * 80)
+    print("COMPLEXITY ASSESSMENT EXAMPLES (No API calls required)")
+    print("=" * 80)
+    print()
+
+    os.environ.setdefault("OPENROUTER_API_KEY", "test")
+    research = ResearchLookup()
+
+    test_queries = [
+        ("Recent CRISPR studies", "pro"),
+        ("Compare CRISPR vs TALENs", "reasoning"),
+        ("Explain how CRISPR works", "reasoning"),
+        ("Western blot protocol", "pro"),
+        ("Pros and cons of different sequencing methods", "reasoning"),
+    ]
+
+    for query, expected in test_queries:
+        complexity = research._assess_query_complexity(query)
+        model_name = "Sonar Reasoning Pro" if complexity == "reasoning" else "Sonar Pro Search"
+        status = "✓" if complexity == expected else "✗"
+        print(f"{status} '{query}'")
+        print(f"  → {model_name}")
+        print()
+
+
+if __name__ == "__main__":
+    main()

package/bin/skills/research-lookup/lookup.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""
+Research Lookup Tool for Claude Code
+Performs research queries using Perplexity Sonar Pro Search via OpenRouter.
+"""
+
+import os
+import sys
+from typing import Dict, Optional
+
+
+# Import the main research lookup class
+sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'scripts'))
+from research_lookup import ResearchLookup
+
+
+def format_response(result: Dict) -> str:
+    """Format the research result for display."""
+    if not result["success"]:
+        return f"❌ Research lookup failed: {result['error']}"
+
+    response = result["response"]
+    citations = result["citations"]
+    sources = result.get("sources", [])
+
+    # Format the output for Claude Code
+    output = f"""🔍 **Research Results**
+
+**Query:** {result['query']}
+**Model:** {result['model']}
+**Timestamp:** {result['timestamp']}
+**Note:** Results prioritized by citation count, venue prestige, and author reputation
+
+---
+
+{response}
+
+"""
+
+    # Display API-provided sources with venue/citation info
+    if sources:
+        output += f"\n📚 **Sources ({len(sources)}):**\n"
+        output += "_Prioritized by venue quality and citation impact_\n\n"
+        for i, source in enumerate(sources, 1):
+            title = source.get("title", "Untitled")
+            url = source.get("url", "")
+            date = source.get("date", "")
+            snippet = source.get("snippet", "")
+
+            # Format source entry with available metadata
+            date_str = f" ({date})" if date else ""
+            output += f"{i}. **{title}**{date_str}\n"
+
+            # Add venue indicator if detectable from URL
+            venue_indicator = _detect_venue_tier(url)
+            if venue_indicator:
+                output += f"   📊 Venue: {venue_indicator}\n"
+
+            if url:
+                output += f"   🔗 {url}\n"
+            if snippet:
+                output += f"   _{snippet[:150]}{'...' if len(snippet) > 150 else ''}_\n"
+            output += "\n"
+
+    # Display extracted citations (DOIs, etc.)
+    if citations:
+        doi_citations = [c for c in citations if c.get("type") == "doi"]
+        url_citations = [c for c in citations if c.get("type") == "url"]
+
+        if doi_citations:
+            output += f"\n🔗 **DOI References ({len(doi_citations)}):**\n"
+            for i, citation in enumerate(doi_citations, 1):
+                output += f"{i}. DOI: {citation.get('doi', '')} → {citation.get('url', '')}\n"
+
+        if url_citations:
+            output += f"\n🌐 **Additional URLs ({len(url_citations)}):**\n"
+            for i, citation in enumerate(url_citations, 1):
+                url = citation.get('url', '')
+                venue = _detect_venue_tier(url)
+                venue_str = f" [{venue}]" if venue else ""
+                output += f"{i}. {url}{venue_str}\n"
+
+    if result.get("usage"):
+        usage = result["usage"]
+        output += f"\n**Usage:** {usage.get('total_tokens', 'N/A')} tokens"
+
+    return output
+
+
+def _detect_venue_tier(url: str) -> Optional[str]:
+    """Detect venue tier from URL to indicate source quality."""
+    if not url:
+        return None
+
+    url_lower = url.lower()
+
+    # Tier 1 - Premier venues
+    tier1_indicators = {
+        "nature.com": "Nature (Tier 1)",
+        "science.org": "Science (Tier 1)",
+        "cell.com": "Cell Press (Tier 1)",
+        "nejm.org": "NEJM (Tier 1)",
+        "thelancet.com": "Lancet (Tier 1)",
+        "jamanetwork.com": "JAMA (Tier 1)",
+        "pnas.org": "PNAS (Tier 1)",
+    }
+
+    # Tier 2 - High-impact specialized
+    tier2_indicators = {
+        "neurips.cc": "NeurIPS (Tier 2 - Top ML)",
+        "icml.cc": "ICML (Tier 2 - Top ML)",
+        "openreview.net": "Top ML Conference (Tier 2)",
+        "aacrjournals.org": "AACR Journals (Tier 2)",
+        "ahajournals.org": "AHA Journals (Tier 2)",
+        "bloodjournal.org": "Blood (Tier 2)",
+        "jci.org": "JCI (Tier 2)",
+    }
+
+    # Tier 3 - Respected academic sources
+    tier3_indicators = {
+        "springer.com": "Springer",
+        "wiley.com": "Wiley",
+        "elsevier.com": "Elsevier",
+        "oup.com": "Oxford University Press",
+        "arxiv.org": "arXiv (Preprint)",
+        "biorxiv.org": "bioRxiv (Preprint)",
+        "medrxiv.org": "medRxiv (Preprint)",
+        "pubmed": "PubMed",
+        "ncbi.nlm.nih.gov": "NCBI/PubMed",
+        "ieee.org": "IEEE",
+        "acm.org": "ACM",
+    }
+
+    for domain, label in tier1_indicators.items():
+        if domain in url_lower:
+            return label
+
+    for domain, label in tier2_indicators.items():
+        if domain in url_lower:
+            return label
+
+    for domain, label in tier3_indicators.items():
+        if domain in url_lower:
+            return label
+
+    return None
+
+
+def main():
+    """Main entry point for Claude Code tool."""
+    # Check for API key
+    if not os.getenv("OPENROUTER_API_KEY"):
+        print("❌ Error: OPENROUTER_API_KEY environment variable not set")
+        print("Please set it in your .env file or export it:")
+        print("  export OPENROUTER_API_KEY='your_openrouter_api_key'")
+        return 1
+
+    # Get query from command line arguments
+    if len(sys.argv) < 2:
+        print("❌ Error: No query provided")
+        print("Usage: python lookup.py 'your research query here'")
+        return 1
+
+    query = " ".join(sys.argv[1:])
+
+    try:
+        # Initialize research tool
+        research = ResearchLookup()
+
+        # Perform lookup
+        print(f"🔍 Researching: {query}")
+        result = research.lookup(query)
+
+        # Format and output result
+        formatted_output = format_response(result)
+        print(formatted_output)
+
+        # Return success code
+        return 0 if result["success"] else 1
+
+    except Exception as e:
+        print(f"❌ Error: {str(e)}")
+        return 1
+
+
+if __name__ == "__main__":
+    exit(main())