@rigour-labs/core 6.10.0 → 6.10.1

package/dist/gates/context.js

@@ -23,7 +23,7 @@ export class ContextGate extends Gate {
             return [];
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
-            patterns: ['**/*.{ts,js,tsx,jsx,py,go,java,cs,rb,kt,swift,rs,php}'],
+            patterns: ['**/*.{ts,js,tsx,jsx,py,go,java,cs,rb,kt,scala,swift,rs,php}'],
             ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/build/**',
                 '**/studio-dist/**', '**/.next/**', '**/coverage/**', '**/out/**',
                 '**/*.test.*', '**/*.spec.*', '**/examples/**', '**/docs/**'],
@@ -93,10 +93,10 @@ export class ContextGate extends Gate {
             const casing = this.detectCasing(match[1]);
             this.addPattern(patterns, 'function', { casing, file, count: 1 });
         }
-        // Class declarations: `class` opening a line (after modifiers: C# partial, Kotlin enum/inner/value/annotation
-        // and the rest), its name on the same line. Not the end of
+        // Class declarations: `class` opening a line (after modifiers: C# partial, Kotlin enum/inner/value/annotation,
+        // Scala case/implicit and a qualified `private[pkg]`, and the rest), its name on the same line. Not the end of
         // `dataclass`, and not the word in a comment or a string ("# this class of errors").
-        const classMatches = content.matchAll(/^[ \t]*(?:(?:export|default|abstract|public|private|protected|internal|final|sealed|static|data|open|partial|enum|inner|value|annotation)[ \t]+)*class[ \t]+([A-Za-z_$][A-Za-z0-9_$]*)/gm);
+        const classMatches = content.matchAll(/^[ \t]*(?:(?:export|default|abstract|public|private|protected|internal|final|sealed|static|data|open|partial|enum|inner|value|annotation|case|implicit)(?:\[[\w.]+\])?[ \t]+)*class[ \t]+([A-Za-z_$][A-Za-z0-9_$]*)/gm);
         for (const match of classMatches) {
             const casing = this.detectCasing(match[1]);
             this.addPattern(patterns, 'class', { casing, file, count: 1 });

package/dist/review/typed/redundancy.js

@@ -5,7 +5,8 @@
  *                             equals on `col` (SQL excludes NULL there);
  *   nullable-filtered-column  the query filters `col` non-null, the row type still says `| null`,
  *                             so every guard on it is dead;
- *   optional-always-supplied  an optional property every host object supplies;
+ *   optional-always-supplied  an optional property every host object supplies (unless values of the type are
+ *                             also read back from JSON, where data written before the member existed lacks it);
  *   write-only-property       a property the hosts set and nothing reads. When the value only
  *                             leaves through serialisation to a callee the program does not declare
  *                             (a wire payload), that is a hint for the reviewer, not a block.
@@ -263,6 +264,53 @@ function redundancyFailures(typed, changedLines, config) {
         escapeMemo.set(t.sym, found);
         return found;
     };
+    // Values of the type read back from JSON (JSON.parse, readJson, a response's .json()) as the type: an assertion,
+    // an annotated variable, a type argument, or the declared return of the function that returns them. Data written
+    // before a member existed lacks it, so the member stays optional however every host in the code supplies it now.
+    const holdsType = (t, ty) => {
+        if (!ty)
+            return false;
+        const awaited = checker.getAwaitedType(ty) ?? ty;
+        return mentionsType(t, awaited) || checker.getIndexInfosOfType(awaited).some(info => mentionsType(t, info.type));
+    };
+    const JSON_READ = /(?:^|\.)(?:JSON\.parse|readJson|readJsonSync|json)$/;
+    const persistedMemo = new Map();
+    const readFromJson = (t) => {
+        if (persistedMemo.has(t.sym))
+            return persistedMemo.get(t.sym);
+        let found;
+        for (const sf of typed.appSources) {
+            if (found)
+                break;
+            if (!/JSON\.parse|readJson|\.json\(/.test(sf.text))
+                continue;
+            walk(sf, node => {
+                if (found || !ts.isCallExpression(node) || !JSON_READ.test(node.expression.getText()))
+                    return;
+                if (node.typeArguments?.some(a => holdsType(t, checker.getTypeFromTypeNode(a)))) {
+                    found = at(node);
+                    return;
+                }
+                let site = node;
+                while (ts.isParenthesizedExpression(site.parent) || ts.isAwaitExpression(site.parent) || ts.isNonNullExpression(site.parent))
+                    site = site.parent;
+                const p = site.parent;
+                const target = ts.isAsExpression(p) || ts.isTypeAssertionExpression(p) || ts.isSatisfiesExpression(p) ? p.type
+                    : ts.isVariableDeclaration(p) && p.initializer === site ? p.type
+                        : undefined;
+                if (target && holdsType(t, checker.getTypeFromTypeNode(target))) {
+                    found = at(node);
+                    return;
+                }
+                const fn = ts.isReturnStatement(p) ? ts.findAncestor(p, ts.isFunctionLike) : ts.isArrowFunction(p) && p.body === site ? p : undefined;
+                const signature = fn && checker.getSignatureFromDeclaration(fn);
+                if (fn?.type && signature && holdsType(t, checker.getReturnTypeOfSignature(signature)))
+                    found = at(node);
+            });
+        }
+        persistedMemo.set(t.sym, found);
+        return found;
+    };
     // A property is read when any non-test file accesses or destructures it; a spread only passes it on.
     const isWriteTarget = (access) => ts.isBinaryExpression(access.parent) && access.parent.left === access && access.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken;
     const isRead = (t, name) => {
@@ -317,7 +365,10 @@ function redundancyFailures(typed, changedLines, config) {
                 const all = hosts.length + outside.length;
                 if (all > 0 && supplied.length === hosts.length && outside.every(s => supplyRe(name).test(s.text))) {
                     const text = `${member} is optional but every host supplies it (${all} host(s), e.g. ${hosts[0] ? at(hosts[0]) : outside[0].file}).`;
-                    if (published)
+                    const stored = readFromJson(t);
+                    if (stored)
+                        hints.push(`optional-always-supplied ${at(m)}: ${text} Values of it are read back from JSON at ${stored}, where data written before the member existed lacks it: keep it optional unless that data is migrated`);
+                    else if (published)
                         publish('optional-always-supplied', m, text);
                     else
                         report('optional-always-supplied', 'Optional member every host supplies', anchor, text, 'Make it required and drop the `?.` and the fallbacks on it.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.10.0",
+  "version": "6.10.1",
   "description": "Rigour's review engine: deterministic gates on changed lines, rules and lessons learned from your team's fixes, and per-check precision from what you fix versus dismiss, across TypeScript, JavaScript, Python, Go, Ruby and C#.",
   "engines": {
     "node": ">=22.13"
@@ -75,11 +75,11 @@
     "@anthropic-ai/sdk": "^0.132.1",
     "pg": "^8.16.3",
     "openai": "^5.23.2",
-    "@rigour-labs/brain-darwin-x64": "6.10.0",
-    "@rigour-labs/brain-darwin-arm64": "6.10.0",
-    "@rigour-labs/brain-linux-arm64": "6.10.0",
-    "@rigour-labs/brain-linux-x64": "6.10.0",
-    "@rigour-labs/brain-win-x64": "6.10.0"
+    "@rigour-labs/brain-darwin-arm64": "6.10.1",
+    "@rigour-labs/brain-linux-arm64": "6.10.1",
+    "@rigour-labs/brain-win-x64": "6.10.1",
+    "@rigour-labs/brain-darwin-x64": "6.10.1",
+    "@rigour-labs/brain-linux-x64": "6.10.1"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",