crossref-local 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

crossref_local/cli.py

@@ -6,10 +6,11 @@ import re
 import sys
 from typing import Optional
 
-from . import search, get, count, info, __version__
+from rich.console import Console
 
+from . import search, get, info, __version__
 
-from .impact_factor import ImpactFactorCalculator
+console = Console()
 
 
 def _strip_xml_tags(text: str) -> str:
@@ -32,12 +33,14 @@ class AliasedGroup(click.Group):
 
     def command(self, *args, aliases=None, **kwargs):
         """Decorator that registers aliases for commands."""
+
         def decorator(f):
             cmd = super(AliasedGroup, self).command(*args, **kwargs)(f)
             if aliases:
                 for alias in aliases:
                     self._aliases[alias] = cmd.name
             return cmd
+
         return decorator
 
     def get_command(self, ctx, cmd_name):
@@ -71,22 +74,118 @@ class AliasedGroup(click.Group):
 CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
 
 
-@click.group(cls=AliasedGroup, context_settings=CONTEXT_SETTINGS)
-@click.version_option(version=__version__, prog_name="crossref-local")
-def cli():
-    """Local CrossRef database with 167M+ works and full-text search."""
-    pass
+def _print_recursive_help(ctx, param, value):
+    """Callback for --help-recursive flag."""
+    if not value or ctx.resilient_parsing:
+        return
+
+    def _print_command_help(cmd, prefix: str, parent_ctx):
+        """Recursively print help for a command and its subcommands."""
+        console.print(f"\n[bold cyan]━━━ {prefix} ━━━[/bold cyan]")
+        sub_ctx = click.Context(cmd, info_name=prefix.split()[-1], parent=parent_ctx)
+        console.print(cmd.get_help(sub_ctx))
+
+        if isinstance(cmd, click.Group):
+            for sub_name, sub_cmd in sorted(cmd.commands.items()):
+                _print_command_help(sub_cmd, f"{prefix} {sub_name}", sub_ctx)
+
+    # Print main help
+    console.print("[bold cyan]━━━ crossref-local ━━━[/bold cyan]")
+    console.print(ctx.get_help())
 
+    # Print all subcommands recursively
+    for name, cmd in sorted(cli.commands.items()):
+        _print_command_help(cmd, f"crossref-local {name}", ctx)
 
-@cli.command(aliases=["s"], context_settings=CONTEXT_SETTINGS)
+    ctx.exit(0)
+
+
+@click.group(cls=AliasedGroup, context_settings=CONTEXT_SETTINGS)
+@click.version_option(version=__version__, prog_name="crossref-local")
+@click.option("--http", is_flag=True, help="Use HTTP API instead of direct database")
+@click.option(
+    "--api-url",
+    envvar="CROSSREF_LOCAL_API_URL",
+    help="API URL for http mode (default: auto-detect)",
+)
+@click.option(
+    "--help-recursive",
+    is_flag=True,
+    is_eager=True,
+    expose_value=False,
+    callback=_print_recursive_help,
+    help="Show help for all commands recursively.",
+)
+@click.pass_context
+def cli(ctx, http: bool, api_url: str):
+    """Local CrossRef database with 167M+ works and full-text search.
+
+    Supports both direct database access (db mode) and HTTP API (http mode).
+
+    \b
+    DB mode (default if database found):
+      crossref-local search "machine learning"
+
+    \b
+    HTTP mode (connect to API server):
+      crossref-local --http search "machine learning"
+    """
+    from .config import Config
+
+    ctx.ensure_object(dict)
+
+    if api_url:
+        Config.set_api_url(api_url)
+    elif http:
+        Config.set_mode("http")
+
+
+def _get_if_fast(db, issn: str, cache: dict) -> Optional[float]:
+    """Fast IF lookup from pre-computed OpenAlex data."""
+    if issn in cache:
+        return cache[issn]
+    row = db.fetchone(
+        "SELECT two_year_mean_citedness FROM journals_openalex WHERE issns LIKE ?",
+        (f"%{issn}%",),
+    )
+    cache[issn] = row["two_year_mean_citedness"] if row else None
+    return cache[issn]
+
+
+@cli.command("search", context_settings=CONTEXT_SETTINGS)
 @click.argument("query")
-@click.option("-n", "--limit", default=10, help="Number of results")
+@click.option(
+    "-n", "--number", "limit", default=10, show_default=True, help="Number of results"
+)
 @click.option("-o", "--offset", default=0, help="Skip first N results")
-@click.option("-a", "--with-abstracts", is_flag=True, help="Show abstracts")
+@click.option("-a", "--abstracts", is_flag=True, help="Show abstracts")
+@click.option("-A", "--authors", is_flag=True, help="Show authors")
+@click.option(
+    "-if", "--impact-factor", "with_if", is_flag=True, help="Show journal impact factor"
+)
 @click.option("--json", "as_json", is_flag=True, help="Output as JSON")
-def search_cmd(query: str, limit: int, offset: int, with_abstracts: bool, as_json: bool):
+def search_cmd(
+    query: str,
+    limit: int,
+    offset: int,
+    abstracts: bool,
+    authors: bool,
+    with_if: bool,
+    as_json: bool,
+):
     """Search for works by title, abstract, or authors."""
-    results = search(query, limit=limit, offset=offset)
+    from .db import get_db
+
+    try:
+        results = search(query, limit=limit, offset=offset)
+    except ConnectionError as e:
+        click.echo(f"Error: {e}", err=True)
+        click.echo("\nRun 'crossref-local status' to check configuration.", err=True)
+        sys.exit(1)
+
+    # Cache for fast IF lookups
+    if_cache = {}
+    db = get_db() if with_if else None
 
     if as_json:
         output = {
@@ -103,9 +202,20 @@ def search_cmd(query: str, limit: int, offset: int, with_abstracts: bool, as_jso
             year = f"({work.year})" if work.year else ""
             click.echo(f"{i}. {title} {year}")
             click.echo(f"   DOI: {work.doi}")
+            if authors and work.authors:
+                authors_str = ", ".join(work.authors[:5])
+                if len(work.authors) > 5:
+                    authors_str += f" et al. ({len(work.authors)} total)"
+                click.echo(f"   Authors: {authors_str}")
             if work.journal:
-                click.echo(f"   Journal: {work.journal}")
-            if with_abstracts and work.abstract:
+                journal_line = f"   Journal: {work.journal}"
+                # Fast IF lookup from pre-computed table
+                if with_if and work.issn:
+                    impact_factor = _get_if_fast(db, work.issn, if_cache)
+                    if impact_factor is not None:
+                        journal_line += f" (IF: {impact_factor:.2f}, OpenAlex)"
+                click.echo(journal_line)
+            if abstracts and work.abstract:
                 # Strip XML tags and truncate
                 abstract = _strip_xml_tags(work.abstract)
                 if len(abstract) > 500:
@@ -114,13 +224,18 @@ def search_cmd(query: str, limit: int, offset: int, with_abstracts: bool, as_jso
             click.echo()
 
 
-@cli.command("get", aliases=["g"], context_settings=CONTEXT_SETTINGS)
+@cli.command("search-by-doi", context_settings=CONTEXT_SETTINGS)
 @click.argument("doi")
 @click.option("--json", "as_json", is_flag=True, help="Output as JSON")
 @click.option("--citation", is_flag=True, help="Output as citation")
-def get_cmd(doi: str, as_json: bool, citation: bool):
-    """Get a work by DOI."""
-    work = get(doi)
+def search_by_doi_cmd(doi: str, as_json: bool, citation: bool):
+    """Search for a work by DOI."""
+    try:
+        work = get(doi)
+    except ConnectionError as e:
+        click.echo(f"Error: {e}", err=True)
+        click.echo("\nRun 'crossref-local status' to check configuration.", err=True)
+        sys.exit(1)
 
     if work is None:
         click.echo(f"DOI not found: {doi}", err=True)
@@ -140,81 +255,65 @@ def get_cmd(doi: str, as_json: bool, citation: bool):
             click.echo(f"Citations: {work.citation_count}")
 
 
-@cli.command(aliases=["c"], context_settings=CONTEXT_SETTINGS)
-@click.argument("query")
-def count_cmd(query: str):
-    """Count matching works."""
-    n = count(query)
-    click.echo(f"{n:,}")
-
-
-@cli.command(aliases=["i"], context_settings=CONTEXT_SETTINGS)
-@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
-def info_cmd(as_json: bool):
-    """Show database information."""
-    db_info = info()
-
-    if as_json:
-        click.echo(json.dumps(db_info, indent=2))
-    else:
-        click.echo("CrossRef Local Database")
-        click.echo("-" * 40)
-        click.echo(f"Database: {db_info['db_path']}")
-        click.echo(f"Works: {db_info['works']:,}")
-        click.echo(f"FTS indexed: {db_info['fts_indexed']:,}")
-        click.echo(f"Citations: {db_info['citations']:,}")
-
-
-@cli.command("impact-factor", aliases=["if"], context_settings=CONTEXT_SETTINGS)
-@click.argument("journal")
-@click.option("-y", "--year", default=2023, help="Target year")
-@click.option("-w", "--window", default=2, help="Citation window years")
-@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
-def impact_factor_cmd(journal: str, year: int, window: int, as_json: bool):
-    """Calculate impact factor for a journal."""
-    with ImpactFactorCalculator() as calc:
-        result = calc.calculate_impact_factor(
-            journal_identifier=journal,
-            target_year=year,
-            window_years=window,
-        )
-
-    if as_json:
-        click.echo(json.dumps(result, indent=2))
-    else:
-        click.echo(f"Journal: {result['journal']}")
-        click.echo(f"Year: {result['target_year']}")
-        click.echo(f"Window: {result['window_range']}")
-        click.echo(f"Articles: {result['total_articles']:,}")
-        click.echo(f"Citations: {result['total_citations']:,}")
-        click.echo(f"Impact Factor: {result['impact_factor']:.3f}")
-
-
 @cli.command(context_settings=CONTEXT_SETTINGS)
-def setup():
-    """Check setup status and configuration."""
-    from .config import Config, DEFAULT_DB_PATHS
+def status():
+    """Show status and configuration."""
+    from .config import DEFAULT_DB_PATHS, DEFAULT_API_URLS
     import os
 
-    click.echo("CrossRef Local - Setup Status")
+    click.echo("CrossRef Local - Status")
     click.echo("=" * 50)
     click.echo()
 
-    # Check environment variable
-    env_db = os.environ.get("CROSSREF_LOCAL_DB")
-    if env_db:
-        click.echo(f"CROSSREF_LOCAL_DB: {env_db}")
-        if os.path.exists(env_db):
-            click.echo("  Status: OK")
+    # Check environment variables
+    click.echo("Environment Variables:")
+    click.echo()
+
+    env_vars = [
+        (
+            "CROSSREF_LOCAL_DB",
+            "Path to SQLite database file",
+            os.environ.get("CROSSREF_LOCAL_DB"),
+        ),
+        (
+            "CROSSREF_LOCAL_API_URL",
+            "HTTP API URL (e.g., http://localhost:8333)",
+            os.environ.get("CROSSREF_LOCAL_API_URL"),
+        ),
+        (
+            "CROSSREF_LOCAL_MODE",
+            "Force mode: 'db', 'http', or 'auto'",
+            os.environ.get("CROSSREF_LOCAL_MODE"),
+        ),
+        (
+            "CROSSREF_LOCAL_HOST",
+            "Host for run-server-http (default: 0.0.0.0)",
+            os.environ.get("CROSSREF_LOCAL_HOST"),
+        ),
+        (
+            "CROSSREF_LOCAL_PORT",
+            "Port for run-server-http (default: 8333)",
+            os.environ.get("CROSSREF_LOCAL_PORT"),
+        ),
+    ]
+
+    for var_name, description, value in env_vars:
+        if value:
+            if var_name == "CROSSREF_LOCAL_DB":
+                status = " (OK)" if os.path.exists(value) else " (NOT FOUND)"
+            else:
+                status = ""
+            click.echo(f"  {var_name}={value}{status}")
+            click.echo(f"      | {description}")
         else:
-            click.echo("  Status: NOT FOUND")
-    else:
-        click.echo("CROSSREF_LOCAL_DB: (not set)")
+            click.echo(f"  {var_name} (not set)")
+            click.echo(f"      | {description}")
+        click.echo()
 
     click.echo()
 
-    # Check default paths
-    click.echo("Checking default database locations:")
+    # Check default database paths
+    click.echo("Local Database Locations:")
     db_found = None
     for path in DEFAULT_DB_PATHS:
         if path.exists():
@@ -226,26 +325,188 @@ def setup():
 
     click.echo()
 
-    if db_found:
-        click.echo(f"Database found: {db_found}")
-        click.echo()
+    # Check API servers
+    click.echo("API Servers:")
+    api_found = None
+    api_compatible = False
+    for url in DEFAULT_API_URLS:
+        try:
+            import urllib.request
+            import json as json_module
+
+            # Check root endpoint for version
+            req = urllib.request.Request(f"{url}/", method="GET")
+            req.add_header("Accept", "application/json")
+            with urllib.request.urlopen(req, timeout=3) as resp:
+                if resp.status == 200:
+                    data = json_module.loads(resp.read().decode())
+                    server_version = data.get("version", "unknown")
+
+                    # Check version compatibility
+                    if server_version == __version__:
+                        click.echo(f"  [OK] {url} (v{server_version})")
+                        api_compatible = True
+                    else:
+                        click.echo(
+                            f"  [WARN] {url} (v{server_version} != v{__version__})"
+                        )
+                        click.echo(
+                            f"         Server version mismatch - may be incompatible"
+                        )
+
+                    if api_found is None:
+                        api_found = url
+                else:
+                    click.echo(f"  [ ] {url}")
+        except Exception:
+            click.echo(f"  [ ] {url}")
 
+    click.echo()
+
+    # Summary and recommendations
+    if db_found:
+        click.echo(f"Local database: {db_found}")
         try:
             db_info = info()
-            click.echo(f"  Works: {db_info['works']:,}")
-            click.echo(f"  FTS indexed: {db_info['fts_indexed']:,}")
-            click.echo(f"  Citations: {db_info['citations']:,}")
-            click.echo()
-            click.echo("Setup complete! Try:")
-            click.echo('  crossref-local search "machine learning"')
+            click.echo(f"  Works: {db_info.get('works', 0):,}")
+            click.echo(f"  FTS indexed: {db_info.get('fts_indexed', 0):,}")
         except Exception as e:
-            click.echo(f"  Error reading database: {e}", err=True)
+            click.echo(f"  Error: {e}", err=True)
+        click.echo()
+        click.echo("Ready! Try:")
+        click.echo('  crossref-local search "machine learning"')
+    elif api_found:
+        click.echo(f"HTTP API available: {api_found}")
+        click.echo()
+        click.echo("Ready! Try:")
+        click.echo('  crossref-local --http search "machine learning"')
+        click.echo()
+        click.echo("Or set environment:")
+        click.echo("  export CROSSREF_LOCAL_MODE=http")
     else:
-        click.echo("No database found!")
+        click.echo("No database or API server found!")
         click.echo()
-        click.echo("To set up:")
-        click.echo("  export CROSSREF_LOCAL_DB=/path/to/crossref.db")
-        click.echo("  See: make db-build-info")
+        click.echo("Options:")
+        click.echo("  1. Direct database access (db mode):")
+        click.echo("     export CROSSREF_LOCAL_DB=/path/to/crossref.db")
+        click.echo()
+        click.echo("  2. HTTP API (connect to server):")
+        click.echo("     crossref-local --http search 'query'")
+
+
+@cli.command("run-server-mcp", context_settings=CONTEXT_SETTINGS)
+@click.option(
+    "-t",
+    "--transport",
+    type=click.Choice(["stdio", "sse", "http"]),
+    default="stdio",
+    help="Transport protocol (http recommended for remote)",
+)
+@click.option(
+    "--host",
+    default="localhost",
+    envvar="CROSSREF_LOCAL_MCP_HOST",
+    help="Host for HTTP/SSE transport",
+)
+@click.option(
+    "--port",
+    default=8082,
+    type=int,
+    envvar="CROSSREF_LOCAL_MCP_PORT",
+    help="Port for HTTP/SSE transport",
+)
+def serve_mcp(transport: str, host: str, port: int):
+    """Run MCP (Model Context Protocol) server.
+
+    \b
+    Transports:
+      stdio  - Standard I/O (default, for Claude Desktop local)
+      http   - Streamable HTTP (recommended for remote/persistent)
+      sse    - Server-Sent Events (deprecated as of MCP spec 2025-03-26)
+
+    \b
+    Local configuration (stdio):
+      {
+        "mcpServers": {
+          "crossref": {
+            "command": "crossref-local",
+            "args": ["run-server-mcp"]
+          }
+        }
+      }
+
+    \b
+    Remote configuration (http):
+      # Start server:
+      crossref-local run-server-mcp -t http --host 0.0.0.0 --port 8082
+
+      # Client config:
+      {
+        "mcpServers": {
+          "crossref-remote": {
+            "url": "http://your-server:8082/mcp"
+          }
+        }
+      }
+
+    \b
+    See docs/remote-deployment.md for systemd and Docker setup.
+    """
+    try:
+        from .mcp_server import run_server
+    except ImportError:
+        click.echo(
+            "MCP server requires fastmcp. Install with:\n"
+            "  pip install crossref-local[mcp]",
+            err=True,
+        )
+        sys.exit(1)
+
+    run_server(transport=transport, host=host, port=port)
+
+
+@cli.command("run-server-http", context_settings=CONTEXT_SETTINGS)
+@click.option(
+    "--host", default="0.0.0.0", envvar="CROSSREF_LOCAL_HOST", help="Host to bind"
+)
+@click.option(
+    "--port",
+    default=8333,
+    type=int,
+    envvar="CROSSREF_LOCAL_PORT",
+    help="Port to listen on",
+)
+def serve_http(host: str, port: int):
+    """Run HTTP API server.
+
+    \b
+    This runs a FastAPI server that provides proper full-text search
+    using FTS5 index across all 167M+ papers.
+
+    \b
+    Example:
+      crossref-local run-server-http                  # Run on 0.0.0.0:8333
+      crossref-local run-server-http --port 8080      # Custom port
+
+    \b
+    Then connect with http mode:
+      crossref-local --http search "CRISPR"
+      curl "http://localhost:8333/works?q=CRISPR&limit=10"
+    """
+    try:
+        from .server import run_server
+    except ImportError:
+        click.echo(
+            "API server requires fastapi and uvicorn. Install with:\n"
+            "  pip install fastapi uvicorn",
+            err=True,
+        )
+        sys.exit(1)
+
+    click.echo(f"Starting CrossRef Local API server on {host}:{port}")
+    click.echo(f"Search endpoint: http://{host}:{port}/search?q=<query>")
+    click.echo(f"Docs: http://{host}:{port}/docs")
+    run_server(host=host, port=port)
 
 
 def main():