codegraph-cli 2.0.0__py3-none-any.whl

codegraph_cli/cli_setup.py

@@ -0,0 +1,470 @@
+"""Interactive setup wizard for CodeGraph CLI."""
+
+from __future__ import annotations
+
+import sys
+from typing import Optional
+
+import typer
+
+from . import config_manager
+
+app = typer.Typer(help="Setup wizard for LLM provider configuration")
+
+
+# Provider model options
+PROVIDER_MODELS = {
+    "groq": [
+        "llama-3.3-70b-versatile",
+        "llama-3.1-70b-versatile",
+        "mixtral-8x7b-32768",
+        "gemma2-9b-it",
+    ],
+    "openai": [
+        "gpt-4",
+        "gpt-4-turbo",
+        "gpt-3.5-turbo",
+    ],
+    "anthropic": [
+        "claude-3-5-sonnet-20241022",
+        "claude-3-opus-20240229",
+        "claude-3-sonnet-20240229",
+    ],
+    "gemini": [
+        "gemini-2.0-flash",
+        "gemini-1.5-pro",
+        "gemini-1.5-flash",
+        "gemini-1.0-pro",
+    ],
+    "openrouter": [
+        "google/gemini-2.0-flash-exp:free",
+        "meta-llama/llama-3.3-70b-instruct:free",
+        "deepseek/deepseek-chat-v3-0324:free",
+        "qwen/qwen3-235b-a22b:free",
+        "stepfun/step-3.5-flash:free",
+        "anthropic/claude-sonnet-4",
+        "openai/gpt-4o",
+    ],
+}
+
+
+def print_header():
+    """Print setup wizard header."""
+    typer.echo("")
+    typer.echo(typer.style("╭──────────────────────────────────────────────╮", fg=typer.colors.CYAN))
+    typer.echo(typer.style("│", fg=typer.colors.CYAN) + typer.style("   🔧 CodeGraph LLM Setup Wizard              ", bold=True) + typer.style("│", fg=typer.colors.CYAN))
+    typer.echo(typer.style("╰──────────────────────────────────────────────╯", fg=typer.colors.CYAN))
+
+
+def print_success(message: str):
+    """Print success message."""
+    typer.echo(typer.style(f"✅ {message}", fg=typer.colors.GREEN))
+
+
+def print_error(message: str):
+    """Print error message."""
+    typer.echo(typer.style(f"❌ {message}", fg=typer.colors.RED), err=True)
+
+
+def print_info(message: str):
+    """Print info message."""
+    typer.echo(typer.style(f"ℹ️  {message}", fg=typer.colors.BLUE))
+
+
+# All supported providers for quick lookup
+ALL_PROVIDERS = ["ollama", "groq", "openai", "anthropic", "gemini", "openrouter"]
+
+
+def select_provider() -> str:
+    """Interactive provider selection.
+    
+    Returns:
+        Selected provider name
+    """
+    typer.echo("\nChoose your LLM provider:")
+    typer.echo("  1) Ollama      (local, free)")
+    typer.echo("  2) Groq        (cloud, fast, free tier)")
+    typer.echo("  3) OpenAI      (cloud, paid)")
+    typer.echo("  4) Anthropic   (cloud, paid)")
+    typer.echo("  5) Gemini      (cloud, free tier available)")
+    typer.echo("  6) OpenRouter  (cloud, multi-model, free tier available)")
+    
+    provider_map = {
+        "1": "ollama",
+        "2": "groq",
+        "3": "openai",
+        "4": "anthropic",
+        "5": "gemini",
+        "6": "openrouter",
+    }
+    
+    while True:
+        choice = typer.prompt("\nEnter choice [1-6]", type=str)
+        if choice in provider_map:
+            return provider_map[choice]
+        print_error("Invalid choice. Please enter 1-6.")
+
+
+def setup_ollama() -> tuple[str, str, str]:
+    """Setup Ollama provider.
+    
+    Returns:
+        Tuple of (provider, model, endpoint)
+    """
+    typer.echo("\n" + typer.style("Setting up Ollama", bold=True))
+    typer.echo("━" * 50)
+    
+    # Check if Ollama is running
+    endpoint = typer.prompt("Ollama endpoint", default="http://127.0.0.1:11434")
+    
+    typer.echo("\n⏳ Checking Ollama connection...")
+    if not config_manager.validate_ollama_connection(endpoint):
+        print_error("Cannot connect to Ollama!")
+        print_info("Make sure Ollama is running: https://ollama.ai")
+        print_info("Start Ollama and run this setup again.")
+        raise typer.Exit(code=1)
+    
+    print_success("Connected to Ollama")
+    
+    # Fetch available models
+    typer.echo("\n⏳ Fetching available models...")
+    models = config_manager.get_ollama_models(endpoint)
+    
+    if not models:
+        print_error("No models found!")
+        print_info("Pull a model first: ollama pull qwen2.5-coder:7b")
+        raise typer.Exit(code=1)
+    
+    # Display models
+    typer.echo("\nAvailable models:")
+    for i, model in enumerate(models, 1):
+        typer.echo(f"  {i}) {model}")
+    
+    # Select model
+    while True:
+        choice = typer.prompt(f"\nSelect model [1-{len(models)}]", type=int)
+        if 1 <= choice <= len(models):
+            selected_model = models[choice - 1]
+            break
+        print_error(f"Invalid choice. Please enter a number between 1 and {len(models)}.")
+    
+    return "ollama", selected_model, endpoint
+
+
+def setup_cloud_provider(provider: str) -> tuple[str, str, str]:
+    """Setup cloud provider (Groq, OpenAI, Anthropic, Gemini, OpenRouter).
+    
+    Args:
+        provider: Provider name
+    
+    Returns:
+        Tuple of (provider, model, api_key)
+    """
+    provider_display = {
+        "openrouter": "OpenRouter",
+        "openai": "OpenAI",
+    }.get(provider, provider.title())
+    
+    typer.echo(f"\n" + typer.style(f"Setting up {provider_display}", bold=True))
+    typer.echo("━" * 50)
+    
+    # Provider-specific hints
+    if provider == "gemini":
+        print_info("Get your Gemini API key at: https://aistudio.google.com/apikey")
+    elif provider == "openrouter":
+        print_info("Get your OpenRouter API key at: https://openrouter.ai/keys")
+        print_info("Many free models available! Look for models ending with ':free'")
+    
+    # Get API key
+    api_key = typer.prompt(f"\nEnter your {provider_display} API key", hide_input=True)
+    
+    if not api_key.strip():
+        print_error("API key cannot be empty!")
+        raise typer.Exit(code=1)
+    
+    # Display available models
+    models = PROVIDER_MODELS.get(provider, [])
+    typer.echo("\nAvailable models:")
+    for i, model in enumerate(models, 1):
+        typer.echo(f"  {i}) {model}")
+    
+    # Select model
+    while True:
+        choice = typer.prompt(f"\nSelect model [1-{len(models)}] or enter custom model name", type=str)
+        
+        # Check if it's a number
+        try:
+            idx = int(choice)
+            if 1 <= idx <= len(models):
+                selected_model = models[idx - 1]
+                break
+            print_error(f"Invalid choice. Please enter a number between 1 and {len(models)}.")
+        except ValueError:
+            # Custom model name
+            selected_model = choice.strip()
+            if selected_model:
+                break
+            print_error("Model name cannot be empty!")
+    
+    # Validate API key
+    typer.echo("\n⏳ Validating API key...")
+    is_valid, error_msg = config_manager.validate_api_key(provider, api_key, selected_model)
+    
+    if not is_valid:
+        print_error(f"API key validation failed: {error_msg}")
+        print_info("Please check your API key and try again.")
+        raise typer.Exit(code=1)
+    
+    print_success("API key validated successfully")
+    
+    return provider, selected_model, api_key
+
+
+def display_summary(provider: str, model: str, api_key: str = "", endpoint: str = ""):
+    """Display configuration summary.
+    
+    Args:
+        provider: Provider name
+        model: Model name
+        api_key: API key (masked for display)
+        endpoint: Endpoint URL
+    """
+    typer.echo("\n" + typer.style("✅ Configuration Summary", bold=True, fg=typer.colors.GREEN))
+    typer.echo("━" * 50)
+    typer.echo(f"Provider: {typer.style(provider, fg=typer.colors.CYAN)}")
+    typer.echo(f"Model: {typer.style(model, fg=typer.colors.CYAN)}")
+    
+    if api_key:
+        masked_key = api_key[:8] + "*" * (len(api_key) - 8)
+        typer.echo(f"API Key: {masked_key}")
+    
+    if endpoint:
+        typer.echo(f"Endpoint: {endpoint}")
+    
+    typer.echo("")
+
+
+def setup():
+    """Interactive setup wizard for LLM provider configuration."""
+    print_header()
+    
+    # Select provider
+    provider = select_provider()
+    
+    # Provider-specific setup
+    api_key = ""
+    endpoint = ""
+    
+    if provider == "ollama":
+        provider, model, endpoint = setup_ollama()
+    elif provider == "openrouter":
+        provider, model, api_key = setup_cloud_provider(provider)
+        endpoint = "https://openrouter.ai/api/v1/chat/completions"
+    else:
+        provider, model, api_key = setup_cloud_provider(provider)
+    
+    # Display summary
+    display_summary(provider, model, api_key, endpoint)
+    
+    # Confirm save
+    save = typer.confirm(f"Save to {config_manager.CONFIG_FILE}?", default=True)
+    
+    if not save:
+        print_info("Configuration not saved.")
+        raise typer.Exit(code=0)
+    
+    # Save configuration
+    success = config_manager.save_config(provider, model, api_key, endpoint)
+    
+    if success:
+        print_success(f"Configuration saved to {config_manager.CONFIG_FILE}")
+        print_info(f"You can now use 'cg' commands without specifying provider options!")
+        typer.echo("\nExample commands:")
+        typer.echo("  cg index ./my-project")
+        typer.echo("  cg search 'authentication logic'")
+        typer.echo("  cg impact main")
+    else:
+        print_error("Failed to save configuration!")
+        raise typer.Exit(code=1)
+
+
+def set_llm(
+    provider: str = typer.Argument(..., help="LLM provider: ollama, groq, openai, anthropic, gemini, openrouter"),
+    model: str = typer.Option(None, "--model", "-m", help="Model name (uses provider default if not set)."),
+    api_key: str = typer.Option(None, "--api-key", "-k", help="API key for cloud providers."),
+    endpoint: str = typer.Option(None, "--endpoint", "-e", help="Custom endpoint URL."),
+    no_validate: bool = typer.Option(False, "--no-validate", help="Skip API key validation."),
+):
+    """Quickly switch LLM provider without full setup wizard.
+    
+    Examples:
+        cg set-llm groq -k YOUR_API_KEY
+        cg set-llm gemini -k YOUR_API_KEY -m gemini-2.0-flash
+        cg set-llm openrouter -k YOUR_API_KEY -m google/gemini-2.0-flash-exp:free
+        cg set-llm ollama -m qwen2.5-coder:7b
+    """
+    provider = provider.lower().strip()
+    
+    if provider not in ALL_PROVIDERS:
+        print_error(f"Unknown provider '{provider}'. Choose from: {', '.join(ALL_PROVIDERS)}")
+        raise typer.Exit(code=1)
+    
+    # Load current config as base
+    current = config_manager.load_config()
+    
+    # Get defaults for the chosen provider
+    defaults = config_manager.get_provider_config(provider)
+    
+    # Resolve model
+    resolved_model = model or defaults.get("model", "")
+    
+    # Resolve endpoint
+    if provider == "openrouter" and not endpoint:
+        resolved_endpoint = "https://openrouter.ai/api/v1/chat/completions"
+    elif provider == "ollama" and not endpoint:
+        resolved_endpoint = defaults.get("endpoint", "http://127.0.0.1:11434/api/generate")
+    else:
+        resolved_endpoint = endpoint or ""
+    
+    # Resolve API key
+    resolved_api_key = api_key or ""
+    
+    # Cloud providers need an API key
+    if provider not in ("ollama",) and not resolved_api_key:
+        # Check if there's one in current config for same provider
+        if current.get("provider") == provider and current.get("api_key"):
+            resolved_api_key = current["api_key"]
+            print_info(f"Reusing existing API key for {provider}")
+        else:
+            resolved_api_key = typer.prompt(f"Enter your {provider} API key", hide_input=True)
+    
+    # Validate if needed
+    if not no_validate and provider not in ("ollama",) and resolved_api_key:
+        typer.echo("⏳ Validating API key...")
+        is_valid, error_msg = config_manager.validate_api_key(provider, resolved_api_key, resolved_model)
+        if not is_valid:
+            print_error(f"Validation failed: {error_msg}")
+            force = typer.confirm("Save anyway?", default=False)
+            if not force:
+                raise typer.Exit(code=1)
+    elif provider == "ollama":
+        typer.echo("⏳ Checking Ollama connection...")
+        base_ep = resolved_endpoint.replace("/api/generate", "")
+        if not config_manager.validate_ollama_connection(base_ep):
+            print_error("Cannot connect to Ollama!")
+            force = typer.confirm("Save anyway?", default=False)
+            if not force:
+                raise typer.Exit(code=1)
+    
+    # Save
+    success = config_manager.save_config(provider, resolved_model, resolved_api_key, resolved_endpoint)
+    
+    if success:
+        print_success(f"LLM provider set to: {provider}")
+        typer.echo(f"  Provider: {typer.style(provider, fg=typer.colors.CYAN)}")
+        typer.echo(f"  Model:    {typer.style(resolved_model, fg=typer.colors.CYAN)}")
+        if resolved_endpoint:
+            typer.echo(f"  Endpoint: {resolved_endpoint}")
+    else:
+        print_error("Failed to save configuration!")
+        raise typer.Exit(code=1)
+
+
+def unset_llm():
+    """Reset LLM configuration to defaults (removes API keys and provider settings)."""
+    typer.echo("\n🔧 " + typer.style("Unset LLM Configuration", bold=True, fg=typer.colors.CYAN))
+    typer.echo("━" * 50)
+    
+    if not config_manager.CONFIG_FILE.exists():
+        print_info("No LLM configuration found. Nothing to unset.")
+        raise typer.Exit(code=0)
+    
+    # Show current config
+    current = config_manager.load_config()
+    typer.echo(f"\nCurrent provider: {typer.style(current.get('provider', 'none'), fg=typer.colors.YELLOW)}")
+    typer.echo(f"Current model:    {typer.style(current.get('model', 'none'), fg=typer.colors.YELLOW)}")
+    if current.get('api_key'):
+        masked = current['api_key'][:8] + '****'
+        typer.echo(f"API key:          {masked}")
+    
+    typer.echo("")
+    typer.echo("Choose what to do:")
+    typer.echo("  1) Reset to Ollama defaults (remove cloud keys)")
+    typer.echo("  2) Delete entire config file")
+    typer.echo("  3) Cancel")
+    
+    choice = typer.prompt("\nEnter choice [1-3]", type=str)
+    
+    if choice == "1":
+        success = config_manager.save_config("ollama", "qwen2.5-coder:7b", "", "http://127.0.0.1:11434/api/generate")
+        if success:
+            print_success("Configuration reset to Ollama defaults.")
+            print_info("API keys have been removed.")
+        else:
+            print_error("Failed to reset configuration!")
+            raise typer.Exit(code=1)
+    
+    elif choice == "2":
+        confirm = typer.confirm("Are you sure you want to delete the config file?", default=False)
+        if confirm:
+            try:
+                config_manager.CONFIG_FILE.unlink()
+                print_success(f"Deleted {config_manager.CONFIG_FILE}")
+                print_info("Will use Ollama defaults on next run.")
+            except OSError as e:
+                print_error(f"Failed to delete config: {e}")
+                raise typer.Exit(code=1)
+        else:
+            print_info("Cancelled.")
+    
+    else:
+        print_info("Cancelled.")
+
+
+def show_llm():
+    """Show current LLM provider configuration."""
+    typer.echo("")
+    typer.echo(typer.style("╭──────────────────────────────────────────────╮", fg=typer.colors.CYAN))
+    typer.echo(typer.style("│", fg=typer.colors.CYAN) + typer.style("   🔍 LLM Configuration                       ", bold=True) + typer.style("│", fg=typer.colors.CYAN))
+    typer.echo(typer.style("╰──────────────────────────────────────────────╯", fg=typer.colors.CYAN))
+    
+    exists = config_manager.CONFIG_FILE.exists()
+    cfg = config_manager.load_config()
+    
+    provider = cfg.get("provider", "ollama")
+    model = cfg.get("model", "qwen2.5-coder:7b")
+    endpoint = cfg.get("endpoint", "")
+    api_key = cfg.get("api_key", "")
+    
+    # Provider badge colors
+    provider_color = {
+        "ollama": typer.colors.GREEN,
+        "groq": typer.colors.YELLOW,
+        "openai": typer.colors.CYAN,
+        "anthropic": typer.colors.MAGENTA,
+        "gemini": typer.colors.BLUE,
+        "openrouter": typer.colors.BRIGHT_CYAN,
+    }.get(provider, typer.colors.WHITE)
+    
+    typer.echo(f"  Provider  {typer.style(f' {provider.upper()} ', bg=provider_color, fg=typer.colors.WHITE, bold=True)}")
+    typer.echo(f"  Model     {typer.style(model, fg=typer.colors.WHITE, bold=True)}")
+    if endpoint:
+        typer.echo(f"  Endpoint  {typer.style(endpoint, dim=True)}")
+    if api_key:
+        masked = api_key[:8] + '•' * min(len(api_key) - 8, 16)
+        typer.echo(f"  API Key   {masked}")
+    else:
+        typer.echo(f"  API Key   {typer.style('(not set)', dim=True)}")
+    typer.echo(f"  Config    {typer.style(str(config_manager.CONFIG_FILE), dim=True)}")
+    
+    typer.echo("")
+    typer.echo(typer.style("  Quick Commands", bold=True))
+    typer.echo(typer.style("  ─────────────────────────────────────────", dim=True))
+    typer.echo(f"  {typer.style('cg setup', fg=typer.colors.YELLOW)}              Full interactive wizard")
+    typer.echo(f"  {typer.style('cg set-llm <name>', fg=typer.colors.YELLOW)}     Quick switch provider")
+    typer.echo(f"  {typer.style('cg unset-llm', fg=typer.colors.YELLOW)}          Reset / clear config")
+    typer.echo("")
+
+
+if __name__ == "__main__":
+    app()

codegraph_cli/cli_test.py

@@ -0,0 +1,177 @@
+"""CLI commands for test generation."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from . import config
+from .llm import LocalLLM
+from .storage import GraphStore, ProjectManager
+from .testgen_agent import TestGenAgent
+
+# Create sub-app for test generation
+test_app = typer.Typer(help="Generate tests from code graph")
+
+
+def _get_testgen_agent(pm: ProjectManager) -> TestGenAgent:
+    """Get TestGenAgent with current project context."""
+    project = pm.get_current_project()
+    if not project:
+        raise typer.BadParameter("No project loaded. Use 'cg load-project <name>' or run 'cg index <path>'.")
+    
+    project_dir = pm.project_dir(project)
+    if not project_dir.exists():
+        raise typer.BadParameter(f"Loaded project '{project}' does not exist in memory.")
+    
+    store = GraphStore(project_dir)
+    
+    # Create LLM if available
+    llm = None
+    if config.LLM_PROVIDER and config.LLM_MODEL:
+        llm = LocalLLM(
+            model=config.LLM_MODEL,
+            provider=config.LLM_PROVIDER,
+            api_key=config.LLM_API_KEY
+        )
+    
+    return TestGenAgent(store, llm)
+
+
+@test_app.command("unit")
+def generate_unit_tests(
+    symbol: str = typer.Argument(..., help="Function name to generate tests for"),
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Output test file path"),
+):
+    """Generate unit tests for a function."""
+    pm = ProjectManager()
+    agent = _get_testgen_agent(pm)
+    
+    typer.echo(f"🧪 Generating unit tests for '{symbol}'...")
+    
+    try:
+        tests = agent.generate_unit_tests(symbol)
+    except ValueError as e:
+        typer.echo(f"❌ Error: {e}")
+        raise typer.Exit(1)
+    
+    if not tests:
+        typer.echo("❌ No tests generated")
+        return
+    
+    typer.echo(f"\n✅ Generated {len(tests)} test(s):\n")
+    
+    # Show tests
+    all_test_code = []
+    for test in tests:
+        typer.echo(f"📝 {test.name}")
+        typer.echo(f"   {test.description}")
+        typer.echo("")
+        all_test_code.append(test.test_code)
+    
+    # Show coverage impact
+    coverage = agent.analyze_coverage_impact(tests)
+    typer.echo(f"📊 Coverage Impact:")
+    typer.echo(f"   Estimated increase: +{coverage['coverage_increase']:.1f}%")
+    typer.echo(f"   Functions covered: {coverage['functions_covered']}")
+    typer.echo("")
+    
+    # Show full test code
+    typer.echo("="*60)
+    typer.echo("GENERATED TEST CODE")
+    typer.echo("="*60)
+    full_code = "\n\n".join(all_test_code)
+    typer.echo(full_code)
+    typer.echo("")
+    
+    # Write to file if requested
+    if output:
+        output_path = Path(output)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Add imports
+        test_file_content = "import pytest\n\n"
+        test_file_content += full_code
+        
+        output_path.write_text(test_file_content)
+        typer.echo(f"✅ Tests written to {output}")
+    else:
+        typer.echo("💡 Use --output to save tests to a file")
+
+
+@test_app.command("integration")
+def generate_integration_tests(
+    flow: str = typer.Argument(..., help="User flow description"),
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Output test file path"),
+):
+    """Generate integration tests for a user flow."""
+    pm = ProjectManager()
+    agent = _get_testgen_agent(pm)
+    
+    typer.echo(f"🧪 Generating integration test for '{flow}'...")
+    
+    tests = agent.generate_integration_tests(flow)
+    
+    if not tests:
+        typer.echo("❌ No tests generated")
+        return
+    
+    typer.echo(f"\n✅ Generated {len(tests)} test(s):\n")
+    
+    # Show tests
+    all_test_code = []
+    for test in tests:
+        typer.echo(f"📝 {test.name}")
+        typer.echo(f"   {test.description}")
+        typer.echo("")
+        all_test_code.append(test.test_code)
+    
+    # Show full test code
+    typer.echo("="*60)
+    typer.echo("GENERATED TEST CODE")
+    typer.echo("="*60)
+    full_code = "\n\n".join(all_test_code)
+    typer.echo(full_code)
+    typer.echo("")
+    
+    # Write to file if requested
+    if output:
+        output_path = Path(output)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Add imports
+        test_file_content = "import pytest\n\n"
+        test_file_content += full_code
+        
+        output_path.write_text(test_file_content)
+        typer.echo(f"✅ Tests written to {output}")
+    else:
+        typer.echo("💡 Use --output to save tests to a file")
+
+
+@test_app.command("coverage")
+def show_coverage_prediction(
+    symbol: str = typer.Argument(..., help="Function to analyze"),
+):
+    """Show predicted coverage impact of generating tests."""
+    pm = ProjectManager()
+    agent = _get_testgen_agent(pm)
+    
+    typer.echo(f"📊 Analyzing coverage impact for '{symbol}'...")
+    
+    try:
+        tests = agent.generate_unit_tests(symbol)
+        coverage = agent.analyze_coverage_impact(tests)
+        
+        typer.echo(f"\n📈 Coverage Analysis:")
+        typer.echo(f"   Current coverage: {coverage['current_coverage']:.1f}%")
+        typer.echo(f"   Estimated after tests: {coverage['estimated_coverage']:.1f}%")
+        typer.echo(f"   Increase: +{coverage['coverage_increase']:.1f}%")
+        typer.echo(f"   Tests to generate: {coverage['tests_generated']}")
+        typer.echo(f"   Functions covered: {coverage['functions_covered']}")
+    
+    except ValueError as e:
+        typer.echo(f"❌ Error: {e}")
+        raise typer.Exit(1)