codexa 0.4.0__py3-none-any.whl

semantic_code_intelligence/ci/hooks.py

@@ -0,0 +1,98 @@
+"""Pre-commit validation hook support.
+
+Provides a lightweight validation pipeline that can be invoked as a
+pre-commit hook or standalone CLI command.  Hooks run the safety
+validator and optionally dispatch ``CUSTOM_VALIDATION`` plugin hooks.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from semantic_code_intelligence.llm.safety import SafetyValidator, SafetyReport
+from semantic_code_intelligence.utils.logging import get_logger
+
+logger = get_logger("ci.hooks")
+
+
+@dataclass
+class HookResult:
+    """Result from a pre-commit validation run."""
+
+    passed: bool = True
+    files_checked: int = 0
+    safety: SafetyReport | None = None
+    plugin_results: list[dict[str, Any]] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "passed": self.passed,
+            "files_checked": self.files_checked,
+            "safety": self.safety.to_dict() if self.safety else None,
+            "plugin_results": self.plugin_results,
+        }
+
+
+def run_precommit_check(
+    files: list[str],
+    *,
+    project_root: Path | None = None,
+    run_plugins: bool = True,
+) -> HookResult:
+    """Run pre-commit safety and validation checks on *files*.
+
+    1. Safety validation: scans each file for dangerous patterns.
+    2. Plugin hooks: dispatches ``CUSTOM_VALIDATION`` on each file (optional).
+    """
+    result = HookResult(files_checked=len(files))
+
+    # Aggregate file content for safety scan
+    all_code = ""
+    for fpath in files:
+        try:
+            all_code += Path(fpath).read_text(encoding="utf-8", errors="replace") + "\n"
+        except Exception as exc:
+            logger.debug("Could not read %s: %s", fpath, exc)
+
+    # Run safety validator
+    validator = SafetyValidator()
+    result.safety = validator.validate(all_code)
+    if not result.safety.safe:
+        result.passed = False
+
+    # Run plugin CUSTOM_VALIDATION hooks if enabled
+    if run_plugins and project_root:
+        try:
+            from semantic_code_intelligence.plugins import PluginManager, PluginHook
+
+            mgr = PluginManager()
+            plugin_dir = project_root / ".codexa" / "plugins"
+            if plugin_dir.is_dir():
+                mgr.discover_from_directory(plugin_dir)
+                for name in mgr.registered_plugins:
+                    mgr.activate(name)
+
+                for fpath in files:
+                    try:
+                        content = Path(fpath).read_text(encoding="utf-8", errors="replace")
+                    except Exception:
+                        logger.debug("Failed to read %s for plugin validation", fpath)
+                        continue
+                    data = {
+                        "file_path": fpath,
+                        "content": content,
+                        "issues": [],
+                    }
+                    out = mgr.dispatch(PluginHook.CUSTOM_VALIDATION, data)
+                    if out.get("issues"):
+                        result.plugin_results.append({
+                            "file": fpath,
+                            "issues": out["issues"],
+                        })
+                        result.passed = False
+        except Exception as exc:
+            logger.debug("Plugin validation skipped: %s", exc)
+
+    return result

semantic_code_intelligence/ci/hotspots.py

@@ -0,0 +1,272 @@
+"""Hotspot detection engine — identifies high-risk, high-impact code areas.
+
+Computes a weighted risk score per file and symbol using:
+- Cyclomatic complexity
+- Duplication density
+- Dependency fan-in / fan-out
+- Historical change frequency (git log, if available)
+"""
+
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from semantic_code_intelligence.context.engine import CallGraph, DependencyMap
+from semantic_code_intelligence.parsing.parser import Symbol
+from semantic_code_intelligence.utils.logging import get_logger
+
+logger = get_logger("ci.hotspots")
+
+# ── Weight defaults ──────────────────────────────────────────────────
+
+_W_COMPLEXITY = 0.30
+_W_DUPLICATION = 0.20
+_W_FAN_IN = 0.15
+_W_FAN_OUT = 0.15
+_W_CHURN = 0.20
+
+
+@dataclass
+class HotspotFactor:
+    """A single contributing factor to a hotspot score."""
+
+    name: str
+    raw_value: float
+    normalized: float  # 0-1
+    weight: float
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "raw_value": round(self.raw_value, 2),
+            "normalized": round(self.normalized, 3),
+            "weight": self.weight,
+        }
+
+
+@dataclass
+class Hotspot:
+    """A detected hotspot — file or symbol with risk score."""
+
+    name: str
+    file_path: str
+    kind: str  # "file" or "symbol"
+    risk_score: float  # 0-100
+    factors: list[HotspotFactor] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "file_path": self.file_path,
+            "kind": self.kind,
+            "risk_score": round(self.risk_score, 1),
+            "factors": [f.to_dict() for f in self.factors],
+        }
+
+
+@dataclass
+class HotspotReport:
+    """Result of hotspot analysis."""
+
+    files_analyzed: int
+    symbols_analyzed: int
+    hotspots: list[Hotspot] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "files_analyzed": self.files_analyzed,
+            "symbols_analyzed": self.symbols_analyzed,
+            "hotspot_count": len(self.hotspots),
+            "hotspots": [h.to_dict() for h in self.hotspots],
+        }
+
+
+# ── Git churn ────────────────────────────────────────────────────────
+
+
+def _git_change_counts(project_root: Path) -> dict[str, int]:
+    """Return commit-count-per-file via ``git log --name-only``.
+
+    Returns an empty dict if git is unavailable or the directory is not
+    a repository.
+    """
+    try:
+        result = subprocess.run(
+            ["git", "log", "--name-only", "--pretty=format:"],
+            cwd=str(project_root),
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        if result.returncode != 0:
+            return {}
+    except Exception:
+        return {}
+
+    counts: dict[str, int] = {}
+    for line in result.stdout.splitlines():
+        line = line.strip()
+        if line:
+            counts[line] = counts.get(line, 0) + 1
+    return counts
+
+
+# ── Normalisation helpers ────────────────────────────────────────────
+
+
+def _normalise(value: float, max_val: float) -> float:
+    """Normalise *value* to [0, 1] given *max_val*."""
+    if max_val <= 0:
+        return 0.0
+    return min(value / max_val, 1.0)
+
+
+# ── Core analyser ────────────────────────────────────────────────────
+
+
+def analyze_hotspots(
+    symbols: list[Symbol],
+    call_graph: CallGraph,
+    dep_map: DependencyMap,
+    project_root: Path,
+    *,
+    top_n: int = 20,
+    include_git: bool = True,
+    weights: dict[str, float] | None = None,
+) -> HotspotReport:
+    """Detect hotspots across files in the project.
+
+    Args:
+        symbols: All parsed symbols.
+        call_graph: Pre-built call graph.
+        dep_map: Pre-built dependency map.
+        project_root: Project root for git and path resolution.
+        top_n: Maximum hotspots to return.
+        include_git: Whether to factor git churn.
+        weights: Override default factor weights.
+
+    Returns:
+        HotspotReport with ranked hotspots.
+    """
+    from semantic_code_intelligence.ci.quality import compute_complexity
+
+    w = weights or {}
+    w_complexity = w.get("complexity", _W_COMPLEXITY)
+    w_duplication = w.get("duplication", _W_DUPLICATION)
+    w_fan_in = w.get("fan_in", _W_FAN_IN)
+    w_fan_out = w.get("fan_out", _W_FAN_OUT)
+    w_churn = w.get("churn", _W_CHURN)
+
+    # If no git, redistribute churn weight
+    churn_map: dict[str, int] = {}
+    if include_git:
+        churn_map = _git_change_counts(project_root)
+    if not churn_map:
+        extra = w_churn / 4
+        w_complexity += extra
+        w_duplication += extra
+        w_fan_in += extra
+        w_fan_out += extra
+        w_churn = 0.0
+
+    callable_symbols = [s for s in symbols if s.kind in ("function", "method")]
+
+    # ── Per-symbol raw metrics ───────────────────────────────────
+    # Complexity
+    sym_complexity: dict[str, int] = {}
+    for s in callable_symbols:
+        cr = compute_complexity(s)
+        sym_complexity[f"{s.file_path}:{s.name}"] = cr.complexity
+
+    max_complexity = max(sym_complexity.values(), default=1)
+
+    # Fan-in / fan-out
+    sym_fan_in: dict[str, int] = {}
+    sym_fan_out: dict[str, int] = {}
+    for s in callable_symbols:
+        key = f"{s.file_path}:{s.name}"
+        sym_fan_in[key] = len(call_graph.callers_of(s.name))
+        sym_fan_out[key] = len(call_graph.callees_of(key))
+
+    max_fan_in = max(sym_fan_in.values(), default=1)
+    max_fan_out = max(sym_fan_out.values(), default=1)
+
+    # Per-file aggregate: duplication density
+    # Count how many duplicate pairs touch each file
+    file_dup_count: dict[str, int] = {}
+    try:
+        from semantic_code_intelligence.ci.quality import detect_duplicates
+
+        dups = detect_duplicates(callable_symbols, threshold=0.70, min_lines=3)
+        for d in dups:
+            file_dup_count[d.file_a] = file_dup_count.get(d.file_a, 0) + 1
+            file_dup_count[d.file_b] = file_dup_count.get(d.file_b, 0) + 1
+    except Exception as exc:
+        logger.debug("Duplicate detection skipped: %s", exc)
+
+    max_dup = max(file_dup_count.values(), default=1)
+
+    # Git churn — resolve relative paths
+    root = project_root.resolve()
+    max_churn = max(churn_map.values(), default=1)
+
+    # ── Score each callable symbol ───────────────────────────────
+    hotspots: list[Hotspot] = []
+    unique_files: set[str] = set()
+
+    for s in callable_symbols:
+        unique_files.add(s.file_path)
+        key = f"{s.file_path}:{s.name}"
+
+        cc = sym_complexity.get(key, 1)
+        fi = sym_fan_in.get(key, 0)
+        fo = sym_fan_out.get(key, 0)
+        dp = file_dup_count.get(s.file_path, 0)
+
+        # Resolve relative path for git churn lookup
+        try:
+            rel = str(Path(s.file_path).resolve().relative_to(root)).replace("\\", "/")
+        except ValueError:
+            rel = ""
+        ch = churn_map.get(rel, 0)
+
+        n_cc = _normalise(float(cc), float(max_complexity))
+        n_fi = _normalise(float(fi), float(max_fan_in))
+        n_fo = _normalise(float(fo), float(max_fan_out))
+        n_dp = _normalise(float(dp), float(max_dup))
+        n_ch = _normalise(float(ch), float(max_churn))
+
+        score = (
+            w_complexity * n_cc
+            + w_fan_in * n_fi
+            + w_fan_out * n_fo
+            + w_duplication * n_dp
+            + w_churn * n_ch
+        ) * 100
+
+        factors = [
+            HotspotFactor("complexity", float(cc), n_cc, w_complexity),
+            HotspotFactor("fan_in", float(fi), n_fi, w_fan_in),
+            HotspotFactor("fan_out", float(fo), n_fo, w_fan_out),
+            HotspotFactor("duplication", float(dp), n_dp, w_duplication),
+        ]
+        if w_churn > 0:
+            factors.append(HotspotFactor("churn", float(ch), n_ch, w_churn))
+
+        hotspots.append(Hotspot(
+            name=s.name,
+            file_path=s.file_path,
+            kind="symbol",
+            risk_score=score,
+            factors=factors,
+        ))
+
+    hotspots.sort(key=lambda h: h.risk_score, reverse=True)
+    return HotspotReport(
+        files_analyzed=len(unique_files),
+        symbols_analyzed=len(callable_symbols),
+        hotspots=hotspots[:top_n],
+    )

semantic_code_intelligence/ci/impact.py

@@ -0,0 +1,246 @@
+"""Impact analysis engine — predicts blast radius of code changes.
+
+Given a file path or symbol name, determines which parts of the codebase
+are directly and transitively affected via call graph edges, dependency
+map imports, and symbol cross-references.
+"""
+
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from semantic_code_intelligence.context.engine import (
+    CallGraph,
+    DependencyMap,
+)
+from semantic_code_intelligence.parsing.parser import Symbol
+from semantic_code_intelligence.utils.logging import get_logger
+
+logger = get_logger("ci.impact")
+
+
+@dataclass
+class AffectedSymbol:
+    """A symbol affected by a change."""
+
+    name: str
+    file_path: str
+    kind: str  # "function", "method", "class"
+    relationship: str  # "direct_caller", "transitive_caller", "import_dep"
+    depth: int  # hops from source
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "file_path": self.file_path,
+            "kind": self.kind,
+            "relationship": self.relationship,
+            "depth": self.depth,
+        }
+
+
+@dataclass
+class AffectedModule:
+    """A module (file) transitively affected by a change."""
+
+    file_path: str
+    relationship: str  # "imports_target", "transitive_import", "contains_caller"
+    depth: int
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "file_path": self.file_path,
+            "relationship": self.relationship,
+            "depth": self.depth,
+        }
+
+
+@dataclass
+class DependencyChain:
+    """A single dependency chain explaining why a module is affected."""
+
+    path: list[str]  # list of file/symbol names forming the chain
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"path": self.path}
+
+
+@dataclass
+class ImpactReport:
+    """Result of impact analysis."""
+
+    target: str
+    target_kind: str  # "file" or "symbol"
+    direct_symbols: list[AffectedSymbol] = field(default_factory=list)
+    transitive_symbols: list[AffectedSymbol] = field(default_factory=list)
+    affected_modules: list[AffectedModule] = field(default_factory=list)
+    chains: list[DependencyChain] = field(default_factory=list)
+
+    @property
+    def total_affected(self) -> int:
+        return len(self.direct_symbols) + len(self.transitive_symbols)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "target": self.target,
+            "target_kind": self.target_kind,
+            "direct_symbols": [s.to_dict() for s in self.direct_symbols],
+            "transitive_symbols": [s.to_dict() for s in self.transitive_symbols],
+            "affected_modules": [m.to_dict() for m in self.affected_modules],
+            "chains": [c.to_dict() for c in self.chains],
+            "total_affected": self.total_affected,
+        }
+
+
+def _resolve_target_symbols(
+    target: str,
+    symbols: list[Symbol],
+    project_root: Path,
+) -> tuple[str, list[Symbol]]:
+    """Resolve a target (file path or symbol name) to matching symbols.
+
+    Returns (target_kind, matched_symbols).
+    """
+    root = project_root.resolve()
+
+    # Check if it looks like a file path
+    candidate = Path(target)
+    if not candidate.is_absolute():
+        candidate = root / target
+
+    if candidate.exists() and candidate.is_file():
+        resolved = str(candidate.resolve())
+        matched = [s for s in symbols if str(Path(s.file_path).resolve()) == resolved]
+        return "file", matched
+
+    # Treat as symbol name
+    matched = [s for s in symbols if s.name == target and s.kind != "import"]
+    return "symbol", matched
+
+
+def analyze_impact(
+    target: str,
+    symbols: list[Symbol],
+    call_graph: CallGraph,
+    dep_map: DependencyMap,
+    project_root: Path,
+    *,
+    max_depth: int = 5,
+) -> ImpactReport:
+    """Analyze the impact of modifying a file or symbol.
+
+    BFS over call graph callers and dependency map importers to find
+    the full blast radius of a change.
+    """
+    target_kind, target_syms = _resolve_target_symbols(target, symbols, project_root)
+
+    if not target_syms:
+        return ImpactReport(target=target, target_kind=target_kind)
+
+    # Collect seed symbol names
+    seed_names: set[str] = set()
+    seed_files: set[str] = set()
+    for s in target_syms:
+        seed_names.add(s.name)
+        seed_files.add(s.file_path)
+
+    # Build symbol-name → Symbol lookup
+    sym_lookup: dict[str, Symbol] = {}
+    for s in symbols:
+        if s.kind != "import":
+            sym_lookup.setdefault(s.name, s)
+
+    # ── BFS over call graph (callers of target symbols) ──────────
+    direct: list[AffectedSymbol] = []
+    transitive: list[AffectedSymbol] = []
+    visited_callers: set[str] = set()  # caller keys visited
+    queue: deque[tuple[str, int, str]] = deque()  # (symbol_name, depth, relationship)
+
+    for name in seed_names:
+        for edge in call_graph.callers_of(name):
+            caller_key = edge.caller
+            if caller_key in visited_callers:
+                continue
+            visited_callers.add(caller_key)
+            # Parse caller_key "file:name"
+            parts = caller_key.rsplit(":", 1)
+            caller_name = parts[-1] if len(parts) == 2 else caller_key
+            queue.append((caller_name, 1, "direct_caller"))
+
+    while queue:
+        sym_name, depth, relationship = queue.popleft()
+        sym = sym_lookup.get(sym_name)
+        if sym is None:
+            continue
+
+        affected = AffectedSymbol(
+            name=sym.name,
+            file_path=sym.file_path,
+            kind=sym.kind,
+            relationship=relationship,
+            depth=depth,
+        )
+        if depth == 1:
+            direct.append(affected)
+        else:
+            transitive.append(affected)
+
+        # Continue BFS if within depth limit
+        if depth < max_depth:
+            for edge in call_graph.callers_of(sym.name):
+                if edge.caller not in visited_callers:
+                    visited_callers.add(edge.caller)
+                    parts = edge.caller.rsplit(":", 1)
+                    cname = parts[-1] if len(parts) == 2 else edge.caller
+                    queue.append((cname, depth + 1, "transitive_caller"))
+
+    # ── Module-level impact via dependency map ────────────────────
+    affected_modules: list[AffectedModule] = []
+    visited_modules: set[str] = set()
+
+    for fpath in seed_files:
+        # Find the module name from file path
+        p = Path(fpath)
+        module_name = p.stem
+
+        dependents = dep_map.get_dependents(module_name)
+        for dep in dependents:
+            if dep.source_file not in visited_modules and dep.source_file not in seed_files:
+                visited_modules.add(dep.source_file)
+                affected_modules.append(AffectedModule(
+                    file_path=dep.source_file,
+                    relationship="imports_target",
+                    depth=1,
+                ))
+
+    # Add files containing direct callers
+    for af in direct:
+        if af.file_path not in visited_modules and af.file_path not in seed_files:
+            visited_modules.add(af.file_path)
+            affected_modules.append(AffectedModule(
+                file_path=af.file_path,
+                relationship="contains_caller",
+                depth=1,
+            ))
+
+    # ── Build dependency chains (top 10) ─────────────────────
+    chains: list[DependencyChain] = []
+    for af in direct[:10]:
+        chain = [target, af.name]
+        chains.append(DependencyChain(path=chain))
+
+    for af in transitive[:5]:
+        chain = [target, "...", af.name]
+        chains.append(DependencyChain(path=chain))
+
+    return ImpactReport(
+        target=target,
+        target_kind=target_kind,
+        direct_symbols=direct,
+        transitive_symbols=transitive,
+        affected_modules=affected_modules,
+        chains=chains,
+    )