tewip-ai 0.69.1 → 0.69.3

package/dist/engine/review/coverage.js

@@ -69,6 +69,15 @@ export function testFiles(root, limit = 4000) {
  * pull request; saying "nothing tests ROADMAP.md" is noise, and noise is how a review gets skipped.
  */
 export const isCode = (file) => /\.(?:[cm]?[jt]sx?|py|rb|go|java|kt|cs|php|rs|vue|svelte|scala|swift|sql)$/i.test(file) && !/(?:^|[\/])(?:package-lock\.json|yarn\.lock)$/i.test(file);
+/**
+ * Code a test could be expected to cover - which a test file and a declaration file are not.
+ *
+ * A changed test file is its own test, and a review that lists `fix-data.test.ts` as covering
+ * `extension.test.ts` is saying nothing. A `.d.ts` has no behaviour at all: `version-compare.d.ts`
+ * was matched to `perf.test.ts` because both contain the words "version" and "compare", and the
+ * match was not wrong by the rule - the file simply should never have been asked about.
+ */
+export const isCoverableCode = (file) => isCode(file) && !TEST_FILE.test(file) && !/\.d\.[cm]?ts$/i.test(file);
 /** The module names a file can be imported by: its path, its name, and its folder's front door. */
 export function importNames(root, changed) {
     const full = resolve(root, changed);
@@ -132,12 +141,35 @@ export function importsIt(source, names) {
 }
 const words = (text) => (text.toLowerCase().match(/[a-z][a-z0-9]{2,}/g) ?? []).filter((w) => !STOP.has(w));
 const STOP = new Set(['src', 'lib', 'app', 'test', 'tests', 'spec', 'index', 'main', 'the', 'and', 'for', 'com', 'org', 'utils', 'util', 'js', 'ts', 'py']);
+/**
+ * A word that most test files contain is not evidence about any of them.
+ *
+ * Found by reading what `review` said about a real change to `extensions/vscode/engine-version.js`:
+ * **eleven** test files were listed as covering it - `a2a`, `junit`, `perf`, `schema`, `write`,
+ * `web-scan` - none of which has anything to do with the extension. Two shared words were required
+ * and two were always found: *engine*, because every test lives in `engine/test/`, and *version*,
+ * because fixtures everywhere say `schemaVersion: 1`. Both are structural noise. Fourteen of the
+ * fifteen tests in that section were guesses and eleven were the same wrong guess, in the headline
+ * section of the command - and a section that is mostly noise is a section a reviewer learns to skip.
+ *
+ * So a word is only evidence if it is rare across the test corpus, which is the rule `recall`
+ * already uses on error text. A quarter is generous: 'engine' was in 100% of them.
+ */
+const NOISE_SHARE = 0.25;
+function informative(byTest) {
+    const seen = new Map();
+    for (const bag of byTest.values())
+        for (const word of bag)
+            seen.set(word, (seen.get(word) ?? 0) + 1);
+    const limit = Math.max(2, Math.floor(byTest.size * NOISE_SHARE));
+    return (word) => (seen.get(word) ?? 0) <= limit;
+}
 /**
  * The tests that reach a set of changed files. Imports first; then, for changed files nothing
  * imports, the tests whose words overlap - marked as a guess.
  */
 export function coverageFor(root, changedAll, tests = testFiles(root)) {
-    const changed = changedAll.filter(isCode);
+    const changed = changedAll.filter(isCoverableCode);
     const sources = new Map();
     const read = (file) => {
         if (!sources.has(file)) {
@@ -181,18 +213,31 @@ export function coverageFor(root, changedAll, tests = testFiles(root)) {
     }
     // Only for the changed files nothing imports: the words, which is a weaker kind of knowing.
     const orphans = changed.filter((f) => !coveredByImport.has(f));
-    for (const file of orphans) {
-        const wanted = new Set(words(file));
-        if (wanted.size === 0)
-            continue;
+    if (orphans.length > 0) {
+        const bags = new Map();
         for (const test of tests) {
             const rel = relative(root, test).split(sep).join('/');
-            if (byTest.has(rel))
-                continue;
-            const shared = words(`${rel} ${read(test).slice(0, 4000)}`).filter((w) => wanted.has(w));
-            if (new Set(shared).size < 2)
+            bags.set(rel, new Set(words(`${rel} ${read(test).slice(0, 4000)}`)));
+        }
+        const isRare = informative(bags);
+        for (const file of orphans) {
+            // The file's own name, not its folders. A test that matches only on the directory a change
+            // happens to live in knows nothing about the change.
+            const named = new Set(words(basename(file)).filter(isRare));
+            if (named.size === 0)
                 continue;
-            add(test, file, 'name');
+            const wanted = new Set(words(file).filter(isRare));
+            for (const test of tests) {
+                const rel = relative(root, test).split(sep).join('/');
+                if (byTest.has(rel))
+                    continue;
+                const bag = bags.get(rel) ?? new Set();
+                const shared = new Set([...wanted].filter((w) => bag.has(w)));
+                // Two rare words, and at least one of them from the changed file's own name.
+                if (shared.size < 2 || ![...named].some((w) => shared.has(w)))
+                    continue;
+                add(test, file, 'name');
+            }
         }
     }
     // Direct imports first, then the package ones - and inside each group the test whose words match
@@ -204,8 +249,15 @@ export function coverageFor(root, changedAll, tests = testFiles(root)) {
     return [...byTest.values()].sort((a, b) => RANK[a.how] - RANK[b.how] || overlap(b) - overlap(a) || b.covers.length - a.covers.length);
 }
 const RANK = { imports: 0, package: 1, name: 2 };
-/** Changed files that no test reaches at all: the part of a change nobody will notice breaking. */
+/**
+ * Changed files that no test reaches at all: the part of a change nobody will notice breaking.
+ *
+ * The same rule as the coverage search, and for the same reason. "`version-compare.d.ts` has no
+ * test that imports it. A mistake there would reach production unnoticed" is a sentence about a
+ * file that declares types and executes nothing - a demand the reader cannot act on, in the section
+ * meant to name the real risk of the change.
+ */
 export function uncovered(changed, coverage) {
     const reached = new Set(coverage.flatMap((c) => c.covers));
-    return changed.filter((f) => isCode(f) && !reached.has(f) && !TEST_FILE.test(f));
+    return changed.filter((f) => isCoverableCode(f) && !reached.has(f));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tewip-ai",
-  "version": "0.69.1",
+  "version": "0.69.3",
   "mcpName": "io.github.hmamut39/tewip",
   "description": "Tewip finds why each failing test failed - real bug, flaky test, environment, test data or changed selector - for any stack, from the command line, CI, or your editor.",
   "keywords": [