java-codebase-rag 0.12.0__py3-none-any.whl → 0.12.2__py3-none-any.whl

java_codebase_rag/analysis/pr_analysis.py

@@ -1,563 +0,0 @@
-"""Unified-diff → symbol mapping and PR-style risk scoring (B4 / PR-B).
-
-Uses the `unidiff` library for parsing. Graph-resident symbols only; newly
-added Java members are not modelled — see `notes` on the returned report.
-"""
-from __future__ import annotations
-
-import re
-from dataclasses import asdict, dataclass
-from typing import Any
-
-from unidiff import PatchSet
-from unidiff.errors import UnidiffParseError
-
-from java_codebase_rag.graph.ladybug_queries import SymbolHit, find_symbols_in_file_range, _row_to_symbol
-
-
-@dataclass
-class DiffHunk:
-    """One unified-diff hunk in the *new* file coordinate system."""
-
-    target_path: str
-    source_path: str
-    target_line_start: int  # inclusive, 1-based; 0 when the hunk has no new-file lines
-    target_line_end: int  # inclusive
-    source_line_start: int
-    source_line_end: int
-    source_length: int = 0
-    target_length: int = 0
-
-
-@dataclass
-class ChangedSymbol:
-    symbol_id: str
-    fqn: str
-    kind: str  # 'method' | 'type' | 'field'
-    change_type: str  # 'added' | 'removed' | 'modified'
-    file: str
-    hunk_lines: list[int]
-    cross_service_callers_count: int = 0
-
-
-@dataclass
-class PrRiskReport:
-    changed_symbols: list[ChangedSymbol]
-    blast_radius_total: int
-    blast_radius_by_symbol: dict[str, int]
-    cross_service_callers: int
-    routes_touched: list[str]
-    risk_score: float
-    risk_band: str
-    notes: list[str]
-
-
-_BINARY_DIFF_LINE = re.compile(r"^Binary files .+ differ\s*$")
-# Heuristic: new Java method/ctor-looking line. Covers annotations, method-level
-# generics, `default` interface methods, and return types with spaces (e.g.
-# `Map<String, String> m(`). Misses multi-line signatures, some compact record
-# forms, and unusual annotations; `_notes_for_unindexed_additions` is best-effort.
-_DECL_ADD = re.compile(
-    r"^\+\s*"
-    r"(?:(?:@[\w.]+\([^)]*\))\s+)*"
-    r"(?:<[^>]+>\s+)?"
-    r"(?:(?:public|private|protected|default|static|final|synchronized|abstract|native)\s+)*"
-    r"(.+?)\s+(\w+)\s*\(",
-)
-
-
-def _strip_ab_prefix(path: str) -> str:
-    p = path.strip()
-    if p.startswith(("a/", "b/")):
-        return p[2:]
-    return p
-
-
-def _hunk_ranges(h: Any) -> tuple[tuple[int, int], tuple[int, int]]:
-    """Return ((src_start, src_end inclusive), (tgt_start, tgt_end inclusive))."""
-    src_len = int(getattr(h, "source_length", 0) or 0)
-    tgt_len = int(getattr(h, "target_length", 0) or 0)
-    src_start = int(getattr(h, "source_start", 0) or 0)
-    tgt_start = int(getattr(h, "target_start", 0) or 0)
-    if src_len <= 0:
-        src_start, src_end = 0, 0
-    else:
-        src_end = src_start + src_len - 1
-    if tgt_len <= 0:
-        tgt_start, tgt_end = 0, 0
-    else:
-        tgt_end = tgt_start + tgt_len - 1
-    return (src_start, src_end), (tgt_start, tgt_end)
-
-
-def parse_unified_diff(diff_text: str) -> list[DiffHunk]:
-    """Parse `diff_text` into logical hunks (non-binary, non-rename files only)."""
-    if not (diff_text or "").strip():
-        return []
-    try:
-        patches = PatchSet(diff_text.splitlines(keepends=True))
-    except UnidiffParseError:
-        return []
-    out: list[DiffHunk] = []
-    for pf in patches:
-        if getattr(pf, "is_rename", False):
-            continue
-        tgt = _strip_ab_prefix(str(pf.path or ""))
-        src = _strip_ab_prefix(str(getattr(pf, "source_file", "") or pf.path or ""))
-        if not tgt:
-            continue
-        for h in pf:
-            (s0, s1), (t0, t1) = _hunk_ranges(h)
-            sl = int(getattr(h, "source_length", 0) or 0)
-            tl = int(getattr(h, "target_length", 0) or 0)
-            out.append(
-                DiffHunk(
-                    target_path=tgt,
-                    source_path=src,
-                    target_line_start=t0,
-                    target_line_end=t1,
-                    source_line_start=s0,
-                    source_line_end=s1,
-                    source_length=sl,
-                    target_length=tl,
-                )
-            )
-    return out
-
-
-def collect_diff_file_notes(diff_text: str) -> list[str]:
-    """Collect human-readable notes for binary diffs and renames (no crash)."""
-    notes: list[str] = []
-    if not (diff_text or "").strip():
-        return notes
-    for line in diff_text.splitlines():
-        if _BINARY_DIFF_LINE.match(line):
-            notes.append(f"skipped binary diff: {line.strip()}")
-    try:
-        patches = PatchSet(diff_text.splitlines(keepends=True))
-    except UnidiffParseError:
-        notes.append("diff text could not be fully parsed as a unified patch")
-        return notes
-    for pf in patches:
-        if getattr(pf, "is_rename", False):
-            a = _strip_ab_prefix(str(getattr(pf, "source_file", "") or ""))
-            b = _strip_ab_prefix(str(pf.path or ""))
-            notes.append(f"rename (symbols not mapped): {a} -> {b}")
-    return notes
-
-
-def _resolve_graph_filename(
-    graph: Any,
-    path: str,
-    *,
-    ambiguity_notes: list[str] | None = None,
-) -> str | None:
-    """Map a diff path to `Symbol.filename` values stored in LadybugDB."""
-    variants = {_strip_ab_prefix(path)}
-    for v in list(variants):
-        if v.startswith("./"):
-            variants.add(v[2:])
-    for candidate in variants:
-        if not candidate:
-            continue
-        rows = graph._rows(
-            "MATCH (s:Symbol) WHERE s.filename = $fn RETURN s.filename AS fn LIMIT 1",
-            {"fn": candidate},
-        )
-        if rows and rows[0].get("fn"):
-            return str(rows[0]["fn"])
-    tail = path.strip().split("/")[-1]
-    if tail:
-        rows = graph._rows(
-            "MATCH (s:Symbol) WHERE s.filename ENDS WITH $tail "
-            "RETURN DISTINCT s.filename AS fn LIMIT 8",
-            {"tail": "/" + tail},
-        )
-        n = len(rows)
-        if n > 1 and ambiguity_notes is not None:
-            fns = [str(r.get("fn") or "") for r in rows if r.get("fn")]
-            ambiguity_notes.append(
-                f"ambiguous filename tail {tail!r} ({n} graph paths); "
-                f"ENDS WITH resolution skipped ({', '.join(fns[:4])}"
-                f"{'…' if len(fns) > 4 else ''})",
-            )
-        if n == 1 and rows[0].get("fn"):
-            return str(rows[0]["fn"])
-    return None
-
-
-def _symbol_to_changed(
-    sym: SymbolHit,
-    *,
-    change_type: str,
-    lines: list[int],
-) -> ChangedSymbol:
-    kind = sym.kind
-    if kind in ("class", "interface", "enum", "record", "annotation"):
-        mapped_kind = "type"
-    elif kind == "field":
-        mapped_kind = "field"
-    elif kind == "constructor":
-        mapped_kind = "method"
-    else:
-        mapped_kind = "method"
-    uniq = sorted({int(x) for x in lines if int(x) > 0})
-    return ChangedSymbol(
-        symbol_id=sym.id,
-        fqn=sym.fqn,
-        kind=mapped_kind,
-        change_type=change_type,
-        file=sym.filename,
-        hunk_lines=uniq,
-    )
-
-
-def _decl_added_lines_for_file(diff_text: str, resolved_filename: str) -> int:
-    """Count `+` lines in the diff that look like Java member declarations for one file."""
-    lines = diff_text.splitlines()
-    in_file = False
-    n = 0
-    for line in lines:
-        if line.startswith("+++ "):
-            rest = line[4:].strip()
-            if rest.startswith("b/"):
-                rest = rest[2:]
-            in_file = rest.endswith(resolved_filename) or resolved_filename.endswith(rest)
-            continue
-        if not in_file:
-            continue
-        if _DECL_ADD.match(line):
-            n += 1
-    return n
-
-
-def _notes_for_unindexed_additions(
-    graph: Any,
-    diff_text: str,
-    changed: list[ChangedSymbol],
-    hunks: list[DiffHunk],
-) -> list[str]:
-    """Heuristic: added declaration lines vs indexed methods touched on the same file."""
-    notes: list[str] = []
-    if not diff_text.strip():
-        return notes
-    for h in hunks:
-        tgt_fn = _resolve_graph_filename(graph, h.target_path)
-        if not tgt_fn or h.target_line_start <= 0:
-            continue
-        decls = _decl_added_lines_for_file(diff_text, tgt_fn)
-        if decls <= 0:
-            continue
-        methods_here = [c for c in changed if c.kind == "method" and c.file == tgt_fn]
-        if decls > len(methods_here):
-            extra = decls - len(methods_here)
-            notes.append(
-                f"{extra} new method(s) not yet indexed; risk underestimated",
-            )
-    return notes
-
-
-def map_hunks_to_symbols(
-    graph: Any,
-    hunks: list[DiffHunk],
-    *,
-    path_ambiguity_notes: list[str] | None = None,
-) -> list[ChangedSymbol]:
-    """Map diff hunks to overlapping `Symbol` rows (graph-resident only)."""
-    by_id: dict[str, ChangedSymbol] = {}
-
-    def merge(sym: ChangedSymbol) -> None:
-        existing = by_id.get(sym.symbol_id)
-        if existing is None:
-            by_id[sym.symbol_id] = sym
-        else:
-            if existing.change_type == "modified" or sym.change_type == "modified":
-                ct = "modified"
-            elif existing.change_type == "removed" or sym.change_type == "removed":
-                ct = "removed"
-            else:
-                ct = sym.change_type
-            merged_lines = sorted(set(existing.hunk_lines + sym.hunk_lines))
-            by_id[sym.symbol_id] = ChangedSymbol(
-                symbol_id=existing.symbol_id,
-                fqn=existing.fqn,
-                kind=existing.kind,
-                change_type=ct,
-                file=existing.file,
-                hunk_lines=merged_lines,
-            )
-
-    for h in hunks:
-        tgt_fn = _resolve_graph_filename(
-            graph, h.target_path, ambiguity_notes=path_ambiguity_notes,
-        )
-        src_fn = (
-            _resolve_graph_filename(
-                graph, h.source_path, ambiguity_notes=path_ambiguity_notes,
-            )
-            if h.source_path
-            else tgt_fn
-        )
-        if not tgt_fn and not src_fn:
-            continue
-
-        minus_only = h.target_length == 0 and h.source_length > 0
-
-        # Removed lines on old file (process before modified so mixed hunks prefer modified)
-        if h.source_line_start > 0 and h.source_line_end >= h.source_line_start and src_fn:
-            rows = find_symbols_in_file_range(
-                graph,
-                filename=src_fn,
-                start_line=h.source_line_start,
-                end_line=h.source_line_end,
-            )
-            for sym in rows:
-                if sym.kind == "file":
-                    continue
-                overlap = list(range(
-                    max(h.source_line_start, sym.start_line),
-                    min(h.source_line_end, sym.end_line) + 1,
-                ))
-                if minus_only:
-                    merge(_symbol_to_changed(sym, change_type="removed", lines=overlap))
-
-        # Modified / added lines on new file
-        if h.target_line_start > 0 and h.target_line_end >= h.target_line_start and tgt_fn:
-            rows = find_symbols_in_file_range(
-                graph,
-                filename=tgt_fn,
-                start_line=h.target_line_start,
-                end_line=h.target_line_end,
-            )
-            for sym in rows:
-                if sym.kind == "file":
-                    continue
-                merge(_symbol_to_changed(sym, change_type="modified", lines=list(range(
-                    max(h.target_line_start, sym.start_line),
-                    min(h.target_line_end, sym.end_line) + 1,
-                ))))
-
-    return list(by_id.values())
-
-
-def _impact_needle_for_changed(_graph: Any, fqn: str, mapped_kind: str) -> str:
-    """Pick the `impact_analysis` needle: type FQN for members, else the symbol FQN."""
-    if mapped_kind in ("method", "field", "constructor"):
-        if "#" in fqn:
-            return fqn.split("#", 1)[0]
-    return fqn
-
-
-def _is_public_interface_method(graph: Any, sym: SymbolHit) -> bool:
-    if sym.kind != "method":
-        return False
-    if "private" in (sym.modifiers or []):
-        return False
-    type_fqn = sym.fqn.split("#", 1)[0] if "#" in sym.fqn else sym.fqn
-    rows = graph._rows(
-        "MATCH (t:Symbol) WHERE t.fqn = $f AND t.kind = 'interface' RETURN t.id LIMIT 1",
-        {"f": type_fqn},
-    )
-    return bool(rows)
-
-
-def _route_ids_for_symbol(graph: Any, symbol_id: str) -> list[str]:
-    # Note: LadybugDB rejects `ORDER BY r.id` together with `RETURN DISTINCT r.id` (binder loses `r`).
-    q = (
-        "MATCH (s:Symbol)-[e:EXPOSES]->(r:Route) WHERE s.id = $sid "
-        "RETURN r.id AS id ORDER BY id"
-    )
-    seen: set[str] = set()
-    out: list[str] = []
-    for row in graph._rows(q, {"sid": symbol_id}):
-        rid = str(row.get("id") or "")
-        if rid and rid not in seen:
-            seen.add(rid)
-            out.append(rid)
-    return out
-
-
-def _route_natural_id(graph: Any, rid: str) -> str:
-    """Map a raw Route node id to its agent-facing natural identifier.
-
-    Mirrors the envelope contract (``METHOD path`` for HTTP endpoints,
-    ``topic:<name>`` for kafka topics surfaced as :Route) so ``routes_touched``
-    in the PR risk report is readable instead of leaking raw graph ids like
-    ``r:970ffaa960a4f65d``. Falls back to ``rid`` only if the route vanished.
-    """
-    rows = graph._rows(
-        "MATCH (r:Route {id: $rid}) "
-        "RETURN r.method AS method, r.path_template AS path_template, "
-        "r.path AS path, r.topic AS topic LIMIT 1",
-        {"rid": rid},
-    )
-    if not rows:
-        return rid
-    r = rows[0]
-    method = str(r.get("method") or "")
-    path = str(r.get("path_template") or r.get("path") or "")
-    if method or path:
-        return f"{method} {path}".strip()
-    topic = str(r.get("topic") or "")
-    return f"topic:{topic}" if topic else rid
-
-
-def compute_risk(graph: Any, changed: list[ChangedSymbol]) -> PrRiskReport:
-    """Aggregate blast radius, routes, cross-service callers, and v1 risk score.
-
-    Risk score stays in [0, 1]. Cross-service route callers add a bounded
-    bump (up to +1.0) after normalization so they influence rank while
-    preserving the public scalar contract.
-    """
-    blast_by: dict[str, int] = {}
-    blast_total = 0
-    routes: list[str] = []
-    cross_total = 0
-
-    sym_cols = (
-        "id", "kind", "name", "fqn", "package", "module", "microservice",
-        "filename", "start_line", "end_line", "start_byte", "end_byte",
-        "modifiers", "annotations", "capabilities", "role", "signature",
-        "parent_id", "resolved",
-    )
-    _sym_return = ", ".join(f"s.{c} AS {c}" for c in sym_cols)
-
-    iface_hit = 0.0
-    enriched_changed: list[ChangedSymbol] = []
-    for cs in changed:
-        sym_row = graph._rows(
-            "MATCH (s:Symbol) WHERE s.id = $id RETURN " + _sym_return,
-            {"id": cs.symbol_id},
-        )
-        if not sym_row:
-            continue
-        row0 = sym_row[0]
-        if iface_hit < 1.0:
-            sym = _row_to_symbol(row0)
-            if _is_public_interface_method(graph, sym):
-                iface_hit = 1.0
-        fqn = str(row0.get("fqn") or cs.fqn)
-        needle = _impact_needle_for_changed(graph, fqn, cs.kind)
-        ia = graph.impact_analysis(needle, depth=2, limit=400)
-        n = len(ia)
-        # Key blast radius by the symbol's FQN (agent-facing identifier), not
-        # its raw graph id — the report is operator-facing JSON.
-        blast_by[fqn or cs.symbol_id] = n
-        blast_total += n
-
-        for e in graph.find_callers(cs.fqn, depth=2, limit=400):
-            if (
-                e.src.microservice
-                and e.dst.microservice
-                and e.src.microservice != e.dst.microservice
-            ):
-                cross_total += 1
-
-        cs_cross_service = 0
-        route_ids = _route_ids_for_symbol(graph, cs.symbol_id)
-        for rid in route_ids:
-            # Record the route by its natural identifier (METHOD path /
-            # topic:name), not the raw graph id.
-            label = _route_natural_id(graph, rid)
-            if label and label not in routes:
-                routes.append(label)
-            callers = graph._rows(
-                "MATCH (s:Symbol)-[:DECLARES_CLIENT]->(c:Client)-[e:HTTP_CALLS]->(r:Route {id: $rid}) "
-                "WHERE e.match = 'cross_service' "
-                "RETURN c.id AS id LIMIT 500",
-                {"rid": rid},
-            )
-            callers += graph._rows(
-                "MATCH (s:Symbol)-[:DECLARES_PRODUCER]->(p:Producer)-[e:ASYNC_CALLS]->(r:Route {id: $rid}) "
-                "WHERE e.match = 'cross_service' "
-                "RETURN p.id AS id LIMIT 500",
-                {"rid": rid},
-            )
-            cs_cross_service += len(callers)
-        enriched_changed.append(
-            ChangedSymbol(
-                symbol_id=cs.symbol_id,
-                fqn=cs.fqn,
-                kind=cs.kind,
-                change_type=cs.change_type,
-                file=cs.file,
-                hunk_lines=list(cs.hunk_lines),
-                cross_service_callers_count=cs_cross_service,
-            ),
-        )
-
-    def _normalize(x: float, ceiling: float) -> float:
-        if ceiling <= 0:
-            return 0.0
-        return min(float(x), ceiling) / ceiling
-
-    # v1 risk weights / ceilings (PR-B §1.2): intentionally simple baselines;
-    # these constants are expected to be tuned after real-world use — do not treat as stable.
-    w_blast, cap_blast = 0.4, 100.0
-    w_cross, cap_cross = 0.3, 20.0
-    w_iface = 0.2
-    w_routes, cap_routes = 0.1, 5.0
-
-    raw = (
-        w_blast * _normalize(float(blast_total), cap_blast)
-        + w_cross * _normalize(float(cross_total), cap_cross)
-        + w_iface * iface_hit
-        + w_routes * _normalize(float(len(routes)), cap_routes)
-    )
-    cross_service_bonus = min(
-        5.0,
-        float(sum(c.cross_service_callers_count for c in enriched_changed)),
-    )
-    score = max(0.0, min(1.0, raw + (cross_service_bonus / 5.0)))
-    if score < 0.3:
-        band = "low"
-    elif score < 0.7:
-        band = "medium"
-    else:
-        band = "high"
-
-    return PrRiskReport(
-        changed_symbols=list(enriched_changed),
-        blast_radius_total=blast_total,
-        blast_radius_by_symbol=blast_by,
-        cross_service_callers=cross_total,
-        routes_touched=routes,
-        risk_score=score,
-        risk_band=band,
-        notes=[],
-    )
-
-
-def pr_report_to_dict(rep: PrRiskReport) -> dict[str, Any]:
-    return {
-        "changed_symbols": [asdict(c) for c in rep.changed_symbols],
-        "blast_radius_total": rep.blast_radius_total,
-        "blast_radius_by_symbol": dict(rep.blast_radius_by_symbol),
-        "cross_service_callers": rep.cross_service_callers,
-        "routes_touched": list(rep.routes_touched),
-        "risk_score": rep.risk_score,
-        "risk_band": rep.risk_band,
-        "notes": list(rep.notes),
-    }
-
-
-def analyze_pr_pipeline(graph: Any, diff_unified: str) -> PrRiskReport:
-    """Full PR-B pipeline: parse → notes → map → risk."""
-    notes = collect_diff_file_notes(diff_unified)
-    hunks = parse_unified_diff(diff_unified)
-    path_amb: list[str] = []
-    changed = map_hunks_to_symbols(graph, hunks, path_ambiguity_notes=path_amb)
-    notes.extend(path_amb)
-    notes.extend(_notes_for_unindexed_additions(graph, diff_unified, changed, hunks))
-    rep = compute_risk(graph, changed)
-    merged = list(dict.fromkeys([*notes, *rep.notes]))
-    return PrRiskReport(
-        changed_symbols=rep.changed_symbols,
-        blast_radius_total=rep.blast_radius_total,
-        blast_radius_by_symbol=rep.blast_radius_by_symbol,
-        cross_service_callers=rep.cross_service_callers,
-        routes_touched=rep.routes_touched,
-        risk_score=rep.risk_score,
-        risk_band=rep.risk_band,
-        notes=merged,
-    )