@arjunkhera/atlas 0.3.46 → 0.3.49

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "atlas",
-  "version": "0.3.46",
+  "version": "0.3.49",
   "description": "Atlas: the delivery lifecycle, its crews and the Atlas tools, for any repository.",
   "author": {
     "name": "Arjun Khera"

package/door/cli.mjs

@@ -35,6 +35,7 @@ import { sweepCommand as testsSweep, coversCommand as testsCovers } from '../tes
 import { issuesCommand as testsIssues } from './lib/issues.mjs';
 import { changedCommand as testsChanged } from './lib/changed-tests.mjs';
 import { beforeCommand as testsBefore } from './lib/fails-before.mjs';
+import { afterCommand as testsAfter } from './lib/passes-after.mjs';
 import { upkeepCommand } from './lib/upkeep.mjs';
 import { gateCommand } from './lib/gate.mjs';
 import { judgeCommand } from './lib/judge.mjs';
@@ -44,7 +45,7 @@ const ATLAS_VERSION = packagePackageVersion(PACKAGE_ROOT);
 
 const HELP = `atlas — the door into a repo's Atlas files
 
-  atlas tooling write --root <repo>    write both Atlas files into a repo
+  atlas tooling write --root <repo>    write the Atlas files into a repo
   atlas tooling pr --root <repo>       the same, as one pull request
       --replace-unknown                also replace a copy that is in no release
       --workflow                       rewrite only the workflow, for a repo whose check is current
@@ -95,6 +96,11 @@ const HELP = `atlas — the door into a repo's Atlas files
       --old <file> --new <file>        read the two run files and give the answer; runs nothing
       --out <file>                     write the JSON here; default the terminal
       --text                           print a short table instead of the JSON
+  atlas tests after --root <repo> --base <ref>   the old version of each changed or removed test case must pass on the new code; exit 1 when one goes to the owner
+      --head <ref>                     the head of the pull request; default HEAD
+      --list <file>                    a changed-test list from atlas tests changed; default the command makes it
+      --out <file>                     write the JSON here; default the terminal
+      --text                           print a short table instead of the JSON
   atlas tests named --root <area>      list the assertions that a pull request names
       --base <ref>                     the base: an assertion is named when its words changed or it is new
       --covers                         also name the assertions of a scenario whose covers path the change touches
@@ -232,7 +238,7 @@ function toolingCommand(chosen) {
     for (const row of result.rows) line(`  ${row.state.padEnd(10)} ${row.path}  sha256 ${row.sha256.slice(0, 12)}…`);
     line('');
     line(result.changed
-      ? 'Both files come from the package. No hand step, and no edit by hand afterwards.'
+      ? 'The files come from the package. No hand step, and no edit by hand afterwards.'
       : 'Nothing changed. Both files already match the package.');
     return 0;
   } catch (error) {
@@ -366,6 +372,7 @@ async function testsCommand(chosen) {
   if (what === 'proof') return testsProof({ run: chosen.run, own: chosen.own, evidence: chosen.evidence, base: chosen.base, covers: Boolean(chosen.covers) }, root, line);
   if (what === 'verdict') return testsVerdict({ run: chosen.run, base: chosen.base, evidence: chosen.evidence, covers: Boolean(chosen.covers) }, root, line);
   if (what === 'changed') return testsChanged({ base: chosen.base, head: chosen.head, out: chosen.out, text: Boolean(chosen.text) }, root, line);
+  if (what === 'after') return testsAfter({ base: chosen.base, head: chosen.head, list: chosen.list, out: chosen.out, text: Boolean(chosen.text) }, root, line);
   if (what === 'before') return testsBefore({ base: chosen.base, head: chosen.head, list: chosen.list, out: chosen.out, side: chosen.side, old: chosen.old, new: chosen.new, text: Boolean(chosen.text) }, root, line);
   if (what === 'named') return testsNamed({ base: chosen.base, covers: Boolean(chosen.covers) }, root, line);
   if (what === 'sweep') return testsSweep({ evidence: chosen.evidence, since: chosen.since, base: chosen.base, out: chosen.out, text: Boolean(chosen.text) }, root, line);
@@ -373,7 +380,7 @@ async function testsCommand(chosen) {
   if (what === 'kept') return (await runKept({ root, evidenceDir: chosen.evidence, only: chosen.scenario ?? null, write: (text) => process.stdout.write(text) })).exit;
   if (what === 'rerun') return testsRerun({ run: chosen.run, evidence: chosen.evidence, tests: chosen.tests, language: chosen.language ?? 'javascript' }, root, line);
   if (what === 'issues') return testsIssues({ findings: chosen.findings, repo: chosen.repo, max: chosen.max, bot: chosen.bot, dryRun: Boolean(chosen['dry-run']), args: [...chosen._, ...Object.values(chosen).filter((v) => typeof v === 'string')] }, line);
-  throw new Error(`there is no tests verb "${what ?? ''}". Use check, write, proof, verdict, named, changed, before, sweep, covers, kept, issues or rerun.`);
+  throw new Error(`there is no tests verb "${what ?? ''}". Use check, write, proof, verdict, named, changed, before, after, sweep, covers, kept, issues or rerun.`);
 }
 
 function upkeepVerb(chosen) {

package/door/lib/fails-before.mjs

@@ -19,7 +19,8 @@
 // Green does not mean proven: the gate counts only `proven` cases (proven_count).
 // The command runs head code. It holds no secret: each run gets a fixed environment and nothing else.
 // In CI each side runs in its own job on a fresh runner (--side old, --side new), and a third job
-// reads both run files (--old, --new) with the base copy of Atlas. Each tree comes from git archive.
+// reads both run files (--old, --new) with the base copy of Atlas. Each tree comes from git archive,
+// and then becomes a new git repo with one commit, so a test that needs git still runs.
 import { spawnSync } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
@@ -50,11 +51,31 @@ export function runnerOf(path) {
   return null;
 }
 
-// Skips a string, a template string or a comment at `i`. Returns the index after it, or `i`.
+// A slash starts a regular expression when the code before it cannot end a value.
+function regexAt(src, i) {
+  let j = i - 1;
+  while (j >= 0 && /\s/.test(src[j])) j -= 1;
+  if (j < 0 || '(,=:[!&|?{};+-*%<>~^'.includes(src[j])) return true;
+  const word = /([A-Za-z_$][\w$]*)$/.exec(src.slice(Math.max(0, j - 10), j + 1));
+  return Boolean(word && ['return', 'typeof', 'case', 'in', 'of', 'void', 'delete', 'throw', 'yield', 'await'].includes(word[1]));
+}
+
+// Skips a string, a template string, a regular expression or a comment at `i`. Returns the index
+// after it, or `i`.
 function skip(src, i) {
   const c = src[i];
   if (c === '/' && src[i + 1] === '/') { const end = src.indexOf('\n', i); return end < 0 ? src.length : end; }
   if (c === '/' && src[i + 1] === '*') { const end = src.indexOf('*/', i + 2); if (end < 0) throw new Error('open comment'); return end + 2; }
+  if (c === '/' && regexAt(src, i)) {
+    let inClass = false;
+    for (let j = i + 1; j < src.length && src[j] !== '\n'; j += 1) {
+      if (src[j] === '\\') { j += 1; continue; }
+      if (src[j] === '[') inClass = true;
+      else if (src[j] === ']') inClass = false;
+      else if (src[j] === '/' && !inClass) { j += 1; while (/[a-z]/.test(src[j] ?? '')) j += 1; return j; }
+    }
+    throw new Error('open regular expression');
+  }
   if (c === '"' || c === "'" || c === '`') {
     for (let j = i + 1; j < src.length; j += 1) {
       if (src[j] === '\\') { j += 1; continue; }
@@ -67,8 +88,7 @@ function skip(src, i) {
   return i;
 }
 
-// The index after the bracket that closes the one at `open`. A regular expression is read as code,
-// so a bracket inside one can end a case early; then the text still differs where the case differs.
+// The index after the bracket that closes the one at `open`.
 function close(src, open) {
   const pair = { '(': ')', '{': '}', '[': ']' };
   const stack = [];
@@ -86,6 +106,19 @@ function close(src, open) {
   throw new Error('open bracket');
 }
 
+// The fixed name of a string at `i`, with its escapes read. null for a template with a ${…} in it.
+function nameAt(src, i) {
+  const raw = src.slice(i + 1, skip(src, i) - 1);
+  if (src[i] === '`' && /(^|[^\\])\$\{/.test(raw)) return null;
+  const named = { n: '\n', t: '\t', r: '\r', b: '\b', f: '\f', v: '\v', 0: '\0' };
+  return raw.replace(/\\(u\{[0-9a-fA-F]+\}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|\n|.)/g, (_, e) => {
+    if (e[0] === 'u' && e.length > 1) return String.fromCodePoint(parseInt(e.replace(/[u{}]/g, ''), 16));
+    if (e[0] === 'x' && e.length === 3) return String.fromCharCode(parseInt(e.slice(1), 16));
+    if (e === '\n') return '';
+    return named[e] ?? e;
+  });
+}
+
 // The test cases of one file: { cases: Map of name to its text, rest, duplicates }. `rest` is the
 // text outside every case, so an edit there (a beforeEach, a shared value) can mark every case.
 // null when the file cannot be read to the end. JavaScript: each test(…) or it(…) call whose first
@@ -111,13 +144,24 @@ export function casesOf(text, path) {
         i = j - 1;
       }
     } else {
-      const call = /(?<![\w.$])(test|it)(\.(?:only|skip|todo))?\(\s*(["'`])([^"'`\n]*)\3/g;
+      const call = /(?<![\w.$])(test|it)(\.(?:only|skip|todo))?\(\s*(?=["'`])/g;
       let m;
       let from = 0;
+      // scan walks the code up to each match, so a test( inside a string or a comment is no case.
+      let scan = 0;
       while ((m = call.exec(src))) {
         if (m.index < from) continue;
+        if (scan < from) scan = from;
+        while (scan < m.index) {
+          const after = skip(src, scan);
+          if (after === scan) scan += 1;
+          else scan = after;
+        }
+        if (scan > m.index) { call.lastIndex = scan; continue; }
+        const name = nameAt(src, m.index + m[0].length);
+        if (name === null) continue;
         const end = close(src, src.indexOf('(', m.index));
-        add(m[4], src.slice(m.index, end));
+        add(name, src.slice(m.index, end));
         rest.push(src.slice(from, m.index));
         from = end;
         call.lastIndex = end;
@@ -217,12 +261,13 @@ export function runEnv(work) {
   return { PATH: process.env.PATH ?? '/usr/bin:/bin', HOME: join(work, 'home'), TMPDIR: join(work, 'tmp'), TZ: 'UTC', LANG: 'C.UTF-8', CI: 'true' };
 }
 
-const commandOf = (runner, file, report) => (runner === 'node'
+export const commandOf = (runner, file, report) => (runner === 'node'
   ? ['node', '--test', '--test-reporter=junit', `--test-reporter-destination=${report}`, file]
   : ['python3', '-B', '-m', 'pytest', '-p', 'no:cacheprovider', '-q', `--junitxml=${report}`, file]);
 
-// A fresh tree of `sha` at `tree`, from git archive: no .git, so a test cannot read which commit it is.
-function freshTree(top, tree, sha) {
+// A fresh tree of `sha` at `tree`, from git archive: no .git of the repo, so a test cannot read which
+// commit it is. gitTree then gives it a .git of its own.
+export function freshTree(top, tree, sha) {
   rmSync(tree, { recursive: true, force: true });
   mkdirSync(tree, { recursive: true });
   const archive = spawnSync('git', ['archive', '--format=tar', sha], { cwd: top, maxBuffer: 1024 * 1024 * 1024 });
@@ -232,6 +277,16 @@ function freshTree(top, tree, sha) {
   if (existsSync(join(top, 'node_modules')) && !existsSync(join(tree, 'node_modules'))) symlinkSync(join(top, 'node_modules'), join(tree, 'node_modules'), 'dir');
 }
 
+// Makes the tree a new git repo with one commit of its files, so a test that needs git runs. The
+// commit has a fixed author, date and message, so it holds no history and names neither real commit.
+export function gitTree(tree) {
+  const env = { PATH: process.env.PATH ?? '/usr/bin:/bin', HOME: tree, GIT_CONFIG_NOSYSTEM: '1', GIT_AUTHOR_NAME: 'atlas', GIT_AUTHOR_EMAIL: 'atlas@invalid', GIT_COMMITTER_NAME: 'atlas', GIT_COMMITTER_EMAIL: 'atlas@invalid', GIT_AUTHOR_DATE: '2000-01-01T00:00:00Z', GIT_COMMITTER_DATE: '2000-01-01T00:00:00Z' };
+  for (const args of [['init', '-q', '-b', 'main'], ['add', '-A'], ['commit', '-q', '--no-verify', '--no-gpg-sign', '-m', 'tree']]) {
+    const r = spawnSync('git', args, { cwd: tree, env, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+    if (r.status !== 0) throw new Error(`git ${args[0]} in the run tree failed: ${String(r.stderr).trim().split('\n')[0]}`);
+  }
+}
+
 // Runs one side: `old` (the merge base with the head's test files) or `new` (the head).
 // Returns the run file: { side, merge_base, head, tree, report, env, files: { path: { command, cases, why } } }.
 export function runSide({ top, changed, plans, side, work = join(tmpdir(), 'atlas-before') }) {
@@ -255,6 +310,7 @@ export function runSide({ top, changed, plans, side, work = join(tmpdir(), 'atla
           writeFileSync(join(tree, r.path), bytes);
         }
       }
+      gitTree(tree);
       for (const dir of ['home', 'tmp', 'report']) { rmSync(join(work, dir), { recursive: true, force: true }); mkdirSync(join(work, dir), { recursive: true }); }
       const command = commandOf(p.runner, p.path, report);
       if (python && p.runner === 'pytest' && spawnSync('python3', ['-B', '-c', 'import pytest'], { cwd: tree, env }).status !== 0) {