Test / gate (push) Canceled after 0s
The gate first ran on the server that deploys the site: a slow container with no C compiler and no ICU. Ten tests failed there on correct code, and no Mojo program could be built at all. - The workflows ask for a runner labeled heavy, not the deploy server: the gate builds and runs some 300 Mojo programs and fuzzes. docs/ci.md says how to register one. With none registered a run waits. - The pinned environment has a C compiler on Linux (gcc, with its C library pinned to glibc 2.34): mojo build links with the C compiler it finds, and conda-forge's default links against a C library too old for Mojo's runtime. mojo-local reports a program that could not be linked as that, and does not keep the answer. - The pinned Dafny runs without ICU, and dafny-fetch fails when the Dafny it fetched does not start. - A test's time limit is processor time at the machine's pace (tests/helpers/pace.mjs). - The prover's time on the clock is the caller's: provePseudo and Workspace.proofBudgetMs take it, the Prove tab's 3 seconds stay the default, and the command line, library-check and the tests use none, so their answers are the counted budgets' alone. - The library pointer moves to its workflow change (e5ae090).
117 lines
6.9 KiB
JavaScript
117 lines
6.9 KiB
JavaScript
#!/usr/bin/env node
|
|
// SPDX-FileCopyrightText: 2026 Scientific Computing Studio, LLC
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
/**
|
|
* pplus: pplus-core without a browser. The same engines, translators, prover and fuzzer the app runs, on a file.
|
|
*
|
|
* pixi run cli check <file> what the language's own reader says
|
|
* pixi run cli run <file> [--call C] [--input F] run it, print what it prints
|
|
* pixi run cli prove <file> [--speco F] [--budget-ms N] every obligation: proved, broken or open
|
|
* pixi run cli fuzz <file> [--seed N] [--budget N] the fuzzer's report per routine
|
|
* pixi run cli translate <file.pseudo> --to mojo|lingo|matho|speco
|
|
*
|
|
* prove has no time limit here unless --budget-ms gives one (milliseconds for each routine): the prover's counted
|
|
* budgets decide alone, so the answer is the same on every machine. The Prove tab of the app gives each routine 3
|
|
* seconds as well, and on a slow machine can leave open what this proves; `--budget-ms 3000` asks for what it does.
|
|
*
|
|
* The language comes from the extension: .pseudo, .lingo, .matho (or .tex), .speco, .mojo, .asm (or .s). Add --json
|
|
* for machine-readable output. Exit status: 0 when nothing is wrong, 1 when the command found a problem (an error,
|
|
* a broken obligation, a failing input, a run that stopped), 2 for a usage error. Build first (`pixi run build`):
|
|
* this reads dist/.
|
|
*/
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import { fileURLToPath, pathToFileURL } from 'node:url';
|
|
|
|
const ROOT = fileURLToPath(new URL('..', import.meta.url));
|
|
const dist = (p) => pathToFileURL(path.join(ROOT, 'dist', p)).href;
|
|
const usage = (why) => {
|
|
if (why) console.error(`pplus: ${why}`);
|
|
console.error('usage: pplus <check|run|prove|fuzz|translate> <file> [--call C] [--input F] [--speco F] [--seed N] [--budget N] [--budget-ms N] [--to LANG] [--json]');
|
|
process.exit(2);
|
|
};
|
|
if (!fs.existsSync(path.join(ROOT, 'dist', 'common', 'workspace.js'))) usage('dist/ is missing; run `pixi run build` first');
|
|
|
|
const [cmd, file, ...rest] = process.argv.slice(2);
|
|
if (!cmd || !file) usage();
|
|
const opt = (name) => { const i = rest.indexOf(`--${name}`); return i >= 0 ? rest[i + 1] : undefined; };
|
|
const json = rest.includes('--json');
|
|
const LANG_OF = { '.pseudo': 'pseudo', '.lingo': 'lingo', '.matho': 'matho', '.tex': 'matho', '.speco': 'speco', '.mojo': 'mojo', '.asm': 'asm', '.s': 'asm' };
|
|
const lang = LANG_OF[path.extname(file).toLowerCase()];
|
|
if (!lang) usage(`cannot tell the language of ${file} from its extension (${Object.keys(LANG_OF).join(', ')})`);
|
|
if (!fs.existsSync(file)) usage(`${file} does not exist`);
|
|
|
|
const { Workspace } = await import(dist('common/workspace.js'));
|
|
const text = fs.readFileSync(file, 'utf8');
|
|
const sources = { [lang]: text };
|
|
const speco = opt('speco');
|
|
if (speco) sources.speco = fs.readFileSync(speco, 'utf8');
|
|
const input = opt('input') ? fs.readFileSync(opt('input'), 'utf8') : '';
|
|
const ws = new Workspace({ sources, lang, call: opt('call') ?? null, input });
|
|
|
|
const out = (obj, lines) => { if (json) console.log(JSON.stringify(obj, null, 2)); else for (const l of lines) console.log(l); };
|
|
const where = (d) => `${file}:${d.line ?? 1}:${d.col ?? 1}`;
|
|
|
|
switch (cmd) {
|
|
case 'check': {
|
|
const ds = ws.diagnostics(lang);
|
|
out(ds, ds.length ? ds.map((d) => `${where(d)}: ${d.severity}: ${d.message}${d.id ? ` [${d.id}]` : ''}`) : [`${file}: no problems`]);
|
|
process.exit(ds.some((d) => d.severity === 'error') ? 1 : 0);
|
|
}
|
|
case 'run': {
|
|
const errors = ws.diagnostics(lang).filter((d) => d.severity === 'error');
|
|
if (errors.length) { out({ errors }, errors.map((d) => `${where(d)}: error: ${d.message}`)); process.exit(1); }
|
|
const tr = ws.trace();
|
|
if (!tr) { out({ error: ws.runError ?? 'nothing to run' }, [`pplus: ${ws.runError ?? 'nothing to run'}`]); process.exit(1); }
|
|
const lines = [...(tr.output ?? [])];
|
|
if (tr.error) lines.push(`stopped at line ${tr.error.line}: ${tr.error.message}`);
|
|
out({ output: tr.output, error: tr.error, steps: tr.count }, lines);
|
|
process.exit(tr.error ? 1 : 0);
|
|
}
|
|
case 'prove': {
|
|
if (lang !== 'pseudo') usage('prove reads a .pseudo file (with --speco for a separate spec)');
|
|
const clock = opt('budget-ms');
|
|
if (clock !== undefined && !(Number(clock) > 0)) usage('--budget-ms takes a number of milliseconds above 0');
|
|
ws.proofBudgetMs = clock === undefined ? Infinity : Number(clock);
|
|
const p = ws.proof();
|
|
if (!p) { out({ error: 'the pseudo does not parse' }, ['pplus: the pseudo does not parse; run `pplus check` first']); process.exit(1); }
|
|
const { report } = p;
|
|
const lines = [];
|
|
for (const u of report.units) {
|
|
lines.push(`${u.name}${u.partial ? ' (partial: not every path was examined)' : ''}`);
|
|
for (const o of u.obligations) lines.push(` ${o.status.padEnd(6)} line ${String(o.line).padEnd(4)} ${o.label}`);
|
|
for (const n of u.notes) lines.push(` note: ${n}`);
|
|
}
|
|
lines.push(`${report.counts.proved} proved, ${report.counts.broken} broken, ${report.counts.open} open`);
|
|
out(report, lines);
|
|
process.exit(report.counts.broken ? 1 : 0);
|
|
}
|
|
case 'fuzz': {
|
|
const reports = ws.fuzz({ seed: Number(opt('seed') ?? 1), budget: Number(opt('budget') ?? 300) });
|
|
const lines = [];
|
|
for (const r of reports) {
|
|
if (r.problem) { lines.push(`${r.name}: ${r.problem}`); continue; }
|
|
lines.push(`${r.name}: ${r.cases.length} cases, ${r.failures.length} failure${r.failures.length === 1 ? '' : 's'}`);
|
|
for (const f of r.failures) lines.push(` ${f.call}: ${f.message}`);
|
|
}
|
|
out(reports.map((r) => ({ name: r.name, problem: r.problem, cases: r.cases.length, failures: r.failures })), lines.length ? lines : [`${file}: no routine to fuzz`]);
|
|
process.exit(reports.some((r) => r.failures.length) ? 1 : 0);
|
|
}
|
|
case 'translate': {
|
|
if (lang !== 'pseudo') usage('translate reads a .pseudo file');
|
|
const to = opt('to');
|
|
let result;
|
|
if (to === 'mojo') result = ws.derivedMojo();
|
|
else if (to === 'speco') { const { extractSpec } = await import(dist('services/speco.js')); result = { source: extractSpec(text) ?? '' }; }
|
|
else if (to === 'lingo' || to === 'matho') {
|
|
const { SyncHub } = await import(dist('sync/hub.js'));
|
|
const f = new SyncHub({ pseudo: text }).fill();
|
|
result = { source: f.sources[to] ?? '', stale: f.stale[to] };
|
|
} else usage('--to must be mojo, lingo, matho or speco');
|
|
if (result.stale) { out({ refused: result.stale }, [`pplus: ${to} cannot say this program: ${result.stale}`]); process.exit(1); }
|
|
if (json) console.log(JSON.stringify(result, null, 2)); else process.stdout.write(result.source.endsWith('\n') ? result.source : result.source + '\n');
|
|
process.exit(0);
|
|
}
|
|
default: usage(`unknown command ${cmd}`);
|
|
}
|