codexa 0.4.0__py3-none-any.whl

semantic_code_intelligence/cli/commands/context_cmd.py

@@ -0,0 +1,120 @@
+"""CLI command: context — generate structured context for external tools."""
+
+from __future__ import annotations
+
+import json as json_mod
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.utils.logging import (
+    console,
+    get_logger,
+    print_error,
+    print_info,
+)
+
+logger = get_logger("cli.context")
+
+
+@click.command("context")
+@click.argument("mode", type=click.Choice(["query", "symbol", "file", "repo"]))
+@click.argument("target", required=False, default=None)
+@click.option(
+    "--top-k",
+    "-k",
+    default=5,
+    type=int,
+    help="Number of results for query mode.",
+)
+@click.option(
+    "--file-path",
+    "-f",
+    default=None,
+    type=str,
+    help="File path hint (for symbol mode).",
+)
+@click.option(
+    "--json-output",
+    "--json",
+    "json_mode",
+    is_flag=True,
+    default=False,
+    help="Output raw JSON (default is pretty-printed).",
+)
+@click.option(
+    "--path",
+    "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path.",
+)
+@click.pass_context
+def context_cmd(
+    ctx: click.Context,
+    mode: str,
+    target: str | None,
+    top_k: int,
+    file_path: str | None,
+    json_mode: bool,
+    path: str,
+) -> None:
+    """Generate structured context for external AI pipelines.
+
+    \b
+    Modes:
+      query   — semantic search (TARGET = search query)
+      symbol  — symbol context  (TARGET = symbol name)
+      file    — file context    (TARGET = file path)
+      repo    — repo summary    (no TARGET needed)
+    """
+    from semantic_code_intelligence.bridge.context_provider import ContextProvider
+
+    project_root = Path(path)
+    provider = ContextProvider(project_root)
+
+    try:
+        if mode == "query":
+            if not target:
+                print_error("Query mode requires a TARGET argument (the search query).")
+                ctx.exit(1)
+                return
+            data = provider.context_for_query(query=target, top_k=top_k)
+
+        elif mode == "symbol":
+            if not target:
+                print_error("Symbol mode requires a TARGET argument (symbol name).")
+                ctx.exit(1)
+                return
+            data = provider.context_for_symbol(
+                symbol_name=target, file_path=file_path,
+            )
+
+        elif mode == "file":
+            if not target:
+                print_error("File mode requires a TARGET argument (file path).")
+                ctx.exit(1)
+                return
+            data = provider.context_for_file(file_path=target)
+
+        elif mode == "repo":
+            data = provider.context_for_repo()
+
+        else:
+            print_error(f"Unknown mode: {mode}")
+            ctx.exit(1)
+            return
+
+    except Exception as exc:
+        logger.exception("Context generation failed")
+        print_error(f"Error: {exc}")
+        ctx.exit(1)
+        return
+
+    if json_mode:
+        click.echo(json_mod.dumps(data, indent=2))
+    else:
+        from rich.syntax import Syntax
+
+        formatted = json_mod.dumps(data, indent=2)
+        console.print(Syntax(formatted, "json", theme="monokai"))

semantic_code_intelligence/cli/commands/cross_refactor_cmd.py

@@ -0,0 +1,113 @@
+"""CLI command: cross-refactor — cross-repository refactoring suggestions."""
+
+from __future__ import annotations
+
+import json as json_mod
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.utils.logging import (
+    console,
+    get_logger,
+    print_error,
+    print_info,
+)
+
+logger = get_logger("cli.cross_refactor")
+
+
+@click.command("cross-refactor")
+@click.option(
+    "--json-output", "--json", "json_mode",
+    is_flag=True,
+    default=False,
+    help="Output in JSON format.",
+)
+@click.option(
+    "--threshold", "-t",
+    default=0.70,
+    type=float,
+    help="Similarity threshold for duplicate detection (0.0-1.0).",
+)
+@click.option(
+    "--path", "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Workspace root path.",
+)
+@click.option("--pipe", is_flag=True, default=False, hidden=True)
+@click.pass_context
+def cross_refactor_cmd(
+    ctx: click.Context,
+    json_mode: bool,
+    threshold: float,
+    path: str,
+    pipe: bool,
+) -> None:
+    """Analyse workspace repos for cross-repo refactoring opportunities.
+
+    Scans all registered repositories in the workspace for duplicate logic,
+    inconsistent patterns, and symbols that could be extracted into a shared
+    library.  When an LLM is configured, generates actionable suggestions.
+    """
+    from semantic_code_intelligence.llm.cross_refactor import analyze_cross_repo
+
+    root = Path(path).resolve()
+    pipe = pipe or ctx.obj.get("pipe", False)
+
+    # Optionally get LLM provider for suggestions
+    provider = None
+    try:
+        from semantic_code_intelligence.config.settings import load_config
+
+        config = load_config(root)
+        if config.llm.provider != "none":
+            from semantic_code_intelligence.cli.commands.chat_cmd import _get_provider
+
+            provider = _get_provider(config)
+    except Exception:
+        logger.debug("LLM provider not available; running without AI suggestions")
+
+    result = analyze_cross_repo(root, provider=provider, threshold=threshold)
+
+    if json_mode:
+        click.echo(json_mod.dumps(result.to_dict(), indent=2))
+    elif pipe:
+        click.echo(f"Repos: {', '.join(result.repos_analyzed)}")
+        click.echo(f"Symbols: {result.total_symbols}")
+        click.echo(f"Matches: {len(result.matches)}")
+        for m in result.matches:
+            click.echo(f"  {m.repo_a}/{m.symbol_a} <-> {m.repo_b}/{m.symbol_b} ({m.similarity_note})")
+        for s in result.suggestions:
+            click.echo(f"  Suggestion: {s.get('title', 'N/A')}")
+    else:
+        from rich.table import Table
+        from rich.panel import Panel
+
+        if not result.repos_analyzed:
+            print_info("No workspace found. Use 'codexa workspace init' first.")
+            return
+
+        console.print(f"[bold]Cross-repo analysis[/] — {result.total_symbols} symbols across {len(result.repos_analyzed)} repos")
+
+        if result.matches:
+            table = Table(title="Cross-Repo Duplicates")
+            table.add_column("Repo A")
+            table.add_column("Symbol A")
+            table.add_column("Repo B")
+            table.add_column("Symbol B")
+            table.add_column("Similarity")
+            for m in result.matches[:20]:
+                table.add_row(m.repo_a, m.symbol_a, m.repo_b, m.symbol_b, m.similarity_note)
+            console.print(table)
+        else:
+            print_info("No cross-repo duplicates detected.")
+
+        if result.suggestions:
+            console.print()
+            for s in result.suggestions:
+                console.print(Panel(
+                    f"{s.get('description', '')}",
+                    title=f"[bold]{s.get('title', 'Suggestion')}[/] [{s.get('priority', 'medium')}]",
+                ))

semantic_code_intelligence/cli/commands/deps_cmd.py

@@ -0,0 +1,91 @@
+"""CLI command: deps — show file/project dependency map."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.config.settings import load_config
+from semantic_code_intelligence.context.engine import DependencyMap
+from semantic_code_intelligence.indexing.scanner import scan_repository
+from semantic_code_intelligence.utils.logging import (
+    console,
+    get_logger,
+    print_error,
+    print_info,
+)
+
+logger = get_logger("cli.deps")
+
+
+@click.command("deps")
+@click.argument("target", type=str, default=".")
+@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.pass_context
+def deps_cmd(ctx: click.Context, target: str, path: str, json_mode: bool) -> None:
+    """Show the dependency/import map for a file or the whole project.
+
+    TARGET can be a specific file path or '.' for the whole project.
+
+    Examples:
+
+        codexa deps src/main.py
+
+        codexa deps .
+
+        codexa deps . --json
+    """
+    import json as json_mod
+
+    root = Path(path).resolve()
+    dep_map = DependencyMap()
+
+    if target != ".":
+        # Single file
+        fpath = (root / target).resolve()
+        if not fpath.exists():
+            print_error(f"File not found: {target}")
+            return
+        content = fpath.read_text(encoding="utf-8", errors="replace")
+        dep_map.add_file(str(fpath), content)
+    else:
+        # Whole project
+        config = load_config(root)
+        scanned = scan_repository(root, config.index)
+        if not json_mode:
+            print_info(f"Analyzing dependencies across {len(scanned)} files...")
+        for sf in scanned:
+            full_path = root / sf.relative_path
+            try:
+                content = full_path.read_text(encoding="utf-8", errors="replace")
+                dep_map.add_file(str(full_path), content)
+            except Exception:
+                logger.debug("Could not read %s", sf.relative_path)
+
+    data = dep_map.to_dict()
+
+    if json_mode:
+        click.echo(json_mod.dumps(data, indent=2))
+    else:
+        for file_path, deps_list in data.items():
+            console.print(f"\n[bold]{file_path}[/bold]")
+            if deps_list:
+                for dep in deps_list:
+                    console.print(f"  → {dep.get('import_text', dep)}")
+            else:
+                console.print("  (no imports)")

semantic_code_intelligence/cli/commands/docs_cmd.py

@@ -0,0 +1,101 @@
+"""CLI command: docs — generate project documentation."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.utils.logging import (
+    get_logger,
+    print_error,
+    print_info,
+    print_success,
+)
+
+logger = get_logger("cli.docs")
+
+
+@click.command("docs")
+@click.option(
+    "--output",
+    "-o",
+    default="docs",
+    type=click.Path(file_okay=False),
+    help="Output directory for generated docs.",
+)
+@click.option(
+    "--section",
+    "-s",
+    type=click.Choice(["cli", "plugins", "bridge", "tools", "all"], case_sensitive=False),
+    default="all",
+    help="Which documentation section to generate.",
+)
+@click.option(
+    "--json-output",
+    "--json",
+    "json_mode",
+    is_flag=True,
+    default=False,
+    help="Output file list as JSON.",
+)
+def docs_cmd(output: str, section: str, json_mode: bool) -> None:
+    """Generate Markdown documentation for CodexA components.
+
+    Produces auto-generated reference docs for CLI commands, plugin hooks,
+    bridge protocol, and tool registry.
+
+    Examples:
+
+        codexa docs
+
+        codexa docs --section plugins -o reference/
+
+        codexa docs --json
+    """
+    import json
+
+    from semantic_code_intelligence.docs import (
+        generate_all_docs,
+        generate_bridge_reference,
+        generate_cli_reference,
+        generate_plugin_reference,
+        generate_tool_reference,
+    )
+
+    out_dir = Path(output).resolve()
+
+    if section == "all":
+        generated = generate_all_docs(out_dir)
+    else:
+        out_dir.mkdir(parents=True, exist_ok=True)
+        generated = []
+
+        if section == "cli":
+            from semantic_code_intelligence.cli.main import cli
+
+            md = generate_cli_reference(cli)
+            (out_dir / "CLI.md").write_text(md, encoding="utf-8")
+            generated.append("CLI.md")
+        elif section == "plugins":
+            md = generate_plugin_reference()
+            (out_dir / "PLUGINS.md").write_text(md, encoding="utf-8")
+            generated.append("PLUGINS.md")
+        elif section == "bridge":
+            md = generate_bridge_reference()
+            (out_dir / "BRIDGE.md").write_text(md, encoding="utf-8")
+            generated.append("BRIDGE.md")
+        elif section == "tools":
+            md = generate_tool_reference()
+            (out_dir / "TOOLS.md").write_text(md, encoding="utf-8")
+            generated.append("TOOLS.md")
+
+    if json_mode:
+        click.echo(json.dumps({"output_dir": str(out_dir), "files": generated}))
+    else:
+        if generated:
+            for f in generated:
+                print_success(f"Generated {out_dir / f}")
+            print_info(f"{len(generated)} doc(s) written to {out_dir}/")
+        else:
+            print_error("No documentation generated.")

semantic_code_intelligence/cli/commands/doctor_cmd.py

@@ -0,0 +1,147 @@
+"""CLI command: doctor — check environment health and dependencies."""
+
+from __future__ import annotations
+
+import importlib
+import json as json_mod
+import platform
+import sys
+from pathlib import Path
+from typing import Any
+
+import click
+
+from semantic_code_intelligence import __version__
+from semantic_code_intelligence.utils.logging import (
+    console,
+    get_logger,
+    print_error,
+    print_info,
+    print_success,
+    print_warning,
+)
+
+logger = get_logger("cli.doctor")
+
+
+def _check_python() -> dict[str, Any]:
+    """Check Python version."""
+    ver = platform.python_version()
+    ok = sys.version_info >= (3, 11)
+    return {
+        "name": "Python",
+        "version": ver,
+        "ok": ok,
+        "detail": f"Python {ver}" + ("" if ok else " (3.11+ required)"),
+    }
+
+
+def _check_package(pkg_name: str, import_name: str | None = None) -> dict[str, Any]:
+    """Check if a Python package is importable."""
+    mod_name = import_name or pkg_name
+    try:
+        importlib.import_module(mod_name)
+        # Prefer importlib.metadata to avoid deprecated __version__ attributes
+        try:
+            from importlib.metadata import version as meta_version
+            ver = meta_version(pkg_name)
+        except Exception:
+            ver = "installed"
+        return {"name": pkg_name, "version": str(ver), "ok": True, "detail": f"{pkg_name} {ver}"}
+    except ImportError:
+        return {"name": pkg_name, "version": None, "ok": False, "detail": f"{pkg_name} not installed"}
+
+
+def _check_project(path: Path) -> dict[str, Any]:
+    """Check if a CodexA project is initialized at the given path."""
+    config_dir = path / ".codexa"
+    if config_dir.is_dir():
+        index_dir = config_dir / "index"
+        has_index = index_dir.is_dir() and any(index_dir.iterdir()) if index_dir.is_dir() else False
+        return {
+            "name": "Project",
+            "version": None,
+            "ok": True,
+            "detail": f"Initialized at {path}" + (" (indexed)" if has_index else " (not indexed)"),
+        }
+    return {
+        "name": "Project",
+        "version": None,
+        "ok": False,
+        "detail": f"Not initialized at {path} — run 'codexa init'",
+    }
+
+
+def run_checks(path: Path) -> list[dict[str, Any]]:
+    """Run all health checks and return results."""
+    checks = [
+        _check_python(),
+        {"name": "CodexA", "version": __version__, "ok": True, "detail": f"CodexA {__version__}"},
+        _check_package("click"),
+        _check_package("pydantic"),
+        _check_package("rich"),
+        _check_package("sentence_transformers", "sentence_transformers"),
+        _check_package("faiss", "faiss"),
+        _check_package("tree_sitter", "tree_sitter"),
+        _check_project(path),
+    ]
+    return checks
+
+
+@click.command("doctor")
+@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 results in JSON format.",
+)
+def doctor_cmd(path: str, json_mode: bool) -> None:
+    """Check environment health, dependencies, and project status.
+
+    Useful for debugging installation issues or verifying that all
+    required packages are available.
+
+    Examples:
+
+        codexa doctor
+
+        codexa doctor --json
+
+        codexa doctor -p /path/to/project
+    """
+    checks = run_checks(Path(path))
+
+    if json_mode:
+        click.echo(json_mod.dumps({"checks": checks}, indent=2))
+        return
+
+    from rich.table import Table
+
+    table = Table(title="CodexA Health Check", show_lines=False)
+    table.add_column("Component", style="bold")
+    table.add_column("Status")
+    table.add_column("Detail")
+
+    all_ok = True
+    for c in checks:
+        status = "[green]OK[/green]" if c["ok"] else "[red]FAIL[/red]"
+        if not c["ok"]:
+            all_ok = False
+        table.add_row(c["name"], status, c["detail"])
+
+    console.print(table)
+    console.print()
+
+    if all_ok:
+        print_success("All checks passed.")
+    else:
+        print_warning("Some checks failed. See details above.")