codexa 0.4.0__py3-none-any.whl

semantic_code_intelligence/cli/commands/benchmark_cmd.py

@@ -0,0 +1,303 @@
+"""CLI command: benchmark — measure indexing speed, search latency, and memory usage."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.config.settings import AppConfig, load_config
+from semantic_code_intelligence.utils.logging import (
+    get_logger,
+    print_error,
+    print_info,
+    print_success,
+    console,
+)
+
+logger = get_logger("cli.benchmark")
+
+
+def _get_memory_mb() -> float:
+    """Get current process memory usage in MB."""
+    try:
+        import resource  # type: ignore[import-untyped]
+        return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024
+    except ImportError:
+        # Windows fallback
+        try:
+            import psutil  # type: ignore[import-untyped]
+            return psutil.Process(os.getpid()).memory_info().rss / (1024 * 1024)
+        except ImportError:
+            return 0.0
+
+
+def _format_duration(seconds: float) -> str:
+    if seconds < 1:
+        return f"{seconds * 1000:.1f}ms"
+    return f"{seconds:.2f}s"
+
+
+def _count_files(root: Path) -> int:
+    """Count indexable files without importing heavy modules."""
+    config = load_config(root)
+    extensions = set(config.index.extensions)
+    count = 0
+    for dirpath, _dirnames, filenames in os.walk(root):
+        if any(part.startswith(".") for part in Path(dirpath).relative_to(root).parts):
+            continue
+        for f in filenames:
+            if Path(f).suffix in extensions:
+                count += 1
+    return count
+
+
+@click.command("benchmark")
+@click.option(
+    "--path",
+    "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path to benchmark against.",
+)
+@click.option(
+    "--json-output",
+    "--json",
+    "json_mode",
+    is_flag=True,
+    default=False,
+    help="Output results as JSON.",
+)
+@click.option(
+    "--rounds",
+    "-r",
+    default=3,
+    type=int,
+    help="Number of search rounds for latency averaging.",
+)
+@click.option(
+    "--profile",
+    is_flag=True,
+    default=False,
+    help="Run cProfile on full indexing and dump top 20 hotspots.",
+)
+@click.pass_context
+def benchmark_cmd(
+    ctx: click.Context,
+    path: str,
+    json_mode: bool,
+    rounds: int,
+    profile: bool,
+) -> None:
+    """Benchmark indexing speed, search latency, and memory usage.
+
+    Measures the full indexing pipeline, incremental re-indexing, all
+    four search modes (semantic, keyword, regex, hybrid), and reports
+    memory consumption and cache hit rates.
+
+    Examples:
+
+    \b
+        codexa benchmark
+        codexa benchmark --json
+        codexa benchmark --rounds 5
+    """
+    from rich.table import Table
+
+    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
+
+    index_dir = AppConfig.index_dir(root)
+    results: dict[str, object] = {
+        "project_root": str(root),
+        "rounds": rounds,
+    }
+
+    file_count = _count_files(root)
+    results["file_count"] = file_count
+    print_info(f"Benchmarking {root} ({file_count} indexable files)")
+
+    # --- 1. Full indexing benchmark ---
+    print_info("1/5: Full indexing...")
+    mem_before = _get_memory_mb()
+    t0 = time.perf_counter()
+    from semantic_code_intelligence.services.indexing_service import run_indexing
+
+    if profile:
+        import cProfile
+        import pstats
+        import io
+
+        profiler = cProfile.Profile()
+        profiler.enable()
+        idx_result = run_indexing(root, force=True)
+        profiler.disable()
+        full_index_time = time.perf_counter() - t0
+
+        # Print profiling results
+        stream = io.StringIO()
+        stats = pstats.Stats(profiler, stream=stream)
+        stats.sort_stats("cumulative")
+        stats.print_stats(20)
+        print_info("cProfile top 20 hotspots (by cumulative time):")
+        click.echo(stream.getvalue())
+    else:
+        idx_result = run_indexing(root, force=True)
+        full_index_time = time.perf_counter() - t0
+
+    mem_after = _get_memory_mb()
+
+    results["full_index"] = {
+        "duration_s": round(full_index_time, 3),
+        "files_indexed": idx_result.files_indexed,
+        "chunks_created": idx_result.chunks_created,
+        "total_vectors": idx_result.total_vectors,
+        "symbols_extracted": idx_result.symbols_extracted,
+        "files_per_second": round(idx_result.files_indexed / full_index_time, 1) if full_index_time > 0 else 0,
+        "memory_delta_mb": round(mem_after - mem_before, 1),
+    }
+    print_success(f"   Full index: {_format_duration(full_index_time)} "
+                  f"({idx_result.files_indexed} files, {idx_result.chunks_created} chunks)")
+
+    # --- 2. Incremental indexing benchmark (no changes → should be fast) ---
+    print_info("2/5: Incremental indexing (no changes)...")
+    t0 = time.perf_counter()
+    inc_result = run_indexing(root, force=False)
+    inc_time = time.perf_counter() - t0
+
+    results["incremental_index"] = {
+        "duration_s": round(inc_time, 3),
+        "files_skipped": inc_result.files_skipped,
+        "files_indexed": inc_result.files_indexed,
+        "chunks_reused": inc_result.chunks_reused,
+        "cache_hit_rate": round(
+            100 * inc_result.files_skipped / inc_result.files_scanned, 1
+        ) if inc_result.files_scanned > 0 else 100.0,
+    }
+    print_success(f"   Incremental: {_format_duration(inc_time)} "
+                  f"(cache hit {results['incremental_index']['cache_hit_rate']}%)")
+
+    # --- 3. Search latency benchmarks ---
+    print_info("3/5: Search latency ({} rounds)...".format(rounds))
+    test_queries = [
+        "authentication middleware",
+        "error handling",
+        "database connection",
+        "parse configuration",
+        "search codebase",
+    ]
+    from semantic_code_intelligence.services.search_service import search_codebase
+
+    search_results: dict[str, dict[str, float]] = {}
+    for mode in ["semantic", "keyword", "regex", "hybrid"]:
+        times: list[float] = []
+        for _r in range(rounds):
+            for query in test_queries:
+                q = query if mode != "regex" else r"def\s+\w+"
+                t0 = time.perf_counter()
+                try:
+                    search_codebase(
+                        query=q,
+                        project_root=root,
+                        top_k=10,
+                        mode=mode,
+                        auto_index=False,
+                    )
+                except Exception:
+                    pass
+                times.append(time.perf_counter() - t0)
+        avg_ms = (sum(times) / len(times)) * 1000 if times else 0
+        p50_ms = sorted(times)[len(times) // 2] * 1000 if times else 0
+        p99_ms = sorted(times)[int(len(times) * 0.99)] * 1000 if times else 0
+        search_results[mode] = {
+            "avg_ms": round(avg_ms, 2),
+            "p50_ms": round(p50_ms, 2),
+            "p99_ms": round(p99_ms, 2),
+            "queries_per_second": round(1000 / avg_ms, 1) if avg_ms > 0 else 0,
+        }
+        print_success(f"   {mode:>8}: avg={avg_ms:.1f}ms  p50={p50_ms:.1f}ms  p99={p99_ms:.1f}ms")
+
+    results["search_latency"] = search_results
+
+    # --- 4. BM25 index load benchmark ---
+    print_info("4/5: BM25 index persistence...")
+    from semantic_code_intelligence.search.keyword_search import BM25Index, _bm25_cache
+    from semantic_code_intelligence.storage.vector_store import VectorStore
+
+    _bm25_cache.clear()  # force disk load
+    store = VectorStore.load(index_dir)
+
+    t0 = time.perf_counter()
+    bm25_loaded = BM25Index.load(index_dir, store.metadata)
+    bm25_load_time = time.perf_counter() - t0
+
+    t0 = time.perf_counter()
+    bm25_fresh = BM25Index(store.metadata)
+    bm25_build_time = time.perf_counter() - t0
+
+    results["bm25"] = {
+        "load_from_disk_ms": round(bm25_load_time * 1000, 2),
+        "build_from_scratch_ms": round(bm25_build_time * 1000, 2),
+        "speedup": round(bm25_build_time / bm25_load_time, 1) if bm25_load_time > 0 else 0,
+        "loaded_from_cache": bm25_loaded is not None,
+    }
+    print_success(f"   BM25 load: {bm25_load_time*1000:.1f}ms (vs build: {bm25_build_time*1000:.1f}ms)")
+
+    # --- 5. Memory snapshot ---
+    print_info("5/5: Memory usage...")
+    peak_mem = _get_memory_mb()
+    results["memory"] = {
+        "peak_mb": round(peak_mem, 1),
+        "index_size_mb": round(
+            sum(f.stat().st_size for f in index_dir.iterdir() if f.is_file()) / (1024 * 1024), 2
+        ) if index_dir.exists() else 0,
+    }
+    print_success(f"   Peak memory: {peak_mem:.0f}MB, Index size: {results['memory']['index_size_mb']:.1f}MB")
+
+    # --- Output ---
+    if json_mode:
+        click.echo(json.dumps(results, indent=2))
+    else:
+        table = Table(title="CodexA Benchmark Results", show_header=True)
+        table.add_column("Metric", style="cyan", min_width=30)
+        table.add_column("Value", style="green", min_width=20)
+
+        table.add_row("Project", str(root))
+        table.add_row("Indexable files", str(file_count))
+        table.add_row("", "")
+
+        fi = results["full_index"]
+        table.add_row("Full index time", _format_duration(fi["duration_s"]))
+        table.add_row("Files/second", f"{fi['files_per_second']}")
+        table.add_row("Total chunks", str(fi["chunks_created"]))
+        table.add_row("Total vectors", str(fi["total_vectors"]))
+        table.add_row("Symbols extracted", str(fi["symbols_extracted"]))
+        table.add_row("", "")
+
+        ii = results["incremental_index"]
+        table.add_row("Incremental index time", _format_duration(ii["duration_s"]))
+        table.add_row("Cache hit rate", f"{ii['cache_hit_rate']}%")
+        table.add_row("", "")
+
+        for mode, stats in search_results.items():
+            table.add_row(f"Search ({mode}) avg", f"{stats['avg_ms']:.1f}ms")
+            table.add_row(f"Search ({mode}) QPS", f"{stats['queries_per_second']}")
+
+        table.add_row("", "")
+        bm25 = results["bm25"]
+        table.add_row("BM25 load (disk)", f"{bm25['load_from_disk_ms']:.1f}ms")
+        table.add_row("BM25 build (fresh)", f"{bm25['build_from_scratch_ms']:.1f}ms")
+        table.add_row("BM25 speedup", f"{bm25['speedup']}x")
+        table.add_row("", "")
+        table.add_row("Peak memory", f"{results['memory']['peak_mb']:.0f}MB")
+        table.add_row("Index size on disk", f"{results['memory']['index_size_mb']:.1f}MB")
+
+        console.print(table)

semantic_code_intelligence/cli/commands/chat_cmd.py

@@ -0,0 +1,252 @@
+"""CLI command: chat — multi-turn conversation with session persistence."""
+
+from __future__ import annotations
+
+import json as json_mod
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import click
+
+from semantic_code_intelligence.utils.logging import (
+    console,
+    get_logger,
+    print_error,
+    print_info,
+)
+
+if TYPE_CHECKING:
+    from semantic_code_intelligence.llm.provider import LLMProvider
+
+logger = get_logger("cli.chat")
+
+
+def _wrap_provider(provider: LLMProvider, llm: Any, config: Any) -> LLMProvider:
+    """Wrap a provider with caching and rate limiting based on config."""
+    from semantic_code_intelligence.llm.cache import LLMCache
+    from semantic_code_intelligence.llm.cached_provider import CachedProvider
+    from semantic_code_intelligence.llm.rate_limiter import RateLimiter
+
+    cache = None
+    if getattr(llm, "cache_enabled", False):
+        cache_dir = str(config.config_dir(config.project_root)) if hasattr(config, "config_dir") else None
+        cache = LLMCache(
+            cache_dir=cache_dir,
+            ttl_hours=getattr(llm, "cache_ttl_hours", 24),
+            max_entries=getattr(llm, "cache_max_entries", 1000),
+        )
+
+    rate_limiter = None
+    rpm = getattr(llm, "rate_limit_rpm", 0)
+    tpm = getattr(llm, "rate_limit_tpm", 0)
+    if rpm > 0 or tpm > 0:
+        rate_limiter = RateLimiter(rpm=rpm, tpm=tpm)
+
+    if cache is not None or rate_limiter is not None:
+        return CachedProvider(provider, cache=cache, rate_limiter=rate_limiter)
+    return provider
+
+
+def _get_provider(config: Any) -> LLMProvider:
+    """Build an LLM provider from the app configuration."""
+    from semantic_code_intelligence.config.settings import LLMConfig
+
+    llm: LLMConfig = config.llm
+    if llm.provider == "openai":
+        from semantic_code_intelligence.llm.openai_provider import OpenAIProvider
+
+        provider: LLMProvider = OpenAIProvider(
+            api_key=llm.api_key,
+            model=llm.model,
+            base_url=llm.base_url or None,
+            temperature=llm.temperature,
+            max_tokens=llm.max_tokens,
+        )
+    elif llm.provider == "ollama":
+        from semantic_code_intelligence.llm.ollama_provider import OllamaProvider
+
+        provider = OllamaProvider(
+            model=llm.model,
+            base_url=llm.base_url or "http://localhost:11434",
+            temperature=llm.temperature,
+            max_tokens=llm.max_tokens,
+        )
+    else:
+        from semantic_code_intelligence.llm.mock_provider import MockProvider
+
+        provider = MockProvider()
+
+    return _wrap_provider(provider, llm, config)
+
+
+@click.command("chat")
+@click.argument("message", type=str)
+@click.option(
+    "--session", "-s",
+    default=None,
+    type=str,
+    help="Session ID to resume. Creates a new session if not given.",
+)
+@click.option(
+    "--list-sessions", "list_sessions",
+    is_flag=True,
+    default=False,
+    help="List all stored chat sessions and exit.",
+)
+@click.option(
+    "--json-output", "--json", "json_mode",
+    is_flag=True,
+    default=False,
+    help="Output in JSON format.",
+)
+@click.option(
+    "--max-turns", "-t",
+    default=20,
+    type=int,
+    help="Maximum conversation turns to send to LLM.",
+)
+@click.option(
+    "--path", "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path.",
+)
+@click.option(
+    "--stream",
+    is_flag=True,
+    default=False,
+    help="Stream tokens incrementally as they arrive.",
+)
+@click.option("--pipe", is_flag=True, default=False, hidden=True)
+@click.pass_context
+def chat_cmd(
+    ctx: click.Context,
+    message: str,
+    session: str | None,
+    list_sessions: bool,
+    json_mode: bool,
+    max_turns: int,
+    path: str,
+    stream: bool,
+    pipe: bool,
+) -> None:
+    """Continue or start a multi-turn conversation about the codebase.
+
+    Each conversation is persisted to disk so you can resume later with
+    --session <id>.  Use --list-sessions to see saved conversations.
+    """
+    from semantic_code_intelligence.config.settings import load_config
+    from semantic_code_intelligence.llm.conversation import SessionStore
+    from semantic_code_intelligence.llm.reasoning import ReasoningEngine
+
+    root = Path(path).resolve()
+    pipe = pipe or ctx.obj.get("pipe", False)
+
+    store = SessionStore(root)
+
+    # --- list sessions mode ---
+    if list_sessions:
+        sessions = store.list_sessions()
+        if json_mode:
+            click.echo(json_mod.dumps(sessions, indent=2))
+        elif pipe:
+            for s in sessions:
+                click.echo(f"{s['session_id']}  turns={s['turns']}  {s['title']}")
+        else:
+            if not sessions:
+                print_info("No stored sessions.")
+            else:
+                from rich.table import Table
+
+                table = Table(title="Chat Sessions")
+                table.add_column("ID")
+                table.add_column("Title")
+                table.add_column("Turns")
+                for s in sessions:
+                    table.add_row(s["session_id"], s["title"], str(s["turns"]))
+                console.print(table)
+        return
+
+    # --- conversation mode ---
+    config = load_config(root)
+    provider = _get_provider(config)
+
+    conv = store.get_or_create(session)
+
+    # If this is a fresh session, set up the system prompt
+    if not conv.messages:
+        conv.add_system(
+            "You are CodexA, an AI coding assistant. Answer questions about the "
+            "user's codebase. Be concise, accurate, and cite file paths when relevant."
+        )
+        conv.title = message[:60]
+
+    # Add user message
+    conv.add_user(message)
+
+    # Get context-enriched messages
+    messages = conv.get_messages_for_llm(max_turns=max_turns)
+
+    # Also inject search context into the user's message
+    engine = ReasoningEngine(provider, root)
+    try:
+        snippets = engine._search_context(message, top_k=3)
+        if snippets:
+            ctx_text = "\n".join(
+                f"[{s.get('file_path', '?')}] {s.get('content', '')[:200]}"
+                for s in snippets[:3]
+            )
+            # Inject context before the last user message
+            messages[-1] = type(messages[-1])(
+                role=messages[-1].role,
+                content=f"Relevant code:\n{ctx_text}\n\nUser: {message}",
+            )
+    except Exception:
+        logger.debug("Context injection failed; continuing without code context")
+
+    # Call LLM (streaming or batch)
+    if stream and not json_mode:
+        from semantic_code_intelligence.llm.streaming import stream_chat
+
+        gen = stream_chat(provider, messages)
+        accumulated = ""
+        if not pipe:
+            console.print(f"[bold cyan]CodexA [{conv.session_id}][/]", end="")
+            click.echo("")
+        for event in gen:
+            if event.kind == "token":
+                accumulated += event.content
+                click.echo(event.content, nl=False)
+        click.echo("")  # trailing newline
+        conv.add_assistant(accumulated)
+        store.save(conv)
+        if not pipe:
+            print_info(f"Session: {conv.session_id} (use --session {conv.session_id} to continue)")
+        return
+
+    resp = provider.chat(messages)
+    conv.add_assistant(resp.content)
+
+    # Persist session
+    store.save(conv)
+
+    # Output
+    if json_mode:
+        click.echo(json_mod.dumps({
+            "session_id": conv.session_id,
+            "answer": resp.content,
+            "turns": conv.turn_count,
+            "usage": resp.usage,
+        }, indent=2))
+    elif pipe:
+        click.echo(resp.content)
+    else:
+        from rich.markdown import Markdown
+        from rich.panel import Panel
+
+        console.print(Panel(
+            Markdown(resp.content),
+            title=f"CodexA [{conv.session_id}]",
+            subtitle=f"Turn {conv.turn_count // 2}",
+        ))
+        print_info(f"Session: {conv.session_id} (use --session {conv.session_id} to continue)")

semantic_code_intelligence/cli/commands/ci_gen_cmd.py

@@ -0,0 +1,74 @@
+"""CLI command: ci-gen — generate CI workflow templates."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.utils.logging import (
+    console,
+    get_logger,
+    print_info,
+    print_success,
+)
+
+logger = get_logger("cli.ci_gen")
+
+
+@click.command("ci-gen")
+@click.argument(
+    "template",
+    type=click.Choice(["analysis", "safety", "precommit"], case_sensitive=False),
+)
+@click.option(
+    "--output",
+    "-o",
+    default=None,
+    help="Write output to a file instead of stdout.",
+)
+@click.option(
+    "--python-version",
+    default="3.12",
+    help="Python version for workflow (default: 3.12).",
+)
+@click.pass_context
+def ci_gen_cmd(
+    ctx: click.Context,
+    template: str,
+    output: str | None,
+    python_version: str,
+) -> None:
+    """Generate CI/CD workflow templates for CodexA integration.
+
+    Available templates:
+
+    - analysis  — Full analysis workflow (quality + PR summary)
+
+    - safety    — Lightweight safety-only workflow
+
+    - precommit — Pre-commit hook configuration
+
+    Examples:
+
+        codexa ci-gen analysis
+
+        codexa ci-gen safety -o .github/workflows/codexa-safety.yml
+
+        codexa ci-gen precommit -o .pre-commit-config.yaml
+    """
+    from semantic_code_intelligence.ci.templates import get_template
+
+    kwargs = {}
+    if template != "precommit":
+        kwargs["python_version"] = python_version
+
+    content = get_template(template, **kwargs)
+
+    if output:
+        out_path = Path(output)
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(content, encoding="utf-8")
+        print_success(f"Written to {output}")
+    else:
+        click.echo(content)