rea-agents 3.0.0 → 3.2.0

package/dist/cli/artifactCommands.js

@@ -1,123 +1,95 @@
 import { z } from "incur";
 import { runProviderAnalysis } from "../application/DirectAnalysis.js";
+import { createArtifactExtractionDestination } from "../application/ArtifactExtractionDestination.js";
 import { logCliCommand } from "../cliLogging.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 export const registerArtifactCommands = (cli, logger) => {
-    registerInventoryCommand(cli, logger);
     registerInspectionCommand(cli, logger);
     registerExtractionCommand(cli, logger);
+    registerInterfaceBuilderCommand(cli, logger);
 };
-const registerInventoryCommand = (cli, logger) => {
-    cli.command(CLI_COMMANDS.inventoryArtifact, {
-        description: "Build a bounded deterministic artifact graph",
+const registerInterfaceBuilderCommand = (cli, logger) => {
+    cli.command(CLI_COMMANDS.decodeInterfaceBuilder, {
+        description: "Decode compiled storyboard and nib archives from an app bundle",
         args: z.object({
-            path: z.string().describe("Application or package path"),
+            path: z.string().describe("Apple .app bundle path"),
         }),
         options: z.object({
-            offset: z
+            maxDocuments: z
                 .number()
                 .int()
-                .min(0)
-                .default(0)
-                .describe("Zero-based offset for graph nodes, occurrences, and edges"),
-            limit: z
+                .min(1)
+                .max(64)
+                .default(64)
+                .describe("Maximum archives to decode"),
+            maxObjects: z
                 .number()
                 .int()
                 .min(1)
-                .max(500)
-                .default(100)
-                .describe("Maximum nodes, occurrences, and edges per result section"),
-            integrityPolicy: z
-                .enum(["fail", "record-and-continue"])
-                .default("fail")
-                .describe("Behavior when declared artifact integrity does not match"),
-            integrityContinueApproved: z
-                .boolean()
-                .default(false)
-                .describe("Approve continuing after recorded integrity mismatches"),
-            maxIntegrityMismatches: z
+                .max(20_000)
+                .default(20_000)
+                .describe("Maximum graph objects"),
+            maxConnections: z
                 .number()
                 .int()
                 .min(1)
-                .max(100)
-                .default(10)
-                .describe("Maximum integrity mismatches to record before stopping"),
-            nativeMountApproved: z
-                .boolean()
-                .default(false)
-                .describe("Approve read-only native mounting when required"),
+                .max(40_000)
+                .default(40_000)
+                .describe("Maximum decoded connections"),
         }),
         alias: {
-            integrityPolicy: "integrity-policy",
-            integrityContinueApproved: "integrity-continue-approved",
-            maxIntegrityMismatches: "max-integrity-mismatches",
-            nativeMountApproved: "native-mount-approved",
+            maxDocuments: "max-documents",
+            maxObjects: "max-objects",
+            maxConnections: "max-connections",
         },
-        run: ({ args, options }) => logCliCommand(logger, "inventory-artifact", () => runProviderAnalysis(args.path, "inventory_artifact", {
-            node_offset: options.offset,
-            node_limit: options.limit,
-            occurrence_offset: options.offset,
-            occurrence_limit: options.limit,
-            edge_offset: options.offset,
-            edge_limit: options.limit,
-            integrity_policy: options.integrityPolicy,
-            integrity_continue_approved: options.integrityContinueApproved,
-            max_integrity_mismatches: options.maxIntegrityMismatches,
-            native_mount_approved: options.nativeMountApproved,
+        run: ({ args, options }) => logCliCommand(logger, "decode-interface-builder", () => runProviderAnalysis(args.path, "decode_interface_builder", {
+            max_documents: options.maxDocuments,
+            max_objects: options.maxObjects,
+            max_connections: options.maxConnections,
         }, logger)),
     });
 };
 const registerExtractionCommand = (cli, logger) => {
     cli.command(CLI_COMMANDS.extractArtifact, {
-        description: "Extract explicitly selected artifact occurrences safely",
+        description: "Extract all regular artifact contents safely",
         args: z.object({
             path: z.string().describe("Application or package path"),
-            outputRoot: z.string().describe("Absent absolute output root"),
-        }),
-        options: z.object({
-            occurrenceIds: z
-                .array(z.string().regex(/^occ_[a-f0-9]{64}$/u))
-                .min(1)
-                .max(500)
-                .describe("Exact artifact occurrence IDs selected for extraction"),
         }),
-        alias: { occurrenceIds: "occurrence-ids" },
-        run: ({ args, options }) => logCliCommand(logger, "extract-artifact", () => runProviderAnalysis(args.path, "extract_artifact", {
-            approved: true,
-            output_root: args.outputRoot,
-            occurrence_ids: options.occurrenceIds,
+        options: z.object({}),
+        run: ({ args }) => logCliCommand(logger, "extract-artifact", () => runProviderAnalysis(args.path, "extract_artifact", {
+            output_root: createArtifactExtractionDestination(),
         }, logger)),
     });
 };
 const registerInspectionCommand = (cli, logger) => {
     cli.command(CLI_COMMANDS.inspectArtifact, {
-        description: "Inspect one artifact with bounded observations and explicit next probes",
+        description: "Inspect one artifact and return all available observations and next probes",
         args: z.object({
             path: z.string().describe("Application or package path"),
         }),
         options: z.object({
-            maxObservations: z
-                .number()
-                .int()
-                .min(1)
-                .max(500)
-                .default(100)
-                .describe("Maximum retained observations"),
-            maxRelationships: z
-                .number()
-                .int()
-                .min(1)
-                .max(500)
-                .default(100)
-                .describe("Maximum retained derived relationships"),
+            integrityPolicy: z
+                .enum(["fail", "record-and-continue"])
+                .default("fail")
+                .describe("Behavior when declared artifact integrity does not match"),
+            integrityContinueApproved: z
+                .boolean()
+                .default(false)
+                .describe("Approve continuing after recorded integrity mismatches"),
+            nativeMountApproved: z
+                .boolean()
+                .default(false)
+                .describe("Approve read-only native mounting when required"),
         }),
         alias: {
-            maxObservations: "max-observations",
-            maxRelationships: "max-relationships",
+            integrityPolicy: "integrity-policy",
+            integrityContinueApproved: "integrity-continue-approved",
+            nativeMountApproved: "native-mount-approved",
         },
         run: ({ args, options }) => logCliCommand(logger, "inspect-artifact", () => runProviderAnalysis(args.path, "inspect_artifact", {
-            max_observations: options.maxObservations,
-            max_relationships: options.maxRelationships,
+            integrity_policy: options.integrityPolicy,
+            integrity_continue_approved: options.integrityContinueApproved,
+            native_mount_approved: options.nativeMountApproved,
         }, logger)),
     });
 };

package/dist/cli/coreAnalysisCommands.js

@@ -14,20 +14,83 @@ export const registerCoreAnalysisCommands = (cli, logger) => {
     registerSearchCommand(cli, logger);
     registerXrefsCommand(cli, logger);
     registerTraceCommand(cli, logger);
+    registerNativeUiActionCommand(cli, logger);
+    registerNativeDispatchMetadataCommand(cli, logger);
+};
+const registerNativeDispatchMetadataCommand = (cli, logger) => {
+    cli.command(CLI_COMMANDS.inspectNativeDispatchMetadata, {
+        description: "Inspect typed Objective-C and Swift dispatch metadata",
+        args: z.object({
+            path: z.string().describe("Target path used to bind the result evidence"),
+        }),
+        options: z.object({
+            maxRecords: z
+                .number()
+                .int()
+                .min(1)
+                .max(20_000)
+                .default(5_000)
+                .describe("Maximum symbol records to inspect"),
+            snapshot: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("Load or update the local analysis snapshot"),
+            provider: providerSelectionOption,
+        }),
+        alias: { maxRecords: "max-records" },
+        run: async ({ args, options }) => logCliCommand(logger, "inspect-native-dispatch-metadata", () => runDirectAnalysis(args.path, "inspect_native_dispatch_metadata", { max_records: options.maxRecords }, directAnalysisOptions(logger, options.snapshot, options.provider))),
+    });
+};
+const registerNativeUiActionCommand = (cli, logger) => {
+    cli.command(CLI_COMMANDS.traceNativeUiAction, {
+        description: "Trace a compiled UI action selector to its native handler and direct callees",
+        args: z.object({
+            path: z.string().describe("Target path used to bind the result evidence"),
+            action: z
+                .string()
+                .min(1)
+                .describe("A unique compiled UI action selector or interface object ID"),
+        }),
+        options: z.object({
+            maxDepth: z
+                .number()
+                .int()
+                .min(0)
+                .max(32)
+                .default(8)
+                .describe("Maximum relationship depth"),
+            maxNodes: z
+                .number()
+                .int()
+                .min(1)
+                .max(2_000)
+                .default(250)
+                .describe("Maximum returned graph nodes"),
+            maxEdges: z
+                .number()
+                .int()
+                .min(1)
+                .max(5_000)
+                .default(500)
+                .describe("Maximum returned graph edges"),
+            provider: providerSelectionOption,
+        }),
+        alias: {
+            maxDepth: "max-depth",
+            maxNodes: "max-nodes",
+            maxEdges: "max-edges",
+        },
+        run: async ({ args, options }) => logCliCommand(logger, "trace-native-ui-action", () => runDirectAnalysis(args.path, "trace_native_ui_action", {
+            action: args.action,
+            max_depth: options.maxDepth,
+            max_nodes: options.maxNodes,
+            max_edges: options.maxEdges,
+        }, directAnalysisOptions(logger, undefined, options.provider))),
+    });
 };
 const registerCoreCommands = (cli, logger) => {
     const overviewOptions = z.object({
-        detail: z
-            .enum(["concise", "detailed"])
-            .default("concise")
-            .describe("Overview detail level"),
-        limit: z
-            .number()
-            .int()
-            .min(1)
-            .max(50)
-            .default(10)
-            .describe("Maximum overview items to return"),
         snapshot: z
             .string()
             .min(1)
@@ -35,18 +98,12 @@ const registerCoreCommands = (cli, logger) => {
             .describe("Load and update a local analysis snapshot"),
         provider: providerSelectionOption,
     });
-    const analyzeOptions = overviewOptions.extend({
-        approved: z
-            .boolean()
-            .default(false)
-            .describe("Approve static analysis when the path is a JavaScript directory or ASAR"),
-    });
     cli.command(CLI_COMMANDS.analyze, {
         description: "Get an overview of an app",
         args: z.object({
             path: z.string().describe("App, program, or analysis database path"),
         }),
-        options: analyzeOptions,
+        options: overviewOptions,
         run: ({ args, options }) => logCliCommand(logger, "analyze", () => runRoutedOverview(args.path, options, logger)),
     });
     cli.command(CLI_COMMANDS.inspect, {
@@ -55,7 +112,7 @@ const registerCoreCommands = (cli, logger) => {
             path: z.string().describe("App, program, or analysis database path"),
         }),
         options: overviewOptions,
-        run: ({ args, options }) => logCliCommand(logger, "inspect", () => runDirectAnalysis(args.path, "binary_overview", { detail: options.detail, limit: options.limit }, directAnalysisOptions(logger, options.snapshot, options.provider))),
+        run: ({ args, options }) => logCliCommand(logger, "inspect", () => runDirectAnalysis(args.path, "binary_overview", {}, directAnalysisOptions(logger, options.snapshot, options.provider))),
     });
     cli.command(CLI_COMMANDS.decompile, {
         description: "Read one part of an app as code",
@@ -80,9 +137,8 @@ const runRoutedOverview = async (path, options, logger) => {
         (await isJavaScriptApplicationPath(path)))
         return runCliJavaScriptApplicationAnalysis({
             input_path: resolve(path),
-            approved: options.approved,
         });
-    return runDirectAnalysis(path, "binary_overview", { detail: options.detail, limit: options.limit }, directAnalysisOptions(logger, options.snapshot, options.provider));
+    return runDirectAnalysis(path, "binary_overview", {}, directAnalysisOptions(logger, options.snapshot, options.provider));
 };
 const isJavaScriptApplicationPath = async (path) => {
     const lower = path.toLowerCase();
@@ -117,7 +173,7 @@ const registerXrefsCommand = (cli, logger) => {
 };
 const registerTraceCommand = (cli, logger) => {
     cli.command(CLI_COMMANDS.trace, {
-        description: "Trace a bounded literal feature through analyzed references",
+        description: "Trace a literal feature through analyzed references",
         args: z.object({
             path: z.string().describe("App or program path"),
             query: z.string().min(1).describe("Literal feature query"),
@@ -127,20 +183,6 @@ const registerTraceCommand = (cli, logger) => {
                 .boolean()
                 .default(false)
                 .describe("Match the query with exact letter case"),
-            limit: z
-                .number()
-                .int()
-                .min(1)
-                .max(100)
-                .default(20)
-                .describe("Maximum matching roots to examine"),
-            maxOperations: z
-                .number()
-                .int()
-                .min(1)
-                .max(100)
-                .default(20)
-                .describe("Maximum analysis operations in the trace"),
             snapshot: z
                 .string()
                 .min(1)
@@ -150,49 +192,21 @@ const registerTraceCommand = (cli, logger) => {
         }),
         alias: {
             caseSensitive: "case-sensitive",
-            maxOperations: "max-operations",
         },
         run: ({ args, options }) => logCliCommand(logger, "trace", () => runDirectAnalysis(args.path, "trace_feature", {
             query: args.query,
             case_sensitive: options.caseSensitive,
-            limit: options.limit,
-            max_operations: options.maxOperations,
         }, directAnalysisOptions(logger, options.snapshot, options.provider))),
     });
 };
 const registerFunctionCommand = (cli, logger) => {
     cli.command(CLI_COMMANDS.function, {
-        description: "Analyze one bounded function with evidence",
+        description: "Analyze one complete function with evidence",
         args: z.object({
             path: z.string().describe("App or program path"),
             address: z.string().describe("Procedure name or address"),
         }),
         options: z.object({
-            includeAssembly: z
-                .boolean()
-                .default(false)
-                .describe("Include bounded assembly instructions"),
-            limit: z
-                .number()
-                .int()
-                .min(1)
-                .max(500)
-                .default(100)
-                .describe("Maximum referenced items to return"),
-            maxPseudocodeChars: z
-                .number()
-                .int()
-                .min(1)
-                .max(100_000)
-                .default(20_000)
-                .describe("Maximum pseudocode characters to return"),
-            maxInstructions: z
-                .number()
-                .int()
-                .min(1)
-                .max(5_000)
-                .default(500)
-                .describe("Maximum assembly instructions to return"),
             snapshot: z
                 .string()
                 .min(1)
@@ -200,18 +214,7 @@ const registerFunctionCommand = (cli, logger) => {
                 .describe("Load and update a local analysis snapshot"),
             provider: providerSelectionOption,
         }),
-        alias: {
-            includeAssembly: "include-assembly",
-            maxPseudocodeChars: "max-pseudocode-chars",
-            maxInstructions: "max-instructions",
-        },
-        run: ({ args, options }) => logCliCommand(logger, "function", () => runDirectAnalysis(args.path, "analyze_function", {
-            procedure: args.address,
-            include_assembly: options.includeAssembly,
-            limit: options.limit,
-            max_pseudocode_chars: options.maxPseudocodeChars,
-            max_instructions: options.maxInstructions,
-        }, directAnalysisOptions(logger, options.snapshot, options.provider))),
+        run: ({ args, options }) => logCliCommand(logger, "function", () => runDirectAnalysis(args.path, "analyze_function", { procedure: args.address }, directAnalysisOptions(logger, options.snapshot, options.provider))),
     });
 };
 const registerNativeApiCommand = (cli, logger) => {
@@ -222,20 +225,6 @@ const registerNativeApiCommand = (cli, logger) => {
             address: z.string().describe("Procedure name or address"),
         }),
         options: z.object({
-            maxPseudocodeChars: z
-                .number()
-                .int()
-                .min(1)
-                .max(100_000)
-                .default(20_000)
-                .describe("Maximum pseudocode characters to inspect"),
-            maxInstructions: z
-                .number()
-                .int()
-                .min(1)
-                .max(5_000)
-                .default(500)
-                .describe("Maximum assembly instructions to inspect"),
             snapshot: z
                 .string()
                 .min(1)
@@ -243,39 +232,17 @@ const registerNativeApiCommand = (cli, logger) => {
                 .describe("Load and update a local analysis snapshot"),
             provider: providerSelectionOption,
         }),
-        alias: {
-            maxPseudocodeChars: "max-pseudocode-chars",
-            maxInstructions: "max-instructions",
-        },
-        run: ({ args, options }) => logCliCommand(logger, "inspect-native-api", () => runDirectAnalysis(args.path, "inspect_native_api", {
-            procedure: args.address,
-            max_pseudocode_chars: options.maxPseudocodeChars,
-            max_instructions: options.maxInstructions,
-        }, directAnalysisOptions(logger, options.snapshot, options.provider))),
+        run: ({ args, options }) => logCliCommand(logger, "inspect-native-api", () => runDirectAnalysis(args.path, "inspect_native_api", { procedure: args.address }, directAnalysisOptions(logger, options.snapshot, options.provider))),
     });
 };
 const registerInstructionsCommand = (cli, logger) => {
     cli.command(CLI_COMMANDS.instructions, {
-        description: "Read one bounded raw-instruction window without decompiling",
+        description: "Read every raw instruction without decompiling",
         args: z.object({
             path: z.string().describe("App or program path"),
             address: z.string().describe("Procedure name or address"),
         }),
         options: z.object({
-            offset: z
-                .number()
-                .int()
-                .min(0)
-                .max(100_000)
-                .default(0)
-                .describe("Zero-based instruction offset"),
-            limit: z
-                .number()
-                .int()
-                .min(1)
-                .max(500)
-                .default(64)
-                .describe("Maximum raw instructions to return"),
             snapshot: z
                 .string()
                 .min(1)
@@ -285,14 +252,12 @@ const registerInstructionsCommand = (cli, logger) => {
         }),
         run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.instructions, () => runDirectAnalysis(args.path, "read_function_instructions", {
             procedure: args.address,
-            offset: options.offset,
-            limit: options.limit,
         }, directAnalysisOptions(logger, options.snapshot, options.provider))),
     });
 };
 const registerSearchCommand = (cli, logger) => {
     cli.command(CLI_COMMANDS.search, {
-        description: "Search bounded analyzed strings or procedure names",
+        description: "Search every analyzed string or procedure name",
         args: z.object({
             path: z.string().describe("App or program path"),
             pattern: z.string().min(1).describe("Literal text or regex pattern"),
@@ -310,19 +275,6 @@ const registerSearchCommand = (cli, logger) => {
                 .boolean()
                 .default(false)
                 .describe("Match the pattern with exact letter case"),
-            offset: z
-                .number()
-                .int()
-                .min(0)
-                .default(0)
-                .describe("Zero-based matching-item offset"),
-            limit: z
-                .number()
-                .int()
-                .min(1)
-                .max(100)
-                .default(100)
-                .describe("Maximum matching items to return"),
             snapshot: z
                 .string()
                 .min(1)
@@ -335,8 +287,6 @@ const registerSearchCommand = (cli, logger) => {
             pattern: args.pattern,
             mode: options.mode,
             case_sensitive: options.caseSensitive,
-            offset: options.offset,
-            limit: options.limit,
         }, directAnalysisOptions(logger, options.snapshot, options.provider))),
     });
 };

package/dist/cli/javascriptApplicationAnalysis.js

@@ -1,16 +1,8 @@
 import { analyzeJavaScriptApplication } from "../application/JavaScriptApplicationService.js";
-import { loadConfiguredPermissionAuthority } from "../application/PermissionConfiguration.js";
-import { parseConfig } from "../config.js";
 import { projectAnalysisError } from "../domain/errors.js";
 /** Execute the shared one-shot CLI boundary for static JavaScript analysis. */
 export const runCliJavaScriptApplicationAnalysis = async (input) => {
-    const config = parseConfig(process.env);
-    if (!config.ok)
-        return cliError(config.error);
-    const authority = await loadConfiguredPermissionAuthority(config.value);
-    if (!authority.ok)
-        return cliError(authority.error);
-    const result = await analyzeJavaScriptApplication(authority.value, input);
+    const result = await analyzeJavaScriptApplication(input);
     return result.ok ? result.value : cliError(result.error);
 };
 const cliError = (error) => ({