rea-agents 6.2.0 → 6.4.0

package/dist/domain/javascript/javascriptSemanticPromises.js

@@ -1,8 +1,8 @@
 import * as t from "@babel/types";
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
-import { semanticStaticPropertyName } from "./javascriptAstValues.js";
+import { semanticStaticPropertyName, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 import { assignedSemanticResultBindings, dataEffectMemberCallee, scalarAssignedResultBinding, } from "./javascriptSemanticDataEffectHelpers.js";
@@ -23,7 +23,7 @@ export const collectJavaScriptSemanticPromises = (program, state, callables) =>
             location: range(candidate.node),
             ownerCallableId: candidate.ownerCallableId,
             ...ownership,
-            sourcePromiseIds: [...new Set(sources.promiseIds)].sort(compareCodePoints),
+            sourcePromiseIds: [...new Set(sources.promiseIds)].sort(compareUnicodeCodePoints),
             sourceResolution: sources.status,
         };
     });
@@ -85,7 +85,8 @@ const promiseCandidateDetails = (node, state) => {
 };
 const isUnshadowedGlobalPromise = (node, state) => resolveSemanticBindingState(state, node, "Promise") === undefined &&
     !semanticResolutionBlocked(state, node, "Promise");
-const isPromiseProducer = (node, state) => promiseCandidateDetails(unwrapExpression(node), state) !== null;
+const isPromiseProducer = (node, state) => promiseCandidateDetails(unwrapJavaScriptExpression(node).node, state) !==
+    null;
 const semanticPromiseId = (kind, node) => `promise:${kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`;
 const promiseOwnership = (candidate, candidateByNode, state, returnSiteIdFor) => {
     if (candidate.kind === "awaited-expression")
@@ -111,7 +112,7 @@ const promiseOwnership = (candidate, candidateByNode, state, returnSiteIdFor) =>
 const ownershipAtAncestor = (ancestor, context) => {
     const { candidate, candidateByNode, state, returnSiteIdFor } = context;
     if (t.isAwaitExpression(ancestor))
-        return unwrapExpression(ancestor.argument) === candidate.node
+        return unwrapJavaScriptExpression(ancestor.argument).node === candidate.node
             ? emptyOwnership("awaited")
             : "boundary";
     const outer = candidateByNode.get(ancestor);
@@ -132,19 +133,20 @@ const ownershipAtAncestor = (ancestor, context) => {
         };
     if (t.isReturnStatement(ancestor)) {
         if (ancestor.argument == null ||
-            unwrapExpression(ancestor.argument) !== candidate.node)
+            unwrapJavaScriptExpression(ancestor.argument).node !== candidate.node)
             return "boundary";
         return returnedPromiseOwnership(candidate.ownerCallableId, range(ancestor), returnSiteIdFor);
     }
     if (t.isExpressionStatement(ancestor))
-        return unwrapExpression(ancestor.expression) === candidate.node
+        return unwrapJavaScriptExpression(ancestor.expression).node ===
+            candidate.node
             ? emptyOwnership("detached")
             : "boundary";
     const callableId = semanticCallableIdForNode(ancestor);
     if (callableId === null || callableId !== candidate.ownerCallableId)
         return null;
     return t.isArrowFunctionExpression(ancestor) &&
-        unwrapExpression(ancestor.body) === candidate.node
+        unwrapJavaScriptExpression(ancestor.body).node === candidate.node
         ? returnedPromiseOwnership(candidate.ownerCallableId, range(ancestor.body), returnSiteIdFor)
         : "boundary";
 };
@@ -160,7 +162,7 @@ const assignedPromiseBinding = (ancestor, candidate, state) => {
         : ancestor.right;
     if (source == null)
         return undefined;
-    if (unwrapExpression(source) !== candidate)
+    if (unwrapJavaScriptExpression(source).node !== candidate)
         return undefined;
     return scalarAssignedResultBinding(assignedSemanticResultBindings(source, [ancestor], state));
 };
@@ -173,7 +175,8 @@ const outerConsumesCandidate = (outer, candidate) => {
     if (outer.kind === "chain" &&
         (t.isCallExpression(outer.node) || t.isOptionalCallExpression(outer.node))) {
         const member = dataEffectMemberCallee(outer.node);
-        return (member !== null && unwrapExpression(member.object) === candidate.node);
+        return (member !== null &&
+            unwrapJavaScriptExpression(member.object).node === candidate.node);
     }
     if (outer.kind === "aggregate" &&
         (t.isCallExpression(outer.node) || t.isOptionalCallExpression(outer.node))) {
@@ -181,7 +184,7 @@ const outerConsumesCandidate = (outer, candidate) => {
         return (t.isArrayExpression(input) &&
             input.elements.some((element) => element !== null &&
                 !t.isSpreadElement(element) &&
-                unwrapExpression(element) === candidate.node));
+                unwrapJavaScriptExpression(element).node === candidate.node));
     }
     return false;
 };
@@ -266,7 +269,7 @@ const aggregateSources = (candidate, candidateByNode, state) => {
 };
 const resolvePromiseExpression = (rawNode, context) => {
     const { current, candidateByNode, state, seenBindings } = context;
-    const node = unwrapExpression(rawNode);
+    const node = unwrapJavaScriptExpression(rawNode).node;
     const direct = candidateByNode.get(node);
     if (direct !== undefined && direct.promiseId !== current.promiseId)
         return { promiseIds: [direct.promiseId], status: "complete" };
@@ -294,15 +297,6 @@ const promiseResolutionContext = (current, candidateByNode, state) => ({
     state,
     seenBindings: new Set(),
 });
-const unwrapExpression = (node) => {
-    if (t.isParenthesizedExpression(node) ||
-        t.isTSAsExpression(node) ||
-        t.isTSSatisfiesExpression(node) ||
-        t.isTSNonNullExpression(node) ||
-        t.isTypeCastExpression(node))
-        return unwrapExpression(node.expression);
-    return node;
-};
 const combinePromiseResolutions = (resolutions) => ({
     promiseIds: resolutions.flatMap(({ promiseIds }) => promiseIds),
     status: resolutions.some(({ status }) => status === "unresolved")

package/dist/domain/javascript/javascriptSemanticPropertyPaths.js

@@ -0,0 +1,100 @@
+/** Read only canonical JavaScript array indices, excluding named properties. */
+export const semanticArrayIndex = (key) => {
+    const index = Number(key);
+    return Number.isInteger(index) &&
+        index >= 0 &&
+        index < 4_294_967_295 &&
+        String(index) === String(key)
+        ? index
+        : null;
+};
+/** Test an exact key, wildcard, or copied-slot selection against an own key. */
+export const semanticPropertyPathKeyMatches = (key, name) => {
+    if (key === null)
+        return true;
+    if (typeof key !== "object")
+        return String(key) === name;
+    if (key.excludedKeys.includes(name))
+        return false;
+    if (key.startIndex === undefined)
+        return true;
+    const index = semanticArrayIndex(name);
+    return index !== null && index >= key.startIndex;
+};
+const coverageNode = () => ({
+    terminal: false,
+    exact: new Map(),
+    selectors: new Map(),
+});
+/** Index exact effect prefixes without widening distinct member paths. */
+export class SemanticPropertyPathCoverage {
+    #root = coverageNode();
+    /** Retain a path only when no previously retained prefix covers it. */
+    retain(path) {
+        if (this.covers(path))
+            return false;
+        let node = this.#root;
+        for (const key of path) {
+            if (key !== null && typeof key !== "object") {
+                const name = String(key);
+                let child = node.exact.get(name);
+                if (child === undefined) {
+                    child = coverageNode();
+                    node.exact.set(name, child);
+                }
+                node = child;
+            }
+            else {
+                const identity = JSON.stringify(key);
+                let selected = node.selectors.get(identity);
+                if (selected === undefined) {
+                    selected = { key, node: coverageNode() };
+                    node.selectors.set(identity, selected);
+                }
+                node = selected.node;
+            }
+        }
+        node.terminal = true;
+        node.exact.clear();
+        node.selectors.clear();
+        return true;
+    }
+    /** Query retained prefixes without changing the coverage index. */
+    covers(path) {
+        const pending = [{ node: this.#root, offset: 0 }];
+        while (pending.length > 0) {
+            const current = pending.pop();
+            if (current === undefined)
+                break;
+            if (current.node.terminal)
+                return true;
+            const key = path[current.offset];
+            if (key === undefined)
+                continue;
+            if (key !== null && typeof key !== "object") {
+                const exact = current.node.exact.get(String(key));
+                if (exact !== undefined)
+                    pending.push({ node: exact, offset: current.offset + 1 });
+            }
+            for (const selected of current.node.selectors.values()) {
+                if (keyCovers(selected.key, key))
+                    pending.push({ node: selected.node, offset: current.offset + 1 });
+            }
+        }
+        return false;
+    }
+}
+const keyCovers = (covering, key) => {
+    if (covering === null)
+        return true;
+    if (key === null)
+        return false;
+    if (typeof key !== "object")
+        return typeof covering === "object"
+            ? semanticPropertyPathKeyMatches(covering, String(key))
+            : String(covering) === String(key);
+    return (typeof covering === "object" &&
+        covering.excludedKeys.every((name) => key.excludedKeys.includes(name)) &&
+        (covering.startIndex === undefined ||
+            (key.startIndex !== undefined && covering.startIndex <= key.startIndex)));
+};

package/dist/domain/javascript/javascriptSemanticProvenance.js

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 /** Construct exact local provenance without inventing module origins. */
 export const semanticLocalProvenance = () => ({
     status: "local",
@@ -20,8 +20,8 @@ export const semanticOriginsProvenance = (origins) => {
 /** Deduplicate and canonically order module origins. */
 export const uniqueSemanticOrigins = (origins) => [
     ...new Map(origins.map((origin) => [semanticOriginKey(origin), origin])).values(),
-].sort((left, right) => compareCodePoints(semanticOriginKey(left), semanticOriginKey(right)));
-const semanticOriginKey = (origin) => `${origin.specifier}\0${origin.importedPath.join("\0")}`;
+].sort((left, right) => compareUnicodeCodePoints(semanticOriginKey(left), semanticOriginKey(right)));
+const semanticOriginKey = (origin) => JSON.stringify([origin.specifier, origin.importedPath]);
 /** Canonically distinguish primitive values across type boundaries. */
 export const semanticPrimitiveKey = (value) => `${value === null ? "null" : typeof value}:${JSON.stringify(value)}`;
 /** Match namespace paths only after the caller has identified a Node built-in. */

package/dist/domain/javascript/javascriptSemanticQuery.js

@@ -1,4 +1,3 @@
-import { compareCodePoints } from "../canonicalOrdering.js";
 import { isJavaScriptSemanticOwnershipRelation as ownershipRelation } from "./javascriptSemanticQueryRelations.js";
 import { javaScriptSemanticQueryInputSchema, javaScriptSemanticQueryResultSchema, } from "./javascriptSemanticQuerySchemas.js";
 import { assessJavaScriptSemanticQuery } from "./javascriptSemanticQueryAssessment.js";
@@ -8,15 +7,18 @@ export const queryJavaScriptSemanticGraph = (graph, rawInput) => {
     const input = javaScriptSemanticQueryInputSchema.parse(rawInput);
     const queryId = queryIdentifier(graph, input);
     const seeds = resolveSeeds(graph, input);
-    const admission = admitSeeds(graph, seeds);
-    const retainedSeeds = admission.nodeIds;
+    const nodes = new Map(graph.nodes.map((node) => [node.node_id, node]));
     const adjacency = buildAdjacency(graph.relations, input);
-    const traversal = traverse(graph, retainedSeeds, adjacency);
+    const traversal = traverse(nodes, seeds, adjacency);
     const result = createQueryResult(graph, traversal);
-    const allRelevantUnknowns = relevantUnknownFrontiers(graph, traversal.nodeIds, input);
-    const relevantUnknowns = allRelevantUnknowns;
+    const relevantUnknowns = relevantUnknownFrontiers(graph, traversal.nodeIds, input);
     const candidateRelations = relevantCandidateRelationCount(graph, traversal.nodeIds, input);
     const expectedMatches = expectedMatchesFor(result.retainedNodes, result.retainedRelations, input);
+    const retainedContextIds = new Set([
+        ...result.retainedNodes.map(({ evidence }) => evidence.context_id),
+        ...result.retainedRelations.map(({ evidence }) => evidence.context_id),
+        ...relevantUnknowns.map(({ evidence }) => evidence.context_id),
+    ]);
     const assessment = assessJavaScriptSemanticQuery({
         graph,
         totalSeeds: seeds.length,
@@ -31,7 +33,8 @@ export const queryJavaScriptSemanticGraph = (graph, rawInput) => {
         seed: input.seed,
         direction: input.direction,
         status: assessment.status,
-        seed_node_ids: retainedSeeds,
+        seed_node_ids: seeds,
+        evidence_contexts: graph.evidence_contexts.filter(({ context_id }) => retainedContextIds.has(context_id)),
         nodes: result.retainedNodes,
         relations: result.retainedRelations,
         unknowns: relevantUnknowns,
@@ -42,7 +45,7 @@ export const queryJavaScriptSemanticGraph = (graph, rawInput) => {
             traversed_relations: traversal.relationIds.size,
             traversed_functions: traversal.functionIds.size,
             traversed_modules: traversal.modules.size,
-            relevant_unknowns: allRelevantUnknowns.length,
+            relevant_unknowns: relevantUnknowns.length,
         },
         coverage: assessment.coverage,
         limitations: assessment.limitations,
@@ -53,17 +56,6 @@ const createQueryResult = (graph, traversal) => {
     const retainedRelations = graph.relations.filter(({ relation_id }) => traversal.relationIds.has(relation_id));
     return { retainedNodes, retainedRelations };
 };
-const admitSeeds = (graph, seeds) => {
-    const nodes = new Map(graph.nodes.map((node) => [node.node_id, node]));
-    const retained = [];
-    for (const nodeId of seeds) {
-        const node = nodes.get(nodeId);
-        if (node === undefined)
-            continue;
-        retained.push(nodeId);
-    }
-    return { nodeIds: retained };
-};
 const buildAdjacency = (relations, input) => {
     const adjacency = new Map();
     const allowed = input.allowed_relations === undefined
@@ -77,8 +69,6 @@ const buildAdjacency = (relations, input) => {
             continue;
         addDirectedEntries(adjacency, relation, input.direction);
     }
-    for (const entries of adjacency.values())
-        entries.sort((left, right) => compareCodePoints(`${left.relation.relation_id}\0${left.nextNodeId}`, `${right.relation.relation_id}\0${right.nextNodeId}`));
     return adjacency;
 };
 const addDirectedEntries = (adjacency, relation, direction) => {
@@ -104,8 +94,7 @@ const addEntry = (adjacency, from, nextNodeId, relation) => {
     entries.push({ relation, nextNodeId });
     adjacency.set(from, entries);
 };
-const traverse = (graph, seeds, adjacency) => {
-    const nodes = new Map(graph.nodes.map((node) => [node.node_id, node]));
+const traverse = (nodes, seeds, adjacency) => {
     const nodeIds = new Set(seeds);
     const relationIds = new Set();
     const functionIds = new Set();
@@ -153,12 +142,27 @@ const relevantUnknownFrontiers = (graph, nodeIds, input) => {
             unknown.relation_kinds.some((relation) => allowed.has(relation))));
 };
 const relevantCandidateRelationCount = (graph, nodeIds, input) => {
-    const adjacency = buildAdjacency(graph.relations.filter(({ resolution }) => resolution === "candidate"), { ...input, include_ambiguous_dynamic_edges: true });
-    const relevant = new Set();
-    for (const nodeId of nodeIds)
-        for (const { relation } of adjacency.get(nodeId) ?? [])
-            relevant.add(relation.relation_id);
-    return relevant.size;
+    const allowed = input.allowed_relations === undefined
+        ? null
+        : new Set(input.allowed_relations);
+    let relevant = 0;
+    for (const relation of graph.relations) {
+        if (relation.resolution !== "candidate" ||
+            (allowed !== null && !allowed.has(relation.relation)))
+            continue;
+        const sourceIsRelevant = nodeIds.has(relation.source_node_id);
+        const targetIsRelevant = nodeIds.has(relation.target_node_id);
+        if ((input.direction === "callers" &&
+            relation.relation === "calls" &&
+            targetIsRelevant) ||
+            (input.direction === "ownership" &&
+                ownershipRelation(relation.relation) &&
+                (sourceIsRelevant || targetIsRelevant)) ||
+            (input.direction === "backward-provenance" && targetIsRelevant) ||
+            (input.direction === "forward-influence" && sourceIsRelevant))
+            relevant += 1;
+    }
+    return relevant;
 };
 const expectedMatchesFor = (nodes, relations, input) => {
     if (input.expected === null)

package/dist/domain/javascript/javascriptSemanticQueryIdentity.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
-import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 /** Canonical JSON used by semantic query commitments and ordering. */
 export const canonicalJavaScriptSemanticQueryJson = (value) => {
     const encoded = canonicalize(value);
@@ -39,7 +40,7 @@ export const resolveJavaScriptSemanticQuerySeeds = (graph, input) => {
     return graph.nodes
         .filter((node) => seedMatches(node, input, fingerprintFunctions))
         .map(({ node_id }) => node_id)
-        .sort(compareCodePoints);
+        .sort(compareUnicodeCodePoints);
 };
 const seedMatches = (node, input, fingerprintFunctions) => {
     const seed = input.seed;
@@ -50,9 +51,7 @@ const seedMatches = (node, input, fingerprintFunctions) => {
     if (seed.kind === "function")
         return fingerprintFunctions.has(node.node_id);
     if (seed.kind === "literal")
-        return (node.kind === "literal" &&
-            canonicalJavaScriptSemanticQueryJson(node.properties.value) ===
-                canonicalJavaScriptSemanticQueryJson(seed.value));
+        return node.kind === "literal" && node.properties.value === seed.value;
     if (seed.kind === "property")
         return node.kind === "property-slot" && node.properties.name === seed.name;
     if (seed.kind === "endpoint")

package/dist/domain/javascript/javascriptSemanticQuerySchemas.js

@@ -1,16 +1,14 @@
 import { z } from "zod";
-import { JAVASCRIPT_SEMANTIC_NODE_KINDS, JAVASCRIPT_SEMANTIC_RELATIONS, javaScriptSemanticNodeSchema, javaScriptSemanticRelationSchema, javaScriptSemanticUnknownSchema, } from "./javascriptSemanticGraphSchemas.js";
-import { jsonValueSchema } from "../jsonValue.js";
+import { JAVASCRIPT_SEMANTIC_NODE_KINDS, JAVASCRIPT_SEMANTIC_RELATIONS, javaScriptSemanticNodeSchema, javaScriptSemanticRelationSchema, javaScriptSemanticEvidenceContextSchema, javaScriptSemanticUnknownSchema, } from "./javascriptSemanticGraphSchemas.js";
 import { digestSchema } from "../digests.js";
 import { prefixedDigestSchema } from "../digests.js";
 const semanticNodeIdSchema = prefixedDigestSchema("jsrg_node");
-const literalValueSchema = jsonValueSchema.refine((value) => value === null ||
-    typeof value === "string" ||
-    typeof value === "number" ||
-    typeof value === "boolean", "Literal seeds accept only JSON primitive values");
-// Zod derivations drop the shared schema's JSON Schema projection override;
-// re-apply it so MCP catalog generation keeps projecting `{}`.
-literalValueSchema._zod.toJSONSchema = () => ({});
+const literalValueSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+]);
 const literalSeedSchema = z.strictObject({
     kind: z.literal("literal"),
     value: literalValueSchema,
@@ -77,6 +75,7 @@ export const javaScriptSemanticQueryResultSchema = z.strictObject({
     direction: javaScriptSemanticQueryInputSchema.shape.direction,
     status: z.enum(["found", "no-match", "ambiguous", "partial", "unsupported"]),
     seed_node_ids: z.array(semanticNodeIdSchema),
+    evidence_contexts: z.array(javaScriptSemanticEvidenceContextSchema),
     nodes: z.array(javaScriptSemanticNodeSchema),
     relations: z.array(javaScriptSemanticRelationSchema),
     unknowns: z.array(javaScriptSemanticUnknownSchema),

package/dist/domain/javascript/javascriptSemanticRequireOrigin.js

@@ -1,24 +1,30 @@
 import * as t from "@babel/types";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
-import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
+import { semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { stringValue } from "./javascriptStaticAnalysisHelpers.js";
 /** Recover an unshadowed literal require origin and its exact member path. */
 export const semanticRequireOrigin = (node, state) => {
     const members = [];
-    while (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
-        const member = semanticStaticPropertyKey(node.property, node.computed);
-        if (member === null || !t.isNode(node.object))
+    let current = node;
+    while (current !== null && current !== undefined) {
+        current = unwrapJavaScriptExpression(current).node;
+        if (!t.isMemberExpression(current) &&
+            !t.isOptionalMemberExpression(current))
+            break;
+        const member = semanticStaticPropertyKey(current.property, current.computed);
+        if (member === null || !t.isNode(current.object))
             return undefined;
         members.push(member);
-        node = node.object;
+        current = current.object;
     }
-    if (!t.isCallExpression(node) ||
-        !t.isIdentifier(node.callee, { name: "require" }))
+    if (!t.isCallExpression(current) ||
+        !t.isIdentifier(current.callee, { name: "require" }))
         return undefined;
-    if (resolveSemanticBindingState(state, node.callee, "require") !== undefined ||
-        semanticResolutionBlocked(state, node.callee, "require"))
+    if (resolveSemanticBindingState(state, current.callee, "require") !==
+        undefined ||
+        semanticResolutionBlocked(state, current.callee, "require"))
         return undefined;
-    const specifier = stringValue(node.arguments[0]);
+    const specifier = stringValue(current.arguments[0]);
     return specifier === undefined
         ? undefined
         : { specifier, importedPath: members.reverse() };