scip-cli 2.2.0__tar.gz → 2.2.1__tar.gz

{scip_cli-2.2.0 → scip_cli-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scip-cli
-Version: 2.2.0
+Version: 2.2.1
 Summary: Fast code intelligence via SCIP indexes
 Project-URL: Homepage, https://github.com/flesler/scip-cli
 Author: Ariel Flesler
@@ -255,7 +255,7 @@ Use `--priority high` for a quick gate; `--priority high,medium` adds context. F
 | **Cycles** | Import/mention cycles between production files — break the edge or extract shared code |
 | **Unreferenced** | No usage in the index at all — delete |
 | **Dead exports** | No external refs — delete or `_` prefix |
-| **Stale types** | Classes/types with ≤1 external consumer — merge, inline, or document why they stay |
+| **Stale types** | Classes/types with no external consumer in the index — verify in-file or type-only use before removing |
 | **Same-file only** | Used only inside defining file — rename to `_` |
 | **Test-only consumers** | Cross-file refs are all from tests — promote to e2e or accept as internal |
 

{scip_cli-2.2.0 → scip_cli-2.2.1}/README.md

@@ -235,7 +235,7 @@ Use `--priority high` for a quick gate; `--priority high,medium` adds context. F
 | **Cycles** | Import/mention cycles between production files — break the edge or extract shared code |
 | **Unreferenced** | No usage in the index at all — delete |
 | **Dead exports** | No external refs — delete or `_` prefix |
-| **Stale types** | Classes/types with ≤1 external consumer — merge, inline, or document why they stay |
+| **Stale types** | Classes/types with no external consumer in the index — verify in-file or type-only use before removing |
 | **Same-file only** | Used only inside defining file — rename to `_` |
 | **Test-only consumers** | Cross-file refs are all from tests — promote to e2e or accept as internal |
 

{scip_cli-2.2.0 → scip_cli-2.2.1}/scip_cli/SKILL.md

@@ -128,10 +128,12 @@ analyze [--limit N] [--path PATH] [--include-tests] [target]
 
 Sections are ordered **high → medium → low**. `[high]` cycles, unreferenced, dead exports, stale types; `[medium]` same-file-only, change surface (file); `[low]` test-only consumers (noisy on Python), coupling, bottlenecks, hotspots.
 
+`--limit` caps **result rows across the whole run** (default 20); remaining checks are skipped once the cap is reached. `(none)` sections and section headers do not count.
+
 `--priority high` or `--priority high,medium` (also `1`/`2`/`3`) skips lower tiers.
 
 Directory detection uses the filesystem when present, otherwise an indexed path prefix. `--path` narrows ambiguous file/symbol resolution only (not directory scope — pass the dir as `target`).
 
 **Dogfood loop:** `reindex` → `analyze --limit 25` → `analyze scip_cli` or `analyze scip_cli/queries.py` on suspects. Skips test paths in project-wide and directory runs (`tests/`, `*.test.*`, `*.spec.*`); `--include-tests` to include them. File-target analyze always includes that file.
 
-**Easy pickings:** **Cycles** and **dead exports** (production paths) — cross-file cleanup. **Stale types** — low-use classes. Ignore `analyze/*` section helpers in dead exports. “Dead” = no refs from *other* files in the index, not `vulture`.
+**Easy pickings:** **Cycles** and **dead exports** (production paths) — cross-file cleanup. **Stale types** — types with no external refs in the index. Ignore `analyze/*` section helpers in dead exports. “Dead” = no refs from *other* files in the index, not `vulture`.

{scip_cli-2.2.0 → scip_cli-2.2.1}/scip_cli/__init__.py

@@ -1,3 +1,3 @@
 """scip-cli: Fast code intelligence via SCIP indexes."""
 
-__version__ = "2.2.0"
+__version__ = "2.2.1"

{scip_cli-2.2.0 → scip_cli-2.2.1}/scip_cli/__main__.py

@@ -115,7 +115,7 @@ def main():
         help="Omit for project-wide; directory for scoped project + per-file; file or symbol for focused checks",
     )
     add_path_argument(analyze_parser)
-    add_limit_argument(analyze_parser, default=20, help_suffix="rows per section")
+    add_limit_argument(analyze_parser, default=20, help_suffix="result rows total")
     analyze_parser.add_argument(
         "--include-tests",
         action="store_true",

{scip_cli-2.2.0 → scip_cli-2.2.1}/scip_cli/analyze/common.py

@@ -127,7 +127,7 @@ def cycle_path_noise(cycle_line: str, *, include_tests: bool = False) -> bool:
     return any(is_test_path(part.strip()) for part in parts if part.strip())
 
 
-def section(title: str, lines: list[str]) -> tuple[str, list[str]]:
+def section(title: str, lines: list[str], *, preface: str | None = None) -> tuple[str, list[str], str | None]:
     if not lines:
-        return title, ["(none)"]
-    return title, lines
+        return title, ["(none)"], None
+    return title, lines, preface

{scip_cli-2.2.0 → scip_cli-2.2.1}/scip_cli/analyze/file.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from .common import DEFAULT_LIMIT, SYM_DEF_JOIN, analyze_noise, fetch_all, short_name
-from .live import LiveIndex
+from .live import LiveIndex, file_has_scip_importers, has_same_file_reference_usage
 from .sections import Check, Priority, run_checks
 from .symbol import symbol_pressure
 
@@ -121,7 +121,7 @@ def same_file_only_in_file(db, relative_path: str, limit: int = DEFAULT_LIMIT) -
     rows = fetch_all(
         db,
         """
-        SELECT gs.symbol, der.start_line, der.end_line
+        SELECT gs.symbol, der.start_line, der.end_line, def_d.id
         FROM global_symbols gs
         JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
         JOIN documents def_d ON der.document_id = def_d.id
@@ -142,10 +142,12 @@ def same_file_only_in_file(db, relative_path: str, limit: int = DEFAULT_LIMIT) -
         (relative_path, limit),
     )
     lines = []
-    for symbol, start, end in rows:
+    for symbol, start, end, def_doc_id in rows:
         if analyze_noise(relative_path, symbol, include_tests=True):
             continue
-        if live.same_file_export_noise(symbol):
+        if live.same_file_export_noise(symbol, def_doc_id):
+            continue
+        if not file_has_scip_importers(db, relative_path, live=live, def_doc_id=def_doc_id):
             continue
         lines.append(f"{short_name(symbol)}  {start + 1}:{end + 1}")
     return lines
@@ -156,7 +158,7 @@ def dead_in_file(db, relative_path: str, limit: int = DEFAULT_LIMIT) -> list[str
     rows = fetch_all(
         db,
         """
-        SELECT gs.symbol, der.start_line, der.end_line, def_d.id
+        SELECT gs.id, gs.symbol, der.start_line, der.end_line, def_d.id
         FROM global_symbols gs
         JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
         JOIN documents def_d ON der.document_id = def_d.id
@@ -175,9 +177,11 @@ def dead_in_file(db, relative_path: str, limit: int = DEFAULT_LIMIT) -> list[str
         (relative_path, limit),
     )
     lines = []
-    for symbol, start, end, def_doc_id in rows:
+    for sym_id, symbol, start, end, def_doc_id in rows:
         if analyze_noise(relative_path, symbol, include_tests=True):
             continue
+        if has_same_file_reference_usage(db, sym_id, def_doc_id):
+            continue
         if live.dead_export_noise(symbol, def_doc_id):
             continue
         lines.append(f"{short_name(symbol)}  {start + 1}:{end + 1}")
@@ -263,19 +267,6 @@ def count_file_importers(db, relative_path: str) -> int:
     return len(get_importer_paths(db, symbol_ids, relative_path))
 
 
-def dead_export_rdeps_warning(db, relative_path: str, *, limit: int = DEFAULT_LIMIT) -> str | None:
-    """Warn when dead/unreferenced exports coexist with file importers (SCIP symbol split)."""
-    if not dead_in_file(db, relative_path, limit=limit) and not unreferenced_in_file(db, relative_path, limit=limit):
-        return None
-    importer_count = count_file_importers(db, relative_path)
-    if importer_count == 0:
-        return None
-    return (
-        f"Warning: {relative_path} has {importer_count} importer(s) but lists dead/unreferenced exports — "
-        "default-export, lazy(), or object-alias false positives are likely; verify with rg or rdeps"
-    )
-
-
 def top_symbol_pressure(db, relative_path: str, limit: int = DEFAULT_LIMIT) -> list[str]:
     """Pressure metrics for the most-consumed exports in a file."""
     cap = min(5, limit)
@@ -357,8 +348,10 @@ def _run_file_checks(
     db,
     limit: int,
     priorities,
-) -> list[tuple[str, list[str]]]:
-    return run_checks(checks, db, limit, priorities)
+    *,
+    budget=None,
+) -> list[tuple[str, list[str], str | None]]:
+    return run_checks(checks, db, limit, priorities, budget=budget)
 
 
 def run_all(
@@ -366,12 +359,14 @@ def run_all(
     relative_path: str,
     limit: int = DEFAULT_LIMIT,
     priorities=None,
-) -> list[tuple[str, list[str]]]:
+    budget=None,
+) -> list[tuple[str, list[str], str | None]]:
     return _run_file_checks(
         _file_checks(relative_path, include_top_symbols=True),
         db,
         limit,
         priorities,
+        budget=budget,
     )
 
 
@@ -380,11 +375,13 @@ def run_all_sections_only(
     relative_path: str,
     limit: int = DEFAULT_LIMIT,
     priorities=None,
-) -> list[tuple[str, list[str]]]:
+    budget=None,
+) -> list[tuple[str, list[str], str | None]]:
     """Per-file sections without top-symbols (directory batch)."""
     return _run_file_checks(
         _file_checks(relative_path, include_top_symbols=False),
         db,
         limit,
         priorities,
+        budget=budget,
     )

{scip_cli-2.2.0 → scip_cli-2.2.1}/scip_cli/analyze/live.py

@@ -64,24 +64,25 @@ class LiveIndex:
     def __init__(self, db) -> None:
         self.live_module_docs: set[int] = set()
         self.live_alias_bases: set[str] = set()
+        self.module_importers: dict[int, int] = {}
         self._build(db)
 
     def _build(self, db) -> None:
-        for (doc_id,) in _fetch_all(
+        for doc_id, importer_count in _fetch_all(
             db,
             """
-            SELECT DISTINCT der.document_id
+            SELECT der.document_id, COUNT(DISTINCT c.document_id)
             FROM global_symbols gs
             JOIN defn_enclosing_ranges der ON der.symbol_id = gs.id
+            JOIN mentions m ON m.symbol_id = gs.id AND m.role != 1
+            JOIN chunks c ON m.chunk_id = c.id
             WHERE gs.symbol LIKE '%/' AND gs.symbol NOT LIKE '%().'
-              AND EXISTS (
-                SELECT 1 FROM mentions m
-                JOIN chunks c ON m.chunk_id = c.id
-                WHERE m.symbol_id = gs.id AND m.role != 1 AND c.document_id != der.document_id
-              )
+              AND c.document_id != der.document_id
+            GROUP BY der.document_id
             """,
         ):
             self.live_module_docs.add(doc_id)
+            self.module_importers[doc_id] = importer_count
 
         for sym_id, symbol in _fetch_all(
             db,
@@ -99,20 +100,35 @@ class LiveIndex:
             if _fetch_one(db, _EXTERNAL_MENTION, (sym_id, def_doc)):
                 self.live_alias_bases.add(base)
 
-    def dead_export_noise(self, symbol: str, def_doc_id: int) -> bool:
+    def possibly_live_label(self, symbol: str, def_doc_id: int) -> str | None:
+        """Proof of liveness via module or export alias (used to suppress false dead-export hits)."""
         if is_module_symbol(symbol):
-            return True
+            if def_doc_id not in self.live_module_docs:
+                return None
+            count = self.module_importers.get(def_doc_id, 0)
+            return f"module_import:{count}"
         base = export_value_base(symbol)
-        if base and base in self.live_alias_bases:
-            return True
-        return bool(base and def_doc_id in self.live_module_docs)
+        if not base:
+            return None
+        if base in self.live_alias_bases:
+            return "export_alias"
+        if def_doc_id in self.live_module_docs:
+            count = self.module_importers.get(def_doc_id, 0)
+            return f"default_export:{count}"
+        return None
 
-    def same_file_export_noise(self, symbol: str) -> bool:
+    def dead_export_noise(self, symbol: str, def_doc_id: int) -> bool:
+        """Suppress from dead_exports when live via module or export alias."""
+        return self.possibly_live_label(symbol, def_doc_id) is not None or is_module_symbol(symbol)
+
+    def same_file_export_noise(self, symbol: str, def_doc_id: int | None = None) -> bool:
         """Export used only in-file but live via module or export alias elsewhere."""
         base = export_value_base(symbol)
         if not base:
             return False
-        return base in self.live_alias_bases
+        if base in self.live_alias_bases:
+            return True
+        return def_doc_id is not None and def_doc_id in self.live_module_docs
 
     def stale_type_live_noise(self, symbol: str, def_doc_id: int) -> bool:
         """Class/type looks unused but file is live via default export or module import."""
@@ -125,7 +141,7 @@ class LiveIndex:
 
 
 def has_same_file_reference_usage(db, symbol_id: int, def_doc_id: int) -> bool:
-    """Type or value referenced in the same file (extends, signatures, object literal)."""
+    """Type or value referenced in the same file (extends, signatures, handler registration)."""
     row = _fetch_one(
         db,
         """
@@ -137,3 +153,16 @@ def has_same_file_reference_usage(db, symbol_id: int, def_doc_id: int) -> bool:
         (symbol_id, def_doc_id),
     )
     return row is not None
+
+
+def file_has_scip_importers(db, relative_path: str, *, live: LiveIndex, def_doc_id: int) -> bool:
+    """True when the index shows another file importing this module or its symbols."""
+    if def_doc_id in live.live_module_docs:
+        return True
+    from ..queries import get_file_symbols, get_importer_paths
+
+    symbols = get_file_symbols(db, relative_path)
+    if not symbols:
+        return False
+    symbol_ids = [row[0] for row in symbols]
+    return bool(get_importer_paths(db, symbol_ids, relative_path))

{scip_cli-2.2.0 → scip_cli-2.2.1}/scip_cli/analyze/project.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import re
 
 from ..paths import path_filter_sql, path_filter_sql_any, path_in_scope
+from ..symbols import is_module_symbol
 from .common import (
     DEFAULT_LIMIT,
     SYM_DEF_JOIN,
@@ -17,7 +18,7 @@ from .common import (
     stale_type_noise,
 )
 from .graph import FILE_EDGES_SQL, fetch_file_edges, find_longer_cycles
-from .live import LiveIndex, has_same_file_reference_usage
+from .live import LiveIndex, file_has_scip_importers, has_same_file_reference_usage
 from .sections import Check, Priority, run_checks
 
 
@@ -80,7 +81,7 @@ def bottlenecks(
     lines = [
         f"{short_name(symbol)}  score={score}  loc={loc}  fan_in={fan_in}  fan_out={fan_out}  ({path})"
         for symbol, path, fan_in, fan_out, loc, score in rows
-        if not analyze_noise(path, symbol, include_tests=include_tests)
+        if not analyze_noise(path, symbol, include_tests=include_tests) and not is_module_symbol(symbol)
     ]
     return lines[:limit]
 
@@ -114,7 +115,7 @@ def hotspots(
     lines = [
         f"{short_name(symbol)}  refs={ref_count}  files={file_count}  ({path})"
         for symbol, path, ref_count, file_count in rows
-        if not analyze_noise(path, symbol, include_tests=include_tests)
+        if not analyze_noise(path, symbol, include_tests=include_tests) and not is_module_symbol(symbol)
     ]
     return lines[:limit]
 
@@ -159,9 +160,11 @@ def _format_dead_export_rows(
     limit: int,
 ) -> list[str]:
     lines = []
-    for symbol, path, loc, def_doc_id in rows:
+    for symbol_id, symbol, path, loc, def_doc_id in rows:
         if analyze_noise(path, symbol, include_tests=include_tests):
             continue
+        if has_same_file_reference_usage(db, symbol_id, def_doc_id):
+            continue
         if live.dead_export_noise(symbol, def_doc_id):
             continue
         lines.append(f"{short_name(symbol)}  loc={loc}  ({path})")
@@ -192,7 +195,7 @@ def stale_types(
           AND gs.symbol NOT LIKE '%().'
           AND gs.symbol NOT LIKE '%#typeLiteral%'{scope_clause}
         GROUP BY gs.id
-        HAVING consumers <= 1
+        HAVING consumers = 0
         ORDER BY consumers ASC, def_d.relative_path
         LIMIT ?
         """,
@@ -226,7 +229,7 @@ def unreferenced_symbols(
     rows = fetch_all(
         db,
         f"""
-        SELECT gs.symbol, def_d.relative_path,
+        SELECT gs.id, gs.symbol, def_d.relative_path,
                sym_def.end_line - sym_def.start_line + 1 AS loc,
                def_d.id
         FROM global_symbols gs
@@ -261,7 +264,8 @@ def same_file_only(
         db,
         f"""
         SELECT gs.symbol, def_d.relative_path,
-               sym_def.end_line - sym_def.start_line + 1 AS loc
+               sym_def.end_line - sym_def.start_line + 1 AS loc,
+               def_d.id
         FROM global_symbols gs
         {SYM_DEF_JOIN}
         WHERE EXISTS (
@@ -280,10 +284,12 @@ def same_file_only(
         (*scope_params, limit * 5),
     )
     lines = []
-    for symbol, path, loc in rows:
+    for symbol, path, loc, def_doc_id in rows:
         if analyze_noise(path, symbol, include_tests=include_tests):
             continue
-        if live.same_file_export_noise(symbol):
+        if live.same_file_export_noise(symbol, def_doc_id):
+            continue
+        if not file_has_scip_importers(db, path, live=live, def_doc_id=def_doc_id):
             continue
         lines.append(f"{short_name(symbol)}  loc={loc}  ({path})")
         if len(lines) >= limit:
@@ -345,7 +351,7 @@ def dead_exports(
     rows = fetch_all(
         db,
         f"""
-        SELECT gs.symbol, def_d.relative_path,
+        SELECT gs.id, gs.symbol, def_d.relative_path,
                sym_def.end_line - sym_def.start_line + 1 AS loc,
                def_d.id
         FROM global_symbols gs
@@ -366,49 +372,6 @@ def dead_exports(
     return _format_dead_export_rows(db, rows, LiveIndex(db), include_tests=include_tests, limit=limit)
 
 
-def possibly_unused_exports(
-    db,
-    limit: int = DEFAULT_LIMIT,
-    *,
-    include_tests: bool = False,
-    scope: str | None = None,
-) -> list[str]:
-    """Exports with no direct external refs but live via module import or export alias."""
-    scope_clause, scope_params = path_filter_sql(db, scope, doc_alias="def_d")
-    live = LiveIndex(db)
-    rows = fetch_all(
-        db,
-        f"""
-        SELECT gs.symbol, def_d.relative_path,
-               sym_def.end_line - sym_def.start_line + 1 AS loc,
-               def_d.id
-        FROM global_symbols gs
-        {SYM_DEF_JOIN}
-        WHERE NOT EXISTS (
-            SELECT 1
-            FROM mentions m
-            JOIN chunks c ON m.chunk_id = c.id
-            WHERE m.symbol_id = gs.id
-              AND m.role != 1
-              AND c.document_id != def_d.id
-        ){scope_clause}
-        ORDER BY loc DESC, def_d.relative_path
-        LIMIT ?
-        """,
-        (*scope_params, limit * 5),
-    )
-    lines = []
-    for symbol, path, loc, def_doc_id in rows:
-        if analyze_noise(path, symbol, include_tests=include_tests):
-            continue
-        if not live.dead_export_noise(symbol, def_doc_id):
-            continue
-        lines.append(f"{short_name(symbol)}  loc={loc}  (live via module/alias)  ({path})")
-        if len(lines) >= limit:
-            break
-    return lines
-
-
 def top_coupling(
     db,
     limit: int = DEFAULT_LIMIT,
@@ -450,21 +413,21 @@ def run_all(
     include_tests: bool = False,
     scope: str | None = None,
     priorities=None,
-) -> list[tuple[str, list[str]]]:
+    budget=None,
+) -> list[tuple[str, list[str], str | None]]:
     suffix = _scope_suffix(scope)
-    opts = {"include_tests": include_tests, "scope": scope}
+    opts = {"include_tests": include_tests, "scope": scope, "budget": budget}
     checks = [
         Check("cycles", Priority.HIGH, f"Cycles (file dependencies){suffix}", cycles),
         Check("unreferenced", Priority.HIGH, f"Unreferenced symbols (no refs){suffix}", unreferenced_symbols),
-        Check("dead_exports", Priority.HIGH, f"Dead exports (no external refs){suffix}", dead_exports),
         Check(
-            "possibly_unused",
-            Priority.MEDIUM,
-            f"Possibly unused exports (live via module/alias){suffix}",
-            possibly_unused_exports,
+            "dead_exports",
+            Priority.HIGH,
+            f"Dead exports (no in-file or external use){suffix}",
+            dead_exports,
         ),
-        Check("stale_types", Priority.HIGH, f"Stale types (≤1 external consumer){suffix}", stale_types),
-        Check("same_file_only", Priority.MEDIUM, f"Same-file only (consider _prefix){suffix}", same_file_only),
+        Check("stale_types", Priority.HIGH, f"Stale types (no external consumers){suffix}", stale_types),
+        Check("same_file_only", Priority.MEDIUM, f"Same-file only (in-file use, not exported){suffix}", same_file_only),
         Check(
             "test_only",
             Priority.LOW,

scip_cli-2.2.1/scip_cli/analyze/sections.py

@@ -0,0 +1,120 @@
+"""Priority ordering and filtering for analyze dashboards."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+from .common import section
+
+CheckFn = Callable[..., list[str]]
+
+
+class Priority(str, Enum):
+    HIGH = "high"
+    MEDIUM = "medium"
+    LOW = "low"
+
+
+_ORDER = (Priority.HIGH, Priority.MEDIUM, Priority.LOW)
+_ALIASES = {
+    "1": Priority.HIGH,
+    "2": Priority.MEDIUM,
+    "3": Priority.LOW,
+    "h": Priority.HIGH,
+    "m": Priority.MEDIUM,
+    "l": Priority.LOW,
+}
+
+
+def parse_priorities(value: str | None) -> set[Priority] | None:
+    """Parse --priority (comma-separated names or 1/2/3). None means all levels."""
+    if not value:
+        return None
+    out: set[Priority] = set()
+    for part in value.replace(" ", "").split(","):
+        if not part:
+            continue
+        key = part.lower()
+        if key in _ALIASES:
+            out.add(_ALIASES[key])
+            continue
+        try:
+            out.add(Priority(key))
+        except ValueError as exc:
+            allowed = ", ".join(p.value for p in Priority)
+            raise RuntimeError(f"unknown analyze priority {part!r} (use {allowed} or 1/2/3)") from exc
+    return out
+
+
+@dataclass(frozen=True)
+class Check:
+    key: str
+    priority: Priority
+    title: str
+    run: CheckFn
+    false_positive_preface: str | None = None
+
+    def labeled_title(self) -> str:
+        return f"[{self.priority.value}] {self.title}"
+
+
+# Shown only when the section has hits (not "(none)").
+FALSE_POSITIVE_PREFACES: dict[str, str] = {
+    "dead_exports": (
+        "SCIP may miss dynamic loading (loadFiles, GraphQL) and default-export object members "
+        "— verify with rdeps/rg before deleting."
+    ),
+    "unreferenced": (
+        "No mentions in the index — symbols may still run via dynamic import or side-effect registration."
+    ),
+    "same_file_only": ("Referenced only in the defining file — often handlers or private helpers, not dead exports."),
+    "stale_types": ("No cross-file refs in the index — may still be used in-file or as a type-only shape."),
+    "cycles": "Remaining cycles may be barrel re-exports; confirm before refactoring.",
+    "dead_in_file": (
+        "SCIP may miss dynamic loading and default-export indirection — verify with rdeps/rg before deleting."
+    ),
+    "unreferenced_in_file": (
+        "No mentions in the index — may still be used in-file via handlers or dynamic registration."
+    ),
+}
+
+
+def _preface_for(key: str) -> str | None:
+    return FALSE_POSITIVE_PREFACES.get(key)
+
+
+@dataclass
+class RowBudget:
+    """Shared cap on result rows across analyze sections."""
+
+    remaining: int
+
+    def exhausted(self) -> bool:
+        return self.remaining <= 0
+
+
+def run_checks(
+    checks: list[Check],
+    db,
+    limit: int,
+    priorities: set[Priority] | None,
+    **kwargs: Any,
+) -> list[tuple[str, list[str], str | None]]:
+    """Run checks in priority order (high → low), optionally filtered."""
+    selected = [check for check in checks if priorities is None or check.priority in priorities]
+    selected.sort(key=lambda check: (_ORDER.index(check.priority), check.key))
+    budget: RowBudget = kwargs.pop("budget", None) or RowBudget(remaining=limit)
+    sections: list[tuple[str, list[str], str | None]] = []
+    for check in selected:
+        if budget.exhausted():
+            break
+        lines = check.run(db, budget.remaining, **kwargs)
+        if lines != ["(none)"]:
+            lines = lines[: budget.remaining]
+            budget.remaining -= len(lines)
+        preface = check.false_positive_preface if check.false_positive_preface else _preface_for(check.key)
+        sections.append(section(check.labeled_title(), lines, preface=preface))
+    return sections

{scip_cli-2.2.0 → scip_cli-2.2.1}/scip_cli/analyze/symbol.py

@@ -168,7 +168,8 @@ def run_all(
     symbol_id: int,
     limit: int = DEFAULT_LIMIT,
     priorities=None,
-) -> list[tuple[str, list[str]]]:
+    budget=None,
+) -> list[tuple[str, list[str], str | None]]:
     checks = [
         Check("consumer_files", Priority.HIGH, "Consumer files (direct)", _bind_symbol(consumer_files, symbol_id)),
         Check("dependencies", Priority.HIGH, "Dependencies (cross-file)", _bind_symbol(dependencies, symbol_id)),
@@ -181,4 +182,4 @@ def run_all(
         ),
         Check("def_context", Priority.LOW, "Definition context", _bind_symbol0(def_context, symbol_id)),
     ]
-    return run_checks(checks, db, limit, priorities)
+    return run_checks(checks, db, limit, priorities, budget=budget)