codexa 0.4.0__py3-none-any.whl

semantic_code_intelligence/cli/commands/languages_cmd.py

@@ -0,0 +1,101 @@
+"""CLI command: languages — List supported languages and their parsing status."""
+
+from __future__ import annotations
+
+import click
+
+from semantic_code_intelligence.parsing.parser import (
+    _LANGUAGE_MODULES,
+    EXTENSION_TO_LANGUAGE,
+    FUNCTION_NODE_TYPES,
+    CLASS_NODE_TYPES,
+    IMPORT_NODE_TYPES,
+    get_language,
+)
+from semantic_code_intelligence.utils.logging import get_logger, console
+
+logger = get_logger("cli.languages")
+
+
+@click.command("languages")
+@click.option(
+    "--json-output",
+    "--json",
+    "json_mode",
+    is_flag=True,
+    default=False,
+    help="Output as JSON.",
+)
+@click.option(
+    "--check",
+    is_flag=True,
+    default=False,
+    help="Verify each grammar can be loaded (slower).",
+)
+def languages_cmd(json_mode: bool, check: bool) -> None:
+    """List all supported programming languages and their tree-sitter grammar status.
+
+    \b
+    Examples:
+        codexa languages
+        codexa languages --check
+        codexa languages --json
+    """
+    import json as json_mod
+
+    # Build extension map (language -> list of extensions)
+    ext_map: dict[str, list[str]] = {}
+    for ext, lang in EXTENSION_TO_LANGUAGE.items():
+        ext_map.setdefault(lang, []).append(ext)
+
+    rows: list[dict] = []
+    for lang_name, module_name in sorted(_LANGUAGE_MODULES.items()):
+        extensions = ext_map.get(lang_name, [])
+        has_functions = lang_name in FUNCTION_NODE_TYPES
+        has_classes = lang_name in CLASS_NODE_TYPES
+        has_imports = lang_name in IMPORT_NODE_TYPES
+
+        status = "available"
+        if check:
+            loaded = get_language(lang_name)
+            status = "loaded" if loaded else "missing"
+
+        rows.append({
+            "language": lang_name,
+            "module": module_name,
+            "extensions": sorted(extensions),
+            "functions": has_functions,
+            "classes": has_classes,
+            "imports": has_imports,
+            "status": status,
+        })
+
+    if json_mode:
+        click.echo(json_mod.dumps(rows, indent=2))
+        return
+
+    from rich.table import Table
+
+    table = Table(title="Supported Languages", show_lines=False)
+    table.add_column("Language", style="cyan bold")
+    table.add_column("Extensions", style="green")
+    table.add_column("Functions", justify="center")
+    table.add_column("Classes", justify="center")
+    table.add_column("Imports", justify="center")
+    if check:
+        table.add_column("Status", justify="center")
+
+    for row in rows:
+        exts = ", ".join(row["extensions"])
+        fn_icon = "[green]✓[/green]" if row["functions"] else "[red]✗[/red]"
+        cls_icon = "[green]✓[/green]" if row["classes"] else "[red]✗[/red]"
+        imp_icon = "[green]✓[/green]" if row["imports"] else "[red]✗[/red]"
+        cols = [row["language"], exts, fn_icon, cls_icon, imp_icon]
+        if check:
+            st = row["status"]
+            st_icon = "[green]loaded[/green]" if st == "loaded" else "[red]missing[/red]"
+            cols.append(st_icon)
+        table.add_row(*cols)
+
+    console.print(table)
+    console.print(f"\n[dim]{len(rows)} languages supported[/dim]")

semantic_code_intelligence/cli/commands/lsp_cmd.py

@@ -0,0 +1,49 @@
+"""CLI command: lsp — start the CodexA LSP server."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.config.settings import AppConfig
+from semantic_code_intelligence.utils.logging import get_logger, print_error
+
+logger = get_logger("cli.lsp")
+
+
+@click.command("lsp")
+@click.option(
+    "--path",
+    "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path.",
+)
+@click.pass_context
+def lsp_cmd(ctx: click.Context, path: str) -> None:
+    """Start the CodexA Language Server Protocol server.
+
+    Runs over stdio using standard LSP Content-Length framing.
+    Compatible with any LSP client: VS Code, Neovim, Sublime, JetBrains.
+
+    \b
+    VS Code settings.json:
+      "codexa.lsp.path": "/path/to/your/project"
+
+    \b
+    Neovim (nvim-lspconfig):
+      require('lspconfig').codexa.setup {
+        cmd = { "codexa", "lsp", "--path", "/your/project" },
+      }
+    """
+    root = Path(path).resolve()
+    config_dir = AppConfig.config_dir(root)
+
+    if not config_dir.exists():
+        print_error(f"Project not initialized at {root}. Run 'codexa init' first.")
+        ctx.exit(1)
+        return
+
+    from semantic_code_intelligence.lsp import run_lsp_server
+    run_lsp_server(root)

semantic_code_intelligence/cli/commands/mcp_cmd.py

@@ -0,0 +1,50 @@
+"""CLI command: mcp - Start the MCP (Model Context Protocol) server."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.config.settings import AppConfig
+from semantic_code_intelligence.utils.logging import get_logger, print_error, print_info
+
+logger = get_logger("cli.mcp")
+
+
+@click.command("mcp")
+@click.option(
+    "--path",
+    "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path.",
+)
+@click.pass_context
+def mcp_cmd(ctx: click.Context, path: str) -> None:
+    """Start the MCP server for AI agent integration.
+
+    Runs a JSON-RPC server over stdio, compatible with Claude Desktop,
+    Cursor, and other MCP-compatible AI tools.
+
+    \b
+    Configuration for Claude Desktop (claude_desktop_config.json):
+      {
+        "mcpServers": {
+          "codexa": {
+            "command": "codexa",
+            "args": ["mcp", "--path", "/your/project"]
+          }
+        }
+      }
+    """
+    root = Path(path).resolve()
+    config_dir = AppConfig.config_dir(root)
+
+    if not config_dir.exists():
+        print_error(f"Project not initialized at {root}. Run 'codexa init' first.")
+        ctx.exit(1)
+        return
+
+    from semantic_code_intelligence.mcp import run_mcp_server
+    run_mcp_server(root)

semantic_code_intelligence/cli/commands/metrics_cmd.py

@@ -0,0 +1,264 @@
+"""CLI command: metrics — code quality metrics, snapshots, and trends."""
+
+from __future__ import annotations
+
+import json as json_mod
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import click
+
+from semantic_code_intelligence.utils.logging import (
+    console,
+    get_logger,
+    print_error,
+    print_info,
+    print_success,
+)
+
+if TYPE_CHECKING:
+    from semantic_code_intelligence.ci.metrics import MetricSnapshot, TrendResult, ProjectMetrics
+
+logger = get_logger("cli.metrics")
+
+
+# ------------------------------------------------------------------
+# Output helpers
+# ------------------------------------------------------------------
+
+
+def _output_history(
+    snaps: list["MetricSnapshot"],
+    limit: int,
+    *,
+    json_mode: bool,
+    pipe: bool,
+) -> None:
+    """Emit snapshot history in the requested format."""
+    if json_mode:
+        click.echo(json_mod.dumps(
+            {"snapshots": [s.to_dict() for s in snaps]},
+            indent=2,
+        ))
+    elif pipe:
+        for s in snaps:
+            click.echo(
+                f"  {s.timestamp:.0f}  MI={s.maintainability_index:.1f}  "
+                f"LOC={s.total_loc}  issues={s.issue_count}"
+            )
+    else:
+        if not snaps:
+            print_info("No snapshots found — run with --snapshot to save one.")
+            return
+        console.print(f"\n[bold cyan]Quality Snapshots[/bold cyan] (last {len(snaps)})\n")
+        for s in snaps:
+            import datetime
+            ts = datetime.datetime.fromtimestamp(s.timestamp).strftime("%Y-%m-%d %H:%M")
+            console.print(
+                f"  {ts}  MI=[bold]{s.maintainability_index:.1f}[/bold]  "
+                f"LOC={s.total_loc}  issues={s.issue_count}"
+            )
+
+
+def _output_trend(
+    results: list["TrendResult"],
+    snap_count: int,
+    *,
+    json_mode: bool,
+    pipe: bool,
+) -> None:
+    """Emit trend analysis in the requested format."""
+    if json_mode:
+        click.echo(json_mod.dumps(
+            {"trends": [t.to_dict() for t in results]},
+            indent=2,
+        ))
+    elif pipe:
+        for t in results:
+            click.echo(
+                f"  TREND  {t.metric_name}  {t.direction}  "
+                f"oldest={t.oldest_value:.2f}  newest={t.newest_value:.2f}  "
+                f"delta={t.delta:+.2f}"
+            )
+    else:
+        console.print(f"\n[bold cyan]Quality Trends[/bold cyan] ({snap_count} snapshots)\n")
+        for t in results:
+            color = {"improving": "green", "degrading": "red", "stable": "yellow"}.get(t.direction, "white")
+            console.print(
+                f"  {t.metric_name:<30} [{color}]{t.direction:>10}[/{color}]  "
+                f"{t.oldest_value:.1f} -> {t.newest_value:.1f}  ({t.delta:+.1f})"
+            )
+
+
+def _output_current_metrics(
+    pm: "ProjectMetrics",
+    root: Path,
+    saved: "MetricSnapshot | None",
+    *,
+    json_mode: bool,
+    pipe: bool,
+) -> None:
+    """Emit current metrics in the requested format."""
+    if json_mode:
+        payload = pm.to_dict()
+        if saved:
+            payload["snapshot"] = saved.to_dict()
+        click.echo(json_mod.dumps(payload, indent=2))
+        return
+
+    if pipe:
+        click.echo(
+            f"Files: {pm.files_analyzed}  LOC: {pm.total_loc}  "
+            f"MI: {pm.maintainability_index:.1f}  "
+            f"AvgCC: {pm.avg_complexity:.1f}  MaxCC: {pm.max_complexity}"
+        )
+        if saved:
+            click.echo(f"Snapshot saved at {saved.timestamp:.0f}")
+        return
+
+    # Rich output
+    console.print(f"\n[bold cyan]Quality Metrics[/bold cyan] — {root}\n")
+    console.print(f"  Files analyzed:       {pm.files_analyzed}")
+    console.print(f"  Lines of code:        {pm.total_loc}")
+    console.print(f"  Comment lines:        {pm.total_comment_lines}")
+    console.print(f"  Comment ratio:        {pm.comment_ratio:.1%}")
+    console.print(f"  Symbols:              {pm.total_symbols}")
+    console.print(f"  Avg complexity:       {pm.avg_complexity:.1f}")
+    console.print(f"  Max complexity:       {pm.max_complexity}")
+    console.print(f"  Maintainability index: [bold]{pm.maintainability_index:.1f}[/bold]")
+
+    if saved:
+        print_success("Snapshot saved")
+
+    if pm.file_metrics:
+        console.print(f"\n[bold]Per-File Maintainability:[/bold]")
+        ranked = sorted(pm.file_metrics, key=lambda f: f.maintainability_index)
+        for fm in ranked[:10]:
+            mi = fm.maintainability_index
+            color = "green" if mi >= 65 else ("yellow" if mi >= 40 else "red")
+            name = Path(fm.file_path).name
+            console.print(f"  [{color}]{mi:5.1f}[/{color}]  {name}  (LOC={fm.lines_of_code}, CC={fm.avg_complexity:.1f})")
+
+
+@click.command("metrics")
+@click.option(
+    "--path",
+    "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path.",
+)
+@click.option(
+    "--json-output",
+    "--json",
+    "json_mode",
+    is_flag=True,
+    default=False,
+    help="Output in JSON format.",
+)
+@click.option(
+    "--pipe",
+    is_flag=True,
+    default=False,
+    help="Plain text output for piping / CI.",
+)
+@click.option(
+    "--snapshot",
+    is_flag=True,
+    default=False,
+    help="Save a quality snapshot after computing metrics.",
+)
+@click.option(
+    "--history",
+    type=int,
+    default=0,
+    help="Show last N snapshots (0 = skip history).",
+)
+@click.option(
+    "--trend",
+    is_flag=True,
+    default=False,
+    help="Show trend analysis from historical snapshots.",
+)
+@click.pass_context
+def metrics_cmd(
+    ctx: click.Context,
+    path: str,
+    json_mode: bool,
+    pipe: bool,
+    snapshot: bool,
+    history: int,
+    trend: bool,
+) -> None:
+    """Compute code quality metrics, save snapshots, and track trends.
+
+    Calculates maintainability index, LOC, complexity, and comment ratios.
+    Supports saving metric snapshots for historical trend analysis.
+
+    Examples:
+
+        codexa metrics
+
+        codexa metrics --snapshot --json
+
+        codexa metrics --history 10
+
+        codexa metrics --trend
+    """
+    from semantic_code_intelligence.ci.metrics import (
+        compute_project_metrics,
+        compute_trend,
+        load_snapshots,
+        save_snapshot,
+    )
+    from semantic_code_intelligence.ci.quality import analyze_project
+
+    root = Path(path).resolve()
+
+    # ── History-only mode ────────────────────────────────────────
+    if history > 0 and not trend:
+        snaps = load_snapshots(root, limit=history)
+        _output_history(snaps, history, json_mode=json_mode, pipe=pipe)
+        return
+
+    # ── Trend-only mode ──────────────────────────────────────────
+    if trend:
+        limit = history if history > 0 else 50
+        snaps = load_snapshots(root, limit=limit)
+        if len(snaps) < 2:
+            print_info("Need at least 2 snapshots for trend — run with --snapshot first.")
+            return
+
+        metrics_to_track = [
+            ("maintainability_index", True),
+            ("avg_complexity", False),
+            ("issue_count", False),
+            ("total_loc", True),
+        ]
+        results = []
+        for metric, higher in metrics_to_track:
+            t = compute_trend(snaps, metric, higher_is_better=higher)
+            results.append(t)
+
+        _output_trend(results, len(snaps), json_mode=json_mode, pipe=pipe)
+        return
+
+    # ── Compute current metrics ──────────────────────────────────
+    try:
+        pm = compute_project_metrics(root)
+    except Exception as exc:
+        logger.debug("Metrics computation failed", exc_info=True)
+        print_error(f"Failed to compute metrics: {exc}")
+        ctx.exit(1)
+        return
+
+    saved = None
+    if snapshot:
+        try:
+            report = analyze_project(root)
+            saved = save_snapshot(root, pm, report)
+        except Exception as exc:
+            logger.debug("Snapshot save failed", exc_info=True)
+            print_error(f"Failed to save snapshot: {exc}")
+
+    _output_current_metrics(pm, root, saved, json_mode=json_mode, pipe=pipe)

semantic_code_intelligence/cli/commands/models_cmd.py

@@ -0,0 +1,157 @@
+"""CLI command: models — download, list, switch, and inspect embedding models."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.config.settings import AppConfig, load_config, save_config
+from semantic_code_intelligence.embeddings.model_registry import (
+    AVAILABLE_MODELS,
+    DEFAULT_MODEL,
+    MODEL_ALIASES,
+    get_model_info,
+    list_models,
+    resolve_model_name,
+)
+from semantic_code_intelligence.utils.logging import (
+    console,
+    get_logger,
+    print_error,
+    print_info,
+    print_success,
+    print_warning,
+)
+
+logger = get_logger("cli.models")
+
+
+@click.group("models")
+def models_cmd() -> None:
+    """Manage embedding models — download, list, switch, info."""
+
+
+@models_cmd.command("list")
+@click.option("--json-output", "--json", "json_mode", is_flag=True, help="Output as JSON.")
+def models_list(json_mode: bool) -> None:
+    """List all available embedding models and their properties."""
+    all_models = list_models()
+
+    if json_mode:
+        out = [
+            {
+                "name": m.name,
+                "display_name": m.display_name,
+                "dimension": m.dimension,
+                "description": m.description,
+                "recommended_for": m.recommended_for,
+                "backend": m.backend,
+                "is_default": m.name == DEFAULT_MODEL,
+            }
+            for m in all_models
+        ]
+        click.echo(json.dumps(out, indent=2, ensure_ascii=False))
+        return
+
+    from rich.table import Table
+
+    table = Table(title="Available Embedding Models", show_lines=True)
+    table.add_column("Name", style="bold cyan", no_wrap=True)
+    table.add_column("Alias", style="dim")
+    table.add_column("Dim", justify="right")
+    table.add_column("Description")
+    table.add_column("Default", justify="center")
+
+    alias_reverse: dict[str, str] = {}
+    for alias, full in MODEL_ALIASES.items():
+        alias_reverse.setdefault(full, alias)
+
+    for m in all_models:
+        alias = alias_reverse.get(m.name, "—")
+        is_default = "✓" if m.name == DEFAULT_MODEL else ""
+        table.add_row(m.name, alias, str(m.dimension), m.description, is_default)
+
+    console.print(table)
+
+
+@models_cmd.command("info")
+@click.argument("model_name")
+def models_info(model_name: str) -> None:
+    """Show detailed information about a specific model."""
+    info = get_model_info(model_name)
+    if info is None:
+        print_error(f"Unknown model: {model_name}")
+        raise SystemExit(1)
+
+    from rich.panel import Panel
+    from rich.text import Text
+
+    body = Text()
+    body.append(f"Name:            ", style="bold")
+    body.append(f"{info.name}\n")
+    body.append(f"Display name:    ", style="bold")
+    body.append(f"{info.display_name}\n")
+    body.append(f"Dimension:       ", style="bold")
+    body.append(f"{info.dimension}\n")
+    body.append(f"Backend:         ", style="bold")
+    body.append(f"{info.backend}\n")
+    body.append(f"Recommended for: ", style="bold")
+    body.append(f"{info.recommended_for}\n")
+    body.append(f"Description:     ", style="bold")
+    body.append(info.description)
+
+    console.print(Panel(body, title=f"[bold]{info.display_name}[/bold]", border_style="cyan"))
+
+
+@models_cmd.command("download")
+@click.argument("model_name")
+@click.option("--backend", type=click.Choice(["auto", "onnx", "torch"]), default="auto")
+def models_download(model_name: str, backend: str) -> None:
+    """Pre-download a model so it is cached locally for offline use."""
+    resolved = resolve_model_name(model_name)
+    print_info(f"Downloading model: {resolved} (backend={backend}) ...")
+
+    from semantic_code_intelligence.embeddings.generator import get_model
+
+    try:
+        model = get_model(resolved, backend=backend)
+        dim = model.get_sentence_embedding_dimension()
+        print_success(f"Model '{resolved}' ready — dimension={dim}")
+    except Exception as exc:
+        print_error(f"Failed to download model: {exc}")
+        raise SystemExit(1) from exc
+
+
+@models_cmd.command("switch")
+@click.argument("model_name")
+@click.option(
+    "--path",
+    "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path.",
+)
+def models_switch(model_name: str, path: str) -> None:
+    """Switch the active embedding model for a project.
+
+    Note: after switching models you must re-index (codexa index --reindex).
+    """
+    resolved = resolve_model_name(model_name)
+    info = get_model_info(resolved)
+    if info is None:
+        print_warning(f"Model '{resolved}' is not in the built-in catalogue — using as custom HF model.")
+
+    root = Path(path).resolve()
+    config_dir = AppConfig.config_dir(root)
+    if not config_dir.exists():
+        print_error(f"Project not initialized at {root}. Run 'codexa init' first.")
+        raise SystemExit(1)
+
+    config = load_config(root)
+    old_model = config.embedding.model_name
+    config.embedding.model_name = resolved
+    save_config(config, root)
+    print_success(f"Switched model: {old_model} → {resolved}")
+    print_info("Run 'codexa index --reindex' to rebuild the index with the new model.")