sourcecode 1.62.0__py3-none-any.whl → 1.63.0__py3-none-any.whl

sourcecode/__init__.py

@@ -1,3 +1,3 @@
 """sourcecode — Deterministic codebase context maps for AI coding agents."""
 
-__version__ = "1.62.0"
+__version__ = "1.63.0"

sourcecode/cli.py

@@ -4841,9 +4841,12 @@ def migrate_check_cmd(
     \b
     Hibernate 5→6 stratification (in the 'hibernate' output section):
       4 independent layers (JPA annotations / Criteria / HQL / SPI), a per-layer
-      risk matrix, a module exposure map, critical call-chain detection, and an
-      UPGRADE vs REWRITE verdict (dynamic Criteria, custom SPI, reflection-built
-      queries, or concatenated query strings force the REWRITE classification).
+      risk matrix with effort ranges, a module exposure map, critical call-chain
+      detection, golden-SQL hotspots, a hibernate_readiness score, and an UPGRADE
+      vs REWRITE verdict (dynamic Criteria, custom SPI, reflection-built queries,
+      or concatenated query strings force the REWRITE classification).
+      Emits actionable rewrite_targets[] (call-site line ranges → target_api +
+      migration_kind) so a migration agent can consume the output directly.
 
     \b
     Examples:

sourcecode/hibernate_strat.py

@@ -10,25 +10,35 @@ independent migration domains and classifies each one on its own risk axis:
   3. HQL / String-based Queries  — MEDIUM, escalates to HIGH on concatenation
   4. Hibernate SPI / Internal    — CRITICAL BLOCKER (UserType, Interceptor, SPI)
 
-It also produces:
+Beyond the diagnostic summary it emits **actionable, machine-readable rewrite
+targets** at call-site granularity (`rewrite_targets[]`) so a migration agent can
+consume the output directly instead of re-parsing the repository. It also produces:
   - a module-level Hibernate exposure map,
-  - critical call-chain detection (DynamicEntityDao, BasicPersistenceModule, …),
-  - stop-condition logic that decides UPGRADE ZONE vs REWRITE ZONE,
-  - separation of observable code risk from inferred runtime risk.
+  - per-layer manual/assisted/mechanical sub-counts (static vs dynamic Criteria),
+  - honest effort ranges (low/high/confidence) + an auditable effort model,
+  - a hibernate_readiness score (0-100),
+  - critical call-chain detection and golden-SQL instrumentation hotspots,
+  - separation of observable code risk from inferred runtime risk,
+  - an UPGRADE-vs-REWRITE verdict via stop-condition logic.
 
 Entry point: analyze_hibernate(file_paths, root) → HibernateStratification
 
-This is purely additive: it does not aggregate Hibernate into a single score, and
-it does not assume that a Spring Boot upgrade resolves ORM risk.
+This is purely additive and does not aggregate Hibernate into a single score.
 """
 from __future__ import annotations
 
+import bisect
+import hashlib
 import re
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Optional
 
 
+# Sub-schema version for the `hibernate` output section. Bump on shape changes.
+HIBERNATE_SCHEMA_VERSION = "2.0"
+
+
 # ---------------------------------------------------------------------------
 # Layer identifiers
 # ---------------------------------------------------------------------------
@@ -44,6 +54,9 @@ _LAYER_TITLES: dict[str, str] = {
     LAYER_HQL: "HQL / String-based Queries",
     LAYER_SPI: "Hibernate SPI / Internal API",
 }
+_LAYER_CODE: dict[str, str] = {
+    LAYER_JPA: "JPA", LAYER_CRITERIA: "CRIT", LAYER_HQL: "HQL", LAYER_SPI: "SPI",
+}
 
 # Classification verdicts
 CLASS_NONE = "none"
@@ -60,6 +73,19 @@ _CLASS_LABELS: dict[str, str] = {
 
 _SEVERITY_RANK: dict[str, int] = {"critical": 0, "high": 1, "medium": 2, "low": 3}
 
+# Migration kinds (ascending automatability)
+KIND_MANUAL = "manual_rewrite"
+KIND_ASSISTED = "assisted"
+KIND_MECHANICAL = "mechanical"
+KIND_REVIEW = "review"
+
+# Effort range multipliers by confidence band: (low_mult, high_mult).
+_CONF_MULT: dict[str, tuple[float, float]] = {
+    "high": (0.9, 1.2),
+    "medium": (0.7, 1.5),
+    "low": (0.5, 2.0),
+}
+
 
 # ---------------------------------------------------------------------------
 # Detection patterns
@@ -73,7 +99,7 @@ _JPA_ANNOTATION_RE = re.compile(
 )
 # Hibernate / JPA annotations deprecated or reworked in Hibernate 6 (escalate).
 _JPA_DEPRECATED_RE = re.compile(
-    r"@TypeDef\b|@TypeDefs\b|"
+    r"@TypeDefs?\b|"
     r"org\.hibernate\.annotations\.Type\b|"
     r"@Type\s*\(\s*type\s*=|"
     r"@GenericGenerator\b|"
@@ -83,8 +109,7 @@ _JPA_DEPRECATED_RE = re.compile(
 # Layer 2 — JPA Criteria API + legacy Hibernate Criteria.
 _CRITERIA_JPA_RE = re.compile(
     r"\bCriteriaBuilder\b|\bCriteriaQuery\b|\bCriteriaUpdate\b|"
-    r"\bCriteriaDelete\b|\bRoot\s*<|\bPredicate\b|\.criteria\b|"
-    r"persistence\.criteria"
+    r"\bCriteriaDelete\b|\bRoot\s*<|\bPredicate\b|persistence\.criteria"
 )
 _CRITERIA_LEGACY_RE = re.compile(
     r"org\.hibernate\.Criteria\b|\.createCriteria\s*\(|\bDetachedCriteria\b|"
@@ -133,21 +158,65 @@ _REFLECTION_RE = re.compile(
     r"\.getMetamodel\s*\("
 )
 
+# Lightweight symbol indexing.
+_CLASS_DECL_RE = re.compile(r"\b(?:class|interface|enum)\s+(\w+)")
+_METHOD_DECL_RE = re.compile(r"\b(\w+)\s*\([^;{)]*\)\s*\{")
+_NON_METHOD_NAMES = frozenset({
+    "if", "for", "while", "switch", "catch", "synchronized", "try", "return",
+    "new", "do", "else", "case", "super", "this",
+})
+
 
 # ---------------------------------------------------------------------------
 # Data model
 # ---------------------------------------------------------------------------
 
+@dataclass
+class RewriteTarget:
+    id: str
+    layer: str
+    source_file: str
+    line_start: int
+    line_end: int
+    current_pattern: str
+    current_snippet: str
+    target_api: str
+    migration_kind: str
+    auto_migratable: bool
+    blocking_reason: str
+    symbol: str
+    module: str
+    dynamic: bool = False
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "layer": self.layer,
+            "source_file": self.source_file,
+            "line_start": self.line_start,
+            "line_end": self.line_end,
+            "current_pattern": self.current_pattern,
+            "current_snippet": self.current_snippet,
+            "target_api": self.target_api,
+            "migration_kind": self.migration_kind,
+            "auto_migratable": self.auto_migratable,
+            "blocking_reason": self.blocking_reason,
+            "symbol": self.symbol,
+            "module": self.module,
+            "dynamic": self.dynamic,
+        }
+
+
 @dataclass
 class HibernateFinding:
     layer: str
     severity: str
-    pattern: str          # short human label of what matched
+    pattern: str
     source_file: str
     first_line: int
     module: str
     occurrences: int = 1
-    dynamic: bool = False  # escalated via reflection / abstraction DAO context
+    dynamic: bool = False
 
     def to_dict(self) -> dict:
         return {
@@ -167,20 +236,44 @@ class HibernateLayerRisk:
     layer: str
     risk: str
     reason: str
-    estimated_effort: str
+    estimated_effort: str          # legacy string "~75.8d" (compat)
     file_count: int
     occurrence_count: int
+    effort_range: dict = field(default_factory=dict)   # {low, high, confidence}
+    # Migration-kind breakdown (derived from rewrite_targets of this layer).
+    manual_count: int = 0
+    assisted_count: int = 0
+    mechanical_count: int = 0
+    review_count: int = 0
+    # Criteria-specific.
+    static_count: Optional[int] = None
+    dynamic_count: Optional[int] = None
+    # SPI-specific.
+    userType_rewrite_count: Optional[int] = None
+    userType_resolvable_count: Optional[int] = None
 
     def to_dict(self) -> dict:
-        return {
+        d: dict = {
             "layer": self.layer,
             "layer_title": _LAYER_TITLES.get(self.layer, self.layer),
             "risk": self.risk,
             "reason": self.reason,
             "estimated_effort": self.estimated_effort,
+            "effort_range": self.effort_range,
             "file_count": self.file_count,
             "occurrence_count": self.occurrence_count,
+            "manual_count": self.manual_count,
+            "assisted_count": self.assisted_count,
+            "mechanical_count": self.mechanical_count,
+            "review_count": self.review_count,
         }
+        if self.static_count is not None:
+            d["static_count"] = self.static_count
+            d["dynamic_count"] = self.dynamic_count
+        if self.userType_rewrite_count is not None:
+            d["userType_rewrite_count"] = self.userType_rewrite_count
+            d["userType_resolvable_count"] = self.userType_resolvable_count
+        return d
 
 
 @dataclass
@@ -188,26 +281,37 @@ class HibernateStratification:
     detected: bool = False
     classification: str = CLASS_NONE
     classification_label: str = _CLASS_LABELS[CLASS_NONE]
+    readiness: int = 100
     risk_matrix: list[HibernateLayerRisk] = field(default_factory=list)
     module_exposure: dict[str, dict] = field(default_factory=dict)
     incompatible_patterns: list[str] = field(default_factory=list)
     critical_call_chains: list[dict] = field(default_factory=list)
+    rewrite_targets: list[RewriteTarget] = field(default_factory=list)
+    golden_sql_hotspots: list[dict] = field(default_factory=list)
     stop_conditions_triggered: list[str] = field(default_factory=list)
     observable_risk: list[str] = field(default_factory=list)
     inferred_runtime_risk: list[str] = field(default_factory=list)
+    total_effort_range_days: dict = field(default_factory=dict)
+    effort_model: dict = field(default_factory=dict)
     findings: list[HibernateFinding] = field(default_factory=list)
 
     def to_dict(self) -> dict:
         return {
+            "schema_version": HIBERNATE_SCHEMA_VERSION,
             "detected": self.detected,
             "classification": self.classification,
             "classification_label": self.classification_label,
             "stratified": True,
+            "hibernate_readiness": self.readiness,
             "risk_matrix": [r.to_dict() for r in self.risk_matrix],
             "module_exposure_map": self.module_exposure,
             "incompatible_patterns": self.incompatible_patterns,
             "critical_call_chains": self.critical_call_chains,
+            "rewrite_targets": [t.to_dict() for t in self.rewrite_targets],
+            "golden_sql_hotspots": self.golden_sql_hotspots,
             "stop_conditions_triggered": self.stop_conditions_triggered,
+            "total_effort_range_days": self.total_effort_range_days,
+            "effort_model": self.effort_model,
             "risk_separation": {
                 "observable_code_risk": self.observable_risk,
                 "inferred_runtime_risk": self.inferred_runtime_risk,
@@ -222,14 +326,22 @@ class HibernateStratification:
         lines: list[str] = [
             "── Hibernate 5.x → 6.x Migration Stratification ──",
             f"Classification: {self.classification_label}",
+            f"Hibernate readiness: {self.readiness}/100   "
+            f"Rewrite targets: {len(self.rewrite_targets)}   "
+            f"Effort: {self.total_effort_range_days.get('low', '?')}–"
+            f"{self.total_effort_range_days.get('high', '?')}d "
+            f"({self.total_effort_range_days.get('confidence', '?')} confidence)",
             "",
             "Hibernate Migration Impact Matrix:",
-            f"  {'Layer':<30} {'Risk':<9} Effort        Reason",
+            f"  {'Layer':<30} {'Risk':<9} {'Effort':<13} Breakdown",
         ]
         for r in self.risk_matrix:
+            bd = f"manual={r.manual_count} assisted={r.assisted_count} mech={r.mechanical_count}"
+            if r.static_count is not None:
+                bd += f" (static={r.static_count}/dyn={r.dynamic_count})"
             lines.append(
                 f"  {_LAYER_TITLES.get(r.layer, r.layer):<30} "
-                f"{r.risk.upper():<9} {r.estimated_effort:<13} {r.reason}"
+                f"{r.risk.upper():<9} {r.estimated_effort:<13} {bd}"
             )
 
         lines.append("")
@@ -249,8 +361,7 @@ class HibernateStratification:
                 tag_str = f"  [{', '.join(tags)}]" if tags else ""
                 layers = ", ".join(sorted(info.get("layers", {}).keys()))
                 lines.append(
-                    f"  {mod:<40} {info.get('max_risk', 'low').upper():<9} "
-                    f"{layers}{tag_str}"
+                    f"  {mod:<40} {info.get('max_risk', 'low').upper():<9} {layers}{tag_str}"
                 )
         else:
             lines.append("  (no module attribution)")
@@ -263,6 +374,24 @@ class HibernateStratification:
                     f"  {cc['class']}  ({cc['source_file']}:{cc['first_line']}) — {cc['reason']}"
                 )
 
+        if self.golden_sql_hotspots:
+            lines.append("")
+            lines.append("Golden-SQL Instrumentation Hotspots (where to pin behaviour tests):")
+            for h in self.golden_sql_hotspots:
+                lines.append(
+                    f"  {h['symbol']:<35} {h['dynamic_query_count']:>4} dyn-queries  "
+                    f"({h['source_file']})"
+                )
+
+        if self.rewrite_targets:
+            lines.append("")
+            lines.append(f"Rewrite Targets (first 15 of {len(self.rewrite_targets)}):")
+            for t in self.rewrite_targets[:15]:
+                lines.append(
+                    f"  [{t.migration_kind}] {t.source_file}:{t.line_start} "
+                    f"{t.symbol} → {t.target_api}"
+                )
+
         if self.incompatible_patterns:
             lines.append("")
             lines.append("Incompatible / High-risk Patterns Found:")
@@ -307,21 +436,150 @@ def _module_of(rel_path: str) -> str:
     return "root"
 
 
-def _first_line(source: str, match: re.Match) -> int:
-    return source[: match.start()].count("\n") + 1
+def _line_index(source: str) -> list[int]:
+    """Offsets of every newline — for O(log n) offset→line lookups via bisect."""
+    return [i for i, c in enumerate(source) if c == "\n"]
+
+
+def _line_at(nl: list[int], pos: int) -> int:
+    return bisect.bisect_right(nl, pos) + 1
+
+
+def _index_symbols(source: str, nl: list[int]) -> tuple[list[tuple[int, str]], list[tuple[int, str]]]:
+    classes = [(_line_at(nl, m.start()), m.group(1)) for m in _CLASS_DECL_RE.finditer(source)]
+    methods = [
+        (_line_at(nl, m.start()), m.group(1))
+        for m in _METHOD_DECL_RE.finditer(source)
+        if m.group(1) not in _NON_METHOD_NAMES
+    ]
+    return classes, methods
+
+
+def _nearest(decls: list[tuple[int, str]], line: int) -> Optional[str]:
+    best: Optional[str] = None
+    for dl, name in decls:
+        if dl <= line:
+            best = name
+        else:
+            break
+    return best
+
+
+def _symbol_at(line: int, classes: list[tuple[int, str]], methods: list[tuple[int, str]]) -> str:
+    cls = _nearest(classes, line)
+    meth = _nearest(methods, line)
+    if cls and meth:
+        return f"{cls}#{meth}"
+    return cls or meth or ""
+
+
+def _snippet(lines: list[str], ls: int, le: int) -> str:
+    seg = " ".join(l.strip() for l in lines[ls - 1: le])
+    seg = re.sub(r"\s+", " ", seg).strip()
+    return (seg[:157] + "...") if len(seg) > 160 else seg
 
 
 def _count(pattern: re.Pattern, source: str) -> int:
     return sum(1 for _ in pattern.finditer(source))
 
 
+def _make_id(layer: str, source_file: str, line: int, pattern: str) -> str:
+    h = hashlib.sha256(f"{source_file}:{line}:{pattern}".encode()).hexdigest()[:10]
+    return f"HB6-{_LAYER_CODE.get(layer, 'GEN')}-{h}"
+
+
 # ---------------------------------------------------------------------------
-# Effort heuristics
+# Target-mapping rules (current pattern → Hibernate 6 destination)
 # ---------------------------------------------------------------------------
 
-def _effort_bucket(file_count: int, base_days_per_file: float, floor: float = 0.5) -> str:
-    days = round(max(floor, file_count * base_days_per_file), 1) if file_count else 0.0
-    return f"~{days}d"
+def _criteria_target(legacy: bool, dynamic: bool) -> tuple[str, str, bool, str]:
+    if legacy:
+        return ("jakarta.persistence.criteria.CriteriaBuilder",
+                KIND_MANUAL, False,
+                "org.hibernate.Criteria / Restrictions / Projections removed in Hibernate 6")
+    if dynamic:
+        return ("jakarta.persistence.criteria.CriteriaBuilder (dynamic builder rewrite)",
+                KIND_MANUAL, False,
+                "dynamic Criteria construction via reflection / abstraction DAO")
+    return ("jakarta.persistence.criteria (validate Hibernate 6 semantics)",
+            KIND_ASSISTED, False,
+            "JPA Criteria metamodel/semantics changed in Hibernate 6")
+
+
+def _jpa_deprecated_target(text: str) -> tuple[str, str, bool, str]:
+    if "@TypeDef" in text:
+        return ("@Type(value=...) (Hibernate 6 — @TypeDef removed)",
+                KIND_ASSISTED, False, "@TypeDef / @TypeDefs removed in Hibernate 6")
+    if "@GenericGenerator" in text:
+        return ("@GenericGenerator (Hibernate 6 — strategy/parameters reworked)",
+                KIND_ASSISTED, False, "@GenericGenerator reworked in Hibernate 6")
+    # @Type(type="...") or org.hibernate.annotations.Type
+    return ("@Type(value=...) / @JdbcTypeCode (Hibernate 6)",
+            KIND_MECHANICAL, True,
+            "@Type(type=) attribute renamed/replaced in Hibernate 6 (1:1 mapping)")
+
+
+def _hql_target(concat: bool) -> tuple[str, str, bool, str]:
+    if concat:
+        return ("HQL (parameterize + validate Hibernate 6 parser)",
+                KIND_ASSISTED, False, "runtime-resolved query string (concatenation)")
+    return ("HQL / native query (validate against Hibernate 6 parser)",
+            KIND_REVIEW, False, "")
+
+
+def _spi_target(text: str) -> tuple[str, str, bool, str]:
+    t = text
+    if "UserCollectionType" in t:
+        return ("org.hibernate.usertype.UserCollectionType (redesigned in H6)",
+                KIND_MANUAL, False, "UserCollectionType interface redesigned in Hibernate 6")
+    if "CompositeUserType" in t:
+        return ("org.hibernate.usertype.CompositeUserType (redesigned in H6)",
+                KIND_MANUAL, False, "CompositeUserType redesigned in Hibernate 6")
+    if "UserType" in t:
+        return ("org.hibernate.usertype.UserType (new method signatures in H6)",
+                KIND_MANUAL, False, "UserType interface redesigned in Hibernate 6")
+    if "EmptyInterceptor" in t:
+        return ("org.hibernate.Interceptor (EmptyInterceptor removed in H6)",
+                KIND_MANUAL, False, "EmptyInterceptor removed in Hibernate 6")
+    if "Interceptor" in t:
+        return ("org.hibernate.Interceptor (default methods in H6)",
+                KIND_ASSISTED, False, "Interceptor gained default methods in Hibernate 6")
+    if "EventListener" in t:
+        return ("Hibernate 6 event SPI",
+                KIND_MANUAL, False, "Hibernate event-listener SPI changed in Hibernate 6")
+    if "PropertyAccessStrategy" in t:
+        return ("org.hibernate.property.access.spi (changed in H6)",
+                KIND_MANUAL, False, "PropertyAccess SPI changed in Hibernate 6")
+    if "NamingStrategy" in t:
+        return ("Hibernate 6 naming-strategy SPI",
+                KIND_ASSISTED, False, "Naming strategy SPI adjusted in Hibernate 6")
+    if "SessionFactoryImpl" in t or "SessionImplementor" in t or "SharedSessionContractImplementor" in t:
+        return ("Hibernate 6 session SPI (SharedSessionContractImplementor)",
+                KIND_MANUAL, False, "internal session SPI changed in Hibernate 6")
+    return ("Hibernate 6 internal SPI (no stable public equivalent)",
+            KIND_MANUAL, False, "internal Hibernate SPI — no direct Hibernate 6 equivalent")
+
+
+# Point-estimate person-days per affected file, per layer/branch — the audit-able
+# basis for effort_model. Ranges derive from these via _CONF_MULT.
+_EFFORT_RATES: dict[str, float] = {
+    "jpa_standard": 0.02,
+    "jpa_deprecated": 0.25,
+    "criteria_static": 0.4,
+    "criteria_dynamic": 0.75,
+    "hql_static": 0.15,
+    "hql_concat": 0.3,
+    "spi": 1.0,
+}
+
+
+def _effort_point(file_count: int, rate: float, floor: float = 0.5) -> float:
+    return round(max(floor, file_count * rate), 1) if file_count else 0.0
+
+
+def _effort_range(point: float, confidence: str) -> dict:
+    lo, hi = _CONF_MULT[confidence]
+    return {"low": round(point * lo, 1), "high": round(point * hi, 1), "confidence": confidence}
 
 
 # ---------------------------------------------------------------------------
@@ -329,11 +587,12 @@ def _effort_bucket(file_count: int, base_days_per_file: float, floor: float = 0.
 # ---------------------------------------------------------------------------
 
 def analyze_hibernate(file_paths: list[str], root: Path) -> HibernateStratification:
-    """Scan Java sources for stratified Hibernate 5→6 migration risk."""
+    """Scan Java sources for stratified Hibernate 5→6 migration risk + rewrite targets."""
     findings: list[HibernateFinding] = []
-    # module -> aggregation accumulator
+    targets: list[RewriteTarget] = []
     modules: dict[str, dict] = {}
     call_chains: list[dict] = []
+    hotspots: list[dict] = []
 
     layer_files: dict[str, set[str]] = {
         LAYER_JPA: set(), LAYER_CRITERIA: set(), LAYER_HQL: set(), LAYER_SPI: set()
@@ -346,10 +605,9 @@ def analyze_hibernate(file_paths: list[str], root: Path) -> HibernateStratificat
     spi_global = False
     reflection_query_global = False
     concat_query_global = False
-
     incompatible: set[str] = set()
 
-    for rel_path in file_paths:
+    for rel_path in sorted(file_paths):
         if not rel_path.endswith(".java"):
             continue
         abs_path = root / rel_path
@@ -358,22 +616,27 @@ def analyze_hibernate(file_paths: list[str], root: Path) -> HibernateStratificat
         except OSError:
             continue
 
-        # Per-file escalation context.
+        nl = _line_index(source)
+        src_lines = source.split("\n")
+        classes, methods = _index_symbols(source, nl)
+        module = _module_of(rel_path)
         has_abstraction = bool(_ABSTRACTION_CLASS_RE.search(source))
         has_reflection = bool(_REFLECTION_RE.search(source))
-        module = _module_of(rel_path)
+
         mod = modules.setdefault(
             module,
             {"layers": {}, "max_risk": "low", "criteria_dynamic": False,
              "has_spi": False, "has_reflection": False, "files": set()},
         )
+        if has_reflection:
+            mod["has_reflection"] = True
 
-        def _record(layer: str, severity: str, pattern_label: str,
-                    match: re.Match, occ: int, dynamic: bool = False) -> None:
+        def _emit_finding(layer: str, severity: str, label: str, line: int,
+                          occ: int, dynamic: bool = False) -> None:
             findings.append(HibernateFinding(
-                layer=layer, severity=severity, pattern=pattern_label,
-                source_file=rel_path, first_line=_first_line(source, match),
-                module=module, occurrences=occ, dynamic=dynamic,
+                layer=layer, severity=severity, pattern=label,
+                source_file=rel_path, first_line=line, module=module,
+                occurrences=occ, dynamic=dynamic,
             ))
             layer_files[layer].add(rel_path)
             layer_occ[layer] += occ
@@ -385,71 +648,114 @@ def analyze_hibernate(file_paths: list[str], root: Path) -> HibernateStratificat
                 mod["max_risk"] = severity
             mod["files"].add(rel_path)
 
-        if has_reflection:
-            mod["has_reflection"] = True
+        def _emit_target(layer: str, pattern: str, ls: int, le: int,
+                         target_api: str, kind: str, auto: bool, reason: str,
+                         dynamic: bool = False) -> None:
+            targets.append(RewriteTarget(
+                id=_make_id(layer, rel_path, ls, pattern),
+                layer=layer, source_file=rel_path, line_start=ls, line_end=le,
+                current_pattern=pattern, current_snippet=_snippet(src_lines, ls, le),
+                target_api=target_api, migration_kind=kind, auto_migratable=auto,
+                blocking_reason=reason, symbol=_symbol_at(ls, classes, methods),
+                module=module, dynamic=dynamic,
+            ))
 
         # ── Layer 1: JPA annotations ───────────────────────────────────────
-        m = _JPA_ANNOTATION_RE.search(source)
-        if m:
-            _record(LAYER_JPA, "low", "JPA mapping annotations",
-                    m, _count(_JPA_ANNOTATION_RE, source))
-        dm = _JPA_DEPRECATED_RE.search(source)
-        if dm:
+        ann_n = _count(_JPA_ANNOTATION_RE, source)
+        if ann_n:
+            am = _JPA_ANNOTATION_RE.search(source)
+            _emit_finding(LAYER_JPA, "low", "JPA mapping annotations",
+                          _line_at(nl, am.start()), ann_n)
+        # Deprecated annotations → escalate + emit rewrite targets (per occurrence).
+        dep_matches = list(_JPA_DEPRECATED_RE.finditer(source))
+        if dep_matches:
             jpa_deprecated_seen = True
-            _record(LAYER_JPA, "high", "Deprecated Hibernate annotation (@Type/@TypeDef/@GenericGenerator)",
-                    dm, _count(_JPA_DEPRECATED_RE, source))
-            incompatible.add("Deprecated Hibernate annotations (@Type(type=)/@TypeDef) — reworked in Hibernate 6")
+            first = dep_matches[0]
+            _emit_finding(LAYER_JPA, "high",
+                          "Deprecated Hibernate annotation (@Type/@TypeDef/@GenericGenerator)",
+                          _line_at(nl, first.start()), len(dep_matches))
+            incompatible.add("Deprecated Hibernate annotations (@Type(type=)/@TypeDef) — "
+                             "reworked in Hibernate 6")
+            for m in dep_matches:
+                ls = _line_at(nl, m.start())
+                api, kind, auto, reason = _jpa_deprecated_target(m.group(0))
+                _emit_target(LAYER_JPA, "deprecated-annotation", ls, ls,
+                             api, kind, auto, reason)
 
         # ── Layer 2: Criteria API ──────────────────────────────────────────
-        crit_m = _CRITERIA_JPA_RE.search(source)
-        legacy_m = _CRITERIA_LEGACY_RE.search(source)
-        crit_hit = crit_m or legacy_m
-        if crit_hit:
-            dynamic = has_abstraction or has_reflection
+        dynamic = has_abstraction or has_reflection
+        crit_matches: list[tuple[re.Match, bool]] = (
+            [(m, False) for m in _CRITERIA_JPA_RE.finditer(source)]
+            + [(m, True) for m in _CRITERIA_LEGACY_RE.finditer(source)]
+        )
+        if crit_matches:
             severity = "critical" if dynamic else "high"
-            occ = _count(_CRITERIA_JPA_RE, source) + _count(_CRITERIA_LEGACY_RE, source)
+            first_line = min(_line_at(nl, m.start()) for m, _ in crit_matches)
             label = ("Dynamic Criteria construction (reflection/abstraction DAO)"
                      if dynamic else "Criteria API usage")
-            _record(LAYER_CRITERIA, severity, label, crit_hit, occ, dynamic=dynamic)
+            _emit_finding(LAYER_CRITERIA, severity, label, first_line,
+                          len(crit_matches), dynamic=dynamic)
             if dynamic:
                 criteria_dynamic_global = True
                 mod["criteria_dynamic"] = True
                 incompatible.add("Criteria built dynamically via reflection/abstraction layer "
                                  "(Hibernate 6 incompatible patterns likely)")
-            if legacy_m:
-                incompatible.add("Legacy org.hibernate.Criteria / Restrictions / Projections "
-                                 "(removed in Hibernate 6 — must move to JPA CriteriaBuilder)")
+            for m, legacy in crit_matches:
+                ls = _line_at(nl, m.start())
+                api, kind, auto, reason = _criteria_target(legacy, dynamic)
+                _emit_target(LAYER_CRITERIA,
+                             "legacy-criteria" if legacy else "jpa-criteria",
+                             ls, ls, api, kind, auto, reason, dynamic=dynamic)
+                if legacy:
+                    incompatible.add("Legacy org.hibernate.Criteria / Restrictions / Projections "
+                                     "(removed in Hibernate 6 — move to JPA CriteriaBuilder)")
 
         # ── Layer 3: HQL / string queries ──────────────────────────────────
-        hql_m = _HQL_RE.search(source)
-        if hql_m:
-            concat_m = _HQL_CONCAT_RE.search(source)
-            if concat_m:
+        hql_matches = list(_HQL_RE.finditer(source))
+        if hql_matches:
+            file_has_concat = False
+            first_line = _line_at(nl, hql_matches[0].start())
+            for m in hql_matches:
+                ls = _line_at(nl, m.start())
+                window = source[m.start(): m.start() + 400]
+                is_concat = bool(_HQL_CONCAT_RE.match("." + window) or _HQL_CONCAT_RE.search(window))
+                le = _line_at(nl, m.start() + (window.find(";") if ";" in window else 0))
+                le = max(ls, le)
+                api, kind, auto, reason = _hql_target(is_concat)
+                _emit_target(LAYER_HQL, "concat-query" if is_concat else "static-query",
+                             ls, le if is_concat else ls, api, kind, auto, reason)
+                if is_concat:
+                    file_has_concat = True
+            sev = "high" if file_has_concat else "medium"
+            label = ("String-concatenated HQL/native query (dynamic SQL shape)"
+                     if file_has_concat else "HQL / native string query")
+            _emit_finding(LAYER_HQL, sev, label, first_line, len(hql_matches))
+            if file_has_concat:
                 concat_query_global = True
-                _record(LAYER_HQL, "high",
-                        "String-concatenated HQL/native query (dynamic SQL shape)",
-                        concat_m, _count(_HQL_RE, source))
                 incompatible.add("String-concatenated HQL/native queries — HIGH risk under "
-                                 "Hibernate 6 ORM parser changes")
-            else:
-                _record(LAYER_HQL, "medium", "HQL / native string query",
-                        hql_m, _count(_HQL_RE, source))
+                                 "Hibernate 6 HQL parser changes")
 
         # ── Layer 4: Hibernate SPI / internal ──────────────────────────────
-        spi_m = _SPI_RE.search(source)
-        if spi_m:
+        spi_matches = list(_SPI_RE.finditer(source))
+        if spi_matches:
             spi_global = True
             mod["has_spi"] = True
-            _record(LAYER_SPI, "critical", "Hibernate SPI / internal API (UserType/Interceptor/SPI)",
-                    spi_m, _count(_SPI_RE, source))
+            first = spi_matches[0]
+            _emit_finding(LAYER_SPI, "critical",
+                          "Hibernate SPI / internal API (UserType/Interceptor/SPI)",
+                          _line_at(nl, first.start()), len(spi_matches))
             incompatible.add("Custom Hibernate SPI (UserType/CompositeUserType/Interceptor/"
                              "EventListener) — primary Hibernate 5→6 breakage source")
+            for m in spi_matches:
+                ls = _line_at(nl, m.start())
+                api, kind, auto, reason = _spi_target(m.group(0))
+                _emit_target(LAYER_SPI, "hibernate-spi", ls, ls, api, kind, auto, reason)
 
         # ── Critical call-chain detection ──────────────────────────────────
-        if has_abstraction and (crit_hit or has_reflection):
+        if has_abstraction and (crit_matches or has_reflection):
             am = _ABSTRACTION_CLASS_RE.search(source)
             reason_bits = []
-            if crit_hit:
+            if crit_matches:
                 reason_bits.append("Criteria construction")
             if has_reflection:
                 reason_bits.append("reflection-based entity metadata")
@@ -457,13 +763,30 @@ def analyze_hibernate(file_paths: list[str], root: Path) -> HibernateStratificat
             call_chains.append({
                 "class": am.group(0),
                 "source_file": rel_path,
-                "first_line": _first_line(source, am),
+                "first_line": _line_at(nl, am.start()),
                 "reason": "dynamic query generation: " + " + ".join(reason_bits),
                 "module": module,
             })
+            # Golden-SQL hotspot: rank by dynamic query volume in this file.
+            dyn_q = len(crit_matches) + _count(_REFLECTION_RE, source)
+            hotspots.append({
+                "symbol": _symbol_at(_line_at(nl, am.start()), classes, methods) or am.group(0),
+                "source_file": rel_path,
+                "module": module,
+                "dynamic_query_count": dyn_q,
+                "reflection": has_reflection,
+                "reason": "concentrates runtime-generated queries — pin golden-SQL tests here",
+            })
 
     strat = HibernateStratification()
     strat.findings = findings
+    strat.rewrite_targets = sorted(
+        targets, key=lambda t: (t.source_file, t.line_start, t.layer, t.id)
+    )
+    strat.critical_call_chains = sorted(call_chains, key=lambda c: (c["source_file"], c["first_line"]))
+    strat.golden_sql_hotspots = sorted(
+        hotspots, key=lambda h: (-h["dynamic_query_count"], h["source_file"])
+    )[:25]
 
     if not findings:
         strat.detected = False
@@ -472,62 +795,98 @@ def analyze_hibernate(file_paths: list[str], root: Path) -> HibernateStratificat
         return strat
 
     strat.detected = True
-    strat.critical_call_chains = call_chains
     strat.incompatible_patterns = sorted(incompatible)
 
-    # ── Build per-layer risk matrix ────────────────────────────────────────
+    # Per-layer target kind tallies.
+    def _kind_counts(layer: str) -> dict[str, int]:
+        c = {KIND_MANUAL: 0, KIND_ASSISTED: 0, KIND_MECHANICAL: 0, KIND_REVIEW: 0}
+        for t in targets:
+            if t.layer == layer:
+                c[t.migration_kind] = c.get(t.migration_kind, 0) + 1
+        return c
+
     matrix: list[HibernateLayerRisk] = []
+    point_days: dict[str, float] = {}
 
     # Layer 1
     if layer_files[LAYER_JPA]:
+        kc = _kind_counts(LAYER_JPA)
         if jpa_deprecated_seen:
-            risk, reason = "high", ("Deprecated Hibernate annotations present "
-                                    "(@Type(type=)/@TypeDef/@GenericGenerator reworked in H6)")
-            effort = _effort_bucket(len(layer_files[LAYER_JPA]), 0.25)
+            risk, conf = "high", "medium"
+            reason = ("Deprecated Hibernate annotations present "
+                      "(@Type(type=)/@TypeDef/@GenericGenerator reworked in H6)")
+            point = _effort_point(len(layer_files[LAYER_JPA]), _EFFORT_RATES["jpa_deprecated"])
         else:
-            risk, reason = "low", ("Standard JPA mapping only — namespace handled by "
-                                   "jakarta migration, no Hibernate-6 annotation breakage")
-            effort = _effort_bucket(len(layer_files[LAYER_JPA]), 0.02, floor=0.2)
+            risk, conf = "low", "high"
+            reason = ("Standard JPA mapping only — namespace handled by jakarta "
+                      "migration, no Hibernate-6 annotation breakage")
+            point = _effort_point(len(layer_files[LAYER_JPA]), _EFFORT_RATES["jpa_standard"], floor=0.2)
+        point_days[LAYER_JPA] = point
         matrix.append(HibernateLayerRisk(
-            LAYER_JPA, risk, reason, effort,
-            len(layer_files[LAYER_JPA]), layer_occ[LAYER_JPA]))
+            LAYER_JPA, risk, reason, f"~{point}d", len(layer_files[LAYER_JPA]),
+            layer_occ[LAYER_JPA], _effort_range(point, conf),
+            manual_count=kc[KIND_MANUAL], assisted_count=kc[KIND_ASSISTED],
+            mechanical_count=kc[KIND_MECHANICAL], review_count=kc[KIND_REVIEW]))
 
     # Layer 2
     if layer_files[LAYER_CRITERIA]:
+        kc = _kind_counts(LAYER_CRITERIA)
+        crit_targets = [t for t in targets if t.layer == LAYER_CRITERIA]
+        dyn_n = sum(1 for t in crit_targets if t.dynamic)
+        stat_n = len(crit_targets) - dyn_n
         if criteria_dynamic_global:
-            risk, reason = "critical", ("Criteria constructed dynamically via reflection / "
-                                        "abstraction DAOs — Hibernate 6 rewrite zone")
-            effort = _effort_bucket(len(layer_files[LAYER_CRITERIA]), 0.75)
+            risk, conf = "critical", "low"
+            reason = ("Criteria constructed dynamically via reflection / abstraction DAOs "
+                      "— Hibernate 6 rewrite zone")
+            point = _effort_point(len(layer_files[LAYER_CRITERIA]), _EFFORT_RATES["criteria_dynamic"])
         else:
-            risk, reason = "high", ("Criteria API in use — JPA Criteria semantics changed; "
-                                    "legacy org.hibernate.Criteria removed in H6")
-            effort = _effort_bucket(len(layer_files[LAYER_CRITERIA]), 0.4)
+            risk, conf = "high", "medium"
+            reason = ("Criteria API in use — JPA Criteria semantics changed; "
+                      "legacy org.hibernate.Criteria removed in H6")
+            point = _effort_point(len(layer_files[LAYER_CRITERIA]), _EFFORT_RATES["criteria_static"])
+        point_days[LAYER_CRITERIA] = point
         matrix.append(HibernateLayerRisk(
-            LAYER_CRITERIA, risk, reason, effort,
-            len(layer_files[LAYER_CRITERIA]), layer_occ[LAYER_CRITERIA]))
+            LAYER_CRITERIA, risk, reason, f"~{point}d", len(layer_files[LAYER_CRITERIA]),
+            layer_occ[LAYER_CRITERIA], _effort_range(point, conf),
+            manual_count=kc[KIND_MANUAL], assisted_count=kc[KIND_ASSISTED],
+            mechanical_count=kc[KIND_MECHANICAL], review_count=kc[KIND_REVIEW],
+            static_count=stat_n, dynamic_count=dyn_n))
 
     # Layer 3
     if layer_files[LAYER_HQL]:
+        kc = _kind_counts(LAYER_HQL)
         if concat_query_global:
-            risk, reason = "high", ("String-concatenated / dynamic queries — HIGH risk under "
-                                    "Hibernate 6 HQL parser changes")
-            effort = _effort_bucket(len(layer_files[LAYER_HQL]), 0.3)
+            risk, conf = "high", "medium"
+            reason = ("String-concatenated / dynamic queries — HIGH risk under "
+                      "Hibernate 6 HQL parser changes")
+            point = _effort_point(len(layer_files[LAYER_HQL]), _EFFORT_RATES["hql_concat"])
         else:
-            risk, reason = "medium", ("Static HQL / native queries — revalidate against "
-                                      "Hibernate 6 parser; mostly mechanical")
-            effort = _effort_bucket(len(layer_files[LAYER_HQL]), 0.15)
+            risk, conf = "medium", "high"
+            reason = ("Static HQL / native queries — revalidate against Hibernate 6 "
+                      "parser; mostly mechanical")
+            point = _effort_point(len(layer_files[LAYER_HQL]), _EFFORT_RATES["hql_static"])
+        point_days[LAYER_HQL] = point
         matrix.append(HibernateLayerRisk(
-            LAYER_HQL, risk, reason, effort,
-            len(layer_files[LAYER_HQL]), layer_occ[LAYER_HQL]))
+            LAYER_HQL, risk, reason, f"~{point}d", len(layer_files[LAYER_HQL]),
+            layer_occ[LAYER_HQL], _effort_range(point, conf),
+            manual_count=kc[KIND_MANUAL], assisted_count=kc[KIND_ASSISTED],
+            mechanical_count=kc[KIND_MECHANICAL], review_count=kc[KIND_REVIEW]))
 
     # Layer 4
     if layer_files[LAYER_SPI]:
-        risk, reason = "critical", ("Custom Hibernate SPI/internal API (UserType, Interceptor, "
-                                    "EventListener, engine.spi) — primary H5→H6 breakage")
-        effort = _effort_bucket(len(layer_files[LAYER_SPI]), 1.0)
+        kc = _kind_counts(LAYER_SPI)
+        point = _effort_point(len(layer_files[LAYER_SPI]), _EFFORT_RATES["spi"])
+        point_days[LAYER_SPI] = point
         matrix.append(HibernateLayerRisk(
-            LAYER_SPI, risk, reason, effort,
-            len(layer_files[LAYER_SPI]), layer_occ[LAYER_SPI]))
+            LAYER_SPI, "critical",
+            "Custom Hibernate SPI/internal API (UserType, Interceptor, EventListener, "
+            "engine.spi) — primary H5→H6 breakage",
+            f"~{point}d", len(layer_files[LAYER_SPI]), layer_occ[LAYER_SPI],
+            _effort_range(point, "low"),
+            manual_count=kc[KIND_MANUAL], assisted_count=kc[KIND_ASSISTED],
+            mechanical_count=kc[KIND_MECHANICAL], review_count=kc[KIND_REVIEW],
+            userType_rewrite_count=kc[KIND_MANUAL],
+            userType_resolvable_count=kc[KIND_ASSISTED]))
 
     strat.risk_matrix = matrix
 
@@ -547,6 +906,31 @@ def analyze_hibernate(file_paths: list[str], root: Path) -> HibernateStratificat
         }
     strat.module_exposure = exposure
 
+    # ── Effort aggregation (honest: upper bound, layers may share files) ────
+    confidences = [r.effort_range.get("confidence", "low") for r in matrix]
+    worst_conf = "low" if "low" in confidences else ("medium" if "medium" in confidences else "high")
+    strat.total_effort_range_days = {
+        "low": round(sum(r.effort_range.get("low", 0) for r in matrix), 1),
+        "high": round(sum(r.effort_range.get("high", 0) for r in matrix), 1),
+        "confidence": worst_conf,
+    }
+    strat.effort_model = {
+        "unit": "person-days",
+        "point_days_per_file": dict(_EFFORT_RATES),
+        "range_multipliers_by_confidence": {k: list(v) for k, v in _CONF_MULT.items()},
+        "range_method": "low = point × low_mult, high = point × high_mult (per confidence band)",
+        "caveat": ("Per-layer efforts may share files; total_effort_range_days is an upper "
+                   "bound and is NOT deduplicated across layers."),
+    }
+
+    # ── hibernate_readiness (0-100) ────────────────────────────────────────
+    crit_f = {f.source_file for f in findings if f.severity == "critical"}
+    high_f = {f.source_file for f in findings if f.severity == "high"}
+    med_f = {f.source_file for f in findings if f.severity == "medium"}
+    low_f = {f.source_file for f in findings if f.severity == "low"}
+    deduction = len(crit_f) * 15 + len(high_f) * 8 + len(med_f) * 3 + min(len(low_f), 15)
+    strat.readiness = max(0, 100 - deduction)
+
     # ── Stop-condition logic → upgrade vs rewrite classification ────────────
     stops: list[str] = []
     if criteria_dynamic_global:
@@ -565,8 +949,6 @@ def analyze_hibernate(file_paths: list[str], root: Path) -> HibernateStratificat
         strat.classification = CLASS_REWRITE
     elif layer_files[LAYER_CRITERIA] or concat_query_global or jpa_deprecated_seen:
         strat.classification = CLASS_UPGRADE_CARE
-    elif layer_files[LAYER_HQL] or layer_files[LAYER_JPA]:
-        strat.classification = CLASS_UPGRADE
     else:
         strat.classification = CLASS_UPGRADE
     strat.classification_label = _CLASS_LABELS[strat.classification]
@@ -582,7 +964,6 @@ def analyze_hibernate(file_paths: list[str], root: Path) -> HibernateStratificat
         observable.append(f"HQL/native query calls in {len(layer_files[LAYER_HQL])} file(s)")
     if layer_files[LAYER_SPI]:
         observable.append(f"Hibernate SPI/internal API in {len(layer_files[LAYER_SPI])} file(s)")
-
     if criteria_dynamic_global or reflection_query_global:
         inferred.append("Runtime-generated query shapes (reflection/metadata) — exact SQL "
                         "cannot be statically enumerated; breakage surface is larger than "

sourcecode/mcp/server.py

@@ -792,7 +792,11 @@ def get_migration_readiness(repo_path: str = ".", min_severity: str = "low") ->
 
     Maps to: sourcecode migrate-check <repo_path> --min-severity <min_severity>
     Returns: MigrationReport with schema_version, readiness_score (0–100; 100=ready to migrate),
-             jakarta_readiness / boot3_readiness / jdk_modernization (per-dimension 0–100),
+             jakarta_readiness / boot3_readiness / jdk_modernization / hibernate_readiness
+             (per-dimension 0–100), headline_blocker (e.g. "hibernate_rewrite" or null),
+             hibernate (Hibernate 5→6 stratified model: 4-layer risk_matrix, rewrite_targets[]
+             with line-level call sites + target_api + migration_kind, module_exposure_map,
+             golden_sql_hotspots, total_effort_range_days, classification upgrade/rewrite),
              blocking_count, estimated_effort_days,
              spring_boot_2_detected (true|false|null — null=undetermined, never assumed true),
              spring_boot_version_detected,

sourcecode/migrate_check.py

@@ -1055,6 +1055,12 @@ class MigrationReport:
     jakarta_readiness: int = 100
     boot3_readiness: int = 100
     jdk_modernization: int = 100
+    # 4th dimension: Hibernate 5→6 rewrite readiness (independent of jakarta/Boot3).
+    # 100 when no Hibernate usage; sinks toward 0 in a rewrite zone.
+    hibernate_readiness: int = 100
+    # Names the dominant blocker class when one dimension dwarfs the headline
+    # score (e.g. "hibernate_rewrite") so a reader of readiness_score is not misled.
+    headline_blocker: Optional[str] = None
     blocking_count: int = 0
     estimated_effort_days: float = 0.0
     # Tri-state: True = Boot 2 confirmed, False = Boot 3+ confirmed,
@@ -1133,6 +1139,14 @@ class MigrationReport:
         self.boot3_readiness = _dimension_score(self.findings, _BOOT3_MIGRATION_TARGETS)
         self.jdk_modernization = _dimension_score(self.findings, None)
 
+        # Hibernate is its own rewrite axis (orthogonal to jakarta/Boot3); it does
+        # NOT sink the headline readiness_score, but is surfaced as a dimension and,
+        # in a rewrite zone, as the headline_blocker so 62/100 is not read as "easy".
+        if self.hibernate is not None and self.hibernate.detected:
+            self.hibernate_readiness = self.hibernate.readiness
+            if self.hibernate.classification == "rewrite_zone":
+                self.headline_blocker = "hibernate_rewrite"
+
         self.estimated_effort_days = round(
             len(critical_files) * 0.5
             + len(high_files) * 0.25
@@ -1160,6 +1174,8 @@ class MigrationReport:
             "jakarta_readiness": self.jakarta_readiness,
             "boot3_readiness": self.boot3_readiness,
             "jdk_modernization": self.jdk_modernization,
+            "hibernate_readiness": self.hibernate_readiness,
+            "headline_blocker": self.headline_blocker,
             "blocking_count": self.blocking_count,
             "estimated_effort_days": self.estimated_effort_days,
             "spring_boot_2_detected": self.spring_boot_2_detected,
@@ -1185,7 +1201,11 @@ class MigrationReport:
             f"Migration Readiness: {self.readiness_score}/100",
             f"  jakarta: {self.jakarta_readiness}/100  "
             f"boot3: {self.boot3_readiness}/100  "
-            f"jdk-modernization: {self.jdk_modernization}/100",
+            f"jdk-modernization: {self.jdk_modernization}/100  "
+            f"hibernate: {self.hibernate_readiness}/100",
+            *([f"  ⚠ Headline blocker: {self.headline_blocker} "
+               f"(readiness_score reflects jakarta/Boot3 only — Hibernate is a separate rewrite axis)"]
+              if self.headline_blocker else []),
             f"Spring Boot 2 detected: {_boot}",
             f"Blocking issues: {self.blocking_count}  "
             f"(critical: {self.summary.get('by_severity', {}).get('critical', 0)}, "

{sourcecode-1.62.0.dist-info → sourcecode-1.63.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.62.0
+Version: 1.63.0
 Summary: Persistent structural context and ultra-fast repeated analysis for AI coding agents
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm
@@ -657,6 +657,58 @@ Detects migration blockers across Java source files, Spring XML config files, an
 
 Each finding includes `severity`, `title`, `source_file`, `first_line`, `explanation`, `fix_hint`, `migration_target`, and `openrewrite_recipe` (when an automated recipe exists).
 
+#### Hibernate 5.x → 6.x stratification (the `hibernate` output section)
+
+A Hibernate major upgrade is **not** a single dependency bump for systems that use
+dynamic persistence. `migrate-check` stratifies Hibernate exposure into four
+independent migration domains — never one aggregated score — and emits **actionable,
+machine-readable rewrite targets** so a migration agent can consume the output
+directly instead of re-parsing the repo. Sub-`schema_version`: `2.0`.
+
+**Four layers** (each on its own risk axis):
+
+| Layer | Baseline | Escalates to |
+|-------|----------|--------------|
+| `jpa_annotations` | LOW (namespace handled by jakarta) | HIGH on deprecated `@Type(type=)` / `@TypeDef` / `@GenericGenerator` |
+| `criteria_api` | HIGH (JPA Criteria semantics changed; legacy `org.hibernate.Criteria` removed) | **CRITICAL** when built via reflection / abstraction DAOs (`DynamicEntityDao`, `GenericDao`, `BasicPersistenceModule`) |
+| `hql_string_queries` | MEDIUM (revalidate against H6 parser) | HIGH on string concatenation (SQL shape not statically inferable) |
+| `hibernate_spi_internal` | CRITICAL blocker | `UserType`, `CompositeUserType`, `Interceptor`, `EventListener`, `org.hibernate.engine.spi` |
+
+**Output keys (under `hibernate`):**
+
+- `classification` — `upgrade_zone` / `upgrade_with_care` / `rewrite_zone`. Any of
+  {dynamic Criteria, custom SPI, reflection-built queries, concatenated query
+  strings} forces **`rewrite_zone`** ("HIGH RISK REWRITE ZONE, NOT UPGRADE ZONE").
+- `risk_matrix[]` — per layer: `risk`, `reason`, `effort_range {low, high, confidence}`,
+  `file_count`, `occurrence_count`, migration-kind sub-counts (`manual_count`,
+  `assisted_count`, `mechanical_count`, `review_count`); Criteria adds
+  `static_count` vs `dynamic_count`; SPI adds `userType_rewrite_count` vs
+  `userType_resolvable_count`.
+- `rewrite_targets[]` — one actionable target per call site: `id`, `layer`,
+  `source_file`, `line_start`/`line_end`, `current_pattern`, `current_snippet`,
+  `target_api` (the Hibernate-6 destination), `migration_kind`
+  (`manual_rewrite` / `assisted` / `mechanical` / `review`), `auto_migratable`,
+  `blocking_reason`, `symbol` (enclosing `Class#method`), `module`, `dynamic`.
+- `module_exposure_map` — per Maven/Gradle module: `max_risk`, layers present, and
+  `dynamic-criteria` / `custom-SPI` / `reflection` tags.
+- `critical_call_chains[]` — dynamic query-generation paths (reflection-based DAOs).
+- `golden_sql_hotspots[]` — classes/methods ranked by dynamic-query volume — where
+  to pin golden-SQL behaviour tests before migrating.
+- `total_effort_range_days` + `effort_model` — aggregate range plus the auditable
+  formula (and the caveat that layers may share files, so the total is an upper bound).
+- `stop_conditions_triggered[]`, `risk_separation` (observable vs inferred runtime risk).
+
+The report also exposes **`hibernate_readiness`** (0–100) as a fourth readiness
+dimension alongside `jakarta_readiness` / `boot3_readiness` / `jdk_modernization`.
+Hibernate is an orthogonal rewrite axis, so it does not sink the headline
+`readiness_score`; instead, in a rewrite zone the top-level `headline_blocker` is set
+to `"hibernate_rewrite"` so a reader of the headline score is not misled.
+
+```bash
+# inspect only the Hibernate rewrite targets
+sourcecode migrate-check . --format json | jq '.hibernate.rewrite_targets[]'
+```
+
 ### `rename-class` — Java class rename
 
 ```bash

{sourcecode-1.62.0.dist-info → sourcecode-1.63.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sourcecode/__init__.py,sha256=M2ctLJu2Bc_7rapOGaPAxxYG50XM5jz5dbisyWgh-sE,103
+sourcecode/__init__.py,sha256=7g_-jxyy4w0b0JRdZtxAZ89mML035ZUubdqOo6hl_u0,103
 sourcecode/adaptive_scanner.py,sha256=XffluXKzJUXrMtjEiAOnSNPZnztdIcts17T9ouHeID0,10521
 sourcecode/architecture_analyzer.py,sha256=liCwQmLgb5vplohy8arjYxs_HOIv5C9MjLh_gY6bc5Q,44115
 sourcecode/architecture_summary.py,sha256=z34_6v7cSwy98cof2UVciGho7SCrZ93tiqMmq5WNzRQ,20405
@@ -7,7 +7,7 @@ sourcecode/cache.py,sha256=1V3vsaODAa2UBJAC0xpvxpmRdriCezQx5Q8JCcfgziE,31892
 sourcecode/canonical_ir.py,sha256=DEwucOPJguLsVtg5cV8mWXNi112l5jmBhv73KGGebVk,24849
 sourcecode/cir_graphs.py,sha256=9G0HHj1kw2325IDyzo2OpX73BNswEckecf4MZUXB4JM,12078
 sourcecode/classifier.py,sha256=hKzg-nQ47htqqIUzSGvYxv15cXrA3KgICTwJmdqal0o,8095
-sourcecode/cli.py,sha256=bEArsMTzwzag8xk-d2AkQk2I3WiZmVyoILRu_PtYBY0,276304
+sourcecode/cli.py,sha256=PwLLelj1ACLkWQBCEThD6vhn4sGMn5kEg-6gRX1IAb8,276536
 sourcecode/code_notes_analyzer.py,sha256=EJemNCNc9Dn-1RZYu-aNbK0ELzmsyC4s6FdHi3XyNEI,9392
 sourcecode/confidence_analyzer.py,sha256=_jckZSxksV-OU38vbkxfVNBnWCtlCq8Vwfg23x1uspA,19054
 sourcecode/context_scorer.py,sha256=QpChSpsmaAYz91rXA4Ue5xzQmNz_ZboZN09YOHScq1U,14679
@@ -28,12 +28,12 @@ sourcecode/format_contract.py,sha256=1cTNqwP8geA2hbQoBHUPgX3_vSh3l8guJT_jmgEnFF8
 sourcecode/fqn_utils.py,sha256=XLU7zDkNBXz_RZkIUNfpPmp1nekWtqP-fxV92tDV1vg,2158
 sourcecode/git_analyzer.py,sha256=JStxTQXNjBWi_wLdwhsZs9mT-v50cSJIz4Agzn6Kh9I,13362
 sourcecode/graph_analyzer.py,sha256=DHR8fY69oU_Pi4SYaWboX6EoEFrctQKB9dsjpqwGMzw,62403
-sourcecode/hibernate_strat.py,sha256=Q_IJpO2jZEDaFPyp0v9svlcB3LetOu56R8Mv7S2F3aU,26165
+sourcecode/hibernate_strat.py,sha256=Xl2gs_uIpjjq4fHtuibi6wGwpeEC-iKYmDSNYC5M6yM,44143
 sourcecode/integration_detector.py,sha256=ZJqrGwvZ4ee2JTGhlazKk67aZi173HxkhNpl8Yntpd8,6503
 sourcecode/license.py,sha256=wckiLuiwaE35KMCStUf1gYzleJuFe6qsSyxUQJvit3s,23500
 sourcecode/mcp_nudge.py,sha256=5ELU_ixzh6uA83NXLOZT8h00OhL53okfQdji3jyKOjg,2917
 sourcecode/metrics_analyzer.py,sha256=m0ENgtqKeBL17kUIK3fmGkgo7UfXBNHxCMj0H_Y5K7c,22750
-sourcecode/migrate_check.py,sha256=2f7f2NCrBmIqh4MzAHthaZ4UQTyAgjIkRPV9Fdi4Nic,65166
+sourcecode/migrate_check.py,sha256=Er4pr_f3_eUS4A5G87hxnPMcQee2hqV9-XaS_sdkdu4,66470
 sourcecode/openapi_surface.py,sha256=BTt0K-woZbkbWTN77IkqeBm_Okag9owR0848fmot8sk,16207
 sourcecode/output_budget.py,sha256=Js9yUlfQtPhqBl9R6wn_9UHVjjJc3GtLcqyfjf5t50Q,9869
 sourcecode/path_filters.py,sha256=EN1RGZRvLq5EcPgpjYV_IyCKVlAQQn2bbpEisQ5LpGg,3780
@@ -91,7 +91,7 @@ sourcecode/mcp/__init__.py,sha256=XU4HfRGbdid8wdUA0x_4f7uKZD1z3mv_XUY_WU_T9Mw,17
 sourcecode/mcp/orchestrator.py,sha256=kT7IssYNyQXVtDf2Q69qrMSTuyJlJ1Rhkp6_EHqc_38,36520
 sourcecode/mcp/registry.py,sha256=8ot8A9_ccPNUvHgFkUO8lIlbp4XT_UcHR101nc71Gjc,65840
 sourcecode/mcp/runner.py,sha256=-Dp2qPGRkfNTVen6bKh7WtzQqpcEtsrXoiuajvshlKk,2866
-sourcecode/mcp/server.py,sha256=AQN076joOHyKoU7HaISpzPIIN-5271DDn5DqbQsnTaI,63324
+sourcecode/mcp/server.py,sha256=DV7aiUObBGekShSDc7Iu67ISdesByutto3JOFbcYBFk,63693
 sourcecode/mcp/onboarding/__init__.py,sha256=sj2PWqEBmMc4zBNkomg89WtL0M6S7A9yb7_wAuSWNP4,66
 sourcecode/mcp/onboarding/applier.py,sha256=B9CneieWTpaDSDIyW3S5nrlRlBpvfqUcgi93-mm_ApQ,2135
 sourcecode/mcp/onboarding/backup.py,sha256=ihqGOR8QTX8HASRSEDyfFyXr5bkXrygPHamv4p9KTmk,1452
@@ -103,8 +103,8 @@ sourcecode/telemetry/consent.py,sha256=H5z2Wu63pZqbaKucRPoJQJ0zCo4cke9ZlBrJC-MaW
 sourcecode/telemetry/events.py,sha256=LtzYfaX9Ilckj5PTvAcTpDa9mLqDsYPDUiDkRa58piY,2580
 sourcecode/telemetry/filters.py,sha256=NHa5T-6DaZduQPFuC34jOqHWQgSizM-Ygq8aZ4j19ng,5834
 sourcecode/telemetry/transport.py,sha256=4gGHsq0WeY9VywEZXA3vUxykfiYnw9uuqfjAAec7F8o,1681
-sourcecode-1.62.0.dist-info/METADATA,sha256=pj1Wd3yqoYh6bYXMq-w9Z4ZF4bqAAAfyfMo4sWaMkzQ,38941
-sourcecode-1.62.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-1.62.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-1.62.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-1.62.0.dist-info/RECORD,,
+sourcecode-1.63.0.dist-info/METADATA,sha256=P3a_x2U773iEAxs6a79XDIL1XT4cyAGfY5Y7KKmUQ_I,42339
+sourcecode-1.63.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-1.63.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-1.63.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-1.63.0.dist-info/RECORD,,