tewip-ai 0.41.0 → 0.43.0

package/README.md

@@ -870,7 +870,7 @@ That last section is the part no SQL linter does: it searches your own code for
 away. "This drops `users.nickname`, and four files still read it" is a different sentence from "dropping a
 column is risky", and it is the one that stops the outage.
 
-It reads **SQL, Django, Rails, Alembic and TypeORM** migrations — which covers Prisma, Drizzle, Flyway
+It reads **SQL, Django, Rails, Alembic, TypeORM, Sequelize, Knex, EF Core and Liquibase** migrations — which covers Prisma, Drizzle, Flyway
 and golang-migrate too, since those all emit plain `.sql`. It judges **only the forward path** (a rollback step
 contains the mirror image of the change, so reading it says a migration that creates a table destroys
 one), and stays quiet when the team already did the safe thing — `atomic = False`, `algorithm:
@@ -995,6 +995,9 @@ tewip vouch tests/            # or a file, or the whole project
 tewip vouch tests/ --strict   # exits non-zero, for a merge gate
 ```
 
+Reads **JavaScript, TypeScript, Python, Java, Kotlin, Scala, Go, C#, Ruby, PHP and Rust** — and says
+so, rather than clearing a file it cannot read.
+
 Most tests in a pull request are now written by an agent, and the question that decides whether they
 are worth anything goes unasked: **could this test ever fail?** Coverage counts a test that checks
 nothing. CI goes green on it. A reviewer skims something plausible and approves it.

package/dist/cli/help.js

@@ -157,9 +157,11 @@ Usage:
                                     What will this migration do to a live database? Names the changes
                                     that break the version still running during a deploy, destroy data,
                                     block writes while they run, or cannot be undone - and searches your
-                                    code for what still uses the column it takes away. Reads SQL, Django,
-                                    Rails and Alembic migrations, and says so when it cannot read one.
-                                    No model, no cost.
+                                    code for what still uses the column it takes away. Reads SQL,
+                                    Django, Rails, Alembic, TypeORM, Sequelize, Knex, EF Core and
+                                    Liquibase - so Prisma, Drizzle, Flyway and golang-migrate too,
+                                    since those emit plain SQL - and says so when it cannot read one.
+                                    It judges only the forward path, never the rollback. No cost.
   tewip pick [--diff main...HEAD] [--list] [--out picked.md]
                                     Which tests could notice this change? Narrows a test run using
                                     facts rather than a prediction: a test runs when it imports a
@@ -183,8 +185,9 @@ Usage:
                                     that check nothing, compare a value with itself, leave an
                                     expectation unfinished, swallow their own failure, or never run.
                                     Where the checking is in a helper it cannot follow it says so
-                                    instead of accusing. --strict exits non-zero on a finding, for a
-                                    gate. No model, no cost.
+                                    instead of accusing. Reads JavaScript, TypeScript, Python, Java,
+                                    Kotlin, Scala, Go, C#, Ruby, PHP and Rust. --strict exits
+                                    non-zero on a finding, for a gate. No model, no cost.
   tewip trace [--only "<ticket or title>"] [--out trace.md]
                                     Is this requirement covered, and is it passing right now? Joins
                                     the plans Tewip wrote to the tests that cover them and the runs

package/dist/engine/a2a/card.js

@@ -51,7 +51,7 @@ export const ANSWERABLE = [
         id: 'migration-safety',
         verb: 'schema',
         name: 'What will this migration do to a live database?',
-        description: 'Names what breaks the version still running during a rolling deploy, destroys data, blocks writes, or cannot be undone - and searches the repository for code that still uses a column being dropped. Reads SQL, Django, Rails, Alembic and TypeORM, which covers Prisma, Drizzle and Flyway.',
+        description: 'Names what breaks the version still running during a rolling deploy, destroys data, blocks writes, or cannot be undone - and searches the repository for code that still uses a column being dropped. Reads SQL, Django, Rails, Alembic, TypeORM, Sequelize, Knex, EF Core and Liquibase, which covers Prisma, Drizzle and Flyway too.',
         tags: ['database', 'migrations', 'deployment', 'risk'],
         examples: ['Is this migration safe to deploy?', 'Will this drop break the running version?'],
     },

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

@@ -0,0 +1,190 @@
+const STR = String.raw `['"]([\w.]+)['"]`;
+/** Alembic. */
+/**
+ * Sequelize. `queryInterface.removeColumn('Users', 'passwordHash')` names the table and the column
+ * in one call, which makes it the simplest of these to read.
+ *
+ * Written against opencollective-api's real migrations, which also show why the forward path
+ * matters more here than anywhere else: a Sequelize migration almost always *adds* in `up` and
+ * *removes* in `down`, so a reader that took the whole file would report every harmless migration
+ * in the ecosystem as dropping a column.
+ */
+const SEQUELIZE = [
+    {
+        find: new RegExp(String.raw `removeColumn\s*\(\s*${STR}\s*,\s*${STR}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `removes ${m[1]}.${m[2]}`,
+        instead: 'deploy code that no longer selects or writes the column, then remove it in a later migration',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `renameColumn\s*\(\s*${STR}\s*,\s*${STR}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `renames ${m[1]}.${m[2]}`,
+        instead: 'add the new column, write to both, move the readers, then remove the old one',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `dropTable\s*\(\s*${STR}`, 'i'),
+        risk: 'destroys-data',
+        what: (m) => `drops the table ${m[1]}`,
+        instead: 'stop reading the table, deploy that, then drop it once nothing refers to it',
+        table: (m) => m[1],
+    },
+    {
+        // Sequelize has no CONCURRENTLY option, so an index on a populated table takes the lock.
+        find: new RegExp(String.raw `addIndex\s*\(\s*${STR}`, 'i'),
+        unless: /concurrently\s*:\s*true/i,
+        risk: 'locks-writes',
+        what: (m) => `builds an index on ${m[1]} while holding a lock that blocks writes to it`,
+        instead: 'build it concurrently with a raw query, or accept the lock if the table is small',
+        table: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `changeColumn\s*\(\s*${STR}\s*,\s*${STR}`, 'i'),
+        risk: 'locks-writes',
+        what: (m) => `changes the type of ${m[1]}.${m[2]}, which can rewrite the whole table`,
+        instead: 'add a new column, backfill it in batches, and switch the readers over',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+];
+/**
+ * Knex. The awkward one: the table is named by `knex.schema.table('articles', ...)` and the
+ * operation happens inside the callback, so the two are matched together across the lines between
+ * them. Matterwiki's real migrations are exactly this shape.
+ */
+const KNEX = [
+    {
+        find: new RegExp(String.raw `\.(?:table|alterTable)\s*\(\s*${STR}[\s\S]{0,400}?\.dropColumn\s*\(\s*${STR}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `drops ${m[1]}.${m[2]}`,
+        instead: 'deploy code that no longer selects or writes the column, then drop it in a later migration',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `\.(?:table|alterTable)\s*\(\s*${STR}[\s\S]{0,400}?\.renameColumn\s*\(\s*${STR}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `renames ${m[1]}.${m[2]}`,
+        instead: 'add the new column, write to both, move the readers, then remove the old one',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `\.dropTable(?:IfExists)?\s*\(\s*${STR}`, 'i'),
+        risk: 'destroys-data',
+        what: (m) => `drops the table ${m[1]}`,
+        instead: 'stop reading the table, deploy that, then drop it once nothing refers to it',
+        table: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `\.(?:table|alterTable)\s*\(\s*${STR}[\s\S]{0,400}?\.notNullable\s*\(`, 'i'),
+        risk: 'locks-writes',
+        what: (m) => `makes a column on ${m[1]} NOT NULL, which scans every row under a lock`,
+        instead: 'add a CHECK ... NOT VALID, validate it, then set NOT NULL - or accept the scan if the table is small',
+        table: (m) => m[1],
+    },
+];
+/**
+ * EF Core. Its MigrationBuilder calls use named arguments over several lines and in either order,
+ * so each operation is matched twice - once for `name` before `table`, once for the reverse -
+ * rather than assuming the order Coflnet's real migrations happen to use.
+ */
+const NAMED = (first, second) => String.raw `(?:${first}:\s*${STR}[\s\S]{0,200}?${second}:\s*${STR}|${second}:\s*${STR}[\s\S]{0,200}?${first}:\s*${STR})`;
+/** Whichever order the arguments came in, the two names are in 1,2 or in 4,3. */
+const pair = (m) => (m[1] !== undefined ? [m[1], m[2]] : [m[4], m[3]]);
+const EFCORE = [
+    {
+        find: new RegExp(String.raw `migrationBuilder\.DropColumn\s*\(\s*${NAMED('name', 'table')}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `drops ${pair(m)[1]}.${pair(m)[0]}`,
+        instead: 'deploy code that no longer selects or writes the column, then drop it in a later migration',
+        table: (m) => pair(m)[1],
+        column: (m) => pair(m)[0],
+    },
+    {
+        find: new RegExp(String.raw `migrationBuilder\.DropTable\s*\(\s*name:\s*${STR}`, 'i'),
+        risk: 'destroys-data',
+        what: (m) => `drops the table ${m[1]}`,
+        instead: 'stop reading the table, deploy that, then drop it once nothing refers to it',
+        table: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `migrationBuilder\.RenameColumn\s*\(\s*${NAMED('name', 'table')}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `renames ${pair(m)[1]}.${pair(m)[0]}`,
+        instead: 'add the new column, write to both, move the readers, then remove the old one',
+        table: (m) => pair(m)[1],
+        column: (m) => pair(m)[0],
+    },
+    {
+        find: new RegExp(String.raw `migrationBuilder\.CreateIndex\s*\(\s*${NAMED('name', 'table')}`, 'i'),
+        risk: 'locks-writes',
+        what: (m) => `builds an index on ${pair(m)[1]} while holding a lock that blocks writes to it`,
+        instead: 'build it concurrently with migrationBuilder.Sql, or accept the lock if the table is small',
+        table: (m) => pair(m)[1],
+    },
+    {
+        find: new RegExp(String.raw `migrationBuilder\.AlterColumn<[^>]*>\s*\(\s*${NAMED('name', 'table')}`, 'i'),
+        risk: 'locks-writes',
+        what: (m) => `alters ${pair(m)[1]}.${pair(m)[0]}, which can rewrite the whole table`,
+        instead: 'add a new column, backfill it in batches, and switch the readers over',
+        table: (m) => pair(m)[1],
+        column: (m) => pair(m)[0],
+    },
+];
+/**
+ * Liquibase. A changelog is XML or YAML rather than code, and the operation is the element name
+ * with the table on `tableName`. DEFRA's real changelogs are the shape this was written against.
+ */
+const XML_TABLE = String.raw `tableName\s*=\s*["']([\w.]+)["']`;
+const LIQUIBASE = [
+    {
+        find: new RegExp(String.raw `<dropColumn[^>]*${XML_TABLE}[\s\S]{0,300}?<column[^>]*name\s*=\s*["']([\w.]+)["']`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `drops ${m[1]}.${m[2]}`,
+        instead: 'deploy code that no longer selects or writes the column, then drop it in a later changeSet',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `<dropColumn[^>]*columnName\s*=\s*["']([\w.]+)["'][^>]*${XML_TABLE}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `drops ${m[2]}.${m[1]}`,
+        instead: 'deploy code that no longer selects or writes the column, then drop it in a later changeSet',
+        table: (m) => m[2],
+        column: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `<dropTable[^>]*${XML_TABLE}`, 'i'),
+        risk: 'destroys-data',
+        what: (m) => `drops the table ${m[1]}`,
+        instead: 'stop reading the table, deploy that, then drop it once nothing refers to it',
+        table: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `<renameColumn[^>]*${XML_TABLE}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `renames a column on ${m[1]}`,
+        instead: 'add the new column, write to both, move the readers, then remove the old one',
+        table: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `<addNotNullConstraint[^>]*${XML_TABLE}`, 'i'),
+        risk: 'locks-writes',
+        what: (m) => `makes a column on ${m[1]} NOT NULL, which scans every row under a lock`,
+        instead: 'add a CHECK ... NOT VALID, validate it, then set NOT NULL - or accept the scan if the table is small',
+        table: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `<createIndex[^>]*${XML_TABLE}`, 'i'),
+        risk: 'locks-writes',
+        what: (m) => `builds an index on ${m[1]} while holding a lock that blocks writes to it`,
+        instead: 'build it concurrently with a <sql> changeSet, or accept the lock if the table is small',
+        table: (m) => m[1],
+    },
+];
+export { SEQUELIZE, KNEX, EFCORE, LIQUIBASE };

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

@@ -0,0 +1,147 @@
+const STR = String.raw `['"]([\w.]+)['"]`;
+/** Django's operations. `model_name` and `name` are the table and the column. */
+const DJANGO = [
+    {
+        find: new RegExp(String.raw `migrations\.RemoveField\([\s\S]{0,200}?model_name=${STR}[\s\S]{0,200}?name=${STR}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `removes the field ${m[2]} from ${m[1]}`,
+        instead: 'stop reading and writing the field, deploy that, then remove it in a later migration. The version still running during a rolling deploy will select a column that no longer exists',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `migrations\.RenameField\([\s\S]{0,200}?model_name=${STR}[\s\S]{0,200}?old_name=${STR}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `renames ${m[1]}.${m[2]}`,
+        instead: 'add the new field, write to both, move the readers, then remove the old one',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `migrations\.DeleteModel\([\s\S]{0,120}?${STR}`, 'i'),
+        risk: 'destroys-data',
+        what: (m) => `deletes the model ${m[1]} and its table`,
+        instead: 'stop using it, ship that, confirm nothing reads it, and delete it later',
+        table: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `migrations\.AddField\([\s\S]{0,400}?null=False(?![\s\S]{0,400}?default=)`, 'i'),
+        risk: 'breaks-old-code',
+        what: () => 'adds a field that cannot be null and has no default',
+        instead: 'add it with null=True or a default. Without one, Django rewrites the table and every insert from the running version fails',
+    },
+    {
+        find: new RegExp(String.raw `migrations\.AlterField\([\s\S]{0,400}?null=False`, 'i'),
+        risk: 'locks-writes',
+        what: () => 'makes an existing field NOT NULL, which reads every row under a lock',
+        instead: 'backfill first, add a validated constraint, then alter - or use SeparateDatabaseAndState with the safe SQL',
+    },
+    {
+        // A data migration. Django wraps a migration in one transaction, so this holds it open for as long as
+        // the work takes - fine for a hundred rows, an outage for a hundred million.
+        find: /migrations\.RunPython\(/,
+        unless: /atomic\s*=\s*False/,
+        risk: 'slow',
+        what: () => 'runs application code against the data inside the migration transaction',
+        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,
+        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',
+        instead: 'AddIndexConcurrently / AddConstraintNotValid from django.contrib.postgres.operations, with atomic = False on the migration',
+    },
+];
+/** Rails migrations. */
+const RAILS = [
+    {
+        find: new RegExp(String.raw `remove_column\s*[\s(]\s*:?(\w+)\s*,\s*:?(\w+)`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `removes ${m[1]}.${m[2]}`,
+        instead: "ignore the column in the model (self.ignored_columns), deploy that, then remove it. Rails caches the column list, so the running version keeps selecting it",
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `rename_column\s*[\s(]\s*:?(\w+)\s*,\s*:?(\w+)`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `renames ${m[1]}.${m[2]}`,
+        instead: 'add the new column, write to both, move the readers, then remove the old one',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `drop_table\s*[\s(]\s*:?(\w+)`, 'i'),
+        risk: 'destroys-data',
+        what: (m) => `drops the table ${m[1]}`,
+        instead: 'stop using it, ship that, then drop it later',
+        table: (m) => m[1],
+    },
+    {
+        find: /add_index\s*[\s(]/i,
+        unless: /algorithm:\s*:concurrently/,
+        risk: 'locks-writes',
+        what: () => 'adds an index without algorithm: :concurrently, so writes to the table block while it builds',
+        instead: 'add_index ..., algorithm: :concurrently, with disable_ddl_transaction! on the migration',
+    },
+    {
+        find: new RegExp(String.raw `change_column\s*[\s(]\s*:?(\w+)\s*,\s*:?(\w+)`, 'i'),
+        risk: 'locks-writes',
+        what: (m) => `changes the type of ${m[1]}.${m[2]}, which usually rewrites the table`,
+        instead: 'add a new column, backfill in batches, switch the readers, then drop the old one',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `change_column_null\s*[\s(]\s*:?(\w+)\s*,\s*:?(\w+)\s*,\s*false`, 'i'),
+        risk: 'locks-writes',
+        what: (m) => `makes ${m[1]}.${m[2]} NOT NULL, which reads every row under a lock`,
+        instead: 'add a validated check constraint first, then set the column NOT NULL',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+];
+const ALEMBIC = [
+    {
+        find: new RegExp(String.raw `op\.drop_column\(\s*${STR}\s*,\s*${STR}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `drops ${m[1]}.${m[2]}`,
+        instead: 'stop reading and writing it, deploy that, then drop it in a later revision',
+        table: (m) => m[1],
+        column: (m) => m[2],
+    },
+    {
+        find: new RegExp(String.raw `op\.drop_table\(\s*${STR}`, 'i'),
+        risk: 'destroys-data',
+        what: (m) => `drops the table ${m[1]}`,
+        instead: 'stop using it, ship that, then drop it later',
+        table: (m) => m[1],
+    },
+    {
+        find: new RegExp(String.raw `op\.alter_column\([\s\S]{0,300}?nullable=False`, 'i'),
+        risk: 'locks-writes',
+        what: () => 'makes a column NOT NULL, which reads every row under a lock',
+        instead: 'backfill, add a validated constraint, then alter the column',
+    },
+    {
+        find: /op\.create_index\(/i,
+        unless: /postgresql_concurrently\s*=\s*True/,
+        risk: 'locks-writes',
+        what: () => 'builds an index without postgresql_concurrently, so writes block while it builds',
+        instead: 'op.create_index(..., postgresql_concurrently=True) with a non-transactional revision',
+    },
+    {
+        find: new RegExp(String.raw `op\.rename_table\(\s*${STR}`, 'i'),
+        risk: 'breaks-old-code',
+        what: (m) => `renames the table ${m[1]}`,
+        instead: 'move the readers first, or keep a view with the old name',
+        table: (m) => m[1],
+    },
+];
+// TypeORM has no operations of its own: unlike Django's `RemoveField` or Rails's `remove_column`,
+// a TypeORM migration contains SQL and nothing else, handed to queryRunner.query(). So its list is
+// empty on purpose and every finding comes from reading that SQL, which is the same reader the
+// `.sql` dialect uses. The exhaustive Record is what made this a compile error rather than a
+// TypeORM migration silently producing no findings at all.
+export { DJANGO, RAILS, ALEMBIC };

package/dist/engine/schema/frameworks.js

@@ -1,3 +1,5 @@
+import { ALEMBIC, DJANGO, RAILS } from './dialect-rules.js';
+import { EFCORE, KNEX, LIQUIBASE, SEQUELIZE } from './dialect-rules-node.js';
 export function dialectOf(file, text) {
     const path = file.split('\\').join('/').toLowerCase();
     if (path.endsWith('.sql'))
@@ -17,158 +19,28 @@ export function dialectOf(file, text) {
     // at all - and on a Node backend that is most of them.
     if (/\bMigrationInterface\b|\bqueryRunner\.query\s*\(/.test(text))
         return 'typeorm';
+    if (/\bqueryInterface\.\w+\s*\(/.test(text))
+        return 'sequelize';
+    if (/\bknex\.schema\b|\bexports\.(?:up|down)\s*=\s*(?:async\s*)?function\s*\(\s*knex\b/.test(text))
+        return 'knex';
+    if (/\bmigrationBuilder\.\w+|\b:\s*Migration\b[\s\S]*\bMigrationBuilder\b/.test(text))
+        return 'efcore';
+    if (/<databaseChangeLog\b|\bdatabaseChangeLog\s*:/.test(text))
+        return 'liquibase';
     if (/(^|\/)(migrations?|db\/migrate)\//.test(path))
         return 'unknown';
     return 'unknown';
 }
-const STR = String.raw `['"]([\w.]+)['"]`;
-/** Django's operations. `model_name` and `name` are the table and the column. */
-const DJANGO = [
-    {
-        find: new RegExp(String.raw `migrations\.RemoveField\([\s\S]{0,200}?model_name=${STR}[\s\S]{0,200}?name=${STR}`, 'i'),
-        risk: 'breaks-old-code',
-        what: (m) => `removes the field ${m[2]} from ${m[1]}`,
-        instead: 'stop reading and writing the field, deploy that, then remove it in a later migration. The version still running during a rolling deploy will select a column that no longer exists',
-        table: (m) => m[1],
-        column: (m) => m[2],
-    },
-    {
-        find: new RegExp(String.raw `migrations\.RenameField\([\s\S]{0,200}?model_name=${STR}[\s\S]{0,200}?old_name=${STR}`, 'i'),
-        risk: 'breaks-old-code',
-        what: (m) => `renames ${m[1]}.${m[2]}`,
-        instead: 'add the new field, write to both, move the readers, then remove the old one',
-        table: (m) => m[1],
-        column: (m) => m[2],
-    },
-    {
-        find: new RegExp(String.raw `migrations\.DeleteModel\([\s\S]{0,120}?${STR}`, 'i'),
-        risk: 'destroys-data',
-        what: (m) => `deletes the model ${m[1]} and its table`,
-        instead: 'stop using it, ship that, confirm nothing reads it, and delete it later',
-        table: (m) => m[1],
-    },
-    {
-        find: new RegExp(String.raw `migrations\.AddField\([\s\S]{0,400}?null=False(?![\s\S]{0,400}?default=)`, 'i'),
-        risk: 'breaks-old-code',
-        what: () => 'adds a field that cannot be null and has no default',
-        instead: 'add it with null=True or a default. Without one, Django rewrites the table and every insert from the running version fails',
-    },
-    {
-        find: new RegExp(String.raw `migrations\.AlterField\([\s\S]{0,400}?null=False`, 'i'),
-        risk: 'locks-writes',
-        what: () => 'makes an existing field NOT NULL, which reads every row under a lock',
-        instead: 'backfill first, add a validated constraint, then alter - or use SeparateDatabaseAndState with the safe SQL',
-    },
-    {
-        // A data migration. Django wraps a migration in one transaction, so this holds it open for as long as
-        // the work takes - fine for a hundred rows, an outage for a hundred million.
-        find: /migrations\.RunPython\(/,
-        unless: /atomic\s*=\s*False/,
-        risk: 'slow',
-        what: () => 'runs application code against the data inside the migration transaction',
-        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,
-        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',
-        instead: 'AddIndexConcurrently / AddConstraintNotValid from django.contrib.postgres.operations, with atomic = False on the migration',
-    },
-];
-/** Rails migrations. */
-const RAILS = [
-    {
-        find: new RegExp(String.raw `remove_column\s*[\s(]\s*:?(\w+)\s*,\s*:?(\w+)`, 'i'),
-        risk: 'breaks-old-code',
-        what: (m) => `removes ${m[1]}.${m[2]}`,
-        instead: "ignore the column in the model (self.ignored_columns), deploy that, then remove it. Rails caches the column list, so the running version keeps selecting it",
-        table: (m) => m[1],
-        column: (m) => m[2],
-    },
-    {
-        find: new RegExp(String.raw `rename_column\s*[\s(]\s*:?(\w+)\s*,\s*:?(\w+)`, 'i'),
-        risk: 'breaks-old-code',
-        what: (m) => `renames ${m[1]}.${m[2]}`,
-        instead: 'add the new column, write to both, move the readers, then remove the old one',
-        table: (m) => m[1],
-        column: (m) => m[2],
-    },
-    {
-        find: new RegExp(String.raw `drop_table\s*[\s(]\s*:?(\w+)`, 'i'),
-        risk: 'destroys-data',
-        what: (m) => `drops the table ${m[1]}`,
-        instead: 'stop using it, ship that, then drop it later',
-        table: (m) => m[1],
-    },
-    {
-        find: /add_index\s*[\s(]/i,
-        unless: /algorithm:\s*:concurrently/,
-        risk: 'locks-writes',
-        what: () => 'adds an index without algorithm: :concurrently, so writes to the table block while it builds',
-        instead: 'add_index ..., algorithm: :concurrently, with disable_ddl_transaction! on the migration',
-    },
-    {
-        find: new RegExp(String.raw `change_column\s*[\s(]\s*:?(\w+)\s*,\s*:?(\w+)`, 'i'),
-        risk: 'locks-writes',
-        what: (m) => `changes the type of ${m[1]}.${m[2]}, which usually rewrites the table`,
-        instead: 'add a new column, backfill in batches, switch the readers, then drop the old one',
-        table: (m) => m[1],
-        column: (m) => m[2],
-    },
-    {
-        find: new RegExp(String.raw `change_column_null\s*[\s(]\s*:?(\w+)\s*,\s*:?(\w+)\s*,\s*false`, 'i'),
-        risk: 'locks-writes',
-        what: (m) => `makes ${m[1]}.${m[2]} NOT NULL, which reads every row under a lock`,
-        instead: 'add a validated check constraint first, then set the column NOT NULL',
-        table: (m) => m[1],
-        column: (m) => m[2],
-    },
-];
-/** Alembic. */
-const ALEMBIC = [
-    {
-        find: new RegExp(String.raw `op\.drop_column\(\s*${STR}\s*,\s*${STR}`, 'i'),
-        risk: 'breaks-old-code',
-        what: (m) => `drops ${m[1]}.${m[2]}`,
-        instead: 'stop reading and writing it, deploy that, then drop it in a later revision',
-        table: (m) => m[1],
-        column: (m) => m[2],
-    },
-    {
-        find: new RegExp(String.raw `op\.drop_table\(\s*${STR}`, 'i'),
-        risk: 'destroys-data',
-        what: (m) => `drops the table ${m[1]}`,
-        instead: 'stop using it, ship that, then drop it later',
-        table: (m) => m[1],
-    },
-    {
-        find: new RegExp(String.raw `op\.alter_column\([\s\S]{0,300}?nullable=False`, 'i'),
-        risk: 'locks-writes',
-        what: () => 'makes a column NOT NULL, which reads every row under a lock',
-        instead: 'backfill, add a validated constraint, then alter the column',
-    },
-    {
-        find: /op\.create_index\(/i,
-        unless: /postgresql_concurrently\s*=\s*True/,
-        risk: 'locks-writes',
-        what: () => 'builds an index without postgresql_concurrently, so writes block while it builds',
-        instead: 'op.create_index(..., postgresql_concurrently=True) with a non-transactional revision',
-    },
-    {
-        find: new RegExp(String.raw `op\.rename_table\(\s*${STR}`, 'i'),
-        risk: 'breaks-old-code',
-        what: (m) => `renames the table ${m[1]}`,
-        instead: 'move the readers first, or keep a view with the old name',
-        table: (m) => m[1],
-    },
-];
-// TypeORM has no operations of its own: unlike Django's `RemoveField` or Rails's `remove_column`,
-// a TypeORM migration contains SQL and nothing else, handed to queryRunner.query(). So its list is
-// empty on purpose and every finding comes from reading that SQL, which is the same reader the
-// `.sql` dialect uses. The exhaustive Record is what made this a compile error rather than a
-// TypeORM migration silently producing no findings at all.
-const BY_DIALECT = { django: DJANGO, rails: RAILS, alembic: ALEMBIC, typeorm: [] };
+const BY_DIALECT = {
+    django: DJANGO,
+    rails: RAILS,
+    alembic: ALEMBIC,
+    typeorm: [],
+    sequelize: SEQUELIZE,
+    knex: KNEX,
+    efcore: EFCORE,
+    liquibase: LIQUIBASE,
+};
 /** Findings from a framework migration, with the line each one sits on. */
 export function readFramework(dialect, text) {
     const lines = text.split(String.fromCharCode(10));
@@ -230,10 +102,24 @@ export function forwardOnly(dialect, text) {
             (dialect === 'sql' && /^\s*--\s*(?:\+migrate\s+Down|\+goose\s+Down|\/\/@UNDO|Down\b)/i.test(line)) ||
             // TypeORM's rollback is `public async down(queryRunner: QueryRunner)`. Reading it as part of
             // the change would report a migration that adds a column as one that drops it.
-            (dialect === 'typeorm' && /^\s*(?:public\s+)?async\s+down\s*\(/.test(line));
+            (dialect === 'typeorm' && /^\s*(?:public\s+)?async\s+down\s*\(/.test(line)) ||
+            // These three matter more than the rest. A Sequelize or Knex migration almost always *adds*
+            // in up and *removes* in down, and an EF Core Down() is the mirror image of its Up(), so a
+            // reader that took the whole file would report nearly every harmless migration in those
+            // ecosystems as dropping a column. Verified on real migrations from opencollective-api,
+            // Matterwiki and Coflnet, all three of which have their only destructive call in down.
+            (dialect === 'sequelize' && /^\s*down\s*:/.test(line)) ||
+            (dialect === 'knex' && /^\s*(?:exports\.down|module\.exports\.down)\s*=/.test(line)) ||
+            (dialect === 'efcore' && /^\s*protected\s+override\s+void\s+Down\s*\(/.test(line)) ||
+            // Liquibase puts the reverse inside the change itself rather than in a second method.
+            (dialect === 'liquibase' && /^\s*<rollback\b/.test(line));
         if (down) {
             // To the end of the block: the next line at the same indentation or less that starts something new.
-            blankFrom(i, (l, indent) => l.trim() !== '' && indentOf(l) <= indent && !/^\s*(end|\})\s*$/.test(l), indentOf(line));
+            // A lone brace is punctuation, not the start of something new. C# puts the opening `{` of a
+            // method on its own line at the same indent as the signature, so without `{` here the block
+            // ended one line after it began and the whole of EF Core's Down() was read as part of the
+            // change - which reported Coflnet's real migration as dropping three columns it adds.
+            blankFrom(i, (l, indent) => l.trim() !== '' && indentOf(l) <= indent && !/^\s*(end|\}|\{)\s*$/.test(l), indentOf(line));
             continue;
         }
         // Rails's `direction.down { ... }` is usually one line.

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

@@ -70,7 +70,7 @@ export function readMigration(root, file) {
             file,
             dialect,
             findings: [],
-            unread: 'Tewip does not recognise how this migration is written, so it says nothing about it rather than passing it. It reads SQL, Django, Rails, Alembic and TypeORM migrations',
+            unread: 'Tewip does not recognise how this migration is written, so it says nothing about it rather than passing it. It reads SQL, Django, Rails, Alembic, TypeORM, Sequelize, Knex, EF Core and Liquibase migrations',
             irreversible: false,
         };
     }

package/dist/engine/vouch/assertions.js

@@ -38,10 +38,35 @@ const CHECKS = [
     // Go.
     /\bt\s*\.\s*(Error|Errorf|Fatal|Fatalf|Fail|FailNow)\b/,
     /\b(require|assert)\s*\.\s*[A-Z]\w+\s*\(/,
-    // Ruby, PHP, Rust.
-    /\bexpect\s*\(.*\)\s*\.\s*to\b/,
-    /\b\$this\s*->\s*assert/,
+    // Ruby. The snake_case family is the whole of minitest and most of Rails's own suite, and
+    // `assert_equal "x", y` has no parentheses - so the generic `assert` patterns above, which all
+    // want a `.` or a `(`, matched none of it. Without this, 121 of the 154 real tests in Rails's
+    // activesupport string_ext_test.rb were reported as comparing no value. That is the Phase 8
+    // lesson for the fourth time: a missing entry here does not produce a smaller answer, it
+    // produces a confident wrong one.
+    /\b(assert|refute)_\w+/,
+    /\bassert\s+[^=\n]/,
+    /\bexpect\s*\(.*\)\s*\.\s*(to|not_to|to_not)\b/,
+    // RSpec's block form, which is how every raise_error, change and output matcher is written:
+    // `expect { thing }.to raise_error(...)`. Missing it reported rspec-core's own specs - the
+    // reference implementation - as containing tests that cannot fail.
+    /\bexpect\s*\{[\s\S]*?\}\s*\.\s*(to|not_to|to_not)\b/,
+    /\bis_expected\s*\.\s*to\b/,
+    /\.\s*(must_equal|must_be|wont_equal|wont_be)\b/,
+    // PHP: PHPUnit on the instance or statically, and Pest's expectation chain.
+    //
+    // No `\b` before the `$`. A word boundary needs a word character on one side, `$` is not one,
+    // and the character before it in real code is a space - so `/\b\$this/` matched nothing, ever.
+    // This pattern was on the list from the start and had never once fired: 88 of the 128 real tests
+    // 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/,
+    /\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.
     /\bassert(_eq|_ne|_matches)?!\s*\(/,
+    /\bdebug_assert(_eq|_ne)?!\s*\(/,
+    /#\s*\[\s*should_panic/,
     // Robot Framework and other keyword styles: a line that reads as a check.
     /^\s*Should\s+(Be|Not|Contain|Match)\b/im,
 ];

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

@@ -0,0 +1,274 @@
+// Phase 22 and after: finding the tests inside a file, in each language's own shape.
+//
+// Split out of tests-in.ts, which passed this project's 300-line rule when Ruby, PHP and Rust were
+// added. tests-in.ts keeps the questions every language shares - which language is this, does it
+// look like tests at all, which parts of it are text rather than code - and this file holds the
+// four readers: callbacks (JavaScript), indentation (Python), `end` (Ruby), and braces (the rest).
+import { braced, isText, lineAt, textRanges } from './tests-in.js';
+/**
+ * `it('...', async () => { ... })` and its many spellings, including `test.each`, `it.skip` and a
+ * plain `function ()` callback. The body is taken by matching braces from the callback's opening one.
+ */
+function jsTests(text) {
+    const found = [];
+    const ranges = textRanges(text);
+    const declaration = /\b(it|test|specify)\s*(\.\s*(skip|only|todo|failing|concurrent|each|for)\s*(\([^)]*\)|`[^`]*`)?\s*)*\(\s*(['"`])((?:\\.|(?!\5)[^\\])*)\5/g;
+    for (const hit of text.matchAll(declaration)) {
+        const at = hit.index ?? 0;
+        if (isText(ranges, at))
+            continue;
+        const open = text.indexOf('{', at + hit[0].length);
+        if (open === -1)
+            continue;
+        const body = braced(text, open);
+        if (body === null)
+            continue;
+        const signature = text.slice(at + hit[0].length, open);
+        found.push({
+            name: hit[6],
+            line: lineAt(text, at),
+            body,
+            skipped: /\.\s*(skip|todo|failing)\b/.test(hit[0]) || /\bxit\s*\(/.test(hit[0]),
+            callback: /\(\s*([A-Za-z_$][\w$]*)\s*\)\s*(=>)?\s*$/.exec(signature.trim())?.[1] ?? '',
+        });
+    }
+    // `xit(...)` and `xtest(...)`, which the pattern above deliberately does not match.
+    for (const hit of text.matchAll(/\bx(it|test)\s*\(\s*(['"`])((?:\\.|(?!\2)[^\\])*)\2/g)) {
+        const at = hit.index ?? 0;
+        if (isText(ranges, at))
+            continue;
+        const open = text.indexOf('{', at + hit[0].length);
+        const body = open === -1 ? null : braced(text, open);
+        found.push({ name: hit[3], line: lineAt(text, at), body: body ?? '', skipped: true, callback: '' });
+    }
+    return found.sort((a, b) => a.line - b.line);
+}
+/** Python has no braces: a test's body is everything indented further than its `def`. */
+function pythonTests(text) {
+    const lines = text.split(String.fromCharCode(10));
+    const ranges = textRanges(text);
+    const offsets = [];
+    let seen = 0;
+    for (const line of lines) {
+        offsets.push(seen);
+        seen += line.length + 1;
+    }
+    const found = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const hit = /^(\s*)(?:async\s+)?def\s+(test_\w+|test)\s*\(/.exec(lines[i]);
+        if (!hit)
+            continue;
+        if (isText(ranges, offsets[i] + hit[1].length + 1))
+            continue;
+        const indent = hit[1].length;
+        // Nested in another def? Then it is a helper or, in Click's tests, a CLI command that happens to
+        // be named `test`. Only a module-level def, or a method of a test class, is a test.
+        if (nestedInFunction(lines, i, indent))
+            continue;
+        if (hit[2] === 'test' && indent > 0)
+            continue;
+        // A def whose parameters run over several lines ends at the line that closes them, and the body
+        // starts after that. Without this, the parameter list was read as the body and the real body was
+        // thrown away: psf/requests has several, and each came back as a test that compares no value.
+        let signatureEnds = i;
+        let open = 0;
+        for (let j = i; j < lines.length && j < i + 20; j += 1) {
+            open += (lines[j].match(/\(/g) ?? []).length - (lines[j].match(/\)/g) ?? []).length;
+            signatureEnds = j;
+            if (open <= 0)
+                break;
+        }
+        const body = [];
+        for (let j = signatureEnds + 1; j < lines.length; j += 1) {
+            const line = lines[j];
+            if (line.trim() === '') {
+                body.push(line);
+                continue;
+            }
+            const width = line.length - line.trimStart().length;
+            if (width <= indent)
+                break;
+            body.push(line);
+        }
+        // Decorators sit above the def, so skipping is read upwards.
+        const above = lines.slice(Math.max(0, i - 4), i).join(String.fromCharCode(10));
+        // A conditional skip runs somewhere - `skipif` on Windows registry tests in psf/requests runs
+        // on Windows - so only an unconditional skip means the test never runs. `xfail` runs too.
+        const skipped = /@\s*(pytest\s*\.\s*mark\s*\.\s*skip|unittest\s*\.\s*skip)\b/.test(above) && !/skipif|skipUnless|xfail/.test(above);
+        found.push({ name: hit[2], line: i + 1, body: body.join(String.fromCharCode(10)), skipped, callback: '' });
+    }
+    return found;
+}
+/** Is the def on line `i` nested inside another def, rather than inside a class or at the top? */
+function nestedInFunction(lines, i, indent) {
+    for (let j = i - 1; j >= 0; j -= 1) {
+        const line = lines[j];
+        if (line.trim() === '')
+            continue;
+        const width = line.length - line.trimStart().length;
+        if (width >= indent)
+            continue;
+        return /^\s*(async\s+)?def\s/.test(line);
+    }
+    return false;
+}
+/**
+ * Ruby, in both of the two shapes that cover nearly all of it: minitest's `def test_name ... end`
+ * and RSpec's `it "name" do ... end`. Rails's own activesupport tests are the first; rspec-core's
+ * own specs are the second.
+ *
+ * The body runs to the `end` that lines up with the opener's indentation. Counting `do`, `def`,
+ * `if`, `case` and the rest against `end` would be the thorough way and is a poor trade: Ruby has
+ * one-line `if` modifiers, `end` inside strings, and heredocs, so a counter gets it wrong on real
+ * code in ways that are hard to see. Matching the indentation is right for conventionally
+ * formatted Ruby, which is nearly all Ruby, and when it cannot find the closing `end` the test is
+ * skipped rather than judged on a body that was guessed at.
+ */
+function rubyTests(text) {
+    /** Each accepted test with the line its `end` sits on, so a nested one can be recognised. */
+    const found = [];
+    const lines = text.split(String.fromCharCode(10));
+    const ranges = textRanges(text);
+    const offsets = [];
+    let seen = 0;
+    for (const line of lines) {
+        offsets.push(seen);
+        seen += line.length + 1;
+    }
+    for (let i = 0; i < lines.length; i += 1) {
+        //  def test_foo            minitest
+        //  it "does a thing" do    RSpec
+        //  test "does a thing" do  Rails and minitest's spec syntax
+        //  specify { ... }         is deliberately not here: a one-line specify has no body to read.
+        const hit = /^(\s*)(?:(?:x|f)?(it|test|scenario|example)\s*[("']|def\s+(test_\w+))/.exec(lines[i]);
+        if (!hit)
+            continue;
+        if (isText(ranges, offsets[i] + hit[1].length))
+            continue;
+        const indent = hit[1].length;
+        let close = -1;
+        for (let j = i + 1; j < lines.length; j += 1) {
+            const line = lines[j];
+            if (line.trim() === '')
+                continue;
+            if (/^\s*end\b/.test(line) && line.length - line.trimStart().length === indent) {
+                close = j;
+                break;
+            }
+        }
+        if (close === -1)
+            continue;
+        // An `it` inside another `it` is not a test. rspec-core's own specs define one as a fixture -
+        // `describe_successfully do it "..." do sequence << :example end end` - and the assertion that
+        // matters is in the enclosing test. Python's finder skips nested defs for the same reason.
+        if (found.some((earlier) => i > earlier.line - 1 && i < earlier.endsAt))
+            continue;
+        const body = lines.slice(i + 1, close).join(String.fromCharCode(10));
+        const named = hit[3] ?? /^\s*(?:x|f)?(?:it|test|scenario|example)\s*[("']\s*["']?([^"')]*)/.exec(lines[i])?.[1]?.trim();
+        found.push({
+            endsAt: close,
+            name: (named ?? '').trim() === '' ? 'unnamed' : named,
+            line: i + 1,
+            body,
+            // `xit` turns a test off. A bare `skip` does too - but only at the top level of the body.
+            // rspec-core's own specs pass a block containing `skip "because"` to a helper, as the
+            // fixture whose behaviour the test is checking, and the test around it asserts plenty.
+            // Reading that as "this test never runs" condemned the reference implementation.
+            skipped: /^\s*(?:x(?:it|specify|example)|skip\b)/.test(lines[i]) || skipsAtTopLevel(body),
+            callback: '',
+        });
+    }
+    return found;
+}
+/**
+ * How each language says "this is a test".
+ *
+ * Rust and PHP join the braced finder rather than getting one of their own, because both mark a
+ * test the way the JVM languages do: an attribute or a naming convention, then a braced body. Only
+ * the marker differs.
+ */
+const DECLARES = {
+    // Rust marks a test with an attribute. `#[bench]` is left out for the same reason Go's Benchmark
+    // is: it measures rather than checks, and calling it assertion-free is true and useless.
+    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,
+};
+/** JUnit, Kotlin, Scala, Go, C#, PHP and Rust: an annotation or a naming convention, then a braced body. */
+function bracedTests(language, text) {
+    const found = [];
+    const ranges = textRanges(text, language);
+    const declaration = DECLARES[language] ??
+        (language === 'go'
+            ? // Only a Test function. A Benchmark asserts nothing by design, an Example is checked against
+                // its own Output comment, and a Fuzz target is not a test - all three were condemned as
+                // "checks nothing" in gorilla/mux before this narrowed.
+                /\bfunc\s+(Test)(\w+)\s*\(\s*\w+\s+\*testing\.[TB]\s*\)\s*\{/g
+            : /(@Test\b[^\n]*|\[\s*(?:Test|Fact|Theory)[^\]]*\]|@(?:ParameterizedTest|RepeatedTest)\b)/g);
+    for (const hit of text.matchAll(declaration)) {
+        const at = hit.index ?? 0;
+        if (isText(ranges, at))
+            continue;
+        // Where the body starts. Go's marker already includes the brace. Rust and PHP put a signature
+        // after the marker, and in PHP the marker may itself *be* the signature, so searching from the
+        // end of the match covers both.
+        const open = language === 'go'
+            ? text.indexOf('{', at)
+            : language === 'rust' || language === 'php'
+                ? text.indexOf('{', at + hit[0].length)
+                : text.indexOf('{', text.indexOf('(', at + hit[0].length));
+        if (open === -1)
+            continue;
+        const body = braced(text, open);
+        if (body === null)
+            continue;
+        const signature = text.slice(at, open);
+        // `void foo() throws IOException` still names foo. Without allowing the throws clause, every
+        // checked-exception test in gson was reported as 'unnamed'.
+        const name = language === 'go'
+            ? hit[1] + hit[2]
+            : language === 'rust'
+                ? // ripgrep generates whole families of tests from a macro, where the name in the source
+                    // is literally `$name`. Reporting that is more honest than inventing one.
+                    /\bfn\s+(\$?\w+)/.exec(text.slice(at, open))?.[1] ?? 'unnamed'
+                : language === 'php'
+                    ? /\bfunction\s+(\w+)/.exec(text.slice(at, open))?.[1] ?? 'unnamed'
+                    : (/([\w]+)\s*\([^)]*\)\s*(throws\s+[\w.,\s]+)?$/.exec(signature.trim())?.[1] ?? 'unnamed');
+        const around = text.slice(Math.max(0, at - 200), open);
+        // An annotation disables a test outright. A `t.Skip()` may be conditional - cobra's
+        // TestDeadcodeElimination skips on Windows and runs everywhere else - so it counts only when it
+        // is unconditional, at the top level of the body.
+        const skipped = /@(Disabled|Ignore)\b|\[\s*Ignore\b/.test(around) || skipsUnconditionally(body);
+        found.push({ name, line: lineAt(text, at), body, skipped, callback: '' });
+    }
+    return found;
+}
+/**
+ * A `t.Skip()` that runs whatever happens: at the top level of the body, not inside an `if`. Go
+ * tests commonly skip on one platform and run on the others, and calling those "never runs" is
+ * wrong.
+ */
+function skipsUnconditionally(body) {
+    let depth = 0;
+    for (const line of body.split(String.fromCharCode(10))) {
+        const text = line.trim();
+        if (depth === 0 && /^\w+\s*\.\s*Skip(Now)?\s*\(/.test(text))
+            return true;
+        depth += (line.match(/\{/g) ?? []).length - (line.match(/\}/g) ?? []).length;
+    }
+    return false;
+}
+/**
+ * A Ruby `skip` that turns this test off, rather than one sitting inside a block the test is
+ * handing to something else. Only a call at the body's own indentation counts: anything deeper is
+ * inside a block, and in rspec-core's specs that block is the fixture under test.
+ */
+function skipsAtTopLevel(body) {
+    const lines = body.split(String.fromCharCode(10)).filter((l) => l.trim() !== '');
+    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));
+}
+export { jsTests, pythonTests, rubyTests, bracedTests };

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

@@ -1,3 +1,10 @@
+// Finding the individual tests in a file, and their bodies, without a parser per language.
+//
+// A parser for each of six languages is not the job, and would be the whole job. What is needed is
+// narrower: where each test starts, what text belongs to it, and whether it was marked as skipped.
+// Everything after this reads that text. Where the shape is not recognised, the file is reported as
+// unread rather than judged - a file Tewip cannot see into is not a file full of worthless tests.
+import { bracedTests, jsTests, pythonTests, rubyTests } from './find-tests.js';
 /** Which language this file is, by extension. Unknown extensions are not guessed at. */
 export function languageOf(file) {
     const lower = file.toLowerCase();
@@ -11,12 +18,27 @@ export function languageOf(file) {
         return 'go';
     if (/\.(cs|fs)$/.test(lower))
         return 'csharp';
+    // Phase 36. The assertion vocabulary already knew how these three check things - `expect(x).to`,
+    // `$this->assert`, `assert_eq!` were all on the list - so the only reason a Ruby, PHP or Rust
+    // file was never judged is that it never got this far. Triage has claimed all three for months.
+    if (lower.endsWith('.rb'))
+        return 'ruby';
+    if (lower.endsWith('.php'))
+        return 'php';
+    if (lower.endsWith('.rs'))
+        return 'rust';
     return null;
 }
 /** Does this file look like tests at all? Vouching for a source file is a category error. */
 export function looksLikeTests(file, text) {
     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);
+    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) ||
+        /^\s*(?:RSpec\.)?(?:describe|context)\s+|^\s*(?:x|f)?it\s+["'].*\bdo\b/m.test(text);
     return named || declares;
 }
 /**
@@ -26,7 +48,9 @@ export function looksLikeTests(file, text) {
  * a checker ends up telling somebody that a string in their fixture checks nothing. Found by
  * pointing this at Tewip's own test suite, where it produced 27 confident false accusations.
  */
-export function textRanges(text) {
+/** A Rust char literal: `'a'`, `'\n'`, `'\''`. Anything else beginning with a quote is a lifetime. */
+const RUST_CHAR = new RegExp(`^'(?:${String.raw `\\`}.|[^'${String.raw `\\`}])'`);
+export function textRanges(text, language) {
     const ranges = [];
     const TRIPLES = ['"'.repeat(3), "'".repeat(3)];
     for (let i = 0; i < text.length; i += 1) {
@@ -47,6 +71,14 @@ export function textRanges(text) {
             ranges.push([i, end]);
             i = end;
         }
+        else if (ch === "'" && language === 'rust' && !RUST_CHAR.test(text.slice(i, i + 4))) {
+            // A lone quote in Rust is a lifetime - `&'a str`, `Cow<'_, str>` - and not the start of
+            // anything. Treating it as a quote made the detector swallow the rest of the file, so all
+            // six of ripgrep's #[test] attributes were discarded as being inside a string and the file
+            // was reported as having no tests at all. A char literal is still text, so it is matched
+            // first: a char closes within three characters and a lifetime never closes.
+            continue;
+        }
         else if (ch === '"' || ch === "'" || ch === '`') {
             // A Python docstring runs to the next triple quote, not to the next single one.
             const triple = TRIPLES.find((t) => text.startsWith(t, i));
@@ -58,171 +90,18 @@ export function textRanges(text) {
     return ranges;
 }
 /** Is this offset inside text rather than code? */
-const isText = (ranges, at) => ranges.some(([from, to]) => at > from && at < to);
+export const isText = (ranges, at) => ranges.some(([from, to]) => at > from && at < to);
 export function testsIn(language, text) {
     if (language === 'python')
         return pythonTests(text);
     if (language === 'js')
         return jsTests(text);
+    if (language === 'ruby')
+        return rubyTests(text);
     return bracedTests(language, text);
 }
 /** The line number of an offset, 1-based. */
-const lineAt = (text, index) => text.slice(0, index).split(String.fromCharCode(10)).length;
-/**
- * `it('...', async () => { ... })` and its many spellings, including `test.each`, `it.skip` and a
- * plain `function ()` callback. The body is taken by matching braces from the callback's opening one.
- */
-function jsTests(text) {
-    const found = [];
-    const ranges = textRanges(text);
-    const declaration = /\b(it|test|specify)\s*(\.\s*(skip|only|todo|failing|concurrent|each|for)\s*(\([^)]*\)|`[^`]*`)?\s*)*\(\s*(['"`])((?:\\.|(?!\5)[^\\])*)\5/g;
-    for (const hit of text.matchAll(declaration)) {
-        const at = hit.index ?? 0;
-        if (isText(ranges, at))
-            continue;
-        const open = text.indexOf('{', at + hit[0].length);
-        if (open === -1)
-            continue;
-        const body = braced(text, open);
-        if (body === null)
-            continue;
-        const signature = text.slice(at + hit[0].length, open);
-        found.push({
-            name: hit[6],
-            line: lineAt(text, at),
-            body,
-            skipped: /\.\s*(skip|todo|failing)\b/.test(hit[0]) || /\bxit\s*\(/.test(hit[0]),
-            callback: /\(\s*([A-Za-z_$][\w$]*)\s*\)\s*(=>)?\s*$/.exec(signature.trim())?.[1] ?? '',
-        });
-    }
-    // `xit(...)` and `xtest(...)`, which the pattern above deliberately does not match.
-    for (const hit of text.matchAll(/\bx(it|test)\s*\(\s*(['"`])((?:\\.|(?!\2)[^\\])*)\2/g)) {
-        const at = hit.index ?? 0;
-        if (isText(ranges, at))
-            continue;
-        const open = text.indexOf('{', at + hit[0].length);
-        const body = open === -1 ? null : braced(text, open);
-        found.push({ name: hit[3], line: lineAt(text, at), body: body ?? '', skipped: true, callback: '' });
-    }
-    return found.sort((a, b) => a.line - b.line);
-}
-/** Python has no braces: a test's body is everything indented further than its `def`. */
-function pythonTests(text) {
-    const lines = text.split(String.fromCharCode(10));
-    const ranges = textRanges(text);
-    const offsets = [];
-    let seen = 0;
-    for (const line of lines) {
-        offsets.push(seen);
-        seen += line.length + 1;
-    }
-    const found = [];
-    for (let i = 0; i < lines.length; i += 1) {
-        const hit = /^(\s*)(?:async\s+)?def\s+(test_\w+|test)\s*\(/.exec(lines[i]);
-        if (!hit)
-            continue;
-        if (isText(ranges, offsets[i] + hit[1].length + 1))
-            continue;
-        const indent = hit[1].length;
-        // Nested in another def? Then it is a helper or, in Click's tests, a CLI command that happens to
-        // be named `test`. Only a module-level def, or a method of a test class, is a test.
-        if (nestedInFunction(lines, i, indent))
-            continue;
-        if (hit[2] === 'test' && indent > 0)
-            continue;
-        // A def whose parameters run over several lines ends at the line that closes them, and the body
-        // starts after that. Without this, the parameter list was read as the body and the real body was
-        // thrown away: psf/requests has several, and each came back as a test that compares no value.
-        let signatureEnds = i;
-        let open = 0;
-        for (let j = i; j < lines.length && j < i + 20; j += 1) {
-            open += (lines[j].match(/\(/g) ?? []).length - (lines[j].match(/\)/g) ?? []).length;
-            signatureEnds = j;
-            if (open <= 0)
-                break;
-        }
-        const body = [];
-        for (let j = signatureEnds + 1; j < lines.length; j += 1) {
-            const line = lines[j];
-            if (line.trim() === '') {
-                body.push(line);
-                continue;
-            }
-            const width = line.length - line.trimStart().length;
-            if (width <= indent)
-                break;
-            body.push(line);
-        }
-        // Decorators sit above the def, so skipping is read upwards.
-        const above = lines.slice(Math.max(0, i - 4), i).join(String.fromCharCode(10));
-        // A conditional skip runs somewhere - `skipif` on Windows registry tests in psf/requests runs
-        // on Windows - so only an unconditional skip means the test never runs. `xfail` runs too.
-        const skipped = /@\s*(pytest\s*\.\s*mark\s*\.\s*skip|unittest\s*\.\s*skip)\b/.test(above) && !/skipif|skipUnless|xfail/.test(above);
-        found.push({ name: hit[2], line: i + 1, body: body.join(String.fromCharCode(10)), skipped, callback: '' });
-    }
-    return found;
-}
-/** Is the def on line `i` nested inside another def, rather than inside a class or at the top? */
-function nestedInFunction(lines, i, indent) {
-    for (let j = i - 1; j >= 0; j -= 1) {
-        const line = lines[j];
-        if (line.trim() === '')
-            continue;
-        const width = line.length - line.trimStart().length;
-        if (width >= indent)
-            continue;
-        return /^\s*(async\s+)?def\s/.test(line);
-    }
-    return false;
-}
-/** JUnit, Kotlin, Scala, Go and C#: an annotation or a naming convention, then a braced body. */
-function bracedTests(language, text) {
-    const found = [];
-    const ranges = textRanges(text);
-    const declaration = language === 'go'
-        ? // Only a Test function. A Benchmark asserts nothing by design, an Example is checked against
-            // its own Output comment, and a Fuzz target is not a test - all three were condemned as
-            // "checks nothing" in gorilla/mux before this narrowed.
-            /\bfunc\s+(Test)(\w+)\s*\(\s*\w+\s+\*testing\.[TB]\s*\)\s*\{/g
-        : /(@Test\b[^\n]*|\[\s*(?:Test|Fact|Theory)[^\]]*\]|@(?:ParameterizedTest|RepeatedTest)\b)/g;
-    for (const hit of text.matchAll(declaration)) {
-        const at = hit.index ?? 0;
-        if (isText(ranges, at))
-            continue;
-        const open = language === 'go' ? text.indexOf('{', at) : text.indexOf('{', text.indexOf('(', at + hit[0].length));
-        if (open === -1)
-            continue;
-        const body = braced(text, open);
-        if (body === null)
-            continue;
-        const signature = text.slice(at, open);
-        // `void foo() throws IOException` still names foo. Without allowing the throws clause, every
-        // checked-exception test in gson was reported as 'unnamed'.
-        const name = language === 'go' ? hit[1] + hit[2] : /([\w]+)\s*\([^)]*\)\s*(throws\s+[\w.,\s]+)?$/.exec(signature.trim())?.[1] ?? 'unnamed';
-        const around = text.slice(Math.max(0, at - 200), open);
-        // An annotation disables a test outright. A `t.Skip()` may be conditional - cobra's
-        // TestDeadcodeElimination skips on Windows and runs everywhere else - so it counts only when it
-        // is unconditional, at the top level of the body.
-        const skipped = /@(Disabled|Ignore)\b|\[\s*Ignore\b/.test(around) || skipsUnconditionally(body);
-        found.push({ name, line: lineAt(text, at), body, skipped, callback: '' });
-    }
-    return found;
-}
-/**
- * A `t.Skip()` that runs whatever happens: at the top level of the body, not inside an `if`. Go
- * tests commonly skip on one platform and run on the others, and calling those "never runs" is
- * wrong.
- */
-function skipsUnconditionally(body) {
-    let depth = 0;
-    for (const line of body.split(String.fromCharCode(10))) {
-        const text = line.trim();
-        if (depth === 0 && /^\w+\s*\.\s*Skip(Now)?\s*\(/.test(text))
-            return true;
-        depth += (line.match(/\{/g) ?? []).length - (line.match(/\}/g) ?? []).length;
-    }
-    return false;
-}
+export const lineAt = (text, index) => text.slice(0, index).split(String.fromCharCode(10)).length;
 /**
  * The text between the brace at `open` and the one that closes it, skipping over strings, template
  * literals, comments and regular expressions - all of which can hold a brace that closes nothing.

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

@@ -34,7 +34,10 @@ export function testFiles(root, paths) {
             }
             if (stat.isDirectory())
                 walk(full, depth + 1);
-            else if (/\.(js|jsx|mjs|cjs|ts|tsx|mts|cts|py|java|kt|kts|scala|groovy|go|cs|fs)$/i.test(entry))
+            // rb, php and rs added in Phase 36. They were missing here as well as in languageOf, so even
+            // a file named outright came back "0 test(s) read in 0 file(s)" - which reads like a clean
+            // answer and is not one.
+            else if (/\.(js|jsx|mjs|cjs|ts|tsx|mts|cts|py|java|kt|kts|scala|groovy|go|cs|fs|rb|php|rs)$/i.test(entry))
                 found.push(full);
         }
     };

package/dist/engine/vouch/vouch.js

@@ -95,6 +95,17 @@ function judge(file, test, helpers) {
     const unknown = called.find((name) => /^(check|verify|ensure|validate|assert|expect|should|confirm)/i.test(name));
     if (unknown)
         return { ...at, verdict: 'cannot-tell', evidence: `${unknown}(…)`, why: `${unknown}() may assert, and it is not in this file, so Tewip will not call this either way` };
+    // A body whose whole content is one call to something defined in another file. The check is very
+    // likely inside it, and Tewip cannot follow it there, so "it compares no value" would be a
+    // confident wrong answer. Rails's own `test_constantize` is exactly this: one line calling
+    // `run_constantize_tests_on`, which lives in a shared helper and asserts plenty.
+    const statements = body
+        .split(String.fromCharCode(10))
+        .map((l) => l.trim())
+        .filter((l) => l !== '' && !l.startsWith('#') && !l.startsWith('//'));
+    if (statements.length === 1 && /^[A-Za-z_][\w.:]*\s*[({]/.test(statements[0])) {
+        return { ...at, verdict: 'cannot-tell', evidence: statements[0].slice(0, 80), why: 'its whole body is one call to something defined elsewhere, which may assert; Tewip will not call this either way' };
+    }
     if (unfinished.length > 0)
         return { ...at, verdict: 'unfinished-expectation', evidence: unfinished[0], why: MEANS['unfinished-expectation'] };
     if (tautology.length > 0)

package/package.json

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