tewip-ai 0.69.6 → 0.69.8

package/dist/engine/access/access-command.js

@@ -12,6 +12,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { normalise } from '../quality/source-text.js';
 import { dirname, join, relative, resolve } from 'node:path';
 import { sourceFiles } from '../secure/secrets.js';
+import { readHandWritten } from '../../reporters/store.js';
 import { JS_LIKE, MARKUP, tags } from './markup.js';
 import { checkFile } from './checks.js';
 import { readAxeReport } from './reports.js';
@@ -27,7 +28,7 @@ export function readAccepted(root) {
     const file = join(root, '.tewip', 'access-accepted.txt');
     if (!existsSync(file))
         return new Set();
-    return new Set(readFileSync(file, 'utf8')
+    return new Set(readHandWritten(file)
         .split('\n')
         .map((l) => l.split(' - ')[0].trim())
         .filter((l) => l !== '' && !l.startsWith('#')));

package/dist/engine/secure/triage.js

@@ -15,12 +15,13 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { readHandWritten } from '../../reporters/store.js';
 /** Findings a person has already judged, one per line: "<kind> <where> - reason". */
 export function readAccepted(root) {
     const file = join(root, '.tewip', 'security-accepted.txt');
     if (!existsSync(file))
         return new Set();
-    return new Set(readFileSync(file, 'utf8')
+    return new Set(readHandWritten(file)
         .split('\n')
         .map((l) => l.split(' - ')[0].trim())
         .filter(Boolean));

package/dist/engine/standards/standards-command.js

@@ -78,11 +78,21 @@ export function renderStandards(standards, violations, checkedFiles) {
         ].join(String.fromCharCode(10));
     }
     const checkable = standards.filter((s) => s.rules.length > 0);
-    const guidanceOnly = standards.filter((s) => s.rules.length === 0 && s.guidance.trim());
+    // Every standard that carries prose, not only the ones carrying nothing else.
+    //
+    // This was `s.rules.length === 0 && s.guidance.trim()`, so a standard written in the shape the
+    // feature is documented with - front matter rules, then prose below them - had its prose
+    // **invisible in this report**. Found by writing this project's own house rules in exactly that
+    // shape: four rules were listed as enforced and three paragraphs of guidance were never mentioned,
+    // under a closing line promising "everything else is prose Tewip carries for you". The other
+    // renderer, `renderViolations`, gets this right but only prints when something is broken - so a
+    // team doing it properly and keeping to its own rules is never told its guidance was read at all.
+    const carrying = standards.filter((s) => s.guidance.trim().length > 0);
+    const guidanceOnly = carrying.filter((s) => s.rules.length === 0);
     const lines = [
         '# What this project has taught Tewip',
         '',
-        `${standards.length} standard(s) loaded: ${checkable.length} with rules Tewip can check, ${guidanceOnly.length} guidance only.`,
+        `${standards.length} standard(s) loaded: ${checkable.length} with rules Tewip can check, ${carrying.length} carrying guidance it cannot${guidanceOnly.length > 0 ? ` (${guidanceOnly.length} guidance only)` : ''}.`,
         ...(checkedFiles > 0 ? ['', `${checkedFiles} changed file(s) checked. **${violations.length}** broke a rule.`] : []),
         '',
         '## Checked and enforced',
@@ -97,8 +107,12 @@ export function renderStandards(standards, violations, checkedFiles) {
         }
     }
     lines.push('');
-    if (guidanceOnly.length > 0) {
-        lines.push('## Carried, but not checked', '', 'Tewip passes these to the model when it writes or fixes something, and quotes them in reports. It', 'cannot verify them, and it will never report them as kept.', '', ...guidanceOnly.map((s) => `- **${s.name}**${s.description ? ` — ${s.description}` : ''}`), '');
+    if (carrying.length > 0) {
+        lines.push('## Carried, but not checked', '', 'Tewip passes these to the model when it writes or fixes something, and quotes them in reports. It', 'cannot verify them, and it will never report them as kept.', '', ...carrying.map((s) => {
+            const words = s.guidance.trim().split(/\s+/).length;
+            const also = s.rules.length > 0 ? ` (alongside its ${s.rules.length} enforced rule${s.rules.length === 1 ? '' : 's'})` : '';
+            return `- **${s.name}**${s.description ? ` — ${s.description}` : ''}: ${words} word(s) of guidance${also}`;
+        }), '');
     }
     const unusable = standards.filter((s) => s.unusable);
     if (unusable.length > 0) {

package/dist/engine/standards/standards.js

@@ -6,8 +6,16 @@
  * unusable rather than silently ignored - a rule nobody is enforcing is worse than no rule, because
  * somebody believes in it.
  */
-export function readStandard(file, text) {
+export function readStandard(file, rawText) {
     const name = file.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? file;
+    // A leading byte-order mark, which Notepad, Visual Studio and PowerShell's `Set-Content -Encoding
+    // utf8` all write by default on Windows. Three invisible bytes before `---` stop the front matter
+    // matching, so **every enforced rule in the file silently becomes prose** and the report says
+    // "0 with rules Tewip can check" without once mentioning why. Found by accident: this project's own
+    // standards file was rewritten by a PowerShell command and four working rules stopped being
+    // enforced with no error anywhere. For a team on Windows that is total, silent rule loss - the
+    // exact thing `unusable` exists to prevent, happening in the one place it could not report.
+    const text = rawText.replace(/^/, '');
     const front = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text);
     const body = front ? text.slice(front[0].length).trim() : text.trim();
     const standard = { name, description: '', appliesTo: [], rules: [], guidance: body, unusable: '' };
@@ -40,7 +48,12 @@ export function readStandard(file, text) {
         standard.description = firstLine(body);
     return standard;
 }
-/** `forbid: /waitForTimeout/ in tests because a fixed wait hides a race` */
+/**
+ * `forbid: /waitForTimeout/ in tests because a fixed wait hides a race`
+ *
+ * The `in` clause may carry an exception: `in engine/ not -command.ts`. Everything before `not` is
+ * where the rule applies, everything after it is where it does not.
+ */
 function parseRule(kind, value, scope) {
     const shape = /^\/(.+?)\/([a-z]*)\s*(?:\bin\s+([^]*?))?\s*(?:\bbecause\s+([^]*))?$/i.exec(value.trim());
     if (!shape)
@@ -51,10 +64,12 @@ function parseRule(kind, value, scope) {
     catch {
         return null;
     }
+    const [inside, outside] = (shape[3] ?? '').split(/\bnot\b/);
     return {
         kind,
         pattern: shape[2] ? `/${shape[1]}/${shape[2]}` : shape[1],
-        where: shape[3] ? list(shape[3]) : scope,
+        where: inside && inside.trim() ? list(inside) : scope,
+        except: outside ? list(outside) : [],
         because: (shape[4] ?? '').trim(),
     };
 }
@@ -92,7 +107,11 @@ export function check(standards, file, text) {
         if (!covers(standard.appliesTo, file))
             continue;
         for (const rule of standard.rules) {
-            if (!covers(rule.where, file))
+            // `covers([])` is deliberately true - an empty scope means everything - so an exception has to
+            // be checked for existence first. Written the short way, `|| covers(rule.except, file)`, every
+            // rule with no exception is skipped and the report says nothing broke: a clean answer produced
+            // by a bug, which is the exact shape this project keeps finding.
+            if (!covers(rule.where, file) || (rule.except.length > 0 && covers(rule.except, file)))
                 continue;
             let pattern;
             try {

package/dist/engine/trace/trace.js

@@ -21,20 +21,44 @@ export function testFor(scenario, attempted) {
     const id = clean(scenario.id);
     return id.length >= 4 ? (attempted.find((t) => clean(t).includes(id)) ?? '') : '';
 }
+/**
+ * Why no test could be named - and what that does and does not establish.
+ *
+ * "no test in this project can be named for it, so nothing is checking it" was printed whatever the
+ * reason, including when **no run had been kept here at all**. Field-tested on this repository, which
+ * has 1,095 passing tests and a kept history belonging to a different project: all twelve scenarios
+ * of a real plan came back "nothing is checking it". Tewip was not looking at this project's tests,
+ * because it only ever sees the tests a kept run names, and it said so as though it had looked.
+ *
+ * The distinction matters because the two cases call for opposite actions: write a test, or keep
+ * your runs so the ones you have can be seen.
+ */
+function notCoveredBecause(runs, knownTests) {
+    if (runs.length === 0) {
+        return 'no run has been kept for this project, so Tewip has no list of its tests to match against - this is not a claim that nothing checks it. Run `tewip explain <report>` once and ask again';
+    }
+    return `no test among the ${knownTests} that the ${runs.length} kept run(s) name matches it, so nothing Tewip can see is checking it`;
+}
 /** Joins one plan to what the runs actually say. Nothing here is inferred from anything else. */
 export function tracePlan(plan, runs, records) {
     const newest = runs.at(-1);
     const attempted = newest ? Object.keys(newest.attempts ?? {}) : [];
     const everAttempted = new Set(runs.flatMap((r) => Object.keys(r.attempts ?? {})));
+    // A scenario's own id was matched against the **newest run only**, so a test that ran last week
+    // and not today could not be found at all - and the answer for it was "no test in this project can
+    // be named for it, so nothing is checking it", which is a different and much stronger claim than
+    // "it did not run today". The branch below that exists to say exactly that ("ran before but not in
+    // the last run") was unreachable for every scenario the plan did not name a test for.
+    const everyTest = [...everAttempted];
     const failures = new Map();
     for (const record of records)
         if (record.runId === newest?.runId)
             failures.set(record.testId, record);
     const scenarios = plan.scenarios.map((scenario) => {
-        const test = testFor(scenario, attempted);
+        const test = testFor(scenario, everyTest);
         const base = { id: scenario.id, title: scenario.title, priority: scenario.priority ?? '', test, runId: newest?.runId ?? '', when: newest?.finishedAt ?? '' };
         if (!test) {
-            return { ...base, standing: 'not-covered', diagnosis: '', why: 'no test in this project can be named for it, so nothing is checking it' };
+            return { ...base, standing: 'not-covered', diagnosis: '', why: notCoveredBecause(runs, everAttempted.size) };
         }
         if (!everAttempted.has(test)) {
             return { ...base, standing: 'never-run', runId: '', when: '', diagnosis: '', why: `${test} is named as the cover, but no run kept here has attempted it` };

package/dist/reporters/store.js

@@ -7,6 +7,19 @@ export const DATA_DIR = join(PROJECT_ROOT, 'data');
 const COLLECT_DIR = process.env.TRIAGE_DATA_DIR ? resolve(PROJECT_ROOT, process.env.TRIAGE_DATA_DIR) : DATA_DIR;
 export const TRIAGE_FILE = join(COLLECT_DIR, 'triage.jsonl');
 export const RUNS_FILE = join(COLLECT_DIR, 'runs.jsonl');
+/**
+ * A file a person wrote, read as text, without the byte-order mark Windows editors put in front.
+ *
+ * Notepad, Visual Studio and PowerShell's `Set-Content -Encoding utf8` all write three invisible
+ * bytes before the first character. Nothing downstream expects them: a standards file stops being
+ * enforced because `/^---/` no longer matches, and the first line of an accepted-findings list stops
+ * matching the finding it was written to accept - so a judged finding comes back and keeps coming
+ * back, with nothing anywhere saying why. Every file this project reads **because a person wrote it
+ * by hand** goes through here.
+ */
+export function readHandWritten(file) {
+    return readFileSync(file, 'utf8').replace(/^\uFEFF/, '');
+}
 export function appendJsonl(file, rows) {
     if (rows.length === 0)
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tewip-ai",
-  "version": "0.69.6",
+  "version": "0.69.8",
   "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": [