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

package/dist/verification/maven/scope-resolve.js

@@ -0,0 +1,153 @@
+import path from "node:path";
+import { MavenPlanError, } from "./types.js";
+function toPosix(value) {
+    return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function stripGlobSuffix(pattern) {
+    let p = toPosix(pattern.trim());
+    // Normalize common task globs to directory prefixes.
+    p = p.replace(/\/\*\*$/, "");
+    p = p.replace(/\/\*$/, "");
+    p = p.replace(/\*\*$/, "");
+    p = p.replace(/\*$/, "");
+    p = p.replace(/\/+$/, "");
+    return p;
+}
+function isPathInside(parent, child) {
+    const p = toPosix(parent);
+    const c = toPosix(child);
+    if (p === "")
+        return true;
+    if (c === p)
+        return true;
+    return c.startsWith(`${p}/`);
+}
+/**
+ * A module is proven when at least one scope path is strictly inside that
+ * module directory tree (or equals the module dir). Sibling name similarity is
+ * never evidence. Broad "**" alone does not prove any module.
+ */
+function scopePathProvesModule(scopePath, moduleDir) {
+    const scope = stripGlobSuffix(scopePath);
+    if (scope === "" || scope === "**" || scope === ".") {
+        return false;
+    }
+    const mod = toPosix(moduleDir);
+    if (mod === "") {
+        // Root module: only proven by explicit root-ish paths, not by "**".
+        return scope === "" || scope === "." || scope === "pom.xml";
+    }
+    // Scope prefix falls inside module, or module falls inside a write/source path
+    // that is more specific than the module parent.
+    if (isPathInside(mod, scope))
+        return true;
+    // writeSet file under module
+    if (isPathInside(mod, scope))
+        return true;
+    return false;
+}
+function collectScopePaths(scope) {
+    const values = [
+        ...(scope.allowedPaths ?? []),
+        ...(scope.writeSet ?? []),
+        ...(scope.sourcePaths ?? []),
+    ];
+    return values.map(toPosix).filter((value) => value.length > 0);
+}
+function nodeDir(node) {
+    return toPosix(node.dir);
+}
+function targetForNode(graph, node) {
+    const reactorRoot = graph.reactorRootByPomPath[node.pomPath];
+    if (reactorRoot && reactorRoot !== node.pomPath) {
+        const reactor = graph.reactors.find((r) => r.rootPomPath === reactorRoot);
+        // Prefer reactor-root-relative module path for -pl (nested aggregators).
+        const coordinate = reactor?.modulePathByPomPath?.[node.pomPath] ??
+            reactor?.artifactIdByPomPath[node.pomPath] ??
+            node.artifactId;
+        return {
+            pomPath: node.pomPath,
+            artifactId: node.artifactId,
+            reactorRootPomPath: reactorRoot,
+            moduleCoordinate: coordinate,
+        };
+    }
+    // Root of a reactor selected itself, or independent POM.
+    return {
+        pomPath: node.pomPath,
+        artifactId: node.artifactId,
+        reactorRootPomPath: reactorRoot === node.pomPath ? reactorRoot : undefined,
+    };
+}
+/**
+ * Resolve uniquely proven Maven targets from task scope.
+ * Never uses depth, lexical order, or first-match as selection heuristics.
+ */
+export function resolveMavenTargets(input) {
+    const scopePaths = collectScopePaths(input.scope);
+    if (scopePaths.length === 0) {
+        throw new MavenPlanError("Maven verification requires task scope paths to prove a unique target; no allowedPaths/writeSet/sourcePaths were provided.", { code: "maven-scope-empty" });
+    }
+    const proven = [];
+    for (const node of input.graph.nodes) {
+        const dir = nodeDir(node);
+        const provenBy = scopePaths.some((scopePath) => scopePathProvesModule(scopePath, dir));
+        if (provenBy) {
+            proven.push(node);
+        }
+    }
+    if (proven.length === 0) {
+        const candidates = input.graph.nodes.map((n) => n.pomPath).sort();
+        throw new MavenPlanError(`Unable to uniquely prove a Maven target from task scope. Candidates: ${candidates.join(", ") || "(none)"}`, { code: "maven-scope-no-target", candidates });
+    }
+    // If multiple modules are proven, keep them only when each is independently
+    // proven by scope — never drop by sorting.
+    // Prefer more specific modules over their reactor ancestors when both match
+    // because a child path also matches the parent prefix.
+    const provenDirs = new Set(proven.map((n) => nodeDir(n)));
+    const filtered = proven.filter((node) => {
+        const dir = nodeDir(node);
+        // Drop ancestor modules when a descendant module is also proven.
+        for (const other of proven) {
+            if (other.pomPath === node.pomPath)
+                continue;
+            const otherDir = nodeDir(other);
+            if (otherDir !== dir && isPathInside(dir, otherDir)) {
+                return false;
+            }
+        }
+        return provenDirs.has(dir);
+    });
+    if (filtered.length === 0) {
+        const candidates = proven.map((n) => n.pomPath).sort();
+        throw new MavenPlanError(`Ambiguous Maven target after filtering ancestors. Candidates: ${candidates.join(", ")}`, { code: "maven-scope-ambiguous", candidates });
+    }
+    // Wide "**" only scope that still matched nothing specific is already handled.
+    // If still multiple independent modules and the only scope paths are broad
+    // globs that equally cover all of them without nested proof, fail.
+    const specificProof = scopePaths.some((scopePath) => {
+        const stripped = stripGlobSuffix(scopePath);
+        return stripped !== "" && stripped !== "**" && stripped !== ".";
+    });
+    if (!specificProof && filtered.length > 1) {
+        const candidates = filtered.map((n) => n.pomPath).sort();
+        throw new MavenPlanError(`Ambiguous Maven task scope matches multiple modules without unique proof. Candidates: ${candidates.join(", ")}`, { code: "maven-scope-ambiguous", candidates });
+    }
+    // Deduplicate by pom path without sorting-based selection.
+    const byPom = new Map();
+    for (const node of filtered) {
+        byPom.set(node.pomPath, targetForNode(input.graph, node));
+    }
+    const targets = [...byPom.values()];
+    if (targets.length === 0) {
+        throw new MavenPlanError("No Maven targets remained after scope resolution.", {
+            code: "maven-scope-no-target",
+        });
+    }
+    return targets;
+}
+export function moduleDirFromPomPath(pomPath) {
+    const posix = toPosix(pomPath);
+    const dir = path.posix.dirname(posix);
+    return dir === "." ? "" : dir;
+}

package/dist/verification/maven/stale.js

@@ -0,0 +1,130 @@
+import { createHash } from "node:crypto";
+import { isCachedGraphStillFresh } from "./cache.js";
+import { MAVEN_CACHE_SCHEMA_VERSION, MAVEN_PLANNER_VERSION, MavenPlanStaleError, } from "./types.js";
+import { buildMavenWorkspaceGraph } from "./workspace-graph.js";
+function digestCommand(command) {
+    return createHash("sha256")
+        .update(JSON.stringify({ label: command.label, args: command.args }))
+        .digest("hex");
+}
+function digestShellCommand(command) {
+    return createHash("sha256").update(command).digest("hex");
+}
+function commandsMatchPlan(plan, commands) {
+    if (plan.plannedCommands && plan.plannedCommands.length > 0) {
+        if (commands.length !== plan.plannedCommands.length)
+            return false;
+        for (let i = 0; i < commands.length; i += 1) {
+            const planned = plan.plannedCommands[i];
+            const actual = commands[i];
+            if (planned.label !== actual.label)
+                return false;
+            if (planned.args.length !== actual.args.length)
+                return false;
+            for (let j = 0; j < planned.args.length; j += 1) {
+                if (planned.args[j] !== actual.args[j])
+                    return false;
+            }
+        }
+        return true;
+    }
+    if (plan.commandDigests && plan.commandDigests.length > 0) {
+        if (commands.length !== plan.commandDigests.length)
+            return false;
+        for (let i = 0; i < commands.length; i += 1) {
+            if (digestCommand(commands[i]) !== plan.commandDigests[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return true;
+}
+function shellCommandsMatchPlan(plan, shellCommands) {
+    if (plan.shellCommandDigests && plan.shellCommandDigests.length > 0) {
+        if (shellCommands.length !== plan.shellCommandDigests.length)
+            return false;
+        for (let i = 0; i < shellCommands.length; i += 1) {
+            if (digestShellCommand(shellCommands[i]) !== plan.shellCommandDigests[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // No frozen shell digests — cannot prove drift; treat as matching.
+    return true;
+}
+function assertWorkspaceFresh(repoRoot, plan) {
+    // Prefer lightweight stat-only check against the frozen manifest.
+    if (plan.workspaceManifest) {
+        const probe = {
+            schemaVersion: plan.schemaVersion,
+            plannerVersion: plan.plannerVersion,
+            fingerprint: plan.fingerprint,
+            pomPaths: [],
+            wrapperPaths: [],
+            nodes: [],
+            reactors: [],
+            reactorRootByPomPath: {},
+            manifest: plan.workspaceManifest,
+        };
+        if (isCachedGraphStillFresh(repoRoot, probe)) {
+            return;
+        }
+        // Metadata changed: confirm via content fingerprint (targeted rebuild).
+        const graph = buildMavenWorkspaceGraph(repoRoot);
+        if (graph.fingerprint !== plan.fingerprint) {
+            throw new MavenPlanStaleError("verification-plan-stale: Maven POM/wrapper fingerprint drifted since DAG generation; regenerate/validate the DAG before running Maven");
+        }
+        // Directory metadata also changes for normal implementation work (for
+        // example, adding a Java source directory). The full static rebuild above
+        // proves the Maven inputs are unchanged, so the frozen plan remains valid.
+        return;
+    }
+    // Legacy plans without manifest: full static fingerprint re-check.
+    const graph = buildMavenWorkspaceGraph(repoRoot);
+    if (graph.fingerprint !== plan.fingerprint) {
+        throw new MavenPlanStaleError("verification-plan-stale: Maven POM/wrapper fingerprint drifted since DAG generation; regenerate/validate the DAG before running Maven");
+    }
+}
+/**
+ * Re-check frozen plan against workspace + optional execution command sequence.
+ * Lightweight path only stats paths recorded in the frozen workspaceManifest.
+ * Throws MavenPlanStaleError (code verification-plan-stale) on drift.
+ */
+export function assertMavenPlanFresh(repoRoot, plan, commands) {
+    if (plan.schemaVersion !== MAVEN_CACHE_SCHEMA_VERSION) {
+        throw new MavenPlanStaleError(`verification-plan-stale: plan schemaVersion ${plan.schemaVersion} != ${MAVEN_CACHE_SCHEMA_VERSION}; regenerate the DAG`);
+    }
+    if (plan.plannerVersion !== MAVEN_PLANNER_VERSION) {
+        throw new MavenPlanStaleError(`verification-plan-stale: plan plannerVersion ${plan.plannerVersion} != ${MAVEN_PLANNER_VERSION}; regenerate the DAG`);
+    }
+    if (commands) {
+        if (Array.isArray(commands)) {
+            const normalized = commands.map((command) => ({
+                label: command.label,
+                args: command.args,
+            }));
+            if (!commandsMatchPlan(plan, normalized)) {
+                throw new MavenPlanStaleError("verification-plan-stale: planned Maven command sequence/digests drifted since DAG generation; regenerate/validate the DAG before running Maven");
+            }
+        }
+        else {
+            if (commands.verifyCommands) {
+                const normalized = commands.verifyCommands.map((command) => ({
+                    label: command.label,
+                    args: command.args,
+                }));
+                if (!commandsMatchPlan(plan, normalized)) {
+                    throw new MavenPlanStaleError("verification-plan-stale: planned Maven command sequence/digests drifted since DAG generation; regenerate/validate the DAG before running Maven");
+                }
+            }
+            if (commands.shellCommands) {
+                if (!shellCommandsMatchPlan(plan, commands.shellCommands)) {
+                    throw new MavenPlanStaleError("verification-plan-stale: shell.commands sequence drifted from frozen Maven verification plan; regenerate/validate the DAG before running Maven");
+                }
+            }
+        }
+    }
+    assertWorkspaceFresh(repoRoot, plan);
+}

package/dist/verification/maven/types.js

@@ -0,0 +1,23 @@
+/** Bump when planner decision rules change (invalidates cache). */
+export const MAVEN_PLANNER_VERSION = "1.1.1";
+/** Bump when on-disk cache JSON shape changes. */
+export const MAVEN_CACHE_SCHEMA_VERSION = 2;
+export class MavenPlanError extends Error {
+    code;
+    candidates;
+    constructor(message, options) {
+        super(message, options?.cause ? { cause: options.cause } : undefined);
+        this.name = "MavenPlanError";
+        this.code = options?.code ?? "maven-plan-error";
+        this.candidates = options?.candidates;
+    }
+}
+export class MavenPlanStaleError extends MavenPlanError {
+    constructor(message, options) {
+        super(message, {
+            code: "verification-plan-stale",
+            cause: options?.cause,
+        });
+        this.name = "MavenPlanStaleError";
+    }
+}

package/dist/verification/maven/workspace-graph.js

@@ -0,0 +1,322 @@
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, readdirSync, readFileSync, statSync, } from "node:fs";
+import path from "node:path";
+import { readStaticPomFile, repoRelativePosix } from "./pom-static.js";
+import { MAVEN_CACHE_SCHEMA_VERSION, MAVEN_PLANNER_VERSION, MavenPlanError, } from "./types.js";
+const SKIP_DIR_NAMES = new Set([
+    ".git",
+    ".harness",
+    "node_modules",
+    "target",
+    "dist",
+    "build",
+    ".idea",
+    ".vscode",
+    "coverage",
+    ".turbo",
+    ".next",
+]);
+const WRAPPER_BASENAMES = new Set([
+    "mvnw",
+    "mvnw.cmd",
+    "mvnw.bat",
+    "maven-wrapper.properties",
+    "maven-wrapper.jar",
+]);
+function toPosix(value) {
+    return value.replace(/\\/g, "/");
+}
+/**
+ * Walk repository files using Dirent and do not follow directory/file symlinks.
+ * Captures every successfully scanned directory in the same pass so cache-hit
+ * checks can detect a POM or wrapper added below a previously empty directory.
+ */
+function walkFiles(root) {
+    const files = [];
+    const directories = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        let entries;
+        try {
+            entries = readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        directories.push({
+            path: current,
+            entryNames: entries
+                .filter((entry) => !entry.isSymbolicLink() && !SKIP_DIR_NAMES.has(entry.name))
+                .map((entry) => entry.name)
+                .sort(),
+        });
+        for (const entry of entries) {
+            if (SKIP_DIR_NAMES.has(entry.name))
+                continue;
+            // Never follow symlinks (dir or file).
+            if (entry.isSymbolicLink())
+                continue;
+            const absolute = path.join(current, entry.name);
+            // Double-check with lstat in case platform Dirent is incomplete.
+            try {
+                const lst = lstatSync(absolute);
+                if (lst.isSymbolicLink())
+                    continue;
+                if (lst.isDirectory()) {
+                    stack.push(absolute);
+                }
+                else if (lst.isFile()) {
+                    files.push(absolute);
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return { files, directories };
+}
+function isPomFile(filePath) {
+    return path.basename(filePath).toLowerCase() === "pom.xml";
+}
+function isWrapperFile(filePath) {
+    const base = path.basename(filePath).toLowerCase();
+    if (WRAPPER_BASENAMES.has(base))
+        return true;
+    const posix = toPosix(filePath).toLowerCase();
+    return posix.endsWith("/.mvn/wrapper/maven-wrapper.properties");
+}
+function contentSha(absolutePath) {
+    const buf = readFileSync(absolutePath);
+    return createHash("sha256").update(buf).digest("hex");
+}
+function resolveModulePomPath(repoRoot, parentDir, moduleDecl) {
+    const absDir = path.resolve(repoRoot, parentDir, moduleDecl);
+    const candidates = [
+        path.join(absDir, "pom.xml"),
+        // moduleDecl may already point at a pom file
+        absDir.endsWith("pom.xml") ? absDir : null,
+    ].filter((value) => Boolean(value));
+    for (const candidate of candidates) {
+        try {
+            const lst = lstatSync(candidate);
+            if (lst.isSymbolicLink())
+                continue;
+            if (lst.isFile()) {
+                return repoRelativePosix(repoRoot, candidate);
+            }
+        }
+        catch {
+            // try next
+        }
+    }
+    return null;
+}
+/**
+ * Build reactor graphs with transitive nested aggregator membership.
+ * -pl coordinates are module paths relative to the reactor root, not bare artifactIds.
+ */
+function buildReactors(repoRoot, nodes) {
+    const byPom = new Map(nodes.map((node) => [node.pomPath, node]));
+    const reactors = [];
+    // Prefer outermost reactor root for each member when nested.
+    const reactorRootByPomPath = {};
+    const rootDepth = new Map();
+    for (const node of nodes) {
+        if (node.modules.length === 0)
+            continue;
+        const modulePomByArtifactId = {};
+        const artifactIdByPomPath = {
+            [node.pomPath]: node.artifactId,
+        };
+        const modulePathByPomPath = {};
+        const pomPaths = new Set([node.pomPath]);
+        const queue = node.modules.map((moduleDecl) => ({
+            parentNode: node,
+            moduleDecl,
+            pathFromRoot: toPosix(moduleDecl).replace(/\/+$/, ""),
+            stack: [node.pomPath],
+        }));
+        const seenEdges = new Set();
+        while (queue.length > 0) {
+            const item = queue.shift();
+            const edgeKey = `${item.parentNode.pomPath}=>${item.moduleDecl}`;
+            if (seenEdges.has(edgeKey))
+                continue;
+            seenEdges.add(edgeKey);
+            if (item.stack.includes(item.parentNode.pomPath) && item.stack.length > 1) {
+                // stack already contains parent from deeper cycle checks below
+            }
+            const modulePom = resolveModulePomPath(repoRoot, item.parentNode.dir, item.moduleDecl);
+            if (!modulePom) {
+                throw new MavenPlanError(`Reactor module path cannot be resolved statically from ${item.parentNode.pomPath}: ${item.moduleDecl}`, {
+                    code: "maven-reactor-module-missing",
+                    candidates: [item.parentNode.pomPath, item.moduleDecl],
+                });
+            }
+            if (item.stack.includes(modulePom)) {
+                throw new MavenPlanError(`Cyclic reactor module relationship detected involving ${modulePom}`, {
+                    code: "maven-reactor-cycle",
+                    candidates: [...item.stack, modulePom],
+                });
+            }
+            const moduleNode = byPom.get(modulePom);
+            if (!moduleNode) {
+                throw new MavenPlanError(`Reactor module POM was not discovered: ${modulePom}`, { code: "maven-reactor-module-missing", candidates: [modulePom] });
+            }
+            // module path relative to reactor root (for -pl)
+            const modulePath = item.pathFromRoot
+                .replace(/\/pom\.xml$/i, "")
+                .replace(/^\.\//, "");
+            if (modulePomByArtifactId[moduleNode.artifactId] &&
+                modulePomByArtifactId[moduleNode.artifactId] !== modulePom) {
+                throw new MavenPlanError(`Duplicate artifactId '${moduleNode.artifactId}' in reactor ${node.pomPath}`, {
+                    code: "maven-reactor-duplicate-artifactId",
+                    candidates: [
+                        modulePomByArtifactId[moduleNode.artifactId],
+                        modulePom,
+                    ],
+                });
+            }
+            modulePomByArtifactId[moduleNode.artifactId] = modulePom;
+            artifactIdByPomPath[modulePom] = moduleNode.artifactId;
+            modulePathByPomPath[modulePom] = modulePath;
+            pomPaths.add(modulePom);
+            // Recurse into nested aggregator modules.
+            for (const childDecl of moduleNode.modules) {
+                const childPath = toPosix(path.posix.join(modulePath, toPosix(childDecl))).replace(/\\/g, "/");
+                queue.push({
+                    parentNode: moduleNode,
+                    moduleDecl: childDecl,
+                    pathFromRoot: childPath,
+                    stack: [...item.stack, modulePom],
+                });
+            }
+        }
+        const reactor = {
+            rootPomPath: node.pomPath,
+            modulePomByArtifactId,
+            artifactIdByPomPath,
+            // Store module path coordinates for -pl via artifactIdByPomPath values when
+            // consumers need paths: expose via modulePathByPomPath on the side channel.
+            pomPaths: [...pomPaths].sort(),
+            // Extended field kept optional for schema compatibility via cast below.
+            ...(Object.keys(modulePathByPomPath).length > 0
+                ? { modulePathByPomPath }
+                : {}),
+        };
+        // Attach modulePathByPomPath for planners (types extended separately).
+        reactor
+            .modulePathByPomPath = modulePathByPomPath;
+        reactors.push(reactor);
+        // Register membership: prefer outermost (shallower path depth) reactor root.
+        const depth = node.pomPath.split("/").length;
+        for (const member of pomPaths) {
+            const existing = reactorRootByPomPath[member];
+            if (!existing) {
+                reactorRootByPomPath[member] = node.pomPath;
+                rootDepth.set(member, depth);
+                continue;
+            }
+            const existingDepth = rootDepth.get(member) ?? Number.MAX_SAFE_INTEGER;
+            if (depth < existingDepth) {
+                reactorRootByPomPath[member] = node.pomPath;
+                rootDepth.set(member, depth);
+            }
+        }
+    }
+    return { reactors, reactorRootByPomPath };
+}
+/**
+ * Statically discover all POMs and wrappers under the repository.
+ * Never executes Maven goals. Does not follow symlinks.
+ */
+/** Test/probe counter: increments only on full walk+parse builds. */
+let fullBuildCount = 0;
+export function getMavenFullBuildCount() {
+    return fullBuildCount;
+}
+export function resetMavenFullBuildCount() {
+    fullBuildCount = 0;
+}
+export function buildMavenWorkspaceGraph(repoRoot) {
+    if (!existsSync(repoRoot)) {
+        throw new MavenPlanError(`Repository root does not exist: ${repoRoot}`, {
+            code: "maven-repo-missing",
+        });
+    }
+    fullBuildCount += 1;
+    const walk = walkFiles(repoRoot);
+    const allFiles = walk.files;
+    const pomAbs = allFiles.filter(isPomFile).sort();
+    const wrapperAbs = allFiles.filter(isWrapperFile).sort();
+    const nodes = [];
+    const fingerprintParts = [];
+    const fileMeta = [];
+    const dirMeta = walk.directories.map((directory) => ({
+        path: directory.path === repoRoot
+            ? ""
+            : repoRelativePosix(repoRoot, directory.path),
+        entryNames: directory.entryNames,
+    }));
+    for (const abs of pomAbs) {
+        const pomPath = repoRelativePosix(repoRoot, abs);
+        const fields = readStaticPomFile(abs);
+        const st = statSync(abs);
+        const dir = toPosix(path.posix.dirname(pomPath));
+        nodes.push({
+            pomPath,
+            dir: dir === "." ? "" : dir,
+            artifactId: fields.artifactId,
+            groupId: fields.groupId,
+            packaging: fields.packaging,
+            modules: fields.modules,
+            parentRelativePath: fields.parentRelativePath,
+        });
+        const sha = contentSha(abs);
+        fingerprintParts.push(`pom:${pomPath}:${sha}`);
+        fileMeta.push({
+            path: pomPath,
+            size: st.size,
+            mtimeMs: st.mtimeMs,
+        });
+    }
+    const wrapperPaths = [];
+    for (const abs of wrapperAbs) {
+        const rel = repoRelativePosix(repoRoot, abs);
+        wrapperPaths.push(rel);
+        const st = statSync(abs);
+        const sha = contentSha(abs);
+        fingerprintParts.push(`wrapper:${rel}:${sha}`);
+        fileMeta.push({
+            path: rel,
+            size: st.size,
+            mtimeMs: st.mtimeMs,
+        });
+    }
+    fingerprintParts.sort();
+    const fingerprint = createHash("sha256")
+        .update(fingerprintParts.join("\n"))
+        .update(`\nplanner:${MAVEN_PLANNER_VERSION}`)
+        .update(`\nschema:${MAVEN_CACHE_SCHEMA_VERSION}`)
+        .digest("hex");
+    const { reactors, reactorRootByPomPath } = buildReactors(repoRoot, nodes);
+    return {
+        schemaVersion: MAVEN_CACHE_SCHEMA_VERSION,
+        plannerVersion: MAVEN_PLANNER_VERSION,
+        fingerprint,
+        pomPaths: nodes.map((n) => n.pomPath).sort(),
+        wrapperPaths: wrapperPaths.sort(),
+        nodes,
+        reactors,
+        reactorRootByPomPath,
+        manifest: {
+            files: fileMeta.sort((a, b) => a.path.localeCompare(b.path)),
+            directories: dirMeta.sort((a, b) => a.path.localeCompare(b.path)),
+        },
+    };
+}
+export function computeWorkspaceFingerprint(repoRoot) {
+    return buildMavenWorkspaceGraph(repoRoot).fingerprint;
+}