feat(artifacts): inspect Maven POM and Gradle module metadata

Inspect local Maven/Gradle metadata as Evidence with bounded report/XML admission, preserved caller choices and owned cleanup.

Refs #8828; broader comparison and resolution work remains outside this change.

Assisted-by: Suika (gensokyo-skills:suika-scatter-gather-planning)
Co-authored-by: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com>
This commit is contained in:
Matt Van Hornandgensokyo-dev authored and GitHub committed 2026-11-17 14:40:38 +00:00
1 parent 5ccb7c59c8
commit 05be423acb
50 files changed
+3872 -24

No files matched your search

@@ -0,0 +1,119 @@
import { createHash } from "node:crypto";
import { expect, it } from "vitest";
import {
AnalysisOutputError,
AnalysisCancelledError,
} from "../../domain/analysisErrorCore.js";
import { parseEvidence } from "../../domain/evidence.js";
import { ok } from "../../domain/result.js";
import type { MavenGradleMetadata } from "../../domain/java/mavenGradleMetadata.js";
import { parseMavenGradleMetadata } from "../../java/MavenGradleMetadataParser.js";
import { mavenPomFixture } from "../../java/MavenGradleMetadata.fixture.js";
import { MavenGradleMetadataService } from "./MavenGradleMetadataService.js";
const reportFor = (): MavenGradleMetadata => {
const bytes = Buffer.from(mavenPomFixture, "utf8");
return parseMavenGradleMetadata(bytes, {
path: "/artifacts/pom.xml",
sha256: createHash("sha256").update(bytes).digest("hex"),
bytes: bytes.length,
});
};
const serviceFor = (report: MavenGradleMetadata) =>
new MavenGradleMetadataService({
identity: {
id: "metadata-fixture",
name: "Metadata fixture",
version: "1",
},
close: async () => {},
inspect: async () => ok(report),
});
const inspect = (report: MavenGradleMetadata, path = report.artifact.path) =>
serviceFor(report).inspect({ path });
it("retains completed Evidence and selected parameters on late cancellation", async () => {
const report = reportFor();
const controller = new AbortController();
const reason = { source: "metadata completion" };
const provider = serviceFor(report).provider;
const service = new MavenGradleMetadataService({
...provider,
inspect: async () => {
controller.abort(reason);
return ok(report);
},
});
const result = await service.inspect(
{ path: report.artifact.path },
{ signal: controller.signal },
);
if (result.ok) throw new Error("Expected late cancellation");
expect(result.error).toBeInstanceOf(AnalysisCancelledError);
expect(result.error.cause).toBe(reason);
expect(result.error.partialObservation).toMatchObject({
operation: "inspect_maven_gradle_metadata",
parameters: { path: report.artifact.path },
normalized_result: report,
});
});
it("rejects complete coverage claiming the wrong examined byte count", async () => {
const report = reportFor();
const result = await inspect({
...report,
coverage: { ...report.coverage, examined_bytes: report.artifact.bytes + 8 },
});
expect(result.ok).toBe(false);
if (!result.ok) expect(result.error).toBeInstanceOf(AnalysisOutputError);
});
it("rejects a report whose artifact identity disagrees with the caller path", async () => {
const report = reportFor();
const result = await inspect(
{
...report,
artifact: { ...report.artifact, path: "/other/pom.xml" },
},
report.artifact.path,
);
expect(result.ok).toBe(false);
if (!result.ok) expect(result.error).toBeInstanceOf(AnalysisOutputError);
});
it("retains observed coordinates and unresolved property references", async () => {
const report = reportFor();
const result = await inspect(report);
if (!result.ok) throw result.error;
expect(parseEvidence(result.value).normalized_result).toMatchObject({
format: "maven-pom",
coordinates: {
artifact_id: "demo",
version: "${revision}",
},
coverage: { status: "complete", examined_bytes: report.artifact.bytes },
});
expect(result.value.confidence).toBe("observed");
});
it("keeps an omitted read budget out of Evidence parameters", async () => {
const report = reportFor();
const omitted = await inspect(report);
if (!omitted.ok) throw omitted.error;
expect(parseEvidence(omitted.value).parameters).toStrictEqual({
path: report.artifact.path,
});
const explicit = await serviceFor(report).inspect({
path: report.artifact.path,
max_file_bytes: 1024 * 1024,
});
if (!explicit.ok) throw explicit.error;
expect(parseEvidence(explicit.value).parameters).toStrictEqual({
path: report.artifact.path,
max_file_bytes: 1024 * 1024,
});
});
@@ -0,0 +1,93 @@
import type { ExecutionOptions } from "../../ports/AnalysisProvider.js";
import type { MavenGradleMetadataPort } from "../../ports/java/MavenGradleMetadataPort.js";
import type { AnalysisError } from "../../domain/analysisErrorBase.js";
import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
import { createEvidence, type Evidence } from "../../domain/evidence.js";
import {
inspectMavenGradleMetadataInputSchema,
mavenGradleMetadataSchema,
type MavenGradleMetadata,
} from "../../domain/java/mavenGradleMetadata.js";
import { err, type Result } from "../../domain/result.js";
import { completeProviderEvidence } from "../ProviderOperationExecution.js";
import {
callerAnalysisParameters,
parseAnalysisInput,
} from "../AnalysisInput.js";
const OPERATION = "inspect_maven_gradle_metadata";
/** Shared caller validation, output parsing and Evidence provenance for CLI/MCP. */
export class MavenGradleMetadataService {
constructor(readonly provider: MavenGradleMetadataPort) {}
close(): Promise<void> {
return this.provider.close();
}
async inspect(
rawInput: unknown,
options?: ExecutionOptions,
): Promise<Result<Evidence, AnalysisError>> {
const selectedParameters = callerAnalysisParameters(rawInput);
const input = parseAnalysisInput(
OPERATION,
rawInput,
inspectMavenGradleMetadataInputSchema,
options?.signal,
);
if (!input.ok) return input;
const result = await this.provider.inspect(input.value, options);
if (!result.ok) return result;
const report = mavenGradleMetadataSchema.safeParse(result.value);
if (
!report.success ||
report.data.artifact.path !== input.value.path ||
!validReport(report.data, input.value)
)
return err(
new AnalysisOutputError(
OPERATION,
"Maven/Gradle metadata provider returned malformed output or changed artifact identity.",
),
);
const value = report.data;
return completeProviderEvidence(
createEvidence(
{
path: value.artifact.path,
format: "file",
sha256: value.artifact.sha256,
},
this.provider.identity,
{
operation: OPERATION,
parameters: selectedParameters(input.value),
result: value,
confidence: "observed",
limitations: value.limitations,
locations: [
{ kind: "artifact-path" as const, path: value.artifact.path },
{
kind: "file-offset-range" as const,
start: 0,
end: value.artifact.bytes,
},
],
},
),
options?.signal,
);
}
}
const validReport = (
report: MavenGradleMetadata,
input: { max_file_bytes: number },
): boolean => {
if (report.artifact.bytes > input.max_file_bytes) return false;
if (report.coverage.examined_bytes !== report.artifact.bytes) return false;
if (report.format === "maven-pom" && report.gradle !== null) return false;
if (report.format === "gradle-module" && report.parent !== null) return false;
return true;
};