rea-agents 2.0.0 → 2.2.0

package/dist/cli/setupCommands.js

@@ -0,0 +1,113 @@
+import { z } from "incur";
+import { runDoctor } from "../application/Doctor.js";
+import { runSetup, systemSetupHost } from "../application/Setup.js";
+import { runUninstall } from "../application/Uninstall.js";
+import { runUpgrade, systemUpgradeHost } from "../application/Upgrade.js";
+import { conciseSetupResult, confirmInteractiveSetup, renderInteractiveSetupResult, renderSetupProgress, } from "../cliSetup.js";
+import { PRODUCT_IDENTITY } from "../identity.js";
+import { logCliCommand } from "../cliLogging.js";
+import { createSystemDoctorHost } from "../doctorRuntime.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+export const registerSetupCommands = (cli, logger) => {
+    cli.command(CLI_COMMANDS.setup, {
+        description: "Install requirements and configure agents",
+        outputPolicy: "agent-only",
+        options: z.object({
+            yes: z
+                .boolean()
+                .default(false)
+                .describe("Approve user-owned setup actions without prompting"),
+            installHopper: z
+                .boolean()
+                .default(false)
+                .describe("Also approve Hopper installation with --yes"),
+            client: z
+                .array(z.enum([
+                "claude_code",
+                "claude_desktop",
+                "codex",
+                "cursor",
+                "gemini_cli",
+                "windsurf",
+            ]))
+                .default([])
+                .describe("Agent integration to configure; repeat for multiple agents"),
+            allDetected: z
+                .boolean()
+                .default(false)
+                .describe("Configure every detected supported agent"),
+            skill: z
+                .boolean()
+                .optional()
+                .describe("Override the bundled skill included with agent integrations"),
+            dryRun: z
+                .boolean()
+                .default(false)
+                .describe("Print the resolved plan without applying it"),
+            accessible: z
+                .boolean()
+                .default(false)
+                .describe("Use sequential accessible setup prompts"),
+        }),
+        alias: { yes: "y" },
+        run: ({ options, formatExplicit, agent }) => logCliCommand(logger, "setup", () => runSetupCommand({ options, formatExplicit, agent })),
+    });
+    cli.command(CLI_COMMANDS.doctor, {
+        description: "Check whether REA is ready",
+        options: z.object({
+            target: z.string().optional().describe("Optional app path to check"),
+        }),
+        run: ({ options }) => logCliCommand(logger, "doctor", () => runDoctor(options.target, createSystemDoctorHost())),
+    });
+    cli.command(CLI_COMMANDS.uninstall, {
+        description: "Remove REA-owned agent configuration and skill files",
+        options: z.object({
+            purgeData: z
+                .boolean()
+                .default(false)
+                .describe("Also remove REA caches and state"),
+        }),
+        alias: { purgeData: "purge-data" },
+        run: ({ options }) => logCliCommand(logger, "uninstall", () => runUninstall(options.purgeData)),
+    });
+    cli.command(CLI_COMMANDS.upgrade, {
+        description: "Upgrade a global npm installation to the latest REA release",
+        run: ({ formatExplicit }) => logCliCommand(logger, "upgrade", () => runUpgrade(PRODUCT_IDENTITY.packageVersion, systemUpgradeHost(), formatExplicit ? "structured" : "human")),
+    });
+};
+const runSetupCommand = async (input) => {
+    const { options } = input;
+    const interactive = !options.yes &&
+        !options.dryRun &&
+        !input.formatExplicit &&
+        process.stdin.isTTY === true &&
+        process.stderr.isTTY === true;
+    const hasExplicitScope = setupHasExplicitScope(options);
+    if (options.yes && !hasExplicitScope)
+        process.stderr.write("!  Implicit `rea setup --yes` scope is deprecated; use `--all-detected` to retain it.\n");
+    const agentIntegrationSelected = options.allDetected || options.client.length > 0;
+    const result = await runSetup({
+        approved: options.yes && !options.dryRun,
+        installHopper: options.installHopper,
+        structured: input.formatExplicit || options.dryRun,
+        proposeHopper: !hasExplicitScope || options.installHopper,
+        ...(!hasExplicitScope || options.allDetected
+            ? {}
+            : { clientIds: options.client }),
+        ...(!hasExplicitScope
+            ? {}
+            : {
+                installSkill: options.skill ?? agentIntegrationSelected,
+            }),
+        ...(interactive ? { onProgress: renderSetupProgress } : {}),
+    }, systemSetupHost(createSystemDoctorHost()), interactive
+        ? (actions) => confirmInteractiveSetup(actions, options.accessible)
+        : undefined);
+    if (interactive)
+        renderInteractiveSetupResult(result);
+    return input.formatExplicit ? result : conciseSetupResult(result);
+};
+const setupHasExplicitScope = (options) => options.allDetected ||
+    options.client.length > 0 ||
+    options.skill !== undefined ||
+    options.installHopper;

package/dist/cli/types.js

@@ -0,0 +1 @@
+import { Cli } from "incur";

package/dist/cli/utilityCommands.js

@@ -0,0 +1,122 @@
+import { z } from "incur";
+import { runProviderAnalysis, runSessionStatus, } from "../application/DirectAnalysis.js";
+import { importReferenceSource } from "../application/ReferenceSourceImport.js";
+import { projectReferenceSourceImportError } from "../application/ReferenceSourceImportTypes.js";
+import { loadConfiguredPermissionAuthority } from "../application/PermissionConfiguration.js";
+import { parseConfig } from "../config.js";
+import { AnalysisProtocolError, PermissionRequiredError, projectAnalysisError, } from "../domain/errors.js";
+import { PRODUCT_IDENTITY } from "../identity.js";
+import { logCliCommand } from "../cliLogging.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+export const registerUtilityCommands = (cli, logger) => {
+    registerCapabilityCommands(cli, logger);
+    registerNativeCommands(cli, logger);
+    registerReferenceSourceCommand(cli, logger);
+};
+const registerCapabilityCommands = (cli, logger) => {
+    for (const command of [
+        CLI_COMMANDS.capabilities,
+        CLI_COMMANDS.providers,
+    ]) {
+        cli.command(command, {
+            description: command === "capabilities"
+                ? "List provider capabilities and side effects"
+                : "List configured analysis providers",
+            run: () => logCliCommand(logger, command, () => runSessionStatus(logger)),
+        });
+    }
+};
+const registerNativeCommands = (cli, logger) => {
+    for (const [command, tool] of [
+        [CLI_COMMANDS.inspectMacho, "inspect_macho"],
+        [CLI_COMMANDS.inspectSignature, "inspect_signature"],
+        [CLI_COMMANDS.listArchitectures, "list_architectures"],
+    ]) {
+        cli.command(command, {
+            description: `Run ${tool} without launching Hopper`,
+            args: z.object({ path: z.string().describe("Mach-O or app path") }),
+            run: ({ args }) => logCliCommand(logger, command, () => runProviderAnalysis(args.path, tool, {}, logger)),
+        });
+    }
+    cli.command(CLI_COMMANDS.inspectPlist, {
+        description: "Parse app plist metadata without launching Hopper",
+        args: z.object({ path: z.string().describe("App or Mach-O path") }),
+        options: z.object({
+            relativePath: z
+                .string()
+                .default("Contents/Info.plist")
+                .describe("Plist path relative to the app root"),
+        }),
+        alias: { relativePath: "relative-path" },
+        run: ({ args, options }) => logCliCommand(logger, "inspect-plist", () => runProviderAnalysis(args.path, "inspect_plist", { relative_path: options.relativePath }, logger)),
+    });
+    cli.command(CLI_COMMANDS.demangleSwift, {
+        description: "Demangle a bounded Swift symbol batch without Hopper",
+        args: z.object({
+            path: z.string().describe("Artifact path used for evidence identity"),
+            symbols: z
+                .array(z.string().min(1))
+                .min(1)
+                .max(500)
+                .describe("Swift mangled symbols to demangle"),
+        }),
+        run: ({ args }) => logCliCommand(logger, "demangle-swift", () => runProviderAnalysis(args.path, "demangle_swift", { symbols: args.symbols }, logger)),
+    });
+};
+const registerReferenceSourceCommand = (cli, logger) => {
+    cli.command(CLI_COMMANDS.importReferenceSource, {
+        description: "Import a bounded source tree as historical reference only",
+        args: z.object({
+            root: z
+                .string()
+                .describe("Source root allowed by REA_REFERENCE_ROOTS_JSON"),
+        }),
+        run: ({ args }) => logCliCommand(logger, "import-reference-source", async () => {
+            const config = parseConfig(process.env);
+            if (!config.ok)
+                return {
+                    error: "Import failed",
+                    ...projectAnalysisError(config.error),
+                };
+            const authority = await loadConfiguredPermissionAuthority(config.value);
+            if (!authority.ok)
+                return {
+                    error: "Import failed",
+                    ...projectAnalysisError(authority.error),
+                };
+            const authorized = await authority.value.authorize({
+                capability: "reference_read",
+                roots: [args.root],
+                executables: [],
+                environment_names: [],
+                network: "none",
+                mount: false,
+                operation_identity: `import_reference_source:${args.root}`,
+            }, "read");
+            if (!authorized.ok) {
+                const error = authorized.error instanceof PermissionRequiredError
+                    ? authorized.error
+                    : new AnalysisProtocolError(authorized.error.message, {
+                        cause: authorized.error,
+                    });
+                return {
+                    error: "Import failed",
+                    ...projectAnalysisError(error),
+                };
+            }
+            const imported = await importReferenceSource({
+                root: args.root,
+                caller: "rea-cli",
+                policy: config.value.referenceSourcePolicy,
+                importer: PRODUCT_IDENTITY.packageName,
+                importerVersion: null,
+            });
+            return imported.ok
+                ? imported.value
+                : {
+                    error: "Import failed",
+                    ...projectReferenceSourceImportError(imported.error),
+                };
+        }),
+    });
+};