codexa 0.4.0__py3-none-any.whl

semantic_code_intelligence/ci/templates.py

@@ -0,0 +1,164 @@
+"""GitHub Actions workflow template generation.
+
+Generates YAML workflow files that integrate CodexA analysis into
+CI pipelines.  Templates are plain strings — no YAML library required.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+
+def generate_analysis_workflow(
+    *,
+    python_version: str = "3.12",
+    trigger: str = "pull_request",
+) -> str:
+    """Generate a GitHub Actions workflow for CodexA analysis on PRs.
+
+    The workflow:
+    1. Installs CodexA and dependencies.
+    2. Runs ``codexa quality`` on the repository.
+    3. Runs ``codexa pr-summary`` on changed files.
+    4. Posts a summary comment (advisory only).
+    """
+    return f"""\
+# CodexA Analysis Workflow
+# Auto-generated by `codexa ci-gen`
+# This workflow runs CodexA quality and PR analysis on pull requests.
+# All outputs are advisory — CodexA never modifies repository code.
+
+name: CodexA Analysis
+
+on:
+  {trigger}:
+    branches: [main]
+
+permissions:
+  contents: read
+  pull-requests: read
+
+jobs:
+  analyze:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python {python_version}
+        uses: actions/setup-python@v5
+        with:
+          python-version: "{python_version}"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip setuptools wheel
+          pip install -r requirements.txt
+
+      - name: CodexA — Initialize
+        run: codexa init
+
+      - name: CodexA — Quality Report
+        run: codexa quality --json > quality-report.json
+        continue-on-error: true
+
+      - name: CodexA — PR Summary
+        run: codexa pr-summary --json > pr-report.json
+        continue-on-error: true
+
+      - name: Upload Reports
+        uses: actions/upload-artifact@v4
+        with:
+          name: codexa-reports
+          path: |
+            quality-report.json
+            pr-report.json
+"""
+
+
+def generate_precommit_config() -> str:
+    """Generate a ``.pre-commit-config.yaml`` snippet for CodexA hooks.
+
+    Uses the ``local`` repo type so no external hook package is needed.
+    """
+    return """\
+# CodexA pre-commit hooks
+# Add this to your .pre-commit-config.yaml
+
+repos:
+  - repo: local
+    hooks:
+      - id: codexa-safety
+        name: CodexA Safety Check
+        entry: codexa quality --safety-only --pipe
+        language: system
+        types: [python]
+        pass_filenames: false
+
+      - id: codexa-quality
+        name: CodexA Quality Check
+        entry: codexa quality --pipe
+        language: system
+        types: [python]
+        pass_filenames: false
+"""
+
+
+def generate_safety_workflow(
+    *,
+    python_version: str = "3.12",
+) -> str:
+    """Generate a lightweight safety-only workflow for fast PR checks."""
+    return f"""\
+# CodexA Safety Check
+# Lightweight workflow — validates changed code for security patterns.
+
+name: CodexA Safety
+
+on:
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  safety:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python {python_version}
+        uses: actions/setup-python@v5
+        with:
+          python-version: "{python_version}"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip setuptools wheel
+          pip install -r requirements.txt
+
+      - name: CodexA — Safety Validation
+        run: codexa quality --safety-only --pipe
+"""
+
+
+TEMPLATES: dict[str, str] = {
+    "analysis": "Full analysis workflow (quality + PR summary)",
+    "safety": "Lightweight safety-only workflow",
+    "precommit": "Pre-commit hook configuration",
+}
+
+
+def get_template(name: str, **kwargs: Any) -> str:
+    """Get a named template. Raises ``KeyError`` for unknown names."""
+    generators: dict[str, Callable[..., str]] = {
+        "analysis": generate_analysis_workflow,
+        "safety": generate_safety_workflow,
+        "precommit": generate_precommit_config,
+    }
+    gen = generators.get(name)
+    if gen is None:
+        raise KeyError(f"Unknown template: {name!r}. Available: {', '.join(generators)}")
+    return gen(**kwargs)

semantic_code_intelligence/ci/trace.py

@@ -0,0 +1,224 @@
+"""Symbol trace tool — traces execution relationships between symbols.
+
+Builds upstream callers and downstream callees for a given symbol,
+with transitive traversal and cross-file relationship tracking.
+"""
+
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass, field
+from typing import Any
+
+from semantic_code_intelligence.context.engine import CallGraph
+from semantic_code_intelligence.parsing.parser import Symbol
+from semantic_code_intelligence.utils.logging import get_logger
+
+logger = get_logger("ci.trace")
+
+
+@dataclass
+class TraceNode:
+    """A node in a symbol trace — a caller or callee."""
+
+    name: str
+    file_path: str
+    kind: str  # "function", "method", "class"
+    depth: int  # hops from source; negative=upstream, positive=downstream
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "file_path": self.file_path,
+            "kind": self.kind,
+            "depth": self.depth,
+        }
+
+
+@dataclass
+class TraceEdge:
+    """A directed edge in the trace graph."""
+
+    caller: str
+    callee: str
+    file_path: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "caller": self.caller,
+            "callee": self.callee,
+            "file_path": self.file_path,
+        }
+
+
+@dataclass
+class TraceResult:
+    """Result of tracing a symbol's execution relationships."""
+
+    target: str
+    target_file: str
+    upstream: list[TraceNode] = field(default_factory=list)
+    downstream: list[TraceNode] = field(default_factory=list)
+    edges: list[TraceEdge] = field(default_factory=list)
+    max_upstream_depth: int = 0
+    max_downstream_depth: int = 0
+
+    @property
+    def total_nodes(self) -> int:
+        return len(self.upstream) + len(self.downstream)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "target": self.target,
+            "target_file": self.target_file,
+            "upstream": [n.to_dict() for n in self.upstream],
+            "downstream": [n.to_dict() for n in self.downstream],
+            "edges": [e.to_dict() for e in self.edges],
+            "max_upstream_depth": self.max_upstream_depth,
+            "max_downstream_depth": self.max_downstream_depth,
+            "total_nodes": self.total_nodes,
+        }
+
+
+def trace_symbol(
+    target: str,
+    symbols: list[Symbol],
+    call_graph: CallGraph,
+    *,
+    max_depth: int = 5,
+) -> TraceResult:
+    """Trace execution relationships for a symbol.
+
+    Walks both upstream (callers) and downstream (callees) in the call graph.
+
+    Args:
+        target: Symbol name to trace.
+        symbols: All parsed symbols.
+        call_graph: Pre-built call graph.
+        max_depth: Maximum BFS traversal depth in each direction.
+
+    Returns:
+        TraceResult with upstream/downstream nodes and edges.
+    """
+    # Resolve target to a known symbol
+    target_syms = [s for s in symbols if s.name == target and s.kind != "import"]
+    if not target_syms:
+        return TraceResult(target=target, target_file="")
+
+    target_sym = target_syms[0]
+    target_key = f"{target_sym.file_path}:{target_sym.name}"
+
+    # Build name → Symbol index
+    sym_by_name: dict[str, Symbol] = {}
+    for s in symbols:
+        if s.kind != "import":
+            sym_by_name.setdefault(s.name, s)
+
+    # Reverse caller_key → Symbol
+    sym_by_key: dict[str, Symbol] = {}
+    for s in symbols:
+        if s.kind in ("function", "method", "class"):
+            sym_by_key[f"{s.file_path}:{s.name}"] = s
+
+    upstream: list[TraceNode] = []
+    downstream: list[TraceNode] = []
+    edges: list[TraceEdge] = []
+    max_up = 0
+    max_down = 0
+
+    # ── Upstream: who calls target? ──────────────────────────────
+    visited_up: set[str] = {target}
+    queue_up: deque[tuple[str, int]] = deque()  # (symbol_name, depth)
+
+    for edge in call_graph.callers_of(target):
+        parts = edge.caller.rsplit(":", 1)
+        caller_name = parts[-1] if len(parts) == 2 else edge.caller
+        if caller_name not in visited_up:
+            visited_up.add(caller_name)
+            queue_up.append((caller_name, 1))
+            edges.append(TraceEdge(
+                caller=caller_name,
+                callee=target,
+                file_path=edge.file_path,
+            ))
+
+    while queue_up:
+        sym_name, depth = queue_up.popleft()
+        sym = sym_by_name.get(sym_name)
+        if sym is None:
+            continue
+
+        upstream.append(TraceNode(
+            name=sym.name,
+            file_path=sym.file_path,
+            kind=sym.kind,
+            depth=-depth,  # negative = upstream
+        ))
+        max_up = max(max_up, depth)
+
+        if depth < max_depth:
+            for edge in call_graph.callers_of(sym.name):
+                parts = edge.caller.rsplit(":", 1)
+                cname = parts[-1] if len(parts) == 2 else edge.caller
+                if cname not in visited_up:
+                    visited_up.add(cname)
+                    queue_up.append((cname, depth + 1))
+                    edges.append(TraceEdge(
+                        caller=cname,
+                        callee=sym.name,
+                        file_path=edge.file_path,
+                    ))
+
+    # ── Downstream: what does target call? ────────────────────────
+    visited_down: set[str] = {target_key}
+    queue_down: deque[tuple[str, str, int]] = deque()  # (caller_key, symbol_name, depth)
+
+    for edge in call_graph.callees_of(target_key):
+        callee_sym = sym_by_name.get(edge.callee)
+        callee_key = f"{callee_sym.file_path}:{callee_sym.name}" if callee_sym else edge.callee
+        if callee_key not in visited_down:
+            visited_down.add(callee_key)
+            queue_down.append((callee_key, edge.callee, 1))
+            edges.append(TraceEdge(
+                caller=target,
+                callee=edge.callee,
+                file_path=edge.file_path,
+            ))
+
+    while queue_down:
+        caller_key, sym_name, depth = queue_down.popleft()
+        sym = sym_by_name.get(sym_name)
+        if sym is None:
+            continue
+
+        downstream.append(TraceNode(
+            name=sym.name,
+            file_path=sym.file_path,
+            kind=sym.kind,
+            depth=depth,
+        ))
+        max_down = max(max_down, depth)
+
+        if depth < max_depth:
+            key = f"{sym.file_path}:{sym.name}"
+            for edge in call_graph.callees_of(key):
+                callee_sym = sym_by_name.get(edge.callee)
+                callee_key = f"{callee_sym.file_path}:{callee_sym.name}" if callee_sym else edge.callee
+                if callee_key not in visited_down:
+                    visited_down.add(callee_key)
+                    queue_down.append((callee_key, edge.callee, depth + 1))
+                    edges.append(TraceEdge(
+                        caller=sym.name,
+                        callee=edge.callee,
+                        file_path=edge.file_path,
+                    ))
+
+    return TraceResult(
+        target=target,
+        target_file=target_sym.file_path,
+        upstream=upstream,
+        downstream=downstream,
+        edges=edges,
+        max_upstream_depth=max_up,
+        max_downstream_depth=max_down,
+    )

semantic_code_intelligence/cli/commands/ask_cmd.py

@@ -0,0 +1,153 @@
+"""CLI command: ask — ask a natural-language question about the codebase."""
+
+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.config.settings import AppConfig, load_config
+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.ask")
+
+
+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("ask")
+@click.argument("question", type=str)
+@click.option(
+    "--top-k",
+    "-k",
+    default=5,
+    type=int,
+    help="Number of context snippets to retrieve.",
+)
+@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 ask_cmd(
+    ctx: click.Context,
+    question: str,
+    top_k: int,
+    json_mode: bool,
+    path: str,
+) -> None:
+    """Ask a natural-language question about the codebase.
+
+    Uses semantic search + LLM to answer questions about your code.
+
+    Examples:
+
+        codexa ask "How does authentication work?"
+
+        codexa ask "What does the search_codebase function do?" --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)
+    provider = _get_provider(config)
+
+    from semantic_code_intelligence.llm.reasoning import ReasoningEngine
+
+    try:
+        engine = ReasoningEngine(provider, root)
+        result = engine.ask(question, top_k=top_k)
+    except Exception as exc:
+        logger.debug("Ask failed", exc_info=True)
+        print_error(f"Failed to answer question: {exc}")
+        ctx.exit(1)
+        return
+
+    if json_mode:
+        click.echo(json_mod.dumps(result.to_dict(), indent=2))
+    else:
+        console.print(f"\n[bold cyan]Question:[/bold cyan] {result.question}\n")
+        console.print(f"[bold green]Answer:[/bold green]\n{result.answer}\n")
+        if result.context_snippets:
+            console.print(f"[dim]({len(result.context_snippets)} context snippets used)[/dim]")