@tea-agent/loop-agent 0.24.11-beta.0 → 0.25.0

package/dist/verification/maven/cache.js

@@ -0,0 +1,142 @@
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, } from "node:fs";
+import path from "node:path";
+import { MAVEN_CACHE_SCHEMA_VERSION, MAVEN_PLANNER_VERSION, } from "./types.js";
+import { buildMavenWorkspaceGraph } from "./workspace-graph.js";
+const CACHE_FILE_NAME = "maven-workspace-graph.json";
+/** Directory names ignored during discovery and lightweight entry-list checks. */
+const SKIP_DIR_NAMES = new Set([
+    ".git",
+    ".harness",
+    "node_modules",
+    "target",
+    "dist",
+    "build",
+    ".idea",
+    ".vscode",
+    "coverage",
+    ".turbo",
+    ".next",
+]);
+export function defaultMavenCacheDir(repoRoot) {
+    return path.join(repoRoot, ".harness", "cache");
+}
+export function mavenGraphCachePath(cacheDir) {
+    return path.join(cacheDir, CACHE_FILE_NAME);
+}
+function isValidCachedGraph(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const graph = value;
+    return (graph.schemaVersion === MAVEN_CACHE_SCHEMA_VERSION &&
+        graph.plannerVersion === MAVEN_PLANNER_VERSION &&
+        typeof graph.fingerprint === "string" &&
+        Array.isArray(graph.pomPaths) &&
+        Array.isArray(graph.nodes));
+}
+/**
+ * Lightweight freshness probe: only stat previously recorded directories and
+ * file metadata. Does NOT re-walk the whole tree or re-parse POMs.
+ * Returns true when the cached graph can be reused as-is.
+ */
+export function isCachedGraphStillFresh(repoRoot, graph) {
+    if (graph.schemaVersion !== MAVEN_CACHE_SCHEMA_VERSION ||
+        graph.plannerVersion !== MAVEN_PLANNER_VERSION) {
+        return false;
+    }
+    const manifest = graph.manifest;
+    if (!manifest) {
+        // Old cache shape without manifest cannot prove lightweight freshness.
+        return false;
+    }
+    // Directory entry lists: any add/remove invalidates.
+    for (const dir of manifest.directories) {
+        const absDir = dir.path === "" ? repoRoot : path.join(repoRoot, ...dir.path.split("/"));
+        let entries;
+        try {
+            entries = readdirSync(absDir, { withFileTypes: true })
+                .filter((e) => {
+                if (SKIP_DIR_NAMES.has(e.name))
+                    return false;
+                try {
+                    return !e.isSymbolicLink();
+                }
+                catch {
+                    return true;
+                }
+            })
+                .map((e) => e.name)
+                .sort();
+        }
+        catch {
+            return false;
+        }
+        if (entries.length !== dir.entryNames.length)
+            return false;
+        for (let i = 0; i < entries.length; i += 1) {
+            if (entries[i] !== dir.entryNames[i])
+                return false;
+        }
+    }
+    // File metadata: size/mtime change triggers rebuild (content re-hash on rebuild).
+    for (const file of manifest.files) {
+        const abs = path.join(repoRoot, ...file.path.split("/"));
+        try {
+            const lst = lstatSync(abs);
+            if (lst.isSymbolicLink())
+                return false;
+            const st = statSync(abs);
+            if (st.size !== file.size)
+                return false;
+            if (st.mtimeMs !== file.mtimeMs)
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Load cached graph when schema/planner versions match and lightweight
+ * directory/file metadata is unchanged. Full parse only on miss/stale.
+ */
+export function loadOrBuildMavenWorkspaceGraph(input) {
+    const cacheDir = input.cacheDir ?? defaultMavenCacheDir(input.repoRoot);
+    const cachePath = mavenGraphCachePath(cacheDir);
+    if (existsSync(cachePath)) {
+        try {
+            const raw = JSON.parse(readFileSync(cachePath, "utf8"));
+            if (isValidCachedGraph(raw) && isCachedGraphStillFresh(input.repoRoot, raw)) {
+                return raw;
+            }
+        }
+        catch {
+            // Fall through to rebuild.
+        }
+    }
+    const graph = buildMavenWorkspaceGraph(input.repoRoot);
+    writeGraphCache(cacheDir, graph);
+    return graph;
+}
+export function writeGraphCache(cacheDir, graph) {
+    mkdirSync(cacheDir, { recursive: true });
+    const payload = `${JSON.stringify(graph, null, 2)}\n`;
+    // Guard: never persist absolute host paths.
+    if (/[A-Za-z]:[\\/]/.test(payload) || payload.includes("\\\\")) {
+        // Absolute Windows paths are forbidden; re-check using graph fields only.
+        const serialized = JSON.stringify({
+            schemaVersion: graph.schemaVersion,
+            plannerVersion: graph.plannerVersion,
+            fingerprint: graph.fingerprint,
+            pomPaths: graph.pomPaths,
+            wrapperPaths: graph.wrapperPaths,
+            nodes: graph.nodes,
+            reactors: graph.reactors,
+            reactorRootByPomPath: graph.reactorRootByPomPath,
+            manifest: graph.manifest,
+        });
+        writeFileSync(mavenGraphCachePath(cacheDir), `${serialized}\n`, "utf8");
+        return;
+    }
+    writeFileSync(mavenGraphCachePath(cacheDir), payload, "utf8");
+}

package/dist/verification/maven/index.js

@@ -0,0 +1,120 @@
+import path from "node:path";
+import { loadOrBuildMavenWorkspaceGraph } from "./cache.js";
+import { commandContainsMaven, extractExplicitMavenFile, parseMavenInvocation, planMavenCommands, } from "./plan-commands.js";
+import { resolveMavenTargets } from "./scope-resolve.js";
+import { assertMavenPlanFresh } from "./stale.js";
+import { MAVEN_CACHE_SCHEMA_VERSION, MAVEN_PLANNER_VERSION, MavenPlanError, MavenPlanStaleError, } from "./types.js";
+export { MAVEN_CACHE_SCHEMA_VERSION, MAVEN_PLANNER_VERSION, MavenPlanError, MavenPlanStaleError, assertMavenPlanFresh, };
+function toPosix(value) {
+    return value.replace(/\\/g, "/");
+}
+function allMavenCommandsHaveExplicitFile(commands) {
+    const mavenCommands = commands.filter(commandContainsMaven);
+    if (mavenCommands.length === 0)
+        return false;
+    return mavenCommands.every((command) => {
+        const parsed = parseMavenInvocation(command);
+        if (!parsed)
+            return false;
+        return extractExplicitMavenFile(parsed.mavenArgs) !== undefined;
+    });
+}
+function targetsFromExplicitFiles(input) {
+    const byPom = new Map();
+    for (const command of input.commands) {
+        const parsed = parseMavenInvocation(command);
+        if (!parsed)
+            continue;
+        const explicit = extractExplicitMavenFile(parsed.mavenArgs);
+        if (!explicit)
+            continue;
+        // Resolve relative -f against the original command cwd.
+        const baseCwd = command.cwd ?? input.repoRoot;
+        const absolute = path.isAbsolute(explicit)
+            ? path.normalize(explicit)
+            : path.resolve(baseCwd, explicit);
+        const rel = toPosix(path.relative(input.repoRoot, absolute));
+        if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) {
+            // Keep unresolved path for planMavenCommands validation/fail-fast.
+            byPom.set(toPosix(explicit), {
+                pomPath: toPosix(explicit),
+                artifactId: path.posix.basename(toPosix(explicit).replace(/\/pom\.xml$/i, "")) || "unknown",
+            });
+            continue;
+        }
+        const node = input.graph.nodes.find((n) => n.pomPath === rel);
+        if (node) {
+            const reactorRoot = input.graph.reactorRootByPomPath[node.pomPath];
+            if (reactorRoot && reactorRoot !== node.pomPath) {
+                const reactor = input.graph.reactors.find((r) => r.rootPomPath === reactorRoot);
+                byPom.set(node.pomPath, {
+                    pomPath: node.pomPath,
+                    artifactId: node.artifactId,
+                    reactorRootPomPath: reactorRoot,
+                    moduleCoordinate: reactor?.modulePathByPomPath?.[node.pomPath] ??
+                        reactor?.artifactIdByPomPath[node.pomPath] ??
+                        node.artifactId,
+                });
+            }
+            else {
+                byPom.set(node.pomPath, {
+                    pomPath: node.pomPath,
+                    artifactId: node.artifactId,
+                    reactorRootPomPath: reactorRoot === node.pomPath ? reactorRoot : undefined,
+                });
+            }
+        }
+        else {
+            const base = rel.replace(/\/pom\.xml$/i, "");
+            const artifactId = base.split("/").filter(Boolean).pop() ?? rel;
+            byPom.set(rel, { pomPath: rel, artifactId });
+        }
+    }
+    return [...byPom.values()];
+}
+/**
+ * Plan Maven verification commands from task scope + static workspace graph.
+ * Non-Maven commands are returned unchanged. Returns plan=null when no Maven
+ * commands are present (REQ-MVN-007).
+ */
+export function planMavenVerification(input) {
+    const mavenCommands = input.commands.filter(commandContainsMaven);
+    if (mavenCommands.length === 0) {
+        return { commands: input.commands, plan: null };
+    }
+    const graph = loadOrBuildMavenWorkspaceGraph({
+        repoRoot: input.repoRoot,
+        cacheDir: input.cacheDir,
+    });
+    if (graph.pomPaths.length === 0) {
+        throw new MavenPlanError("Maven verification is requested but no pom.xml was found in the repository.", { code: "maven-no-pom" });
+    }
+    // When every Maven command already carries a resolvable -f, skip automatic
+    // scope target resolution (wide/empty scope must not block explicit targets).
+    const targets = allMavenCommandsHaveExplicitFile(input.commands)
+        ? targetsFromExplicitFiles({
+            repoRoot: input.repoRoot,
+            commands: input.commands,
+            graph,
+        })
+        : resolveMavenTargets({
+            graph,
+            scope: input.scope,
+        });
+    const planned = planMavenCommands({
+        repoRoot: input.repoRoot,
+        commands: input.commands,
+        targets,
+        graph,
+        scope: input.scope,
+    });
+    // Ensure planned commands keep original repoRoot cwd (explicit -f, not module cd).
+    const commands = planned.commands.map((command) => ({
+        ...command,
+        cwd: input.repoRoot,
+    }));
+    return {
+        commands,
+        plan: planned.plan,
+    };
+}

package/dist/verification/maven/plan-commands.js

@@ -0,0 +1,421 @@
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { MAVEN_CACHE_SCHEMA_VERSION, MAVEN_PLANNER_VERSION, MavenPlanError, } from "./types.js";
+const MAVEN_LAUNCHERS = new Set([
+    "mvn",
+    "mvnw",
+    "./mvnw",
+    ".\\mvnw",
+    ".\\mvnw.cmd",
+    "mvnw.cmd",
+    "mvnw.bat",
+    "./mvnw.cmd",
+    "./mvnw.bat",
+]);
+function toPosix(value) {
+    return value.replace(/\\/g, "/");
+}
+export function isMavenLauncherToken(token) {
+    const normalized = token.replace(/\\/g, "/");
+    if (MAVEN_LAUNCHERS.has(token) || MAVEN_LAUNCHERS.has(normalized)) {
+        return true;
+    }
+    const base = path.posix.basename(normalized).toLowerCase();
+    return base === "mvn" || base === "mvnw" || base === "mvnw.cmd" || base === "mvnw.bat";
+}
+const ENV_ASSIGNMENT_RE = /^[A-Za-z_][A-Za-z0-9_]*=.*$/;
+/** Detect shell metacharacters that make silent rewrite unsafe. */
+export function assertSafeMavenShellPayload(script) {
+    // Strip quoted segments so quoted pipes/redirects do not false-positive,
+    // but unquoted operators remain visible.
+    const withoutQuotes = script
+        .replace(/'[^']*'/g, " ")
+        .replace(/"[^"]*"/g, " ");
+    if (/[|;&><`]/.test(withoutQuotes) || /\n/.test(script)) {
+        throw new MavenPlanError(`Unsafe compound shell payload around Maven (pipeline/redirect/control): ${script}`, { code: "maven-unsafe-shell-payload" });
+    }
+    if (/\$\(|\$\{/.test(withoutQuotes)) {
+        throw new MavenPlanError(`Unsupported shell expansion around Maven: ${script}`, { code: "maven-unsafe-shell-payload" });
+    }
+}
+function splitEnvPrefix(tokens) {
+    const envPrefix = [];
+    let i = 0;
+    while (i < tokens.length && ENV_ASSIGNMENT_RE.test(tokens[i])) {
+        envPrefix.push(tokens[i]);
+        i += 1;
+    }
+    return { envPrefix, remaining: tokens.slice(i) };
+}
+function tokenizeShellLike(command) {
+    const tokens = [];
+    let current = "";
+    let quote = null;
+    for (let i = 0; i < command.length; i += 1) {
+        const ch = command[i];
+        if (quote) {
+            if (ch === quote) {
+                quote = null;
+            }
+            else {
+                current += ch;
+            }
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            quote = ch;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += ch;
+    }
+    if (current)
+        tokens.push(current);
+    return tokens;
+}
+function joinShellTokens(tokens) {
+    return tokens
+        .map((token) => {
+        if (token.length === 0)
+            return "''";
+        if (/^[A-Za-z0-9_./:=,@%+-]+$/.test(token))
+            return token;
+        return `'${token.replace(/'/g, `'\\''`)}'`;
+    })
+        .join(" ");
+}
+/**
+ * Detect Maven invocations in VerifyCommand args.
+ * Supports direct `mvn ...` and `bash -lc 'mvn ...'`.
+ */
+export function parseMavenInvocation(command) {
+    const args = command.args;
+    if (args.length === 0)
+        return null;
+    // bash -lc "mvn ..."
+    if (args.length >= 3 &&
+        /^(bash|sh|zsh)$/.test(args[0] ?? "") &&
+        (args[1] === "-lc" || args[1] === "-c")) {
+        const script = args[2] ?? "";
+        assertSafeMavenShellPayload(script);
+        const tokens = tokenizeShellLike(script);
+        const launcherIndex = tokens.findIndex(isMavenLauncherToken);
+        if (launcherIndex < 0)
+            return null;
+        const beforeLauncher = tokens.slice(0, launcherIndex);
+        const { envPrefix, remaining } = splitEnvPrefix(beforeLauncher);
+        if (remaining.length > 0) {
+            throw new MavenPlanError(`Unsupported shell prefix before Maven launcher: ${remaining.join(" ")}`, { code: "maven-unsafe-shell-payload", candidates: remaining });
+        }
+        return {
+            prefix: args.slice(0, 2),
+            envPrefix,
+            embeddedShell: true,
+            embedArgIndex: 2,
+            launcher: tokens[launcherIndex],
+            mavenArgs: tokens.slice(launcherIndex + 1),
+            kind: "bash-lc",
+        };
+    }
+    const launcherIndex = args.findIndex(isMavenLauncherToken);
+    if (launcherIndex < 0)
+        return null;
+    const beforeLauncher = args.slice(0, launcherIndex);
+    const { envPrefix, remaining } = splitEnvPrefix(beforeLauncher);
+    if (remaining.length > 0) {
+        // Non-env prefix tokens on direct argv are preserved as outer prefix
+        // (e.g. env wrappers). Only pure env assignments become envPrefix.
+        return {
+            prefix: beforeLauncher,
+            envPrefix: [],
+            embeddedShell: false,
+            launcher: args[launcherIndex],
+            mavenArgs: args.slice(launcherIndex + 1),
+            kind: "direct",
+        };
+    }
+    return {
+        prefix: [],
+        envPrefix,
+        embeddedShell: false,
+        launcher: args[launcherIndex],
+        mavenArgs: args.slice(launcherIndex + 1),
+        kind: "direct",
+    };
+}
+export function commandContainsMaven(command) {
+    return parseMavenInvocation(command) !== null;
+}
+function extractMavenFlags(mavenArgs) {
+    const rest = [];
+    let explicitFile;
+    let explicitPl;
+    let explicitAm = false;
+    for (let i = 0; i < mavenArgs.length; i += 1) {
+        const arg = mavenArgs[i];
+        if (arg === "-f" || arg === "--file") {
+            const value = mavenArgs[i + 1];
+            if (!value) {
+                throw new MavenPlanError(`Maven ${arg} is missing a path argument`, {
+                    code: "maven-flag-missing-value",
+                });
+            }
+            explicitFile = toPosix(value);
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("-f=") || arg.startsWith("--file=")) {
+            explicitFile = toPosix(arg.slice(arg.indexOf("=") + 1));
+            continue;
+        }
+        if (arg === "-pl" || arg === "--projects") {
+            const value = mavenArgs[i + 1];
+            if (!value) {
+                throw new MavenPlanError(`Maven ${arg} is missing a value`, {
+                    code: "maven-flag-missing-value",
+                });
+            }
+            explicitPl = value;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("-pl=") || arg.startsWith("--projects=")) {
+            explicitPl = arg.slice(arg.indexOf("=") + 1);
+            continue;
+        }
+        if (arg === "-am" || arg === "--also-make") {
+            explicitAm = true;
+            continue;
+        }
+        rest.push(arg);
+    }
+    return { explicitFile, explicitPl, explicitAm, rest };
+}
+/** Return explicit -f/--file value from maven args, if present. */
+export function extractExplicitMavenFile(mavenArgs) {
+    return extractMavenFlags(mavenArgs).explicitFile;
+}
+function assertInRepoFile(repoRoot, relPath, baseCwd) {
+    const raw = toPosix(relPath);
+    const absolute = path.isAbsolute(raw)
+        ? path.normalize(raw)
+        : path.resolve(baseCwd ?? repoRoot, raw);
+    const rel = path.relative(repoRoot, absolute);
+    if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) {
+        throw new MavenPlanError(`Maven -f path escapes repository root: ${relPath}`, { code: "maven-file-outside-repo", candidates: [relPath] });
+    }
+    if (!existsSync(absolute)) {
+        throw new MavenPlanError(`Maven -f path does not exist: ${toPosix(rel)}`, {
+            code: "maven-file-missing",
+            candidates: [toPosix(rel)],
+        });
+    }
+    return toPosix(rel);
+}
+function groupTargetsByBuild(targets) {
+    // reactorRoot -> modules; independent -> each own entry
+    const reactorGroups = new Map();
+    const independents = [];
+    for (const target of targets) {
+        if (target.reactorRootPomPath && target.moduleCoordinate) {
+            const list = reactorGroups.get(target.reactorRootPomPath) ?? [];
+            list.push(target.moduleCoordinate);
+            reactorGroups.set(target.reactorRootPomPath, list);
+        }
+        else if (target.reactorRootPomPath && !target.moduleCoordinate) {
+            // Selecting the reactor root itself
+            if (!reactorGroups.has(target.reactorRootPomPath)) {
+                reactorGroups.set(target.reactorRootPomPath, []);
+            }
+        }
+        else {
+            independents.push(target.pomPath);
+        }
+    }
+    const builds = [];
+    for (const [root, modules] of reactorGroups.entries()) {
+        const uniqueModules = [...new Set(modules)];
+        if (uniqueModules.length === 0) {
+            builds.push({ filePom: root, plModules: [], useAm: false });
+        }
+        else {
+            builds.push({
+                filePom: root,
+                plModules: uniqueModules,
+                useAm: true,
+            });
+        }
+    }
+    for (const pom of independents) {
+        builds.push({ filePom: pom, plModules: [], useAm: false });
+    }
+    // Stable output ordered by filePom path for determinism (not used as selection).
+    builds.sort((a, b) => a.filePom.localeCompare(b.filePom));
+    return builds;
+}
+function buildMavenArgList(input) {
+    const args = ["-f", input.filePom];
+    if (input.plModules.length > 0) {
+        args.push("-pl", input.plModules.join(","));
+    }
+    if (input.useAm) {
+        args.push("-am");
+    }
+    args.push(...input.rest);
+    return args;
+}
+function rebuildCommand(input) {
+    if (input.parsed.kind === "bash-lc" && input.parsed.embeddedShell) {
+        const script = joinShellTokens([
+            ...input.parsed.envPrefix,
+            input.parsed.launcher,
+            ...input.mavenArgs,
+        ]);
+        const args = [...input.original.args];
+        args[input.parsed.embedArgIndex ?? 2] = script;
+        return {
+            ...input.original,
+            args,
+        };
+    }
+    return {
+        ...input.original,
+        args: [
+            ...input.parsed.prefix,
+            ...input.parsed.envPrefix,
+            input.parsed.launcher,
+            ...input.mavenArgs,
+        ],
+    };
+}
+function digestCommand(command) {
+    return createHash("sha256")
+        .update(JSON.stringify({ label: command.label, args: command.args }))
+        .digest("hex");
+}
+function digestInputs(input) {
+    return createHash("sha256")
+        .update(JSON.stringify({
+        commands: input.commands.map((c) => ({
+            label: c.label,
+            args: c.args,
+        })),
+        targets: input.targets,
+        scope: {
+            allowedPaths: input.scope.allowedPaths,
+            writeSet: input.scope.writeSet ?? [],
+            sourcePaths: input.scope.sourcePaths ?? [],
+        },
+        plannerVersion: MAVEN_PLANNER_VERSION,
+    }))
+        .digest("hex");
+}
+/**
+ * Rewrite Maven VerifyCommands for the resolved targets.
+ * Non-Maven commands pass through unchanged.
+ */
+export function planMavenCommands(input) {
+    const builds = groupTargetsByBuild(input.targets);
+    const planned = [];
+    for (const command of input.commands) {
+        const parsed = parseMavenInvocation(command);
+        if (!parsed) {
+            planned.push(command);
+            continue;
+        }
+        const flags = extractMavenFlags(parsed.mavenArgs);
+        if (flags.explicitFile) {
+            const filePom = assertInRepoFile(input.repoRoot, flags.explicitFile, command.cwd ?? input.repoRoot);
+            // Explicit -f: respect user target; still forbid conflicting auto -pl when
+            // the file is an independent module pom without those modules.
+            if (flags.explicitPl || flags.explicitAm) {
+                const node = input.graph.nodes.find((n) => n.pomPath === filePom);
+                const isReactorRoot = input.graph.reactors.some((r) => r.rootPomPath === filePom);
+                if (!isReactorRoot) {
+                    throw new MavenPlanError(`Explicit -pl/-am conflicts with automatic planning for non-reactor POM -f ${filePom}`, {
+                        code: "maven-explicit-pl-conflict",
+                        candidates: [filePom, flags.explicitPl ?? "-am"],
+                    });
+                }
+                // When user already provided full -f/-pl/-am, keep rest + their flags.
+                const mavenArgs = buildMavenArgList({
+                    filePom,
+                    plModules: flags.explicitPl
+                        ? flags.explicitPl.split(",").map((s) => s.trim()).filter(Boolean)
+                        : [],
+                    useAm: flags.explicitAm,
+                    rest: flags.rest,
+                });
+                // Avoid double -f from buildMavenArgList — already correct.
+                planned.push(rebuildCommand({
+                    original: command,
+                    parsed,
+                    mavenArgs,
+                }));
+                continue;
+            }
+            // Explicit -f without -pl: keep that single target.
+            const mavenArgs = buildMavenArgList({
+                filePom,
+                plModules: [],
+                useAm: false,
+                rest: flags.rest,
+            });
+            planned.push(rebuildCommand({ original: command, parsed, mavenArgs }));
+            continue;
+        }
+        if (flags.explicitPl || flags.explicitAm) {
+            throw new MavenPlanError("Existing -pl/-am without a validated -f conflicts with automatic Maven planning; provide an explicit in-repo -f or remove -pl/-am.", {
+                code: "maven-explicit-pl-conflict",
+                candidates: [
+                    flags.explicitPl ?? "",
+                    flags.explicitAm ? "-am" : "",
+                ].filter(Boolean),
+            });
+        }
+        // Auto plan: expand one original command into one command per build group.
+        for (const build of builds) {
+            const mavenArgs = buildMavenArgList({
+                filePom: build.filePom,
+                plModules: build.plModules,
+                useAm: build.useAm,
+                rest: flags.rest,
+            });
+            planned.push(rebuildCommand({
+                original: {
+                    ...command,
+                    label: builds.length > 1
+                        ? `${command.label}:${build.filePom}`
+                        : command.label,
+                },
+                parsed,
+                mavenArgs,
+            }));
+        }
+    }
+    const plan = {
+        schemaVersion: MAVEN_CACHE_SCHEMA_VERSION,
+        plannerVersion: MAVEN_PLANNER_VERSION,
+        fingerprint: input.graph.fingerprint,
+        inputDigest: digestInputs({
+            commands: input.commands,
+            targets: input.targets,
+            scope: input.scope,
+        }),
+        targets: input.targets,
+        commandDigests: planned.map(digestCommand),
+        plannedCommands: planned.map((command) => ({
+            label: command.label,
+            args: command.args,
+        })),
+        workspaceManifest: input.graph.manifest,
+    };
+    return { commands: planned, plan };
+}