@sackville-mcp/coverage 0.0.1-alpha.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Curtis Autery
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/index.d.mts

@@ -0,0 +1,233 @@
+import { DiffFile, changedFiles, parseUnifiedDiff } from "@sackville-mcp/diff";
+
+//#region src/uncovered.d.ts
+/**
+ * Uncovered-new-line detection — the first, pure slice of the coverage pillar. Given a
+ * file's istanbul coverage and the set of lines a diff *added/changed*, classify each
+ * new line as covered, uncovered, or non-executable, and surface the
+ * executable-but-unhit ones: the **forgotten-assertion catch** that is the genuinely
+ * novel win under Sackville's TDD gate (a generic "what's uncovered" report largely
+ * duplicates the suite the agent already runs — the new lines a change introduced
+ * without a test exercising them is the signal worth isolating).
+ *
+ * Pure and offline: running the scoped suite to *produce* the coverage needs a
+ * child-process boundary (the repo has a single root `vitest.config.ts`, so there is no
+ * in-process Vitest-in-Vitest) and is a later slice. Keeping the differ pure is what
+ * lets the green gate stay deterministic.
+ *
+ * THE CORRECTNESS TRAP (ADR 0010): istanbul derives line coverage from `statementMap`,
+ * so a line carrying **no statement** (a blank line, a lone brace, a bare comment) is
+ * in *neither* the covered nor the uncovered set. A differ that treats "not covered" as
+ * "uncovered" would flag those false positives. We model an explicit third state,
+ * `nonExecutable`, and never report it as a finding.
+ */
+interface IstanbulPosition {
+  line: number;
+  column?: number;
+}
+interface IstanbulRange {
+  start: IstanbulPosition;
+  end: IstanbulPosition;
+}
+/**
+ * The subset of an istanbul `FileCoverage` we read — the per-file shape inside a
+ * `coverage-final.json` (as emitted by `@vitest/coverage-v8`). `s` holds statement hit
+ * counts keyed identically to `statementMap`.
+ */
+interface FileCoverage {
+  path?: string;
+  statementMap: Record<string, IstanbulRange>;
+  s: Record<string, number>;
+}
+type LineState = 'covered' | 'uncovered' | 'nonExecutable';
+interface ClassifiedLine {
+  line: number;
+  state: LineState;
+}
+interface UncoveredNewLines {
+  /** Every new line, classified, sorted ascending (input deduped). */
+  lines: ClassifiedLine[];
+  /** The executable new lines with zero hits — the forgotten-assertion catch. */
+  uncovered: number[];
+  summary: {
+    covered: number;
+    uncovered: number;
+    nonExecutable: number;
+    total: number;
+  };
+}
+/**
+ * Classify a diff's `newLines` against a file's istanbul coverage. New lines are
+ * deduped and sorted; each is `covered` (a statement on it was hit), `uncovered` (a
+ * statement on it was never hit), or `nonExecutable` (no statement maps to it).
+ */
+declare function uncoveredNewLines(fc: FileCoverage, newLines: number[]): UncoveredNewLines;
+//#endregion
+//#region src/coveragepy.d.ts
+/** The per-file shape inside a `coverage json` report (line-number lists). */
+interface CoveragePyFile {
+  executed_lines: number[];
+  missing_lines: number[];
+  /** Lines coverage.py was told to exclude; omitted from the map (→ nonExecutable). */
+  excluded_lines?: number[];
+}
+/** A `coverage json` report — `files` keyed by source path (relative or absolute). */
+interface CoveragePyReport {
+  files?: Record<string, CoveragePyFile>;
+  meta?: Record<string, unknown>;
+}
+/**
+ * Convert one coverage.py file entry into a {@link FileCoverage}. Each executed line becomes a
+ * synthetic statement hit once; each missing line a statement hit zero times; excluded lines are
+ * left out entirely (they classify as `nonExecutable`).
+ */
+declare function fileCoverageFromCoveragePy(path: string, file: CoveragePyFile): FileCoverage;
+/**
+ * Convert a whole `coverage json` report into the `Record<path, FileCoverage>` map
+ * `uncoveredInDiff` consumes, preserving coverage.py's path keys (its own diff-path↔key
+ * reconciliation handles relative vs absolute).
+ */
+declare function coveragePyToIstanbul(report: CoveragePyReport): Record<string, FileCoverage>;
+//#endregion
+//#region src/report.d.ts
+interface DiffCoverageFile {
+  /** The diff (repo-relative) path. */
+  path: string;
+  /** Whether a coverage entry was confidently matched. */
+  found: boolean;
+  /** The matched absolute coverage key, when found. */
+  coveragePath?: string;
+  /** New-side added line numbers from the diff. */
+  addedLines: number[];
+  /** The per-line classification, present only when coverage was found. */
+  result?: UncoveredNewLines;
+}
+interface DiffCoverageReport {
+  files: DiffCoverageFile[];
+  /** Every executable-but-unhit new line across the diff — the headline finding. */
+  uncovered: {
+    path: string;
+    line: number;
+  }[];
+  summary: {
+    covered: number;
+    uncovered: number;
+    nonExecutable: number; /** Classified new lines (across files that had coverage). */
+    total: number;
+    filesWithoutCoverage: number;
+  };
+}
+interface UncoveredInDiffOptions {
+  /** Absolute project root; when set, a diff path resolves to `<root>/<path>` exactly. */
+  projectRoot?: string;
+}
+/**
+ * Report the coverage of a diff's added lines. Each diff file is matched to its coverage
+ * entry and classified; files with no (or no confident) coverage match are returned with
+ * `found:false` and counted in `summary.filesWithoutCoverage`.
+ */
+declare function uncoveredInDiff(diff: string, coverage: Record<string, FileCoverage>, opts?: UncoveredInDiffOptions): DiffCoverageReport;
+//#endregion
+//#region src/run.d.ts
+/** Thrown when the paired operator gate denies a run. */
+declare class CoverageGateError extends Error {
+  constructor(message: string);
+}
+interface RunScopedConfig {
+  /** The project to run tests in. */
+  projectRoot: string;
+  /** OPERATOR allowlist of roots `runScoped` may execute in. Load-bearing even with allowRun. */
+  allowedRoots: string[];
+  /** OPERATOR opt-in to actually run tests. Deny-by-default. */
+  allowRun: boolean;
+  /** Wall-clock cap (ms) passed to the runner. */
+  timeoutMs?: number;
+}
+interface ScopedRunInput {
+  /** Changed source files to scope the test selection to (`vitest related`). */
+  changedFiles: string[];
+  /** Optional unified diff; when present the result includes the {@link uncoveredInDiff} report. */
+  diff?: string;
+}
+/** Injected command runner — executes `vitest <argv>` and yields its exit status. */
+type TestRunner = (argv: string[], opts: {
+  cwd: string;
+  timeoutMs?: number;
+}) => Promise<{
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}>;
+interface ScopedRunResult {
+  /** False when there were no changed files (the runner was not invoked). */
+  ran: boolean;
+  exitCode: number;
+  passed: boolean;
+  scopedFiles: string[];
+  coverage: Record<string, FileCoverage>;
+  coveragePath?: string;
+  /** Present when a diff was supplied. */
+  report?: DiffCoverageReport;
+}
+/** Default live runner: spawn the local `vitest` as a subprocess (used by the bin, not the gate). */
+declare const defaultVitestRunner: TestRunner;
+/** Default live runner: spawn the local `pytest` as a subprocess (used by the bin, not the gate). */
+declare const defaultPytestCovRunner: TestRunner;
+/** The paired deny-by-default operator gate (allowRun + allowlisted root). Shared by both runners. */
+declare function assertAllowed(config: RunScopedConfig): void;
+/**
+ * Run the tests related to a change, with coverage, behind the operator gate. Returns the
+ * collected coverage (and, when a diff is supplied, the uncovered-new-line report). The
+ * actual `vitest` invocation is the injected `runner` (default {@link defaultVitestRunner}).
+ */
+declare function runScoped(config: RunScopedConfig, input: ScopedRunInput, deps?: {
+  runner?: TestRunner;
+  coverageDir?: string;
+}): Promise<ScopedRunResult>;
+//#endregion
+//#region src/run-python.d.ts
+/** Fallback when a changed source file maps to no confident test (operator-visible, ADR 0010 addendum). */
+type ScopeMode = 'report-gap' | 'widen';
+interface ScopedPythonInput extends ScopedRunInput {
+  /** coverage.py measurement targets (`--cov=<target>`). Required — coverage.py needs explicit scope. */
+  measureTargets: string[];
+  /** Fallback when a changed source maps to no test. Default `report-gap`. */
+  scopeMode?: ScopeMode;
+}
+interface ScopedPythonResult extends ScopedRunResult {
+  /** pytest produced a non-test-result exit (no tests collected / usage / internal) ⇒ not a pass. */
+  inconclusive?: boolean;
+  /** Changed source files with no confident mirrored test — the coverage gap (never a silent pass). */
+  unmatched?: string[];
+  /** True when the no-test fallback widened the run to the whole suite. */
+  widened?: boolean;
+}
+/** A pytest test selection derived from a change. */
+interface PytestScope {
+  /** pytest positional test targets (files). Empty ⇒ run the whole suite. */
+  selectors: string[];
+  /** Changed source files with no confident mirrored test. */
+  unmatched: string[];
+  /** True when the run was widened to the whole suite (the `widen` fallback). */
+  widened: boolean;
+}
+/**
+ * Derive a pytest test scope from the changed files. A changed test file is a selector; a changed
+ * source file maps to its mirrored test when `testExists` confirms one. A source with no test is
+ * `unmatched`; the `mode` decides whether that widens to the whole suite (`widen`) or is reported
+ * as a gap while the matched tests still run (`report-gap`). Pure (FS access via `testExists`).
+ */
+declare function selectPytestScope(changedFiles: string[], mode: ScopeMode, testExists: (path: string) => boolean): PytestScope;
+/**
+ * Run the pytest tests related to a change, with coverage.py, behind the operator gate. Returns the
+ * converted coverage (and, when a diff is supplied, the uncovered-new-line report). The actual
+ * `pytest` invocation is the injected `runner` (default {@link defaultPytestCovRunner}).
+ */
+declare function runScopedPython(config: RunScopedConfig, input: ScopedPythonInput, deps?: {
+  runner?: TestRunner;
+  coverageDir?: string; /** Existence check for mirrored tests (FS by default; injected in tests). */
+  testExists?: (path: string) => boolean;
+}): Promise<ScopedPythonResult>;
+//#endregion
+export { type ClassifiedLine, CoverageGateError, type CoveragePyFile, type CoveragePyReport, type DiffCoverageFile, type DiffCoverageReport, type DiffFile, type FileCoverage, type IstanbulPosition, type IstanbulRange, type LineState, type PytestScope, type RunScopedConfig, type ScopeMode, type ScopedPythonInput, type ScopedPythonResult, type ScopedRunInput, type ScopedRunResult, type TestRunner, type UncoveredInDiffOptions, type UncoveredNewLines, assertAllowed, changedFiles, coveragePyToIstanbul, defaultPytestCovRunner, defaultVitestRunner, fileCoverageFromCoveragePy, parseUnifiedDiff, runScoped, runScopedPython, selectPytestScope, uncoveredInDiff, uncoveredNewLines };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/uncovered.ts","../src/coveragepy.ts","../src/report.ts","../src/run.ts","../src/run-python.ts"],"mappings":";;;;;;AAqBA;;;;AAEQ;AAGR;;;;;;;;;AAEuB;AAQvB;;UAfiB,gBAAA;EACf,IAAA;EACA,MAAM;AAAA;AAAA,UAGS,aAAA;EACf,KAAA,EAAO,gBAAA;EACP,GAAA,EAAK,gBAAgB;AAAA;;;;;;UAQN,YAAA;EACf,IAAA;EACA,YAAA,EAAc,MAAA,SAAe,aAAA;EAC7B,CAAA,EAAG,MAAA;AAAA;AAAA,KAGO,SAAA;AAAA,UAEK,cAAA;EACf,IAAA;EACA,KAAA,EAAO,SAAS;AAAA;AAAA,UAGD,iBAAA;EAHf;EAKA,KAAA,EAAO,cAAc;EALL;EAOhB,SAAA;EACA,OAAA;IAAW,OAAA;IAAiB,SAAA;IAAmB,aAAA;IAAuB,KAAA;EAAA;AAAA;;;;;;iBAwBxD,iBAAA,CAAkB,EAAA,EAAI,YAAA,EAAc,QAAA,aAAqB,iBAAiB;;;AAlDnE;AAAA,UCRN,cAAA;EACf,cAAA;EACA,aAAA;EDgB6B;ECd7B,cAAA;AAAA;;UAIe,gBAAA;EACf,KAAA,GAAQ,MAAA,SAAe,cAAA;EACvB,IAAA,GAAO,MAAA;AAAA;;;;;ADSE;iBCDK,0BAAA,CAA2B,IAAA,UAAc,IAAA,EAAM,cAAA,GAAiB,YAAY;;;;ADIvE;AAErB;iBCagB,oBAAA,CAAqB,MAAA,EAAQ,gBAAA,GAAmB,MAAA,SAAe,YAAA;;;UCvC9D,gBAAA;EFUM;EERrB,IAAA;EFgBe;EEdf,KAAA;;EAEA,YAAA;EFcc;EEZd,UAAA;EFaS;EEXT,MAAA,GAAS,iBAAiB;AAAA;AAAA,UAGX,kBAAA;EACf,KAAA,EAAO,gBAAgB;EFMM;EEJ7B,SAAA;IAAa,IAAA;IAAc,IAAA;EAAA;EAC3B,OAAA;IACE,OAAA;IACA,SAAA;IACA,aAAA,UFIiB;IEFjB,KAAA;IACA,oBAAA;EAAA;AAAA;AAAA,UAIa,sBAAA;EFCf;EECA,WAAW;AAAA;AFDK;AAGlB;;;;AAHkB,iBEsCF,eAAA,CACd,IAAA,UACA,QAAA,EAAU,MAAA,SAAe,YAAA,GACzB,IAAA,GAAM,sBAAA,GACL,kBAAA;;;;cC5DU,iBAAA,SAA0B,KAAK;cAC9B,OAAA;AAAA;AAAA,UAWG,eAAA;EHHf;EGKA,WAAA;EHJc;EGMd,YAAA;EHLA;EGOA,QAAA;EHPS;EGST,SAAA;AAAA;AAAA,UAGe,cAAA;;EAEf,YAAA;EHXmB;EGanB,IAAI;AAAA;;KAIM,UAAA,IACV,IAAA,YACA,IAAA;EAAQ,GAAA;EAAa,SAAA;AAAA,MAClB,OAAO;EAAG,QAAA;EAAkB,MAAA;EAAgB,MAAA;AAAA;AAAA,UAEhC,eAAA;EHbM;EGerB,GAAA;EACA,QAAA;EACA,MAAA;EACA,WAAA;EACA,QAAA,EAAU,MAAA,SAAe,YAAA;EACzB,YAAA;EHjB+C;EGmB/C,MAAA,GAAS,kBAAA;AAAA;AHnBkE;AAAA,cG0DhE,mBAAA,EAAqB,UAAkC;;cAGvD,sBAAA,EAAwB,UAAkC;;iBAGvD,aAAA,CAAc,MAAuB,EAAf,eAAe;;;;;AHxCqC;iBG4DpE,SAAA,CACpB,MAAA,EAAQ,eAAA,EACR,KAAA,EAAO,cAAA,EACP,IAAA;EAAQ,MAAA,GAAS,UAAA;EAAY,WAAA;AAAA,IAC5B,OAAA,CAAQ,eAAA;;;;KCvGC,SAAA;AAAA,UAEK,iBAAA,SAA0B,cAAc;EJJvD;EIMA,cAAA;EJLc;EIOd,SAAA,GAAY,SAAA;AAAA;AAAA,UAGG,kBAAA,SAA2B,eAAe;EJThD;EIWT,YAAA;EJRU;EIUV,SAAA;;EAEA,OAAA;AAAA;AJVF;AAAA,UIciB,WAAA;;EAEf,SAAA;EJfA;EIiBA,SAAA;EJhBO;EIkBP,OAAA;AAAA;AJfF;;;;;;AAAA,iBI6CgB,iBAAA,CACd,YAAA,YACA,IAAA,EAAM,SAAA,EACN,UAAA,GAAa,IAAA,uBACZ,WAAW;;;;;;iBAkCQ,eAAA,CACpB,MAAA,EAAQ,eAAA,EACR,KAAA,EAAO,iBAAA,EACP,IAAA;EACE,MAAA,GAAS,UAAA;EACT,WAAA,WJ3D6B;EI6D7B,UAAA,IAAc,IAAA;AAAA,IAEf,OAAA,CAAQ,kBAAA"}

package/dist/index.mjs

@@ -0,0 +1,441 @@
+import { changedFiles, parseUnifiedDiff, parseUnifiedDiff as parseUnifiedDiff$1 } from "@sackville-mcp/diff";
+import { execFile } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join, resolve } from "node:path";
+//#region src/coveragepy.ts
+/**
+* Convert one coverage.py file entry into a {@link FileCoverage}. Each executed line becomes a
+* synthetic statement hit once; each missing line a statement hit zero times; excluded lines are
+* left out entirely (they classify as `nonExecutable`).
+*/
+function fileCoverageFromCoveragePy(path, file) {
+	const statementMap = {};
+	const s = {};
+	let id = 0;
+	const add = (line, hits) => {
+		const key = String(id++);
+		statementMap[key] = {
+			start: {
+				line,
+				column: 0
+			},
+			end: {
+				line,
+				column: 0
+			}
+		};
+		s[key] = hits;
+	};
+	for (const line of file.executed_lines ?? []) add(line, 1);
+	for (const line of file.missing_lines ?? []) add(line, 0);
+	return {
+		path,
+		statementMap,
+		s
+	};
+}
+/**
+* Convert a whole `coverage json` report into the `Record<path, FileCoverage>` map
+* `uncoveredInDiff` consumes, preserving coverage.py's path keys (its own diff-path↔key
+* reconciliation handles relative vs absolute).
+*/
+function coveragePyToIstanbul(report) {
+	const out = {};
+	for (const [path, file] of Object.entries(report.files ?? {})) out[path] = fileCoverageFromCoveragePy(path, file);
+	return out;
+}
+//#endregion
+//#region src/uncovered.ts
+/**
+* Map each source line to its statement hit count, mirroring istanbul's
+* `getLineCoverage`: a line's count is the **max** hit count over the statements that
+* *start* on it. A line absent from the map carries no statement (non-executable).
+*/
+function lineHitCounts(fc) {
+	const hits = /* @__PURE__ */ new Map();
+	for (const [id, range] of Object.entries(fc.statementMap)) {
+		const line = range.start.line;
+		const count = fc.s[id] ?? 0;
+		const prev = hits.get(line);
+		if (prev === void 0 || count > prev) hits.set(line, count);
+	}
+	return hits;
+}
+/**
+* Classify a diff's `newLines` against a file's istanbul coverage. New lines are
+* deduped and sorted; each is `covered` (a statement on it was hit), `uncovered` (a
+* statement on it was never hit), or `nonExecutable` (no statement maps to it).
+*/
+function uncoveredNewLines(fc, newLines) {
+	const hits = lineHitCounts(fc);
+	const lines = [];
+	const uncovered = [];
+	let covered = 0;
+	let uncov = 0;
+	let nonExecutable = 0;
+	for (const line of [...new Set(newLines)].sort((a, b) => a - b)) {
+		const count = hits.get(line);
+		let state;
+		if (count === void 0) {
+			state = "nonExecutable";
+			nonExecutable++;
+		} else if (count > 0) {
+			state = "covered";
+			covered++;
+		} else {
+			state = "uncovered";
+			uncov++;
+			uncovered.push(line);
+		}
+		lines.push({
+			line,
+			state
+		});
+	}
+	return {
+		lines,
+		uncovered,
+		summary: {
+			covered,
+			uncovered: uncov,
+			nonExecutable,
+			total: lines.length
+		}
+	};
+}
+//#endregion
+//#region src/report.ts
+/**
+* Diff ↔ coverage integrator — joins the two pure halves of the forgotten-assertion
+* catch: {@link parseUnifiedDiff} (the lines a change added) and {@link uncoveredNewLines}
+* (which of a file's lines are covered/uncovered/non-executable). The result answers the
+* headline question — "of the lines this change introduced, which executable ones did no
+* test exercise" — across every file in the diff.
+*
+* The one real subtlety is **path reconciliation**: a unified diff names files
+* repo-relative (`packages/app/src/math.ts`), while a `coverage-final.json` is keyed by
+* **absolute** path (`/abs/repo/packages/app/src/math.ts`). With a `projectRoot` we match
+* exactly (`<root>/<diffPath>`); without one we fall back to a **unique** path-suffix
+* match and refuse to guess when more than one key matches (so a stray second checkout in
+* the coverage map can't cause a wrong attribution). Pure/offline.
+*/
+/** Forward-slash + collapse repeated separators, for cross-platform path comparison. */
+function norm(p) {
+	return p.replace(/\\/g, "/").replace(/\/{2,}/g, "/").replace(/^\.\//, "");
+}
+/**
+* Match a repo-relative diff path to a coverage key. Prefer an exact `<root>/<path>`
+* resolution; else require a single key ending in `/<path>` (refusing an ambiguous match).
+*/
+function matchCoverageKey(diffPath, keys, projectRoot) {
+	const p = norm(diffPath);
+	if (projectRoot !== void 0) {
+		const target = norm(`${projectRoot}/${p}`);
+		const exactRoot = keys.find((k) => k.norm === target);
+		if (exactRoot) return exactRoot.orig;
+	}
+	const exact = keys.find((k) => k.norm === p);
+	if (exact) return exact.orig;
+	const suffix = keys.filter((k) => k.norm.endsWith(`/${p}`));
+	return suffix.length === 1 ? suffix[0]?.orig : void 0;
+}
+/**
+* Report the coverage of a diff's added lines. Each diff file is matched to its coverage
+* entry and classified; files with no (or no confident) coverage match are returned with
+* `found:false` and counted in `summary.filesWithoutCoverage`.
+*/
+function uncoveredInDiff(diff, coverage, opts = {}) {
+	const keys = Object.keys(coverage).map((orig) => ({
+		orig,
+		norm: norm(orig)
+	}));
+	const files = [];
+	const uncovered = [];
+	let covered = 0;
+	let uncov = 0;
+	let nonExecutable = 0;
+	let filesWithoutCoverage = 0;
+	for (const { path, addedLines } of parseUnifiedDiff$1(diff)) {
+		const key = matchCoverageKey(path, keys, opts.projectRoot);
+		if (key === void 0) {
+			filesWithoutCoverage++;
+			files.push({
+				path,
+				found: false,
+				addedLines
+			});
+			continue;
+		}
+		const result = uncoveredNewLines(coverage[key], addedLines);
+		covered += result.summary.covered;
+		uncov += result.summary.uncovered;
+		nonExecutable += result.summary.nonExecutable;
+		for (const line of result.uncovered) uncovered.push({
+			path,
+			line
+		});
+		files.push({
+			path,
+			found: true,
+			coveragePath: key,
+			addedLines,
+			result
+		});
+	}
+	return {
+		files,
+		uncovered,
+		summary: {
+			covered,
+			uncovered: uncov,
+			nonExecutable,
+			total: covered + uncov + nonExecutable,
+			filesWithoutCoverage
+		}
+	};
+}
+//#endregion
+//#region src/run.ts
+/**
+* Impact-scoped test runner — the live half of the coverage pillar. Runs ONLY the tests
+* a change touches (via `vitest related <changed files>`) with coverage, then feeds the
+* produced `coverage-final.json` into {@link uncoveredInDiff} to surface the new lines a
+* change introduced that no test exercised.
+*
+* Two ADR-0010 constraints shape this:
+*
+* 1. **It runs code**, so it is behind a *paired* deny-by-default operator gate — an
+*    `allowRun` boolean AND an `allowedRoots` allowlist, with a wall-clock cap. Both are
+*    operator-set (the bin reads `SACKVILLE_COVERAGE_ALLOW_RUN` / `_PROJECT_ROOTS` /
+*    `_TIMEOUT_MS`); no caller input can self-authorize a run.
+* 2. **Child-process boundary.** The repo has a single root `vitest.config.ts`, so the
+*    in-process `startVitest` API can't be used from inside the outer Vitest worker
+*    (reentrancy). The actual run is therefore an injected {@link TestRunner} that the
+*    bin wires to a `vitest` *subprocess*; the engine here owns the gate, argv, coverage
+*    collection, and diff wiring, and is unit-tested with a fake runner (no real spawn in
+*    the green gate).
+*/
+/** Thrown when the paired operator gate denies a run. */
+var CoverageGateError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CoverageGateError";
+		this[Symbol.for("sackville.gate-denial")] = true;
+	}
+};
+/** Build the `vitest related` argv: run once, scoped to the changed files, with v8 JSON coverage. */
+function scopedArgv(changedFiles, coverageDir) {
+	return [
+		"related",
+		...changedFiles,
+		"--run",
+		"--coverage.enabled=true",
+		"--coverage.provider=v8",
+		"--coverage.reporter=json",
+		`--coverage.reportsDirectory=${coverageDir}`
+	];
+}
+/** Spawn a local command as a subprocess, surfacing its exit code (never rejecting on non-zero). */
+function spawnRunner(command) {
+	return (argv, opts) => new Promise((res) => {
+		execFile(command, argv, {
+			cwd: opts.cwd,
+			timeout: opts.timeoutMs,
+			maxBuffer: 64 * 1024 * 1024
+		}, (err, stdout, stderr) => {
+			res({
+				exitCode: err && typeof err.code === "number" ? err.code : err ? 1 : 0,
+				stdout: String(stdout),
+				stderr: String(stderr)
+			});
+		});
+	});
+}
+/** Default live runner: spawn the local `vitest` as a subprocess (used by the bin, not the gate). */
+const defaultVitestRunner = spawnRunner("vitest");
+/** Default live runner: spawn the local `pytest` as a subprocess (used by the bin, not the gate). */
+const defaultPytestCovRunner = spawnRunner("pytest");
+/** The paired deny-by-default operator gate (allowRun + allowlisted root). Shared by both runners. */
+function assertAllowed(config) {
+	if (!config.allowRun) throw new CoverageGateError("scoped test execution is not enabled (the operator must set allowRun)");
+	const root = resolve(config.projectRoot);
+	if (!config.allowedRoots.map((r) => resolve(r)).includes(root)) throw new CoverageGateError(`project root ${config.projectRoot} is not in the operator allowlist`);
+}
+/**
+* Run the tests related to a change, with coverage, behind the operator gate. Returns the
+* collected coverage (and, when a diff is supplied, the uncovered-new-line report). The
+* actual `vitest` invocation is the injected `runner` (default {@link defaultVitestRunner}).
+*/
+async function runScoped(config, input, deps = {}) {
+	assertAllowed(config);
+	if (input.changedFiles.length === 0) return {
+		ran: false,
+		exitCode: 0,
+		passed: true,
+		scopedFiles: [],
+		coverage: {}
+	};
+	const runner = deps.runner ?? defaultVitestRunner;
+	const coverageDir = deps.coverageDir ?? mkdtempSync(join(tmpdir(), "sackville-cov-"));
+	const { exitCode } = await runner(scopedArgv(input.changedFiles, coverageDir), {
+		cwd: config.projectRoot,
+		timeoutMs: config.timeoutMs
+	});
+	const coveragePath = join(coverageDir, "coverage-final.json");
+	let coverage;
+	try {
+		coverage = JSON.parse(readFileSync(coveragePath, "utf8"));
+	} catch {
+		throw new Error(`scoped run did not produce a coverage report at ${coveragePath} (exit code ${exitCode})`);
+	}
+	const report = input.diff !== void 0 ? uncoveredInDiff(input.diff, coverage, { projectRoot: config.projectRoot }) : void 0;
+	return {
+		ran: true,
+		exitCode,
+		passed: exitCode === 0,
+		scopedFiles: input.changedFiles,
+		coverage,
+		coveragePath,
+		report
+	};
+}
+//#endregion
+//#region src/run-python.ts
+/**
+* Python impact-scoped coverage runner (ADR 0010 addendum) — the coverage.py sibling of
+* {@link runScoped}. Runs `pytest --cov=<target> --cov-report=json` scoped to the tests a change
+* touched, converts the report via the shipped {@link coveragePyToIstanbul} (unchanged), and feeds
+* {@link uncoveredInDiff} (unchanged) to surface the new lines no test exercised.
+*
+* Two coverage.py / pytest specifics drive the design:
+*
+* 1. **No `vitest related`.** pytest has no built-in changed-files test selection, so we derive a
+*    scope with {@link selectPytestScope}: a changed TEST file is a selector directly; a changed
+*    SOURCE file maps to a mirrored test (`test_<x>.py` / `tests/test_<x>.py`) when one exists. When
+*    a changed source maps to NO confident test, the ratified fallback is operator-visible:
+*    `report-gap` (default — run the matched tests, report the unmatched source as a coverage gap)
+*    or `widen` (run the whole suite). testmon is intentionally NOT used (a stale `.testmondata`
+*    silently deselects tests → false clean, violating absence-is-never-a-pass).
+*
+* 2. **pytest exit codes are not vitest's.** Exit 5 (no tests collected), 2/3/4 (usage/internal) are
+*    NOT a clean pass — they map to `inconclusive`, and the run never produces a (misleading) clean
+*    report. Only 0 (passed) / 1 (tests failed) carry a real result.
+*
+* The `pytest`/coverage.py invocation is the injected {@link TestRunner}; no real spawn in the gate.
+*/
+const TEST_FILE = /(?:^|\/)(?:test_[^/]+|[^/]+_test)\.py$/;
+const IN_TEST_DIR = /(?:^|\/)tests?\//;
+function isTestFile(path) {
+	return TEST_FILE.test(path) || IN_TEST_DIR.test(path) && path.endsWith(".py");
+}
+/** Candidate mirrored-test paths for a changed source file (same dir + a `tests/` sibling). */
+function mirroredTestCandidates(srcPath) {
+	if (!srcPath.endsWith(".py")) return [];
+	const slash = srcPath.lastIndexOf("/");
+	const dir = slash === -1 ? "" : srcPath.slice(0, slash + 1);
+	const stem = basename(srcPath).slice(0, -3);
+	return [
+		`${dir}test_${stem}.py`,
+		`${dir}${stem}_test.py`,
+		`${dir}tests/test_${stem}.py`,
+		`tests/test_${stem}.py`
+	];
+}
+/**
+* Derive a pytest test scope from the changed files. A changed test file is a selector; a changed
+* source file maps to its mirrored test when `testExists` confirms one. A source with no test is
+* `unmatched`; the `mode` decides whether that widens to the whole suite (`widen`) or is reported
+* as a gap while the matched tests still run (`report-gap`). Pure (FS access via `testExists`).
+*/
+function selectPytestScope(changedFiles, mode, testExists) {
+	const selectors = /* @__PURE__ */ new Set();
+	const unmatched = [];
+	for (const file of changedFiles) {
+		if (isTestFile(file)) {
+			selectors.add(file);
+			continue;
+		}
+		if (!file.endsWith(".py")) continue;
+		const found = mirroredTestCandidates(file).filter(testExists);
+		if (found.length > 0) for (const t of found) selectors.add(t);
+		else unmatched.push(file);
+	}
+	if (unmatched.length > 0 && mode === "widen") return {
+		selectors: [],
+		unmatched,
+		widened: true
+	};
+	return {
+		selectors: [...selectors],
+		unmatched,
+		widened: false
+	};
+}
+/** Build the `pytest --cov` argv with a JSON report at `jsonPath` and the selected test targets. */
+function pytestArgv(measureTargets, selectors, jsonPath) {
+	return [
+		...measureTargets.map((t) => `--cov=${t}`),
+		`--cov-report=json:${jsonPath}`,
+		...selectors
+	];
+}
+/** A pytest exit code that is NOT a test result (no tests collected / usage / internal). */
+function isInconclusiveExit(exitCode) {
+	return exitCode === 2 || exitCode === 3 || exitCode === 4 || exitCode === 5;
+}
+/**
+* Run the pytest tests related to a change, with coverage.py, behind the operator gate. Returns the
+* converted coverage (and, when a diff is supplied, the uncovered-new-line report). The actual
+* `pytest` invocation is the injected `runner` (default {@link defaultPytestCovRunner}).
+*/
+async function runScopedPython(config, input, deps = {}) {
+	assertAllowed(config);
+	if (input.changedFiles.length === 0) return {
+		ran: false,
+		exitCode: 0,
+		passed: true,
+		scopedFiles: [],
+		coverage: {}
+	};
+	const mode = input.scopeMode ?? "report-gap";
+	const testExists = deps.testExists ?? ((p) => existsSync(join(config.projectRoot, p)));
+	const scope = selectPytestScope(input.changedFiles, mode, testExists);
+	if (scope.selectors.length === 0 && !scope.widened && scope.unmatched.length === 0) return {
+		ran: false,
+		exitCode: 0,
+		passed: true,
+		scopedFiles: [],
+		coverage: {}
+	};
+	const runner = deps.runner ?? defaultPytestCovRunner;
+	const jsonPath = join(deps.coverageDir ?? mkdtempSync(join(tmpdir(), "sackville-cov-py-")), "coverage.json");
+	const { exitCode } = await runner(pytestArgv(input.measureTargets, scope.selectors, jsonPath), {
+		cwd: config.projectRoot,
+		timeoutMs: config.timeoutMs
+	});
+	const inconclusive = isInconclusiveExit(exitCode);
+	let coverage = {};
+	try {
+		coverage = coveragePyToIstanbul(JSON.parse(readFileSync(jsonPath, "utf8")));
+	} catch {
+		if (!inconclusive) throw new Error(`scoped pytest run did not produce a coverage report at ${jsonPath} (exit code ${exitCode})`);
+	}
+	const report = input.diff !== void 0 && !inconclusive && Object.keys(coverage).length > 0 ? uncoveredInDiff(input.diff, coverage, { projectRoot: config.projectRoot }) : void 0;
+	return {
+		ran: true,
+		exitCode,
+		passed: exitCode === 0,
+		inconclusive: inconclusive || void 0,
+		scopedFiles: input.changedFiles,
+		unmatched: scope.unmatched.length > 0 ? scope.unmatched : void 0,
+		widened: scope.widened || void 0,
+		coverage,
+		coveragePath: jsonPath,
+		report
+	};
+}
+//#endregion
+export { CoverageGateError, assertAllowed, changedFiles, coveragePyToIstanbul, defaultPytestCovRunner, defaultVitestRunner, fileCoverageFromCoveragePy, parseUnifiedDiff, runScoped, runScopedPython, selectPytestScope, uncoveredInDiff, uncoveredNewLines };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["parseUnifiedDiff"],"sources":["../src/coveragepy.ts","../src/uncovered.ts","../src/report.ts","../src/run.ts","../src/run-python.ts"],"sourcesContent":["/**\n * coverage.py adapter — converts a `coverage json` report into the istanbul\n * {@link FileCoverage} shape the pure differ ({@link uncoveredNewLines}/`uncoveredInDiff`)\n * already consumes. The Python sibling of the `@vitest/coverage-v8` `coverage-final.json`\n * path: the differ is entirely ecosystem-agnostic (it reads `statementMap` + `s`), so the\n * Python adapter is purely this shape converter — no change to the differ.\n *\n * THE GRANULARITY GAP: coverage.py is **line-based** (`executed_lines` / `missing_lines` /\n * `excluded_lines`), while istanbul is **statement-based**. We bridge by minting one synthetic\n * single-line statement per executed/missing line — executed → hit count 1, missing → 0. This\n * is loss-free for the forgotten-assertion catch, because that question is asked per *line*\n * (`uncoveredNewLines` reduces statements to lines via the max hit count on each start line),\n * never per sub-expression. `excluded_lines` are simply omitted from the map, so — exactly like\n * istanbul's blank/brace/comment lines — they fall into the `nonExecutable` third state and are\n * never reported as a finding (the ADR-0010 correctness trap, honoured for free). Pure, offline.\n */\n\nimport type { FileCoverage } from './uncovered.js'\n\n/** The per-file shape inside a `coverage json` report (line-number lists). */\nexport interface CoveragePyFile {\n  executed_lines: number[]\n  missing_lines: number[]\n  /** Lines coverage.py was told to exclude; omitted from the map (→ nonExecutable). */\n  excluded_lines?: number[]\n}\n\n/** A `coverage json` report — `files` keyed by source path (relative or absolute). */\nexport interface CoveragePyReport {\n  files?: Record<string, CoveragePyFile>\n  meta?: Record<string, unknown>\n}\n\n/**\n * Convert one coverage.py file entry into a {@link FileCoverage}. Each executed line becomes a\n * synthetic statement hit once; each missing line a statement hit zero times; excluded lines are\n * left out entirely (they classify as `nonExecutable`).\n */\nexport function fileCoverageFromCoveragePy(path: string, file: CoveragePyFile): FileCoverage {\n  const statementMap: FileCoverage['statementMap'] = {}\n  const s: FileCoverage['s'] = {}\n  let id = 0\n  const add = (line: number, hits: number) => {\n    const key = String(id++)\n    statementMap[key] = { start: { line, column: 0 }, end: { line, column: 0 } }\n    s[key] = hits\n  }\n  for (const line of file.executed_lines ?? []) add(line, 1)\n  for (const line of file.missing_lines ?? []) add(line, 0)\n  return { path, statementMap, s }\n}\n\n/**\n * Convert a whole `coverage json` report into the `Record<path, FileCoverage>` map\n * `uncoveredInDiff` consumes, preserving coverage.py's path keys (its own diff-path↔key\n * reconciliation handles relative vs absolute).\n */\nexport function coveragePyToIstanbul(report: CoveragePyReport): Record<string, FileCoverage> {\n  const out: Record<string, FileCoverage> = {}\n  for (const [path, file] of Object.entries(report.files ?? {})) {\n    out[path] = fileCoverageFromCoveragePy(path, file)\n  }\n  return out\n}\n","/**\n * Uncovered-new-line detection — the first, pure slice of the coverage pillar. Given a\n * file's istanbul coverage and the set of lines a diff *added/changed*, classify each\n * new line as covered, uncovered, or non-executable, and surface the\n * executable-but-unhit ones: the **forgotten-assertion catch** that is the genuinely\n * novel win under Sackville's TDD gate (a generic \"what's uncovered\" report largely\n * duplicates the suite the agent already runs — the new lines a change introduced\n * without a test exercising them is the signal worth isolating).\n *\n * Pure and offline: running the scoped suite to *produce* the coverage needs a\n * child-process boundary (the repo has a single root `vitest.config.ts`, so there is no\n * in-process Vitest-in-Vitest) and is a later slice. Keeping the differ pure is what\n * lets the green gate stay deterministic.\n *\n * THE CORRECTNESS TRAP (ADR 0010): istanbul derives line coverage from `statementMap`,\n * so a line carrying **no statement** (a blank line, a lone brace, a bare comment) is\n * in *neither* the covered nor the uncovered set. A differ that treats \"not covered\" as\n * \"uncovered\" would flag those false positives. We model an explicit third state,\n * `nonExecutable`, and never report it as a finding.\n */\n\nexport interface IstanbulPosition {\n  line: number\n  column?: number\n}\n\nexport interface IstanbulRange {\n  start: IstanbulPosition\n  end: IstanbulPosition\n}\n\n/**\n * The subset of an istanbul `FileCoverage` we read — the per-file shape inside a\n * `coverage-final.json` (as emitted by `@vitest/coverage-v8`). `s` holds statement hit\n * counts keyed identically to `statementMap`.\n */\nexport interface FileCoverage {\n  path?: string\n  statementMap: Record<string, IstanbulRange>\n  s: Record<string, number>\n}\n\nexport type LineState = 'covered' | 'uncovered' | 'nonExecutable'\n\nexport interface ClassifiedLine {\n  line: number\n  state: LineState\n}\n\nexport interface UncoveredNewLines {\n  /** Every new line, classified, sorted ascending (input deduped). */\n  lines: ClassifiedLine[]\n  /** The executable new lines with zero hits — the forgotten-assertion catch. */\n  uncovered: number[]\n  summary: { covered: number; uncovered: number; nonExecutable: number; total: number }\n}\n\n/**\n * Map each source line to its statement hit count, mirroring istanbul's\n * `getLineCoverage`: a line's count is the **max** hit count over the statements that\n * *start* on it. A line absent from the map carries no statement (non-executable).\n */\nfunction lineHitCounts(fc: FileCoverage): Map<number, number> {\n  const hits = new Map<number, number>()\n  for (const [id, range] of Object.entries(fc.statementMap)) {\n    const line = range.start.line\n    const count = fc.s[id] ?? 0\n    const prev = hits.get(line)\n    if (prev === undefined || count > prev) hits.set(line, count)\n  }\n  return hits\n}\n\n/**\n * Classify a diff's `newLines` against a file's istanbul coverage. New lines are\n * deduped and sorted; each is `covered` (a statement on it was hit), `uncovered` (a\n * statement on it was never hit), or `nonExecutable` (no statement maps to it).\n */\nexport function uncoveredNewLines(fc: FileCoverage, newLines: number[]): UncoveredNewLines {\n  const hits = lineHitCounts(fc)\n  const lines: ClassifiedLine[] = []\n  const uncovered: number[] = []\n  let covered = 0\n  let uncov = 0\n  let nonExecutable = 0\n\n  for (const line of [...new Set(newLines)].sort((a, b) => a - b)) {\n    const count = hits.get(line)\n    let state: LineState\n    if (count === undefined) {\n      state = 'nonExecutable'\n      nonExecutable++\n    } else if (count > 0) {\n      state = 'covered'\n      covered++\n    } else {\n      state = 'uncovered'\n      uncov++\n      uncovered.push(line)\n    }\n    lines.push({ line, state })\n  }\n\n  return {\n    lines,\n    uncovered,\n    summary: { covered, uncovered: uncov, nonExecutable, total: lines.length },\n  }\n}\n","/**\n * Diff ↔ coverage integrator — joins the two pure halves of the forgotten-assertion\n * catch: {@link parseUnifiedDiff} (the lines a change added) and {@link uncoveredNewLines}\n * (which of a file's lines are covered/uncovered/non-executable). The result answers the\n * headline question — \"of the lines this change introduced, which executable ones did no\n * test exercise\" — across every file in the diff.\n *\n * The one real subtlety is **path reconciliation**: a unified diff names files\n * repo-relative (`packages/app/src/math.ts`), while a `coverage-final.json` is keyed by\n * **absolute** path (`/abs/repo/packages/app/src/math.ts`). With a `projectRoot` we match\n * exactly (`<root>/<diffPath>`); without one we fall back to a **unique** path-suffix\n * match and refuse to guess when more than one key matches (so a stray second checkout in\n * the coverage map can't cause a wrong attribution). Pure/offline.\n */\n\nimport { parseUnifiedDiff } from '@sackville-mcp/diff'\nimport { type FileCoverage, type UncoveredNewLines, uncoveredNewLines } from './uncovered.js'\n\nexport interface DiffCoverageFile {\n  /** The diff (repo-relative) path. */\n  path: string\n  /** Whether a coverage entry was confidently matched. */\n  found: boolean\n  /** The matched absolute coverage key, when found. */\n  coveragePath?: string\n  /** New-side added line numbers from the diff. */\n  addedLines: number[]\n  /** The per-line classification, present only when coverage was found. */\n  result?: UncoveredNewLines\n}\n\nexport interface DiffCoverageReport {\n  files: DiffCoverageFile[]\n  /** Every executable-but-unhit new line across the diff — the headline finding. */\n  uncovered: { path: string; line: number }[]\n  summary: {\n    covered: number\n    uncovered: number\n    nonExecutable: number\n    /** Classified new lines (across files that had coverage). */\n    total: number\n    filesWithoutCoverage: number\n  }\n}\n\nexport interface UncoveredInDiffOptions {\n  /** Absolute project root; when set, a diff path resolves to `<root>/<path>` exactly. */\n  projectRoot?: string\n}\n\n/** Forward-slash + collapse repeated separators, for cross-platform path comparison. */\nfunction norm(p: string): string {\n  return p\n    .replace(/\\\\/g, '/')\n    .replace(/\\/{2,}/g, '/')\n    .replace(/^\\.\\//, '')\n}\n\n/**\n * Match a repo-relative diff path to a coverage key. Prefer an exact `<root>/<path>`\n * resolution; else require a single key ending in `/<path>` (refusing an ambiguous match).\n */\nfunction matchCoverageKey(\n  diffPath: string,\n  keys: { norm: string; orig: string }[],\n  projectRoot?: string,\n): string | undefined {\n  const p = norm(diffPath)\n  if (projectRoot !== undefined) {\n    const target = norm(`${projectRoot}/${p}`)\n    const exactRoot = keys.find((k) => k.norm === target)\n    if (exactRoot) return exactRoot.orig\n  }\n  const exact = keys.find((k) => k.norm === p)\n  if (exact) return exact.orig\n  const suffix = keys.filter((k) => k.norm.endsWith(`/${p}`))\n  return suffix.length === 1 ? suffix[0]?.orig : undefined\n}\n\n/**\n * Report the coverage of a diff's added lines. Each diff file is matched to its coverage\n * entry and classified; files with no (or no confident) coverage match are returned with\n * `found:false` and counted in `summary.filesWithoutCoverage`.\n */\nexport function uncoveredInDiff(\n  diff: string,\n  coverage: Record<string, FileCoverage>,\n  opts: UncoveredInDiffOptions = {},\n): DiffCoverageReport {\n  const keys = Object.keys(coverage).map((orig) => ({ orig, norm: norm(orig) }))\n  const files: DiffCoverageFile[] = []\n  const uncovered: { path: string; line: number }[] = []\n  let covered = 0\n  let uncov = 0\n  let nonExecutable = 0\n  let filesWithoutCoverage = 0\n\n  for (const { path, addedLines } of parseUnifiedDiff(diff)) {\n    const key = matchCoverageKey(path, keys, opts.projectRoot)\n    if (key === undefined) {\n      filesWithoutCoverage++\n      files.push({ path, found: false, addedLines })\n      continue\n    }\n    const result = uncoveredNewLines(coverage[key] as FileCoverage, addedLines)\n    covered += result.summary.covered\n    uncov += result.summary.uncovered\n    nonExecutable += result.summary.nonExecutable\n    for (const line of result.uncovered) uncovered.push({ path, line })\n    files.push({ path, found: true, coveragePath: key, addedLines, result })\n  }\n\n  return {\n    files,\n    uncovered,\n    summary: {\n      covered,\n      uncovered: uncov,\n      nonExecutable,\n      total: covered + uncov + nonExecutable,\n      filesWithoutCoverage,\n    },\n  }\n}\n","/**\n * Impact-scoped test runner — the live half of the coverage pillar. Runs ONLY the tests\n * a change touches (via `vitest related <changed files>`) with coverage, then feeds the\n * produced `coverage-final.json` into {@link uncoveredInDiff} to surface the new lines a\n * change introduced that no test exercised.\n *\n * Two ADR-0010 constraints shape this:\n *\n * 1. **It runs code**, so it is behind a *paired* deny-by-default operator gate — an\n *    `allowRun` boolean AND an `allowedRoots` allowlist, with a wall-clock cap. Both are\n *    operator-set (the bin reads `SACKVILLE_COVERAGE_ALLOW_RUN` / `_PROJECT_ROOTS` /\n *    `_TIMEOUT_MS`); no caller input can self-authorize a run.\n * 2. **Child-process boundary.** The repo has a single root `vitest.config.ts`, so the\n *    in-process `startVitest` API can't be used from inside the outer Vitest worker\n *    (reentrancy). The actual run is therefore an injected {@link TestRunner} that the\n *    bin wires to a `vitest` *subprocess*; the engine here owns the gate, argv, coverage\n *    collection, and diff wiring, and is unit-tested with a fake runner (no real spawn in\n *    the green gate).\n */\n\nimport { execFile } from 'node:child_process'\nimport { mkdtempSync, readFileSync } from 'node:fs'\nimport { tmpdir } from 'node:os'\nimport { join, resolve } from 'node:path'\nimport { type DiffCoverageReport, uncoveredInDiff } from './report.js'\nimport type { FileCoverage } from './uncovered.js'\n\n/** Thrown when the paired operator gate denies a run. */\nexport class CoverageGateError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = 'CoverageGateError'\n    // Brand as a gate DENIAL (ADR 0013 Addendum, milestone 5c): the run-driving\n    // `@sackville-mcp/verify` reads this global-registry symbol via `isGateDenial` to map a\n    // denial to `skipReason:'gate-not-set'` (never `errored`) WITHOUT importing engine\n    // code. The `Symbol.for` key string is the cross-package contract.\n    ;(this as unknown as Record<symbol, unknown>)[Symbol.for('sackville.gate-denial')] = true\n  }\n}\n\nexport interface RunScopedConfig {\n  /** The project to run tests in. */\n  projectRoot: string\n  /** OPERATOR allowlist of roots `runScoped` may execute in. Load-bearing even with allowRun. */\n  allowedRoots: string[]\n  /** OPERATOR opt-in to actually run tests. Deny-by-default. */\n  allowRun: boolean\n  /** Wall-clock cap (ms) passed to the runner. */\n  timeoutMs?: number\n}\n\nexport interface ScopedRunInput {\n  /** Changed source files to scope the test selection to (`vitest related`). */\n  changedFiles: string[]\n  /** Optional unified diff; when present the result includes the {@link uncoveredInDiff} report. */\n  diff?: string\n}\n\n/** Injected command runner — executes `vitest <argv>` and yields its exit status. */\nexport type TestRunner = (\n  argv: string[],\n  opts: { cwd: string; timeoutMs?: number },\n) => Promise<{ exitCode: number; stdout: string; stderr: string }>\n\nexport interface ScopedRunResult {\n  /** False when there were no changed files (the runner was not invoked). */\n  ran: boolean\n  exitCode: number\n  passed: boolean\n  scopedFiles: string[]\n  coverage: Record<string, FileCoverage>\n  coveragePath?: string\n  /** Present when a diff was supplied. */\n  report?: DiffCoverageReport\n}\n\n/** Build the `vitest related` argv: run once, scoped to the changed files, with v8 JSON coverage. */\nfunction scopedArgv(changedFiles: string[], coverageDir: string): string[] {\n  return [\n    'related',\n    ...changedFiles,\n    '--run',\n    '--coverage.enabled=true',\n    '--coverage.provider=v8',\n    '--coverage.reporter=json',\n    `--coverage.reportsDirectory=${coverageDir}`,\n  ]\n}\n\n/** Spawn a local command as a subprocess, surfacing its exit code (never rejecting on non-zero). */\nfunction spawnRunner(command: string): TestRunner {\n  return (argv, opts) =>\n    new Promise((res) => {\n      execFile(\n        command,\n        argv,\n        { cwd: opts.cwd, timeout: opts.timeoutMs, maxBuffer: 64 * 1024 * 1024 },\n        (err, stdout, stderr) => {\n          // The tool exits non-zero on a test failure — surface the code, don't reject.\n          const code =\n            err && typeof (err as { code?: unknown }).code === 'number'\n              ? (err as { code: number }).code\n              : err\n                ? 1\n                : 0\n          res({ exitCode: code, stdout: String(stdout), stderr: String(stderr) })\n        },\n      )\n    })\n}\n\n/** Default live runner: spawn the local `vitest` as a subprocess (used by the bin, not the gate). */\nexport const defaultVitestRunner: TestRunner = spawnRunner('vitest')\n\n/** Default live runner: spawn the local `pytest` as a subprocess (used by the bin, not the gate). */\nexport const defaultPytestCovRunner: TestRunner = spawnRunner('pytest')\n\n/** The paired deny-by-default operator gate (allowRun + allowlisted root). Shared by both runners. */\nexport function assertAllowed(config: RunScopedConfig): void {\n  if (!config.allowRun) {\n    throw new CoverageGateError(\n      'scoped test execution is not enabled (the operator must set allowRun)',\n    )\n  }\n  const root = resolve(config.projectRoot)\n  const allowed = config.allowedRoots.map((r) => resolve(r))\n  if (!allowed.includes(root)) {\n    throw new CoverageGateError(\n      `project root ${config.projectRoot} is not in the operator allowlist`,\n    )\n  }\n}\n\n/**\n * Run the tests related to a change, with coverage, behind the operator gate. Returns the\n * collected coverage (and, when a diff is supplied, the uncovered-new-line report). The\n * actual `vitest` invocation is the injected `runner` (default {@link defaultVitestRunner}).\n */\nexport async function runScoped(\n  config: RunScopedConfig,\n  input: ScopedRunInput,\n  deps: { runner?: TestRunner; coverageDir?: string } = {},\n): Promise<ScopedRunResult> {\n  assertAllowed(config)\n\n  if (input.changedFiles.length === 0) {\n    return { ran: false, exitCode: 0, passed: true, scopedFiles: [], coverage: {} }\n  }\n\n  const runner = deps.runner ?? defaultVitestRunner\n  const coverageDir = deps.coverageDir ?? mkdtempSync(join(tmpdir(), 'sackville-cov-'))\n  const argv = scopedArgv(input.changedFiles, coverageDir)\n\n  const { exitCode } = await runner(argv, { cwd: config.projectRoot, timeoutMs: config.timeoutMs })\n\n  const coveragePath = join(coverageDir, 'coverage-final.json')\n  let coverage: Record<string, FileCoverage>\n  try {\n    coverage = JSON.parse(readFileSync(coveragePath, 'utf8')) as Record<string, FileCoverage>\n  } catch {\n    throw new Error(\n      `scoped run did not produce a coverage report at ${coveragePath} (exit code ${exitCode})`,\n    )\n  }\n\n  const report =\n    input.diff !== undefined\n      ? uncoveredInDiff(input.diff, coverage, { projectRoot: config.projectRoot })\n      : undefined\n\n  return {\n    ran: true,\n    exitCode,\n    passed: exitCode === 0,\n    scopedFiles: input.changedFiles,\n    coverage,\n    coveragePath,\n    report,\n  }\n}\n","/**\n * Python impact-scoped coverage runner (ADR 0010 addendum) — the coverage.py sibling of\n * {@link runScoped}. Runs `pytest --cov=<target> --cov-report=json` scoped to the tests a change\n * touched, converts the report via the shipped {@link coveragePyToIstanbul} (unchanged), and feeds\n * {@link uncoveredInDiff} (unchanged) to surface the new lines no test exercised.\n *\n * Two coverage.py / pytest specifics drive the design:\n *\n * 1. **No `vitest related`.** pytest has no built-in changed-files test selection, so we derive a\n *    scope with {@link selectPytestScope}: a changed TEST file is a selector directly; a changed\n *    SOURCE file maps to a mirrored test (`test_<x>.py` / `tests/test_<x>.py`) when one exists. When\n *    a changed source maps to NO confident test, the ratified fallback is operator-visible:\n *    `report-gap` (default — run the matched tests, report the unmatched source as a coverage gap)\n *    or `widen` (run the whole suite). testmon is intentionally NOT used (a stale `.testmondata`\n *    silently deselects tests → false clean, violating absence-is-never-a-pass).\n *\n * 2. **pytest exit codes are not vitest's.** Exit 5 (no tests collected), 2/3/4 (usage/internal) are\n *    NOT a clean pass — they map to `inconclusive`, and the run never produces a (misleading) clean\n *    report. Only 0 (passed) / 1 (tests failed) carry a real result.\n *\n * The `pytest`/coverage.py invocation is the injected {@link TestRunner}; no real spawn in the gate.\n */\n\nimport { existsSync, mkdtempSync, readFileSync } from 'node:fs'\nimport { tmpdir } from 'node:os'\nimport { basename, join } from 'node:path'\nimport { type CoveragePyReport, coveragePyToIstanbul } from './coveragepy.js'\nimport { uncoveredInDiff } from './report.js'\nimport {\n  assertAllowed,\n  defaultPytestCovRunner,\n  type RunScopedConfig,\n  type ScopedRunInput,\n  type ScopedRunResult,\n  type TestRunner,\n} from './run.js'\nimport type { FileCoverage } from './uncovered.js'\n\n/** Fallback when a changed source file maps to no confident test (operator-visible, ADR 0010 addendum). */\nexport type ScopeMode = 'report-gap' | 'widen'\n\nexport interface ScopedPythonInput extends ScopedRunInput {\n  /** coverage.py measurement targets (`--cov=<target>`). Required — coverage.py needs explicit scope. */\n  measureTargets: string[]\n  /** Fallback when a changed source maps to no test. Default `report-gap`. */\n  scopeMode?: ScopeMode\n}\n\nexport interface ScopedPythonResult extends ScopedRunResult {\n  /** pytest produced a non-test-result exit (no tests collected / usage / internal) ⇒ not a pass. */\n  inconclusive?: boolean\n  /** Changed source files with no confident mirrored test — the coverage gap (never a silent pass). */\n  unmatched?: string[]\n  /** True when the no-test fallback widened the run to the whole suite. */\n  widened?: boolean\n}\n\n/** A pytest test selection derived from a change. */\nexport interface PytestScope {\n  /** pytest positional test targets (files). Empty ⇒ run the whole suite. */\n  selectors: string[]\n  /** Changed source files with no confident mirrored test. */\n  unmatched: string[]\n  /** True when the run was widened to the whole suite (the `widen` fallback). */\n  widened: boolean\n}\n\nconst TEST_FILE = /(?:^|\\/)(?:test_[^/]+|[^/]+_test)\\.py$/\nconst IN_TEST_DIR = /(?:^|\\/)tests?\\//\n\nfunction isTestFile(path: string): boolean {\n  return TEST_FILE.test(path) || (IN_TEST_DIR.test(path) && path.endsWith('.py'))\n}\n\n/** Candidate mirrored-test paths for a changed source file (same dir + a `tests/` sibling). */\nfunction mirroredTestCandidates(srcPath: string): string[] {\n  if (!srcPath.endsWith('.py')) return []\n  const slash = srcPath.lastIndexOf('/')\n  const dir = slash === -1 ? '' : srcPath.slice(0, slash + 1)\n  const stem = basename(srcPath).slice(0, -'.py'.length)\n  return [\n    `${dir}test_${stem}.py`,\n    `${dir}${stem}_test.py`,\n    `${dir}tests/test_${stem}.py`,\n    `tests/test_${stem}.py`,\n  ]\n}\n\n/**\n * Derive a pytest test scope from the changed files. A changed test file is a selector; a changed\n * source file maps to its mirrored test when `testExists` confirms one. A source with no test is\n * `unmatched`; the `mode` decides whether that widens to the whole suite (`widen`) or is reported\n * as a gap while the matched tests still run (`report-gap`). Pure (FS access via `testExists`).\n */\nexport function selectPytestScope(\n  changedFiles: string[],\n  mode: ScopeMode,\n  testExists: (path: string) => boolean,\n): PytestScope {\n  const selectors = new Set<string>()\n  const unmatched: string[] = []\n  for (const file of changedFiles) {\n    if (isTestFile(file)) {\n      selectors.add(file)\n      continue\n    }\n    if (!file.endsWith('.py')) continue // a non-Python change can't be coverage-scoped\n    const found = mirroredTestCandidates(file).filter(testExists)\n    if (found.length > 0) for (const t of found) selectors.add(t)\n    else unmatched.push(file)\n  }\n  if (unmatched.length > 0 && mode === 'widen') {\n    return { selectors: [], unmatched, widened: true }\n  }\n  return { selectors: [...selectors], unmatched, widened: false }\n}\n\n/** Build the `pytest --cov` argv with a JSON report at `jsonPath` and the selected test targets. */\nfunction pytestArgv(measureTargets: string[], selectors: string[], jsonPath: string): string[] {\n  return [...measureTargets.map((t) => `--cov=${t}`), `--cov-report=json:${jsonPath}`, ...selectors]\n}\n\n/** A pytest exit code that is NOT a test result (no tests collected / usage / internal). */\nfunction isInconclusiveExit(exitCode: number): boolean {\n  return exitCode === 2 || exitCode === 3 || exitCode === 4 || exitCode === 5\n}\n\n/**\n * Run the pytest tests related to a change, with coverage.py, behind the operator gate. Returns the\n * converted coverage (and, when a diff is supplied, the uncovered-new-line report). The actual\n * `pytest` invocation is the injected `runner` (default {@link defaultPytestCovRunner}).\n */\nexport async function runScopedPython(\n  config: RunScopedConfig,\n  input: ScopedPythonInput,\n  deps: {\n    runner?: TestRunner\n    coverageDir?: string\n    /** Existence check for mirrored tests (FS by default; injected in tests). */\n    testExists?: (path: string) => boolean\n  } = {},\n): Promise<ScopedPythonResult> {\n  assertAllowed(config)\n\n  if (input.changedFiles.length === 0) {\n    return { ran: false, exitCode: 0, passed: true, scopedFiles: [], coverage: {} }\n  }\n\n  const mode = input.scopeMode ?? 'report-gap'\n  const testExists = deps.testExists ?? ((p: string) => existsSync(join(config.projectRoot, p)))\n  const scope = selectPytestScope(input.changedFiles, mode, testExists)\n\n  // Nothing Python to run (e.g. only non-.py files changed, and nothing widened): a no-op.\n  if (scope.selectors.length === 0 && !scope.widened && scope.unmatched.length === 0) {\n    return { ran: false, exitCode: 0, passed: true, scopedFiles: [], coverage: {} }\n  }\n\n  const runner = deps.runner ?? defaultPytestCovRunner\n  const coverageDir = deps.coverageDir ?? mkdtempSync(join(tmpdir(), 'sackville-cov-py-'))\n  const jsonPath = join(coverageDir, 'coverage.json')\n  const argv = pytestArgv(input.measureTargets, scope.selectors, jsonPath)\n\n  const { exitCode } = await runner(argv, { cwd: config.projectRoot, timeoutMs: config.timeoutMs })\n  const inconclusive = isInconclusiveExit(exitCode)\n\n  let coverage: Record<string, FileCoverage> = {}\n  try {\n    const report = JSON.parse(readFileSync(jsonPath, 'utf8')) as CoveragePyReport\n    coverage = coveragePyToIstanbul(report)\n  } catch {\n    // A genuine run (passed/failed) must produce a report; an inconclusive exit may not.\n    if (!inconclusive) {\n      throw new Error(\n        `scoped pytest run did not produce a coverage report at ${jsonPath} (exit code ${exitCode})`,\n      )\n    }\n  }\n\n  // Never produce a (misleading) clean report from an inconclusive run.\n  const report =\n    input.diff !== undefined && !inconclusive && Object.keys(coverage).length > 0\n      ? uncoveredInDiff(input.diff, coverage, { projectRoot: config.projectRoot })\n      : undefined\n\n  return {\n    ran: true,\n    exitCode,\n    passed: exitCode === 0,\n    inconclusive: inconclusive || undefined,\n    scopedFiles: input.changedFiles,\n    unmatched: scope.unmatched.length > 0 ? scope.unmatched : undefined,\n    widened: scope.widened || undefined,\n    coverage,\n    coveragePath: jsonPath,\n    report,\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@sackville-mcp/coverage",
+  "version": "0.0.1-alpha.0",
+  "type": "module",
+  "license": "Apache-2.0",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
+    }
+  },
+  "main": "./dist/index.mjs",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@sackville-mcp/diff": "0.0.1-alpha.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ceautery/sackville.git",
+    "directory": "packages/coverage"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --dts",
+    "typecheck": "tsc --noEmit"
+  }
+}