rea-agents 3.1.0 → 3.2.0

package/dist/application/ApplicationWorkflowEvidenceResolver.js

@@ -1,188 +0,0 @@
-import { z } from "zod";
-import { compareApplicationVersionsRequestSchema, compareJavaScriptExportShapesRequestSchema, compareSourceToBundleRequestSchema, traceApplicationFeatureRequestSchema, traceJavaScriptSemanticsRequestSchema, } from "../contracts/applicationWorkflowInputContracts.js";
-import { AnalysisInputError } from "../domain/errors.js";
-import { projectInputIssues } from "../domain/inputIssueProjection.js";
-import { compareApplicationVersionsInputSchema } from "../domain/javascriptApplicationVersionComparisonSchemas.js";
-import { compareJavaScriptExportShapesInputSchema } from "../domain/javascriptExportShapeComparisonSchemas.js";
-import { traceApplicationFeatureInputSchema } from "../domain/javascriptFeatureTraceSchemas.js";
-import { traceJavaScriptSemanticsInputSchema } from "../domain/javascriptSemanticTraceSchemas.js";
-import { compareSourceToBundleInputSchema } from "../domain/sourceToBundleComparisonSchemas.js";
-import { err, ok } from "../domain/result.js";
-import { resolveEvidenceReferences, } from "./EvidenceReferenceResolver.js";
-const APPLICATION_GRAPH_IDENTITIES = [
-    {
-        operation: "analyze_javascript_application",
-        predicate: "rea.javascript-application-analysis/v1",
-    },
-    {
-        operation: "analyze_javascript_application",
-        predicate: "rea.javascript-application-analysis/v2",
-    },
-    {
-        operation: "reconcile_javascript_runtime",
-        predicate: "rea.javascript-runtime-reconciliation/v1",
-    },
-    {
-        operation: "project_managed_application_graph",
-        predicate: "rea.managed-application-graph/v1",
-    },
-];
-/** Parse and resolve one trace adapter request into its canonical domain input. */
-export const resolveTraceApplicationFeatureRequest = (input, lookup) => {
-    const parsed = traceApplicationFeatureRequestSchema.safeParse(input);
-    return parsed.success
-        ? resolveTraceApplicationFeatureRequestValidated(parsed.data, lookup)
-        : invalid("trace_application_feature", parsed.error, input);
-};
-/** Resolve a trace request already parsed by the caller-facing contract. */
-export const resolveTraceApplicationFeatureRequestValidated = (input, lookup) => {
-    const application = graphEvidence(input, lookup);
-    if (!application.ok)
-        return application;
-    const native = resolveEvidenceReferences(lookup, input.native_observation_evidence_ids);
-    if (!native.ok)
-        return native;
-    const raw = {
-        application: application.value,
-        native_observations: [...input.native_observations, ...native.value],
-        seed: input.seed,
-        direction: input.direction,
-        limits: input.limits,
-    };
-    const parsed = traceApplicationFeatureInputSchema.safeParse(raw);
-    return parsed.success
-        ? ok(parsed.data)
-        : invalid("trace_application_feature", parsed.error, raw);
-};
-/** Parse and resolve one semantic trace adapter request. */
-export const resolveTraceJavaScriptSemanticsRequest = (input, lookup) => {
-    const parsed = traceJavaScriptSemanticsRequestSchema.safeParse(input);
-    return parsed.success
-        ? resolveTraceJavaScriptSemanticsRequestValidated(parsed.data, lookup)
-        : invalid("trace_javascript_semantics", parsed.error, input);
-};
-/** Resolve a semantic trace request already parsed by its public contract. */
-export const resolveTraceJavaScriptSemanticsRequestValidated = (input, lookup) => {
-    const application = graphEvidence(input, lookup);
-    if (!application.ok)
-        return application;
-    const raw = { application: application.value, query: input.query };
-    const parsed = traceJavaScriptSemanticsInputSchema.safeParse(raw);
-    return parsed.success
-        ? ok(parsed.data)
-        : invalid("trace_javascript_semantics", parsed.error, raw);
-};
-/** Parse and resolve one comparison adapter request into canonical input. */
-export const resolveCompareApplicationVersionsRequest = (input, lookup) => {
-    const parsed = compareApplicationVersionsRequestSchema.safeParse(input);
-    return parsed.success
-        ? resolveCompareApplicationVersionsRequestValidated(parsed.data, lookup)
-        : invalid("compare_application_versions", parsed.error, input);
-};
-/** Resolve a comparison request parsed by the caller-facing contract. */
-export const resolveCompareApplicationVersionsRequestValidated = (input, lookup) => {
-    const left = graphEvidence("left" in input
-        ? { application: input.left }
-        : { application_evidence_id: input.left_evidence_id }, lookup);
-    if (!left.ok)
-        return left;
-    const right = graphEvidence("right" in input
-        ? { application: input.right }
-        : { application_evidence_id: input.right_evidence_id }, lookup);
-    if (!right.ok)
-        return right;
-    const leftNative = resolveEvidenceReferences(lookup, input.left_native_observation_evidence_ids);
-    if (!leftNative.ok)
-        return leftNative;
-    const rightNative = resolveEvidenceReferences(lookup, input.right_native_observation_evidence_ids);
-    if (!rightNative.ok)
-        return rightNative;
-    const raw = {
-        left: left.value,
-        right: right.value,
-        left_native_observations: [
-            ...input.left_native_observations,
-            ...leftNative.value,
-        ],
-        right_native_observations: [
-            ...input.right_native_observations,
-            ...rightNative.value,
-        ],
-        limits: input.limits,
-        ...(input.unknown_registry_approved === undefined
-            ? {}
-            : { unknown_registry_approved: input.unknown_registry_approved }),
-    };
-    const parsed = compareApplicationVersionsInputSchema.safeParse(raw);
-    return parsed.success
-        ? ok(parsed.data)
-        : invalid("compare_application_versions", parsed.error, raw);
-};
-/** Parse and resolve one historical-source comparison adapter request. */
-export const resolveCompareSourceToBundleRequest = (input, lookup) => {
-    const parsed = compareSourceToBundleRequestSchema.safeParse(input);
-    return parsed.success
-        ? resolveCompareSourceToBundleRequestValidated(parsed.data, lookup)
-        : invalid("compare_source_to_bundle", parsed.error, input);
-};
-/** Resolve a historical-source comparison request parsed by its public contract. */
-export const resolveCompareSourceToBundleRequestValidated = (input, lookup) => {
-    const application = graphEvidence(input, lookup);
-    if (!application.ok)
-        return application;
-    const raw = {
-        reference: input.reference,
-        application: application.value,
-        limits: input.limits,
-        ...(input.unknown_registry_approved === undefined
-            ? {}
-            : { unknown_registry_approved: input.unknown_registry_approved }),
-    };
-    const parsed = compareSourceToBundleInputSchema.safeParse(raw);
-    return parsed.success
-        ? ok(parsed.data)
-        : invalid("compare_source_to_bundle", parsed.error, raw);
-};
-/** Parse and resolve an export-shape adapter request into canonical input. */
-export const resolveCompareJavaScriptExportShapesRequest = (input, lookup) => {
-    const parsed = compareJavaScriptExportShapesRequestSchema.safeParse(input);
-    return parsed.success
-        ? resolveCompareJavaScriptExportShapesRequestValidated(parsed.data, lookup)
-        : invalid("compare_javascript_export_shapes", parsed.error, input);
-};
-/** Resolve an export-shape request already parsed by the adapter contract. */
-export const resolveCompareJavaScriptExportShapesRequestValidated = (input, lookup) => {
-    const left = graphEvidence("left" in input
-        ? { application: input.left }
-        : { application_evidence_id: input.left_evidence_id }, lookup);
-    if (!left.ok)
-        return left;
-    const right = graphEvidence("right" in input
-        ? { application: input.right }
-        : { application_evidence_id: input.right_evidence_id }, lookup);
-    if (!right.ok)
-        return right;
-    const raw = {
-        left: left.value,
-        right: right.value,
-        left_module_path: input.left_module_path,
-        left_export_name: input.left_export_name,
-        right_module_path: input.right_module_path,
-        right_export_name: input.right_export_name,
-        limits: input.limits,
-        ...(input.unknown_registry_approved === undefined
-            ? {}
-            : { unknown_registry_approved: input.unknown_registry_approved }),
-    };
-    const parsed = compareJavaScriptExportShapesInputSchema.safeParse(raw);
-    return parsed.success
-        ? ok(parsed.data)
-        : invalid("compare_javascript_export_shapes", parsed.error, raw);
-};
-const graphEvidence = (source, lookup) => {
-    if ("application" in source)
-        return ok(source.application);
-    const resolved = resolveEvidenceReferences(lookup, [source.application_evidence_id], APPLICATION_GRAPH_IDENTITIES);
-    return resolved.ok ? ok(resolved.value[0]) : resolved;
-};
-const invalid = (operation, cause, input) => err(new AnalysisInputError(operation, undefined, projectInputIssues(cause.issues, input)));

package/dist/application/BoundedJsonFiles.js

@@ -1,86 +0,0 @@
-import { lstat, readFile, realpath } from "node:fs/promises";
-import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
-import writeFileAtomic from "write-file-atomic";
-import { EvidenceFileError } from "../domain/errors.js";
-import { isJsonWithinLimits } from "../domain/jsonLimits.js";
-import { err, ok } from "../domain/result.js";
-import { canonicalizeConfiguredRoots } from "./ConfiguredRoots.js";
-/** Read bounded JSON data from a regular file beneath an approved root. */
-export const readBoundedJson = async (path, policy) => {
-    if (policy.roots.length === 0)
-        return err(new EvidenceFileError("read", "disabled"));
-    try {
-        const canonicalPath = await realpath(resolve(path));
-        if (!(await isApproved(canonicalPath, policy.roots)))
-            return err(new EvidenceFileError("read", "outside-root"));
-        const stats = await lstat(canonicalPath);
-        if (!stats.isFile())
-            return err(new EvidenceFileError("read", "not-file"));
-        if (stats.size > policy.maxBytes)
-            return err(new EvidenceFileError("read", "too-large"));
-        const encoded = await readFile(canonicalPath);
-        if (encoded.byteLength > policy.maxBytes)
-            return err(new EvidenceFileError("read", "too-large"));
-        let decoded;
-        try {
-            decoded = JSON.parse(encoded.toString("utf8"));
-        }
-        catch (cause) {
-            return err(new EvidenceFileError("read", "invalid-json", { cause }));
-        }
-        return isJsonWithinLimits(decoded, policy)
-            ? ok(decoded)
-            : err(new EvidenceFileError("read", "too-large"));
-    }
-    catch (cause) {
-        return err(new EvidenceFileError("read", "io", { cause }));
-    }
-};
-/** Atomically write bounded text to a regular file beneath an approved root. */
-export const writeBoundedText = async (encoded, path, overwrite, policy) => {
-    if (policy.roots.length === 0)
-        return err(new EvidenceFileError("write", "disabled"));
-    const bytes = Buffer.byteLength(encoded, "utf8");
-    if (bytes > policy.maxBytes)
-        return err(new EvidenceFileError("write", "too-large"));
-    try {
-        const requestedPath = resolve(path);
-        const canonicalParent = await realpath(dirname(requestedPath));
-        const destination = resolve(canonicalParent, basename(requestedPath));
-        if (!(await isApproved(destination, policy.roots)))
-            return err(new EvidenceFileError("write", "outside-root"));
-        const existing = await lstat(destination).catch((cause) => {
-            if (isFileNotFound(cause))
-                return undefined;
-            throw cause;
-        });
-        if (existing !== undefined) {
-            if (!overwrite)
-                return err(new EvidenceFileError("write", "exists"));
-            if (!existing.isFile() || existing.isSymbolicLink())
-                return err(new EvidenceFileError("write", "not-file"));
-        }
-        await writeFileAtomic(destination, encoded, {
-            encoding: "utf8",
-            mode: 0o600,
-            fsync: true,
-        });
-        return ok({ path: requestedPath, bytes });
-    }
-    catch (cause) {
-        return err(new EvidenceFileError("write", "io", { cause }));
-    }
-};
-const isApproved = async (candidate, roots) => {
-    for (const root of await canonicalizeConfiguredRoots(roots.map((configuredRoot) => resolve(configuredRoot)))) {
-        const relation = relative(root, candidate);
-        if (relation === "" ||
-            (!relation.startsWith("..") && !isAbsolute(relation)))
-            return true;
-    }
-    return false;
-};
-const isFileNotFound = (cause) => typeof cause === "object" &&
-    cause !== null &&
-    "code" in cause &&
-    cause.code === "ENOENT";

package/dist/application/CrossVersionInventory.js

@@ -1,129 +0,0 @@
-import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
-import { createEvidence } from "../domain/evidence.js";
-import { AnalysisCancelledError, ArtifactOperationError, } from "../domain/errors.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { err, ok } from "../domain/result.js";
-import { paginateArtifactInventory, } from "./ArtifactInventory.js";
-import { scanAuthorizedArtifactInventory } from "./AuthorizedArtifactInventory.js";
-import { ARTIFACT_GRAPH_PROVIDER } from "./InvestigationProviders.js";
-import { resolveArtifactIntegrityPolicy } from "./ArtifactInventory/policy.js";
-export const AUTOMATIC_RUN_LIMITATION = "Automatic cross-version runs compare shipped artifact structure only; they do not execute either version.";
-/** Start both independent version scans while preserving left/right identity. */
-export const scanVersionInventories = async (options, scanner = scanAuthorizedArtifactInventory) => {
-    const [left, right] = await Promise.all([
-        scanner(options.leftPath, options.inputRoots, options.limits, {
-            signal: options.signal,
-            integrity: options.integrity,
-        }),
-        scanner(options.rightPath, options.inputRoots, options.limits, {
-            signal: options.signal,
-            integrity: options.integrity,
-        }),
-    ]);
-    return { left, right };
-};
-/** Authorize and scan both inputs once under the same bounded traversal policy. */
-export const scanVersions = async (input, inputRoots, signal, integrityContinueEnabled = false) => {
-    try {
-        if (signal?.aborted === true)
-            return err(new AnalysisCancelledError("find_changed_behavior"));
-        const limits = artifactLimits(input.options);
-        const integrity = resolveArtifactIntegrityPolicy(input.integrity_policy === "fail"
-            ? { mode: "fail" }
-            : {
-                mode: input.integrity_policy,
-                maxMismatches: input.max_integrity_mismatches,
-            }, integrityContinueEnabled);
-        return ok(await scanVersionInventories({
-            leftPath: input.left_path,
-            rightPath: input.right_path,
-            inputRoots,
-            limits,
-            ...(signal === undefined ? {} : { signal }),
-            integrity,
-        }));
-    }
-    catch (cause) {
-        if (cause instanceof ArtifactReaderFailure)
-            return err(new ArtifactOperationError("inventory_artifact", cause.reason, cause.details));
-        return err(new ArtifactOperationError("inventory_artifact", "io"));
-    }
-};
-/** Project complete snapshots into bounded, comparable Evidence page sets. */
-export const createInventoryEvidencePages = (input, snapshots) => {
-    const left = inventoryPages(input.left_path, snapshots.left, input);
-    const right = inventoryPages(input.right_path, snapshots.right, input);
-    if (left.length > 100 || right.length > 100)
-        return err(new ArtifactOperationError("inventory_artifact", "limit"));
-    return ok({ left, right });
-};
-/** Reduce a snapshot to the content commitments used by run identity. */
-export const targetFor = (snapshot) => ({
-    root_sha256: snapshot.manifest.root_sha256,
-    graph_sha256: snapshot.manifest.graph_sha256,
-    manifest_id: snapshot.manifest.manifest_id,
-    format: snapshot.manifest.root_format,
-});
-/** Preserve scan and execution limitations in stable order. */
-export const runLimitations = (snapshots) => [
-    ...new Set([
-        ...snapshots.left.limitations.map((item) => `Left: ${item}`),
-        ...snapshots.right.limitations.map((item) => `Right: ${item}`),
-        AUTOMATIC_RUN_LIMITATION,
-    ]),
-].sort((left, right) => left.localeCompare(right));
-const inventoryPages = (path, snapshot, input) => {
-    const options = input.options;
-    const count = Math.max(1, Math.ceil(snapshot.nodes.length / options.page_size), Math.ceil(snapshot.occurrences.length / options.page_size), Math.ceil(snapshot.edges.length / options.page_size));
-    return Array.from({ length: count }, (_, index) => inventoryPage(path, snapshot, input, index * options.page_size));
-};
-const inventoryPage = (path, snapshot, input, offset) => {
-    const options = input.options;
-    const result = paginateArtifactInventory(snapshot, {
-        nodeOffset: offset,
-        nodeLimit: options.page_size,
-        occurrenceOffset: offset,
-        occurrenceLimit: options.page_size,
-        edgeOffset: offset,
-        edgeLimit: options.page_size,
-    });
-    return createEvidence({
-        path,
-        sha256: snapshot.manifest.root_sha256,
-        format: snapshot.manifest.root_format,
-    }, ARTIFACT_GRAPH_PROVIDER, {
-        operation: "inventory_artifact",
-        parameters: {
-            node_offset: offset,
-            node_limit: options.page_size,
-            occurrence_offset: offset,
-            occurrence_limit: options.page_size,
-            edge_offset: offset,
-            edge_limit: options.page_size,
-            max_entries: options.max_entries,
-            max_total_bytes: options.max_total_bytes,
-            max_entry_bytes: options.max_entry_bytes,
-            max_compression_ratio: options.max_compression_ratio,
-            max_depth: options.max_depth,
-            max_path_bytes: options.max_path_bytes,
-            integrity_policy: input.integrity_policy,
-            integrity_continue_approved: input.integrity_continue_approved,
-            max_integrity_mismatches: input.max_integrity_mismatches,
-        },
-        result: jsonValueSchema.parse(result),
-        rawResult: null,
-        limitations: result.limitations,
-        locations: result.occurrences.items.map(({ logical_path: logicalPath }) => ({
-            kind: "artifact-path",
-            path: logicalPath,
-        })),
-    });
-};
-const artifactLimits = (options) => ({
-    maxEntries: options.max_entries,
-    maxTotalBytes: options.max_total_bytes,
-    maxEntryBytes: options.max_entry_bytes,
-    maxCompressionRatio: options.max_compression_ratio,
-    maxDepth: options.max_depth,
-    maxPathBytes: options.max_path_bytes,
-});