codexa 0.4.0__py3-none-any.whl

semantic_code_intelligence/cli/commands/evolve_cmd.py

@@ -0,0 +1,171 @@
+"""CLI command: evolve — run the self-improving development loop."""
+
+from __future__ import annotations
+
+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.evolve")
+
+
+def _get_provider(config):
+    """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 = 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 provider
+
+
+@click.command("evolve")
+@click.option(
+    "--iterations",
+    "-n",
+    default=3,
+    type=click.IntRange(min=1, max=20),
+    help="Maximum number of improvement iterations.",
+)
+@click.option(
+    "--budget",
+    "-b",
+    default=20000,
+    type=click.IntRange(min=1000),
+    help="Maximum total tokens to spend across all LLM calls.",
+)
+@click.option(
+    "--timeout",
+    "-t",
+    default=600,
+    type=click.IntRange(min=30),
+    help="Maximum wall-clock seconds for the entire run.",
+)
+@click.option(
+    "--path",
+    "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Project root path.",
+)
+@click.pass_context
+def evolve_cmd(
+    ctx: click.Context,
+    iterations: int,
+    budget: int,
+    timeout: int,
+    path: str,
+) -> None:
+    """Run the self-improving development loop.
+
+    Automatically selects small improvement tasks (fix tests, add type
+    hints, improve error handling, reduce duplication) and applies them
+    using the configured LLM.  Every change is tested; failures are
+    reverted and successes are committed.
+
+    Examples:
+
+        codexa evolve
+
+        codexa evolve --iterations 5 --budget 50000
+
+        codexa evolve --path /my/project --timeout 300
+    """
+    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)
+    provider = _get_provider(config)
+
+    from semantic_code_intelligence.evolution.budget_guard import BudgetGuard
+    from semantic_code_intelligence.evolution.engine import EvolutionEngine
+
+    guard = BudgetGuard(
+        max_tokens=budget,
+        max_iterations=iterations,
+        max_seconds=float(timeout),
+    )
+
+    console.print(
+        f"\n[bold cyan]Evolution loop[/bold cyan]  "
+        f"iterations={iterations}  budget={budget} tokens  "
+        f"timeout={timeout}s\n"
+    )
+
+    engine = EvolutionEngine(
+        project_root=root,
+        provider=provider,
+        budget=guard,
+    )
+
+    result = engine.run()
+
+    # — Summary ————————————————————————————————
+    console.print("\n[bold green]Evolution complete[/bold green]\n")
+    console.print(f"  Iterations : {result.iterations_completed}")
+    console.print(f"  Commits    : {len(result.commits)}")
+    console.print(f"  Reverts    : {result.reverts}")
+    console.print(f"  Stop reason: {result.stop_reason}")
+
+    bs = result.budget_summary
+    console.print(
+        f"  Tokens     : {bs.get('tokens_used', 0)}/{bs.get('tokens_max', 0)}"
+    )
+    console.print(
+        f"  Time       : {bs.get('elapsed_seconds', 0)}s / {bs.get('max_seconds', 0)}s"
+    )
+
+    if result.commits:
+        console.print("\n[bold]Commits:[/bold]")
+        for sha in result.commits:
+            console.print(f"  {sha}")
+
+    if result.history:
+        console.print("\n[bold]Iteration details:[/bold]")
+        for rec in result.history:
+            status = "[green]committed[/green]" if rec.committed else (
+                "[red]reverted[/red]" if rec.reverted else "[yellow]skipped[/yellow]"
+            )
+            console.print(
+                f"  {rec.iteration}. {rec.task_category} — {status}"
+                f"  ({rec.patch_lines_changed} lines)"
+            )
+            if rec.error:
+                console.print(f"     [dim]{rec.error}[/dim]")
+
+    print_info("History saved to .codexa/evolution_history.json")

semantic_code_intelligence/cli/commands/explain_cmd.py

@@ -0,0 +1,112 @@
+"""CLI command: explain — structural explanation of a symbol or file."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.analysis.ai_features import explain_file, explain_symbol
+from semantic_code_intelligence.context.engine import ContextBuilder
+from semantic_code_intelligence.utils.logging import (
+    console,
+    get_logger,
+    print_error,
+    print_info,
+)
+
+logger = get_logger("cli.explain")
+
+
+@click.command("explain")
+@click.argument("target", type=str)
+@click.option(
+    "--file",
+    "-f",
+    "file_path",
+    default=None,
+    type=click.Path(exists=True, resolve_path=True),
+    help="Source file containing the symbol.",
+)
+@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 explain_cmd(
+    ctx: click.Context,
+    target: str,
+    file_path: str | None,
+    path: str,
+    json_mode: bool,
+) -> None:
+    """Explain a code symbol or all symbols in a file.
+
+    Examples:
+
+        codexa explain MyClass -f src/models.py
+
+        codexa explain --file src/main.py .
+
+        codexa explain search_codebase
+    """
+    import json as json_mod
+
+    root = Path(path).resolve()
+
+    if target == "." and file_path:
+        # Explain entire file
+        explanations = explain_file(file_path)
+        if json_mode:
+            click.echo(json_mod.dumps([e.to_dict() for e in explanations], indent=2))
+        else:
+            for exp in explanations:
+                console.print(exp.render(), markup=False)
+                console.print()
+        return
+
+    # Explain specific symbol
+    builder = ContextBuilder()
+    if file_path:
+        builder.index_file(file_path)
+        symbols = builder.get_symbols(file_path)
+        matches = [s for s in symbols if s.name == target]
+    else:
+        # Scan repo for the symbol
+        from semantic_code_intelligence.config.settings import load_config
+        from semantic_code_intelligence.indexing.scanner import scan_repository
+
+        config = load_config(root)
+        scanned = scan_repository(root, config.index)
+        for sf in scanned:
+            full_path = str(root / sf.relative_path)
+            try:
+                builder.index_file(full_path)
+            except Exception:
+                logger.debug("Failed to index %s", full_path)
+                continue
+        matches = builder.find_symbol(target)
+
+    if not matches:
+        print_error(f"Symbol '{target}' not found.")
+        return
+
+    explanations = [explain_symbol(s, builder) for s in matches]
+    if json_mode:
+        click.echo(json_mod.dumps([e.to_dict() for e in explanations], indent=2))
+    else:
+        for exp in explanations:
+            console.print(exp.render(), markup=False)
+            console.print()
+        print_info(f"Found {len(explanations)} match(es) for '{target}'.")

semantic_code_intelligence/cli/commands/gate_cmd.py

@@ -0,0 +1,135 @@
+"""CLI command: gate — enforce quality gates for CI pipelines."""
+
+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_success,
+)
+
+logger = get_logger("cli.gate")
+
+
+@click.command("gate")
+@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(
+    "--min-maintainability",
+    type=float,
+    default=40.0,
+    help="Minimum maintainability index (default: 40).",
+)
+@click.option(
+    "--max-complexity",
+    type=int,
+    default=25,
+    help="Maximum allowed complexity (default: 25).",
+)
+@click.option(
+    "--max-issues",
+    type=int,
+    default=20,
+    help="Maximum allowed total issues (default: 20).",
+)
+@click.option(
+    "--strict",
+    is_flag=True,
+    default=False,
+    help="Exit with code 1 on gate failure (for CI).",
+)
+@click.pass_context
+def gate_cmd(
+    ctx: click.Context,
+    path: str,
+    json_mode: bool,
+    pipe: bool,
+    min_maintainability: float,
+    max_complexity: int,
+    max_issues: int,
+    strict: bool,
+) -> None:
+    """Enforce quality gates — fail CI builds that violate quality policies.
+
+    Runs full quality analysis plus maintainability metrics and checks
+    results against configurable thresholds.
+
+    Examples:
+
+        codexa gate
+
+        codexa gate --strict --json
+
+        codexa gate --min-maintainability 60 --max-complexity 15
+
+        codexa gate --pipe --strict
+    """
+    import sys
+
+    from semantic_code_intelligence.ci.metrics import (
+        QualityPolicy,
+        compute_project_metrics,
+        enforce_quality_gate,
+    )
+    from semantic_code_intelligence.ci.quality import analyze_project
+
+    root = Path(path).resolve()
+
+    report = analyze_project(root)
+    pm = compute_project_metrics(root)
+
+    policy = QualityPolicy(
+        min_maintainability=min_maintainability,
+        max_complexity=max_complexity,
+        max_issues=max_issues,
+    )
+
+    result = enforce_quality_gate(pm, report, policy)
+
+    if json_mode:
+        click.echo(json_mod.dumps(result.to_dict(), indent=2))
+    elif pipe:
+        status = "PASS" if result.passed else "FAIL"
+        click.echo(f"{status}  MI={pm.maintainability_index:.1f}  issues={report.issue_count}")
+        for v in result.violations:
+            click.echo(f"  VIOLATION  {v.rule}: {v.message}")
+    else:
+        if result.passed:
+            print_success(
+                f"Quality gate passed — MI={pm.maintainability_index:.1f}, "
+                f"{report.issue_count} issue(s)"
+            )
+        else:
+            print_error(
+                f"Quality gate FAILED — {len(result.violations)} violation(s)"
+            )
+            for v in result.violations:
+                console.print(f"  [red]{v.rule}[/red]: {v.message}")
+
+    if strict and not result.passed:
+        sys.exit(1)

semantic_code_intelligence/cli/commands/grep_cmd.py

@@ -0,0 +1,234 @@
+"""CLI command: grep — Raw filesystem search without requiring an index.
+
+Unlike ``codexa search --mode regex``, this command searches raw files on disk
+using ripgrep (if available) or a pure-Python fallback. Zero setup required.
+Supports standard grep flags (-A/-B/-C context, -w word, -v invert, -c count).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+from semantic_code_intelligence.search.grep import grep_search
+from semantic_code_intelligence.utils.logging import (
+    get_logger,
+    print_error,
+    console,
+)
+
+logger = get_logger("cli.grep")
+
+
+@click.command("grep")
+@click.argument("pattern", type=str)
+@click.option(
+    "--path",
+    "-p",
+    default=".",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    help="Directory root to search.",
+)
+@click.option(
+    "--case-sensitive",
+    "-s",
+    is_flag=True,
+    default=False,
+    help="Case-sensitive matching.",
+)
+@click.option(
+    "--max-results",
+    "-n",
+    default=100,
+    type=int,
+    help="Maximum number of matches to return.",
+)
+@click.option(
+    "--glob",
+    "-g",
+    "file_glob",
+    default=None,
+    type=str,
+    help="Filter files by glob pattern (e.g. '*.py').",
+)
+@click.option(
+    "--no-ripgrep",
+    is_flag=True,
+    default=False,
+    help="Force pure-Python search (skip ripgrep even if available).",
+)
+@click.option(
+    "--json-output",
+    "--json",
+    "json_mode",
+    is_flag=True,
+    default=False,
+    help="Output results as JSON.",
+)
+@click.option(
+    "--files-only",
+    "-l",
+    is_flag=True,
+    default=False,
+    help="Print only file paths with matches (like grep -l).",
+)
+@click.option(
+    "-A",
+    "after_context",
+    default=0,
+    type=int,
+    help="Lines of context after each match.",
+)
+@click.option(
+    "-B",
+    "before_context",
+    default=0,
+    type=int,
+    help="Lines of context before each match.",
+)
+@click.option(
+    "-C",
+    "context",
+    default=0,
+    type=int,
+    help="Lines of context before and after each match (shorthand for -A N -B N).",
+)
+@click.option(
+    "--word",
+    "-w",
+    is_flag=True,
+    default=False,
+    help="Match whole words only.",
+)
+@click.option(
+    "--invert-match",
+    "-v",
+    is_flag=True,
+    default=False,
+    help="Show lines that do NOT match the pattern.",
+)
+@click.option(
+    "--count",
+    "-c",
+    "count_only",
+    is_flag=True,
+    default=False,
+    help="Only print a count of matching lines per file.",
+)
+@click.option(
+    "--hidden",
+    is_flag=True,
+    default=False,
+    help="Include hidden files and directories in search.",
+)
+@click.pass_context
+def grep_cmd(
+    ctx: click.Context,
+    pattern: str,
+    path: str,
+    case_sensitive: bool,
+    max_results: int,
+    file_glob: str | None,
+    no_ripgrep: bool,
+    json_mode: bool,
+    files_only: bool,
+    after_context: int,
+    before_context: int,
+    context: int,
+    word: bool,
+    invert_match: bool,
+    count_only: bool,
+    hidden: bool,
+) -> None:
+    """Search raw files using regex — no index required.
+
+    Uses ripgrep for maximum speed when available, with a pure-Python
+    fallback. Unlike 'codexa search --mode regex', this searches the
+    actual filesystem, not the index.
+
+    \b
+    Examples:
+        codexa grep "TODO|FIXME"
+        codexa grep "def authenticate" -g "*.py"
+        codexa grep "password" --case-sensitive
+        codexa grep "import re" --json
+        codexa grep "class.*Service" -l
+        codexa grep "error" -A 3 -B 1
+        codexa grep "def main" -C 2
+        codexa grep "TODO" -c
+        codexa grep "login" -w
+        codexa grep "debug" -v
+    """
+    import json as json_mod
+
+    root = Path(path).resolve()
+
+    # -C sets both before and after context
+    ctx_before = context if context > 0 else before_context
+    ctx_after = context if context > 0 else after_context
+
+    result = grep_search(
+        pattern,
+        root,
+        case_insensitive=not case_sensitive,
+        max_results=max_results,
+        use_ripgrep=not no_ripgrep,
+        file_glob=file_glob,
+        context_before=ctx_before,
+        context_after=ctx_after,
+        word_match=word,
+        invert_match=invert_match,
+        include_hidden=hidden,
+        count_only=count_only,
+    )
+
+    if json_mode:
+        click.echo(json_mod.dumps(result.to_dict(), indent=2))
+        return
+
+    if not result.matches:
+        print_error(f"No matches for pattern: {pattern}")
+        ctx.exit(1)
+        return
+
+    if count_only:
+        # Aggregate counts per file
+        from collections import Counter
+        counts: Counter[str] = Counter()
+        for m in result.matches:
+            if not m.is_context:
+                counts[m.file_path] += 1
+        for fp, cnt in sorted(counts.items()):
+            click.echo(f"{fp}:{cnt}")
+        return
+
+    if files_only:
+        seen: set[str] = set()
+        for m in result.matches:
+            if m.file_path not in seen:
+                seen.add(m.file_path)
+                click.echo(m.file_path)
+        return
+
+    # Rich output
+    from rich.text import Text
+
+    prev_file: str | None = None
+    for m in result.matches:
+        line = Text()
+        line.append(m.file_path, style="green")
+        line.append(":", style="dim")
+        line.append(str(m.line_number), style="yellow")
+        if m.is_context:
+            line.append("-", style="dim")
+        else:
+            line.append(":", style="dim")
+        line.append(m.line_content)
+        console.print(line)
+
+    console.print(
+        f"\n[dim]{len([m for m in result.matches if not m.is_context])} matches "
+        f"in {result.files_matched} files"
+        f" (backend: {result.backend})[/dim]"
+    )