replicant-mcp 1.0.0

package/dist/cli/emulator.js

@@ -0,0 +1,181 @@
+import { Command } from "commander";
+import { EmulatorAdapter } from "../adapters/index.js";
+const adapter = new EmulatorAdapter();
+export function createEmulatorCommand() {
+    const emulator = new Command("emulator").description("Android emulator management");
+    // List subcommand
+    emulator
+        .command("list")
+        .description("List available AVDs and running emulators")
+        .option("--json", "Output as JSON")
+        .action(async (options) => {
+        try {
+            const result = await adapter.list();
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.log("Available AVDs:");
+                if (result.available.length === 0) {
+                    console.log("  (none)");
+                }
+                else {
+                    result.available.forEach((avd) => {
+                        const status = result.running.includes(avd.name) ? " [running]" : "";
+                        console.log(`  ${avd.name}${status}`);
+                        if (avd.skin) {
+                            console.log(`    Skin: ${avd.skin}`);
+                        }
+                        if (avd.target) {
+                            console.log(`    Target: ${avd.target}`);
+                        }
+                    });
+                }
+                console.log("\nRunning emulators:");
+                if (result.running.length === 0) {
+                    console.log("  (none)");
+                }
+                else {
+                    result.running.forEach((id) => {
+                        console.log(`  ${id}`);
+                    });
+                }
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Start subcommand
+    emulator
+        .command("start <avdName>")
+        .description("Start an emulator")
+        .option("--cold-boot", "Perform a cold boot (ignore snapshots)")
+        .option("--wipe-data", "Wipe user data before starting")
+        .option("--json", "Output as JSON")
+        .action(async (avdName, options) => {
+        try {
+            if (options.wipeData) {
+                console.log(`Wiping data for ${avdName}...`);
+                await adapter.wipe(avdName);
+            }
+            console.log(`Starting emulator ${avdName}...`);
+            const deviceId = await adapter.start(avdName);
+            if (options.json) {
+                console.log(JSON.stringify({ avdName, deviceId, status: "started" }, null, 2));
+            }
+            else {
+                console.log(`Emulator started: ${deviceId}`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Stop subcommand
+    emulator
+        .command("stop <deviceId>")
+        .description("Stop a running emulator")
+        .option("--json", "Output as JSON")
+        .action(async (deviceId, options) => {
+        try {
+            await adapter.kill(deviceId);
+            if (options.json) {
+                console.log(JSON.stringify({ deviceId, status: "stopped" }, null, 2));
+            }
+            else {
+                console.log(`Emulator stopped: ${deviceId}`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Snapshot subcommand
+    emulator
+        .command("snapshot <action>")
+        .description("Manage emulator snapshots (save, load, list, delete)")
+        .requiredOption("-d, --device <deviceId>", "Target emulator device ID")
+        .option("-n, --name <name>", "Snapshot name (required for save, load, delete)")
+        .option("--json", "Output as JSON")
+        .action(async (action, options) => {
+        try {
+            const deviceId = options.device;
+            const snapshotName = options.name;
+            switch (action) {
+                case "save":
+                    if (!snapshotName) {
+                        console.error("Error: --name is required for save action");
+                        process.exit(1);
+                    }
+                    await adapter.snapshotSave(deviceId, snapshotName);
+                    if (options.json) {
+                        console.log(JSON.stringify({ action: "save", deviceId, name: snapshotName, status: "saved" }, null, 2));
+                    }
+                    else {
+                        console.log(`Snapshot saved: ${snapshotName}`);
+                    }
+                    break;
+                case "load":
+                    if (!snapshotName) {
+                        console.error("Error: --name is required for load action");
+                        process.exit(1);
+                    }
+                    await adapter.snapshotLoad(deviceId, snapshotName);
+                    if (options.json) {
+                        console.log(JSON.stringify({ action: "load", deviceId, name: snapshotName, status: "loaded" }, null, 2));
+                    }
+                    else {
+                        console.log(`Snapshot loaded: ${snapshotName}`);
+                    }
+                    break;
+                case "list":
+                    const snapshots = await adapter.snapshotList(deviceId);
+                    if (options.json) {
+                        console.log(JSON.stringify({ deviceId, snapshots }, null, 2));
+                    }
+                    else {
+                        console.log(`Snapshots for ${deviceId}:`);
+                        if (snapshots.length === 0) {
+                            console.log("  (none)");
+                        }
+                        else {
+                            snapshots.forEach((name) => {
+                                console.log(`  ${name}`);
+                            });
+                        }
+                    }
+                    break;
+                case "delete":
+                    if (!snapshotName) {
+                        console.error("Error: --name is required for delete action");
+                        process.exit(1);
+                    }
+                    await adapter.snapshotDelete(deviceId, snapshotName);
+                    if (options.json) {
+                        console.log(JSON.stringify({ action: "delete", deviceId, name: snapshotName, status: "deleted" }, null, 2));
+                    }
+                    else {
+                        console.log(`Snapshot deleted: ${snapshotName}`);
+                    }
+                    break;
+                default:
+                    console.error(`Unknown action: ${action}`);
+                    console.error("Valid actions: save, load, list, delete");
+                    process.exit(1);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    return emulator;
+}

package/dist/cli/formatter.d.ts

@@ -0,0 +1,52 @@
+export interface BuildSuccessData {
+    duration: string;
+    apkPath?: string;
+    apkSize?: string;
+    warnings: number;
+    cacheId: string;
+}
+export interface BuildFailureData {
+    duration: string;
+    error: string;
+    cacheId: string;
+}
+export interface TestResultsData {
+    passed: number;
+    failed: number;
+    skipped: number;
+    duration: string;
+    failures: string[];
+    cacheId: string;
+}
+export interface UiElement {
+    index: number;
+    type: string;
+    text?: string;
+    hint?: string;
+    focused?: boolean;
+}
+export interface UiDumpData {
+    screenName: string;
+    elements: UiElement[];
+}
+export interface LogcatData {
+    level: string;
+    count: number;
+    lines: string[];
+    cacheId: string;
+}
+export interface DeviceInfo {
+    id: string;
+    name: string;
+    state: string;
+    selected: boolean;
+}
+export interface DeviceListData {
+    devices: DeviceInfo[];
+}
+export declare function formatBuildSuccess(data: BuildSuccessData): string;
+export declare function formatBuildFailure(data: BuildFailureData): string;
+export declare function formatTestResults(data: TestResultsData): string;
+export declare function formatUiDump(data: UiDumpData): string;
+export declare function formatLogcat(data: LogcatData): string;
+export declare function formatDeviceList(data: DeviceListData): string;

package/dist/cli/formatter.js

@@ -0,0 +1,68 @@
+export function formatBuildSuccess(data) {
+    const lines = [`✓ Build successful (${data.duration})`];
+    if (data.apkPath) {
+        const filename = data.apkPath.split("/").pop();
+        lines.push(`  APK: ${filename}${data.apkSize ? ` (${data.apkSize})` : ""}`);
+    }
+    if (data.warnings > 0) {
+        lines.push(`  Warnings: ${data.warnings}`);
+    }
+    lines.push(`  Cache ID: ${data.cacheId}`);
+    return lines.join("\n");
+}
+export function formatBuildFailure(data) {
+    const lines = [
+        `✗ Build failed (${data.duration})`,
+        "",
+        `  Error: ${data.error}`,
+        "",
+        `  Cache ID: ${data.cacheId}`,
+        `  Run: replicant gradle details ${data.cacheId} --errors`,
+    ];
+    return lines.join("\n");
+}
+export function formatTestResults(data) {
+    const status = data.failed === 0 ? "✓" : "✗";
+    const lines = [
+        `${status} ${data.passed} passed, ${data.failed} failed, ${data.skipped} skipped (${data.duration})`,
+    ];
+    if (data.failures.length > 0) {
+        lines.push("");
+        lines.push("Failed:");
+        data.failures.forEach(f => lines.push(`  • ${f}`));
+    }
+    lines.push("");
+    lines.push(`Cache ID: ${data.cacheId}`);
+    return lines.join("\n");
+}
+export function formatUiDump(data) {
+    const lines = [`Screen: ${data.screenName}`];
+    data.elements.forEach((el, i) => {
+        const prefix = i === data.elements.length - 1 ? "└─" : "├─";
+        let desc = el.text || el.hint || "";
+        if (el.focused)
+            desc += " (focused)";
+        lines.push(`${prefix} [${el.index}] ${el.type}${desc ? ` "${desc}"` : ""}`);
+    });
+    lines.push("");
+    lines.push(`${data.elements.length} interactive elements`);
+    return lines.join("\n");
+}
+export function formatLogcat(data) {
+    const lines = [`${data.count} ${data.level}s in recent logs:`, ""];
+    data.lines.forEach(line => lines.push(line));
+    lines.push("");
+    lines.push(`Cache ID: ${data.cacheId}`);
+    return lines.join("\n");
+}
+export function formatDeviceList(data) {
+    if (data.devices.length === 0) {
+        return "No devices connected";
+    }
+    const lines = ["Devices:"];
+    data.devices.forEach(device => {
+        const indicator = device.selected ? "→ " : "  ";
+        lines.push(`${indicator}${device.id} (${device.name}) [${device.state}]`);
+    });
+    return lines.join("\n");
+}

package/dist/cli/gradle.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createGradleCommand(): Command;

package/dist/cli/gradle.js

@@ -0,0 +1,192 @@
+import { Command } from "commander";
+import { GradleAdapter } from "../adapters/index.js";
+import { CacheManager } from "../services/index.js";
+import { formatBuildSuccess, formatBuildFailure, formatTestResults, } from "./formatter.js";
+import { CACHE_TTLS, ReplicantError } from "../types/index.js";
+const adapter = new GradleAdapter();
+const cache = new CacheManager();
+export function createGradleCommand() {
+    const gradle = new Command("gradle").description("Build and test Android apps");
+    // Build subcommand
+    gradle
+        .command("build")
+        .description("Build the Android project")
+        .option("-o, --operation <type>", "Build operation (assembleDebug, assembleRelease, bundle)", "assembleDebug")
+        .option("-m, --module <name>", "Target module")
+        .option("-f, --flavor <name>", "Build flavor")
+        .option("--json", "Output full JSON result")
+        .action(async (options) => {
+        try {
+            const startTime = Date.now();
+            const { result, fullOutput } = await adapter.build(options.operation, options.module, options.flavor);
+            const duration = `${((Date.now() - startTime) / 1000).toFixed(1)}s`;
+            const cacheId = cache.generateId("build");
+            cache.set(cacheId, { result, fullOutput }, "build", CACHE_TTLS.BUILD_OUTPUT);
+            if (options.json) {
+                console.log(JSON.stringify({ result, cacheId }, null, 2));
+            }
+            else {
+                console.log(formatBuildSuccess({
+                    duration,
+                    apkPath: result.apkPath,
+                    warnings: result.warnings,
+                    cacheId,
+                }));
+            }
+        }
+        catch (error) {
+            const duration = "0s";
+            const cacheId = cache.generateId("build");
+            if (error instanceof ReplicantError && error.details?.buildResult) {
+                cache.set(cacheId, { result: error.details.buildResult, fullOutput: "" }, "build", CACHE_TTLS.BUILD_OUTPUT);
+                if (options.json) {
+                    console.log(JSON.stringify({ error: error.message, result: error.details.buildResult, cacheId }, null, 2));
+                }
+                else {
+                    console.log(formatBuildFailure({
+                        duration,
+                        error: error.message,
+                        cacheId,
+                    }));
+                }
+            }
+            else {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.error(`Error: ${errorMessage}`);
+            }
+            process.exit(1);
+        }
+    });
+    // Test subcommand
+    gradle
+        .command("test")
+        .description("Run tests")
+        .option("-o, --operation <type>", "Test type (unitTest, connectedTest)", "unitTest")
+        .option("-m, --module <name>", "Target module")
+        .option("-f, --filter <pattern>", "Test filter pattern")
+        .option("--json", "Output full JSON result")
+        .action(async (options) => {
+        try {
+            const startTime = Date.now();
+            const { result, fullOutput } = await adapter.test(options.operation, options.module, options.filter);
+            const duration = `${((Date.now() - startTime) / 1000).toFixed(1)}s`;
+            const cacheId = cache.generateId("test");
+            cache.set(cacheId, { result, fullOutput }, "test", CACHE_TTLS.TEST_RESULTS);
+            if (options.json) {
+                console.log(JSON.stringify({ result, cacheId }, null, 2));
+            }
+            else {
+                console.log(formatTestResults({
+                    passed: result.passed,
+                    failed: result.failed,
+                    skipped: result.skipped,
+                    duration,
+                    failures: result.failures.map((f) => `${f.test}: ${f.message}`),
+                    cacheId,
+                }));
+            }
+            if (result.failed > 0) {
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // List subcommand
+    gradle
+        .command("list")
+        .description("List modules, variants, or tasks")
+        .option("-t, --type <type>", "What to list (modules, variants, tasks)", "modules")
+        .option("-m, --module <name>", "Target module (for variants/tasks)")
+        .option("--json", "Output as JSON")
+        .action(async (options) => {
+        try {
+            let result;
+            switch (options.type) {
+                case "modules":
+                    result = await adapter.listModules();
+                    break;
+                case "variants":
+                    result = await adapter.listVariants(options.module);
+                    break;
+                case "tasks":
+                    result = await adapter.listTasks(options.module);
+                    break;
+                default:
+                    console.error(`Unknown list type: ${options.type}`);
+                    process.exit(1);
+            }
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                if (options.type === "variants") {
+                    const variants = result;
+                    console.log("Variants:");
+                    variants.forEach((v) => {
+                        const flavors = v.flavors.length > 0 ? ` (flavors: ${v.flavors.join(", ")})` : "";
+                        console.log(`  ${v.name} [${v.buildType}]${flavors}`);
+                    });
+                }
+                else {
+                    const items = result;
+                    console.log(`${options.type.charAt(0).toUpperCase() + options.type.slice(1)}:`);
+                    items.forEach((item) => console.log(`  ${item}`));
+                }
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    // Details subcommand
+    gradle
+        .command("details <cacheId>")
+        .description("Get details from a cached build/test result")
+        .option("--errors", "Show only errors")
+        .option("--warnings", "Show only warnings")
+        .option("--json", "Output as JSON")
+        .action((cacheId, options) => {
+        try {
+            const entry = cache.get(cacheId);
+            if (!entry) {
+                console.error(`Cache entry not found: ${cacheId}`);
+                console.error("Cache entries expire after 30 minutes.");
+                process.exit(1);
+            }
+            if (options.json) {
+                console.log(JSON.stringify(entry.data, null, 2));
+                return;
+            }
+            const output = entry.data.fullOutput;
+            if (options.errors) {
+                const errorLines = output
+                    .split("\n")
+                    .filter((line) => /error:|FAILED|Exception/i.test(line));
+                console.log("Errors:");
+                errorLines.forEach((line) => console.log(line));
+            }
+            else if (options.warnings) {
+                const warningLines = output
+                    .split("\n")
+                    .filter((line) => /warning:|warn:/i.test(line));
+                console.log("Warnings:");
+                warningLines.forEach((line) => console.log(line));
+            }
+            else {
+                console.log(output);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+    return gradle;
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,6 @@
+export { createGradleCommand } from "./gradle.js";
+export { createAdbCommand } from "./adb.js";
+export { createEmulatorCommand } from "./emulator.js";
+export { createUiCommand } from "./ui.js";
+export { createCacheCommand } from "./cache.js";
+export * from "./formatter.js";

package/dist/cli/index.js

@@ -0,0 +1,6 @@
+export { createGradleCommand } from "./gradle.js";
+export { createAdbCommand } from "./adb.js";
+export { createEmulatorCommand } from "./emulator.js";
+export { createUiCommand } from "./ui.js";
+export { createCacheCommand } from "./cache.js";
+export * from "./formatter.js";

package/dist/cli/ui.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createUiCommand(): Command;