skilltotal 0.76.0__tar.gz → 0.78.0__tar.gz

{skilltotal-0.76.0/skilltotal.egg-info → skilltotal-0.78.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skilltotal
-Version: 0.76.0
+Version: 0.78.0
 Summary: Static security scanner for npm and PyPI packages, MCP servers and agent skills. Runs locally, never runs the code, no LLM.
 Author: SkillTotal
 License-Expression: Apache-2.0
@@ -102,7 +102,7 @@ skilltotal scan npm:express     # or pypi:name, a git URL, a folder, an archive
 ([full example with permissions](https://github.com/pezhik/skilltotal/blob/main/docs/ci.md)):
 
 ```yaml
-      - uses: pezhik/skilltotal@v0.76.0
+      - uses: pezhik/skilltotal@v0.78.0
         with: { source: ., fail-on: high }
 ```
 
@@ -241,7 +241,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-      - uses: pezhik/skilltotal@v0.76.0
+      - uses: pezhik/skilltotal@v0.78.0
         with:
           source: .             # a path, a git URL, or an npm:/pypi:<name> spec
           fail-on: high         # fail on a high/critical risk finding (or 'none')
@@ -259,7 +259,7 @@ out on an existing repository. Anywhere else Python 3.10+ runs, install a pinned
 on the exit code (0 passed, 2 a gate tripped, 1 the scan could not run):
 
 ```bash
-pip install skilltotal==0.76.0      # in a virtual environment outside the checkout
+pip install skilltotal==0.78.0      # in a virtual environment outside the checkout
 skilltotal scan . --fail-on high
 ```
 
@@ -317,7 +317,7 @@ With npx (it needs uv, pipx, or Python 3.11+ with `skilltotal` installed), name
 `--package` so npx does not run a `skilltotal` from the scanned repository's `node_modules/.bin`:
 
 ```bash
-npx -y --package=skilltotal@0.76.0 -- skilltotal scan https://github.com/owner/repo
+npx -y --package=skilltotal@0.78.0 -- skilltotal scan https://github.com/owner/repo
 ```
 
 ## Measured, not asserted
@@ -326,6 +326,8 @@ npx -y --package=skilltotal@0.76.0 -- skilltotal scan https://github.com/owner/r
   recall and precision on a labeled corpus we built and publish (130 malicious and
   94 benign samples), regenerated every release and enforced by CI as a floor. A perfect score on
   our own corpus guards against regressions; it is not a claim about every attack in the wild.
+  Each rule behind the survey's OWASP class counts also has labeled samples of its own, listed in
+  the report's rule coverage table.
 - **[The MCP registry, scanned](https://github.com/pezhik/skilltotal/blob/main/docs/mcp-registry-survey.md)**
   (September 2026, engine 0.49.0, rulesets 56 to 59; later rule changes are not reflected): 15,341
   of the 17,535 distinct components in the official registry (87.5%). Of those scanned, 88.2%

{skilltotal-0.76.0 → skilltotal-0.78.0}/README.md

@@ -61,7 +61,7 @@ skilltotal scan npm:express     # or pypi:name, a git URL, a folder, an archive
 ([full example with permissions](https://github.com/pezhik/skilltotal/blob/main/docs/ci.md)):
 
 ```yaml
-      - uses: pezhik/skilltotal@v0.76.0
+      - uses: pezhik/skilltotal@v0.78.0
         with: { source: ., fail-on: high }
 ```
 
@@ -200,7 +200,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-      - uses: pezhik/skilltotal@v0.76.0
+      - uses: pezhik/skilltotal@v0.78.0
         with:
           source: .             # a path, a git URL, or an npm:/pypi:<name> spec
           fail-on: high         # fail on a high/critical risk finding (or 'none')
@@ -218,7 +218,7 @@ out on an existing repository. Anywhere else Python 3.10+ runs, install a pinned
 on the exit code (0 passed, 2 a gate tripped, 1 the scan could not run):
 
 ```bash
-pip install skilltotal==0.76.0      # in a virtual environment outside the checkout
+pip install skilltotal==0.78.0      # in a virtual environment outside the checkout
 skilltotal scan . --fail-on high
 ```
 
@@ -276,7 +276,7 @@ With npx (it needs uv, pipx, or Python 3.11+ with `skilltotal` installed), name
 `--package` so npx does not run a `skilltotal` from the scanned repository's `node_modules/.bin`:
 
 ```bash
-npx -y --package=skilltotal@0.76.0 -- skilltotal scan https://github.com/owner/repo
+npx -y --package=skilltotal@0.78.0 -- skilltotal scan https://github.com/owner/repo
 ```
 
 ## Measured, not asserted
@@ -285,6 +285,8 @@ npx -y --package=skilltotal@0.76.0 -- skilltotal scan https://github.com/owner/r
   recall and precision on a labeled corpus we built and publish (130 malicious and
   94 benign samples), regenerated every release and enforced by CI as a floor. A perfect score on
   our own corpus guards against regressions; it is not a claim about every attack in the wild.
+  Each rule behind the survey's OWASP class counts also has labeled samples of its own, listed in
+  the report's rule coverage table.
 - **[The MCP registry, scanned](https://github.com/pezhik/skilltotal/blob/main/docs/mcp-registry-survey.md)**
   (September 2026, engine 0.49.0, rulesets 56 to 59; later rule changes are not reflected): 15,341
   of the 17,535 distinct components in the official registry (87.5%). Of those scanned, 88.2%

{skilltotal-0.76.0 → skilltotal-0.78.0}/skilltotal/__init__.py

@@ -22,10 +22,10 @@ from skilltotal.models import (
 # REPORT_SCHEMA_VERSION: shape of Report.to_dict(); bumps only on schema changes.
 # RULESET_VERSION: integer counter of the detection ruleset; bumps when rules change, so a
 #   consumer knows when re-scanning old reports may surface new findings.
-__version__ = "0.76.0"
+__version__ = "0.78.0"
 ENGINE_VERSION = __version__
 REPORT_SCHEMA_VERSION = "1.9"
-RULESET_VERSION = 78
+RULESET_VERSION = 79
 
 __all__ = [
     "__version__",

{skilltotal-0.76.0 → skilltotal-0.78.0}/skilltotal/agent_hook.py

@@ -193,8 +193,10 @@ _INSTALL_WORDS = re.compile(
     r"(?<![\w.-])(?:install|isntall|i|in|it|add|create|init|innit|exec|x|dlx|tool|run)(?![\w.-]))",
     re.IGNORECASE,
 )
-# A word the shell fills in when it runs: a variable, a substitution, a brace expansion.
-_COMPUTED = re.compile(r"[$`{}]")
+# A word the shell fills in when it runs: a variable, a substitution, a brace expansion, or cmd's
+# `%NAME%` / delayed `!NAME!` (`set V=install & npm %V% x` installs x: read as a plain word, `%V%`
+# was no subcommand the hook knew, and the line went through unasked).
+_COMPUTED = re.compile(r"[$`{}]|%[A-Za-z_][^%\s]*%|![A-Za-z_][^!\s]*!")
 
 
 def _globbed(word: str) -> bool:
@@ -3914,6 +3916,8 @@ def _uv(rest: list[str], shell: str, depth: int, level: _Level) -> list[Install]
         return [] if _help(args, _PY_HELP) else _lockfile("pyproject.toml")
     if sub == "pip":
         sub2, args2 = _subcommand(args, _PIP_VALUE_FLAGS | _UV_VALUE_FLAGS)
+        if _filled_in(sub2 or ""):
+            return [_NOT_READ]  # `uv pip $V x`: filled in when the line runs
         if sub2 == "sync":  # `uv pip sync requirements.txt`
             if _help(args2, _PY_HELP):
                 return []
@@ -3922,6 +3926,8 @@ def _uv(rest: list[str], shell: str, depth: int, level: _Level) -> list[Install]
         return _pip_install(args2, "uv", index) if sub2 == "install" else []
     if sub == "tool":
         sub2, args2 = _subcommand(args, _UV_VALUE_FLAGS)
+        if _filled_in(sub2 or ""):
+            return [_NOT_READ]
         if sub2 == "install":
             return _first_py(args2, index) + _with_values(args2, index)
         if sub2 == "run":

{skilltotal-0.76.0 → skilltotal-0.78.0}/skilltotal/autorun.py

@@ -78,6 +78,8 @@ _MCP_MANIFEST_NAMES = frozenset(
 # Bundles Claude Code unpacks and runs: their code is not in the files this scan reads.
 _BUNDLE_SUFFIXES = (".mcpb", ".dxt")
 MCP_BUNDLE_NOT_ANALYZED = "MCP server bundle not analyzed"
+# A skill's or subagent's frontmatter longer than this reader goes (_MAX_FRONTMATTER_LINES).
+FRONTMATTER_PARTLY_READ = "Frontmatter partly analyzed"
 
 
 @dataclass(frozen=True)
@@ -219,6 +221,9 @@ class _Collector:
             or lower.endswith((_VSCODE_TASKS, _VSCODE_SETTINGS))
             or name in ("mcp.json", "manifest.json")
             or '"mcpServers"' in text
+            # A key written with escapes (`"mcp\u0053ervers"`) is the same name to a JSON
+            # reader, so a file with any escape is parsed and its decoded keys decide.
+            or "\\u" in text
         )
         if not candidate:
             return
@@ -453,7 +458,7 @@ class _Collector:
         ref_data = self._load(ref) if ref is not None else None
         if not isinstance(ref_data, dict) or ref is None:
             return
-        if '"mcpServers"' in ref.text:
+        if isinstance(ref_data.get("mcpServers"), dict):
             return  # read on its own like any file with an `mcpServers` map
         self._servers(ref, _Anchors(ref), ref_data, ORIGIN_PLUGIN, "referenced")
 
@@ -482,9 +487,22 @@ class _Collector:
 
     # -- Markdown frontmatter -----------------------------------------------------------------
     def frontmatter(self, f: IndexedFile, *, skill: bool) -> None:
-        block = _frontmatter_lines(f.text)
+        block, cut = _frontmatter_lines(f.text)
         if not block:
             return
+        if cut:
+            # The agent reads all of it: hooks or servers declared past the limit would run
+            # unchecked, so the report says the rest was not read.
+            self.reviews.append(NeedsReview(
+                category="coverage",
+                title=FRONTMATTER_PARTLY_READ,
+                reason=(
+                    f"The frontmatter is longer than {_MAX_FRONTMATTER_LINES} lines; hooks or MCP "
+                    "servers declared past that were not analyzed. Read the rest before using it."
+                ),
+                file=f.relpath,
+                line=f.line_of_offset(block[-1].start),
+            ))
         found = False
         for kind, origin, piece in _frontmatter_hooks(block):
             found = True
@@ -759,16 +777,17 @@ class _Line:
         return len(self.text) - len(self.text.lstrip(" \t"))
 
 
-def _frontmatter_lines(text: str) -> list[_Line]:
-    """The lines of a leading ``---`` YAML frontmatter block, with their file offsets."""
+def _frontmatter_lines(text: str) -> tuple[list[_Line], bool]:
+    """The lines of a leading ``---`` YAML frontmatter block, with their file offsets, and whether
+    the block goes on past ``_MAX_FRONTMATTER_LINES`` (the rest is not read)."""
     if not text.startswith("---"):
-        return []
+        return [], False
     first_nl = text.find("\n")
     if first_nl < 0:
-        return []
+        return [], False
     end = _FRONTMATTER_END.search(text, first_nl + 1)
     if end is None:
-        return []
+        return [], False
     lines: list[_Line] = []
     pos = first_nl + 1
     while pos < end.start() and len(lines) < _MAX_FRONTMATTER_LINES:
@@ -776,7 +795,7 @@ def _frontmatter_lines(text: str) -> list[_Line]:
         stop = end.start() if nl < 0 else nl
         lines.append(_Line(text[pos:stop].rstrip("\r"), pos))  # a CRLF file reads the same
         pos = stop + 1
-    return lines
+    return lines, pos < end.start()
 
 
 def _yaml_scalar(raw: str, offset: int) -> tuple[str, int, int]:

{skilltotal-0.76.0 → skilltotal-0.78.0}/skilltotal/cli.py

@@ -15,10 +15,12 @@ Commands:
         A config that was applied is named on the console. CLI flags override config. Inline
         `# skilltotal:ignore[ST-ID]` on a finding's line, or on the line above it, suppresses it
         when the source is a local directory (never in a fetched package or repository).
-    skilltotal diff <old> <new> [--json] [--output FILE] [--fail-on-new LEVEL] [--no-config]
+    skilltotal diff <old> <new> [--json] [--output FILE] [--fail-on-new LEVEL]
+                                [--fail-on-unanalyzed] [--no-config]
         compare two versions of a component: each side is any scannable source (as in
         `scan`) or a previously saved JSON report. Reports new/resolved findings,
-        evidence-level changes, and capability changes.
+        evidence-level changes, capability changes, and what only the new version's scan
+        could not analyze.
     skilltotal guard <source> [--block-on malicious|high|medium] [--json]
     skilltotal guard --installed [--project DIR] [--block-on ...] [--json]
         pre-install allow/block decision (exit 2 on block): malicious indicators always
@@ -254,6 +256,15 @@ def build_parser() -> argparse.ArgumentParser:
             "capabilities never do."
         ),
     )
+    diff.add_argument(
+        "--fail-on-unanalyzed",
+        action="store_true",
+        help=(
+            "Exit with code 2 if the new version has a file, or part of one, that could not be "
+            "analyzed and the old version did not: a finding that disappeared with it may only "
+            "be out of view."
+        ),
+    )
     diff.add_argument(
         "--exclude",
         metavar="GLOB",
@@ -691,7 +702,7 @@ def _cmd_scan(args: argparse.Namespace) -> int:
     try:
         config = _load_config(args)
     except ConfigError as exc:  # a gate that would silently be off
-        print(f"error: {exc}", file=sys.stderr)
+        print(f"error: {_diagnostic(str(exc))}", file=sys.stderr)
         return EXIT_ERROR
 
     # A report the scan cannot write is known before the scan, which can take minutes.
@@ -714,7 +725,8 @@ def _cmd_scan(args: argparse.Namespace) -> int:
         try:
             suppress = load_baseline(baseline_path)
         except (OSError, json.JSONDecodeError) as exc:
-            print(f"error: cannot read baseline {baseline_path}: {exc}", file=sys.stderr)
+            print(f"error: cannot read baseline {_one_line(str(baseline_path))}: "
+                  f"{_diagnostic(str(exc))}", file=sys.stderr)
             return EXIT_ERROR
 
     exclude = [*config.exclude, *args.exclude, *_own_report(args.source, args.output)]
@@ -739,17 +751,17 @@ def _cmd_scan(args: argparse.Namespace) -> int:
             )
             report.component.source = args.source  # not the snapshot's temporary path
     except StagedError as exc:
-        print(f"error: --staged: {exc}", file=sys.stderr)
+        print(f"error: --staged: {_diagnostic(str(exc))}", file=sys.stderr)
         return EXIT_ERROR
     except CollectionError as exc:
         from skilltotal.collector import failure_category
 
         # A repository that does not exist reads as git asking for a password.
         if failure_category(exc) == "repo-not-found":
-            print(f"error: {args.source}: the repository was not found, or it is private "
-                  "(a private repository needs git credentials)", file=sys.stderr)
+            print(f"error: {_one_line(args.source)}: the repository was not found, or it is "
+                  "private (a private repository needs git credentials)", file=sys.stderr)
         else:
-            print(f"error: {exc}", file=sys.stderr)
+            print(f"error: {_diagnostic(str(exc))}", file=sys.stderr)
         if _joined_by_trailing_backslash(args.source):
             print("hint: a trailing backslash before the closing quote joined your arguments; "
                   "drop the trailing \\ (write '.\\my folder', not '.\\my folder\\')",
@@ -784,7 +796,7 @@ def _cmd_scan(args: argparse.Namespace) -> int:
         try:
             signals = collect_provenance(args.source)
         except ProvenanceError as exc:
-            print(f"warning: {exc}", file=sys.stderr)
+            print(f"warning: {_diagnostic(str(exc))}", file=sys.stderr)
         else:
             report.needs_review.extend(signals)
             report.metadata["provenance_checked"] = True
@@ -927,7 +939,7 @@ def _cmd_diff(args: argparse.Namespace) -> int:
     try:
         config = _load_config(args)
     except ConfigError as exc:  # a gate that would silently be off
-        print(f"error: {exc}", file=sys.stderr)
+        print(f"error: {_diagnostic(str(exc))}", file=sys.stderr)
         return EXIT_ERROR
     exclude = [*config.exclude, *args.exclude]
     problem = _output_problem(args.output) if args.output else ""
@@ -937,18 +949,24 @@ def _cmd_diff(args: argparse.Namespace) -> int:
         return EXIT_ERROR
 
     try:
-        old_report = _resolve_diff_side(args.old, config, exclude)
-        new_report = _resolve_diff_side(args.new, config, exclude)
+        old_report, old_saved = _resolve_diff_side(args.old, config, exclude)
+        new_report, new_saved = _resolve_diff_side(args.new, config, exclude)
     except CollectionError as exc:
-        print(f"error: {exc}", file=sys.stderr)
+        print(f"error: {_diagnostic(str(exc))}", file=sys.stderr)
         return EXIT_ERROR
     except (OSError, json.JSONDecodeError) as exc:
-        print(f"error: cannot read report: {exc}", file=sys.stderr)
+        print(f"error: cannot read report: {_diagnostic(str(exc))}", file=sys.stderr)
         return EXIT_ERROR
 
     diff = diff_reports(old_report, new_report)
     if config.path is not None:
         print(f"config applied: {_one_line(config.describe())}", file=sys.stderr)
+    # A saved report is taken as it says: whoever wrote the file wrote its findings. The gate
+    # below compares what the file claims, so the log says that no scan stands behind it.
+    for side, source, saved in (("old", args.old, old_saved), ("new", args.new, new_saved)):
+        if saved:
+            print(f"diff: the {side} side ({_one_line(source)}) was read as a saved SkillTotal "
+                  "report, not scanned; its findings are taken as given", file=sys.stderr)
 
     if args.output:
         try:
@@ -969,8 +987,15 @@ def _cmd_diff(args: argparse.Namespace) -> int:
         if tripping:
             first = tripping[0]
             more = f" and {len(tripping) - 1} more" if len(tripping) > 1 else ""
-            print(f"gate: --fail-on-new {args.fail_on_new} tripped by {first['id']} "
-                  f"({first['severity']}){more}", file=sys.stderr)
+            print(f"gate: --fail-on-new {args.fail_on_new} tripped by {_one_line(first['id'])} "
+                  f"({_one_line(first['severity'])}){more}", file=sys.stderr)
+            return EXIT_FAIL_ON_HIGH
+    if diff.coverage_gaps_added:
+        titles = "; ".join(dict.fromkeys(_one_line(str(n.get("title", "")))
+                                         for n in diff.coverage_gaps_added))
+        print(f"Not analyzed in the new version only: {titles}.", file=sys.stderr)
+        if args.fail_on_unanalyzed:
+            print("gate: --fail-on-unanalyzed tripped", file=sys.stderr)
             return EXIT_FAIL_ON_HIGH
     return EXIT_OK
 
@@ -994,19 +1019,20 @@ def _new_risk(diff, level: str) -> list[dict]:
     return tripping
 
 
-def _resolve_diff_side(source: str, config: Config, exclude: list[str]) -> dict:
-    """Resolve one diff side: a saved JSON report is loaded, anything else is scanned."""
+def _resolve_diff_side(source: str, config: Config, exclude: list[str]) -> tuple[dict, bool]:
+    """Resolve one diff side: a saved JSON report is loaded, anything else is scanned. Returns
+    the report and whether it was a saved one."""
     from skilltotal.engine import analyze
 
     path = Path(source)
     if path.is_file() and path.suffix.lower() == ".json":
         data = json.loads(path.read_text(encoding="utf-8"))
         if isinstance(data, dict) and {"component", "risk_score", "findings"} <= data.keys():
-            return data
+            return data, True
         # A .json file that is not a saved report (e.g. a bare package.json) is scanned
         # like any other single-file source.
     report = analyze(source, ignore_rules=config.ignored_rules(), exclude=exclude)
-    return report.to_dict()
+    return report.to_dict(), False
 
 
 def _cmd_guard(args: argparse.Namespace) -> int:
@@ -1023,7 +1049,7 @@ def _cmd_guard(args: argparse.Namespace) -> int:
     try:
         report = analyze(args.source).to_dict()
     except CollectionError as exc:
-        print(f"error: {exc}", file=sys.stderr)
+        print(f"error: {_diagnostic(str(exc))}", file=sys.stderr)
         return EXIT_ERROR
     decision = evaluate(report, args.block_on)
     if args.json:
@@ -1805,6 +1831,15 @@ def _one_line(text: str) -> str:
     return one_line(text)
 
 
+def _diagnostic(text: str) -> str:
+    """An error message that carries text from outside (a git server's `remote:` lines, a
+    registry's answer, a file name): its line breaks are kept, but control characters and CI
+    workflow commands (`::error::`, `##[...]`) are shown as text, as in a report."""
+    from skilltotal.report import _terminal_safe
+
+    return _terminal_safe(text)
+
+
 # A quote inside one argument, then the end of it or what reads as a flag: on Windows, `\"` in a
 # command line is a literal quote, so PowerShell's `'.\my comp\' --json` reaches the program as the
 # single argument `.\my comp" --json`.

{skilltotal-0.76.0 → skilltotal-0.78.0}/skilltotal/diff.py

@@ -13,11 +13,12 @@ gating live in :mod:`skilltotal.cli`.
 
 from __future__ import annotations
 
+from collections import Counter
 from dataclasses import dataclass, field
 from typing import Any
 
 from skilltotal.baseline import evidence_fingerprint
-from skilltotal.models import Severity
+from skilltotal.models import UNANALYZED_TITLES, Severity
 
 _SEVERITY_ORDER = ("critical", "high", "medium", "low")
 
@@ -42,6 +43,10 @@ class DiffReport:
     # True when the two reports were produced by different rulesets: finding churn may then
     # come from detection changes rather than component changes.
     ruleset_mismatch: bool = False
+    # Notes of the new report that say part of it was not analyzed (models.UNANALYZED_TITLES)
+    # and that the old report did not have. A finding that disappears along with one of these
+    # may have left the scan's view, not the component.
+    coverage_gaps_added: list[dict[str, Any]] = field(default_factory=list)
     summary: str = ""
 
     def to_dict(self) -> dict[str, Any]:
@@ -56,6 +61,7 @@ class DiffReport:
             "capabilities_added": self.capabilities_added,
             "capabilities_removed": self.capabilities_removed,
             "ruleset_mismatch": self.ruleset_mismatch,
+            "coverage_gaps_added": self.coverage_gaps_added,
             "summary": self.summary,
         }
 
@@ -96,6 +102,7 @@ def diff_reports(old: dict[str, Any], new: dict[str, Any]) -> DiffReport:
             old.get("metadata", {}).get("ruleset_version")
             != new.get("metadata", {}).get("ruleset_version")
         ),
+        coverage_gaps_added=_coverage_gaps_added(old, new),
     )
     diff.summary = _summary(diff, old, new)
     return diff
@@ -117,11 +124,12 @@ def max_new_severity(diff: DiffReport) -> Severity | None:
 def _evidence_delta(
     rule_id: str, old_f: dict[str, Any], new_f: dict[str, Any]
 ) -> dict[str, Any] | None:
-    """Evidence-level delta for a rule present in both reports, or None if unchanged."""
-    old_fps = {_fp(rule_id, e): e for e in old_f.get("evidence", [])}
-    new_fps = {_fp(rule_id, e): e for e in new_f.get("evidence", [])}
-    added = [new_fps[k] for k in sorted(new_fps.keys() - old_fps.keys())]
-    removed = [old_fps[k] for k in sorted(old_fps.keys() - new_fps.keys())]
+    """Evidence-level delta for a rule present in both reports, or None if unchanged.
+
+    Occurrences are counted per fingerprint: a second copy of a line the old version already had
+    (the same snippet in the same file) is an added occurrence, not the old one again."""
+    added = _beyond(rule_id, new_f.get("evidence", []), old_f.get("evidence", []))
+    removed = _beyond(rule_id, old_f.get("evidence", []), new_f.get("evidence", []))
     if not added and not removed:
         return None
     return {
@@ -134,10 +142,37 @@ def _evidence_delta(
     }
 
 
+def _beyond(
+    rule_id: str, side: list[dict[str, Any]], other: list[dict[str, Any]]
+) -> list[dict[str, Any]]:
+    """The occurrences in ``side`` beyond as many as ``other`` has of each, in fingerprint order."""
+    left = Counter(_fp(rule_id, e) for e in other)
+    extra: list[tuple[str, int, dict[str, Any]]] = []
+    for k, e in enumerate(side):
+        fp = _fp(rule_id, e)
+        if left[fp] > 0:
+            left[fp] -= 1
+        else:
+            extra.append((fp, k, e))
+    return [e for _fp_key, _k, e in sorted(extra, key=lambda item: item[:2])]
+
+
 def _fp(rule_id: str, evidence: dict[str, Any]) -> str:
     return evidence_fingerprint(rule_id, evidence.get("file", ""), evidence.get("snippet", ""))
 
 
+def _coverage_gaps_added(old: dict[str, Any], new: dict[str, Any]) -> list[dict[str, Any]]:
+    """The new report's not-analyzed notes that the old report has no copy of (the same title,
+    file and reason)."""
+
+    def gaps(report: dict[str, Any]) -> list[dict[str, Any]]:
+        return [n for n in report.get("needs_review") or []
+                if isinstance(n, dict) and n.get("title") in UNANALYZED_TITLES]
+
+    seen = {(n.get("title"), n.get("file"), n.get("reason")) for n in gaps(old)}
+    return [n for n in gaps(new) if (n.get("title"), n.get("file"), n.get("reason")) not in seen]
+
+
 def _side_summary(report: dict[str, Any]) -> dict[str, Any]:
     component = report.get("component", {})
     metadata = report.get("metadata", {})
@@ -175,4 +210,6 @@ def _summary(diff: DiffReport, old: dict[str, Any], new: dict[str, Any]) -> str:
     parts.append(f"{len(diff.new_findings)} new finding(s)")
     parts.append(f"{len(diff.resolved_findings)} resolved")
     parts.append(f"{len(diff.changed_findings)} changed")
+    if diff.coverage_gaps_added:
+        parts.append(f"{len(diff.coverage_gaps_added)} new coverage gap(s)")
     return ": ".join([parts[0], ", ".join(parts[1:])])

{skilltotal-0.76.0 → skilltotal-0.78.0}/skilltotal/engine.py

@@ -144,7 +144,8 @@ def analyze_directory(
     # must be scanned there; in a repository they duplicate source that is checked in beside them.
     published = component.type in _PUBLISHED_PACKAGE_TYPES
     # What npm runs on install is read whatever its shape, minified or not: it is the attack.
-    install_scripts = _install_script_files(Path(root))
+    install_limits: list[str] = []
+    install_scripts = _install_script_files(Path(root), install_limits)
     # So is the code the package runs when it is imported or its command is run: a main file padded
     # with one long comment until it looked minified was skipped, and its payload with it.
     index = FileIndex.build(
@@ -161,6 +162,18 @@ def analyze_directory(
     for relpath, script in install_scripts.items():
         if relpath not in indexed:
             needs_review.append(_unanalyzed_install_script(Path(root), relpath, script))
+    if install_limits:
+        # The walk of what install scripts run stopped at a limit: what lies past it runs at
+        # install time and was not followed. The install guard keys on this title.
+        needs_review.append(NeedsReview(
+            category="coverage",
+            title=UNANALYZED_INSTALL_SCRIPT,
+            reason=(
+                "Reading what package.json runs at install time stopped at a limit ("
+                + "; ".join(install_limits) + "). Code past it runs at install time and may "
+                "not have been analyzed, so read the install scripts before installing."
+            ),
+        ))
     if index.minified:
         shown = ", ".join(index.minified[:5])
         more = f" (+{len(index.minified) - 5} more)" if len(index.minified) > 5 else ""
@@ -421,9 +434,12 @@ _UNANALYZED_LANGUAGES = {
 _NPM_INSTALL_SCRIPTS = ("preinstall", "install", "postinstall")
 
 
-def _install_script_files(root: Path) -> dict[str, str]:
+def _install_script_files(root: Path, limits: list[str] | None = None) -> dict[str, str]:
     """Files ``package.json`` runs at install time, as ``{relpath: script name}``.
 
+    Each bound the walk stops at is appended to ``limits`` (when given), in words: what lies past
+    it was not followed, and the report must not call the install clean.
+
     Any word of a ``preinstall`` / ``install`` / ``postinstall`` command that names a file inside
     the component is that file (``node setup.js``, ``sh ./scripts/x.sh``, ``./bin/fetch``), found
     the way Node finds it (``node .`` runs the package's ``main``, ``node install`` runs
@@ -440,7 +456,11 @@ def _install_script_files(root: Path) -> dict[str, str]:
     """
     base = root.resolve()
     queue: list[tuple[Path, str]] = []
-    for manifest in _package_manifests(root):
+    reached: list[str] = []
+    manifests = _package_manifests(root)
+    if len(manifests) > _MAX_PACKAGES:
+        reached.append(f"{_MAX_PACKAGES} packages inside the component")
+    for manifest in manifests:
         try:
             data = bounded_json.loads(manifest.read_text(encoding="utf-8", errors="replace"))
         except (OSError, ValueError):
@@ -453,12 +473,19 @@ def _install_script_files(root: Path) -> dict[str, str]:
             command = scripts.get(script)
             if not isinstance(command, str):
                 continue
-            for word in _install_command_words(package, command):
+            words = _install_command_words(package, command)
+            if len(words) >= _MAX_INSTALL_WORDS:
+                reached.append(f"{_MAX_INSTALL_WORDS} words of the {script} command")
+            for word in words:
                 target = _module_file(base, package, word)
                 if target is not None:
                     queue.append((target, script))
     found: dict[str, str] = {}
-    while queue and len(found) < _MAX_INSTALL_FILES:
+    while queue:
+        if len(found) >= _MAX_INSTALL_FILES:
+            if any(target.relative_to(base).as_posix() not in found for target, _ in queue):
+                reached.append(f"{_MAX_INSTALL_FILES} files")
+            break
         target, script = queue.pop(0)
         relpath = target.relative_to(base).as_posix()
         if relpath in found:
@@ -480,6 +507,8 @@ def _install_script_files(root: Path) -> dict[str, str]:
             loaded = _bundled_module_file(base, target.parent, match.group(2))
             if loaded is not None:
                 queue.append((loaded, script))
+    if limits is not None:
+        limits.extend(dict.fromkeys(reached))
     return found
 
 
@@ -516,9 +545,11 @@ def _install_command_words(package: Path, command: str) -> list[str]:
 _MAX_INSTALL_WORDS = 64
 # An install-time dropper is a handful of files; this only bounds a pathological require graph.
 _MAX_INSTALL_FILES = 200
-# Packages inside a component: how deep and how many are read (a monorepo has tens).
+# Packages inside a component: how deep and how many are read. A large monorepo has a few
+# hundred; a package.json is small, so the count only bounds a pathological tree. Reaching it
+# makes the install guard ask, so it must sit above what real repositories hold.
 _MAX_PACKAGE_DEPTH = 6
-_MAX_PACKAGES = 100
+_MAX_PACKAGES = 2000
 
 
 # How many entry points of the component's own package.json are read whatever their shape.
@@ -646,7 +677,8 @@ def _skipped_folders_note(index: FileIndex) -> NeedsReview | None:
         reason=(
             f"{len(folders)} folder(s) were not read: {shown}{more}. They hold third-party code "
             "or a build of the component's own. Code the component loads from them by a literal "
-            "path was read and checked; nothing else in them was."
+            "path was read and checked; packages it loads by name (a bundled dependency) and "
+            "everything else in them were not."
         ),
         file=f"{folders[0][0]}/",
     )
@@ -661,9 +693,10 @@ def _unloaded_note(unloaded: list[str]) -> NeedsReview:
         title=UNANALYZED_LOADED_CODE,
         reason=(
             f"The component loads {len(unloaded)} file(s) from a folder the scan otherwise skips, "
-            f"and they could not be read (larger than {MAX_FILE_BYTES // (1024 * 1024)} MiB, "
-            f"unreadable, or past the {MAX_LOADED_FILES}-file limit): {shown}{more}. That code "
-            "runs and nothing in it was checked."
+            f"and they were not read (a native binary, larger than "
+            f"{MAX_FILE_BYTES // (1024 * 1024)} MiB, unreadable, excluded from the scan, or past "
+            f"the {MAX_LOADED_FILES}-file limit): {shown}{more}. That code runs and nothing in it "
+            "was checked."
         ),
         file=unloaded[0],
     )