jev-agent-tools 0.1.4 → 0.2.0

package/dist/core/runner-version.js

@@ -0,0 +1,45 @@
+export function runnerVersion(value) {
+    return typeof value === "string" &&
+        /^\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?$/.test(value)
+        ? value
+        : undefined;
+}
+/** Parse only resolved lock versions, never dependency ranges or executable configuration. */
+export function lockedRunnerVersion(runner, path, text) {
+    if (path.endsWith("package-lock.json")) {
+        try {
+            const lock = JSON.parse(text);
+            return runnerVersion(lock.packages?.[`node_modules/${runner}`]?.version ??
+                lock.dependencies?.[runner]?.version);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (path.endsWith("bun.lock")) {
+        const match = new RegExp(`"${runner}"\\s*:\\s*\\[\\s*"${runner}@(\\d+\\.\\d+\\.\\d+(?:-[\\w.-]+)?)"`).exec(text);
+        return runnerVersion(match?.[1]);
+    }
+    if (path.endsWith("pnpm-lock.yaml")) {
+        const rootImporter = /(?:^|\n) {2}\.:\s*\n([\s\S]*?)(?=\n {2}[^ ]|\n[^ ]|$)/.exec(text)?.[1] ??
+            "";
+        const block = new RegExp(`(?:^|\\n)\\s{4,}${runner}:\\s*\\n\\s+specifier:[^\\n]*\\n\\s+version:\\s*['"]?([^\\s'"(]+)`).exec(rootImporter);
+        return runnerVersion(block?.[1]);
+    }
+    if (path.endsWith("yarn.lock")) {
+        const expression = new RegExp(`(?:^|\\n)["']?${runner}@[^\\n]*:\\s*\\n(?:[^\\n]*\\n)*?\\s+version[ :]+["']?([^\\s"']+)`, "g");
+        const versions = new Set([...text.matchAll(expression)].map((match) => runnerVersion(match[1])));
+        return versions.size === 1 ? [...versions][0] : undefined;
+    }
+    return undefined;
+}
+// Only identity-smoked release lines can receive native name filters.
+export const VERIFIED_NAME_FILTERS = {
+    vitest: [
+        { version: /^3\.2\.\d+$/, separator: " " },
+        { version: /^4\.1\.\d+$/, separator: " " },
+        { version: /^5\.0\.\d+$/, separator: " > " },
+    ],
+    jest: [{ version: /^30\.\d+\.\d+$/, separator: " " }],
+    mocha: [{ version: /^11\.8\.0$/, separator: " " }],
+};

package/dist/core/sections.js

@@ -0,0 +1,230 @@
+import { LOCATE_SECTION_MAX_LINES, LOCATE_SECTION_MIN_LINES, LOCATE_WINDOW_LINES, } from "../constants.js";
+/** Exact Markdown heading sections; callers may apply their own display grouping. */
+export function markdownSections(text) {
+    const lines = text.split("\n");
+    if (lines.at(-1) === "")
+        lines.pop();
+    const headings = [];
+    let fence;
+    let frontMatter = lines[0]?.trim() === "---";
+    let html;
+    let previousText = false;
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index] ?? "";
+        if (frontMatter) {
+            if (index > 0 && /^(?:---|\.\.\.)\s*$/.test(line))
+                frontMatter = false;
+            previousText = false;
+            continue;
+        }
+        if (html) {
+            if (html === "blank" ? !line.trim() : line.toLowerCase().includes(html))
+                html = undefined;
+            previousText = false;
+            continue;
+        }
+        const marker = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+        if (fence) {
+            if (marker &&
+                marker[1]?.[0] === fence.character &&
+                marker[1].length >= fence.length &&
+                !marker[2]?.trim())
+                fence = undefined;
+            previousText = false;
+            continue;
+        }
+        if (marker && !(marker[1]?.[0] === "`" && marker[2]?.includes("`"))) {
+            fence = {
+                character: marker[1]?.[0] ?? "`",
+                length: marker[1]?.length ?? 3,
+            };
+            previousText = false;
+            continue;
+        }
+        const block = /^ {0,3}<(script|pre|style|textarea)(?:\s|>|$)/i.exec(line);
+        const closing = line.trimStart().startsWith("<!--")
+            ? "-->"
+            : block
+                ? `</${block[1]?.toLowerCase()}>`
+                : /^ {0,3}<\/?(?:address|article|aside|blockquote|div|dl|fieldset|figure|footer|form|h[1-6]|header|hr|li|main|nav|ol|p|section|table|tbody|td|th|tr|ul)(?:\s|\/?>|$)/i.test(line)
+                    ? "blank"
+                    : undefined;
+        if (closing) {
+            if (closing === "blank" || !line.toLowerCase().includes(closing))
+                html = closing;
+            previousText = false;
+            continue;
+        }
+        const heading = /^ {0,3}#{1,6}(?:[\t ]+|$)(.*?)\s*$/.exec(line);
+        if (heading) {
+            headings.push({
+                start: index + 1,
+                level: line.trimStart().match(/^#+/)?.[0].length ?? 1,
+                label: (heading[1] ?? "").replace(/[\t ]+#+[\t ]*$/, "").trim(),
+            });
+            previousText = false;
+        }
+        else if (previousText && /^ {0,3}(?:=+|-+)\s*$/.test(line)) {
+            headings.push({
+                start: index,
+                level: line.trimStart().startsWith("=") ? 1 : 2,
+                label: lines[index - 1]?.trim() ?? "",
+            });
+            previousText = false;
+        }
+        else
+            previousText = Boolean(line.trim()) && !/^ {4}|^\t/.test(line);
+    }
+    return headings.map((heading, index) => {
+        const end = (headings[index + 1]?.start ?? lines.length + 1) - 1;
+        return {
+            id: `S${index + 1}`,
+            ...heading,
+            end,
+            text: lines.slice(heading.start - 1, end).join("\n"),
+        };
+    });
+}
+/** Produces disjoint, exhaustive ranges; labels never replace the underlying evidence. */
+export function sectionFile(path, text, declarations) {
+    const lines = text.split("\n");
+    if (lines.at(-1) === "")
+        lines.pop();
+    if (!lines.length)
+        return { sections: [], lines: 0, method: "windows" };
+    const boundaries = [];
+    let method = "windows";
+    if (declarations?.length) {
+        const sorted = [...declarations].sort((a, b) => a.start - b.start || b.end - a.end);
+        const ancestors = [];
+        for (let index = 0; index < sorted.length; index++) {
+            const declaration = sorted[index];
+            if (!declaration)
+                continue;
+            while ((ancestors.at(-1)?.end ?? Infinity) < declaration.end)
+                ancestors.pop();
+            const enclosing = ancestors.at(-1);
+            const suppressed = enclosing &&
+                enclosing.end - enclosing.start + 1 <= LOCATE_SECTION_MAX_LINES;
+            if (!suppressed && boundaries.at(-1)?.start !== declaration.start)
+                boundaries.push({ start: declaration.start, label: declaration.name });
+            ancestors.push(declaration);
+            if (!suppressed && declaration.end < lines.length)
+                boundaries.push({
+                    start: declaration.end + 1,
+                    label: `${enclosing?.name ?? declaration.name} continuation`,
+                });
+        }
+        boundaries.sort((a, b) => a.start - b.start ||
+            Number(a.label.endsWith(" continuation")) -
+                Number(b.label.endsWith(" continuation")));
+        for (let index = boundaries.length - 1; index > 0; index--)
+            if (boundaries[index]?.start === boundaries[index - 1]?.start)
+                boundaries.splice(index, 1);
+        method = "syntax";
+    }
+    else if (/\.(?:md|mdx|markdown)$/i.test(path)) {
+        for (const section of markdownSections(text))
+            boundaries.push({ start: section.start, label: section.label });
+        if (boundaries.length)
+            method = "markdown";
+    }
+    if (!boundaries.length) {
+        let pythonClass;
+        lines.forEach((line, index) => {
+            const indentation = line.length - line.trimStart().length;
+            if (path.endsWith(".py") &&
+                line.trim() &&
+                !line.trimStart().startsWith("#")) {
+                if (pythonClass && indentation <= pythonClass.indent)
+                    pythonClass = undefined;
+                const className = /^\s*class\s+(\w+)/.exec(line)?.[1];
+                if (className) {
+                    pythonClass = {
+                        name: className,
+                        indent: indentation,
+                        start: index + 1,
+                        seenMethod: false,
+                    };
+                    boundaries.push({ start: index + 1, label: className });
+                    return;
+                }
+            }
+            const declaration = /^\s*(?:(?:export|default|async|public|private|protected|static|abstract)\s+)*(?:(?:function\s*\*?|class|interface|enum|type|def|fn|func|struct|impl)\s+([\w.$]+)|(?:const|let|var)\s+([\w$]+)\s*=|([\w$]+)\s*\([^;]*\)\s*(?::[^=]+)?\s*\{)/.exec(line);
+            if (!declaration)
+                return;
+            const indent = line.length - line.trimStart().length;
+            if (indent > 4 ||
+                /^(?:if|for|while|switch|catch)$/.test(declaration[3] ?? ""))
+                return;
+            let start = index + 1;
+            if (path.endsWith(".py") &&
+                pythonClass &&
+                /^\s*(?:async\s+)?def\s/.test(line) &&
+                !pythonClass.seenMethod) {
+                boundaries.pop();
+                pythonClass.seenMethod = true;
+                start = pythonClass.start;
+            }
+            boundaries.push({
+                start,
+                label: pythonClass
+                    ? `${pythonClass.name}.${declaration[1] ?? "method"}`
+                    : (declaration[1] ?? declaration[2] ?? declaration[3] ?? "section"),
+            });
+        });
+        if (boundaries.length)
+            method = "heuristic";
+    }
+    if (!boundaries.length) {
+        for (let start = 1; start <= lines.length; start += LOCATE_WINDOW_LINES)
+            boundaries.push({
+                start,
+                label: `lines ${start}-${Math.min(lines.length, start + LOCATE_WINDOW_LINES - 1)}`,
+            });
+    }
+    else {
+        const first = boundaries[0];
+        if (first)
+            first.start = 1;
+    }
+    const ranges = boundaries.map((boundary, index) => ({
+        ...boundary,
+        end: (boundaries[index + 1]?.start ?? lines.length + 1) - 1,
+    }));
+    // Split oversized leaf nodes without losing a line or inventing syntax.
+    const chunks = ranges.flatMap((range) => {
+        const result = [];
+        const size = method === "windows" ? LOCATE_WINDOW_LINES : LOCATE_SECTION_MAX_LINES;
+        for (let start = range.start; start <= range.end; start += size)
+            result.push({
+                start,
+                end: Math.min(range.end, start + size - 1),
+                label: range.label,
+            });
+        return result;
+    });
+    const merged = [];
+    for (const chunk of chunks) {
+        const previous = merged.at(-1);
+        if (method !== "windows" &&
+            previous &&
+            (chunk.end - chunk.start + 1 < LOCATE_SECTION_MIN_LINES ||
+                previous.end - previous.start + 1 < LOCATE_SECTION_MIN_LINES) &&
+            chunk.end - previous.start + 1 <= LOCATE_SECTION_MAX_LINES) {
+            previous.end = chunk.end;
+            previous.label += ` / ${chunk.label}`;
+        }
+        else
+            merged.push({ ...chunk });
+    }
+    return {
+        lines: lines.length,
+        method,
+        sections: merged.map((range, index) => ({
+            id: `S${index + 1}`,
+            ...range,
+            text: lines.slice(range.start - 1, range.end).join("\n"),
+        })),
+    };
+}

package/dist/core/state.js

@@ -0,0 +1,44 @@
+import { ASK_NOTE_MAX_CHARS, STATE_MAX_CHARS } from "../constants.js";
+import { isRecord } from "../result.js";
+const reservedKeys = ["files", "files_before", "base_sha", "closure"];
+export function assembleState(note, files) {
+    if (note !== undefined && note.length > ASK_NOTE_MAX_CHARS)
+        return {
+            ok: false,
+            error: `state exceeds ${ASK_NOTE_MAX_CHARS} chars (${note.length}); shorten the note.`,
+        };
+    let state = {};
+    if (note !== undefined) {
+        let parsed;
+        try {
+            parsed = JSON.parse(note);
+        }
+        catch {
+            parsed = note;
+        }
+        const reserved = isRecord(parsed)
+            ? reservedKeys.find((key) => Object.hasOwn(parsed, key))
+            : undefined;
+        if (reserved)
+            return {
+                ok: false,
+                error: `state contains reserved key ${reserved}; rename it in your note and use paths for files read by code.`,
+            };
+        if (isRecord(parsed))
+            state = parsed;
+        else
+            state.state = parsed;
+    }
+    const noteSize = JSON.stringify(state).length;
+    if (Object.keys(files).length)
+        state.files = files;
+    const size = JSON.stringify(state).length;
+    if (size > STATE_MAX_CHARS)
+        return {
+            ok: false,
+            error: `serialized state exceeds ${STATE_MAX_CHARS} chars (${size}); serialized parts: note ${noteSize}, ${Object.entries(files)
+                .map(([path, text]) => `${path} ${JSON.stringify({ [path]: text }).length}`)
+                .join(", ")}. Split the situation into smaller states or provide smaller source files; files are never truncated.`,
+        };
+    return { ok: true, state };
+}

package/dist/core/syntax.js

@@ -0,0 +1 @@
+export {};

package/dist/core/test-commands.js

@@ -0,0 +1,334 @@
+import { posix } from "node:path";
+import { SELECT_FILE_SHARE } from "../constants.js";
+import { VERIFIED_NAME_FILTERS } from "./runner-version.js";
+const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const exactPattern = (names) => [...new Set(names)].map((name) => `^${escapeRegex(name)}$`).join("|");
+const localPath = (entry, path = entry.path) => posix.relative(entry.cwd, path) || ".";
+function resolveSelection(selection) {
+    const { entry, scenarioIds } = selection;
+    if (scenarioIds === null)
+        return { entry, scenarios: null };
+    if (!entry.countKnown)
+        return { entry, scenarios: null, reason: "unknown scenario count" };
+    const ids = new Set(scenarioIds);
+    const scenarios = entry.scenarios.filter((scenario) => ids.has(scenario.id));
+    if (scenarios.length !== ids.size)
+        return {
+            entry,
+            scenarios: null,
+            reason: "unresolved scenario identifier",
+        };
+    if (scenarios.length >= entry.scenarios.length * SELECT_FILE_SHARE)
+        return { entry, scenarios: null };
+    if (entry.scenarios.some((scenario) => !scenario.reliable))
+        return { entry, scenarios: null, reason: "dynamic names or parameters" };
+    const names = new Set();
+    for (const scenario of entry.scenarios) {
+        if (names.has(scenario.name))
+            return { entry, scenarios: null, reason: "ambiguous scenario names" };
+        names.add(scenario.name);
+    }
+    return { entry, scenarios };
+}
+/** Builds argument vectors only; neither collects nor executes any runner. */
+export function buildRunnerCommands(selected) {
+    const commands = [];
+    const limits = [];
+    const groups = new Map();
+    for (const selection of selected) {
+        if (selection.scenarioIds !== null && selection.scenarioIds.length === 0)
+            continue;
+        const { entry } = selection;
+        const key = JSON.stringify([
+            entry.cwd,
+            entry.framework,
+            entry.runnerVersion,
+            entry.config,
+            entry.project,
+            entry.options,
+            entry.kind,
+            entry.invocation,
+            entry.commandRefusal,
+            entry.nameFilterBlocked,
+            entry.nameFilterReason,
+        ]);
+        const group = groups.get(key);
+        if (group)
+            group.push(selection);
+        else
+            groups.set(key, [selection]);
+    }
+    for (const group of groups.values()) {
+        const entry = group[0].entry;
+        const files = [...new Set(group.map((item) => item.entry.path))];
+        const limit = (reason, action) => {
+            limits.push({ files, reason, action });
+        };
+        if (entry.kind === "types") {
+            if (entry.invocation?.kind === "typecheck") {
+                commands.push({
+                    cwd: entry.cwd,
+                    framework: entry.framework,
+                    ...(entry.config ? { config: entry.config } : {}),
+                    ...(entry.project ? { project: entry.project } : {}),
+                    executable: entry.invocation.executable,
+                    args: [...entry.invocation.args],
+                    files,
+                });
+                limit("typecheck project scope: selected files do not restrict the command", "run the identified project type-check command without file or name filters");
+            }
+            else {
+                limit("type tests: command not identified", "run the project's type-check command");
+            }
+            continue;
+        }
+        if (entry.framework === "unknown") {
+            limit("framework unknown", "run the listed files with the project runner");
+            continue;
+        }
+        if (entry.commandRefusal) {
+            limit(entry.commandRefusal, "run the listed files with the project runner");
+            continue;
+        }
+        if (["ava", "mocha"].includes(entry.framework) &&
+            files.some((file) => /[*?[\]{}()!]/.test(localPath(entry, file)))) {
+            limit("targeted path has unverified glob metacharacters", "run the listed files with the project runner");
+            continue;
+        }
+        if (entry.invocation?.kind !== "runner")
+            limit("local_runner_unproven: native executable availability is not established", "verify the local executable or use the project's runner script");
+        const resolved = group.map(resolveSelection);
+        for (const item of resolved)
+            if (item.entry.nameFilterReason)
+                limits.push({
+                    files: [item.entry.path],
+                    reason: `fallback: all — ${item.entry.nameFilterReason}`,
+                    action: "run the whole file with the project runner",
+                });
+        for (const item of resolved) {
+            if (item.reason)
+                limits.push({
+                    files: [item.entry.path],
+                    reason: `fallback: all — ${item.reason}`,
+                    action: "run the whole file with the project runner",
+                });
+        }
+        let wholeGroup = false;
+        const nominal = ["vitest", "jest", "node", "bun", "go", "mocha"].includes(entry.framework);
+        if (nominal &&
+            resolved.some((item) => item.scenarios === null) &&
+            resolved.some((item) => item.scenarios !== null)) {
+            wholeGroup = true;
+            limit("fallback: all — whole files and name filters in the same group", "run all listed files without a name filter");
+        }
+        const paths = files.map((file) => localPath(entry, file));
+        const scenarios = resolved.flatMap((item) => item.scenarios ?? []);
+        let pattern = !wholeGroup && resolved.every((item) => item.scenarios !== null)
+            ? exactPattern(scenarios.map((scenario) => scenario.name))
+            : undefined;
+        if (pattern &&
+            (entry.framework === "vitest" ||
+                entry.framework === "jest" ||
+                entry.framework === "mocha")) {
+            const contract = VERIFIED_NAME_FILTERS[entry.framework].find((candidate) => candidate.version.test(entry.runnerVersion ?? ""));
+            if (!contract ||
+                (contract.separator !== " " &&
+                    scenarios.some((scenario) => !scenario.nameParts))) {
+                pattern = undefined;
+                limit(`name filter skipped: ${entry.framework} ${entry.runnerVersion ?? "unknown"} not verified`, "run the whole file with the project runner");
+            }
+            else {
+                pattern = exactPattern(scenarios.map((scenario) => scenario.nameParts?.join(contract.separator) ?? scenario.name));
+            }
+        }
+        if (entry.nameFilterBlocked)
+            pattern = undefined;
+        let executable;
+        let args;
+        const config = entry.config ? localPath(entry, entry.config) : undefined;
+        switch (entry.framework) {
+            case "ava":
+                executable = "ava";
+                args = [...entry.options];
+                if (config && !config.endsWith("package.json"))
+                    args.push("--config", config);
+                args.push(...paths);
+                break;
+            case "mocha":
+                executable = "mocha";
+                args = [...entry.options];
+                if (config && !config.endsWith("package.json"))
+                    args.push("--config", config);
+                if (pattern)
+                    args.push("--grep", pattern);
+                args.push(...paths);
+                break;
+            case "deno":
+                executable = "deno";
+                args = ["test", ...entry.options];
+                if (config)
+                    args.push("--config", config);
+                args.push(...paths);
+                break;
+            case "vitest":
+                executable = "vitest";
+                args = ["run", ...entry.options];
+                if (config)
+                    args.push("--config", config);
+                if (entry.project)
+                    args.push("--project", entry.project);
+                if (pattern)
+                    args.push("-t", pattern);
+                args.push(...paths);
+                break;
+            case "jest":
+                executable = "jest";
+                args = [...entry.options];
+                if (config)
+                    args.push("--config", config);
+                if (entry.project)
+                    args.push("--selectProjects", entry.project);
+                if (pattern)
+                    args.push("-t", pattern);
+                args.push("--runTestsByPath", ...paths);
+                break;
+            case "node":
+                executable = "node";
+                if (pattern) {
+                    if (scenarios.some((scenario) => scenario.ancestors === undefined)) {
+                        pattern = undefined;
+                        limit("fallback: all — unresolved node:test hierarchy", "run all listed files without a name filter");
+                    }
+                    else {
+                        pattern = exactPattern(scenarios.flatMap((scenario) => [
+                            ...(scenario.ancestors ?? []),
+                            scenario.name,
+                        ]));
+                        if (scenarios.some((scenario) => (scenario.ancestors?.length ?? 0) > 0))
+                            limit("node:test: admitting an ancestor may also run its other subtests", "verify the expanded subtree with the project runner");
+                    }
+                }
+                args = [...entry.options, "--test"];
+                if (pattern)
+                    args.push("--test-name-pattern", pattern);
+                args.push(...paths);
+                break;
+            case "bun":
+                executable = "bun";
+                args = config ? ["--config", config, "test"] : ["test"];
+                args.push(...entry.options);
+                if (pattern)
+                    args.push("--test-name-pattern", pattern);
+                args.push(...paths.map((path) => (posix.isAbsolute(path) ? path : `./${path}`)));
+                break;
+            case "playwright":
+                executable = "playwright";
+                args = ["test", ...entry.options];
+                if (config)
+                    args.push("--config", config);
+                if (entry.project)
+                    args.push("--project", entry.project);
+                for (const item of resolved) {
+                    const path = escapeRegex(localPath(item.entry));
+                    if (item.scenarios === null ||
+                        item.scenarios.some((scenario) => scenario.line < 1)) {
+                        args.push(path);
+                        if (item.scenarios !== null)
+                            limit("fallback: all — unknown declaration line", "run the whole file with the project runner");
+                    }
+                    else {
+                        args.push(...new Set(item.scenarios.map((scenario) => `${path}:${scenario.line}`)));
+                    }
+                }
+                break;
+            case "go": {
+                executable = "go";
+                const packages = [
+                    ...new Set(paths.map((path) => {
+                        const directory = posix.dirname(path);
+                        return directory === "."
+                            ? "."
+                            : directory.startsWith(".")
+                                ? directory
+                                : `./${directory}`;
+                    })),
+                ];
+                if (pattern) {
+                    const names = scenarios.map((scenario) => {
+                        const separator = scenario.name.indexOf("/");
+                        return separator < 0
+                            ? scenario.name
+                            : scenario.name.slice(0, separator);
+                    });
+                    if (names.some((name) => !/^(Test|Example)[A-Za-z0-9_]*$/.test(name))) {
+                        pattern = undefined;
+                        limit("fallback: all — benchmarks or fuzz targets cannot be expressed safely", "run the affected packages, benchmarks and fuzz targets with the project runner");
+                    }
+                    else {
+                        pattern = exactPattern(names);
+                        if (scenarios.some((scenario) => scenario.name.includes("/")))
+                            limit("fallback: all — Go subtest: whole parent retained", "run the selected top-level parents with the project runner");
+                    }
+                }
+                args = ["test", ...entry.options, ...packages];
+                if (pattern)
+                    args.push("-run", pattern);
+                limit("Go runs packages, not files; examples and build constraints depend on the project", "verify build constraints and executable examples with the project runner");
+                break;
+            }
+            case "pytest":
+                executable = "python";
+                args = ["-m", "pytest", ...entry.options];
+                if (config)
+                    args.push("-c", config);
+                for (const item of resolved) {
+                    const path = localPath(item.entry);
+                    if (item.scenarios === null)
+                        args.push(path);
+                    else
+                        for (const scenario of item.scenarios) {
+                            const separator = scenario.name.indexOf("::");
+                            const nodePath = scenario.name.slice(0, separator);
+                            const isFullId = separator >= 0 &&
+                                (nodePath === item.entry.path || nodePath === path);
+                            args.push(isFullId
+                                ? path + scenario.name.slice(separator)
+                                : `${path}::${scenario.name}`);
+                        }
+                }
+                break;
+            default:
+                continue;
+        }
+        if (entry.invocation?.kind === "runner") {
+            // Identified options are already part of the invocation prefix.
+            const bunConfig = entry.framework === "bun" && config ? 2 : 0;
+            const prefixLength = entry.options.length +
+                bunConfig +
+                (entry.framework === "pytest"
+                    ? 2
+                    : ["jest", "ava", "mocha"].includes(entry.framework)
+                        ? 0
+                        : 1);
+            executable = entry.invocation.executable;
+            args = [
+                ...(bunConfig ? ["--config", config] : []),
+                ...(entry.framework === "vitest" && entry.invocation.args[0] !== "run"
+                    ? ["run"]
+                    : []),
+                ...entry.invocation.args,
+                ...args.slice(prefixLength),
+            ];
+        }
+        commands.push({
+            cwd: entry.cwd,
+            framework: entry.framework,
+            ...(entry.config ? { config: entry.config } : {}),
+            ...(entry.project ? { project: entry.project } : {}),
+            executable,
+            args,
+            files,
+        });
+    }
+    return { commands, limits };
+}