emdash-cli 0.1.4__py3-none-any.whl

emdash_cli/commands/analyze.py

@@ -0,0 +1,137 @@
+"""Analytics CLI commands."""
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from ..client import EmdashClient
+from ..server_manager import get_server_manager
+
+console = Console()
+
+
+@click.group()
+def analyze():
+    """Run graph analytics."""
+    pass
+
+
+@analyze.command("pagerank")
+@click.option("--top", default=20, help="Number of results to show")
+@click.option("--damping", default=0.85, help="Damping factor")
+def analyze_pagerank(top: int, damping: float):
+    """Compute PageRank scores to identify important code entities."""
+    server = get_server_manager()
+    client = EmdashClient(server.get_server_url())
+
+    try:
+        result = client.analyze_pagerank(top=top, damping=damping)
+
+        entities = result.get("entities", [])
+
+        table = Table(title=f"Top {top} by PageRank")
+        table.add_column("Rank", justify="right", style="dim")
+        table.add_column("Entity", style="cyan")
+        table.add_column("Type")
+        table.add_column("Score", justify="right")
+
+        for i, entity in enumerate(entities, 1):
+            table.add_row(
+                str(i),
+                entity.get("name", ""),
+                entity.get("type", ""),
+                f"{entity.get('score', 0):.4f}",
+            )
+
+        console.print(table)
+
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise click.Abort()
+
+
+@analyze.command("communities")
+@click.option("--resolution", default=1.0, help="Resolution parameter")
+@click.option("--min-size", default=3, help="Minimum community size")
+@click.option("--top", default=20, help="Number of communities to show")
+def analyze_communities(resolution: float, min_size: int, top: int):
+    """Detect code communities using Louvain algorithm."""
+    server = get_server_manager()
+    client = EmdashClient(server.get_server_url())
+
+    try:
+        result = client.analyze_communities(
+            resolution=resolution,
+            min_size=min_size,
+            top=top,
+        )
+
+        communities = result.get("communities", [])
+
+        table = Table(title=f"Top {top} Communities")
+        table.add_column("ID", justify="right", style="dim")
+        table.add_column("Size", justify="right")
+        table.add_column("Members", style="cyan")
+
+        for comm in communities:
+            members = comm.get("members", [])
+            member_str = ", ".join(members[:5])
+            if len(members) > 5:
+                member_str += f" (+{len(members) - 5} more)"
+
+            table.add_row(
+                str(comm.get("id", "")),
+                str(comm.get("size", 0)),
+                member_str,
+            )
+
+        console.print(table)
+
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise click.Abort()
+
+
+@analyze.command("areas")
+@click.option("--depth", default=2, help="Directory depth")
+@click.option("--days", default=30, help="Days to look back for focus")
+@click.option("--top", default=20, help="Number of results")
+@click.option("--sort", type=click.Choice(["focus", "importance", "commits", "authors"]),
+              default="focus", help="Sort metric")
+@click.option("--files", is_flag=True, help="Show individual files instead of directories")
+def analyze_areas(depth: int, days: int, top: int, sort: str, files: bool):
+    """Get importance metrics by directory/area or individual files."""
+    server = get_server_manager()
+    client = EmdashClient(server.get_server_url())
+
+    try:
+        result = client.analyze_areas(
+            depth=depth,
+            days=days,
+            top=top,
+            sort=sort,
+            files=files,
+        )
+
+        areas = result.get("areas", [])
+
+        title = f"Top {top} {'Files' if files else 'Areas'} by {sort.title()}"
+        table = Table(title=title)
+        table.add_column("Path", style="cyan")
+        table.add_column("Commits", justify="right")
+        table.add_column("Authors", justify="right")
+        table.add_column("Focus %", justify="right")
+
+        for area in areas:
+            table.add_row(
+                area.get("path", ""),
+                str(area.get("commits", 0)),
+                str(area.get("authors", 0)),
+                f"{area.get('focus_pct', 0):.1f}%",
+            )
+
+        console.print(table)
+
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise click.Abort()

emdash_cli/commands/auth.py

@@ -0,0 +1,121 @@
+"""Authentication CLI commands."""
+
+import time
+import webbrowser
+
+import click
+from rich.console import Console
+
+from ..client import EmdashClient
+from ..server_manager import get_server_manager
+
+console = Console()
+
+
+@click.group()
+def auth():
+    """Manage GitHub authentication."""
+    pass
+
+
+@auth.command("login")
+@click.option("--no-browser", is_flag=True, help="Don't open browser automatically")
+def auth_login(no_browser: bool):
+    """Authenticate with GitHub using device flow."""
+    server = get_server_manager()
+    client = EmdashClient(server.get_server_url())
+
+    try:
+        # Start device flow
+        result = client.auth_login()
+
+        user_code = result.get("user_code")
+        verification_uri = result.get("verification_uri")
+        interval = result.get("interval", 5)
+        expires_in = result.get("expires_in", 900)
+
+        console.print()
+        console.print("[bold]GitHub Device Authorization[/bold]")
+        console.print()
+        console.print(f"1. Go to: [cyan]{verification_uri}[/cyan]")
+        console.print(f"2. Enter code: [bold yellow]{user_code}[/bold yellow]")
+        console.print()
+
+        if not no_browser:
+            webbrowser.open(verification_uri)
+            console.print("[dim]Browser opened automatically[/dim]")
+
+        console.print("[dim]Waiting for authorization...[/dim]")
+
+        # Poll for completion
+        start_time = time.time()
+        while time.time() - start_time < expires_in:
+            time.sleep(interval)
+
+            poll_result = client.auth_poll(user_code)
+            status = poll_result.get("status")
+
+            if status == "success":
+                username = poll_result.get("username")
+                console.print()
+                console.print(f"[green]Successfully authenticated as {username}![/green]")
+                return
+
+            elif status == "expired":
+                console.print("[red]Authorization expired. Please try again.[/red]")
+                raise click.Abort()
+
+            elif status == "error":
+                error = poll_result.get("error", "Unknown error")
+                console.print(f"[red]Error: {error}[/red]")
+                raise click.Abort()
+
+            # status == "pending" - continue polling
+
+        console.print("[red]Authorization timed out. Please try again.[/red]")
+        raise click.Abort()
+
+    except click.Abort:
+        raise
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise click.Abort()
+
+
+@auth.command("logout")
+def auth_logout():
+    """Remove stored GitHub authentication."""
+    server = get_server_manager()
+    client = EmdashClient(server.get_server_url())
+
+    try:
+        result = client.auth_logout()
+        if result.get("success"):
+            console.print("[green]Successfully logged out.[/green]")
+        else:
+            console.print(f"[yellow]{result.get('message', 'Logout completed')}[/yellow]")
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise click.Abort()
+
+
+@auth.command("status")
+def auth_status():
+    """Show current GitHub authentication status."""
+    server = get_server_manager()
+    client = EmdashClient(server.get_server_url())
+
+    try:
+        status = client.auth_status()
+
+        if status.get("authenticated"):
+            console.print("[green]Authenticated[/green]")
+            console.print(f"  User: [cyan]{status.get('username')}[/cyan]")
+            if status.get("scope"):
+                console.print(f"  Scope: [dim]{status.get('scope')}[/dim]")
+        else:
+            console.print("[yellow]Not authenticated[/yellow]")
+            console.print("[dim]Run 'emdash auth login' to authenticate[/dim]")
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise click.Abort()

emdash_cli/commands/db.py

@@ -0,0 +1,95 @@
+"""Database CLI commands."""
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from ..client import EmdashClient
+from ..server_manager import get_server_manager
+
+console = Console()
+
+
+@click.group()
+def db():
+    """Database management commands."""
+    pass
+
+
+@db.command("init")
+def db_init():
+    """Initialize the Kuzu database schema."""
+    server = get_server_manager()
+    client = EmdashClient(server.get_server_url())
+
+    try:
+        result = client.db_init()
+        if result.get("success"):
+            console.print("[green]Database schema initialized successfully![/green]")
+        else:
+            console.print(f"[red]Error: {result.get('message')}[/red]")
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise click.Abort()
+
+
+@db.command("clear")
+@click.confirmation_option(prompt="Are you sure you want to clear all data?")
+def db_clear():
+    """Clear all data from the database."""
+    server = get_server_manager()
+    client = EmdashClient(server.get_server_url())
+
+    try:
+        result = client.db_clear(confirm=True)
+        if result.get("success"):
+            console.print("[green]Database cleared successfully![/green]")
+        else:
+            console.print(f"[red]Error: {result.get('message')}[/red]")
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise click.Abort()
+
+
+@db.command("stats")
+def db_stats():
+    """Show database statistics."""
+    server = get_server_manager()
+    client = EmdashClient(server.get_server_url())
+
+    try:
+        stats = client.db_stats()
+
+        table = Table(title="Database Statistics")
+        table.add_column("Metric", style="cyan")
+        table.add_column("Count", justify="right")
+
+        table.add_row("Files", str(stats.get("file_count", 0)))
+        table.add_row("Functions", str(stats.get("function_count", 0)))
+        table.add_row("Classes", str(stats.get("class_count", 0)))
+        table.add_row("Communities", str(stats.get("community_count", 0)))
+        table.add_row("Total Nodes", str(stats.get("node_count", 0)))
+        table.add_row("Relationships", str(stats.get("relationship_count", 0)))
+
+        console.print(table)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise click.Abort()
+
+
+@db.command("test")
+def db_test():
+    """Test the database connection."""
+    server = get_server_manager()
+    client = EmdashClient(server.get_server_url())
+
+    try:
+        result = client.db_test()
+        if result.get("connected"):
+            console.print("[green]Database connection successful![/green]")
+            console.print(f"[dim]Path: {result.get('database_path')}[/dim]")
+        else:
+            console.print(f"[red]Connection failed: {result.get('message')}[/red]")
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise click.Abort()

emdash_cli/commands/embed.py

@@ -0,0 +1,103 @@
+"""Embedding management CLI commands."""
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from ..client import EmdashClient
+from ..server_manager import get_server_manager
+
+console = Console()
+
+
+@click.group()
+def embed():
+    """Embedding management commands."""
+    pass
+
+
+@embed.command("index")
+@click.option("--prs/--no-prs", default=True, help="Index PR embeddings")
+@click.option("--functions/--no-functions", default=True, help="Index function embeddings")
+@click.option("--classes/--no-classes", default=True, help="Index class embeddings")
+@click.option("--reindex", is_flag=True, help="Re-generate all embeddings")
+def embed_index(prs: bool, functions: bool, classes: bool, reindex: bool):
+    """Generate embeddings for graph entities."""
+    server = get_server_manager()
+    client = EmdashClient(server.get_server_url())
+
+    try:
+        console.print("[cyan]Generating embeddings...[/cyan]")
+
+        result = client.embed_index(
+            include_prs=prs,
+            include_functions=functions,
+            include_classes=classes,
+            reindex=reindex,
+        )
+
+        if result.get("success"):
+            indexed = result.get("indexed", 0)
+            skipped = result.get("skipped", 0)
+            console.print(f"[green]Indexed {indexed} entities ({skipped} skipped)[/green]")
+        else:
+            console.print(f"[red]Error: {result.get('error')}[/red]")
+
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise click.Abort()
+
+
+@embed.command("status")
+def embed_status():
+    """Show embedding coverage statistics."""
+    server = get_server_manager()
+    client = EmdashClient(server.get_server_url())
+
+    try:
+        status = client.embed_status()
+
+        table = Table(title="Embedding Coverage")
+        table.add_column("Metric", style="cyan")
+        table.add_column("Value", justify="right")
+
+        table.add_row("Total Entities", str(status.get("total_entities", 0)))
+        table.add_row("Embedded", str(status.get("embedded_entities", 0)))
+        table.add_row("Coverage", f"{status.get('coverage_percent', 0):.1f}%")
+        table.add_row("PRs", str(status.get("pr_count", 0)))
+        table.add_row("Functions", str(status.get("function_count", 0)))
+        table.add_row("Classes", str(status.get("class_count", 0)))
+
+        console.print(table)
+
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise click.Abort()
+
+
+@embed.command("models")
+def embed_models():
+    """List all available embedding models."""
+    server = get_server_manager()
+    client = EmdashClient(server.get_server_url())
+
+    try:
+        models = client.embed_models()
+
+        table = Table(title="Available Embedding Models")
+        table.add_column("Name", style="cyan")
+        table.add_column("Dimension", justify="right")
+        table.add_column("Description")
+
+        for model in models:
+            table.add_row(
+                model.get("name", ""),
+                str(model.get("dimension", 0)),
+                model.get("description", ""),
+            )
+
+        console.print(table)
+
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise click.Abort()

emdash_cli/commands/index.py

@@ -0,0 +1,134 @@
+"""Index command - parse and index a codebase."""
+
+import json
+import os
+
+import click
+from rich.console import Console
+from rich.status import Status
+
+from ..client import EmdashClient
+from ..server_manager import get_server_manager
+
+console = Console()
+
+
+@click.group()
+def index():
+    """Index a codebase into the knowledge graph."""
+    pass
+
+
+@index.command("start")
+@click.argument("repo_path", required=False)
+@click.option("--changed-only", is_flag=True, help="Only index changed files")
+@click.option("--skip-git", is_flag=True, help="Skip git history indexing")
+@click.option("--github-prs", default=0, help="Number of GitHub PRs to index")
+@click.option("--detect-communities", is_flag=True, default=True, help="Run community detection")
+@click.option("--describe-communities", is_flag=True, help="Use LLM to describe communities")
+@click.option("--model", "-m", default=None, help="Model for community descriptions")
+def index_start(
+    repo_path: str | None,
+    changed_only: bool,
+    skip_git: bool,
+    github_prs: int,
+    detect_communities: bool,
+    describe_communities: bool,
+    model: str | None,
+):
+    """Index a repository into the knowledge graph.
+
+    If REPO_PATH is not provided, indexes the current directory.
+
+    Examples:
+        emdash index start                    # Index current directory
+        emdash index start /path/to/repo      # Index specific repo
+        emdash index start --changed-only     # Only index changed files
+        emdash index start --github-prs 50    # Also index 50 PRs
+    """
+    # Default to current directory
+    if not repo_path:
+        repo_path = os.getcwd()
+
+    # Ensure server is running
+    server = get_server_manager()
+    client = EmdashClient(server.get_server_url())
+
+    console.print(f"\n[bold cyan]Indexing[/bold cyan] {repo_path}\n")
+
+    # Build options
+    options = {
+        "changed_only": changed_only,
+        "index_git": not skip_git,
+        "index_github": github_prs,
+        "detect_communities": detect_communities,
+        "describe_communities": describe_communities,
+    }
+    if model:
+        options["model"] = model
+
+    try:
+        # Stream indexing progress with spinner
+        with Status("[bold cyan]Indexing in progress...[/bold cyan]", console=console) as status:
+            for line in client.index_start_stream(repo_path, changed_only):
+                line = line.strip()
+                if line.startswith("data: "):
+                    try:
+                        data = json.loads(line[6:])
+                        step = data.get("step") or data.get("message", "")
+                        percent = data.get("percent")
+                        if step:
+                            if percent is not None:
+                                status.update(f"[bold cyan]{step}[/bold cyan] ({percent:.0f}%)")
+                            else:
+                                status.update(f"[bold cyan]{step}[/bold cyan]")
+                    except json.JSONDecodeError:
+                        pass
+
+        console.print("\n[green]Indexing complete![/green]")
+
+    except Exception as e:
+        console.print(f"\n[red]Error:[/red] {e}")
+        raise click.Abort()
+
+
+@index.command("status")
+@click.argument("repo_path", required=False)
+def index_status(repo_path: str | None):
+    """Show current indexing status.
+
+    If REPO_PATH is not provided, checks the current directory.
+
+    Example:
+        emdash index status
+        emdash index status /path/to/repo
+    """
+    # Default to current directory
+    if not repo_path:
+        repo_path = os.getcwd()
+
+    server = get_server_manager()
+    client = EmdashClient(server.get_server_url())
+
+    try:
+        status = client.index_status(repo_path)
+
+        console.print("\n[bold]Index Status[/bold]")
+        console.print(f"  Indexed: {'[green]Yes[/green]' if status.get('is_indexed') else '[yellow]No[/yellow]'}")
+
+        if status.get("is_indexed"):
+            console.print(f"  Files: {status.get('file_count', 0)}")
+            console.print(f"  Functions: {status.get('function_count', 0)}")
+            console.print(f"  Classes: {status.get('class_count', 0)}")
+            console.print(f"  Communities: {status.get('community_count', 0)}")
+
+            if status.get("last_indexed"):
+                console.print(f"  Last indexed: {status.get('last_indexed')}")
+            if status.get("last_commit"):
+                console.print(f"  Last commit: {status.get('last_commit')}")
+
+        console.print()
+
+    except Exception as e:
+        console.print(f"\n[red]Error:[/red] {e}")
+        raise click.Abort()

emdash_cli/commands/plan.py

@@ -0,0 +1,77 @@
+"""Planning CLI commands."""
+
+import json
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from ..client import EmdashClient
+from ..server_manager import get_server_manager
+
+console = Console()
+
+
+@click.group()
+def plan():
+    """Feature planning commands."""
+    pass
+
+
+@plan.command("context")
+@click.argument("description")
+@click.option("--similar-prs", default=5, help="Number of similar PRs to show")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def plan_context(description: str, similar_prs: int, output_json: bool):
+    """Get planning context for a feature.
+
+    Finds similar PRs and relevant code patterns to help plan
+    the implementation of a new feature.
+
+    Examples:
+        emdash plan context "add dark mode toggle"
+        emdash plan context "user authentication" --similar-prs 10
+    """
+    server = get_server_manager()
+    client = EmdashClient(server.get_server_url())
+
+    try:
+        result = client.plan_context(
+            description=description,
+            similar_prs=similar_prs,
+        )
+
+        if output_json:
+            console.print(json.dumps(result, indent=2))
+            return
+
+        # Display similar PRs
+        prs = result.get("similar_prs", [])
+        if prs:
+            table = Table(title="Similar PRs")
+            table.add_column("Score", justify="right", style="dim")
+            table.add_column("PR", style="cyan")
+            table.add_column("Title")
+
+            for pr in prs:
+                table.add_row(
+                    f"{pr.get('score', 0):.3f}",
+                    f"#{pr.get('number', '')}",
+                    pr.get("title", ""),
+                )
+
+            console.print(table)
+        else:
+            console.print("[dim]No similar PRs found[/dim]")
+
+        # Display relevant patterns
+        patterns = result.get("patterns", [])
+        if patterns:
+            console.print()
+            console.print("[bold]Relevant Patterns[/bold]")
+            for pattern in patterns:
+                console.print(f"  • {pattern}")
+
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise click.Abort()