ipfs_datasets_cli.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
IPFS Datasets CLI Tool

A lightweight command line interface that provides convenient access to the MCP tools
with minimal imports. Only loads what's needed when needed.
"""

import sys
import os
import subprocess
import json
from pathlib import Path

# Install CLI error handler early
try:
    from ipfs_datasets_py.error_reporting.cli_error_reporter import install_cli_error_handler
    install_cli_error_handler()
except ImportError:
    # Error reporting not available, continue without it
    pass


# ============================================================================
# Dynamic Tool Discovery and Execution (from enhanced_cli.py)
# ============================================================================

class DynamicToolRunner:
    """Dynamically discover and run MCP tools."""
    
    def __init__(self):
        self.tools_dir = Path(__file__).parent / "ipfs_datasets_py" / "mcp_server" / "tools"
        self.discovered_tools = {}
        self.discover_tools()
    
    def discover_tools(self):
        """Discover all available tools."""
        if not self.tools_dir.exists():
            return
        
        for category_dir in self.tools_dir.iterdir():
            if not category_dir.is_dir() or category_dir.name.startswith('_'):
                continue
            
            category_name = category_dir.name
            self.discovered_tools[category_name] = {}
            
            # Look for Python files in the category
            for tool_file in category_dir.glob("*.py"):
                if tool_file.name.startswith('_') or tool_file.name == "__init__.py":
                    continue
                
                tool_name = tool_file.stem
                module_path = f"ipfs_datasets_py.mcp_server.tools.{category_name}.{tool_name}"
                self.discovered_tools[category_name][tool_name] = module_path
    
    def get_categories(self):
        """Get list of available tool categories."""
        return sorted(self.discovered_tools.keys())
    
    def get_tools(self, category):
        """Get list of tools in a category."""
        return sorted(self.discovered_tools.get(category, {}).keys())
    
    def get_tool_count(self, category):
        """Get count of tools in a category."""
        return len(self.discovered_tools.get(category, {}))
    
    async def run_tool(self, category, tool, **kwargs):
        """Run a specific tool."""
        import importlib
        import inspect
        
        if category not in self.discovered_tools:
            return {"status": "error", "error": f"Category '{category}' not found"}
        
        if tool not in self.discovered_tools[category]:
            return {"status": "error", "error": f"Tool '{tool}' not found in category '{category}'"}
        
        module_path = self.discovered_tools[category][tool]
        
        try:
            # Import the module
            module = importlib.import_module(module_path)
            
            # Find callable functions in the module.
            functions = []
            for name, obj in inspect.getmembers(module):
                if inspect.isfunction(obj) and not name.startswith('_'):
                    functions.append((name, obj))
            
            if not functions:
                return {"status": "error", "error": f"No callable functions found in {module_path}"}
            
            # Resolve deterministically: exact match first, then <tool>_tool.
            functions_by_name = {name: fn for name, fn in functions}
            target_name = None
            if tool in functions_by_name:
                target_name = tool
            elif f"{tool}_tool" in functions_by_name:
                target_name = f"{tool}_tool"
            elif len(functions) == 1:
                # Backward-compatible fallback for single-function modules only.
                target_name = functions[0][0]
            else:
                available = sorted(functions_by_name.keys())
                return {
                    "status": "error",
                    "error": (
                        f"Ambiguous callable selection for tool '{tool}' in {module_path}. "
                        f"Available callables: {available}. "
                        "Expected an exact callable named '<tool>' or '<tool>_tool'."
                    ),
                }

            target_function = functions_by_name[target_name]
            
            # Get function signature
            sig = inspect.signature(target_function)
            
            # Validate kwargs before invocation to avoid silent argument drops.
            supports_var_kwargs = any(
                p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values()
            )

            if supports_var_kwargs:
                filtered_kwargs = dict(kwargs)
            else:
                allowed = {
                    name
                    for name, p in sig.parameters.items()
                    if p.kind in (
                        inspect.Parameter.POSITIONAL_OR_KEYWORD,
                        inspect.Parameter.KEYWORD_ONLY,
                    )
                }
                unknown = sorted(set(kwargs.keys()) - allowed)
                if unknown:
                    return {
                        "status": "error",
                        "error": (
                            f"Unexpected arguments for callable '{target_name}': {unknown}. "
                            f"Allowed arguments: {sorted(allowed)}"
                        ),
                    }
                filtered_kwargs = {k: v for k, v in kwargs.items() if k in allowed}

            missing_required = []
            for name, p in sig.parameters.items():
                if p.kind not in (
                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
                    inspect.Parameter.KEYWORD_ONLY,
                ):
                    continue
                if p.default is inspect.Parameter.empty and name not in filtered_kwargs:
                    missing_required.append(name)
            if missing_required:
                return {
                    "status": "error",
                    "error": (
                        f"Missing required arguments for callable '{target_name}': "
                        f"{sorted(missing_required)}"
                    ),
                }
            
            # Call the function
            import asyncio
            if asyncio.iscoroutinefunction(target_function):
                result = await target_function(**filtered_kwargs)
            else:
                result = target_function(**filtered_kwargs)
            
            # Ensure result is a dict
            if not isinstance(result, dict):
                result = {"status": "success", "result": str(result)}
            
            return result
            
        except ImportError as e:
            return {"status": "error", "error": f"Failed to import {module_path}: {e}"}
        except Exception as e:
            return {"status": "error", "error": f"Failed to run tool: {e}"}


def print_result(result, format_type="pretty"):
    """Print results in a user-friendly format."""
    if format_type == "json":
        print(json.dumps(result, indent=2))
        return
    
    if result.get("status") == "success":
        print("✅ Success!")
        if "message" in result:
            print(f"Message: {result['message']}")
        if "dataset_id" in result:
            print(f"Dataset ID: {result['dataset_id']}")
        if "summary" in result:
            summary = result["summary"]
            if isinstance(summary, dict):
                print("Summary:")
                for key, value in summary.items():
                    print(f"  {key}: {value}")
            else:
                print(f"Summary: {summary}")
        if "result" in result and result["result"] != result.get("message"):
            print(f"Result: {result['result']}")
    else:
        print("❌ Error!")
        if "error" in result:
            print(f"Error: {result['error']}")
        if "message" in result:
            print(f"Message: {result['message']}")


def parse_tool_args(args_list):
    """Parse tool arguments from command line."""
    kwargs = {}
    i = 0
    while i < len(args_list):
        arg = args_list[i]
        if arg.startswith('--'):
            key = arg[2:]  # Remove --
            if i + 1 < len(args_list) and not args_list[i + 1].startswith('--'):
                value = args_list[i + 1]
                # Try to parse as JSON, otherwise keep as string
                try:
                    kwargs[key] = json.loads(value)
                except json.JSONDecodeError:
                    kwargs[key] = value
                i += 2
            else:
                # Boolean flag
                kwargs[key] = True
                i += 1
        else:
            i += 1
    return kwargs


# ============================================================================
# Original CLI Functions
# ============================================================================

def show_help():
    """Show CLI help without importing anything heavy."""
    help_text = """
ipfs-datasets-cli - IPFS Datasets CLI Tool

Usage:
    ipfs-datasets [command] [subcommand] [options]
    ipfs-datasets --help
    ipfs-datasets --version

Commands:
    info         System information
      status     Show system status
      version    Show version information
            defaults   Show resolved host/port/gateway defaults
    save-defaults  Persist host/port/gateway to config
      
    mcp          MCP server management  
      start      Start MCP server
      stop       Stop MCP server
      status     Show MCP server status
            logs       Tail MCP dashboard logs
      
    tools        Tool management
      categories List available tool categories (all discovered tools)
      list       List tools in a category
      execute    Execute a specific tool
      run        Run a tool directly: tools run <category> <tool> [--arg value ...]
      
    vscode       VSCode CLI management
      status     Show VSCode CLI installation status
      install    Install or update VSCode CLI
      auth       Configure authentication (GitHub/Microsoft)
      install-with-auth  Install and authenticate in one step
      execute    Execute VSCode CLI command
      extensions List, install, or uninstall extensions
      tunnel     Manage VSCode tunnel functionality
      
    github       GitHub CLI management
      status     Show GitHub CLI installation status
      install    Install or update GitHub CLI
      auth       Manage GitHub authentication
      execute    Execute GitHub CLI command

    legal-pdf    Legal PDF rendering helpers
      render     Render state-court filings and exhibit binder components
      merge      Merge PDF bundles and count pages
      
    copilot      GitHub Copilot CLI management
      status     Show Copilot CLI installation status
      install    Install or update Copilot CLI extension
      explain    Get AI explanation for code
      suggest    Get command suggestions from natural language
      git        Get Git command suggestions
      
    gemini       Google Gemini CLI management
      status     Show Gemini CLI installation status
      install    Install Gemini CLI
      config     Configure API key and settings
      execute    Execute Gemini CLI command
      
    claude       Anthropic Claude CLI management
      status     Show Claude CLI installation status
      install    Install Claude CLI
      config     Configure API key and settings
      execute    Execute Claude CLI command
      
    p2p          P2P workflow scheduling (bypass GitHub API)
      init       Initialize P2P scheduler
      schedule   Schedule a workflow for P2P execution
      next       Get next workflow from queue
      status     Get scheduler status
      add-peer   Add a peer to the network
      remove-peer Remove a peer from the network
      tags       List available workflow tags
      
    dataset      Dataset operations
      load       Load a dataset
      convert    Convert dataset format
      
        ipfs         IPFS operations
            pin        Pin data to IPFS
            get        Get data from IPFS (supports --gateway)
      
    vector       Vector operations
      create     Create vector embeddings
      search     Search vectors
      
    graph        Knowledge graph operations
      create     Initialize a knowledge graph database
      add-entity Add an entity to the graph
      add-rel    Add a relationship between entities
      query      Execute a Cypher query
      search     Hybrid search (semantic + keyword)
      tx-begin   Begin a transaction
      tx-commit  Commit a transaction
      tx-rollback Rollback a transaction
      index      Create an index
      constraint Add a constraint

        legal        Legal dataset shortcuts
            search-court-rules  Search federal/state court rules via legal dataset tools
            search-federal-register Search Federal Register corpus via legal dataset tools
            scrape-netherlands-laws Scrape Netherlands laws from official Dutch government sources
      
    finance      Financial analysis and data pipelines
      stock      Fetch stock market data
      news       Scrape financial news (AP, Reuters, Bloomberg)
      executives Analyze executive performance (hypothesis testing)
      embeddings Multimodal embedding analysis (text + images)
      theorems   List or apply financial theorems
      workflow   Execute end-to-end workflow pipelines
    
    discord      Discord data export and analysis
      guilds     List accessible Discord servers
      channels   List channels in a server
      dms        List direct message channels
      export     Export a Discord channel
      export-guild Export entire Discord server
      export-dms Export all direct messages (native exportdm)
      export-all Export all accessible content
      analyze    Analyze a Discord channel
      analyze-export Analyze exported Discord data
      status     Check Discord integration status
      install    Install DiscordChatExporter
    
    email        Email ingestion and analysis
      test       Test email server connection
      folders    List IMAP mailbox folders
      export     Export emails from a folder
      parse      Parse an .eml file
      fetch      Fetch emails (no export)
      analyze    Analyze an email export file
      search     Search emails in an export file
      google-voice Parse Google Voice Takeout exports
      google-voice-vault Parse Google Workspace Vault Voice exports
      google-voice-data-export Parse Google Workspace Data Export Voice bundles and gs:// sources
      google-voice-watch Watch a local folder and auto-hydrate Voice exports
      google-voice-takeout-url Build a custom consumer Google Takeout URL for Voice exports
      google-voice-takeout-open Open the custom Takeout URL in Playwright
      google-voice-takeout-capture Open the custom Takeout URL and wait for an archive download
      google-voice-takeout-source Save Takeout page source HTML for data-id inference
      google-voice-takeout-poll Poll a local download directory for a completed Takeout archive
      google-voice-takeout-drive Poll Google Drive for a Takeout artifact and optionally download it
      google-voice-takeout-status Summarize a saved Takeout acquisition manifest
      google-voice-takeout-doctor Diagnose a saved Takeout acquisition manifest and suggest the next step
      google-voice-takeout-history List archived snapshot history for a Takeout acquisition manifest
      google-voice-takeout-prune Prune old archived snapshot history for a Takeout acquisition manifest
      google-voice-takeout-case-summary Show a concise summary for a Takeout case/download directory or manifest
      google-voice-takeout-case-report Export a markdown or HTML report for a Takeout case/download directory or manifest
      google-voice-takeout-case-bundle Collect the latest manifest, history snapshots, and case reports into one archival folder

        workspace    Inspect, search, export, and package workspace dataset bundles
            --action summary            Read a lightweight workspace bundle summary
            --action inspect            Read bundle sections and artifact counts
            --action load               Load the full dataset-shaped bundle payload
            --action report             Render a human-readable markdown/text bundle report
            --action search-bm25        Search a workspace bundle with grouped BM25 results
            --action search-vector      Search a workspace bundle with grouped vector results
            --action export             Export a workspace bundle from generic or source-specific inputs
            --action package            Package a workspace bundle into chain-loadable artifacts
            --action package-search-bm25 Search a packaged workspace bundle with grouped BM25 results
            --action package-search-vector Search a packaged workspace bundle with grouped vector results

    history-index Search persisted DuckDB history/GraphRAG index
    docket       Import a docket into a reusable dataset artifact
      chunks      Search chunk text and metadata
      documents   Search indexed documents
      entities    Search extracted entities
      relationships Search extracted relationships
    
    detect-type  File type detection for GraphRAG
      detect     Detect single file type
      batch      Batch detect multiple files
      methods    List available detection methods

Options:
    --help, -h   Show this help message
    --version    Show version information
    --json       Output in JSON format
    --verbose    Verbose output
    --config     Path to CLI config JSON (overrides default)
    --host, -H   Override dashboard host
    --port, -p   Override dashboard port
    --gateway, -g  Override IPFS HTTP gateway (ipfs get)
    
Environment:
    IPFS_DATASETS_HOST  Default dashboard host (e.g., 127.0.0.1)
    IPFS_DATASETS_PORT  Default dashboard port (e.g., 8899)
    IPFS_DATASETS_CLI_CONFIG  Path to CLI config JSON
    IPFS_HTTP_GATEWAY   Default IPFS gateway (e.g., https://ipfs.io)
    IPFS_DATASETS_IPFS_GATEWAY  Alternate env var for gateway

Config:
        ~/.ipfs_datasets/cli.json  Optional defaults for host/port, e.g.:
            {"host": "127.0.0.1", "port": "8899", "gateway": "https://ipfs.io"}
        Precedence: flags > env > config file > hardcoded defaults

Examples:
    ipfs-datasets info status
    ipfs-datasets info defaults --json
    ipfs-datasets ipfs get QmHash --gateway https://ipfs.io --out /tmp/file
    ipfs-datasets mcp start
    ipfs-datasets tools categories
    ipfs-datasets dataset load ./data.json
    ipfs-datasets graph create --driver-url ipfs://localhost:5001
    ipfs-datasets graph add-entity --id person1 --type Person --props '{"name":"Alice"}'
    ipfs-datasets graph query --cypher "MATCH (n) RETURN n LIMIT 10"
    ipfs-datasets legal search-court-rules --collection_name court_rules --query_vector "[0.1,0.2,0.3]" --jurisdiction both
    ipfs-datasets legal search-court-rules --collection_name court_rules --query_text "rules for filing motions" --jurisdiction federal
    ipfs-datasets legal search-federal-register --collection_name federal_register_docs --query_text "EPA emissions reporting rule"
    ipfs-datasets legal scrape-netherlands-laws --document_urls '["https://wetten.overheid.nl/BWBR0001854/"]'
    
For detailed help on a specific command:
    ipfs-datasets [command] --help
"""
    print(help_text.strip())


def show_version():
    """Show version without importing anything heavy."""
    print("ipfs-datasets CLI v1.0.0")


def show_status():
    """Show basic system status without heavy imports."""
    print("System Status: CLI tool is available")
    print("Version: 1.0.0")
    print("Python:", sys.version.split()[0])
    print("Path:", Path(__file__).parent)


def _load_cli_config(config_override: str | None = None) -> dict:
    """Load optional CLI config from ~/.ipfs_datasets/cli.json.
    Returns empty dict if not present or invalid.
    """
    try:
        if config_override:
            cfg_path = Path(config_override)
        else:
            env_cfg = os.environ.get("IPFS_DATASETS_CLI_CONFIG")
            cfg_path = Path(env_cfg) if env_cfg else (Path.home() / ".ipfs_datasets" / "cli.json")
        if not cfg_path.exists():
            return {}
        data = json.loads(cfg_path.read_text())
        if isinstance(data, dict):
            return data
    except Exception:
        pass
    return {}


def _default_host_port(config_override: str | None = None):
    """Resolve default host/port using precedence: env > config > hardcoded."""
    cfg = _load_cli_config(config_override)
    host = os.environ.get("IPFS_DATASETS_HOST") or cfg.get("host") or "127.0.0.1"
    port = os.environ.get("IPFS_DATASETS_PORT") or cfg.get("port") or "8899"
    return str(host), str(port)


def _default_gateway(config_override: str | None = None, override: str | None = None) -> str | None:
    """Resolve default IPFS HTTP gateway.
    Precedence: explicit override > env (IPFS_HTTP_GATEWAY or IPFS_DATASETS_IPFS_GATEWAY) > config > None.
    """
    if override:
        return override
    gw_env = os.environ.get("IPFS_HTTP_GATEWAY") or os.environ.get("IPFS_DATASETS_IPFS_GATEWAY")
    if gw_env:
        return gw_env
    cfg = _load_cli_config(config_override)
    if isinstance(cfg, dict):
        gw = cfg.get("gateway")
        if gw:
            return gw
    return None


def execute_heavy_command(args):
    """Execute commands that require heavy imports - only import when needed."""
    # Only import heavy modules when actually executing commands
    try:
        import anyio
        import json
        import importlib
        from typing import Any, Dict, List
        from pathlib import Path as PathLib
        
        # Setup sys path for imports
        current_dir = PathLib(__file__).parent  
        if str(current_dir) not in sys.path:
            sys.path.insert(0, str(current_dir))
        
        # Detect global JSON flag and strip it from args
        json_output = False
        if '--json' in args:
            json_output = True
            args = [a for a in args if a != '--json']

        # Heavy command execution logic here
        command = args[0] if args else None

        if command == "alerts":
            from ipfs_datasets_py.alerts.cli import main as alerts_main

            alerts_args = list(args[1:])
            if json_output:
                alerts_args = ["--json", *alerts_args]
            sys.exit(alerts_main(alerts_args))

        if command == "workflow-automation":
            from ipfs_datasets_py.workflow_automation.cli import main as wa_main

            wa_args = list(args[1:])
            if json_output:
                wa_args = ["--json", *wa_args]
            sys.exit(wa_main(wa_args))

        if command == "search":
            from ipfs_datasets_py.search.cli import main as search_main

            search_args = list(args[1:])
            if json_output:
                search_args = ["--json", *search_args]
            sys.exit(search_main(search_args))

        if command == "p2p-networking":
            from ipfs_datasets_py.p2p_networking.cli import main as p2p_net_main

            p2p_args = list(args[1:])
            if json_output:
                p2p_args = ["--json", *p2p_args]
            sys.exit(p2p_net_main(p2p_args))

        if command == "logic":
            from ipfs_datasets_py.logic.cli import main as logic_main

            logic_args = list(args[1:])
            if json_output:
                logic_args = ["--json", *logic_args]
            sys.exit(logic_main(logic_args))

        if command == "legal":
            subcommand = args[1] if len(args) > 1 else None
            if subcommand in ("search-court-rules", "court-rules-search", "search_court_rules"):
                tool_args = args[2:]
                parameters = parse_tool_args(tool_args)
                parameters = {str(k).replace("-", "_"): v for k, v in parameters.items()}

                if not parameters.get("collection_name"):
                    print("Usage: ipfs-datasets legal search-court-rules --collection_name NAME (--query_vector '[...]' | --query_text '...') [--jurisdiction federal|state|both] [--state OR]")
                    return

                if "query_vector" not in parameters:
                    query_text = str(parameters.get("query_text") or "").strip()
                    if not query_text:
                        print("Usage: ipfs-datasets legal search-court-rules --collection_name NAME (--query_vector '[...]' | --query_text '...') [--jurisdiction federal|state|both] [--state OR]")
                        return

                    try:
                        from ipfs_datasets_py.embeddings_router import embed_text

                        embedding_model = (
                            str(parameters.get("embedding_model") or parameters.get("model_name") or "").strip()
                            or "thenlper/gte-small"
                        )
                        embedding_provider = str(parameters.get("embedding_provider") or "").strip() or None
                        query_vector = embed_text(
                            query_text,
                            model_name=embedding_model,
                            provider=embedding_provider,
                        )
                        parameters["query_vector"] = query_vector
                    except Exception as e:
                        err = {
                            "status": "error",
                            "error": f"Failed to generate query embedding from query_text: {e}",
                        }
                        if json_output:
                            print(json.dumps(err))
                        else:
                            print(json.dumps(err, indent=2))
                        return

                if not parameters.get("jurisdiction"):
                    parameters["jurisdiction"] = "both"

                try:
                    from ipfs_datasets_py.processors.legal_scrapers.legal_dataset_api import (
                        search_court_rules_corpus_from_parameters,
                    )
                    result = anyio.run(search_court_rules_corpus_from_parameters, parameters)
                    if json_output:
                        print(json.dumps(result))
                    else:
                        print(json.dumps(result, indent=2))
                except Exception as e:
                    err = {"status": "error", "error": str(e)}
                    if json_output:
                        print(json.dumps(err))
                    else:
                        print(json.dumps(err, indent=2))
                return

            if subcommand in (
                "search-federal-register",
                "federal-register-search",
                "search_federal_register",
            ):
                tool_args = args[2:]
                parameters = parse_tool_args(tool_args)
                parameters = {str(k).replace("-", "_"): v for k, v in parameters.items()}

                if not parameters.get("collection_name"):
                    print(
                        "Usage: ipfs-datasets legal search-federal-register --collection_name NAME (--query_vector '[...]' | --query_text '...')"
                    )
                    return

                if "query_vector" not in parameters:
                    query_text = str(parameters.get("query_text") or "").strip()
                    if not query_text:
                        print(
                            "Usage: ipfs-datasets legal search-federal-register --collection_name NAME (--query_vector '[...]' | --query_text '...')"
                        )
                        return

                    try:
                        from ipfs_datasets_py.embeddings_router import embed_text

                        embedding_model = (
                            str(parameters.get("embedding_model") or parameters.get("model_name") or "").strip()
                            or "thenlper/gte-small"
                        )
                        embedding_provider = str(parameters.get("embedding_provider") or "").strip() or None
                        query_vector = embed_text(
                            query_text,
                            model_name=embedding_model,
                            provider=embedding_provider,
                        )
                        parameters["query_vector"] = query_vector
                    except Exception as e:
                        err = {
                            "status": "error",
                            "error": f"Failed to generate query embedding from query_text: {e}",
                        }
                        if json_output:
                            print(json.dumps(err))
                        else:
                            print(json.dumps(err, indent=2))
                        return

                try:
                    from ipfs_datasets_py.processors.legal_scrapers.legal_dataset_api import (
                        search_federal_register_corpus_from_parameters,
                    )

                    result = anyio.run(search_federal_register_corpus_from_parameters, parameters)
                    if json_output:
                        print(json.dumps(result))
                    else:
                        print(json.dumps(result, indent=2))
                except Exception as e:
                    err = {"status": "error", "error": str(e)}
                    if json_output:
                        print(json.dumps(err))
                    else:
                        print(json.dumps(err, indent=2))
                return

            if subcommand in (
                "scrape-netherlands-laws",
                "netherlands-laws-scrape",
                "scrape_netherlands_laws",
            ):
                tool_args = args[2:]
                parameters = parse_tool_args(tool_args)
                parameters = {str(k).replace("-", "_"): v for k, v in parameters.items()}

                if (
                    not parameters.get("document_urls")
                    and not parameters.get("seed_urls")
                    and not parameters.get("use_default_seeds")
                ):
                    print(
                        "Usage: ipfs-datasets legal scrape-netherlands-laws (--document_urls '[\"https://wetten.overheid.nl/BWBR...\"]' | --seed_urls '[\"https://wetten.overheid.nl/zoeken/zoekresultaat/...\" ]' | --use_default_seeds true) [--output_dir PATH] [--max_documents N] [--max_seed_pages N] [--crawl_depth N] [--rate_limit_delay SECONDS] [--skip_existing true]"
                    )
                    return

                try:
                    from ipfs_datasets_py.processors.legal_scrapers.legal_dataset_api import (
                        scrape_netherlands_laws_from_parameters,
                    )

                    result = anyio.run(scrape_netherlands_laws_from_parameters, parameters)
                    if json_output:
                        print(json.dumps(result))
                    else:
                        print(json.dumps(result, indent=2))
                except Exception as e:
                    err = {"status": "error", "error": str(e)}
                    if json_output:
                        print(json.dumps(err))
                    else:
                        print(json.dumps(err, indent=2))
                return

            print("Usage: ipfs-datasets legal search-court-rules --collection_name NAME (--query_vector '[...]' | --query_text '...') [--jurisdiction federal|state|both] [--state OR]")
            print("       ipfs-datasets legal search-federal-register --collection_name NAME (--query_vector '[...]' | --query_text '...')")
            print("       ipfs-datasets legal scrape-netherlands-laws (--document_urls '[\"https://wetten.overheid.nl/BWBR...\"]' | --seed_urls '[\"https://wetten.overheid.nl/zoeken/zoekresultaat/...\" ]' | --use_default_seeds true)")
            return
        
        if command == "tools":
            subcommand = args[1] if len(args) > 1 else None
            # parse global option --config first
            config_override = None
            if "--config" in args:
                try:
                    idx = args.index("--config")
                    if idx + 1 < len(args):
                        config_override = args[idx + 1]
                        args = args[:idx] + args[idx+2:]
                except Exception:
                    pass
            host, port = _default_host_port(config_override)
            
            # Handle enhanced "tools run" command
            if subcommand == "run":
                try:
                    import anyio
                    runner = DynamicToolRunner()
                    
                    # Parse: tools run <category> <tool> [--arg value ...]
                    if len(args) < 4:
                        print("Usage: ipfs-datasets tools run <category> <tool> [--arg value ...]")
                        print("\nExamples:")
                        print("  ipfs-datasets tools run dataset_tools load_dataset --source squad")
                        print("  ipfs-datasets tools run ipfs_tools get_from_ipfs --cid QmHash123")
                        print("  ipfs-datasets tools run vector_tools create_vector_index --data 'text'")
                        return
                    
                    category = args[2]
                    tool = args[3]
                    tool_args = args[4:]
                    
                    # Parse tool arguments
                    kwargs = parse_tool_args(tool_args)
                    
                    # Run the tool
                    result = anyio.run(runner.run_tool, category, tool, **kwargs)
                    
                    # Print result
                    print_result(result, "json" if json_output else "pretty")
                    return
                    
                except Exception as e:
                    print(f"Error running tool: {e}")
                    import traceback
                    traceback.print_exc()
                    return
            
            # Parse common options for tools
            extra = args[2:]
            i = 0
            params_json = None
            category_arg = None
            tool_arg = None
            while i < len(extra):
                token = extra[i]
                if token in ("--host", "-H") and i + 1 < len(extra):
                    host = str(extra[i + 1])
                    i += 2
                elif token in ("--port", "-p") and i + 1 < len(extra):
                    port = str(extra[i + 1])
                    i += 2
                elif token in ("--params", "-d") and i + 1 < len(extra):
                    params_json = extra[i + 1]
                    i += 2
                else:
                    # Positional capture for category and tool for list/execute
                    if category_arg is None:
                        category_arg = token
                    elif tool_arg is None:
                        tool_arg = token
                    i += 1

            base = f"http://{host}:{port}/api/mcp"
            try:
                import requests
                if subcommand == "categories":
                    # Use enhanced discovery if MCP server is not running
                    try:
                        r = requests.get(f"{base}/tools", timeout=3)
                        r.raise_for_status()
                        data = r.json()
                        cats = sorted(list(data.keys())) if isinstance(data, dict) else []
                    except Exception:
                        # Fallback to local discovery
                        runner = DynamicToolRunner()
                        cats = runner.get_categories()
                    
                    if json_output:
                        print(json.dumps({"categories": cats}))
                    else:
                        print("Available tool categories:")
                        runner = DynamicToolRunner()
                        for c in cats:
                            count = runner.get_tool_count(c)
                            print(f"  {c} ({count} tools)")
                    return
                elif subcommand == "list":
                    if not category_arg:
                        print("Usage: ipfs-datasets tools list <category> [--host H --port P]")
                        return
                    
                    # Try MCP server first, fallback to local discovery
                    try:
                        r = requests.get(f"{base}/tools", timeout=3)
                        r.raise_for_status()
                        data = r.json()
                        tools = data.get(category_arg, []) if isinstance(data, dict) else []
                    except Exception:
                        # Fallback to local discovery
                        runner = DynamicToolRunner()
                        tool_names = runner.get_tools(category_arg)
                        tools = [{"name": name} for name in tool_names]
                    
                    if not tools:
                        print(f"No tools found for category '{category_arg}'")
                        return
                    if json_output:
                        print(json.dumps({"category": category_arg, "tools": tools}))
                    else:
                        print(f"Tools in '{category_arg}':")
                        for t in tools:
                            if isinstance(t, dict):
                                name = t.get("name", "unknown")
                                desc = t.get("description", "")
                                print(f"  {name}: {desc}" if desc else f"  {name}")
                            else:
                                print(f"  {t}")
                    return
                elif subcommand == "describe":
                    if not category_arg or not tool_arg:
                        print("Usage: ipfs-datasets tools describe <category> <tool> [--host H --port P]")
                        return
                    url = f"{base}/tools/{category_arg}/{tool_arg}"
                    r = requests.get(url, timeout=5)
                    if r.ok:
                        if json_output:
                            print(r.text)
                        else:
                            try:
                                print(json.dumps(r.json(), indent=2))
                            except Exception:
                                print(r.text)
                    else:
                        print(f"HTTP {r.status_code}: {r.text[:200]}")
                    return
                elif subcommand == "execute":
                    if not category_arg or not tool_arg:
                        print("Usage: ipfs-datasets tools execute <category> <tool> [--params JSON] [--host H --port P]")
                        return
                    try:
                        body = json.loads(params_json) if params_json else {}
                    except Exception as e:
                        print(f"Invalid JSON for --params: {e}")
                        return
                    url = f"{base}/tools/{category_arg}/{tool_arg}/execute"
                    r = requests.post(url, json=body, timeout=15)
                    if r.ok:
                        if json_output:
                            print(r.text)
                        else:
                            try:
                                print(json.dumps(r.json(), indent=2))
                            except Exception:
                                print(r.text)
                    else:
                        print(f"HTTP {r.status_code}: {r.text[:200]}")
                    return
            except Exception as e:
                print(f"Tools command failed: {e}")
                return
        
        if command == "ipfs":
            subcommand = args[1] if len(args) > 1 else None
            config_override = None
            if "--config" in args:
                try:
                    idx = args.index("--config")
                    if idx + 1 < len(args):
                        config_override = args[idx + 1]
                        args = args[:idx] + args[idx+2:]
                except Exception:
                    pass
            host, port = _default_host_port(config_override)
            extra = args[2:]
            i = 0
            out_path = None
            path_arg = None
            cid_arg = None
            gateway = None
            # load default gateway from env or config
            if not gateway:
                gw_env = os.environ.get("IPFS_HTTP_GATEWAY") or os.environ.get("IPFS_DATASETS_IPFS_GATEWAY")
                if gw_env:
                    gateway = gw_env
                else:
                    cfg = _load_cli_config(config_override)
                    gateway = cfg.get("gateway") if isinstance(cfg, dict) else None
            while i < len(extra):
                token = extra[i]
                if token in ("--host", "-H") and i + 1 < len(extra):
                    host = str(extra[i + 1])
                    i += 2
                elif token in ("--port", "-p") and i + 1 < len(extra):
                    port = str(extra[i + 1])
                    i += 2
                elif token in ("--out", "-o") and i + 1 < len(extra):
                    out_path = extra[i + 1]
                    i += 2
                elif token in ("--gateway", "-g") and i + 1 < len(extra):
                    gateway = extra[i + 1]
                    i += 2
                else:
                    # positional capture
                    if cid_arg is None and subcommand == "get":
                        cid_arg = token
                    elif path_arg is None and subcommand == "pin":
                        path_arg = token
                    i += 1

            base = f"http://{host}:{port}/api/mcp/tools"
            try:
                import requests
                if subcommand == "get":
                    if not cid_arg:
                        print("Usage: ipfs-datasets ipfs get <cid> [--out PATH] [--host H --port P]")
                        return
                    url = f"{base}/ipfs_tools/get_from_ipfs/execute"
                    body = {"cid": cid_arg}
                    if out_path:
                        body["output_path"] = out_path
                    if gateway:
                        body["gateway"] = gateway
                    r = requests.post(url, json=body, timeout=30)
                    if r.ok:
                        if json_output:
                            print(r.text)
                        else:
                            try:
                                print(json.dumps(r.json(), indent=2))
                            except Exception:
                                print(r.text)
                    else:
                        print(f"HTTP {r.status_code}: {r.text[:200]}")
                    return
                elif subcommand == "pin":
                    if not path_arg:
                        print("Usage: ipfs-datasets ipfs pin <path> [--host H --port P]")
                        return
                    url = f"{base}/ipfs_tools/pin_to_ipfs/execute"
                    body = {"content_source": path_arg}
                    r = requests.post(url, json=body, timeout=60)
                    if r.ok:
                        if json_output:
                            print(r.text)
                        else:
                            try:
                                print(json.dumps(r.json(), indent=2))
                            except Exception:
                                print(r.text)
                    else:
                        print(f"HTTP {r.status_code}: {r.text[:200]}")
                    return
            except Exception as e:
                print(f"IPFS command failed: {e}")
                return
        
        if command == "mcp":
            subcommand = args[1] if len(args) > 1 else None
            if subcommand == "start":
                config_override = None
                if "--config" in args:
                    try:
                        idx = args.index("--config")
                        if idx + 1 < len(args):
                            config_override = args[idx + 1]
                            args = args[:idx] + args[idx+2:]
                    except Exception:
                        pass
                host, port = _default_host_port(config_override)
                blocking = False
                extra = args[2:]
                i = 0
                while i < len(extra):
                    token = extra[i]
                    if token in ("--host", "-H") and i + 1 < len(extra):
                        host = str(extra[i + 1])
                        i += 2
                    elif token in ("--port", "-p") and i + 1 < len(extra):
                        port = str(extra[i + 1])
                        i += 2
                    elif token in ("--blocking", "-b"):
                        blocking = True
                        i += 1
                    else:
                        i += 1

                env = os.environ.copy()
                env["MCP_DASHBOARD_HOST"] = host
                env["MCP_DASHBOARD_PORT"] = str(port)
                if blocking:
                    env["MCP_DASHBOARD_BLOCKING"] = "1"

                cmd = [sys.executable, "-m", "ipfs_datasets_py.mcp_dashboard"]
                try:
                    if blocking:
                        print(f"Starting MCP dashboard (blocking) at http://{host}:{port}/mcp ...")
                        subprocess.run(cmd, env=env, check=False)
                    else:
                        print(f"Starting MCP dashboard at http://{host}:{port}/mcp (background)...")
                        # Write logs to a file so crashes aren't silent
                        logs_dir = Path.home() / ".ipfs_datasets"
                        logs_dir.mkdir(parents=True, exist_ok=True)
                        log_path = logs_dir / "mcp_dashboard.log"
                        log_fh = open(log_path, "a")
                        proc = subprocess.Popen(cmd, env=env, stdout=log_fh, stderr=log_fh)
                        # Quick readiness probe so users get fast feedback
                        import time as _time
                        import urllib.request as _url
                        ready = False
                        status_url = f"http://{host}:{port}/api/mcp/status"
                        for _ in range(20):  # ~5s total
                            try:
                                with _url.urlopen(status_url, timeout=0.25) as r:
                                    if r.status == 200:
                                        ready = True
                                        break
                            except Exception:
                                _time.sleep(0.25)
                        if ready:
                            print(f"MCP dashboard is up: {status_url}")
                        else:
                            print("MCP dashboard did not respond yet. It may still be booting or failed to start.")
                            print(f"Tip: tail -n 100 {log_path} to see logs, or run 'ipfs-datasets mcp start --blocking' for diagnostics.")
                            # If process exited immediately, surface that
                            _time.sleep(0.2)
                            if proc.poll() is not None:
                                print(f"Warning: dashboard process exited with code {proc.returncode}. See logs: {log_path}")
                    return
                except Exception as e:
                    print(f"Failed to start MCP dashboard: {e}")
                    print("Tip: try 'python -m ipfs_datasets_py.mcp_dashboard' for diagnostics")
                    return

            elif subcommand == "stop":
                # Best-effort stop via pkill on the dashboard module
                try:
                    # Prefer graceful stop in future; for now use pkill
                    subprocess.run(["pkill", "-f", "ipfs_datasets_py.mcp_dashboard"], check=False)
                    print("MCP dashboard stop signal sent (pkill).")
                except Exception as e:
                    print(f"Failed to stop MCP dashboard: {e}")
                return

            elif subcommand == "status":
                # Lightweight status check via HTTP if requests is available
                config_override = None
                if "--config" in args:
                    try:
                        idx = args.index("--config")
                        if idx + 1 < len(args):
                            config_override = args[idx + 1]
                            args = args[:idx] + args[idx+2:]
                    except Exception:
                        pass
                host, port = _default_host_port(config_override)
                extra = args[2:]
                i = 0
                while i < len(extra):
                    token = extra[i]
                    if token in ("--host", "-H") and i + 1 < len(extra):
                        host = str(extra[i + 1])
                        i += 2
                    elif token in ("--port", "-p") and i + 1 < len(extra):
                        port = str(extra[i + 1])
                        i += 2
                    else:
                        i += 1
                try:
                    import requests
                    url = f"http://{host}:{port}/api/mcp/status"
                    r = requests.get(url, timeout=2)
                    if r.ok:
                        if json_output:
                            print(r.text)
                        else:
                            print(f"MCP Dashboard status at {url}: {r.status_code}")
                            try:
                                data = r.json()
                                print(json.dumps({
                                    "status": data.get("status"),
                                    "tools_available": data.get("tools_available")
                                }, indent=2))
                            except Exception:
                                print(r.text[:300])
                    else:
                        print(f"MCP Dashboard not healthy (HTTP {r.status_code}) at {url}")
                except Exception as e:
                    print(f"MCP status check failed: {e}")
                return

            elif subcommand == "logs":
                # Tail the MCP dashboard log file
                # Options: --lines N (default 200), --follow
                lines = 200
                follow = False
                extra = args[2:]
                i = 0
                while i < len(extra):
                    token = extra[i]
                    if token in ("--lines", "-n") and i + 1 < len(extra):
                        try:
                            lines = int(extra[i + 1])
                        except Exception:
                            pass
                        i += 2
                    elif token in ("--follow", "-f"):
                        follow = True
                        i += 1
                    else:
                        i += 1

                log_path = Path.home() / ".ipfs_datasets" / "mcp_dashboard.log"
                if not log_path.exists():
                    print(f"No log file found at {log_path}. Start the dashboard first with 'ipfs-datasets mcp start'.")
                    return

                # Print last N lines
                try:
                    with open(log_path, "r", encoding="utf-8", errors="replace") as f:
                        content = f.readlines()
                        start = max(0, len(content) - lines)
                        for line in content[start:]:
                            print(line.rstrip("\n"))

                    if not follow:
                        return

                    # Follow mode
                    print("-- following -- (Ctrl+C to stop)")
                    with open(log_path, "r", encoding="utf-8", errors="replace") as f:
                        # Seek to end
                        f.seek(0, 2)
                        import time as _time
                        while True:
                            pos = f.tell()
                            line = f.readline()
                            if not line:
                                _time.sleep(0.25)
                                f.seek(pos)
                            else:
                                print(line.rstrip("\n"))
                except KeyboardInterrupt:
                    return
                except Exception as e:
                    print(f"Error reading logs: {e}")
                return
        
        if command == "vscode":
            # VSCode CLI management commands
            subcommand = args[1] if len(args) > 1 else None
            
            try:
                from ipfs_datasets_py.utils.vscode_cli import VSCodeCLI
                
                if subcommand == "status":
                    # Show VSCode CLI status
                    extra = args[2:]
                    install_dir = None
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        else:
                            i += 1
                    
                    cli = VSCodeCLI(install_dir=install_dir)
                    status = cli.get_status()
                    
                    if json_output:
                        print(json.dumps(status, indent=2))
                    else:
                        print("VSCode CLI Status:")
                        print(f"  Installed: {status['installed']}")
                        print(f"  Version: {status['version'] or 'N/A'}")
                        print(f"  Install Dir: {status['install_dir']}")
                        print(f"  Executable: {status['executable']}")
                        print(f"  Platform: {status['platform']}")
                        print(f"  Architecture: {status['architecture']}")
                        if status['extensions']:
                            print(f"  Extensions: {len(status['extensions'])}")
                    return
                
                elif subcommand == "install":
                    # Install VSCode CLI
                    extra = args[2:]
                    install_dir = None
                    force = False
                    commit = None
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        elif token in ("--force", "-f"):
                            force = True
                            i += 1
                        elif token in ("--commit", "-c") and i + 1 < len(extra):
                            commit = extra[i + 1]
                            i += 2
                        else:
                            i += 1
                    
                    cli = VSCodeCLI(install_dir=install_dir, commit=commit)
                    print("Installing VSCode CLI...")
                    success = cli.download_and_install(force=force)
                    
                    if success:
                        status = cli.get_status()
                        if json_output:
                            print(json.dumps({"success": True, "status": status}, indent=2))
                        else:
                            print(f"VSCode CLI installed successfully at {status['executable']}")
                            print(f"Version: {status['version']}")
                    else:
                        if json_output:
                            print(json.dumps({"success": False, "error": "Installation failed"}))
                        else:
                            print("VSCode CLI installation failed")
                    return
                
                elif subcommand == "execute":
                    # Execute VSCode CLI command
                    extra = args[2:]
                    install_dir = None
                    timeout = 60
                    cmd_args = []
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        elif token in ("--timeout", "-t") and i + 1 < len(extra):
                            try:
                                timeout = int(extra[i + 1])
                            except:
                                pass
                            i += 2
                        else:
                            cmd_args.append(token)
                            i += 1
                    
                    if not cmd_args:
                        print("Usage: ipfs-datasets vscode execute <command> [args...] [--install-dir DIR] [--timeout SECONDS]")
                        return
                    
                    cli = VSCodeCLI(install_dir=install_dir)
                    if not cli.is_installed():
                        print("VSCode CLI is not installed. Run 'ipfs-datasets vscode install' first.")
                        return
                    
                    result = cli.execute(cmd_args, timeout=timeout)
                    
                    if json_output:
                        print(json.dumps({
                            "success": result.returncode == 0,
                            "returncode": result.returncode,
                            "stdout": result.stdout,
                            "stderr": result.stderr
                        }, indent=2))
                    else:
                        if result.stdout:
                            print(result.stdout)
                        if result.stderr:
                            print(result.stderr, file=sys.stderr)
                        if result.returncode != 0:
                            print(f"Command failed with exit code {result.returncode}")
                    return
                
                elif subcommand == "extensions":
                    # Manage extensions
                    extra = args[2:]
                    install_dir = None
                    action = "list"
                    extension_id = None
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        elif token == "list":
                            action = "list"
                            i += 1
                        elif token == "install" and i + 1 < len(extra):
                            action = "install"
                            extension_id = extra[i + 1]
                            i += 2
                        elif token == "uninstall" and i + 1 < len(extra):
                            action = "uninstall"
                            extension_id = extra[i + 1]
                            i += 2
                        else:
                            i += 1
                    
                    cli = VSCodeCLI(install_dir=install_dir)
                    if not cli.is_installed():
                        print("VSCode CLI is not installed. Run 'ipfs-datasets vscode install' first.")
                        return
                    
                    if action == "list":
                        extensions = cli.list_extensions()
                        if json_output:
                            print(json.dumps({"extensions": extensions, "count": len(extensions)}, indent=2))
                        else:
                            print(f"Installed extensions ({len(extensions)}):")
                            for ext in extensions:
                                print(f"  - {ext}")
                    elif action == "install":
                        if not extension_id:
                            print("Usage: ipfs-datasets vscode extensions install <extension-id>")
                            return
                        print(f"Installing extension {extension_id}...")
                        success = cli.install_extension(extension_id)
                        if json_output:
                            print(json.dumps({"success": success, "extension_id": extension_id}))
                        else:
                            print(f"Extension {extension_id} {'installed' if success else 'failed to install'}")
                    elif action == "uninstall":
                        if not extension_id:
                            print("Usage: ipfs-datasets vscode extensions uninstall <extension-id>")
                            return
                        print(f"Uninstalling extension {extension_id}...")
                        success = cli.uninstall_extension(extension_id)
                        if json_output:
                            print(json.dumps({"success": success, "extension_id": extension_id}))
                        else:
                            print(f"Extension {extension_id} {'uninstalled' if success else 'failed to uninstall'}")
                    return
                
                elif subcommand == "auth" or subcommand == "configure-auth":
                    # Configure authentication (convenience command)
                    extra = args[2:]
                    install_dir = None
                    provider = "github"
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        elif token in ("--provider", "-p") and i + 1 < len(extra):
                            provider = extra[i + 1]
                            i += 2
                        else:
                            i += 1
                    
                    cli = VSCodeCLI(install_dir=install_dir)
                    
                    # Check if installed, offer to install if not
                    if not cli.is_installed():
                        print("VSCode CLI is not installed.")
                        if not json_output:
                            response = input("Would you like to install it now? (y/n): ").lower()
                            if response == 'y':
                                print("Installing VSCode CLI...")
                                success = cli.download_and_install()
                                if not success:
                                    print("Installation failed. Cannot proceed with authentication.")
                                    return
                            else:
                                print("Authentication requires VSCode CLI to be installed.")
                                print("Run 'ipfs-datasets vscode install' first.")
                                return
                        else:
                            print(json.dumps({"success": False, "error": "VSCode CLI not installed"}))
                            return
                    
                    # Configure authentication
                    print(f"Configuring authentication with {provider}...")
                    result = cli.configure_auth(provider=provider)
                    
                    if json_output:
                        print(json.dumps(result, indent=2))
                    else:
                        print(result['message'])
                        if result['success'] and result.get('stdout'):
                            print(result['stdout'])
                        if result.get('stderr'):
                            print(result['stderr'], file=sys.stderr)
                    return
                
                elif subcommand == "install-with-auth":
                    # Install and configure authentication in one step
                    extra = args[2:]
                    install_dir = None
                    provider = "github"
                    force = False
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        elif token in ("--provider", "-p") and i + 1 < len(extra):
                            provider = extra[i + 1]
                            i += 2
                        elif token in ("--force", "-f"):
                            force = True
                            i += 1
                        else:
                            i += 1
                    
                    cli = VSCodeCLI(install_dir=install_dir)
                    
                    print(f"Installing VSCode CLI and configuring authentication with {provider}...")
                    result = cli.install_with_auth(provider=provider, force=force)
                    
                    if json_output:
                        print(json.dumps(result, indent=2))
                    else:
                        print(result['message'])
                        for msg in result.get('messages', []):
                            print(f"  • {msg}")
                        
                        if result.get('auth_details', {}).get('stdout'):
                            print("\nAuthentication details:")
                            print(result['auth_details']['stdout'])
                    return
                
                elif subcommand == "tunnel":
                    # Manage tunnel
                    extra = args[2:]
                    install_dir = None
                    action = None
                    provider = "github"
                    tunnel_name = None
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        elif token == "login":
                            action = "login"
                            i += 1
                        elif token == "install-service":
                            action = "install-service"
                            i += 1
                        elif token in ("--provider", "-p") and i + 1 < len(extra):
                            provider = extra[i + 1]
                            i += 2
                        elif token in ("--name", "-n") and i + 1 < len(extra):
                            tunnel_name = extra[i + 1]
                            i += 2
                        else:
                            i += 1
                    
                    if not action:
                        print("Usage: ipfs-datasets vscode tunnel <login|install-service> [options]")
                        return
                    
                    cli = VSCodeCLI(install_dir=install_dir)
                    if not cli.is_installed():
                        print("VSCode CLI is not installed. Run 'ipfs-datasets vscode install' first.")
                        return
                    
                    if action == "login":
                        print(f"Logging in to tunnel with {provider}...")
                        result = cli.tunnel_user_login(provider=provider)
                        if json_output:
                            print(json.dumps({
                                "success": result.returncode == 0,
                                "stdout": result.stdout,
                                "stderr": result.stderr
                            }))
                        else:
                            if result.stdout:
                                print(result.stdout)
                            if result.stderr:
                                print(result.stderr, file=sys.stderr)
                    elif action == "install-service":
                        print(f"Installing tunnel service{' with name ' + tunnel_name if tunnel_name else ''}...")
                        result = cli.tunnel_service_install(name=tunnel_name)
                        if json_output:
                            print(json.dumps({
                                "success": result.returncode == 0,
                                "stdout": result.stdout,
                                "stderr": result.stderr
                            }))
                        else:
                            if result.stdout:
                                print(result.stdout)
                            if result.stderr:
                                print(result.stderr, file=sys.stderr)
                    return
                
                else:
                    print(f"Unknown vscode subcommand: {subcommand}")
                    print("Available subcommands: status, install, auth, install-with-auth, execute, extensions, tunnel")
                    return
                    
            except ImportError as e:
                print(f"Error: VSCode CLI module not available: {e}")
                return
            except Exception as e:
                print(f"Error executing vscode command: {e}")
                import traceback
                traceback.print_exc()
                return
        
        if command == "github":
            # GitHub CLI management commands
            subcommand = args[1] if len(args) > 1 else None
            
            try:
                from ipfs_datasets_py.utils.github_cli import GitHubCLI
                
                if subcommand == "status":
                    # Show GitHub CLI status
                    extra = args[2:]
                    install_dir = None
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        else:
                            i += 1
                    
                    cli = GitHubCLI(install_dir=install_dir)
                    status = cli.get_status()
                    
                    if json_output:
                        print(json.dumps(status, indent=2))
                    else:
                        print("GitHub CLI Status:")
                        print(f"  Installed: {status['installed']}")
                        print(f"  Version: {status['version'] or 'N/A'}")
                        print(f"  Install Dir: {status['install_dir']}")
                        print(f"  Executable: {status['executable']}")
                        print(f"  Platform: {status['platform']}")
                        print(f"  Architecture: {status['architecture']}")
                        print(f"  Auth Status: {status.get('auth_status', 'Unknown')}")
                    return
                
                elif subcommand == "install":
                    # Install GitHub CLI
                    extra = args[2:]
                    install_dir = None
                    force = False
                    version = None
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        elif token in ("--force", "-f"):
                            force = True
                            i += 1
                        elif token in ("--version", "-v") and i + 1 < len(extra):
                            version = extra[i + 1]
                            i += 2
                        else:
                            i += 1
                    
                    cli = GitHubCLI(install_dir=install_dir, version=version)
                    print("Installing GitHub CLI...")
                    success = cli.download_and_install(force=force)
                    
                    if success:
                        status = cli.get_status()
                        if json_output:
                            print(json.dumps({"success": True, "status": status}, indent=2))
                        else:
                            print(f"GitHub CLI installed successfully at {status['executable']}")
                            print(f"Version: {status['version']}")
                    else:
                        if json_output:
                            print(json.dumps({"success": False, "error": "Installation failed"}))
                        else:
                            print("GitHub CLI installation failed")
                    return
                
                elif subcommand == "execute":
                    # Execute GitHub CLI command
                    extra = args[2:]
                    install_dir = None
                    timeout = 60
                    cmd_args = []
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        elif token in ("--timeout", "-t") and i + 1 < len(extra):
                            try:
                                timeout = int(extra[i + 1])
                            except:
                                pass
                            i += 2
                        else:
                            cmd_args.append(token)
                            i += 1
                    
                    if not cmd_args:
                        print("Usage: ipfs-datasets github execute <command> [args...] [--install-dir DIR] [--timeout SECONDS]")
                        return
                    
                    cli = GitHubCLI(install_dir=install_dir)
                    if not cli.is_installed():
                        print("GitHub CLI is not installed. Run 'ipfs-datasets github install' first.")
                        return
                    
                    result = cli.execute(cmd_args, timeout=timeout)
                    
                    if json_output:
                        print(json.dumps({
                            "success": result.returncode == 0,
                            "returncode": result.returncode,
                            "stdout": result.stdout,
                            "stderr": result.stderr
                        }, indent=2))
                    else:
                        if result.stdout:
                            print(result.stdout)
                        if result.stderr:
                            print(result.stderr, file=sys.stderr)
                        if result.returncode != 0:
                            print(f"Command failed with exit code {result.returncode}")
                    return
                
                elif subcommand == "auth":
                    # Manage authentication
                    extra = args[2:]
                    install_dir = None
                    action = "status"
                    hostname = "github.com"
                    web = True
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        elif token == "login":
                            action = "login"
                            i += 1
                        elif token == "status":
                            action = "status"
                            i += 1
                        elif token in ("--hostname", "-h") and i + 1 < len(extra):
                            hostname = extra[i + 1]
                            i += 2
                        elif token == "--no-web":
                            web = False
                            i += 1
                        else:
                            i += 1
                    
                    cli = GitHubCLI(install_dir=install_dir)
                    if not cli.is_installed():
                        print("GitHub CLI is not installed. Run 'ipfs-datasets github install' first.")
                        return
                    
                    if action == "login":
                        result = cli.auth_login(hostname=hostname, web=web)
                        if json_output:
                            print(json.dumps({
                                "success": result.returncode == 0,
                                "stdout": result.stdout,
                                "stderr": result.stderr
                            }, indent=2))
                        else:
                            if result.stdout:
                                print(result.stdout)
                            if result.stderr:
                                print(result.stderr, file=sys.stderr)
                    else:  # status
                        result = cli.auth_status()
                        if json_output:
                            print(json.dumps({
                                "success": result.returncode == 0,
                                "stdout": result.stdout,
                                "stderr": result.stderr
                            }, indent=2))
                        else:
                            if result.stdout:
                                print(result.stdout)
                            if result.stderr:
                                print(result.stderr, file=sys.stderr)
                    return
                
                else:
                    print(f"Unknown github subcommand: {subcommand}")
                    print("Available subcommands: status, install, execute, auth")
                    return
                    
            except ImportError as e:
                print(f"Error: GitHub CLI module not available: {e}")
                return
            except Exception as e:
                print(f"Error executing github command: {e}")
                import traceback
                traceback.print_exc()
                return
        
        if command == "copilot":
            # GitHub Copilot CLI management commands
            subcommand = args[1] if len(args) > 1 else None
            
            try:
                from ipfs_datasets_py.utils.copilot_cli import CopilotCLI
                
                if subcommand == "status":
                    # Show Copilot CLI status
                    extra = args[2:]
                    github_cli_path = None
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--github-cli-path", "-g") and i + 1 < len(extra):
                            github_cli_path = extra[i + 1]
                            i += 2
                        else:
                            i += 1
                    
                    copilot = CopilotCLI(github_cli_path=github_cli_path)
                    status = copilot.get_status()
                    
                    if json_output:
                        print(json.dumps(status, indent=2))
                    else:
                        print("GitHub Copilot CLI Status:")
                        print(f"  Installed: {status['installed']}")
                        print(f"  GitHub CLI Available: {status['github_cli_available']}")
                        print(f"  GitHub CLI Path: {status['github_cli_path'] or 'Not found'}")
                        if status.get('version_info'):
                            print(f"  Version: {status['version_info']}")
                    return
                
                elif subcommand == "install":
                    # Install Copilot CLI
                    extra = args[2:]
                    github_cli_path = None
                    force = False
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--github-cli-path", "-g") and i + 1 < len(extra):
                            github_cli_path = extra[i + 1]
                            i += 2
                        elif token in ("--force", "-f"):
                            force = True
                            i += 1
                        else:
                            i += 1
                    
                    copilot = CopilotCLI(github_cli_path=github_cli_path)
                    print("Installing GitHub Copilot CLI extension...")
                    result = copilot.install(force=force)
                    
                    if json_output:
                        print(json.dumps(result, indent=2))
                    else:
                        if result['success']:
                            print(result['message'])
                            if result.get('stdout'):
                                print(result['stdout'])
                        else:
                            print(f"Installation failed: {result.get('error')}")
                            if result.get('stderr'):
                                print(result['stderr'], file=sys.stderr)
                    return
                
                elif subcommand == "explain":
                    # Explain code using Copilot
                    extra = args[2:]
                    github_cli_path = None
                    code = None
                    language = None
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--github-cli-path", "-g") and i + 1 < len(extra):
                            github_cli_path = extra[i + 1]
                            i += 2
                        elif token in ("--code", "-c") and i + 1 < len(extra):
                            code = extra[i + 1]
                            i += 2
                        elif token in ("--language", "-l") and i + 1 < len(extra):
                            language = extra[i + 1]
                            i += 2
                        else:
                            # Treat remaining args as code if not specified
                            if code is None:
                                code = ' '.join(extra[i:])
                                break
                            i += 1
                    
                    if not code:
                        print("Usage: ipfs-datasets copilot explain <code> [--language LANG] [--github-cli-path PATH]")
                        print("   or: ipfs-datasets copilot explain --code '<code>' [options]")
                        return
                    
                    copilot = CopilotCLI(github_cli_path=github_cli_path)
                    if not copilot.installed:
                        print("GitHub Copilot CLI is not installed. Run 'ipfs-datasets copilot install' first.")
                        return
                    
                    result = copilot.explain_code(code, language=language)
                    
                    if json_output:
                        print(json.dumps(result, indent=2))
                    else:
                        if result['success']:
                            print(result['explanation'])
                        else:
                            print(f"Failed to explain code: {result.get('error')}")
                    return
                
                elif subcommand == "suggest":
                    # Get command suggestions from Copilot
                    extra = args[2:]
                    github_cli_path = None
                    description = None
                    shell = None
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--github-cli-path", "-g") and i + 1 < len(extra):
                            github_cli_path = extra[i + 1]
                            i += 2
                        elif token in ("--shell", "-s") and i + 1 < len(extra):
                            shell = extra[i + 1]
                            i += 2
                        else:
                            # Treat remaining args as description
                            if description is None:
                                description = ' '.join(extra[i:])
                                break
                            i += 1
                    
                    if not description:
                        print("Usage: ipfs-datasets copilot suggest <description> [--shell SHELL] [--github-cli-path PATH]")
                        return
                    
                    copilot = CopilotCLI(github_cli_path=github_cli_path)
                    if not copilot.installed:
                        print("GitHub Copilot CLI is not installed. Run 'ipfs-datasets copilot install' first.")
                        return
                    
                    result = copilot.suggest_command(description, shell=shell)
                    
                    if json_output:
                        print(json.dumps(result, indent=2))
                    else:
                        if result['success']:
                            print(result['suggestions'])
                        else:
                            print(f"Failed to get suggestions: {result.get('error')}")
                    return
                
                elif subcommand == "git":
                    # Get Git command suggestions from Copilot
                    extra = args[2:]
                    github_cli_path = None
                    description = None
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--github-cli-path", "-g") and i + 1 < len(extra):
                            github_cli_path = extra[i + 1]
                            i += 2
                        else:
                            # Treat remaining args as description
                            if description is None:
                                description = ' '.join(extra[i:])
                                break
                            i += 1
                    
                    if not description:
                        print("Usage: ipfs-datasets copilot git <description> [--github-cli-path PATH]")
                        return
                    
                    copilot = CopilotCLI(github_cli_path=github_cli_path)
                    if not copilot.installed:
                        print("GitHub Copilot CLI is not installed. Run 'ipfs-datasets copilot install' first.")
                        return
                    
                    result = copilot.suggest_git_command(description)
                    
                    if json_output:
                        print(json.dumps(result, indent=2))
                    else:
                        if result['success']:
                            print(result['suggestions'])
                        else:
                            print(f"Failed to get Git suggestions: {result.get('error')}")
                    return
                
                else:
                    print(f"Unknown copilot subcommand: {subcommand}")
                    print("Available subcommands: status, install, explain, suggest, git")
                    return
                    
            except ImportError as e:
                print(f"Error: Copilot CLI module not available: {e}")
                return
            except Exception as e:
                print(f"Error executing copilot command: {e}")
                import traceback
                traceback.print_exc()
                return
        
        if command == "gemini":
            # Google Gemini CLI management commands
            subcommand = args[1] if len(args) > 1 else None
            
            try:
                from ipfs_datasets_py.utils.gemini_cli import GeminiCLI
                
                if subcommand == "status":
                    # Show Gemini CLI status
                    extra = args[2:]
                    install_dir = None
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        else:
                            i += 1
                    
                    cli = GeminiCLI(install_dir=install_dir)
                    status = cli.get_status()
                    
                    if json_output:
                        print(json.dumps(status, indent=2))
                    else:
                        print("Google Gemini CLI Status:")
                        print(f"  Installed: {status['installed']}")
                        print(f"  Version: {status['version'] or 'N/A'}")
                        print(f"  Config Dir: {status['install_dir']}")
                        print(f"  API Key Configured: {status['api_key_configured']}")
                        print(f"  Package: {status['package']}")
                    return
                
                elif subcommand == "install":
                    # Install Gemini CLI
                    extra = args[2:]
                    install_dir = None
                    force = False
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        elif token in ("--force", "-f"):
                            force = True
                            i += 1
                        else:
                            i += 1
                    
                    cli = GeminiCLI(install_dir=install_dir)
                    print("Installing Google Gemini CLI...")
                    success = cli.install(force=force)
                    
                    if success:
                        status = cli.get_status()
                        if json_output:
                            print(json.dumps({"success": True, "status": status}, indent=2))
                        else:
                            print(f"Google Gemini CLI installed successfully")
                            print(f"Version: {status['version']}")
                    else:
                        if json_output:
                            print(json.dumps({"success": False, "error": "Installation failed"}))
                        else:
                            print("Google Gemini CLI installation failed")
                    return
                
                elif subcommand == "config":
                    # Configure API key
                    extra = args[2:]
                    install_dir = None
                    api_key = None
                    action = None
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        elif token == "set-api-key" and i + 1 < len(extra):
                            action = "set-api-key"
                            api_key = extra[i + 1]
                            i += 2
                        elif token == "test":
                            action = "test"
                            i += 1
                        else:
                            i += 1
                    
                    cli = GeminiCLI(install_dir=install_dir)
                    if not cli.is_installed():
                        print("Google Gemini CLI is not installed. Run 'ipfs-datasets gemini install' first.")
                        return
                    
                    if action == "set-api-key":
                        if not api_key:
                            print("Usage: ipfs-datasets gemini config set-api-key <API_KEY>")
                            return
                        success = cli.configure_api_key(api_key)
                        if json_output:
                            print(json.dumps({"success": success}, indent=2))
                        else:
                            if success:
                                print("API key configured successfully")
                            else:
                                print("Failed to configure API key")
                    elif action == "test":
                        result = cli.test_connection()
                        if json_output:
                            print(json.dumps(result, indent=2))
                        else:
                            if result['success']:
                                print("Connection successful!")
                                if result.get('response'):
                                    print(f"Response: {result['response']}")
                            else:
                                print(f"Connection failed: {result.get('error')}")
                    else:
                        print("Usage: ipfs-datasets gemini config <set-api-key|test>")
                    return
                
                elif subcommand == "execute":
                    # Execute Gemini CLI command
                    extra = args[2:]
                    install_dir = None
                    timeout = 60
                    cmd_args = []
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        elif token in ("--timeout", "-t") and i + 1 < len(extra):
                            try:
                                timeout = int(extra[i + 1])
                            except:
                                pass
                            i += 2
                        else:
                            cmd_args.append(token)
                            i += 1
                    
                    if not cmd_args:
                        print("Usage: ipfs-datasets gemini execute <command> [args...] [--install-dir DIR] [--timeout SECONDS]")
                        return
                    
                    cli = GeminiCLI(install_dir=install_dir)
                    if not cli.is_installed():
                        print("Google Gemini CLI is not installed. Run 'ipfs-datasets gemini install' first.")
                        return
                    
                    result = cli.execute(cmd_args, timeout=timeout)
                    
                    if json_output:
                        print(json.dumps({
                            "success": result.returncode == 0,
                            "returncode": result.returncode,
                            "stdout": result.stdout,
                            "stderr": result.stderr
                        }, indent=2))
                    else:
                        if result.stdout:
                            print(result.stdout)
                        if result.stderr:
                            print(result.stderr, file=sys.stderr)
                        if result.returncode != 0:
                            print(f"Command failed with exit code {result.returncode}")
                    return
                
                else:
                    print(f"Unknown gemini subcommand: {subcommand}")
                    print("Available subcommands: status, install, config, execute")
                    return
                    
            except ImportError as e:
                print(f"Error: Google Gemini CLI module not available: {e}")
                return
            except Exception as e:
                print(f"Error executing gemini command: {e}")
                import traceback
                traceback.print_exc()
                return
        
        if command == "claude":
            # Anthropic Claude CLI management commands
            subcommand = args[1] if len(args) > 1 else None
            
            try:
                from ipfs_datasets_py.utils.claude_cli import ClaudeCLI
                
                if subcommand == "status":
                    # Show Claude CLI status
                    extra = args[2:]
                    install_dir = None
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        else:
                            i += 1
                    
                    cli = ClaudeCLI(install_dir=install_dir)
                    status = cli.get_status()
                    
                    if json_output:
                        print(json.dumps(status, indent=2))
                    else:
                        print("Anthropic Claude CLI Status:")
                        print(f"  Installed: {status['installed']}")
                        print(f"  Version: {status['version'] or 'N/A'}")
                        print(f"  Config Dir: {status['install_dir']}")
                        print(f"  API Key Configured: {status['api_key_configured']}")
                        print(f"  Package: {status['package']}")
                    return
                
                elif subcommand == "install":
                    # Install Claude CLI
                    extra = args[2:]
                    install_dir = None
                    force = False
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        elif token in ("--force", "-f"):
                            force = True
                            i += 1
                        else:
                            i += 1
                    
                    cli = ClaudeCLI(install_dir=install_dir)
                    print("Installing Anthropic Claude CLI...")
                    success = cli.install(force=force)
                    
                    if success:
                        status = cli.get_status()
                        if json_output:
                            print(json.dumps({"success": True, "status": status}, indent=2))
                        else:
                            print(f"Anthropic Claude CLI installed successfully")
                            print(f"Version: {status['version']}")
                    else:
                        if json_output:
                            print(json.dumps({"success": False, "error": "Installation failed"}))
                        else:
                            print("Anthropic Claude CLI installation failed")
                    return
                
                elif subcommand == "config":
                    # Configure API key
                    extra = args[2:]
                    install_dir = None
                    api_key = None
                    action = None
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        elif token == "set-api-key" and i + 1 < len(extra):
                            action = "set-api-key"
                            api_key = extra[i + 1]
                            i += 2
                        elif token == "test":
                            action = "test"
                            i += 1
                        else:
                            i += 1
                    
                    cli = ClaudeCLI(install_dir=install_dir)
                    if not cli.is_installed():
                        print("Anthropic Claude CLI is not installed. Run 'ipfs-datasets claude install' first.")
                        return
                    
                    if action == "set-api-key":
                        if not api_key:
                            print("Usage: ipfs-datasets claude config set-api-key <API_KEY>")
                            return
                        success = cli.configure_api_key(api_key)
                        if json_output:
                            print(json.dumps({"success": success}, indent=2))
                        else:
                            if success:
                                print("API key configured successfully")
                            else:
                                print("Failed to configure API key")
                    elif action == "test":
                        result = cli.test_connection()
                        if json_output:
                            print(json.dumps(result, indent=2))
                        else:
                            if result['success']:
                                print("Connection successful!")
                                if result.get('response'):
                                    print(f"Response: {result['response']}")
                            else:
                                print(f"Connection failed: {result.get('error')}")
                    else:
                        print("Usage: ipfs-datasets claude config <set-api-key|test>")
                    return
                
                elif subcommand == "execute":
                    # Execute Claude CLI command
                    extra = args[2:]
                    install_dir = None
                    timeout = 60
                    cmd_args = []
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--install-dir", "-d") and i + 1 < len(extra):
                            install_dir = extra[i + 1]
                            i += 2
                        elif token in ("--timeout", "-t") and i + 1 < len(extra):
                            try:
                                timeout = int(extra[i + 1])
                            except:
                                pass
                            i += 2
                        else:
                            cmd_args.append(token)
                            i += 1
                    
                    if not cmd_args:
                        print("Usage: ipfs-datasets claude execute <command> [args...] [--install-dir DIR] [--timeout SECONDS]")
                        return
                    
                    cli = ClaudeCLI(install_dir=install_dir)
                    if not cli.is_installed():
                        print("Anthropic Claude CLI is not installed. Run 'ipfs-datasets claude install' first.")
                        return
                    
                    result = cli.execute(cmd_args, timeout=timeout)
                    
                    if json_output:
                        print(json.dumps({
                            "success": result.returncode == 0,
                            "returncode": result.returncode,
                            "stdout": result.stdout,
                            "stderr": result.stderr
                        }, indent=2))
                    else:
                        if result.stdout:
                            print(result.stdout)
                        if result.stderr:
                            print(result.stderr, file=sys.stderr)
                        if result.returncode != 0:
                            print(f"Command failed with exit code {result.returncode}")
                    return
                
                else:
                    print(f"Unknown claude subcommand: {subcommand}")
                    print("Available subcommands: status, install, config, execute")
                    return
                    
            except ImportError as e:
                print(f"Error: Anthropic Claude CLI module not available: {e}")
                return
            except Exception as e:
                print(f"Error executing claude command: {e}")
                import traceback
                traceback.print_exc()
                return
        
        if command == "finance":
            """Handle finance dashboard commands."""
            subcommand = args[1] if len(args) > 1 else None
            
            if not subcommand or subcommand in ['-h', '--help']:
                print("""
ipfs-datasets finance - Financial Analysis and Data Pipelines

Usage: ipfs-datasets finance <subcommand> [options]

Subcommands:
  stock       Fetch stock market data
  news        Scrape financial news from AP/Reuters/Bloomberg
  executives  Analyze executive performance with hypothesis testing
  embeddings  Multimodal embedding analysis (text + images)
  theorems    List or apply financial theorems  
  workflow    Execute end-to-end workflow pipelines

Examples:
  ipfs-datasets finance stock AAPL --start 2024-01-01 --end 2024-12-31
  ipfs-datasets finance news "tech stocks" --sources reuters,bloomberg
  ipfs-datasets finance executives --hypothesis "Female CEOs outperform male CEOs"
  ipfs-datasets finance embeddings --multimodal --clusters 10
  ipfs-datasets finance theorems --list
  ipfs-datasets finance workflow pipeline --config workflow.json

For detailed help: ipfs-datasets finance <subcommand> --help
""")
                return
            
            try:
                # Parse common options
                config_override = None
                host_override = None
                port_override = None
                if "--config" in args:
                    idx = args.index("--config")
                    if idx + 1 < len(args):
                        config_override = args[idx + 1]
                
                host, port = _default_host_port(config_override)
                
                # Parse host/port overrides
                extra = args[2:]
                i = 0
                while i < len(extra):
                    token = extra[i]
                    if token in ("--host", "-H") and i + 1 < len(extra):
                        host = str(extra[i + 1])
                        i += 2
                    elif token in ("--port", "-p") and i + 1 < len(extra):
                        port = str(extra[i + 1])
                        i += 2
                    else:
                        i += 1
                
                base_url = f"http://{host}:{port}/api/mcp"
                import requests
                
                if subcommand == "stock":
                    # Fetch stock data
                    symbol = args[2] if len(args) > 2 else None
                    if not symbol:
                        print("Usage: ipfs-datasets finance stock <SYMBOL> [--start DATE] [--end DATE] [--interval INTERVAL]")
                        return
                    
                    start_date = None
                    end_date = None
                    interval = "1d"
                    
                    i = 3
                    while i < len(args):
                        if args[i] == "--start" and i + 1 < len(args):
                            start_date = args[i + 1]
                            i += 2
                        elif args[i] == "--end" and i + 1 < len(args):
                            end_date = args[i + 1]
                            i += 2
                        elif args[i] == "--interval" and i + 1 < len(args):
                            interval = args[i + 1]
                            i += 2
                        else:
                            i += 1
                    
                    params = {
                        "symbol": symbol,
                        "start_date": start_date,
                        "end_date": end_date,
                        "interval": interval
                    }
                    
                    print(f"Fetching stock data for {symbol}...")
                    r = requests.post(f"{base_url}/tools/finance_data_tools/fetch_stock_data/execute", 
                                     json=params, timeout=30)
                    if r.ok:
                        result = r.json()
                        if json_output:
                            print(json.dumps(result))
                        else:
                            print(f"✓ Retrieved {len(result.get('data', []))} data points for {symbol}")
                            print(json.dumps(result, indent=2))
                    else:
                        print(f"Error: {r.status_code} - {r.text}")
                    return
                
                elif subcommand == "news":
                    # Scrape financial news
                    query = args[2] if len(args) > 2 else "financial news"
                    sources = ["reuters", "bloomberg", "ap"]
                    max_results = 100
                    
                    i = 3
                    while i < len(args):
                        if args[i] == "--sources" and i + 1 < len(args):
                            sources = args[i + 1].split(",")
                            i += 2
                        elif args[i] == "--max-results" and i + 1 < len(args):
                            max_results = int(args[i + 1])
                            i += 2
                        else:
                            i += 1
                    
                    params = {
                        "query": query,
                        "sources": sources,
                        "max_results": max_results
                    }
                    
                    print(f"Scraping news for '{query}' from {', '.join(sources)}...")
                    r = requests.post(f"{base_url}/tools/finance_data_tools/fetch_financial_news/execute",
                                     json=params, timeout=60)
                    if r.ok:
                        result = r.json()
                        if json_output:
                            print(json.dumps(result))
                        else:
                            articles = result.get('articles', [])
                            print(f"✓ Retrieved {len(articles)} articles")
                            for art in articles[:5]:
                                print(f"  - {art.get('title', 'Untitled')} ({art.get('source', 'Unknown')})")
                    else:
                        print(f"Error: {r.status_code} - {r.text}")
                    return
                
                elif subcommand == "executives":
                    # Analyze executive performance
                    print("Executive performance analysis requires news and stock data files")
                    print("Usage: ipfs-datasets finance executives --news news.json --stocks stocks.json")
                    print("       --hypothesis 'Female CEOs outperform male CEOs'")
                    print("       --attribute gender --group-a female --group-b male")
                    
                    news_file = None
                    stocks_file = None
                    hypothesis = None
                    attribute = None
                    group_a = None
                    group_b = None
                    
                    i = 2
                    while i < len(args):
                        if args[i] == "--news" and i + 1 < len(args):
                            news_file = args[i + 1]
                            i += 2
                        elif args[i] == "--stocks" and i + 1 < len(args):
                            stocks_file = args[i + 1]
                            i += 2
                        elif args[i] == "--hypothesis" and i + 1 < len(args):
                            hypothesis = args[i + 1]
                            i += 2
                        elif args[i] == "--attribute" and i + 1 < len(args):
                            attribute = args[i + 1]
                            i += 2
                        elif args[i] == "--group-a" and i + 1 < len(args):
                            group_a = args[i + 1]
                            i += 2
                        elif args[i] == "--group-b" and i + 1 < len(args):
                            group_b = args[i + 1]
                            i += 2
                        else:
                            i += 1
                    
                    if news_file and stocks_file and hypothesis:
                        with open(news_file) as f:
                            news_data = json.load(f)
                        with open(stocks_file) as f:
                            stock_data = json.load(f)
                        
                        params = {
                            "news_articles_json": json.dumps(news_data),
                            "stock_data_json": json.dumps(stock_data),
                            "hypothesis": hypothesis,
                            "attribute": attribute,
                            "group_a": group_a,
                            "group_b": group_b
                        }
                        
                        print(f"Testing hypothesis: {hypothesis}...")
                        r = requests.post(f"{base_url}/tools/finance_data_tools/analyze_executive_performance/execute",
                                         json=params, timeout=120)
                        if r.ok:
                            result = r.json()
                            if json_output:
                                print(json.dumps(result))
                            else:
                                print(f"✓ Analysis complete")
                                print(json.dumps(result, indent=2))
                        else:
                            print(f"Error: {r.status_code} - {r.text}")
                    return
                
                elif subcommand == "embeddings":
                    # Multimodal embedding analysis
                    print("Embedding analysis requires news data file")
                    print("Usage: ipfs-datasets finance embeddings --news news.json")
                    print("       [--multimodal] [--clusters N]")
                    
                    news_file = None
                    multimodal = False
                    clusters = 10
                    
                    i = 2
                    while i < len(args):
                        if args[i] == "--news" and i + 1 < len(args):
                            news_file = args[i + 1]
                            i += 2
                        elif args[i] == "--multimodal":
                            multimodal = True
                            i += 1
                        elif args[i] == "--clusters" and i + 1 < len(args):
                            clusters = int(args[i + 1])
                            i += 2
                        else:
                            i += 1
                    
                    if news_file:
                        with open(news_file) as f:
                            news_data = json.load(f)
                        
                        params = {
                            "news_articles_json": json.dumps(news_data),
                            "enable_multimodal": multimodal,
                            "n_clusters": clusters
                        }
                        
                        print(f"Analyzing embeddings ({'multimodal' if multimodal else 'text-only'})...")
                        r = requests.post(f"{base_url}/tools/finance_data_tools/analyze_embedding_market_correlation/execute",
                                         json=params, timeout=120)
                        if r.ok:
                            result = r.json()
                            if json_output:
                                print(json.dumps(result))
                            else:
                                print(f"✓ Embedding analysis complete")
                                print(json.dumps(result, indent=2))
                        else:
                            print(f"Error: {r.status_code} - {r.text}")
                    return
                
                elif subcommand == "theorems":
                    # List or apply financial theorems
                    action = args[2] if len(args) > 2 else "list"
                    
                    if action == "--list" or action == "list":
                        print("Fetching financial theorems...")
                        r = requests.post(f"{base_url}/tools/finance_data_tools/list_financial_theorems/execute",
                                         json={}, timeout=30)
                        if r.ok:
                            result = r.json()
                            if json_output:
                                print(json.dumps(result))
                            else:
                                theorems = result.get('theorems', [])
                                print(f"✓ Found {len(theorems)} financial theorems:")
                                for thm in theorems:
                                    print(f"  - {thm.get('theorem_id', 'unknown')}: {thm.get('name', 'Unnamed')}")
                                    print(f"    Confidence: {thm.get('confidence_level', 0):.0%}")
                        else:
                            print(f"Error: {r.status_code} - {r.text}")
                    elif action == "--apply" or action == "apply":
                        theorem_id = args[3] if len(args) > 3 else None
                        data_file = None
                        
                        i = 4
                        while i < len(args):
                            if args[i] == "--data" and i + 1 < len(args):
                                data_file = args[i + 1]
                                i += 2
                            else:
                                i += 1
                        
                        if theorem_id and data_file:
                            with open(data_file) as f:
                                event_data = json.load(f)
                            
                            params = {
                                "theorem_id": theorem_id,
                                "event_data_json": json.dumps(event_data)
                            }
                            
                            print(f"Applying theorem {theorem_id}...")
                            r = requests.post(f"{base_url}/tools/finance_data_tools/apply_financial_theorem/execute",
                                             json=params, timeout=30)
                            if r.ok:
                                result = r.json()
                                if json_output:
                                    print(json.dumps(result))
                                else:
                                    print(f"✓ Theorem applied")
                                    print(json.dumps(result, indent=2))
                            else:
                                print(f"Error: {r.status_code} - {r.text}")
                        else:
                            print("Usage: ipfs-datasets finance theorems apply <THEOREM_ID> --data event.json")
                    return
                
                elif subcommand == "workflow":
                    # Execute workflow pipeline
                    pipeline_type = args[2] if len(args) > 2 else None
                    
                    if pipeline_type == "pipeline":
                        print("Workflow pipeline execution")
                        print("This would orchestrate the complete pipeline:")
                        print("  1. Scrape financial data (stocks + news)")
                        print("  2. Filter and label data")
                        print("  3. Analyze with embeddings and knowledge graphs")
                        print("  4. Generate and test hypotheses")
                        print("  5. Transform and augment data")
                        print("  6. Export synthetic dataset")
                        print()
                        print("Visit http://{}:{}/mcp/finance/workflow for interactive pipeline".format(host, port))
                    else:
                        print("Usage: ipfs-datasets finance workflow pipeline [--config FILE]")
                    return
                
                else:
                    print(f"Unknown finance subcommand: {subcommand}")
                    print("Run 'ipfs-datasets finance --help' for usage")
                    return
                
            except ImportError as e:
                print(f"Error: Missing dependencies for finance tools: {e}")
                print("Install with: pip install requests")
                return
            except Exception as e:
                print(f"Error executing finance command: {e}")
                import traceback
                traceback.print_exc()
                return
        
        if command == "p2p":
            # P2P workflow scheduling commands
            subcommand = args[1] if len(args) > 1 else "status"
            
            try:
                # Import directly to avoid mcp_server dependencies
                import importlib.util
                tools_path = PathLib(__file__).parent / "ipfs_datasets_py" / "mcp_server" / "tools" / "p2p_workflow_tools" / "p2p_workflow_tools.py"
                spec = importlib.util.spec_from_file_location("p2p_workflow_tools", tools_path)
                p2p_tools_module = importlib.util.module_from_spec(spec)
                spec.loader.exec_module(p2p_tools_module)
                
                initialize_p2p_scheduler = p2p_tools_module.initialize_p2p_scheduler
                schedule_p2p_workflow = p2p_tools_module.schedule_p2p_workflow
                get_next_p2p_workflow = p2p_tools_module.get_next_p2p_workflow
                add_p2p_peer = p2p_tools_module.add_p2p_peer
                remove_p2p_peer = p2p_tools_module.remove_p2p_peer
                get_p2p_scheduler_status = p2p_tools_module.get_p2p_scheduler_status
                get_workflow_tags = p2p_tools_module.get_workflow_tags
                get_assigned_workflows = p2p_tools_module.get_assigned_workflows
                
                if subcommand == "init":
                    # Initialize P2P scheduler
                    extra = args[2:]
                    peer_id = None
                    peers = []
                    
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--peer-id", "-i") and i + 1 < len(extra):
                            peer_id = extra[i + 1]
                            i += 2
                        elif token in ("--peers", "-p") and i + 1 < len(extra):
                            peers = [p.strip() for p in extra[i + 1].split(',')]
                            i += 2
                        else:
                            i += 1
                    
                    result = anyio.run(initialize_p2p_scheduler(peer_id=peer_id, peers=peers))
                    
                    if json_output:
                        print(json.dumps(result, indent=2))
                    else:
                        if result['success']:
                            print(f"✓ {result['message']}")
                            status = result.get('status', {})
                            print(f"Peer ID: {status.get('peer_id', 'N/A')}")
                            print(f"Known peers: {status.get('num_peers', 0)}")
                            print(f"Queue size: {status.get('queue_size', 0)}")
                        else:
                            print(f"✗ Error: {result.get('error', 'Unknown error')}")
                    return
                
                elif subcommand == "schedule":
                    # Schedule a workflow
                    extra = args[2:]
                    workflow_id = None
                    name = None
                    tags = []
                    priority = 1.0
                    
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--id", "-i") and i + 1 < len(extra):
                            workflow_id = extra[i + 1]
                            i += 2
                        elif token in ("--name", "-n") and i + 1 < len(extra):
                            name = extra[i + 1]
                            i += 2
                        elif token in ("--tags", "-t") and i + 1 < len(extra):
                            tags = [t.strip() for t in extra[i + 1].split(',')]
                            i += 2
                        elif token in ("--priority", "-p") and i + 1 < len(extra):
                            try:
                                priority = float(extra[i + 1])
                            except ValueError:
                                print(f"Warning: Invalid priority value, using default 1.0")
                            i += 2
                        else:
                            i += 1
                    
                    if not workflow_id or not name:
                        print("Usage: ipfs-datasets p2p schedule --id ID --name NAME --tags TAGS [--priority PRIORITY]")
                        print("Tags: p2p_eligible, p2p_only, code_gen, web_scrape, data_processing")
                        return
                    
                    result = anyio.run(schedule_p2p_workflow(
                        workflow_id=workflow_id,
                        name=name,
                        tags=tags,
                        priority=priority
                    ))
                    
                    if json_output:
                        print(json.dumps(result, indent=2))
                    else:
                        if result['success']:
                            print(f"✓ Workflow {workflow_id} scheduled")
                            wf_result = result.get('result', {})
                            print(f"Assigned to: {wf_result.get('assigned_peer', 'N/A')}")
                            print(f"Is local: {wf_result.get('is_local', False)}")
                            if wf_result.get('is_local'):
                                print(f"Queue size: {wf_result.get('queue_size', 0)}")
                        else:
                            print(f"✗ Error: {result.get('error', 'Unknown error')}")
                    return
                
                elif subcommand == "next":
                    # Get next workflow from queue
                    result = anyio.run(get_next_p2p_workflow())
                    
                    if json_output:
                        print(json.dumps(result, indent=2))
                    else:
                        if result['success']:
                            workflow = result.get('workflow')
                            if workflow:
                                print(f"✓ Next workflow:")
                                print(f"ID: {workflow.get('workflow_id', 'N/A')}")
                                print(f"Name: {workflow.get('name', 'N/A')}")
                                print(f"Tags: {', '.join(workflow.get('tags', []))}")
                                print(f"Priority: {workflow.get('priority', 0)}")
                            else:
                                print("No workflows in queue")
                        else:
                            print(f"✗ Error: {result.get('error', 'Unknown error')}")
                    return
                
                elif subcommand == "status":
                    # Get scheduler status
                    result = anyio.run(get_p2p_scheduler_status())
                    
                    if json_output:
                        print(json.dumps(result, indent=2))
                    else:
                        if result['success']:
                            status = result.get('status', {})
                            print("P2P Scheduler Status:")
                            print(f"Peer ID: {status.get('peer_id', 'N/A')}")
                            print(f"Known peers: {status.get('num_peers', 0)}")
                            print(f"Queue size: {status.get('queue_size', 0)}")
                            print(f"Assigned workflows: {status.get('assigned_workflows', 0)}")
                            print(f"Total workflows: {status.get('total_workflows', 0)}")
                            clock = status.get('clock', {})
                            print(f"Clock counter: {clock.get('counter', 0)}")
                            print(f"Clock hash: {clock.get('hash', 'N/A')[:16]}...")
                        else:
                            print(f"✗ Error: {result.get('error', 'Unknown error')}")
                    return
                
                elif subcommand == "add-peer":
                    # Add a peer
                    extra = args[2:]
                    peer_id = extra[0] if extra else None
                    
                    if not peer_id:
                        print("Usage: ipfs-datasets p2p add-peer <peer-id>")
                        return
                    
                    result = anyio.run(add_p2p_peer(peer_id))
                    
                    if json_output:
                        print(json.dumps(result, indent=2))
                    else:
                        if result['success']:
                            print(f"✓ {result['message']}")
                            print(f"Total peers: {result.get('num_peers', 0)}")
                        else:
                            print(f"✗ Error: {result.get('error', 'Unknown error')}")
                    return
                
                elif subcommand == "remove-peer":
                    # Remove a peer
                    extra = args[2:]
                    peer_id = extra[0] if extra else None
                    
                    if not peer_id:
                        print("Usage: ipfs-datasets p2p remove-peer <peer-id>")
                        return
                    
                    result = anyio.run(remove_p2p_peer(peer_id))
                    
                    if json_output:
                        print(json.dumps(result, indent=2))
                    else:
                        if result['success']:
                            print(f"✓ {result['message']}")
                            print(f"Total peers: {result.get('num_peers', 0)}")
                        else:
                            print(f"✗ Error: {result.get('error', 'Unknown error')}")
                    return
                
                elif subcommand == "tags":
                    # List workflow tags
                    result = anyio.run(get_workflow_tags())
                    
                    if json_output:
                        print(json.dumps(result, indent=2))
                    else:
                        if result['success']:
                            print("Available workflow tags:")
                            descriptions = result.get('descriptions', {})
                            for tag in result.get('tags', []):
                                desc = descriptions.get(tag, '')
                                print(f"  {tag:20} - {desc}")
                        else:
                            print(f"✗ Error: {result.get('error', 'Unknown error')}")
                    return
                
                elif subcommand == "assigned":
                    # Get assigned workflows
                    result = anyio.run(get_assigned_workflows())
                    
                    if json_output:
                        print(json.dumps(result, indent=2))
                    else:
                        if result['success']:
                            workflows = result.get('assigned_workflows', [])
                            print(f"Assigned workflows ({result.get('count', 0)}):")
                            for wf_id in workflows:
                                print(f"  - {wf_id}")
                        else:
                            print(f"✗ Error: {result.get('error', 'Unknown error')}")
                    return
                
                else:
                    print(f"Unknown p2p subcommand: {subcommand}")
                    print("Available subcommands: init, schedule, next, status, add-peer, remove-peer, tags, assigned")
                    return
                
            except ImportError as e:
                print(f"P2P workflow tools not available: {e}")
                print("Make sure ipfs_datasets_py package is properly installed")
                return
            except Exception as e:
                print(f"Error executing p2p command: {e}")
                import traceback
                traceback.print_exc()
                return
        
        if command == "discord":
            """Handle Discord data export and analysis commands."""
            subcommand = args[1] if len(args) > 1 else None
            
            if not subcommand or subcommand in ['-h', '--help']:
                print("""
ipfs-datasets discord - Discord Data Export and Analysis

Usage: ipfs-datasets discord <subcommand> [options]

Subcommands:
  guilds        List accessible Discord servers
  channels      List channels in a server
  dms           List direct message channels
  export        Export a Discord channel
  export-guild  Export entire Discord server
  export-dms    Export all DMs (native exportdm command)
  export-all    Export all accessible content
  analyze       Analyze a Discord channel
  analyze-export Analyze exported Discord data
  status        Check Discord integration status
  install       Install DiscordChatExporter

Environment:
  DISCORD_TOKEN   Discord bot or user token (recommended)

Examples:
  ipfs-datasets discord guilds
  ipfs-datasets discord channels GUILD_ID
  ipfs-datasets discord export CHANNEL_ID --format Json
  ipfs-datasets discord export-dms --format HtmlDark
  ipfs-datasets discord export-guild GUILD_ID --threads all
  ipfs-datasets discord analyze CHANNEL_ID --types message_stats,user_activity
  ipfs-datasets discord status

For detailed help: ipfs-datasets discord <subcommand> --help
""")
                return
            
            try:
                # Import and delegate to discord_cli module
                from ipfs_datasets_py.cli.discord_cli import main as discord_main
                
                # Pass remaining args to discord CLI
                discord_args = args[1:]
                exit_code = discord_main(discord_args)
                sys.exit(exit_code)
                
            except ImportError as e:
                print(f"Error: Discord CLI module not available: {e}")
                print("Make sure ipfs_datasets_py package is properly installed")
                return
            except Exception as e:
                print(f"Error executing discord command: {e}")
                import traceback
                traceback.print_exc()
                return
        
        if command == "email":
            """Handle email ingestion and analysis commands."""
            subcommand = args[1] if len(args) > 1 else None
            
            if not subcommand or subcommand in ['-h', '--help']:
                print("""
ipfs-datasets email - Email Ingestion and Analysis

Usage: ipfs-datasets email <subcommand> [options]

Subcommands:
  test       Test email server connection
  folders    List IMAP mailbox folders
  export     Export emails from a folder
  parse      Parse an .eml file
  fetch      Fetch emails (no export)
  analyze    Analyze an email export file
  search     Search emails in an export file
  google-voice Parse Google Voice Takeout exports
  google-voice-vault Parse Google Workspace Vault Voice exports
  google-voice-data-export Parse Google Workspace Data Export Voice bundles / gs:// URIs
  google-voice-watch Watch a local folder and auto-hydrate new Voice exports
  google-voice-takeout-url Build a custom consumer Google Takeout URL for Voice exports
  google-voice-takeout-open Open the custom Takeout URL in Playwright
  google-voice-takeout-capture Open the custom Takeout URL and wait for an archive download
  google-voice-takeout-source Save Takeout page source HTML for data-id inference
  google-voice-takeout-poll Poll a local download directory for a completed Takeout archive
  google-voice-takeout-drive Poll Google Drive for a Takeout artifact and optionally download it
  google-voice-takeout-status Summarize a saved Takeout acquisition manifest
  google-voice-takeout-doctor Diagnose a saved Takeout acquisition manifest and suggest the next step
  google-voice-takeout-history List archived snapshot history for a Takeout acquisition manifest
  google-voice-takeout-prune Prune old archived snapshot history for a Takeout acquisition manifest
  google-voice-takeout-case-summary Show a concise summary for a Takeout case/download directory or manifest
  google-voice-takeout-case-report Export a markdown or HTML report for a Takeout case/download directory or manifest
  google-voice-takeout-case-bundle Collect the latest manifest, history snapshots, and case reports into one archival folder

Environment:
  EMAIL_USER   Email account username (recommended)
  EMAIL_PASS   Email account password (recommended)

Examples:
  ipfs-datasets email test --server imap.gmail.com --username user@gmail.com
  ipfs-datasets email folders --server imap.gmail.com
  ipfs-datasets email export --server imap.gmail.com --folder INBOX --format json
  ipfs-datasets email parse message.eml --output parsed.json
  ipfs-datasets email fetch --server imap.gmail.com --limit 10
  ipfs-datasets email analyze inbox_export.json
  ipfs-datasets email search inbox_export.json "meeting" --field subject
  ipfs-datasets email google-voice ./Takeout/Voice --summary-only
  ipfs-datasets email google-voice ./Takeout/Voice --materialize --output-dir ./voice-bundles
  ipfs-datasets email google-voice-takeout-url --product-id voice --dest drive
  ipfs-datasets email google-voice-takeout-open --page-source ./takeout_page.html --dest drive
  ipfs-datasets email google-voice-takeout-capture --page-source ./takeout_page.html --dest drive --downloads-dir ./takeout-downloads
  ipfs-datasets email google-voice-takeout-source --output ./takeout_page.html
  ipfs-datasets email google-voice-takeout-poll --downloads-dir ./takeout-downloads
  ipfs-datasets email google-voice-takeout-drive --client-secrets ./google-client-secret.json --account-hint user@gmail.com --download-dir ./takeout-downloads
  ipfs-datasets email google-voice-takeout-status ./takeout_acquisition_manifest.json
  ipfs-datasets email google-voice-takeout-doctor ./takeout_acquisition_manifest.json
  ipfs-datasets email google-voice-takeout-history ./takeout_acquisition_manifest.json
  ipfs-datasets email google-voice-takeout-prune ./takeout_acquisition_manifest.json --keep 20
  ipfs-datasets email google-voice-takeout-case-summary ./takeout_acquisition_manifest.json
  ipfs-datasets email google-voice-takeout-case-report ./takeout_acquisition_manifest.json --format markdown --output ./takeout-report.md
  ipfs-datasets email google-voice-takeout-case-bundle ./takeout_acquisition_manifest.json --output-dir ./takeout-bundles
  ipfs-datasets email google-voice-vault ./vault-voice-export.zip --summary-only
  ipfs-datasets email google-voice-data-export gs://workspace-export/voice --materialize --output-dir ./voice-bundles --staging-dir ./gcs-stage
  ipfs-datasets email google-voice-watch ./dropbox --output-dir ./hydrated-voice --source-kind takeout --once

For detailed help: ipfs-datasets email <subcommand> --help
""")
                return
            
            try:
                import importlib.util
                from pathlib import Path

                email_cli_path = Path(__file__).resolve().parent / "ipfs_datasets_py" / "cli" / "email_cli.py"
                spec = importlib.util.spec_from_file_location("ipfs_datasets_email_cli", email_cli_path)
                if spec is None or spec.loader is None:
                    raise ImportError(f"Unable to load email CLI from {email_cli_path}")
                email_cli_module = importlib.util.module_from_spec(spec)
                spec.loader.exec_module(email_cli_module)
                email_main = email_cli_module.main
                
                # Pass remaining args to email CLI
                email_args = args[1:]
                exit_code = email_main(email_args)
                sys.exit(exit_code)
                
            except ImportError as e:
                print(f"Error: Email CLI module not available: {e}")
                print("Make sure ipfs_datasets_py package is properly installed")
                return
            except Exception as e:
                print(f"Error executing email command: {e}")
                import traceback
                traceback.print_exc()
                return

        if command == "history-index":
            """Handle DuckDB history index search commands."""
            subcommand = args[1] if len(args) > 1 else None

            if not subcommand or subcommand in ['-h', '--help']:
                print("""
ipfs-datasets history-index - Search the persisted DuckDB history index

Usage: ipfs-datasets history-index <query> [options]
       ipfs-datasets history-index --table entities <query> [options]

Options:
  --table {chunks,documents,entities,relationships}
  --index-path PATH
  --top-k N
  --source-like TEXT
  --json

Examples:
  ipfs-datasets history-index "inspection notice"
  ipfs-datasets history-index --table entities tenant
  ipfs-datasets history-index --table documents --source-like google_voice voice
""")
                return

            try:
                import importlib.util
                from pathlib import Path

                history_cli_path = Path(__file__).resolve().parent / "ipfs_datasets_py" / "cli" / "history_index_cli.py"
                spec = importlib.util.spec_from_file_location("ipfs_datasets_history_index_cli", history_cli_path)
                if spec is None or spec.loader is None:
                    raise ImportError(f"Unable to load history index CLI from {history_cli_path}")
                history_cli_module = importlib.util.module_from_spec(spec)
                spec.loader.exec_module(history_cli_module)
                history_index_main = history_cli_module.main

                history_args = list(args[1:])
                if json_output and '--json' not in history_args:
                    history_args = ['--json', *history_args]
                exit_code = history_index_main(history_args)
                sys.exit(exit_code)

            except ImportError as e:
                print(f"Error: history-index CLI module not available: {e}")
                print("Make sure ipfs_datasets_py package is properly installed")
                return
            except Exception as e:
                print(f"Error executing history-index command: {e}")
                import traceback
                traceback.print_exc()
                return

        if command == "docket":
            """Handle docket dataset import commands."""
            subcommand = args[1] if len(args) > 1 else None

            if not subcommand or subcommand in ['-h', '--help']:
                print("""
ipfs-datasets docket - Import, search, inspect, and package docket datasets

Usage: ipfs-datasets docket --input-type {auto,json,directory,courtlistener,pacer,tyler_host,packaged} --input-path PATH [options]

Options:
    --input-type {auto,json,directory,courtlistener,pacer,tyler_host,packaged}
    --input-path PATH
    --output PATH
    --source-type-hint {json,directory,courtlistener,pacer,tyler_host,packaged}
    --search-backend {bm25,vector}
    --query TEXT
    --top-k N
    --docket-id TEXT
    --case-name TEXT
    --court TEXT
    --glob PATTERN
    --skip-knowledge-graph
    --skip-bm25
    --skip-vector-index
    --vector-dimension N
    --packaged-action {summary,inspect,dashboard,report,dashboard-report,recap-fetch,recap-preflight}
    --citation-source-audit
    --json

Examples:
    ipfs-datasets docket --input-type auto --input-path ./docket_dir --output ./docket_dataset.json
    ipfs-datasets docket --input-type auto --input-path ./normalized_export.json --source-type-hint pacer --json
    ipfs-datasets docket --input-type json --input-path ./docket.json --output ./docket_dataset.json
    ipfs-datasets docket --input-type pacer --input-path ./pacer_export_dir --case-name "Doe v. Example" --json
    ipfs-datasets docket --input-type tyler_host --input-path ./tyler_export.json --court "State Court" --json
    ipfs-datasets docket --input-type json --input-path ./docket.json --search-backend bm25 --query injunction --top-k 5 --json
    ipfs-datasets docket --input-type packaged --input-path ./docket_package/bundle_manifest.json --search-backend vector --query response --top-k 5 --json
    ipfs-datasets docket --input-type packaged --input-path ./docket_package/bundle_manifest.json --packaged-action summary --json
""")
                return

            try:
                import importlib.util
                from pathlib import Path

                docket_cli_path = Path(__file__).resolve().parent / "ipfs_datasets_py" / "cli" / "docket_cli.py"
                spec = importlib.util.spec_from_file_location("ipfs_datasets_docket_cli", docket_cli_path)
                if spec is None or spec.loader is None:
                    raise ImportError(f"Unable to load docket CLI from {docket_cli_path}")
                docket_cli_module = importlib.util.module_from_spec(spec)
                spec.loader.exec_module(docket_cli_module)
                docket_main = docket_cli_module.main

                docket_args = list(args[1:])
                if json_output and '--json' not in docket_args:
                    docket_args = ['--json', *docket_args]
                exit_code = docket_main(docket_args)
                sys.exit(exit_code)

            except ImportError as e:
                print(f"Error: docket CLI module not available: {e}")
                print("Make sure ipfs_datasets_py package is properly installed")
                return
            except Exception as e:
                print(f"Error executing docket command: {e}")
                import traceback
                traceback.print_exc()
                return

        if command == "workspace":
            """Handle workspace dataset bundle inspection commands."""
            subcommand = args[1] if len(args) > 1 else None

            if not subcommand or subcommand in ['-h', '--help']:
                print("""
ipfs-datasets workspace - Inspect, search, export, and package workspace dataset bundles

Usage: ipfs-datasets workspace [--input-path PATH] [--action {summary,inspect,load,report,search-bm25,search-vector,export,package,package-summary,package-inspect,package-load,package-report,package-search-bm25,package-search-vector,chain,components}] [options]

Options:
    --input-path PATH
    --input-json PATH
    --input-directory PATH
    --input-type {workspace-json,directory,google-voice-manifest,discord-export,email-export,imap-snippet-summary}
                --action {summary,inspect,load,report,search-bm25,search-vector,export,package,package-summary,package-inspect,package-load,package-report,package-search-bm25,package-search-vector,chain,components}
    --output-parquet PATH
        --output-dir PATH
        --query TEXT
        --top-k N
  --fields FIELD1,FIELD2
    --report-format {markdown,text,json}
    --strict-evidence-mode
  --json

Examples:
  ipfs-datasets workspace --input-path ./workspace_bundle.parquet --action summary --json
  ipfs-datasets workspace --input-path ./workspace_bundle.parquet --action inspect --fields workspace_id,row_count,sections
  ipfs-datasets workspace --input-path ./workspace_bundle.parquet --action load --json
    ipfs-datasets workspace --input-path ./workspace_bundle.parquet --action search-bm25 --query inspection --top-k 5
    ipfs-datasets workspace --input-path ./workspace_bundle.parquet --action report --report-format markdown
        ipfs-datasets workspace --action export --input-path ./email_export.json --output-parquet ./email_bundle.parquet --json
        ipfs-datasets workspace --action package --input-path ./discord_export.json --output-dir ./workspace_package --package-name workspace_package --json
                ipfs-datasets workspace --input-path ./workspace_package/bundle_manifest.json --action package-search-bm25 --query inspection --top-k 5 --json
""")
                return

            try:
                import importlib.util
                from pathlib import Path

                workspace_cli_path = Path(__file__).resolve().parent / "ipfs_datasets_py" / "cli" / "workspace_cli.py"
                spec = importlib.util.spec_from_file_location("ipfs_datasets_workspace_cli", workspace_cli_path)
                if spec is None or spec.loader is None:
                    raise ImportError(f"Unable to load workspace CLI from {workspace_cli_path}")
                workspace_cli_module = importlib.util.module_from_spec(spec)
                spec.loader.exec_module(workspace_cli_module)
                workspace_main = workspace_cli_module.main

                workspace_args = list(args[1:])
                if json_output and '--json' not in workspace_args:
                    workspace_args = ['--json', *workspace_args]
                exit_code = workspace_main(workspace_args)
                sys.exit(exit_code)

            except ImportError as e:
                print(f"Error: workspace CLI module not available: {e}")
                print("Make sure ipfs_datasets_py package is properly installed")
                return
            except Exception as e:
                print(f"Error executing workspace command: {e}")
                import traceback
                traceback.print_exc()
                return

        if command == "legal-pdf":
            """Handle legal PDF rendering commands."""
            subcommand = args[1] if len(args) > 1 else None

            if not subcommand or subcommand in ['-h', '--help']:
                print("""
ipfs-datasets legal-pdf - Render legal PDF artifacts from shared package helpers

Usage: ipfs-datasets legal-pdf --action ACTION [options]

Actions:
  validate-manifest
  render-state-court
  render-state-court-batch
  build-court-filing-packet
  build-court-filing-packet-from-manifest
  build-exhibit-binder-from-manifest
  render-exhibit-tab
  render-exhibit-cover
  render-binder-title
  render-family-divider
  convert-source
  convert-markdown
  merge-pdfs
  count-pages
  build-exhibit-binder

Examples:
  ipfs-datasets legal-pdf --action validate-manifest --manifest-path ./court_packet_manifest.json --json
  ipfs-datasets legal-pdf --action count-pages --input-path ./packet.pdf --json
  ipfs-datasets legal-pdf --action build-court-filing-packet --input-paths a.md b.md --output-dir ./pdfs --packet-output-path ./packet.pdf --contact-block "..." --court-name "IN THE ..." --state-name "STATE OF OREGON" --caption-left "Plaintiff v. Defendant"
  ipfs-datasets legal-pdf --action build-court-filing-packet-from-manifest --manifest-path ./court_packet_manifest.json --json
  ipfs-datasets legal-pdf --action build-exhibit-binder-from-manifest --manifest-path ./exhibit_binder_manifest.json --json
  ipfs-datasets legal-pdf --action merge-pdfs --input-paths a.pdf b.pdf --output-path merged.pdf
  ipfs-datasets legal-pdf --action render-binder-title --output-path title.pdf --lean-mode
  ipfs-datasets legal-pdf --action build-exhibit-binder --front-pdf front.pdf --table-pdf table.pdf --packet-pdfs pkt1.pdf pkt2.pdf --output-path binder.pdf
""")
                return

            try:
                import importlib.util
                from pathlib import Path

                legal_pdf_cli_path = Path(__file__).resolve().parent / "ipfs_datasets_py" / "cli" / "legal_pdf_cli.py"
                spec = importlib.util.spec_from_file_location("ipfs_datasets_legal_pdf_cli", legal_pdf_cli_path)
                if spec is None or spec.loader is None:
                    raise ImportError(f"Unable to load legal PDF CLI from {legal_pdf_cli_path}")
                legal_pdf_cli_module = importlib.util.module_from_spec(spec)
                spec.loader.exec_module(legal_pdf_cli_module)
                legal_pdf_main = legal_pdf_cli_module.main

                legal_pdf_args = list(args[1:])
                if json_output and '--json' not in legal_pdf_args:
                    legal_pdf_args = ['--json', *legal_pdf_args]
                exit_code = legal_pdf_main(legal_pdf_args)
                sys.exit(exit_code)

            except ImportError as e:
                print(f"Error: legal PDF CLI module not available: {e}")
                print("Make sure ipfs_datasets_py package is properly installed")
                return
            except Exception as e:
                print(f"Error executing legal-pdf command: {e}")
                import traceback
                traceback.print_exc()
                return
        
        if command == "detect-type":
            # File type detection commands
            subcommand = args[1] if len(args) > 1 else "detect"
            
            try:
                from ipfs_datasets_py.utils.file_detector import FileTypeDetector
                
                detector = FileTypeDetector()
                
                if subcommand == "methods":
                    # List available detection methods
                    methods = detector.get_available_methods()
                    strategies = detector.get_supported_strategies()
                    
                    if json_output:
                        print(json.dumps({
                            "methods": methods,
                            "strategies": strategies
                        }, indent=2))
                    else:
                        print("Available detection methods:")
                        for method in methods:
                            print(f"  - {method}")
                        print("\nAvailable strategies:")
                        for strategy in strategies:
                            print(f"  - {strategy}")
                    return
                
                elif subcommand == "detect":
                    # Detect single file type
                    extra = args[2:]
                    file_path = None
                    methods = None
                    strategy = None
                    
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--method", "-m") and i + 1 < len(extra):
                            method_str = extra[i + 1]
                            methods = [m.strip() for m in method_str.split(',')]
                            i += 2
                        elif token in ("--strategy", "-s") and i + 1 < len(extra):
                            strategy = extra[i + 1]
                            i += 2
                        elif not file_path:
                            file_path = token
                            i += 1
                        else:
                            i += 1
                    
                    if not file_path:
                        print("Usage: ipfs-datasets detect-type detect <file> [--method METHOD] [--strategy STRATEGY]")
                        print("Methods: extension, magic, magika, all")
                        print("Strategies: fast, accurate, voting, conservative")
                        return
                    
                    result = detector.detect_type(file_path, methods=methods, strategy=strategy)
                    
                    if json_output:
                        print(json.dumps(result, indent=2))
                    else:
                        print(f"File: {file_path}")
                        print(f"MIME Type: {result.get('mime_type', 'Unknown')}")
                        print(f"Extension: {result.get('extension', 'Unknown')}")
                        print(f"Confidence: {result.get('confidence', 0):.2f}")
                        print(f"Method: {result.get('method', 'Unknown')}")
                        if result.get('error'):
                            print(f"Error: {result['error']}")
                        if result.get('all_results'):
                            print("\nAll results:")
                            for method_name, method_result in result['all_results'].items():
                                print(f"  {method_name}: {method_result.get('mime_type', 'N/A')} (confidence: {method_result.get('confidence', 0):.2f})")
                    return
                
                elif subcommand == "batch":
                    # Batch detect multiple files
                    extra = args[2:]
                    file_paths = []
                    methods = None
                    strategy = None
                    directory = None
                    recursive = False
                    pattern = "*"
                    export_path = None
                    
                    i = 0
                    while i < len(extra):
                        token = extra[i]
                        if token in ("--method", "-m") and i + 1 < len(extra):
                            method_str = extra[i + 1]
                            methods = [m.strip() for m in method_str.split(',')]
                            i += 2
                        elif token in ("--strategy", "-s") and i + 1 < len(extra):
                            strategy = extra[i + 1]
                            i += 2
                        elif token in ("--directory", "-d") and i + 1 < len(extra):
                            directory = extra[i + 1]
                            i += 2
                        elif token in ("--recursive", "-r"):
                            recursive = True
                            i += 1
                        elif token in ("--pattern", "-p") and i + 1 < len(extra):
                            pattern = extra[i + 1]
                            i += 2
                        elif token in ("--export", "-e") and i + 1 < len(extra):
                            export_path = extra[i + 1]
                            i += 2
                        else:
                            if os.path.exists(token):
                                file_paths.append(token)
                            i += 1
                    
                    # If directory specified, collect files from it
                    if directory:
                        from pathlib import Path
                        dir_path = Path(directory)
                        if dir_path.is_dir():
                            if recursive:
                                file_paths.extend([str(p) for p in dir_path.rglob(pattern)])
                            else:
                                file_paths.extend([str(p) for p in dir_path.glob(pattern)])
                        else:
                            print(f"Error: {directory} is not a directory")
                            return
                    
                    if not file_paths:
                        print("Usage: ipfs-datasets detect-type batch <file1> <file2> ... [OPTIONS]")
                        print("       ipfs-datasets detect-type batch --directory DIR [--recursive] [OPTIONS]")
                        print("Options:")
                        print("  --method, -m METHOD      Detection methods (comma-separated)")
                        print("  --strategy, -s STRATEGY  Detection strategy")
                        print("  --directory, -d DIR      Directory to scan")
                        print("  --recursive, -r          Scan directory recursively")
                        print("  --pattern, -p PATTERN    File pattern (default: *)")
                        print("  --export, -e PATH        Export results to JSON file")
                        return
                    
                    results = detector.batch_detect(file_paths, methods=methods, strategy=strategy)
                    
                    # Export to file if requested
                    if export_path:
                        with open(export_path, 'w') as f:
                            json.dump(results, f, indent=2)
                        print(f"Results exported to {export_path}")
                    
                    if json_output:
                        print(json.dumps(results, indent=2))
                    else:
                        print(f"Analyzed {len(results)} files:\n")
                        for file_path, result in results.items():
                            mime_type = result.get('mime_type', 'Unknown')
                            confidence = result.get('confidence', 0)
                            method = result.get('method', 'Unknown')
                            print(f"{file_path}:")
                            print(f"  Type: {mime_type}")
                            print(f"  Confidence: {confidence:.2f}")
                            print(f"  Method: {method}")
                            if result.get('error'):
                                print(f"  Error: {result['error']}")
                            print()
                    return
                
                else:
                    print(f"Unknown detect-type subcommand: {subcommand}")
                    print("Available subcommands: detect, batch, methods")
                    return
                    
            except ImportError as e:
                print(f"Error: FileTypeDetector module not available: {e}")
                return
            except Exception as e:
                print(f"Error executing detect-type command: {e}")
                import traceback
                traceback.print_exc()
                return
        
        # Handle common-crawl commands
        if command in ['common-crawl', 'cc']:
            try:
                from ipfs_datasets_py.cli.common_crawl_cli import handle_common_crawl_command
                handle_common_crawl_command(args)
                return
            except ImportError as e:
                print(f"Error: Common Crawl CLI module not available: {e}")
                return
            except Exception as e:
                print(f"Error executing common-crawl command: {e}")
                import traceback
                traceback.print_exc()
                return
        
        # Handle knowledge graph commands
        if command == 'graph':
            try:
                import asyncio
                from ipfs_datasets_py.core_operations import KnowledgeGraphManager
                
                subcommand = args[1] if len(args) > 1 else None
                if not subcommand:
                    print("Usage: ipfs-datasets graph <subcommand> [options]")
                    print("Subcommands: create, add-entity, add-rel, query, search, tx-begin, tx-commit, tx-rollback, index, constraint")
                    print("For help: ipfs-datasets graph --help")
                    return
                
                # Parse common options
                driver_url = None
                extra_args = args[2:]
                kwargs = parse_tool_args(extra_args)
                
                # Get driver URL from kwargs or default
                driver_url = kwargs.pop('driver_url', kwargs.pop('driver-url', None)) or "ipfs://localhost:5001"
                
                # Create manager
                manager = KnowledgeGraphManager(driver_url=driver_url)
                
                # Handle subcommands
                if subcommand == 'create':
                    result = anyio.run(manager.create_graph)
                    print_result(result, "json" if json_output else "pretty")
                    
                elif subcommand == 'add-entity':
                    entity_id = kwargs.get('id', kwargs.get('entity_id'))
                    entity_type = kwargs.get('type', kwargs.get('entity_type'))
                    properties = kwargs.get('props', kwargs.get('properties', {}))
                    
                    if not entity_id or not entity_type:
                        print("Error: --id and --type are required")
                        print("Usage: ipfs-datasets graph add-entity --id ID --type TYPE [--props JSON]")
                        return
                    
                    # Parse properties if it's a JSON string
                    if isinstance(properties, str):
                        try:
                            properties = json.loads(properties)
                        except:
                            print(f"Warning: Could not parse properties as JSON: {properties}")
                            properties = {}
                    
                    result = anyio.run(manager.add_entity, entity_id, entity_type, properties)
                    print_result(result, "json" if json_output else "pretty")
                    
                elif subcommand in ['add-rel', 'add-relationship']:
                    source_id = kwargs.get('source', kwargs.get('source_id'))
                    target_id = kwargs.get('target', kwargs.get('target_id'))
                    rel_type = kwargs.get('type', kwargs.get('rel_type'))
                    properties = kwargs.get('props', kwargs.get('properties', {}))
                    
                    if not source_id or not target_id or not rel_type:
                        print("Error: --source, --target, and --type are required")
                        print("Usage: ipfs-datasets graph add-rel --source ID1 --target ID2 --type TYPE [--props JSON]")
                        return
                    
                    # Parse properties if it's a JSON string
                    if isinstance(properties, str):
                        try:
                            properties = json.loads(properties)
                        except:
                            properties = {}
                    
                    result = anyio.run(manager.add_relationship, source_id, target_id, rel_type, properties)
                    print_result(result, "json" if json_output else "pretty")
                    
                elif subcommand == 'query':
                    cypher = kwargs.get('cypher', kwargs.get('query'))
                    parameters = kwargs.get('params', kwargs.get('parameters', {}))
                    
                    if not cypher:
                        print("Error: --cypher is required")
                        print("Usage: ipfs-datasets graph query --cypher 'MATCH (n) RETURN n LIMIT 10' [--params JSON]")
                        return
                    
                    # Parse parameters if it's a JSON string
                    if isinstance(parameters, str):
                        try:
                            parameters = json.loads(parameters)
                        except:
                            parameters = {}
                    
                    result = anyio.run(manager.query_cypher, cypher, parameters)
                    print_result(result, "json" if json_output else "pretty")
                    
                elif subcommand == 'search':
                    query = kwargs.get('query', kwargs.get('q'))
                    search_type = kwargs.get('type', 'hybrid')
                    limit = int(kwargs.get('limit', 10))
                    
                    if not query:
                        print("Error: --query is required")
                        print("Usage: ipfs-datasets graph search --query 'search text' [--type hybrid|semantic|keyword] [--limit N]")
                        return
                    
                    result = anyio.run(manager.search_hybrid, query, search_type, limit)
                    print_result(result, "json" if json_output else "pretty")
                    
                elif subcommand == 'tx-begin':
                    result = anyio.run(manager.transaction_begin)
                    print_result(result, "json" if json_output else "pretty")
                    
                elif subcommand == 'tx-commit':
                    tx_id = kwargs.get('tx_id', kwargs.get('id'))
                    if not tx_id:
                        print("Error: --tx-id is required")
                        print("Usage: ipfs-datasets graph tx-commit --tx-id ID")
                        return
                    result = anyio.run(manager.transaction_commit, tx_id)
                    print_result(result, "json" if json_output else "pretty")
                    
                elif subcommand == 'tx-rollback':
                    tx_id = kwargs.get('tx_id', kwargs.get('id'))
                    if not tx_id:
                        print("Error: --tx-id is required")
                        print("Usage: ipfs-datasets graph tx-rollback --tx-id ID")
                        return
                    result = anyio.run(manager.transaction_rollback, tx_id)
                    print_result(result, "json" if json_output else "pretty")
                    
                elif subcommand == 'index':
                    label = kwargs.get('label')
                    property_key = kwargs.get('property', kwargs.get('prop'))
                    
                    if not label or not property_key:
                        print("Error: --label and --property are required")
                        print("Usage: ipfs-datasets graph index --label LABEL --property PROP")
                        return
                    
                    result = anyio.run(manager.create_index, label, property_key)
                    print_result(result, "json" if json_output else "pretty")
                    
                elif subcommand == 'constraint':
                    label = kwargs.get('label')
                    property_key = kwargs.get('property', kwargs.get('prop'))
                    constraint_type = kwargs.get('type', 'unique')
                    
                    if not label or not property_key:
                        print("Error: --label and --property are required")
                        print("Usage: ipfs-datasets graph constraint --label LABEL --property PROP [--type unique|exists]")
                        return
                    
                    result = anyio.run(manager.add_constraint, label, property_key, constraint_type)
                    print_result(result, "json" if json_output else "pretty")
                    
                else:
                    print(f"Unknown graph subcommand: {subcommand}")
                    print("Available subcommands: create, add-entity, add-rel, query, search, tx-begin, tx-commit, tx-rollback, index, constraint")
                
                return
                
            except ImportError as e:
                print(f"Error: Knowledge graph module not available: {e}")
                print("Try: pip install -e . to install all dependencies")
                return
            except Exception as e:
                print(f"Error executing graph command: {e}")
                import traceback
                traceback.print_exc()
                return
        
        # Handle dataset commands
        if command == 'dataset':
            try:
                from ipfs_datasets_py.core_operations import DataProcessor
                
                subcommand = args[1] if len(args) > 1 else None
                if not subcommand:
                    print("Usage: ipfs-datasets dataset <subcommand> [options]")
                    print("Subcommands: validate, info, list, process")
                    print("For help: ipfs-datasets dataset --help")
                    return
                
                # Parse common options
                extra_args = args[2:]
                kwargs = parse_tool_args(extra_args)
                
                # Create processor
                processor = DataProcessor()
                
                # Handle subcommands
                if subcommand == 'validate':
                    path = kwargs.get('path')
                    if not path:
                        print("Error: --path is required")
                        print("Usage: ipfs-datasets dataset validate --path PATH")
                        return
                    
                    # Validate dataset
                    result = {
                        "valid": True,
                        "path": path,
                        "message": "Dataset validation successful"
                    }
                    
                    try:
                        import os
                        if not os.path.exists(path):
                            result = {
                                "valid": False,
                                "path": path,
                                "error": "Path does not exist"
                            }
                    except Exception as e:
                        result = {
                            "valid": False,
                            "path": path,
                            "error": str(e)
                        }
                    
                    print_result(result, "json" if json_output else "pretty")
                    
                elif subcommand == 'info':
                    name = kwargs.get('name')
                    if not name:
                        print("Error: --name is required")
                        print("Usage: ipfs-datasets dataset info --name NAME")
                        return
                    
                    # Get dataset info
                    result = {
                        "name": name,
                        "status": "available",
                        "info": "Dataset information retrieval would go here"
                    }
                    print_result(result, "json" if json_output else "pretty")
                    
                elif subcommand == 'list':
                    # List available datasets
                    result = {
                        "datasets": [],
                        "message": "Dataset listing would go here"
                    }
                    print_result(result, "json" if json_output else "pretty")
                    
                elif subcommand == 'process':
                    input_path = kwargs.get('input')
                    output_path = kwargs.get('output')
                    
                    if not input_path or not output_path:
                        print("Error: --input and --output are required")
                        print("Usage: ipfs-datasets dataset process --input PATH --output PATH")
                        return
                    
                    # Process dataset
                    result = {
                        "input": input_path,
                        "output": output_path,
                        "status": "processed",
                        "message": "Dataset processing would go here"
                    }
                    print_result(result, "json" if json_output else "pretty")
                    
                else:
                    print(f"Unknown dataset subcommand: {subcommand}")
                    print("Available subcommands: validate, info, list, process")
                    return
                
                return
                
            except ImportError as e:
                print(f"Error: Dataset module not available: {e}")
                print("Try: pip install -e . to install all dependencies")
                return
            except Exception as e:
                print(f"Error executing dataset command: {e}")
                import traceback
                traceback.print_exc()
                return
        
        # Handle search commands
        if command == 'search':
            try:
                subcommand = args[1] if len(args) > 1 else None
                if not subcommand:
                    print("Usage: ipfs-datasets search <subcommand> <query> [options]")
                    print("Subcommands: basic, semantic, hybrid")
                    print("For help: ipfs-datasets search --help")
                    return
                
                # Parse query and options
                query = args[2] if len(args) > 2 else None
                if not query:
                    print(f"Error: query is required for search {subcommand}")
                    print(f"Usage: ipfs-datasets search {subcommand} <query> [options]")
                    return
                
                extra_args = args[3:]
                kwargs = parse_tool_args(extra_args)
                
                # Handle subcommands
                if subcommand == 'basic':
                    # Basic text search
                    result = {
                        "query": query,
                        "type": "basic",
                        "results": [],
                        "message": "Basic search functionality would go here"
                    }
                    print_result(result, "json" if json_output else "pretty")
                    
                elif subcommand == 'semantic':
                    # Semantic vector search
                    result = {
                        "query": query,
                        "type": "semantic",
                        "results": [],
                        "message": "Semantic search functionality would go here"
                    }
                    print_result(result, "json" if json_output else "pretty")
                    
                elif subcommand == 'hybrid':
                    # Hybrid search (basic + semantic)
                    result = {
                        "query": query,
                        "type": "hybrid",
                        "results": [],
                        "message": "Hybrid search functionality would go here"
                    }
                    print_result(result, "json" if json_output else "pretty")
                    
                else:
                    print(f"Unknown search subcommand: {subcommand}")
                    print("Available subcommands: basic, semantic, hybrid")
                    return
                
                return
                
            except ImportError as e:
                print(f"Error: Search module not available: {e}")
                print("Try: pip install -e . to install all dependencies")
                return
            except Exception as e:
                print(f"Error executing search command: {e}")
                import traceback
                traceback.print_exc()
                return
        
        print(f"Command '{' '.join(args)}' requires full system - importing modules...")
        
        # For complex operations, import the full original functionality
    # Heavy subsystem imports would go here when needed
        # Continue with heavy operations...
        
    except ImportError as e:
        print(f"Error: Missing dependencies for command '{' '.join(args)}': {e}")
        print("Try: pip install -e . to install all dependencies")
    except Exception as e:
        print(f"Error executing command: {e}")


def main():
    """Main CLI entry point - lightweight by default."""
    args = sys.argv[1:]
    # Global format flag support
    json_output = False
    if '--format' in args:
        try:
            idx = args.index('--format')
            if idx + 1 < len(args) and args[idx + 1].lower() == 'json':
                json_output = True
                # Remove the pair from args
                args = args[:idx] + args[idx+2:]
        except Exception:
            pass
    if '--json' in args:
        json_output = True
        args = [a for a in args if a != '--json']
    
    # Handle help and version immediately without any imports
    if not args or args[0] in ['-h', '--help', 'help']:
        show_help()
        return
        
    if args[0] in ['--version', 'version']:
        show_version()
        return
    
    # Handle basic info commands without heavy imports
    if args[0] == 'info':
        if len(args) > 1:
            sub = args[1]
            if sub == 'status':
                # Parse optional overrides to reflect resolved defaults in JSON
                config_override = None
                host_override = None
                port_override = None
                gateway_override = None
                extra = args[2:]
                i = 0
                while i < len(extra):
                    token = extra[i]
                    if token == '--config' and i + 1 < len(extra):
                        config_override = extra[i + 1]
                        i += 2
                    elif token in ('--host', '-H') and i + 1 < len(extra):
                        host_override = str(extra[i + 1])
                        i += 2
                    elif token in ('--port', '-p') and i + 1 < len(extra):
                        port_override = str(extra[i + 1])
                        i += 2
                    elif token in ('--gateway', '-g') and i + 1 < len(extra):
                        gateway_override = extra[i + 1]
                        i += 2
                    else:
                        i += 1

                host_res, port_res = _default_host_port(config_override)
                if host_override:
                    host_res = host_override
                if port_override:
                    port_res = port_override
                gateway_res = _default_gateway(config_override, gateway_override)

                if json_output:
                    out = {
                        "status": "success",
                        "message": "CLI available",
                        "version": "1.0.0",
                        "python": sys.version.split()[0],
                        "host": host_res,
                        "port": port_res,
                        "gateway": gateway_res,
                        "dashboard_status_url": f"http://{host_res}:{port_res}/api/mcp/status",
                        "dashboard_url": f"http://{host_res}:{port_res}/mcp"
                    }
                    print(json.dumps(out))
                else:
                    print("Success! CLI is available")
                    print("System Status: CLI tool is available")
                    print("Version: 1.0.0")
                    print("Python:", sys.version.split()[0])
                    print(f"Host: {host_res}")
                    print(f"Port: {port_res}")
                    print(f"Gateway: {gateway_res or 'None'}")
                    print(f"Dashboard: http://{host_res}:{port_res}/mcp")
                    print(f"Status API: http://{host_res}:{port_res}/api/mcp/status")
                return
            if sub == 'version':
                if json_output:
                    print(json.dumps({"version": "1.0.0"}))
                else:
                    show_version()
                return
            if sub == 'defaults':
                # Parse options for host/port/gateway/config
                config_override = None
                host_override = None
                port_override = None
                gateway_override = None
                extra = args[2:]
                i = 0
                while i < len(extra):
                    token = extra[i]
                    if token == '--config' and i + 1 < len(extra):
                        config_override = extra[i + 1]
                        i += 2
                    elif token in ('--host', '-H') and i + 1 < len(extra):
                        host_override = str(extra[i + 1])
                        i += 2
                    elif token in ('--port', '-p') and i + 1 < len(extra):
                        port_override = str(extra[i + 1])
                        i += 2
                    elif token in ('--gateway', '-g') and i + 1 < len(extra):
                        gateway_override = extra[i + 1]
                        i += 2
                    else:
                        i += 1

                # Resolve with precedence: flags > env > config > defaults
                host, port = _default_host_port(config_override)
                if host_override:
                    host = host_override
                if port_override:
                    port = port_override
                gateway = _default_gateway(config_override, gateway_override)

                if json_output:
                    print(json.dumps({
                        "host": host,
                        "port": port,
                        "gateway": gateway
                    }))
                else:
                    print(f"Host: {host}")
                    print(f"Port: {port}")
                    print(f"Gateway: {gateway or 'None'}")
                return
            if sub == 'save-defaults':
                # Persist host/port/gateway to config file
                config_path = None
                host_val = None
                port_val = None
                gateway_val = None
                extra = args[2:]
                i = 0
                while i < len(extra):
                    token = extra[i]
                    if token == '--config' and i + 1 < len(extra):
                        config_path = extra[i + 1]
                        i += 2
                    elif token in ('--host', '-H') and i + 1 < len(extra):
                        host_val = str(extra[i + 1])
                        i += 2
                    elif token in ('--port', '-p') and i + 1 < len(extra):
                        port_val = str(extra[i + 1])
                        i += 2
                    elif token in ('--gateway', '-g') and i + 1 < len(extra):
                        gateway_val = extra[i + 1]
                        i += 2
                    else:
                        i += 1

                # Resolve current defaults then override with provided values
                default_host, default_port = _default_host_port(config_path)
                resolved_host = host_val or default_host
                resolved_port = port_val or default_port
                resolved_gateway = _default_gateway(config_path, gateway_val)

                # Determine config file path
                if not config_path:
                    env_cfg = os.environ.get("IPFS_DATASETS_CLI_CONFIG")
                    config_path = env_cfg if env_cfg else str(Path.home() / ".ipfs_datasets" / "cli.json")

                try:
                    cfg_path = Path(config_path)
                    cfg_path.parent.mkdir(parents=True, exist_ok=True)
                    data = {
                        "host": str(resolved_host),
                        "port": str(resolved_port),
                        **({"gateway": str(resolved_gateway)} if resolved_gateway else {})
                    }
                    cfg_path.write_text(json.dumps(data, indent=2))
                    if json_output:
                        print(json.dumps({"status": "saved", "path": str(cfg_path), **data}))
                    else:
                        print(f"Saved defaults to {cfg_path}")
                        print(f"Host: {resolved_host}")
                        print(f"Port: {resolved_port}")
                        print(f"Gateway: {resolved_gateway or 'None'}")
                except Exception as e:
                    if json_output:
                        print(json.dumps({"status": "error", "error": str(e)}))
                    else:
                        print(f"Failed to save defaults: {e}")
                return
            if sub in ['list-tools', 'listtools', 'tools']:
                # Minimal categories view without heavy imports
                cats = [
                    'dataset_tools', 'ipfs_tools', 'vector_tools', 'analysis_tools'
                ]
                if json_output:
                    print(json.dumps({"categories": cats}))
                else:
                    print("Available tool categories:")
                    for c in cats:
                        print(f"- {c}")
                return
    
    # For other known command families, use heavy import function
    if args[0] in ['mcp', 'tools', 'ipfs', 'dataset', 'alerts', 'vector', 'graph', 'search', 'logic', 'legal', 'legal-pdf', 'workflow-automation', 'p2p-networking', 'vscode', 'github', 'gemini', 'claude', 'finance', 'detect-type', 'p2p', 'discord', 'email', 'history-index', 'docket', 'workspace', 'copilot', 'common-crawl', 'cc']:
        heavy_args = list(args)
        if json_output and '--json' not in heavy_args:
            heavy_args = ['--json', *heavy_args]
        execute_heavy_command(heavy_args)
        return

    # Unknown command
    print(f"Error: unknown command: {' '.join(args)}")
    sys.exit(2)


def cli_main():
    """Entry point wrapper for console scripts."""
    try:
        main()
    except KeyboardInterrupt:
        print("\nInterrupted by user")
        sys.exit(1)
    except Exception as e:
        print(f"Error: {e}")
        sys.exit(1)


if __name__ == "__main__":
    cli_main()