codexa 0.4.0__py3-none-any.whl

semantic_code_intelligence/cli/commands/refactor_cmd.py

@@ -0,0 +1,103 @@
+"""CLI command: refactor — AI-powered refactoring suggestions for a file."""
+
+from __future__ import annotations
+
+import json as json_mod
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.config.settings import AppConfig, load_config
+from semantic_code_intelligence.utils.logging import (
+    console,
+    get_logger,
+    print_error,
+    print_info,
+)
+
+logger = get_logger("cli.refactor")
+
+
+@click.command("refactor")
+@click.argument(
+    "file",
+    type=click.Path(exists=True, dir_okay=False, resolve_path=True),
+)
+@click.option(
+    "--instruction",
+    "-i",
+    default="Improve code quality, readability, and performance.",
+    help="Refactoring instruction for the AI.",
+)
+@click.option(
+    "--json-output",
+    "--json",
+    "json_mode",
+    is_flag=True,
+    default=False,
+    help="Output in JSON format.",
+)
+@click.option(
+    "--path",
+    "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path.",
+)
+@click.pass_context
+def refactor_cmd(
+    ctx: click.Context,
+    file: str,
+    instruction: str,
+    json_mode: bool,
+    path: str,
+) -> None:
+    """Suggest refactored code for a source file.
+
+    Uses structural analysis + LLM to propose improved code with explanations.
+
+    Examples:
+
+        codexa refactor src/main.py
+
+        codexa refactor src/utils.py -i "Extract duplicated logic into helpers"
+    """
+    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
+
+    config = load_config(root)
+
+    from semantic_code_intelligence.cli.commands.ask_cmd import _get_provider
+    from semantic_code_intelligence.llm.reasoning import ReasoningEngine
+    from semantic_code_intelligence.llm.safety import SafetyValidator
+
+    provider = _get_provider(config)
+    engine = ReasoningEngine(provider, root)
+    result = engine.refactor(file, instruction)
+
+    # Safety check on refactored code
+    if result.refactored_code:
+        validator = SafetyValidator()
+        report = validator.validate(result.refactored_code)
+        if not report.safe:
+            from semantic_code_intelligence.utils.logging import _ICON_WARNING
+            console.print(f"[bold red]{_ICON_WARNING} Safety issues detected in refactored code:[/bold red]")
+            for issue in report.issues:
+                console.print(f"  L{issue.line_number}: {issue.description}")
+            console.print()
+
+    if json_mode:
+        click.echo(json_mod.dumps(result.to_dict(), indent=2))
+    else:
+        console.print(f"\n[bold cyan]Refactor:[/bold cyan] {result.file_path}\n")
+        console.print(f"[bold green]Explanation:[/bold green]\n{result.explanation}\n")
+        if result.refactored_code:
+            console.print("[bold]Refactored code:[/bold]")
+            console.print(result.refactored_code)
+        else:
+            print_info("No refactored code produced (check LLM configuration).")

semantic_code_intelligence/cli/commands/review_cmd.py

@@ -0,0 +1,88 @@
+"""CLI command: review — AI-powered code review of a file."""
+
+from __future__ import annotations
+
+import json as json_mod
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.config.settings import AppConfig, load_config
+from semantic_code_intelligence.utils.logging import (
+    console,
+    get_logger,
+    print_error,
+)
+
+logger = get_logger("cli.review")
+
+
+@click.command("review")
+@click.argument(
+    "file",
+    type=click.Path(exists=True, dir_okay=False, resolve_path=True),
+)
+@click.option(
+    "--json-output",
+    "--json",
+    "json_mode",
+    is_flag=True,
+    default=False,
+    help="Output in JSON format.",
+)
+@click.option(
+    "--path",
+    "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path.",
+)
+@click.pass_context
+def review_cmd(
+    ctx: click.Context,
+    file: str,
+    json_mode: bool,
+    path: str,
+) -> None:
+    """Review a source file for issues, bugs, and improvements.
+
+    Uses structural analysis + LLM to perform an AI-assisted code review.
+
+    Examples:
+
+        codexa review src/main.py
+
+        codexa review src/utils.py --json
+    """
+    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
+
+    config = load_config(root)
+
+    from semantic_code_intelligence.cli.commands.ask_cmd import _get_provider
+    from semantic_code_intelligence.llm.reasoning import ReasoningEngine
+
+    provider = _get_provider(config)
+    engine = ReasoningEngine(provider, root)
+    result = engine.review(file)
+
+    if json_mode:
+        click.echo(json_mod.dumps(result.to_dict(), indent=2))
+    else:
+        console.print(f"\n[bold cyan]Code Review:[/bold cyan] {result.file_path}\n")
+        if result.issues:
+            for issue in result.issues:
+                sev = issue.get("severity", "info")
+                line = issue.get("line", "?")
+                msg = issue.get("message", str(issue))
+                color = {"error": "red", "warning": "yellow"}.get(sev, "blue")
+                console.print(f"  [{color}]{sev.upper()}[/{color}] L{line}: {msg}")
+                if issue.get("suggestion"):
+                    console.print(f"    [dim]Suggestion: {issue['suggestion']}[/dim]")
+            console.print()
+        console.print(f"[bold green]Summary:[/bold green]\n{result.summary}")

semantic_code_intelligence/cli/commands/search_cmd.py

@@ -0,0 +1,236 @@
+"""CLI command: search - Perform semantic, keyword, regex, or hybrid search."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.config.settings import AppConfig, load_config
+from semantic_code_intelligence.services.search_service import SearchMode, search_codebase
+from semantic_code_intelligence.search.formatter import (
+    format_results_json,
+    format_results_jsonl,
+    format_results_rich,
+)
+from semantic_code_intelligence.utils.logging import (
+    get_logger,
+    print_error,
+    print_info,
+    print_warning,
+    console,
+)
+
+logger = get_logger("cli.search")
+
+
+@click.command("search")
+@click.argument("query", type=str)
+@click.option(
+    "--top-k",
+    "-k",
+    default=None,
+    type=int,
+    help="Number of results to return (overrides config).",
+)
+@click.option(
+    "--json-output",
+    "--json",
+    "json_mode",
+    is_flag=True,
+    default=False,
+    help="Output results in JSON format for AI integration.",
+)
+@click.option(
+    "--jsonl",
+    "jsonl_mode",
+    is_flag=True,
+    default=False,
+    help="Output one JSON object per line (JSONL), for piping into jq/fzf.",
+)
+@click.option(
+    "--path",
+    "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path.",
+)
+@click.option(
+    "--mode",
+    "-m",
+    type=click.Choice(["semantic", "keyword", "regex", "hybrid"], case_sensitive=False),
+    default="semantic",
+    help="Search mode: semantic (default), keyword (BM25), regex, or hybrid (RRF).",
+)
+@click.option(
+    "--full-section",
+    "--full",
+    is_flag=True,
+    default=False,
+    help="Expand results to show the full enclosing function/class.",
+)
+@click.option(
+    "--no-auto-index",
+    is_flag=True,
+    default=False,
+    help="Disable automatic indexing on first search.",
+)
+@click.option(
+    "--case-sensitive",
+    "-s",
+    is_flag=True,
+    default=False,
+    help="Case-sensitive matching (regex mode only).",
+)
+@click.option(
+    "--context-lines",
+    "-C",
+    default=0,
+    type=int,
+    help="Show N context lines before/after each match (grep-style).",
+)
+@click.option(
+    "--files-only",
+    "-l",
+    is_flag=True,
+    default=False,
+    help="Print only file paths with matches (like grep -l).",
+)
+@click.option(
+    "--files-without-match",
+    "-L",
+    is_flag=True,
+    default=False,
+    help="Print file paths without any matches (like grep -L).",
+)
+@click.option(
+    "--line-numbers",
+    "-n",
+    is_flag=True,
+    default=False,
+    help="Prefix each output line with its line number (like grep -n).",
+)
+@click.pass_context
+def search_cmd(
+    ctx: click.Context,
+    query: str,
+    top_k: int | None,
+    json_mode: bool,
+    jsonl_mode: bool,
+    path: str,
+    mode: str,
+    full_section: bool,
+    no_auto_index: bool,
+    case_sensitive: bool,
+    context_lines: int,
+    files_only: bool,
+    files_without_match: bool,
+    line_numbers: bool,
+) -> None:
+    """Search the indexed codebase using a natural language query.
+
+    Supports four search modes:
+
+    \b
+      semantic  — vector similarity (default)
+      keyword   — BM25 ranked keyword search
+      regex     — grep-compatible regex pattern matching
+      hybrid    — fused semantic + BM25 via Reciprocal Rank Fusion
+
+    Grep-compatible flags:
+
+    \b
+        -l   show only file paths with matches
+        -L   show only file paths without matches
+        -n   prefix lines with line numbers
+        -C N show N context lines before/after each match
+
+    Examples:
+
+    \b
+        codexa search "jwt verification"
+        codexa search "database connection" --mode hybrid
+        codexa search "def\\s+authenticate" --mode regex -n
+        codexa search "error handling" --mode keyword --full-section
+        codexa search "error handling" -k 5 --json
+        codexa search "TODO" --mode regex -l
+        codexa search "pattern" --jsonl | jq .file_path
+    """
+    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
+
+    config = load_config(root)
+    result_count = top_k or config.search.top_k
+
+    try:
+        results = search_codebase(
+            query=query,
+            project_root=root,
+            top_k=result_count,
+            mode=mode,  # type: ignore[arg-type]
+            full_section=full_section,
+            auto_index=not no_auto_index,
+            case_insensitive=not case_sensitive,
+        )
+    except FileNotFoundError:
+        if json_mode:
+            click.echo(format_results_json(query, [], result_count))
+        elif jsonl_mode:
+            pass  # no output for JSONL with no results
+        else:
+            print_warning(
+                "Search index is empty. Run 'codexa index' to build the index."
+            )
+        return
+
+    # --- Grep-style output modes ---
+
+    if files_without_match:
+        # Show all indexed files NOT in the results
+        matched_files = {r.file_path for r in results}
+        from semantic_code_intelligence.storage.vector_store import VectorStore
+        index_dir = AppConfig.index_dir(root)
+        try:
+            store = VectorStore.load(index_dir)
+            all_files = sorted({m.file_path for m in store.metadata})
+        except FileNotFoundError:
+            all_files = []
+        for fp in all_files:
+            if fp not in matched_files:
+                click.echo(fp)
+        return
+
+    if files_only:
+        seen: set[str] = set()
+        for r in results:
+            if r.file_path not in seen:
+                seen.add(r.file_path)
+                click.echo(r.file_path)
+        return
+
+    # --- Machine-readable output ---
+
+    if jsonl_mode:
+        click.echo(format_results_jsonl(results))
+        return
+
+    if json_mode:
+        click.echo(format_results_json(query, results, result_count))
+        return
+
+    # --- Rich / grep-style human output ---
+
+    format_results_rich(
+        query,
+        results,
+        line_numbers=line_numbers,
+        context_lines=context_lines,
+    )

semantic_code_intelligence/cli/commands/serve_cmd.py

@@ -0,0 +1,117 @@
+"""CLI command: serve — start the CodexA bridge server.
+
+Supports MCP-over-SSE via ``--mcp`` flag for AI agent integration.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.utils.logging import (
+    get_logger,
+    print_info,
+)
+
+logger = get_logger("cli.serve")
+
+
+@click.command("serve")
+@click.option(
+    "--host",
+    "-h",
+    default="127.0.0.1",
+    type=str,
+    help="Host to bind the bridge server to.",
+)
+@click.option(
+    "--port",
+    "-p",
+    default=24842,
+    type=int,
+    help="Port to bind the bridge server to.",
+)
+@click.option(
+    "--path",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path.",
+)
+@click.option(
+    "--mcp",
+    "mcp_mode",
+    is_flag=True,
+    default=False,
+    help="Expose MCP tools over HTTP+SSE (for AI agent integration).",
+)
+@click.pass_context
+def serve_cmd(
+    ctx: click.Context,
+    host: str,
+    port: int,
+    path: str,
+    mcp_mode: bool,
+) -> None:
+    """Start the CodexA bridge server for external AI integration.
+
+    Use --mcp to expose MCP-compliant tools over HTTP with SSE streaming.
+
+    \b
+    Examples:
+        codexa serve
+        codexa serve --port 8080
+        codexa serve --mcp
+    """
+    project_root = Path(path)
+
+    if mcp_mode:
+        _run_mcp_http(project_root, host, port)
+        return
+
+    from semantic_code_intelligence.bridge.server import BridgeServer
+
+    server = BridgeServer(project_root, host=host, port=port)
+
+    print_info(f"Starting CodexA bridge server on {server.url}")
+    print_info("Press Ctrl+C to stop.")
+
+    server.start()
+
+
+def _run_mcp_http(project_root: Path, host: str, port: int) -> None:
+    """Run MCP tools over HTTP+SSE using the streamable-http transport."""
+    try:
+        from mcp.server.sse import SseServerTransport
+        from starlette.applications import Starlette
+        from starlette.routing import Route, Mount
+        import uvicorn
+    except ImportError:
+        # Fallback: just run MCP stdio server
+        print_info("SSE/Starlette not installed — falling back to stdio MCP.")
+        from semantic_code_intelligence.mcp import run_mcp_server
+        run_mcp_server(project_root)
+        return
+
+    from semantic_code_intelligence.mcp import _create_server
+
+    server = _create_server(project_root)
+    sse = SseServerTransport("/messages/")
+
+    async def handle_sse(request):
+        async with sse.connect_sse(request.scope, request.receive, request._send) as streams:
+            await server.run(
+                streams[0], streams[1],
+                server.create_initialization_options(),
+            )
+
+    app = Starlette(
+        routes=[
+            Route("/sse", endpoint=handle_sse),
+            Mount("/messages/", app=sse.handle_post_message),
+        ],
+    )
+
+    print_info(f"MCP-over-SSE server on http://{host}:{port}/sse")
+    print_info("Press Ctrl+C to stop.")
+    uvicorn.run(app, host=host, port=port, log_level="info")

semantic_code_intelligence/cli/commands/suggest_cmd.py

@@ -0,0 +1,100 @@
+"""CLI command: suggest — AI-powered intelligent suggestions for a symbol/file."""
+
+from __future__ import annotations
+
+import json as json_mod
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.config.settings import AppConfig, load_config
+from semantic_code_intelligence.utils.logging import (
+    console,
+    get_logger,
+    print_error,
+)
+
+logger = get_logger("cli.suggest")
+
+
+@click.command("suggest")
+@click.argument("target", type=str)
+@click.option(
+    "--top-k",
+    "-k",
+    default=5,
+    type=int,
+    help="Number of context snippets to consider.",
+)
+@click.option(
+    "--json-output",
+    "--json",
+    "json_mode",
+    is_flag=True,
+    default=False,
+    help="Output in JSON format.",
+)
+@click.option(
+    "--path",
+    "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path.",
+)
+@click.pass_context
+def suggest_cmd(
+    ctx: click.Context,
+    target: str,
+    top_k: int,
+    json_mode: bool,
+    path: str,
+) -> None:
+    """Get intelligent suggestions for a symbol, file, or topic.
+
+    Combines call-graph, dependency, and semantic data with LLM reasoning
+    to produce actionable suggestions with "why" reasoning.
+
+    Examples:
+
+        codexa suggest search_codebase
+
+        codexa suggest "error handling patterns" --json
+    """
+    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
+
+    config = load_config(root)
+
+    from semantic_code_intelligence.cli.commands.ask_cmd import _get_provider
+    from semantic_code_intelligence.llm.reasoning import ReasoningEngine
+
+    provider = _get_provider(config)
+    engine = ReasoningEngine(provider, root)
+    result = engine.suggest(target, top_k=top_k)
+
+    if json_mode:
+        click.echo(json_mod.dumps(result.to_dict(), indent=2))
+    else:
+        console.print(f"\n[bold cyan]Suggestions for:[/bold cyan] {result.target}\n")
+        if result.suggestions:
+            for i, sug in enumerate(result.suggestions, 1):
+                title = sug.get("title", f"Suggestion {i}")
+                desc = sug.get("description", "")
+                reason = sug.get("reason", "")
+                priority = sug.get("priority", "medium")
+                color = {"high": "red", "medium": "yellow", "low": "green"}.get(
+                    priority, "blue"
+                )
+                console.print(f"  [{color}]{priority.upper()}[/{color}] {title}")
+                if desc:
+                    console.print(f"    {desc}")
+                if reason:
+                    console.print(f"    [dim]Why: {reason}[/dim]")
+                console.print()
+        else:
+            console.print("[dim]No suggestions generated.[/dim]")