tewip-ai 0.16.0 → 0.16.2

package/README.md

@@ -14,7 +14,23 @@ It works for every stack: Node.js (node:test, Jest, Vitest, Mocha), Python (pyte
 
 Formerly *triage-agent*: the repository moved to `hmamut39/tewip`, and GitHub redirects the old address. See [ROADMAP.md](ROADMAP.md) for the plan.
 
-**Status: phases 1 to 4 are built, Phase 5 (auto-fix) is in progress, and phases 6 and 7 (test plans and verified test writing) are built.** Those phases are collection, rule-based diagnosis, LLM diagnosis with a real-data eval, multi-role views, and planning and writing tests in the project's own framework. It runs live in GitHub CI and answers questions from AI assistants through MCP. On fresh real Gutenberg CI failures, with the pipeline frozen before labelling, accuracy is 93.4%; the caveats are in [eval/README.md](eval/README.md).
+**Status: phases 1 to 14 are built; the two auto-fix phases (5 and 8) are the ones still in progress.** Tewip collects failures from any framework, diagnoses them with rules first and a model only for what rules cannot settle, and turns that into work for each role: a CI comment and merge gate, test plans and verified tests, a flake dossier, a PR-risk review, security scanning, tickets in Jira, Rally, GitHub Issues, Azure Boards or Linear, checks generated from a Figma design, specifications written for people, and - opt in, and only when proved - fixes to test or application code. It runs live in GitHub CI and answers questions from AI assistants through MCP. On fresh real Gutenberg CI failures, with the pipeline frozen before labelling, accuracy is 93.4%; across six real datasets it ranges from 86.1% to 99.7%, and the caveats are in [eval/README.md](eval/README.md).
+
+## What it costs
+
+Most failures never reach a model. On 3,556 real CI failures from six public projects, the
+deterministic rules answered **75.1%** on their own - and on the labelled ones they answered
+correctly **1,979 times out of 2,012 (98.4%)**. A rule-answered failure costs nothing, explains
+itself, and gives the same answer every time.
+
+Only the remaining quarter is sent to a model, so triaging **1,000 real failures costs about
+$1.12** at gpt-5.4-mini's published price. That is measured, not estimated: three real uncached
+calls on held-out failures billed 3,624 prompt and 499 completion tokens each. A real week costs
+less, because a failure that repeats is answered from cache, and a failure someone has corrected
+never goes to the model again.
+
+Tewip prints what every command costs, caps its own spend, and works with no key at all - the rules
+run on their own and everything they cannot settle is left as UNKNOWN rather than guessed.
 
 ## Use it in your project
 

package/dist/engine/autofix/data-site.js

@@ -0,0 +1,58 @@
+/** The line is checking the value rather than creating anything with it. */
+const ASSERTING = /\bexpect\s*\(|\.\s*should\s*\(|\bassert(?:Equals?|That|ion)?\b|\btoBe\w*\s*\(|\bto(?:Have|Contain)\w*\s*\(/;
+/**
+ * The line is making or sending something: this is data, and making it unique is the fix.
+ * The object-property form matters most and was missing at first - real test data is written
+ * `name: "Secondi"` and `employee_name="Nguyen Van A"` far more often than it is assigned to its
+ * own variable, so without it four real creation sites were misread as assertions.
+ */
+const CREATING = /\b(?:const|let|var)\s+[\w$]+\s*=|[\w$]+\s*[:=]\s*['"`]|\b(?:create|insert|add|register|signup|signUp|post|put|save|seed|make|new)\w*\s*\(|\.\s*(?:fill|type|values|send)\s*\(/;
+/**
+ * The value is naming an element, not creating a record. `getByRole('button', { name: 'Submit' })`
+ * reads exactly like an object property to the pattern above, and rewriting it would point the test
+ * at an element that does not exist - breaking the test rather than fixing the collision. A unit
+ * test caught this before any real data did.
+ */
+const A_SELECTOR = /\bgetBy\w+\s*\(|\bfindBy\w+\s*\(|\blocator\s*\(|\bcy\.get\s*\(|querySelector|\bBy\.\w+\s*\(|\bselector\b/i;
+/**
+ * Picks the one occurrence it is safe to make unique, given the whole file.
+ */
+export function chooseDataSite(source, sites, value) {
+    const asserting = sites.filter((s) => ASSERTING.test(lineOf(source, s)));
+    const creating = sites.filter((s) => {
+        const line = lineOf(source, s);
+        return CREATING.test(line) && !ASSERTING.test(line) && !A_SELECTOR.test(line);
+    });
+    if (creating.length === 0) {
+        return {
+            site: null,
+            reason: 'value-only-asserted',
+            why: sites.length === 1
+                ? `"${value}" appears only in ${lineOf(source, sites[0]).trim().slice(0, 60)}, where the test is checking it rather than creating anything. Making that unique would change what the test asserts instead of fixing the collision.`
+                : `"${value}" is written ${sites.length} times in the test and none of them creates anything: they are assertions or arguments Tewip cannot tell apart. A person should decide which one is the data.`,
+        };
+    }
+    if (creating.length > 1) {
+        return {
+            site: null,
+            reason: 'value-ambiguous',
+            why: `"${value}" is created in ${creating.length} places (lines ${creating.map((s) => s.line).join(', ')}). Making only one unique would break the link between them, so this needs a person.`,
+        };
+    }
+    if (asserting.length > 0) {
+        // The commonest real shape of all: `name: "Secondi"` on one line and
+        // `expect(body.data.name).toBe("Secondi")` a few lines down. Making the data unique without
+        // rewriting the assertion turns a flaky test into a failing one, and rewriting both is a bigger
+        // change than this fix is allowed to make.
+        return {
+            site: null,
+            reason: 'value-also-asserted',
+            why: `"${value}" is created on line ${creating[0].line} and also checked on line ${asserting[0].line}. Making the data unique would leave the assertion looking for the old value, so the two have to change together - which is a person's call, not this fix's.`,
+        };
+    }
+    return {
+        site: creating[0],
+        why: sites.length === 1 ? `"${value}" is written once in the test, where the record is created` : `"${value}" is written ${sites.length} times; line ${creating[0].line} is the one that creates the record`,
+    };
+}
+const lineOf = (source, site) => source.split('\n')[site.line - 1] ?? '';

package/dist/engine/autofix/fix-data.js

@@ -8,6 +8,7 @@
 // Same sandbox as the other fixes: test files only, never application code, and the file goes back
 // exactly as it was unless a candidate is accepted.
 import { relative, resolve, sep } from 'node:path';
+import { chooseDataSite } from './data-site.js';
 import { applyDataFix, collision, dataFixCandidates, findLiteral, languageOf } from './data.js';
 /** Two passes in a row: the second run is what proves the value is really unique. */
 export const REQUIRED_PASSES = 2;
@@ -34,7 +35,13 @@ export async function attemptDataFix({ record, diagnosis, action, specFile }, de
     const sites = findLiteral(source, found.value);
     if (sites.length === 0)
         return stop('value-not-in-test', `"${found.value}" is not written in ${specFile}: it comes from a fixture or a factory, which a person should make unique`);
-    const site = sites[0];
+    // Not simply the first occurrence: a colliding value is often also a value the test checks, and
+    // rewriting that would change what the test asserts while leaving the collision in place.
+    const choice = chooseDataSite(source, sites, found.value);
+    if (!choice.site)
+        return stop(choice.reason, `refused: ${choice.why}`);
+    const site = choice.site;
+    result.log.push(choice.why);
     result.line = site.line;
     result.original = site.text;
     const candidates = dataFixCandidates(found.value, languageOf(specFile));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tewip-ai",
-  "version": "0.16.0",
+  "version": "0.16.2",
   "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": [
     "test-failures",