rea-agents 6.4.0 → 6.5.0

package/dist/cli/utilityCommands.js

@@ -1,4 +1,5 @@
 import { z } from "incur";
+import { createHistoricalSourceSummary } from "../domain/referenceSourceSummary.js";
 import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
 import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
 import { importReferenceSource } from "../application/ReferenceSourceImport.js";
@@ -20,77 +21,87 @@ export const registerUtilityCommands = (cli, logger, environment, analysis) => {
     registerCapabilityCommands(cli, logger, analysis);
     registerNativeCommands(cli, logger, runProviderAnalysis);
     registerNativeCallCommands(cli, logger, runProviderAnalysis);
-    for (const [command, operation] of [
-        [CLI_COMMANDS.observeNativeUi, "observe_native_ui"],
-        [CLI_COMMANDS.captureNativeUiScenario, "capture_native_ui_scenario"],
-    ]) {
-        cli.command(command, {
-            description: "Observe or run a scenario in one exact native application window",
-            args: z.object({
-                path: z.string().describe("Local native executable or app path"),
-            }),
-            options: z.object({
-                pid: z.number().int().positive().describe("Existing application PID"),
-                windowId: z
-                    .number()
-                    .int()
-                    .positive()
-                    .describe("Exact selected application window ID"),
-                steps: z
-                    .string()
-                    .optional()
-                    .describe("JSON array of declarative AX actions or waits"),
-                screenshot: z
-                    .boolean()
-                    .default(true)
-                    .describe("Capture only the selected window"),
-                accessibility: z
-                    .boolean()
-                    .default(true)
-                    .describe("Read the selected window accessibility tree"),
-                maxNodes: z
-                    .number()
-                    .int()
-                    .positive()
-                    .safe()
-                    .default(500)
-                    .describe("Maximum accessibility nodes per capture"),
-            }),
-            run: ({ args, options }) => logCliCommand(logger, command, async () => {
-                const parameters = {
-                    pid: options.pid,
-                    window_id: options.windowId,
-                    screenshot: options.screenshot,
-                    accessibility: options.accessibility,
-                    max_nodes: options.maxNodes,
-                };
-                if (operation === "capture_native_ui_scenario") {
-                    const decoded = options.steps === undefined
-                        ? { ok: true, value: undefined }
-                        : safeParseJson(options.steps);
-                    if (!decoded.ok)
-                        return invalidNativeUiScenarioInput(operation, [
-                            { path: ["steps"], reason: "invalid_format", expected: "JSON" },
-                        ]);
-                    const parsed = nativeUiScenarioInputSchema.safeParse({
-                        ...parameters,
-                        steps: decoded.value,
-                    });
-                    if (!parsed.success)
-                        return invalidNativeUiScenarioInput(operation, projectInputIssues(parsed.error.issues, {
-                            ...parameters,
-                            ...(options.steps === undefined
-                                ? {}
-                                : { steps: decoded.value }),
-                        }));
-                    return runProviderAnalysis(args.path, operation, parsed.data, logger);
-                }
-                return runProviderAnalysis(args.path, operation, parameters, logger);
-            }),
-        });
-    }
+    registerNativeUiCommands(cli, logger, runProviderAnalysis);
     registerReferenceSourceCommand(cli, logger, environment);
 };
+const nativeUiScopeOptions = {
+    pid: z.number().int().positive().describe("Existing application PID"),
+    windowId: z
+        .number()
+        .int()
+        .positive()
+        .describe("Exact selected application window ID"),
+    screenshot: z
+        .boolean()
+        .default(true)
+        .describe("Capture only the selected window"),
+    accessibility: z
+        .boolean()
+        .default(true)
+        .describe("Read the selected window accessibility tree"),
+    maxNodes: z
+        .number()
+        .int()
+        .positive()
+        .safe()
+        .default(500)
+        .describe("Maximum accessibility nodes per capture"),
+};
+const nativeUiScope = (options) => ({
+    pid: options.pid,
+    window_id: options.windowId,
+    screenshot: options.screenshot,
+    accessibility: options.accessibility,
+    max_nodes: options.maxNodes,
+});
+/**
+ * Passive observation and active scenarios have different input contracts.
+ * Only the scenario command accepts steps, so passive observation rejects
+ * them as an unknown flag instead of silently dropping them.
+ */
+const registerNativeUiCommands = (cli, logger, runProviderAnalysis) => {
+    const pathArgument = z.object({
+        path: z.string().describe("Local native executable or app path"),
+    });
+    cli.command(CLI_COMMANDS.observeNativeUi, {
+        description: "Observe one already-running native application window by PID and window ID",
+        args: pathArgument,
+        options: z.object(nativeUiScopeOptions),
+        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.observeNativeUi, () => runProviderAnalysis(args.path, "observe_native_ui", nativeUiScope(options), logger)),
+    });
+    const operation = "capture_native_ui_scenario";
+    cli.command(CLI_COMMANDS.captureNativeUiScenario, {
+        description: "Run declarative AX actions or waits in one exact native application window",
+        args: pathArgument,
+        options: z.object({
+            ...nativeUiScopeOptions,
+            steps: z
+                .string()
+                .optional()
+                .describe("JSON array of declarative AX actions or waits"),
+        }),
+        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.captureNativeUiScenario, async () => {
+            const parameters = nativeUiScope(options);
+            const decoded = options.steps === undefined
+                ? { ok: true, value: undefined }
+                : safeParseJson(options.steps);
+            if (!decoded.ok)
+                return invalidNativeUiScenarioInput(operation, [
+                    { path: ["steps"], reason: "invalid_format", expected: "JSON" },
+                ]);
+            const parsed = nativeUiScenarioInputSchema.safeParse({
+                ...parameters,
+                steps: decoded.value,
+            });
+            if (!parsed.success)
+                return invalidNativeUiScenarioInput(operation, projectInputIssues(parsed.error.issues, {
+                    ...parameters,
+                    ...(options.steps === undefined ? {} : { steps: decoded.value }),
+                }));
+            return runProviderAnalysis(args.path, operation, parsed.data, logger);
+        }),
+    });
+};
 const invalidNativeUiScenarioInput = (operation, issues) => ({
     error: "Application workflow failed",
     ...projectAnalysisError(new AnalysisInputError(operation, undefined, issues)),
@@ -150,18 +161,47 @@ const registerReferenceSourceCommand = (cli, logger, environment) => {
                 .string()
                 .describe("Local source directory to import as historical reference"),
         }),
-        run: ({ args }) => logCliCommand(logger, "import-reference-source", async () => {
+        options: z.object({
+            detail: z
+                .enum(["full", "summary"])
+                .default("full")
+                .describe("Complete committed graph or compact historical-source summary"),
+            outlineDepth: z
+                .number()
+                .int()
+                .safe()
+                // After .safe(): its safe-range check overwrites an earlier minimum,
+                // which advertised negative depths the parser rejects.
+                .nonnegative()
+                .optional()
+                .describe("Summary outline path depth (default: 2; 0 omits entries); requires --detail summary"),
+        }),
+        run: ({ args, options }) => logCliCommand(logger, "import-reference-source", async () => {
+            if (options.outlineDepth !== undefined &&
+                options.detail !== "summary")
+                return {
+                    error: "Import failed",
+                    ...projectAnalysisError(new AnalysisInputError("import-reference-source", { userMessage: "--outline-depth requires --detail summary" }, [
+                        {
+                            path: ["outlineDepth"],
+                            reason: "invalid_value",
+                            message: "--outline-depth requires --detail summary",
+                        },
+                    ])),
+                };
             const config = parseConfig(environment);
             if (!config.ok)
                 return {
                     error: "Import failed",
                     ...projectAnalysisError(config.error),
                 };
-            return runReferenceSourceImport(args.root, config.value.referenceSourcePolicy);
+            return runReferenceSourceImport(args.root, config.value.referenceSourcePolicy, options.detail === "summary"
+                ? (options.outlineDepth ?? 2)
+                : undefined);
         }, isReferenceSourceImportCliFailure),
     });
 };
-const runReferenceSourceImport = async (root, policy) => {
+const runReferenceSourceImport = async (root, policy, outlineDepth) => {
     const resources = new ArtifactResourceScope();
     let outcome;
     try {
@@ -172,7 +212,7 @@ const runReferenceSourceImport = async (root, policy) => {
                 caller: "rea-cli",
                 policy,
                 importer: PRODUCT_IDENTITY.packageName,
-                importerVersion: null,
+                importerVersion: PRODUCT_IDENTITY.packageVersion,
             }, resources),
         };
     }
@@ -216,7 +256,9 @@ const runReferenceSourceImport = async (root, policy) => {
                 cause: closeOutcome.cause,
             }),
         };
-    return imported.value;
+    return outlineDepth === undefined
+        ? imported.value
+        : createHistoricalSourceSummary(imported.value, outlineDepth);
 };
 const mergeReferenceSourceCleanup = (first, second) => first === undefined
     ? second

package/dist/cli/wasmCommands.js

@@ -0,0 +1,61 @@
+import { compareWasmInterfaces } from "../application/wasm/WasmInterfaceComparisonService.js";
+import { parseCliJsonInput } from "../cliJsonInput.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { z } from "incur";
+import { resolve } from "node:path";
+import { wasmArtifactModule } from "../composition/wasm.js";
+import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { withCommandCancellation } from "./commandCancellation.js";
+/** Resolve all caller-selected artifact paths through the shared workflow. */
+export const registerWasmCommands = (cli, logger, environment) => {
+    cli.command(CLI_COMMANDS.compareWasmInterfaces, {
+        description: "Compare core WASM interfaces from two exact inspection Evidence records",
+        args: z.object({
+            input: z
+                .string()
+                .describe("Inline JSON or input file containing left/right complete Evidence and required scope"),
+        }),
+        run: ({ args }) => withCommandCancellation(async (signal) => logCliCommand(logger, CLI_COMMANDS.compareWasmInterfaces, async () => {
+            const input = await parseCliJsonInput(args.input, "compare_wasm_interfaces");
+            if (!input.ok)
+                return input.error;
+            const result = await compareWasmInterfaces(input.value, { signal });
+            return result.ok ? result.value : projectAnalysisError(result.error);
+        })),
+    });
+    const service = wasmArtifactModule.create(environment);
+    cli.command(wasmArtifactModule.cliCommand, {
+        description: "Inspect an explicit local WASM artifact with WABT",
+        args: z.object({
+            path: z.string().describe("Local WASM artifact"),
+        }),
+        options: z.object({
+            glue_paths: z
+                .array(z.string())
+                .optional()
+                .describe("Selected local JavaScript glue paths"),
+            candidate_paths: z
+                .array(z.string())
+                .optional()
+                .describe("Explicit local WASM candidates"),
+        }),
+        run: ({ args, options }) => withCommandCancellation(async (signal) => {
+            try {
+                return await logCliCommand(logger, wasmArtifactModule.cliCommand, async () => {
+                    const result = await service.inspect({
+                        path: resolve(args.path),
+                        glue_paths: options.glue_paths?.map((path) => resolve(path)),
+                        candidate_paths: options.candidate_paths?.map((path) => resolve(path)),
+                    }, { signal });
+                    return result.ok
+                        ? result.value
+                        : projectAnalysisError(result.error);
+                });
+            }
+            finally {
+                await service.close();
+            }
+        }),
+    });
+};

package/dist/cli/webModuleCommands.js

@@ -3,16 +3,16 @@ import { createWebModuleTraceService } from "../composition/webModules.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { webModuleTraceInputSchema } from "../domain/webModuleTrace.js";
 import { withCommandCancellation } from "./commandCancellation.js";
+const importMapInputSchema = webModuleTraceInputSchema.shape.import_map.unwrap();
 /** Expose the same selected-context module trace through the CLI. */
 export const registerWebModuleCommands = (cli, logger, environment) => {
     const service = createWebModuleTraceService(environment);
     cli.command(CLI_COMMANDS.traceWebModuleImports, {
         description: "Trace one captured script's native imports to URLs and captured source candidates",
         args: z.object({
-            manifestPath: z
-                .string()
-                .describe("Absolute export_web_scripts manifest path"),
+            manifestPath: webModuleTraceInputSchema.shape.manifest_path,
             scriptIndex: z.coerce
                 .number()
                 .int()
@@ -20,37 +20,41 @@ export const registerWebModuleCommands = (cli, logger, environment) => {
                 .describe("Zero-based manifest script index"),
         }),
         options: z.object({
-            importerUrl: z
-                .string()
+            importerUrl: webModuleTraceInputSchema.shape.importer_url,
+            importMapPath: importMapInputSchema.shape.path
                 .optional()
-                .describe("Explicit HTTP(S) importer URL"),
-            importMapPath: z
-                .string()
+                .describe("Absolute local import-map JSON path; requires --import-map-base-url"),
+            importMapBaseUrl: importMapInputSchema.shape.base_url
                 .optional()
-                .describe("Absolute local import-map JSON"),
-            importMapBaseUrl: z
-                .string()
-                .optional()
-                .describe("HTTP(S) import-map base URL"),
+                .describe("HTTP(S) import-map base URL; requires --import-map-path"),
+        }),
+        run: ({ args, options }) => withCommandCancellation(async (signal) => {
+            try {
+                return await logCliCommand(logger, CLI_COMMANDS.traceWebModuleImports, async () => {
+                    const result = await service.trace({
+                        manifest_path: args.manifestPath,
+                        script_index: args.scriptIndex,
+                        ...(options.importerUrl === undefined
+                            ? {}
+                            : { importer_url: options.importerUrl }),
+                        ...(options.importMapPath === undefined &&
+                            options.importMapBaseUrl === undefined
+                            ? {}
+                            : {
+                                import_map: {
+                                    path: options.importMapPath,
+                                    base_url: options.importMapBaseUrl,
+                                },
+                            }),
+                    }, { signal });
+                    return result.ok
+                        ? result.value
+                        : projectAnalysisError(result.error);
+                });
+            }
+            finally {
+                await service.close();
+            }
         }),
-        run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.traceWebModuleImports, async () => {
-            const result = await service.trace({
-                manifest_path: args.manifestPath,
-                script_index: args.scriptIndex,
-                ...(options.importerUrl === undefined
-                    ? {}
-                    : { importer_url: options.importerUrl }),
-                ...(options.importMapPath === undefined &&
-                    options.importMapBaseUrl === undefined
-                    ? {}
-                    : {
-                        import_map: {
-                            path: options.importMapPath,
-                            base_url: options.importMapBaseUrl,
-                        },
-                    }),
-            }, { signal });
-            return result.ok ? result.value : projectAnalysisError(result.error);
-        })),
     });
 };

package/dist/cli/webNetworkCaptureCommands.js

@@ -1,17 +1,20 @@
 import { z } from "incur";
+import { WEB_NETWORK_CAPTURE_FORMATS } from "../domain/webNetworkCapture.js";
 import { createWebNetworkCaptureService } from "../composition/webNetworkCaptures.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
-import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { withCommandCancellation } from "./commandCancellation.js";
+import { finishAnalysisCommand } from "./finishAnalysisCommand.js";
 /** Expose offline historical capture inspection with the same selection contract as MCP. */
 export const registerWebNetworkCaptureCommands = (cli, logger, environment) => {
     const service = createWebNetworkCaptureService(environment);
     cli.command(CLI_COMMANDS.inspectWebNetworkCapture, {
-        description: "Inspect retained HAR or native mitmproxy records without fetching recorded URLs",
+        description: "Inspect retained HAR, native mitmproxy, Fiddler SAZ or aioquic qlog records without fetching recorded URLs",
         args: z.object({
             capturePath: z.string().describe("Absolute local capture path"),
-            format: z.enum(["har", "mitmproxy"]).describe("Producer capture format"),
+            format: z
+                .enum(WEB_NETWORK_CAPTURE_FORMATS)
+                .describe("Producer capture format"),
         }),
         options: z.object({
             record: z
@@ -24,17 +27,14 @@ export const registerWebNetworkCaptureCommands = (cli, logger, environment) => {
                 .describe("Literal string values explicitly marked sensitive; repeat as needed"),
         }),
         run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.inspectWebNetworkCapture, async () => {
-            const result = await service.inspect({
+            return finishAnalysisCommand(() => service.inspect({
                 capture_path: args.capturePath,
                 format: args.format,
                 sensitive_values: options.sensitiveValue,
                 ...(options.record === undefined
                     ? {}
                     : { record_ordinals: options.record }),
-            }, { signal });
-            return result.ok
-                ? result.value
-                : projectAnalysisError(result.error);
+            }, { signal }), service, "web-network-capture", "inspect_web_network_capture", "Web network capture resources");
         })),
     });
 };

package/dist/cli-runtime/AbortablePromise-BVBemxbD.js

@@ -0,0 +1,123 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { init_snapshotEnvironment, snapshotEnvironment } from "./snapshotEnvironment-D_tWyOub.js";
+import { win32 } from "node:path";
+
+//#region dist/process/PendingOperations.js
+var PendingOperations;
+function init_PendingOperations() {
+	return (init_PendingOperations = __esmMin((() => {
+		PendingOperations = class {
+			#pending = new Map();
+			/** Number of currently correlated operations. */
+			get size() {
+				return this.#pending.size;
+			}
+			/** Return whether an operation key is awaiting a protocol reply. */
+			has(key) {
+				return this.#pending.has(key);
+			}
+			/** Register one unique operation key and await its reply or cancellation. */
+			wait(key, options) {
+				if (this.#pending.has(key)) throw new Error("Pending operation key is already registered");
+				if (options.signal?.aborted === true) return Promise.resolve(options.cancelledValue());
+				return new Promise((resolve) => {
+					const onAbort = options.signal === undefined ? undefined : () => this.#finish(key, options.cancelledValue());
+					const timer = options.timeoutMs === undefined ? undefined : setTimeout(() => this.#finish(key, options.timeoutValue()), options.timeoutMs);
+					this.#pending.set(key, {
+						resolve,
+						timer,
+						signal: options.signal,
+						onAbort
+					});
+					if (onAbort !== undefined) options.signal?.addEventListener("abort", onAbort, { once: true });
+				});
+			}
+			/** Settle one correlated reply; returns false for late or unknown keys. */
+			settle(key, value) {
+				return this.#finish(key, value);
+			}
+			/** Fail every active operation while releasing all timers and listeners. */
+			failAll(valueFor) {
+				for (const key of this.#pending.keys()) this.#finish(key, valueFor(key));
+			}
+			#finish(key, value) {
+				const pending = this.#pending.get(key);
+				if (pending === undefined) return false;
+				this.#pending.delete(key);
+				if (pending.timer !== undefined) clearTimeout(pending.timer);
+				if (pending.signal !== undefined && pending.onAbort !== undefined) pending.signal.removeEventListener("abort", pending.onAbort);
+				pending.resolve(value);
+				return true;
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/process/WindowsBatchCommand.js
+var WindowsBatchCommandError, isWindowsBatchFile, quoteWindowsBatchToken, windowsBatchCommand;
+function init_WindowsBatchCommand() {
+	return (init_WindowsBatchCommand = __esmMin((() => {
+		init_snapshotEnvironment();
+		WindowsBatchCommandError = class extends Error {
+			reason;
+			constructor(reason, message) {
+				super(message);
+				this.reason = reason;
+				this.name = "WindowsBatchCommandError";
+			}
+		};
+		isWindowsBatchFile = (command) => /\.(?:bat|cmd)$/iu.test(command);
+		quoteWindowsBatchToken = (value) => {
+			if (value.length === 0 || value.includes("\0") || value.includes("\r") || value.includes("\n") || /["%^!&|<>]/u.test(value)) throw new WindowsBatchCommandError("metacharacter", "Windows batch arguments cannot contain command-interpreter metacharacters");
+			return `"${value}"`;
+		};
+		windowsBatchCommand = (options) => {
+			const environment = snapshotEnvironment(options.environment, "win32");
+			const systemRoot = environment.SYSTEMROOT;
+			const comSpec = options.comSpec ?? environment.COMSPEC ?? (systemRoot === undefined ? "C:\\Windows\\System32\\cmd.exe" : win32.join(systemRoot, "System32", "cmd.exe"));
+			if (!win32.isAbsolute(comSpec) || win32.basename(comSpec).toLowerCase() !== "cmd.exe") throw new WindowsBatchCommandError("invalid_comspec", "Windows ComSpec must be an absolute cmd.exe path");
+			const tokens = [options.batchPath, ...options.arguments].map(quoteWindowsBatchToken);
+			return {
+				command: comSpec,
+				arguments: [
+					"/d",
+					"/e:on",
+					"/v:off",
+					"/s",
+					"/c",
+					`"${tokens.join(" ")}"`
+				]
+			};
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/process/AbortablePromise.js
+var ABORTED, waitForAbortable;
+function init_AbortablePromise() {
+	return (init_AbortablePromise = __esmMin((() => {
+		ABORTED = Symbol("aborted");
+		waitForAbortable = async (pending, signal) => {
+			if (signal === undefined) return pending;
+			let onAbort;
+			const cancelled = new Promise((resolve) => {
+				if (signal.aborted) {
+					resolve(ABORTED);
+					return;
+				}
+				onAbort = () => resolve(ABORTED);
+				signal.addEventListener("abort", onAbort, { once: true });
+			});
+			try {
+				return await Promise.race([cancelled, pending]);
+			} finally {
+				if (onAbort !== undefined) signal.removeEventListener("abort", onAbort);
+			}
+		};
+	})))();
+}
+
+//#endregion
+export { ABORTED, PendingOperations, WindowsBatchCommandError, init_AbortablePromise, init_PendingOperations, init_WindowsBatchCommand, isWindowsBatchFile, quoteWindowsBatchToken, waitForAbortable, windowsBatchCommand };

package/dist/cli-runtime/AnalysisProvider-D0Us2OTk.js

@@ -0,0 +1,27 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { init_relationshipCoverage, relationshipCoverageSchema } from "./reconstructionObligationLedgerSchemas-Bao0xMr-.js";
+import { init_jsonValue, jsonValueSchema } from "./errorSchemas-CTRmvMl3.js";
+
+//#region dist/application/AnalysisProvider.js
+function createAnalysisExecution(result, provider, options = {}) {
+	return {
+		result: jsonValueSchema.parse(result),
+		rawResult: options.rawResult === undefined ? null : jsonValueSchema.parse(options.rawResult),
+		provider,
+		...options.analysisProfile === undefined ? {} : { analysisProfile: structuredClone(options.analysisProfile) },
+		limitations: [...options.limitations ?? []],
+		...options.relationshipCoverage === undefined ? {} : { relationshipCoverage: relationshipCoverageSchema.parse(options.relationshipCoverage) },
+		...options.referencesTruncated === undefined ? {} : { referencesTruncated: options.referencesTruncated },
+		locations: [...options.locations ?? []],
+		subject: options.subject ?? null
+	};
+}
+function init_AnalysisProvider() {
+	return (init_AnalysisProvider = __esmMin((() => {
+		init_jsonValue();
+		init_relationshipCoverage();
+	})))();
+}
+
+//#endregion
+export { createAnalysisExecution, init_AnalysisProvider };