@orkestrel/scaffold 0.0.100 → 0.0.102

package/dist/agents/skills/orkestrel-harden/scripts/discovery.js

@@ -45,104 +45,103 @@ function readCLIOptions() {
     });
     if (help.status !== 0)
         throw new Error(help.stderr || 'Cannot read Vitest CLI options');
-    const options = new Map();
-    for (const line of help.stdout.split(/\r\n|\n/u)) {
+    // A later line that names the same flag replaces the earlier option at the earlier position.
+    return new Map(help.stdout.split(/\r\n|\n/u).flatMap((line) => {
         const match = /^\s+(?:(-\w), )?--([\w.-]+)(?: ([<[][^\n]*?[>\]]))?\s{2}/u.exec(line);
         const name = match?.[2];
         if (name === undefined)
-            continue;
+            return [];
         const option = { name: name.replace(/^no-/u, ''), argument: match?.[3] };
-        options.set(`--${name}`, option);
-        if (name.startsWith('no-'))
-            options.set(`--${name.slice(3)}`, option);
-        options.set(`--${name.replace(/[A-Z]/gu, (letter) => `-${letter.toLowerCase()}`)}`, option);
-        if (match?.[1] !== undefined)
-            options.set(match[1], option);
-    }
-    return options;
+        return [
+            [`--${name}`, option],
+            ...(name.startsWith('no-') ? [[`--${name.slice(3)}`, option]] : []),
+            [`--${name.replace(/[A-Z]/gu, (letter) => `-${letter.toLowerCase()}`)}`, option],
+            ...(match?.[1] === undefined ? [] : [[match[1], option]]),
+        ];
+    }));
+}
+// An option that takes a value consumes the token after it, so that token is never read as a runner.
+function skipRunnerOptions(command, index) {
+    const skipped = [...command.entries()].reduce((state, [position, option]) => {
+        if (state.found !== undefined || position < state.next)
+            return state;
+        if (!option.startsWith('-'))
+            return { ...state, found: position };
+        if (['-e', '--eval', '-p', '--print', '-c', '--check'].includes(option)) {
+            return { ...state, found: -1 };
+        }
+        return {
+            ...state,
+            next: position +
+                ([
+                    '-r',
+                    '--require',
+                    '--import',
+                    '--loader',
+                    '--experimental-loader',
+                    '--max-old-space-size',
+                    '--max_old_space_size',
+                    '-p',
+                    '--package',
+                ].includes(option)
+                    ? 2
+                    : 1),
+        };
+    }, { next: index, found: undefined });
+    return skipped.found ?? skipped.next;
 }
 function findRunner(command) {
-    let index = 0;
     const executable = basename(command[0] ?? '').replace(/\.(?:exe|cmd)$/u, '');
-    if (executable === 'npm') {
-        if (command[1] !== 'exec')
-            return -1;
-        index = 2;
-    }
-    else if (executable === 'node' || executable === 'npx')
-        index = 1;
-    if (index > 0) {
-        while (command[index]?.startsWith('-')) {
-            const option = command[index];
-            if (['-e', '--eval', '-p', '--print', '-c', '--check'].includes(option ?? ''))
-                return -1;
-            index += [
-                '-r',
-                '--require',
-                '--import',
-                '--loader',
-                '--experimental-loader',
-                '--max-old-space-size',
-                '--max_old_space_size',
-                '-p',
-                '--package',
-            ].includes(option ?? '')
-                ? 2
-                : 1;
-        }
-    }
+    const start = executable === 'npm'
+        ? command[1] === 'exec'
+            ? 2
+            : -1
+        : executable === 'node' || executable === 'npx'
+            ? 1
+            : 0;
+    const index = start > 0 ? skipRunnerOptions(command, start) : start;
+    if (index < 0)
+        return -1;
     return ['vitest', 'vitest.mjs', 'vitest.js'].includes(basename(command[index] ?? '').replace(/\.cmd$/u, ''))
         ? index
         : -1;
 }
+// The first `--` ends the options, so the rest of the arguments pass verbatim. A runner option that
+// takes a value consumes the argument after it, so a step below `skip` reads nothing.
 function readSelection(argv, options) {
-    const selected = [];
-    for (let index = 0; index < argv.length; index++) {
-        const token = argv[index];
-        if (token === undefined)
-            continue;
+    return argv.reduce((state, token, index) => {
+        if (state.closed || index < state.skip)
+            return state;
         if (token === '--') {
-            selected.push(...argv.slice(index));
-            break;
-        }
-        if (!token.startsWith('-')) {
-            selected.push(token);
-            continue;
+            return { ...state, selected: state.selected.concat(argv.slice(index)), closed: true };
         }
+        if (!token.startsWith('-'))
+            return { ...state, selected: [...state.selected, token] };
         const equals = token.indexOf('=');
         const flag = equals < 0 ? token : token.slice(0, equals);
         const positive = flag.replace(/^--no-/u, '--');
         const option = options.get(positive) ?? options.get(positive.split('.').slice(0, 1).join('.'));
         if (option === undefined || !OMITTED.has(option.name.split('.')[0] ?? '')) {
-            selected.push(token);
-            continue;
+            return { ...state, selected: [...state.selected, token] };
         }
         const next = argv[index + 1];
-        if (!flag.startsWith('--no-') &&
+        const valued = !flag.startsWith('--no-') &&
             equals < 0 &&
             next !== undefined &&
             !next.startsWith('-') &&
-            (option.argument !== undefined || next === 'true' || next === 'false'))
-            index++;
-    }
-    return selected;
+            (option.argument !== undefined || next === 'true' || next === 'false');
+        return { ...state, skip: index + (valued ? 2 : 1) };
+    }, { selected: [], skip: 0, closed: false }).selected;
 }
 function readArguments(argv, names) {
-    const values = [];
-    for (let index = 0; index < argv.length; index++) {
-        const token = argv[index];
-        if (token === '--')
-            break;
-        if (token === undefined)
-            continue;
+    const end = argv.indexOf('--');
+    return (end < 0 ? argv : argv.slice(0, end)).flatMap((token, index) => {
         const equals = token.indexOf('=');
         if (!names.includes(equals < 0 ? token : token.slice(0, equals)))
-            continue;
+            return [];
         const value = equals < 0 ? argv[index + 1] : token.slice(equals + 1);
-        if (value !== undefined && !value.startsWith('-'))
-            values.push(value);
-    }
-    return values;
+        return value !== undefined && !value.startsWith('-') ? [value] : [];
+    });
 }
 function readScripts() {
     const parsed = JSON.parse(readFileSync('package.json', 'utf8'));
@@ -151,38 +150,23 @@ function readScripts() {
     const scripts = Object.fromEntries(Object.entries(parsed)).scripts;
     if (typeof scripts !== 'object' || scripts === null)
         return {};
-    const record = {};
-    for (const [key, value] of Object.entries(scripts))
-        if (typeof value === 'string')
-            record[key] = value;
-    return record;
+    return Object.fromEntries(Object.entries(scripts).flatMap(([key, value]) => typeof value === 'string' ? [[key, value]] : []));
 }
 function readCommands(text) {
-    const commands = [];
-    let command = [];
-    for (const match of text.matchAll(/(?:[^\s"';&|]+|"[^"]*"|'[^']*')+|[;&|]+/gu)) {
-        if (/^[;&|]+$/u.test(match[0])) {
-            commands.push(command);
-            command = [];
-        }
-        else {
-            command.push(match[0].replace(/["']/gu, ''));
-        }
-    }
-    commands.push(command);
-    return commands;
+    const tokens = [...text.matchAll(/(?:[^\s"';&|]+|"[^"]*"|'[^']*')+|[;&|]+/gu)].map((match) => match[0]);
+    // A separator token ends a command, so the commands are the runs of tokens between the cuts.
+    const cuts = tokens.flatMap((token, index) => (/^[;&|]+$/u.test(token) ? [index] : []));
+    return [-1, ...cuts].map((cut, at) => tokens.slice(cut + 1, cuts[at] ?? tokens.length).map((token) => token.replace(/["']/gu, '')));
 }
 function listInvocations(commands) {
-    const invoked = [];
-    for (const command of commands) {
+    return commands.flatMap((command) => {
         const index = command.indexOf('npm');
         const name = command[index + 2];
         if (index < 0 || command[index + 1] !== 'run' || name === undefined)
-            continue;
+            return [];
         const separator = command.indexOf('--', index + 3);
-        invoked.push({ name, args: separator < 0 ? [] : command.slice(separator + 1), ancestors: [] });
-    }
-    return invoked;
+        return [{ name, args: separator < 0 ? [] : command.slice(separator + 1), ancestors: [] }];
+    });
 }
 function readGates(scripts, config, options) {
     const commands = Object.fromEntries(Object.entries(scripts).map(([name, text]) => [name, readCommands(text)]));
@@ -207,10 +191,9 @@ function readGates(scripts, config, options) {
             if (script === undefined)
                 continue;
             const expanded = script.map((command, index) => index === script.length - 1 ? [...command, ...args] : command);
-            pending.push(...listInvocations(expanded).map((entry) => ({
-                ...entry,
-                ancestors: [...ancestors, name],
-            })));
+            for (const entry of listInvocations(expanded)) {
+                pending.push({ ...entry, ancestors: [...ancestors, name] });
+            }
             const gate = root === name ? name : `${root} > ${name}`;
             for (const command of expanded) {
                 const index = findRunner(command);
@@ -290,26 +273,28 @@ function listCollected(args, full, cache) {
         const parsed = JSON.parse(readFileSync(listing, 'utf8'));
         if (!Array.isArray(parsed))
             return undefined;
-        const collected = [];
-        for (const entry of parsed) {
+        const collected = parsed.flatMap((entry) => {
             if (typeof entry !== 'object' || entry === null)
-                continue;
+                return [];
             const record = Object.fromEntries(Object.entries(entry));
             const location = typeof record.location === 'object' && record.location !== null
                 ? Object.fromEntries(Object.entries(record.location))
                 : {};
-            if (typeof record.file === 'string' &&
-                (record.projectName === undefined || typeof record.projectName === 'string') &&
-                (!full || typeof record.name === 'string')) {
-                collected.push({
+            if (typeof record.file !== 'string' ||
+                (record.projectName !== undefined && typeof record.projectName !== 'string') ||
+                (full && typeof record.name !== 'string')) {
+                return [];
+            }
+            return [
+                {
                     file: relative(process.cwd(), record.file).split('\\').join('/'),
                     projectName: record.projectName ?? '',
                     name: typeof record.name === 'string' ? record.name : undefined,
                     line: typeof location.line === 'number' ? location.line : undefined,
                     column: typeof location.column === 'number' ? location.column : undefined,
-                });
-            }
-        }
+                },
+            ];
+        });
         cache.set(key, collected);
         return collected;
     }
@@ -330,82 +315,111 @@ function listTestFiles(directory) {
 }
 function countMarkers(file) {
     const text = readFileSync(file, 'utf8');
-    const counts = {};
-    for (const marker of MARKERS) {
-        const count = text.split(marker).length - 1;
-        if (count > 0)
-            counts[marker] = count;
-    }
-    return counts;
+    return Object.fromEntries(MARKERS.map((marker) => [marker, text.split(marker).length - 1]).filter(([, count]) => count > 0));
 }
 function collectListings(config, named, gates) {
-    const units = [{ config, mode: undefined }];
-    for (const gate of gates.units) {
-        if (!units.some((unit) => unit.config === gate.config &&
-            unit.mode === gate.mode &&
-            unit.root === gate.root &&
-            unit.dir === gate.dir)) {
-            units.push({
-                config: gate.config,
-                mode: gate.mode,
-                ...(gate.root === undefined ? {} : { root: gate.root }),
-                ...(gate.dir === undefined ? {} : { dir: gate.dir }),
-            });
-        }
-    }
-    const listings = [];
-    const populated = new Set();
+    const base = { config, mode: undefined };
+    // A gate joins the units unless the base unit or an earlier gate already names the same unit.
+    const units = [
+        base,
+        ...gates.units
+            .filter((gate, index) => ![base, ...gates.units.slice(0, index)].some((unit) => isSameUnit(unit, gate)))
+            .map((gate) => ({
+            config: gate.config,
+            mode: gate.mode,
+            ...(gate.root === undefined ? {} : { root: gate.root }),
+            ...(gate.dir === undefined ? {} : { dir: gate.dir }),
+        })),
+    ];
+    // A listing is a memo keyed by its arguments: each key is written once, on its first miss.
     const cache = new Map();
-    for (const unit of units) {
-        const reached = gates.units.filter((gate) => gate.config === unit.config &&
-            gate.mode === unit.mode &&
-            gate.root === unit.root &&
-            gate.dir === unit.dir);
-        const parameters = readUnitArguments(unit);
-        const collected = listCollected(parameters, true, cache);
-        if (collected === undefined)
+    const readings = collectReadings(units, (unit) => readUnit(unit, named, gates, cache));
+    if (readings === undefined)
+        return undefined;
+    const listings = readings.map(({ listing }) => listing);
+    const populated = new Set(readings.flatMap((reading) => reading.populated));
+    // A project empty under one unit may still list tests under another, so each unit is asked for it.
+    const rescans = collectReadings([...new Set(listings.flatMap((listing) => listing.empty))]
+        .filter((name) => !populated.has(name))
+        .flatMap((name) => units.map((unit) => ({ name, unit }))), ({ name, unit }) => {
+        const selection = listCollected([...readUnitArguments(unit), '--project', name], false, cache);
+        return selection === undefined ? undefined : { name, listed: selection.length > 0 };
+    });
+    if (rescans === undefined)
+        return undefined;
+    const resolved = new Set([
+        ...populated,
+        ...rescans.filter(({ listed }) => listed).map(({ name }) => name),
+    ]);
+    return listings.map((listing) => ({
+        ...listing,
+        empty: listing.empty.filter((name) => !resolved.has(name)),
+    }));
+}
+// Runs one read per item in order and stops at the first refusal, so no later read spawns.
+function collectReadings(items, read) {
+    return items.reduce((readings, item) => {
+        if (readings === undefined)
             return undefined;
-        const scope = named.length === 0
-            ? undefined
-            : listCollected([...parameters, ...named.flatMap((name) => ['--project', name])], false, cache);
-        if (named.length > 0 && scope === undefined)
+        const reading = read(item);
+        return reading === undefined ? undefined : [...readings, reading];
+    }, []);
+}
+function isSameUnit(left, right) {
+    return (left.config === right.config &&
+        left.mode === right.mode &&
+        left.root === right.root &&
+        left.dir === right.dir);
+}
+function readUnit(unit, named, gates, cache) {
+    const reached = gates.units.filter((gate) => isSameUnit(gate, unit));
+    const parameters = readUnitArguments(unit);
+    const collected = listCollected(parameters, true, cache);
+    if (collected === undefined)
+        return undefined;
+    const scope = named.length === 0
+        ? undefined
+        : listCollected([...parameters, ...named.flatMap((name) => ['--project', name])], false, cache);
+    if (named.length > 0 && scope === undefined)
+        return undefined;
+    const selected = collectReadings(reached, (gate) => {
+        const selection = JSON.stringify(gate.args) === JSON.stringify(parameters)
+            ? collected
+            : listCollected(gate.args, gate.full, cache);
+        if (selection === undefined) {
+            console.error(`discovery: gate ${gate.chain}: vitest list refused ${gate.args.join(' ')}`);
             return undefined;
-        const selected = [];
-        for (const gate of reached) {
-            const selection = JSON.stringify(gate.args) === JSON.stringify(parameters)
-                ? collected
-                : listCollected(gate.args, gate.full, cache);
-            if (selection === undefined) {
-                console.error(`discovery: gate ${gate.chain}: vitest list refused ${gate.args.join(' ')}`);
-                return undefined;
-            }
-            selected.push({
-                gate,
-                identities: new Set(selection.map((entry) => JSON.stringify([
-                    entry.file,
-                    entry.projectName,
-                    ...(gate.full ? [entry.name, entry.line, entry.column] : []),
-                ]))),
-            });
         }
-        const empty = [];
-        for (const project of new Set([...reached.flatMap((gate) => gate.projects), ...named])) {
-            if (project.includes('*') || project.startsWith('!'))
-                continue;
-            if (selected.some(({ gate, identities }) => gate.projects.length === 1 && gate.projects[0] === project && identities.size > 0)) {
-                populated.add(project);
-                continue;
-            }
-            const selection = listCollected([...parameters, '--project', project], false, cache);
-            if (selection === undefined)
-                return undefined;
-            if (selection.length > 0)
-                populated.add(project);
-            else if ((reached.some((gate) => gate.projects.includes(project)) || named.includes(project)) &&
-                (named.length === 0 || named.includes(project)))
-                empty.push(project);
+        return {
+            gate,
+            identities: new Set(selection.map((entry) => JSON.stringify([
+                entry.file,
+                entry.projectName,
+                ...(gate.full ? [entry.name, entry.line, entry.column] : []),
+            ]))),
+        };
+    });
+    if (selected === undefined)
+        return undefined;
+    const readings = collectReadings([...new Set([...reached.flatMap((gate) => gate.projects), ...named])].filter((project) => !project.includes('*') && !project.startsWith('!')), (project) => {
+        if (selected.some(({ gate, identities }) => gate.projects.length === 1 && gate.projects[0] === project && identities.size > 0)) {
+            return { project, populated: true, empty: false };
         }
-        listings.push({
+        const selection = listCollected([...parameters, '--project', project], false, cache);
+        if (selection === undefined)
+            return undefined;
+        return {
+            project,
+            populated: selection.length > 0,
+            empty: selection.length === 0 &&
+                (reached.some((gate) => gate.projects.includes(project)) || named.includes(project)) &&
+                (named.length === 0 || named.includes(project)),
+        };
+    });
+    if (readings === undefined)
+        return undefined;
+    return {
+        listing: {
             ...unit,
             collected: collected
                 .filter((entry) => scope === undefined ||
@@ -418,25 +432,10 @@ function collectListings(config, named, gates) {
                     ...(gate.full ? [entry.name, entry.line, entry.column] : []),
                 ])))?.gate.chain,
             })),
-            empty,
-        });
-    }
-    const candidates = new Set(listings.flatMap((listing) => listing.empty));
-    for (const name of candidates) {
-        if (populated.has(name))
-            continue;
-        for (const unit of units) {
-            const selection = listCollected([...readUnitArguments(unit), '--project', name], false, cache);
-            if (selection === undefined)
-                return undefined;
-            if (selection.length > 0)
-                populated.add(name);
-        }
-    }
-    return listings.map((listing) => ({
-        ...listing,
-        empty: listing.empty.filter((name) => !populated.has(name)),
-    }));
+            empty: readings.filter(({ empty }) => empty).map(({ project }) => project),
+        },
+        populated: readings.filter(({ populated }) => populated).map(({ project }) => project),
+    };
 }
 function readUnitArguments(unit) {
     return [
@@ -446,25 +445,30 @@ function readUnitArguments(unit) {
         ...(unit.dir === undefined ? [] : ['--dir', unit.dir]),
     ];
 }
+function identifyCollected(entry) {
+    return JSON.stringify([entry.file, entry.projectName, entry.name, entry.line, entry.column]);
+}
+// The same test listed twice in one listing is two occurrences, and the same occurrence listed by
+// two listings is one test: the last listing's fields win, and the gate is the last one any named.
 function mergeCollected(listings) {
-    const collected = new Map();
-    for (const listing of listings) {
-        const occurrences = new Map();
-        for (const entry of listing.collected) {
-            const identity = JSON.stringify([
-                entry.file,
-                entry.projectName,
-                entry.name,
-                entry.line,
-                entry.column,
-            ]);
-            const occurrence = (occurrences.get(identity) ?? 0) + 1;
-            occurrences.set(identity, occurrence);
-            const key = JSON.stringify([identity, occurrence]);
-            collected.set(key, { ...entry, gate: entry.gate ?? collected.get(key)?.gate });
-        }
-    }
-    return [...collected.values()];
+    const keyed = listings.flatMap((listing) => {
+        const positions = new Map([...Map.groupBy(listing.collected, identifyCollected).values()].flatMap((group) => group.map((entry, position) => [entry, position + 1])));
+        return listing.collected.map((entry) => ({
+            entry,
+            key: JSON.stringify([identifyCollected(entry), positions.get(entry)]),
+        }));
+    });
+    return [...Map.groupBy(keyed, ({ key }) => key).values()].flatMap((group) => {
+        const last = group.at(-1);
+        return last === undefined
+            ? []
+            : [
+                {
+                    ...last.entry,
+                    gate: group.findLast(({ entry }) => entry.gate !== undefined)?.entry.gate,
+                },
+            ];
+    });
 }
 function readSnapshot(gates) {
     const bases = [
@@ -472,17 +476,23 @@ function readSnapshot(gates) {
         ...gates.units.flatMap((gate) => [gate.root, gate.dir].filter((path) => path !== undefined).map((path) => resolve(path))),
     ];
     const roots = new Set(bases.flatMap((base) => [base, join(base, 'tmp/probes')]));
-    const files = new Map();
-    for (const root of roots) {
-        if (!existsSync(root))
-            continue;
-        for (const file of listFiles(root)) {
-            if (/\.test\.[cm]?[jt]sx?$/u.test(file.path))
-                files.set(file.path, file.modified);
-        }
-    }
+    // A later listing of the same path replaces the earlier modification time at the earlier position.
+    const files = new Map([...roots].flatMap((root) => existsSync(root)
+        ? listFiles(root)
+            .filter((file) => /\.test\.[cm]?[jt]sx?$/u.test(file.path))
+            .map((file) => [file.path, file.modified])
+        : []));
     return JSON.stringify([...files].sort(([left], [right]) => left.localeCompare(right)));
 }
+function collectStableListings(config, named, gates, attempt = 0) {
+    const before = readSnapshot(gates);
+    const listings = collectListings(config, named, gates);
+    if (before === readSnapshot(gates))
+        return listings;
+    if (attempt === 1)
+        throw new Error('Test files changed during both census attempts');
+    return collectStableListings(config, named, gates, attempt + 1);
+}
 function main(argv) {
     const missing = readMissingFlags(argv, ['--config', '--projects']);
     if (missing.length > 0) {
@@ -501,16 +511,7 @@ function main(argv) {
     const canonical = relative(process.cwd(), resolve(config)).split('\\').join('/');
     const gates = readGates(readScripts(), canonical, readCLIOptions());
     const named = (readOption(argv, '--projects') ?? '').split(',').filter((name) => name !== '');
-    let listings;
-    for (let attempt = 0; attempt < 2; attempt++) {
-        const before = readSnapshot(gates);
-        listings = collectListings(canonical, named, gates);
-        if (before === readSnapshot(gates))
-            break;
-        listings = undefined;
-        if (attempt === 1)
-            throw new Error('Test files changed during both census attempts');
-    }
+    const listings = collectStableListings(canonical, named, gates);
     if (listings === undefined) {
         console.error('discovery: vitest list failed');
         return 2;