sourcecode 2.0.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

sourcecode/__init__.py

@@ -4,4 +4,4 @@ ASK Engine is the product. ``ask`` is the canonical CLI command; ``sourcecode``
 the legacy compatibility alias and the Python/PyPI package name. See
 docs/PRODUCT_IDENTITY.md (normative)."""
 
-__version__ = "2.0.0"
+__version__ = "2.1.0"

sourcecode/cli.py

@@ -4496,7 +4496,18 @@ def validation_cmd(
     from sourcecode.context_graph import ContextGraph
     from sourcecode.validation_surface import build_validation_surface
     # Structural facts come from the ContextGraph — the single access layer.
-    data = build_validation_surface(target, graph=ContextGraph.build_from_root(target))
+    _graph = ContextGraph.build_from_root(target)
+    data = build_validation_surface(target, graph=_graph)
+
+    # P1-C: classify the request-body validation *pattern* so a repo with a
+    # validation framework on the classpath but no @Valid reads as
+    # "present-but-unused" instead of a silent sea of zeros (DESIGN §2/§5).
+    try:
+        from sourcecode.validation_inference import infer_validation_pattern
+
+        data["validation_pattern"] = infer_validation_pattern(_graph.cir).to_dict()
+    except Exception:
+        pass
 
     if path_prefix:
         data["endpoints"] = [
@@ -4836,6 +4847,16 @@ def migrate_check_cmd(
         help="Minimum severity to include: critical, high, medium, or low (default).",
         show_default=True,
     ),
+    compact: bool = typer.Option(
+        False,
+        "--compact",
+        help=(
+            "Bounded decision summary (JSON): readiness scores, headline blocker, "
+            "effort, executive summary, Hibernate classification and aggregate "
+            "counts, with large collections capped to their top items (+N more). "
+            "No new analysis — same report, projected. Full detail is the default."
+        ),
+    ),
     no_cache: bool = typer.Option(
         False, "--no-cache",
         help="Accepted for compatibility; this command always reads fresh source (no snapshot cache). No-op.",
@@ -4867,6 +4888,7 @@ def migrate_check_cmd(
     \b
     Examples:
       ask migrate-check .
+      ask migrate-check . --compact          bounded decision summary
       ask migrate-check /path/to/repo --format text
       ask migrate-check . --min-severity high
       ask migrate-check . --output migration.json
@@ -4905,7 +4927,11 @@ def migrate_check_cmd(
     if format == "text":
         output = report.to_text(min_severity=min_severity)
     else:
-        output = _serialize_dict(report.to_dict(), "json")
+        # --compact projects the SAME report into a bounded, decision-grade view
+        # (output-shaping only). Default (full) output is unchanged — it is the
+        # baseline-oracle form and must stay byte-identical.
+        payload = report.to_compact_dict() if compact else report.to_dict()
+        output = _serialize_dict(payload, "json")
 
     _total = report.summary.get("total_findings", 0)
     _emit_command_output(

sourcecode/migrate_check.py

@@ -1308,6 +1308,33 @@ def _dimension_score(
     return max(0, 100 - deduction)
 
 
+# --- Compact projection (output-shaping only) --------------------------------
+# `--compact` renders a bounded, decision-grade view of the SAME report: it caps
+# each large leaf collection to its top-N items and reports total/omitted counts.
+# It performs NO new analysis — it is a pure projection over the dict `to_dict()`
+# already produces (Semantic IR / ContextGraph / semantic engines untouched).
+# The default (full) output is unchanged and remains the baseline-oracle form.
+# FUTURE (not this increment): invert the default — emit compact by default and
+# add `--full` for the complete report — once the oracle baseline is recaptured.
+_COMPACT_TOP_N = 5
+
+
+def _cap_collection(items: list, top_n: int, key=None) -> dict:
+    """Project a list into a bounded `{total, shown, omitted, items}` view. Items
+    are optionally reordered by `key` (stable) so the retained slice is the most
+    important; ordering falls back to the engine's own emission order. No values
+    are recomputed — only selected and counted."""
+    total = len(items)
+    ordered = sorted(items, key=key) if key is not None else items
+    shown = ordered[:top_n]
+    return {
+        "total": total,
+        "shown": len(shown),
+        "omitted": max(0, total - len(shown)),
+        "items": shown,
+    }
+
+
 @dataclass
 class MigrationReport:
     schema_version: str = "1.4"
@@ -1679,6 +1706,43 @@ class MigrationReport:
             "metadata": self.metadata,
         }
 
+    def to_compact_dict(self, top_n: int = _COMPACT_TOP_N) -> dict:
+        """Bounded, decision-grade projection of `to_dict()`.
+
+        Keeps every decision field verbatim (readiness_score, per-dimension
+        readiness, headline_blocker, blocking_count, estimated_effort_days,
+        effort_breakdown, summary, Hibernate classification, aggregate counts) and
+        caps only the large leaf collections — top-level `findings` and the
+        Hibernate `rewrite_targets` / `findings` / `critical_call_chains` /
+        `golden_sql_hotspots` — to their top-`top_n` items, each wrapped as
+        `{total, shown, omitted, items}`. It reuses the already-computed
+        `to_dict()` output and recomputes nothing (output-shaping only)."""
+        full = self.to_dict()
+        compact = dict(full)
+        compact["mode"] = "compact"
+        compact["compact_note"] = (
+            f"Bounded decision summary: large collections are capped to the top {top_n} "
+            "items (see each collection's total/omitted). Run without --compact (JSON "
+            "default) for the complete report. A future release will invert this — "
+            "compact by default with --full for the full detail."
+        )
+        # Top-level findings: retain the most severe first, then engine order.
+        compact["findings"] = _cap_collection(
+            full["findings"], top_n,
+            key=lambda f: SEVERITY_ORDER.get(f.get("severity"), 3),
+        )
+        hib = full.get("hibernate")
+        if isinstance(hib, dict):
+            h = dict(hib)
+            for _col in (
+                "rewrite_targets", "findings",
+                "critical_call_chains", "golden_sql_hotspots",
+            ):
+                if isinstance(h.get(_col), list):
+                    h[_col] = _cap_collection(h[_col], top_n)
+            compact["hibernate"] = h
+        return compact
+
     def to_text(self, min_severity: str = "low") -> str:
         min_order = SEVERITY_ORDER.get(min_severity, 3)
         visible = [f for f in self.findings if SEVERITY_ORDER.get(f.severity, 3) <= min_order]