@redue/cli 0.1.0-alpha.20 → 0.1.0-alpha.21

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.1.0-alpha.21 — 2026-10-25
+
+`init` finds more typecheck scripts and no longer stops in large monorepos.
+In the census of 108 public TypeScript repos, the general recipe qualifies 26
+typecheck scripts (was 23) and 20 lint scripts.
+
+- `init` prefers typecheck scripts named `tsc`, `types` or `lint:types`, then
+  takes one script named under a typecheck name (`typecheck:test`,
+  `tsc:build`, ...), watch scripts aside. Two such scripts are reported as
+  ambiguous unless a command alone decides. Scripts named `build` or `dev`
+  that run tsc are not taken: they write output.
+- A workspace of more than 50 packages no longer stops `init`. It reads up to
+  1000 packages, proposes the root's checks, and past 50 packages skips
+  per-package checks and says so (`skipped` in `--json`, a "Skipped:" line
+  otherwise). Five census repos got no check at all before.
+- General recipe: pnpm 12 writes its workspace state through a temporary
+  `node_modules/.tmpXXXXXX` file. Like the state file, it counts as the run's
+  output when the pnpm executable ran. Known limit: the agent eval's seed lint
+  run on one pnpm 12 project is still UNVERIFIED for an input event REDUE does
+  not yet name.
+
+- Contributors: the agent eval records each run's seed and final receipt,
+  and the files a session changed when its seed run is not stable.
+
 ## 0.1.0-alpha.20 — 2026-10-24
 
 A fix for agents on macOS.

package/bin/redue.mjs

@@ -120,7 +120,7 @@ if(command==='init'){
     package_manager:discovery.manager.name,version:discovery.manager.version,
     installation_layout:discovery.manager.layout,
     issue:discovery.observationIssue||discovery.manager.issue,workspaces:discovery.workspaces,
-    ambiguous:discovery.ambiguous,
+    ambiguous:discovery.ambiguous,skipped:discovery.skipped||[],
     checks:discovery.checks.map(({config:check,level,reason})=>({name:check.name,
       script:check.script||null,command:check.command||null,
       workspace:check.workspace||null,level,reason})),config:configFile,
@@ -139,6 +139,7 @@ if(command==='init'){
     }
     for(const row of summary.ambiguous)
       console.log(`  ${row.kind}: ambiguous scripts (${row.scripts.join(', ')}); choose one explicitly`);
+    for(const row of summary.skipped)console.log(`  Skipped: ${row.reason}`);
     if(!summary.checks.length)console.log('No useful existing verification scripts found.');
     console.log(configured?`Existing ${configFile} left unchanged.`:
       dryRun?`Preview only; ${configFile} was not written.`:

package/docs/user/node-script.md

@@ -67,13 +67,14 @@ UNVERIFIED. At the top of each `node_modules`, only `.cache`, `.vite`,
 `.vite-temp`, `.vitest` and `.vitest-cache` are left out, and `*.tsbuildinfo`
 anywhere in it.
 
-Two installed files are rewritten by tools during a run: pnpm's
+Two installed files are rewritten by tools during a run. pnpm rewrites
 `node_modules/.pnpm-workspace-state-v1.json` at the first run after an
-install, and the `node_modules/.vue-global-types/*.d.ts` files vue-tsc writes
-before it reads them. They stay inputs. When they are the only files a run
-changed, and the run wrote them (a recorded process wrote the file, or the
-pnpm executable ran, for its state), the result is kept with the files as the
-run left them, and a later change to them makes it STALE.
+install, through a temporary `node_modules/.tmpXXXXXX` file. vue-tsc writes
+`node_modules/.vue-global-types/*.d.ts` before it reads them. These files stay
+inputs. When they are the only files a run changed, and the run wrote them,
+the result is kept with the files as the run left them. A recorded process
+counts as writing a file it wrote; for pnpm's files, the pnpm executable must
+have run. A later change to them makes the result STALE.
 
 It does not mean a rerun would give the same result: a test that depends on
 the time or on randomness can pass now and fail later on the same inputs.

package/docs/user/supported-projects.md

@@ -12,7 +12,10 @@ is known. When npm is not pinned in `package.json`,
 leaves the version unknown rather than guessing if that inspection fails.
 
 At the repository root, `init` looks for existing typecheck, test, lint, and
-build scripts. It prefers familiar script names, then unique recognizable
+build scripts. It prefers familiar script names (for typecheck: `typecheck`,
+`type-check`, `check-types`, `check:types`, `types:check`, `tsc`, `types`,
+`lint:types`), then for typecheck one script named under such a name
+(`typecheck:test`, `tsc:build`; not a watch script), then unique recognizable
 `tsc`, Vitest/Jest, ESLint, or Vite commands under other names. Multiple
 matches are reported as ambiguous rather than guessed. It never creates a new
 project script. Without `--recipe`, `init` tries the strict recipes below first,
@@ -30,7 +33,9 @@ not npm. Full installed compiler identity, config/membership, installed inputs
 and relevant Node environment are checked before reuse. See the
 [exact direct boundary](direct-typescript.md). Unsupported plugins, preloads,
 configuration or outside-root inputs remain UNVERIFIED. Root and package-level npm/Yarn workspace scripts are discovered from
-`package.json` workspace declarations. Pinned Yarn 4 `node-modules`/classic
+`package.json` workspace declarations. In a workspace of more than 50
+packages, `init` proposes the root's checks only and names what it skipped;
+add package checks to the config yourself. Up to 1000 packages are read. Pinned Yarn 4 `node-modules`/classic
 workspaces with a standalone `tsc -p .` script, local TypeScript, a conventional
 `src` include, and Node module resolution can qualify automatically. For one
 workspace, use `redue init --workspace NAME --check typecheck`; it writes only

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@redue/cli",
   "private": false,
-  "version": "0.1.0-alpha.20",
+  "version": "0.1.0-alpha.21",
   "publishConfig": {
     "access": "public",
     "tag": "alpha"

package/src/node-onboarding.mjs

@@ -4,6 +4,7 @@ import {commandLineIssue,scriptCheckInputs,scriptPath,scriptProject,scriptQualif
 // Init proposes the general recipe for typecheck and lint scripts; test
 // scripts use the direct test recipe (Vitest, Jest).
 const generalKinds=['typecheck','lint'];
+const perPackageLimit=50;
 import fs from 'node:fs';
 import path from 'node:path';
 import {spawnSync} from 'node:child_process';
@@ -17,7 +18,7 @@ import {partName,tscRuns} from './typescript-invocation.mjs';
 const exists=file=>{try{fs.accessSync(file);return true;}catch{return false;}};
 const readJson=file=>JSON.parse(fs.readFileSync(file,'utf8'));
 const scriptNames={
-  typecheck:['typecheck','type-check','check:types','types:check','check-types'],
+  typecheck:['typecheck','type-check','check:types','types:check','check-types','tsc','types','lint:types'],
   test:['test','test:unit','test:check'],
   lint:['lint','lint:check'],
   build:['build'],
@@ -160,10 +161,16 @@ function classify(kind,scriptName,script,pkg,managerInfo,root) {
     'Vite detected; build environment and generated inputs need review':
     'build script detected; generated and runtime inputs need review'};
 }
+// Typecheck scripts named under a typecheck name (`typecheck:test`,
+// `tsc:build`), watch scripts aside.
+const typecheckFamily=/^(?:typecheck|type-check|check-types|check:types|types:check|tsc):(?!.*watch)/;
 function selectScript(kind,names,scripts) {
   const preferred=names.find(name=>typeof scripts[name]==='string'&&
     scripts[name].trim()&&!/^echo\s+["']?Error: no test specified/.test(scripts[name]));
   if(preferred)return {script:preferred};
+  const family=kind==='typecheck'?Object.keys(scripts).filter(name=>typecheckFamily.test(name)&&
+    typeof scripts[name]==='string'&&scripts[name].trim()&&!/(?:^|\s)(?:--watch|-w)(?:\s|$)/.test(scripts[name])):[];
+  if(family.length===1)return {script:family[0]};
   const candidates=Object.keys(scripts).filter(name=>{
     const value=scripts[name]?.trim();
     if(typeof value!=='string')return false;
@@ -177,7 +184,7 @@ function selectScript(kind,names,scripts) {
   const exact=kind==='typecheck'?candidates.filter(name=>exactTypeScript(scripts[name])):[];
   if(exact.length===1)return {script:exact[0]};
   return candidates.length===1?{script:candidates[0]}:
-    candidates.length>1?{ambiguous:candidates}:{};
+    candidates.length>1?{ambiguous:candidates}:family.length>1?{ambiguous:family}:{};
 }
 // A pnpm workspace package's TypeScript run, as its check's command, cwd and inputs.
 function pnpmCheck(root,name,dir,manifest,run){
@@ -233,7 +240,7 @@ export function discoverNodeProject(root,{recipe=null}={}) {
     workspacePatterns.some(value=>typeof value!=='string'||path.isAbsolute(value)||
       value.split('/').includes('..'))))
     throw Error('workspace patterns need a supported project-relative package list');
-  const checks=[],ambiguous=[];
+  const checks=[],ambiguous=[],skipped=[];
   for(const [kind,names] of Object.entries(scriptNames)) {
     const selected=selectScript(kind,names,scripts),script=selected.script;
     if(selected.ambiguous)ambiguous.push({kind,scripts:selected.ambiguous});
@@ -304,8 +311,11 @@ export function discoverNodeProject(root,{recipe=null}={}) {
     checks.push({config:check,...classification});
   }
   if(workspaces&&!observationIssue){
-    const seen=new Set();
-    for(const {file,pkg:member} of workspaceManifests(root,workspacePatterns)){
+    const seen=new Set(),members=workspaceManifests(root,workspacePatterns);
+    // Past 50 packages, init proposes the root's checks only and says so.
+    if(members.length>perPackageLimit)skipped.push({kind:'workspace',packages:members.length,
+      reason:`${members.length} workspace packages, more than ${perPackageLimit}: per-package checks were not proposed; add the ones you need to the config`});
+    for(const {file,pkg:member} of members.length>perPackageLimit?[]:members){
       const dir=path.posix.dirname(file),name=member.name;
       if(typeof name!=='string'||!name||seen.has(name)){
         ambiguous.push({kind:'workspace',scripts:[dir],reason:'missing or duplicate package name'});
@@ -367,6 +377,6 @@ export function discoverNodeProject(root,{recipe=null}={}) {
     }
   }
   return {schema:1,root,manager:pm,observationIssue,workspaces,node:process.version,
-    checks,ambiguous,
+    checks,ambiguous,skipped,
     config:{schema:1,packageManager:pm.name||'unknown',checks:checks.map(row=>row.config)}};
 }

package/src/node-script.mjs

@@ -42,19 +42,21 @@ export function scriptCheckInputs(dirs=[]){
   installedInputs:[...modules.flatMap(at=>[`${at}/**`,`!${at}/.cache/**`,`!${at}/.vite/**`,`!${at}/.vite-temp/**`,
     `!${at}/.vitest/**`,`!${at}/.vitest-cache/**`,`!${at}/**/*.tsbuildinfo`]),...installState]};
 }
-// Installed files a tool rewrites during a run: the workspace state pnpm
-// writes at the first run after an install, and the global types vue-tsc
-// writes before it reads them, in a workspace node_modules. They stay inputs;
-// when they are a run's only change and the run wrote them, the run is kept
-// with the files as the run left them.
+// Installed files a tool rewrites during a run. pnpm writes its workspace
+// state in the root node_modules at the first run after an install, through
+// a temporary .tmpXXXXXX file it renames. vue-tsc writes its global types in
+// a workspace node_modules before it reads them. They stay inputs. When they
+// are a run's only change and the run wrote them, the run is kept with the
+// files as the run left them.
 const pnpmState=rel=>/^node_modules\/\.pnpm-workspace-state(?:-v\d+)?\.json$/.test(rel);
+const pnpmTemp=rel=>/^node_modules\/\.tmp[A-Za-z0-9]{6}$/.test(rel);
 const vueTypes=rel=>{const parts=rel.split('/');
   return /^[^/]+\.d\.ts$/.test(parts.at(-1))&&parts.at(-2)==='.vue-global-types'&&parts.at(-3)==='node_modules'&&
     !parts.slice(0,-3).includes('node_modules')&&!rel.startsWith('external:');};
-export const toolOutputPath=rel=>pnpmState(rel)||vueTypes(rel);
-// The run wrote it: a recorded process did, or the pnpm executable ran, which
-// writes its state natively.
-export const toolOutput=(rel,guard)=>toolOutputPath(rel)&&(guard.wroteInstalled(rel)||pnpmState(rel)&&guard.opaque);
+export const toolOutputPath=rel=>pnpmState(rel)||pnpmTemp(rel)||vueTypes(rel);
+// The run wrote it: a recorded process did, or, for pnpm's files, the pnpm
+// executable ran, which writes them natively.
+export const toolOutput=(rel,guard)=>toolOutputPath(rel)&&(guard.wroteInstalled(rel)||(pnpmState(rel)||pnpmTemp(rel))&&guard.opaque);
 // The installed paths the recorder treats as observed by identity.
 export const scriptInstalledPaths=(root,dirs=[])=>[...modulesDirs(dirs),...installState].map(at=>path.join(root,at));
 // Variables a recorded run cannot be seen reading: Node's and libc's (as in

package/src/workspace-manifests.mjs

@@ -5,7 +5,9 @@ import path from 'node:path';
 import {spawnSync} from 'node:child_process';
 import {patternMatcher} from './glob.mjs';
 
-export function workspaceManifests(root,patterns) {
+// Up to 1000 packages: every workspace node_modules is an installed input of
+// a root check, so all of them are listed.
+export function workspaceManifests(root,patterns,limit=1000) {
   const listing=spawnSync('git',['ls-files','--cached','--others','--exclude-standard',
     '-z','--',':(glob)**/package.json'],{cwd:root,encoding:'utf8',timeout:5000,
     maxBuffer:32*1024*1024,stdio:['ignore','pipe','ignore'],
@@ -17,6 +19,6 @@ export function workspaceManifests(root,patterns) {
     const dir=path.posix.dirname(file);
     return dir!=='.'&&!dir.split('/').includes('node_modules')&&included(dir);
   }).sort();
-  if(matched.length>50)throw Error('more than 50 workspace packages found; select checks explicitly');
+  if(matched.length>limit)throw Error(`more than ${limit} workspace packages found; select checks explicitly`);
   return matched.map(file=>({file,pkg:JSON.parse(fs.readFileSync(path.join(root,file),'utf8'))}));
 }