tewip-ai 0.56.0 → 0.58.0

package/dist/engine/schema/dialect-rules.js

@@ -46,11 +46,16 @@ const DJANGO = [
         instead: 'for a large table, work in batches with atomic = False on the migration and make it resumable. For a small one this is fine - Tewip cannot see how many rows there are',
     },
     {
-        find: /AddIndex\(|AddConstraint\(/i,
+        // The model is named, for two reasons. A finding that says "adds an index or constraint" without
+        // saying to what is most of the way to useless, and `createdHere` - which stops an index on a
+        // table created moments earlier from counting as a lock - matches on the table name, so with no
+        // name it could never suppress anything here. Django writes it `AddIndex(model_name="order", ...)`.
+        find: /(?:AddIndex|AddConstraint)\s*\([\s\S]{0,120}?model_name\s*=\s*["']([\w]+)["']/i,
         unless: /AddIndexConcurrently|AddConstraintNotValid|atomic\s*=\s*False/,
         risk: 'locks-writes',
-        what: () => 'adds an index or constraint, which Django builds with a lock unless told otherwise',
+        what: (m) => `adds an index or constraint to ${m[1]}, which Django builds with a lock unless told otherwise`,
         instead: 'AddIndexConcurrently / AddConstraintNotValid from django.contrib.postgres.operations, with atomic = False on the migration',
+        table: (m) => m[1],
     },
 ];
 /** Rails migrations. */

package/dist/engine/schema/migration-files.js

@@ -4,7 +4,8 @@
 // across a whole checkout rather than across a diff and that file went past the 300-line rule.
 // Keeping it in one place is the point: the alternative was a copy of these patterns in a script,
 // and two definitions of "is this a migration" drift the moment one of them is fixed.
-import { readdirSync, statSync } from 'node:fs';
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { dialectOf } from './frameworks.js';
 import { join, relative } from 'node:path';
 // A directory called `migration/` says what is probably in it, not what every file in it is. This
 // matched *anything* underneath one, so Keycloak's `docs/guides/migration/index.adoc` and its 113
@@ -70,8 +71,29 @@ export function migrationsUnder(root, limit = 20_000) {
                 continue;
             }
             const rel = relative(root, full).replaceAll(String.fromCharCode(92), '/');
-            if (SCHEMA_FILE.test(rel) || MIGRATION.test(rel) || NAMED_MIGRATION.test(rel))
-                found.push(rel);
+            if (!SCHEMA_FILE.test(rel) && !MIGRATION.test(rel) && !NAMED_MIGRATION.test(rel))
+                continue;
+            // And it has to look like one inside. Phase 44 stopped a directory called `migration/` from
+            // claiming every file under it by extension; discourse shows that was not enough. `lib/migration/
+            // helpers.rb` is a library module, `table_dropper.rb` is a class, and
+            // `migrations/converters/config/locales/migrations.en.yml` is a locale file - all three were
+            // selected, none could be read, and all three were reported as migrations Tewip could not read.
+            // 550 of discourse's 3,095, which is a "could not read" list that is mostly library code.
+            //
+            // `dialectOf` is the one definition of what a migration is written in, so it decides here too:
+            // a file whose dialect is unknown is not an unreadable migration, it is not a migration.
+            if (info.size > 2_000_000)
+                continue;
+            let text = '';
+            try {
+                text = readFileSync(full, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            if (dialectOf(rel, text) === 'unknown')
+                continue;
+            found.push(rel);
         }
     };
     walk(root, 0);

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

@@ -46,6 +46,11 @@ function createdHere(text) {
     // EF Core puts the name on the line after the call, so these have to reach across a newline.
     const FRAMEWORK_CREATES = [
         /migrationBuilder\s*\.\s*CreateTable\s*\([\s\S]{0,80}?name\s*:\s*["']([\w$.]+)["']/gi,
+        // Django names the model rather than the table, and so does its AddIndex, so the two match each
+        // other. Saleor never exercises this - Django convention puts CreateModel and AddIndex in
+        // separate migrations - but every other dialect here has its create form registered and this
+        // one did not, which is the kind of gap that waits for a project with different habits.
+        /migrations\s*\.\s*CreateModel\s*\([\s\S]{0,60}?name\s*=\s*["']([\w]+)["']/gi,
         /queryInterface\s*\.\s*createTable\s*\(\s*["']([\w$.]+)["']/gi,
         /knex\s*\.\s*schema\s*\.\s*createTable\s*\(\s*["']([\w$.]+)["']/gi,
         /Schema\s*::\s*create\s*\(\s*["']([\w$.]+)["']/gi,

package/dist/engine/vouch/assertions.js

@@ -68,6 +68,21 @@ const CHECKS = [
     // in laravel/framework's SupportStrTest came back as "Tewip would not judge" because the
     // `assertSame(...)` in them was being read as an unknown helper that might assert.
     /\$this\s*->\s*assert/,
+    // Laravel's fluent assertions, which is what a Laravel HTTP test actually asserts with:
+    //
+    //     $response = $this->get(route('api.v1.autocomplete.accounts'));
+    //     $response->assertUnauthorized();
+    //     $response->assertHeader('Content-Type', 'application/json');
+    //
+    // The pattern above only reads `$this->assert`, so every one of those was an unknown helper that
+    // might assert - and firefly-iii, a real finance application, came back **72% "Tewip would not
+    // judge"**. A capital after `assert` is what keeps this from matching an ordinary method: it is
+    // assertOk, assertStatus, assertJson, assertUnauthorized, never assertion() or asserts().
+    // `$response->`, not any `->`: Java's lambda arrow is also `->`, so the first version of this
+    // quietly moved thirteen Keycloak verdicts - `coseKey -> assertEcKey(coseKey, ...)` matched. It
+    // happened to be right about them, and that is not the point: a PHP fix had changed Java answers
+    // nobody had looked at. The corpus caught it on the next run, which is what it is for.
+    /\$\w+\s*->\s*assert[A-Z]\w*\s*\(/,
     /\b(?:self|static|Assert)\s*::\s*assert/,
     /\bexpect\s*\(.*\)\s*->\s*\w+/,
     // Rust. A #[should_panic] test asserts by panicking, so it can fail without an assert in it.
@@ -90,7 +105,8 @@ export function checksSomething(text) {
  */
 export function unfinishedExpectations(body) {
     const found = [];
-    for (const line of body.split(String.fromCharCode(10))) {
+    const lines = body.split(String.fromCharCode(10));
+    for (const [i, line] of lines.entries()) {
         const text = line.trim();
         if (!/^(await\s+)?expect(\.soft)?\s*\(/.test(text))
             continue;
@@ -98,6 +114,27 @@ export function unfinishedExpectations(body) {
         if (after === null)
             continue; // the call spans more lines; judged as part of the whole body
         const rest = after.trim();
+        // An expectation kept in a variable and finished on a later line. RSpec allows it, and
+        // discourse writes it:
+        //
+        //     preview =
+        //       expect(Onebox.preview(url).to_s)
+        //     preview.to match(/start=120/)
+        //
+        // `expect(...)` returns the target and `.to` is a method on it, so this is a finished
+        // expectation that happens to span three lines. Reading only the line the `expect` is on called
+        // it unfinished - "an expectation was written but no matcher was called on it" - about a test
+        // that checks two things.
+        if (rest === '' || rest === ';') {
+            // Only the continuation form, because that is the only one that reaches here: a line reading
+            // `preview = expect(x)` does not start with `expect(` and the loop above never looks at it.
+            const named = /([A-Za-z_$][\w$]*)\s*=\s*$/.exec(lines[i - 1] ?? '');
+            // Built by concatenation on purpose. Written as a template literal, `\b` is a backspace
+            // character and `\s` is the letter s, so the pattern silently matched nothing.
+            const finished = new RegExp('(^|[^\\w$.])' + named?.[1] + '\\s*\\.\\s*(to|not_to|to_not)\\b');
+            if (named && finished.test(body))
+                continue;
+        }
         if (rest === '' || rest === ';')
             found.push(text);
         // A matcher named but not called: `.toBeVisible;` or `.toBeVisible` at the end of a statement.

package/dist/engine/vouch/find-tests.js

@@ -193,7 +193,9 @@ const DECLARES = {
     rust: /#\s*\[\s*(?:test|tokio::test|async_std::test|rstest)\s*\]/g,
     // PHPUnit accepts three markers and real suites use all of them: the testFoo naming convention
     // (laravel/framework does this), the #[Test] attribute of PHPUnit 10, and the @test docblock.
-    php: /(?:#\s*\[\s*Test[^\]]*\]|\*\s*@test\b|(?:public|protected|private)?\s*function\s+test\w*\s*\()/g,
+    // `private`/`protected` dropped: PHPUnit collects public methods only, and a private helper whose
+    // name happens to start with "test" is not one. See tests-in.ts for the production file this cost.
+    php: /(?:#\s*\[\s*Test[^\]]*\]|\*\s*@test\b|(?:^|[^\w$>])(?:public\s+)?(?:static\s+)?function\s+test\w*\s*\()/gm,
 };
 /** JUnit, Kotlin, Scala, Go, C#, PHP and Rust: an annotation or a naming convention, then a braced body. */
 function bracedTests(language, text) {
@@ -281,6 +283,15 @@ function skipsAtTopLevel(body) {
     if (lines.length === 0)
         return false;
     const base = Math.min(...lines.map((l) => l.length - l.trimStart().length));
-    return lines.some((l) => l.length - l.trimStart().length === base && /^\s*(?:skip|pending)\b/.test(l));
+    // Not a `skip` carrying a trailing condition. Ruby writes a guard as a modifier -
+    //
+    //     skip "suggested topic not found in results" if suggested_topic.nil?
+    //
+    // - and that test runs every time the condition is false, which is most of the time. The Go side
+    // has refused conditional skips since it was written; Ruby's was added in Phase 36 without it, and
+    // discourse has four tests that run perfectly well being called "never runs".
+    return lines.some((l) => l.length - l.trimStart().length === base &&
+        /^\s*(?:skip|pending)\b/.test(l) &&
+        !/\s(?:if|unless)\s/.test(l));
 }
 export { jsTests, pythonTests, rubyTests, bracedTests };

package/dist/engine/vouch/tests-in.js

@@ -30,14 +30,47 @@ export function languageOf(file) {
     return null;
 }
 /** Does this file look like tests at all? Vouching for a source file is a category error. */
+/**
+ * Minified or vendored: a file nobody in this project wrote, and nobody is going to fix.
+ *
+ * firefly-iii ships `public/v1/lib/jquery-4.0.0.min.js`, and minified JavaScript is full of `test(`
+ * - it is how a regular expression is applied - so it read as a test file and was judged as one.
+ * Nothing useful can come of that: the author cannot act on it, and it is not their code.
+ *
+ * Length is the signal rather than the name, because plenty of vendored bundles are not called
+ * `.min.js`. A minified file is one enormous line; source is not.
+ */
+function minifiedOrVendored(file, text) {
+    if (/[.-]min\.(js|css|mjs)$/i.test(file))
+        return true;
+    if (/(^|[\/])(vendor|third[_-]?party|bundles?|dist)[\/]/i.test(file))
+        return true;
+    const lines = text.split(String.fromCharCode(10));
+    const longest = lines.reduce((most, line) => Math.max(most, line.length), 0);
+    return longest > 2000 && text.length / Math.max(lines.length, 1) > 400;
+}
 export function looksLikeTests(file, text) {
+    if (minifiedOrVendored(file, text))
+        return false;
     const named = /(^|[\\/])(tests?|spec|specs|__tests__|e2e|it|integration)[\\/]|[._-](test|tests|spec|specs|it)\.[a-z]+$|(^|[\\/])test_[^\\/]+\.py$|_test\.(go|py|rb)$|Tests?\.(java|kt|cs|scala)$/i.test(file);
     const declares = /\b(it|test|describe|Scenario)\s*\(|^\s*def\s+test_|@Test\b|\[(Test|Fact|Theory)\]|\bfunc\s+Test[A-Z]/m.test(text) ||
         // Ruby, PHP and Rust, added in Phase 36. PHPUnit names a test `testSomething`, so the `test\s*\(`
         // above never matched it, and Rust marks one with an attribute no pattern here knew. Both came
         // back as "0 test(s) read in 0 file(s)", which reads like a clean answer and is not one.
         /#\s*\[\s*(?:test|tokio::test|rstest)\s*\]/.test(text) ||
-        /\bfunction\s+test\w*\s*\(|#\s*\[\s*Test\b|\*\s*@test\b/.test(text) ||
+        // `public`, or no modifier at all: PHPUnit runs public methods and nothing else. Without that,
+        // firefly-iii's `private function testing()` - a middleware helper asking whether the app is in
+        // the test environment - made `app/Http/Middleware/InterestingMessage.php` a test file, and the
+        // whole of that production class was judged as tests. Vouching for source code is a different
+        // question, and this file says so three lines further down.
+        // A PHP method called `test*` is not a PHPUnit test. firefly-iii has eight public ones in
+        // production controllers - `testRule`, `testNotification` - which are endpoints a user hits to
+        // try a rule or send a test notification, and every one of them made its controller a test file.
+        // What makes a PHPUnit test is the class it is in, so that is what is asked for: a TestCase to
+        // extend, or the attribute and annotation forms that need no base class.
+        (/#\s*\[\s*Test\b|\*\s*@test\b/.test(text) ||
+            (/(?:^|[^\w$>])(?:public\s+)?(?:static\s+)?function\s+test\w*\s*\(/m.test(text) &&
+                /\bextends\s+\w*TestCase\b|\buse\s+PHPUnit\{2}Framework/.test(text))) ||
         /^\s*(?:RSpec\.)?(?:describe|context)\s+|^\s*(?:x|f)?it\s+["'].*\bdo\b/m.test(text);
     return named || declares;
 }

package/package.json

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