@esneiderbravo/speclaw 2.0.8 → 2.0.10

package/dist/cli/lib/self-update.js

@@ -0,0 +1,107 @@
+/**
+ * Self-update for `speclaw update`: re-run the command as
+ * `npx -y <pkg>@<latest> update …` so the latest release applies its own
+ * migrations instead of a stale binary applying old ones. This is the only CLI
+ * module that imports `child_process`; `update.ts` receives it through
+ * `UpdateHooks` so tests never spawn anything.
+ */
+// Covers: req~update-self-update~1
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Flag tokens safe to forward to the child: `-x`, `--flag`, or `--flag=value`
+ * with a conservative value charset. The charset also keeps the Windows shell
+ * spawn free of injection.
+ */
+const SAFE_TOKEN = /^--?[A-Za-z][A-Za-z0-9-]*(=[A-Za-z0-9._/:@-]*)?$/;
+/**
+ * A registry version that is safe to put on a command line: strict semver with
+ * an optional prerelease tag. Anything else (for example `"9.9.9 & calc"`) is
+ * never spawned — it would reach the Windows shell verbatim.
+ */
+const SAFE_VERSION = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/;
+/**
+ * Whether `version` is a strict semver string safe to spawn with.
+ *
+ * @param version - The `latest` version reported by the registry.
+ * @returns True only for `MAJOR.MINOR.PATCH` with an optional `-prerelease`.
+ */
+export function isSafeVersion(version) {
+    return SAFE_VERSION.test(version);
+}
+/**
+ * Whether `command` exists as a file in a directory on the env's PATH (the key
+ * is matched case-insensitively, since Windows spells it `Path`).
+ *
+ * @param command - The executable file name, e.g. `npx.cmd`.
+ * @param env - The environment whose PATH is searched.
+ * @param delimiter - The PATH separator (`;` on Windows).
+ * @returns True when some PATH entry holds `command`.
+ */
+export function onPath(command, env, delimiter = path.delimiter) {
+    const key = Object.keys(env).find((k) => k.toUpperCase() === "PATH");
+    const dirs = (key ? (env[key] ?? "") : "").split(delimiter).filter(Boolean);
+    return dirs.some((dir) => fs.existsSync(path.join(dir, command)));
+}
+/**
+ * Split the original `update` arguments into the ones forwarded to the child
+ * and the ones dropped. `update` takes no positional arguments, so dropping
+ * anything that is not a safe flag loses nothing in practice.
+ *
+ * @param argv - The arguments after `speclaw update`.
+ * @returns The forwarded tokens (in order) and the dropped ones.
+ */
+export function safeForwardArgs(argv) {
+    const forward = [];
+    const dropped = [];
+    for (const token of argv)
+        (SAFE_TOKEN.test(token) ? forward : dropped).push(token);
+    return { forward, dropped };
+}
+/**
+ * Run `npx -y <pkg>@<version> update <args>` with inherited stdio and the loop
+ * guard `SPECLAW_SELF_UPDATED=<version>` in its environment. On Windows the
+ * `npx.cmd` shim is spawned through the shell (Node refuses `.cmd` files
+ * otherwise); `args` must already be filtered by {@link safeForwardArgs}. A
+ * version that is not strict semver is never spawned, and on Windows a missing
+ * `npx.cmd` is detected up front (the shell would turn it into exit code 1
+ * rather than an ENOENT), so both report `unavailable` and the caller migrates
+ * in process.
+ *
+ * @param opts - Package name, target version, forwarded args, the base env,
+ *   and the platform (defaults to `process.platform`; tests pass `win32`).
+ * @returns `ran` with the child's exit code, or `unavailable` when it could not start.
+ */
+export function selfUpdate(opts) {
+    if (!isSafeVersion(opts.version)) {
+        return Promise.resolve({
+            kind: "unavailable",
+            reason: `invalid version ${JSON.stringify(opts.version)}`,
+        });
+    }
+    const windows = (opts.platform ?? process.platform) === "win32";
+    const command = windows ? "npx.cmd" : "npx";
+    const args = ["-y", `${opts.pkg}@${opts.version}`, "update", ...opts.args];
+    const env = { ...(opts.env ?? process.env), SPECLAW_SELF_UPDATED: opts.version };
+    if (windows && !onPath(command, env, ";")) {
+        return Promise.resolve({ kind: "unavailable", reason: `${command} not found on PATH` });
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        const done = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(outcome);
+        };
+        try {
+            const child = spawn(command, args, { stdio: "inherit", env, shell: windows });
+            child.on("error", (err) => done({ kind: "unavailable", reason: err.message }));
+            child.on("exit", (code) => done({ kind: "ran", code: code ?? 1 }));
+        }
+        catch (err) {
+            done({ kind: "unavailable", reason: err.message });
+        }
+    });
+}

package/dist/cli/lib/update-check.js

@@ -77,23 +77,28 @@ export function isNewer(latest, current) {
  * cache unless `force` is set. Falls back to stale cache when offline.
  *
  * @param opts - `force` bypasses the cache and always queries the registry.
- * @returns The current/latest versions and whether an upgrade is available.
+ * @returns The current/latest versions, whether an upgrade is available, and
+ *   `fresh`: true only when `latest` came from the registry during this call
+ *   (a cached or offline value is not fresh — `npx` could not resolve it either).
  */
 export async function checkForUpdates(opts = {}) {
     const current = pkgVersion();
     const cache = readCache();
     let latest;
+    let fresh = false;
     if (!opts.force && cache && Date.now() - cache.checkedAt < TTL_MS) {
         latest = cache.latest;
     }
     else {
         latest = await fetchLatest(pkgName());
-        if (latest)
+        if (latest) {
+            fresh = true;
             writeCache(latest);
+        }
         else if (cache)
             latest = cache.latest; // offline: use whatever we last knew
     }
-    return { current, latest, updateAvailable: !!latest && isNewer(latest, current) };
+    return { current, latest, updateAvailable: !!latest && isNewer(latest, current), fresh };
 }
 /** The public npm page for a package, where an upgrade can be reviewed. */
 export function npmPackageUrl(name) {
@@ -102,8 +107,8 @@ export function npmPackageUrl(name) {
 /**
  * Build the two-line "update available" notice. The latest version is rendered
  * as a clickable link to the package's npm page, so a capable terminal lets the
- * user open the release with a single click. Project migrations stay
- * `speclaw update`; the binary is upgraded separately (prefer npx).
+ * user open the release with a single click. `speclaw update` upgrades itself
+ * (it re-runs at the latest version through npx) and migrates the project.
  *
  * @param current - The installed version.
  * @param latest - The newest published version.
@@ -119,16 +124,18 @@ export function upgradeNotice(current, latest) {
         c.muted(" available") +
         "\n" +
         "  " +
-        c.muted("prefer ") +
-        c.cyan(`npx ${name}@latest update`) +
-        c.muted(" — or ") +
+        c.muted("run ") +
         c.cyan("speclaw update") +
-        c.muted(" to migrate this project"));
+        c.muted(" (or ") +
+        c.cyan(`npx ${name}@latest update`) +
+        c.muted(") — it upgrades itself through npx and migrates this project"));
 }
 /**
  * Print the "update available" notice to stderr when a newer version exists.
  * No-op for the `mcp`/`update`/`help`/`version` commands, on non-TTY stderr, or
  * when NO_UPDATE_NOTIFIER / SPECLAW_NO_UPDATE_NOTIFIER is set. Never throws.
+ * `SPECLAW_UPDATE_NOTIFIER=force` lifts only the TTY check, so a test with
+ * piped stderr can prove a command path does (or does not) reach the notifier.
  *
  * @param cmd - The command that just ran (used to skip noisy contexts).
  */
@@ -136,7 +143,7 @@ export async function maybeNotifyUpdate(cmd) {
     try {
         if (process.env.NO_UPDATE_NOTIFIER || process.env.SPECLAW_NO_UPDATE_NOTIFIER)
             return;
-        if (!process.stderr.isTTY)
+        if (!process.stderr.isTTY && process.env.SPECLAW_UPDATE_NOTIFIER !== "force")
             return;
         // `init` shows its own prominent up-front warning and ends on the clean
         // copy-paste prompt — don't append a second notice after it.

package/dist/modules/compass/affected-config.js

@@ -10,10 +10,15 @@ const DEFAULT_TARGETS = {
         exclude: ["**/*.{test,spec}.{ts,tsx,js,jsx,mts,cts}", "test/**", "tests/**"],
     },
     test: {
+        // The `**/` forms cover workspace packages (`apps/web/src/**`), whose
+        // changes would otherwise be filtered out before any test is selected.
         include: [
             "src/**",
             "test/**",
             "tests/**",
+            "**/src/**",
+            "**/test/**",
+            "**/tests/**",
             "**/*.{test,spec}.{ts,tsx,js,jsx}",
             "**/conftest.py",
         ],

package/dist/modules/compass/affected.js

@@ -1,13 +1,13 @@
 /**
  * Static affected-test selection: reverse reachability into `files.is_test = 1`,
- * plus a ready-to-run command string.
+ * plus ready-to-run commands per package (runner detected from `package.json`).
  */
 import fs from "node:fs";
 import path from "node:path";
 import { changedFiles, isGitRepo } from "../../shared/git.js";
 import { openDb, indexExists } from "./db.js";
 import { impact } from "./query.js";
-import { loadAffectedConfig, matchGlobalFiles, matchesAny, } from "./affected-config.js";
+import { loadAffectedConfig, matchGlobalFiles, matchesAny, matchGlob, } from "./affected-config.js";
 /**
  * Select a safe superset of test files affected by a change.
  *
@@ -40,7 +40,7 @@ export function affectedTests(projectPath, query = {}) {
                 reason: "no changed files",
                 tests: [],
                 skipped: { files: countTestFiles(projectPath), percent: 100 },
-                command: buildTestCommand(projectPath, [], cfg, "none"),
+                ...planTestCommand(projectPath, [], "none"),
                 warnings,
             };
         }
@@ -48,12 +48,13 @@ export function affectedTests(projectPath, query = {}) {
     const glob = matchGlobalFiles(files, cfg);
     if (glob.matched.length > 0) {
         const allTests = listTestFiles(projectPath);
+        const reason = `global file matched (${glob.matched.join(", ")})`;
         return {
             mode: "all",
-            reason: `global file matched (${glob.matched.join(", ")})`,
+            reason,
             tests: allTests.map((file) => ({ file, nodes: 0, minDepth: 0 })),
             skipped: { files: 0, percent: 0 },
-            command: buildTestCommand(projectPath, [], cfg, "all"),
+            ...planTestCommand(projectPath, [], "all", reason),
             warnings,
         };
     }
@@ -125,7 +126,7 @@ export function affectedTests(projectPath, query = {}) {
                 : "empty selection",
         tests,
         skipped: { files: skippedFiles, percent },
-        command: buildTestCommand(projectPath, tests.map((t) => t.file), cfg, tests.length === 0 ? "none" : "subset"),
+        ...planTestCommand(projectPath, tests.map((t) => t.file), tests.length === 0 ? "none" : "subset"),
         warnings,
     };
 }
@@ -160,43 +161,359 @@ function listTestFiles(projectPath) {
     }
 }
 /**
- * Build an executable test command from package.json scripts.test when present.
+ * Build the command for a selection as a single string (see {@link planTestCommand}).
  *
  * @param projectPath - Project root.
- * @param tests - Selected test paths (ignored for mode `all`).
+ * @param tests - Selected repo-relative test paths (ignored for mode `all`).
  * @param _cfg - Reserved for future runner overrides.
  * @param mode - `all` | `subset` | `none`.
+ * @returns The command to run from the root, or null when nothing is selected.
  */
 export function buildTestCommand(projectPath, tests, _cfg, mode) {
-    const pkgPath = path.join(projectPath, "package.json");
-    let script;
-    if (fs.existsSync(pkgPath)) {
-        try {
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-            script = pkg.scripts?.test;
-        }
-        catch {
-            /* ignore */
-        }
+    return planTestCommand(projectPath, tests, mode).command;
+}
+/** Read a `package.json`; null when absent or unparseable. */
+function readPackage(dir) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+    }
+    catch {
+        return null;
     }
+}
+/**
+ * Turn a selection into runnable commands.
+ *
+ * - `none`: `command` is null with a reason; a run-nothing command is never emitted.
+ * - `all`: the root runner's full suite.
+ * - `subset`: files are grouped by their nearest `package.json` directory
+ *   (bounded by the root) and each group gets its own runner's command:
+ *   `npx vitest run`, `npx jest --runTestsByPath`, the `node --test` script's
+ *   flags without coverage flags (mapped onto a compiled-test glob, after
+ *   `npm run pretest`), or `npm test -- <files>` for an unrecognized script.
+ *   Several groups compose as `(cd a && …) && (cd b && …)` from the root.
+ *
+ * @param projectPath - Project root.
+ * @param tests - Selected repo-relative test paths (ignored unless `subset`).
+ * @param mode - `all` | `subset` | `none`.
+ * @param allReason - Why the full suite was selected (mode `all`).
+ * @returns The command plan; `commands` is empty exactly when `command` is null.
+ */
+export function planTestCommand(projectPath, tests, mode, allReason = "the full suite was selected") {
+    // Covers: req~affected-test-selection~1
     if (mode === "all") {
-        return script ? "npm test" : "node --test";
+        const command = fullSuiteCommand(readPackage(projectPath));
+        return {
+            command,
+            commandReason: `${allReason}; run the full suite`,
+            commands: [{ cwd: ".", command, files: [] }],
+        };
     }
     if (mode === "none" || tests.length === 0) {
-        return script ? "npm test -- --test-name-pattern=^$" : "node --test --test-name-pattern=^$";
+        return {
+            command: null,
+            commandReason: "no test file is reachable from the change; nothing to run",
+            commands: [],
+        };
+    }
+    const groups = new Map();
+    const nearest = new Map();
+    for (const t of [...tests].sort()) {
+        const cwd = nearestPackageDir(projectPath, path.posix.dirname(t), nearest);
+        const rel = cwd === "." ? t : t.slice(cwd.length + 1);
+        groups.set(cwd, [...(groups.get(cwd) ?? []), rel]);
+    }
+    const commands = [];
+    const notes = [];
+    const runners = [];
+    for (const cwd of [...groups.keys()].sort()) {
+        const files = groups.get(cwd);
+        const own = readPackage(path.join(projectPath, cwd));
+        const inherited = inheritedRunner(projectPath, cwd, own);
+        const plan = groupCommand(inherited?.pkg ?? own, files);
+        if (inherited) {
+            const from = inherited.dir === "." ? "the root package.json" : `${inherited.dir}/package.json`;
+            plan.note = [`${plan.runner} inherited from ${from}`, plan.note]
+                .filter((n) => n !== undefined)
+                .join("; ");
+        }
+        if (plan.note)
+            notes.push(cwd === "." ? plan.note : `${cwd}: ${plan.note}`);
+        if (plan.command === null)
+            continue;
+        commands.push({ cwd, command: plan.command, files: plan.kept ?? files });
+        runners.push(`${cwd}: ${plan.runner}`);
+    }
+    if (commands.length === 0) {
+        return {
+            command: null,
+            commandReason: `no runnable test file is selected; ${notes.join("; ")}`,
+            commands: [],
+        };
+    }
+    const command = commands.length === 1
+        ? commands[0].cwd === "."
+            ? commands[0].command
+            : `cd ${shellQuote(commands[0].cwd)} && ${commands[0].command}`
+        : commands
+            .map((c) => c.cwd === "." ? `(${c.command})` : `(cd ${shellQuote(c.cwd)} && ${c.command})`)
+            .join(" && ");
+    const head = commands.length === 1
+        ? `${runners[0].split(": ")[1]} in ${commands[0].cwd} for ${tests.length} selected test file(s)`
+        : `${tests.length} selected test file(s) across ${commands.length} packages (${runners.join(", ")}); run from the repository root`;
+    return {
+        command,
+        commandReason: [head, ...notes].join("; "),
+        commands,
+    };
+}
+/** Full-suite command for a package (root `all` mode). */
+function fullSuiteCommand(pkg) {
+    if (pkg?.scripts?.test)
+        return "npm test";
+    const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+    if (deps.vitest)
+        return "npx vitest run";
+    if (deps.jest)
+        return "npx jest";
+    return "node --test";
+}
+/** Nearest directory at or above `dir` (repo-relative) holding a `package.json`; `.` at worst. */
+function nearestPackageDir(root, dir, cache) {
+    const hit = cache.get(dir);
+    if (hit !== undefined)
+        return hit;
+    let found;
+    if (dir === "." || dir === "" || dir === "/")
+        found = ".";
+    else if (fs.existsSync(path.join(root, dir, "package.json")))
+        found = dir;
+    else
+        found = nearestPackageDir(root, path.posix.dirname(dir), cache);
+    cache.set(dir, found);
+    return found;
+}
+/** Whether a package declares vitest or jest as a dependency. */
+function declaresRunner(pkg) {
+    const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+    return Boolean(deps.vitest || deps.jest);
+}
+/**
+ * Runner inherited by a package that declares none (no `scripts.test`, no
+ * vitest/jest dependency): the nearest ancestor `package.json`, up to the
+ * root, that declares vitest or jest — the hoisted-monorepo layout. Returns
+ * the package to plan with (the leaf with the ancestor's runner dependencies)
+ * and the ancestor's directory, or null when nothing is inherited.
+ */
+function inheritedRunner(root, cwd, own) {
+    if (cwd === "." || own?.scripts?.test || declaresRunner(own))
+        return null;
+    let dir = cwd;
+    while (dir !== ".") {
+        dir = path.posix.dirname(dir);
+        if (dir === "" || dir === "/")
+            dir = ".";
+        const anc = readPackage(path.join(root, dir));
+        if (!declaresRunner(anc))
+            continue;
+        const deps = { ...anc?.dependencies, ...anc?.devDependencies };
+        const runnerDeps = {};
+        if (deps.vitest)
+            runnerDeps.vitest = deps.vitest;
+        if (deps.jest)
+            runnerDeps.jest = deps.jest;
+        return {
+            pkg: { ...own, devDependencies: { ...own?.devDependencies, ...runnerDeps } },
+            dir,
+        };
+    }
+    return null;
+}
+/** Flags dropped from a `node --test` script: coverage thresholds fail on a subset. */
+function isCoverageFlag(token) {
+    return token === "--experimental-test-coverage" || token.startsWith("--test-coverage-");
+}
+/** Node flags whose value may follow as a separate word (`--import ./x.mjs`). */
+const NODE_VALUE_FLAGS = new Set([
+    "--import",
+    "--require",
+    "-r",
+    "--loader",
+    "--experimental-loader",
+    "--env-file",
+    "--conditions",
+    "-C",
+    "--test-reporter",
+    "--test-reporter-destination",
+    "--test-name-pattern",
+    "--test-skip-pattern",
+    "--test-concurrency",
+    "--test-timeout",
+    "--test-shard",
+    "--test-coverage-lines",
+    "--test-coverage-branches",
+    "--test-coverage-functions",
+    "--test-coverage-include",
+    "--test-coverage-exclude",
+]);
+/**
+ * Split a `node --test` script's words (after `node`) into the flags to keep
+ * and the positional test globs. A value-taking flag keeps its value with it;
+ * coverage flags are dropped together with their values. A directory
+ * positional (no glob character, no file extension) becomes `<dir>/**`, so it
+ * matches every file under it.
+ */
+function splitNodeTestArgs(words) {
+    const flags = [];
+    const globs = [];
+    for (let i = 0; i < words.length; i++) {
+        const word = words[i];
+        if (word.startsWith("-")) {
+            const group = [word];
+            if (!word.includes("=") && NODE_VALUE_FLAGS.has(word) && i + 1 < words.length) {
+                group.push(words[++i]);
+            }
+            if (!isCoverageFlag(word))
+                flags.push(...group);
+            continue;
+        }
+        const isDir = !/[*?{[]/.test(word) && !/\.[cm]?[jt]sx?$/.test(word);
+        globs.push(isDir ? `${word.replace(/\/+$/, "")}/**` : word);
     }
-    const args = tests.map(shellQuote).join(" ");
-    if (script && /\bnode\s+--test\b/.test(script)) {
-        return `node --test ${args}`;
+    return { flags, globs };
+}
+/** Source extensions mapped to their compiled JavaScript counterparts. */
+const COMPILED_EXT = [
+    [/\.tsx?$/, ".js"],
+    [/\.mts$/, ".mjs"],
+    [/\.cts$/, ".cjs"],
+];
+/** Source path with its TypeScript extension swapped for the compiled one. */
+function compiledPath(file) {
+    let out = file;
+    for (const [re, ext] of COMPILED_EXT)
+        out = out.replace(re, ext);
+    return out;
+}
+/**
+ * Map a source test path onto the script's globs: the path itself when a glob
+ * matches it, else `<first glob segment>/<compiled path>` when that matches.
+ * `helper` marks a file whose name no glob's last segment can match (e.g.
+ * `test/helpers/fixtures.ts` against `*.test.js`): the runner never executes it,
+ * not even in a full run, so it is left out rather than forcing the full suite.
+ * `null` means a test-shaped file that could not be mapped.
+ */
+function mapOntoGlobs(file, globs) {
+    if (globs.some((g) => matchGlob(file, g)))
+        return file;
+    const base = path.posix.basename(file);
+    const testShaped = globs.some((g) => {
+        const last = g.split("/").pop() ?? g;
+        return matchGlob(base, last) || matchGlob(compiledPath(base), last);
+    });
+    if (!testShaped)
+        return "helper";
+    for (const glob of globs) {
+        const first = glob.split("/")[0];
+        if (!first || /[*{]/.test(first))
+            continue;
+        const mapped = `${first}/${compiledPath(file)}`;
+        if (matchGlob(mapped, glob))
+            return mapped;
+    }
+    return null;
+}
+/**
+ * Command for one package group, with its detected runner and an optional note.
+ * `command` is null only when every file is a helper the runner never executes;
+ * `kept` lists the files the command runs when helpers were left out.
+ */
+function groupCommand(pkg, files) {
+    const script = pkg?.scripts?.test;
+    const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+    const args = files.map(shellQuote).join(" ");
+    const tokens = script ? shellSplit(script) : [];
+    const isNodeTest = tokens[0] === "node" && tokens.includes("--test");
+    if ((script && /\bvitest\b/.test(script)) || (!script && deps.vitest)) {
+        return { command: `npx vitest run ${args}`, runner: "vitest" };
+    }
+    if ((script && /\bjest\b/.test(script)) || (!isNodeTest && deps.jest)) {
+        return { command: `npx jest --runTestsByPath ${args}`, runner: "jest" };
+    }
+    if (isNodeTest) {
+        const { flags, globs } = splitNodeTestArgs(tokens.slice(1));
+        const base = ["node", ...flags].map(shellQuote).join(" ");
+        if (globs.length === 0)
+            return { command: `${base} ${args}`, runner: "node --test" };
+        const mapped = files.map((f) => mapOntoGlobs(f, globs));
+        if (mapped.some((m) => m === null)) {
+            return {
+                command: "npm test",
+                runner: "node --test",
+                note: "a selected test file does not fit the test script's glob, so the full suite runs (a safe superset)",
+            };
+        }
+        const runnable = mapped.filter((m) => m !== null && m !== "helper");
+        const kept = files.filter((_, i) => mapped[i] !== "helper");
+        const helpers = mapped.length - runnable.length;
+        const helperNote = helpers > 0 ? `${helpers} helper file(s) the test script never runs left out` : undefined;
+        if (runnable.length === 0)
+            return { command: null, runner: "node --test", note: helperNote };
+        const compiled = runnable.some((m) => !files.includes(m));
+        const prefix = compiled && pkg?.scripts?.pretest ? "npm run pretest && " : "";
+        const notes = [
+            compiled ? "files mapped onto the compiled test glob; coverage flags dropped" : undefined,
+            helperNote,
+        ].filter((n) => n !== undefined);
+        return {
+            command: `${prefix}${base} ${runnable.map(shellQuote).join(" ")}`,
+            runner: "node --test",
+            note: notes.length > 0 ? notes.join("; ") : undefined,
+            kept,
+        };
     }
     if (script) {
-        // Pass paths after `--` for npm/vitest/jest-style scripts.
-        return `npm test -- ${args}`;
+        return {
+            command: `npm test -- ${args}`,
+            runner: "npm test",
+            note: "unrecognized test script: paths are forwarded and it may run the full suite (a superset)",
+        };
+    }
+    return { command: `node --test ${args}`, runner: "node --test" };
+}
+/** Split a shell command line into words, honoring single and double quotes. */
+function shellSplit(line) {
+    const out = [];
+    let cur = "";
+    let quote = null;
+    let has = false;
+    for (const ch of line) {
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+            else
+                cur += ch;
+        }
+        else if (ch === "'" || ch === '"') {
+            quote = ch;
+            has = true;
+        }
+        else if (/\s/.test(ch)) {
+            if (has || cur)
+                out.push(cur);
+            cur = "";
+            has = false;
+        }
+        else {
+            cur += ch;
+        }
     }
-    return `node --test ${args}`;
+    if (has || cur)
+        out.push(cur);
+    return out;
 }
 function shellQuote(p) {
-    if (/^[A-Za-z0-9_./-]+$/.test(p))
+    if (/^[A-Za-z0-9_./=:,@+-]+$/.test(p))
         return p;
     return `'${p.replace(/'/g, `'\\''`)}'`;
 }