Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

refactor(javascript): reuse parsed semantic query contracts

morluto0b17cb621d4e
diff --git a/src/application/javascript/JavaScriptSemanticTraceService.ts b/src/application/javascript/JavaScriptSemanticTraceService.ts
index 0a51a9398..8aa831599 100644
--- a/src/application/javascript/JavaScriptSemanticTraceService.ts
+++ b/src/application/javascript/JavaScriptSemanticTraceService.ts
@@ -1,20 +1,16 @@
import { z } from "zod";
-import {
- AnalysisInputError,
- AnalysisProtocolError,
-} from "../../domain/analysisErrorCore.js";
+import { AnalysisInputError } from "../../domain/analysisErrorCore.js";
import type { AnalysisError } from "../../domain/analysisErrorBase.js";
import {
applicationGraphEvidenceInputError,
parseApplicationGraphEvidence,
} from "./JavaScriptApplicationEvidenceGraph.js";
import type { Evidence } from "../../domain/evidence.js";
-import { jsonValueSchema } from "../../domain/jsonValue.js";
-import { queryJavaScriptSemanticGraph } from "../../domain/javascript/javascriptSemanticQuery.js";
+import { queryJavaScriptSemanticGraphValidated } from "../../domain/javascript/javascriptSemanticQuery.js";
import {
- javaScriptSemanticTraceResultSchema,
traceJavaScriptSemanticsInputSchema,
+ type JavaScriptSemanticTraceResult,
} from "../../domain/javascript/javascriptSemanticTraceSchemas.js";
import { err, ok, type Result } from "../../domain/result.js";
import { createJavaScriptSemanticTraceEvidence } from "./JavaScriptApplicationWorkflowEvidence.js";
@@ -44,28 +40,26 @@ export const traceJavaScriptSemanticsEvidenceValidated = (
},
]),
);
- try {
- const query = queryJavaScriptSemanticGraph(
- source.semanticGraph,
- input.query,
- );
- const result = javaScriptSemanticTraceResultSchema.parse({
- ...query,
- source_evidence_id: source.evidence.evidence_id,
- evidence_links: [source.evidence.evidence_id],
- });
- return ok(
- createJavaScriptSemanticTraceEvidence(
- {
- application_evidence_id: source.evidence.evidence_id,
- query: jsonValueSchema.parse(input.query),
- },
- result,
- ),
- );
- } catch (cause: unknown) {
- return err(
- new AnalysisProtocolError("JavaScript semantic trace failed", { cause }),
- );
- }
+ const query = queryJavaScriptSemanticGraphValidated(
+ source.semanticGraph,
+ input.query,
+ );
+ const result: JavaScriptSemanticTraceResult = {
+ ...query,
+ source_evidence_id: source.evidence.evidence_id,
+ evidence_links: [source.evidence.evidence_id],
+ };
+ const { allowed_relations, ...queryParameters } = input.query;
+ return ok(
+ createJavaScriptSemanticTraceEvidence(
+ {
+ application_evidence_id: source.evidence.evidence_id,
+ query:
+ allowed_relations === undefined
+ ? queryParameters
+ : { ...queryParameters, allowed_relations },
+ },
+ result,
+ ),
+ );
};
diff --git a/src/domain/javascript/javascriptSemanticGraphTraversal.test.ts b/src/domain/javascript/javascriptSemanticGraphTraversal.test.ts
index ff5238d2b..785538f3c 100644
--- a/src/domain/javascript/javascriptSemanticGraphTraversal.test.ts
+++ b/src/domain/javascript/javascriptSemanticGraphTraversal.test.ts
@@ -4,6 +4,7 @@ import {
unknownSemanticGraphTestEvidence,
} from "../../../tests/support/javascriptSemanticGraphFixture.js";
import { expect, it } from "vitest";
+import { z } from "zod";
import {
JAVASCRIPT_SEMANTIC_NODE_KINDS,
@@ -24,7 +25,11 @@ import type {
JavaScriptSemanticGraphNode,
JavaScriptSemanticGraphRelation,
} from "./javascriptSemanticGraphSchemas.js";
-import { queryJavaScriptSemanticGraph } from "./javascriptSemanticQuery.js";
+import {
+ queryJavaScriptSemanticGraph,
+ queryJavaScriptSemanticGraphValidated,
+} from "./javascriptSemanticQuery.js";
+import { javaScriptSemanticQueryInputSchema } from "./javascriptSemanticQuerySchemas.js";
import type { JsonValue } from "../jsonValue.js";
const SHA = "a".repeat(64);
@@ -266,7 +271,10 @@ it("excludes candidate edges unless the caller explicitly opts in", () => {
direction: "forward-influence" as const,
allowed_relations: ["supplies-request-field" as const],
};
- const conservative = queryJavaScriptSemanticGraph(graph, input);
+ const conservative = queryJavaScriptSemanticGraphValidated(
+ graph,
+ javaScriptSemanticQueryInputSchema.parse(input),
+ );
const optedIn = queryJavaScriptSemanticGraph(graph, {
...input,
include_ambiguous_dynamic_edges: true,
@@ -281,6 +289,16 @@ it("excludes candidate edges unless the caller explicitly opts in", () => {
]);
});
+it("rejects an empty relation selection at the raw query boundary", () => {
+ expect(() =>
+ queryJavaScriptSemanticGraph(graphWithCandidateEdge(), {
+ seed: { kind: "literal", value: "TOKEN" },
+ direction: "forward-influence",
+ allowed_relations: [],
+ }),
+ ).toThrow(z.ZodError);
+});
+
it("retains every structural application node linked to one semantic node", () => {
const evidenceContexts = new JavaScriptSemanticEvidenceContextRegistry();
const original = node("module", "module", evidenceContexts);
diff --git a/src/domain/javascript/javascriptSemanticQuery.ts b/src/domain/javascript/javascriptSemanticQuery.ts
index 7b883521a..7db6689e1 100644
--- a/src/domain/javascript/javascriptSemanticQuery.ts
+++ b/src/domain/javascript/javascriptSemanticQuery.ts
@@ -38,8 +38,17 @@ interface QueryResult {
export const queryJavaScriptSemanticGraph = (
graph: JavaScriptSemanticGraph,
rawInput: unknown,
+): JavaScriptSemanticQueryResult =>
+ queryJavaScriptSemanticGraphValidated(
+ graph,
+ javaScriptSemanticQueryInputSchema.parse(rawInput),
+ );
+
+/** Run a query already parsed by its owning request boundary. */
+export const queryJavaScriptSemanticGraphValidated = (
+ graph: JavaScriptSemanticGraph,
+ input: JavaScriptSemanticQueryInput,
): JavaScriptSemanticQueryResult => {
- const input = javaScriptSemanticQueryInputSchema.parse(rawInput);
const queryId = queryIdentifier(graph, input);
const seeds = resolveSeeds(graph, input);
const nodes = new Map(graph.nodes.map((node) => [node.node_id, node]));
diff --git a/tests/boundary/javascriptSemanticTraceEvidence.test.ts b/tests/boundary/javascriptSemanticTraceEvidence.test.ts
index 94157c130..7cb46c65f 100644
--- a/tests/boundary/javascriptSemanticTraceEvidence.test.ts
+++ b/tests/boundary/javascriptSemanticTraceEvidence.test.ts
@@ -297,6 +297,22 @@ const assertSuccessfulTraceParity = async (
const cliResult = javaScriptSemanticTraceResultSchema.parse(
cliEvidence.normalized_result,
);
+ expect(cliEvidence.parameters.query).toMatchObject({
+ seed: query.seed,
+ direction: query.direction,
+ include_ambiguous_dynamic_edges: false,
+ expected: null,
+ });
+ if (query.allowed_relations === undefined)
+ expect(cliEvidence.parameters.query).not.toHaveProperty(
+ "allowed_relations",
+ );
+ else
+ expect(cliEvidence.parameters.query).toHaveProperty(
+ "allowed_relations",
+ query.allowed_relations,
+ );
+
assertTraceContextsResolve(cliResult);
const mcpResponse = await harness.client.callTool({
diff --git a/tests/process-global/derivedOperationFailures.test.ts b/tests/process-global/derivedOperationFailures.test.ts
index fb151326b..482013fda 100644
--- a/tests/process-global/derivedOperationFailures.test.ts
+++ b/tests/process-global/derivedOperationFailures.test.ts
@@ -36,6 +36,9 @@ import {
processEvidence,
} from "../../src/application/ReconstructionObligationLedger.fixture.js";
import { processCaptureSchema } from "../../src/domain/process/processCapture.js";
+import { JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE } from "../../src/contracts/javascript/javascriptRuntimeReconciliationExample.js";
+import { javascriptApplicationAnalysisResultSchema } from "../../src/domain/javascript/javascriptApplicationAnalysis.js";
+import { javaScriptSemanticQueryResultSchema } from "../../src/domain/javascript/javascriptSemanticQuerySchemas.js";
/** Unexpected implementation failures retain the SDK text surface, without a typed caller error. */
const expectUnexpectedToolFailure = (
@@ -468,3 +471,41 @@ describe("ledger generation failure ownership through the public SDK", () => {
},
);
});
+
+describe("semantic query output failures through the public SDK", () => {
+ afterEach(() => vi.restoreAllMocks());
+
+ it.each(unexpectedResultFailures)(
+ "preserves an unexpected %s from generated query validation",
+ async (_label, createFailure) => {
+ await withSdk(async ({ client, session }) => {
+ const application = JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE;
+ const analysis = javascriptApplicationAnalysisResultSchema.parse(
+ application.normalized_result,
+ );
+ const node = analysis.semantic_graph.nodes[0];
+ if (node === undefined)
+ throw new Error("Expected a semantic fixture node");
+ const failure = createFailure();
+ vi.spyOn(
+ javaScriptSemanticQueryResultSchema,
+ "parse",
+ ).mockImplementation(() => {
+ throw failure;
+ });
+ const response = await client.callTool({
+ name: "trace_javascript_semantics",
+ arguments: {
+ application,
+ query: {
+ seed: { kind: "semantic-node", node_id: node.node_id },
+ direction: "backward-provenance",
+ },
+ },
+ });
+ expectUnexpectedToolFailure(response, failure);
+ expect(session.exportEvidenceBundle().records).toEqual([]);
+ });
+ },
+ );
+});