replicant-mcp 1.5.0 → 1.6.0

package/dist/adapters/emulator.d.ts

@@ -10,6 +10,8 @@ export declare class EmulatorAdapter {
     list(): Promise<EmulatorListResult>;
     create(name: string, device: string, systemImage: string): Promise<void>;
     start(avdName: string): Promise<string>;
+    private getRunningEmulatorIds;
+    private getAvdName;
     kill(emulatorId: string): Promise<void>;
     wipe(avdName: string): Promise<void>;
     snapshotSave(emulatorId: string, name: string): Promise<void>;

package/dist/adapters/emulator.js

@@ -29,6 +29,8 @@ export class EmulatorAdapter {
         }
     }
     async start(avdName) {
+        // Snapshot existing emulators before starting a new one
+        const existingIds = await this.getRunningEmulatorIds();
         // Start emulator in background - don't wait for it
         // Returns immediately, emulator boots in background
         this.runner.runEmulator([
@@ -40,13 +42,41 @@ export class EmulatorAdapter {
         });
         // Give it a moment to register
         await new Promise((r) => setTimeout(r, 2000));
-        // Find the new emulator ID
+        // Find the NEW emulator by diffing against pre-existing ones
+        const currentIds = await this.getRunningEmulatorIds();
+        const newIds = currentIds.filter((id) => !existingIds.includes(id));
+        if (newIds.length === 1) {
+            return newIds[0];
+        }
+        // Ambiguous or no new emulator — fall back to matching by AVD name
+        for (const id of currentIds) {
+            if (existingIds.includes(id))
+                continue;
+            const name = await this.getAvdName(id);
+            if (name === avdName)
+                return id;
+        }
+        // Last resort: check all current emulators by AVD name
+        for (const id of currentIds) {
+            const name = await this.getAvdName(id);
+            if (name === avdName)
+                return id;
+        }
+        throw new ReplicantError(ErrorCode.EMULATOR_START_FAILED, `Emulator ${avdName} failed to start`, "Check the AVD name and try again");
+    }
+    async getRunningEmulatorIds() {
         const result = await this.runner.runAdb(["devices"]);
-        const match = result.stdout.match(/emulator-\d+/);
-        if (!match) {
-            throw new ReplicantError(ErrorCode.EMULATOR_START_FAILED, `Emulator ${avdName} failed to start`, "Check the AVD name and try again");
+        const matches = result.stdout.match(/emulator-\d+/g);
+        return matches ?? [];
+    }
+    async getAvdName(emulatorId) {
+        try {
+            const result = await this.runner.runAdb(["-s", emulatorId, "emu", "avd", "name"]);
+            return result.stdout.trim().split("\n")[0].trim();
+        }
+        catch {
+            return "";
         }
-        return match[0];
     }
     async kill(emulatorId) {
         await this.runner.runAdb(["-s", emulatorId, "emu", "kill"]);

package/dist/parsers/adb-output.js

@@ -9,7 +9,11 @@ export function parseDeviceList(output) {
         if (!id)
             continue;
         const type = id.startsWith("emulator") ? "emulator" : "physical";
-        const status = statusStr === "device" ? "online" : "offline";
+        const status = statusStr === "device"
+            ? "online"
+            : statusStr === "unauthorized"
+                ? "unauthorized"
+                : "offline";
         devices.push({
             id,
             type,

package/dist/server.js

@@ -6,7 +6,7 @@ import { CacheManager, DeviceStateManager, ProcessRunner, EnvironmentService, Co
 import { AdbAdapter, EmulatorAdapter, GradleAdapter, UiAutomatorAdapter } from "./adapters/index.js";
 import { ReplicantError, ErrorCode } from "./types/index.js";
 import { VERSION } from "./version.js";
-import { cacheInputSchema, cacheToolDefinition, handleCacheTool, rtfmInputSchema, rtfmToolDefinition, handleRtfmTool, adbDeviceInputSchema, adbDeviceToolDefinition, handleAdbDeviceTool, adbAppInputSchema, adbAppToolDefinition, handleAdbAppTool, adbLogcatInputSchema, adbLogcatToolDefinition, handleAdbLogcatTool, adbShellInputSchema, adbShellToolDefinition, handleAdbShellTool, emulatorDeviceInputSchema, emulatorDeviceToolDefinition, handleEmulatorDeviceTool, gradleBuildInputSchema, gradleBuildToolDefinition, handleGradleBuildTool, gradleTestInputSchema, gradleTestToolDefinition, handleGradleTestTool, gradleListInputSchema, gradleListToolDefinition, handleGradleListTool, gradleGetDetailsInputSchema, gradleGetDetailsToolDefinition, handleGradleGetDetailsTool, uiInputSchema, uiToolDefinition, handleUiTool, } from "./tools/index.js";
+import { cacheInputSchema, cacheToolDefinition, handleCacheTool, rtfmInputSchema, rtfmToolDefinition, handleRtfmTool, adbDeviceInputSchema, adbDeviceToolDefinition, handleAdbDeviceTool, adbAppInputSchema, adbAppToolDefinition, handleAdbAppTool, adbLogcatInputSchema, adbLogcatToolDefinition, handleAdbLogcatTool, adbShellInputSchema, adbShellToolDefinition, handleAdbShellTool, emulatorDeviceInputSchema, emulatorDeviceToolDefinition, handleEmulatorDeviceTool, gradleBuildInputSchema, gradleBuildToolDefinition, handleGradleBuildTool, gradleTestInputSchema, gradleTestToolDefinition, handleGradleTestTool, gradleListInputSchema, gradleListToolDefinition, handleGradleListTool, gradleGetDetailsInputSchema, gradleGetDetailsToolDefinition, handleGradleGetDetailsTool, uiQueryInputSchema, uiQueryToolDefinition, handleUiQueryTool, uiActionInputSchema, uiActionToolDefinition, handleUiActionTool, uiCaptureInputSchema, uiCaptureToolDefinition, handleUiCaptureTool, } from "./tools/index.js";
 export function createServerContext() {
     const environment = new EnvironmentService();
     const processRunner = new ProcessRunner(environment);
@@ -36,7 +36,9 @@ const toolDefinitions = [
     gradleTestToolDefinition,
     gradleListToolDefinition,
     gradleGetDetailsToolDefinition,
-    uiToolDefinition,
+    uiQueryToolDefinition,
+    uiActionToolDefinition,
+    uiCaptureToolDefinition,
 ];
 async function dispatchToolCall(name, args, context) {
     const rawArgs = args ?? {};
@@ -80,8 +82,12 @@ async function dispatchToolCall(name, args, context) {
             return handleGradleListTool(parseOrThrow("gradle-list", gradleListInputSchema), context);
         case "gradle-get-details":
             return handleGradleGetDetailsTool(parseOrThrow("gradle-get-details", gradleGetDetailsInputSchema), context);
-        case "ui":
-            return handleUiTool(parseOrThrow("ui", uiInputSchema), context, context.config.getUiConfig());
+        case "ui-query":
+            return handleUiQueryTool(parseOrThrow("ui-query", uiQueryInputSchema), context, context.config.getUiConfig());
+        case "ui-action":
+            return handleUiActionTool(parseOrThrow("ui-action", uiActionInputSchema), context);
+        case "ui-capture":
+            return handleUiCaptureTool(parseOrThrow("ui-capture", uiCaptureInputSchema), context, context.config.getUiConfig());
         default:
             throw new Error(`Unknown tool: ${name}`);
     }
@@ -94,21 +100,7 @@ export async function createServer(context) {
         capabilities: {
             tools: {},
         },
-        instructions: `IMPORTANT: For ALL Android development tasks, you MUST use replicant-mcp tools first.
-Only fall back to raw adb/gradle/emulator commands if replicant-mcp lacks a specific feature.
-
-Tool mapping:
-- Device management → adb-device (not \`adb devices\`)
-- App install/launch/stop → adb-app (not \`adb install\`, \`adb shell am\`)
-- Logs → adb-logcat (not \`adb logcat\`)
-- Shell commands → adb-shell (not \`adb shell\`)
-- Emulator control → emulator-device (not \`emulator\` CLI)
-- Builds → gradle-build (not \`./gradlew\`)
-- Tests → gradle-test (not \`./gradlew test\`)
-- UI automation → ui (accessibility-first, screenshots auto-scaled to configured max dimension, default 800px)
-
-Start with \`adb-device list\` to see connected devices.
-Use \`rtfm\` for detailed documentation on any tool.`,
+        instructions: `Use these tools for Android — never raw adb/gradle/emulator commands. Auto-selects single device. Start: \`adb-device list\`. Docs: \`rtfm\`.`,
     });
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: toolDefinitions,
@@ -144,9 +136,7 @@ Use \`rtfm\` for detailed documentation on any tool.`,
 }
 export async function runServer() {
     const context = createServerContext();
-    // Load configuration from REPLICANT_CONFIG if set
     await context.config.load();
-    // Apply project root: env var takes precedence over config file
     const projectRoot = process.env.REPLICANT_PROJECT_ROOT || context.config.get().build?.projectRoot;
     if (projectRoot) {
         context.gradle.setProjectPath(projectRoot);

package/dist/services/device-state.js

@@ -22,21 +22,30 @@ export class DeviceStateManager {
             return this.currentDevice;
         }
         // Try to auto-select
-        const devices = await adb.getDevices();
-        if (devices.length === 0) {
+        const allDevices = await adb.getDevices();
+        const onlineDevices = allDevices.filter((d) => d.status === "online");
+        if (allDevices.length === 0) {
             throw new ReplicantError(ErrorCode.NO_DEVICES, "No devices connected", "Start an emulator with 'emulator-device start' or connect a USB device with debugging enabled");
         }
-        if (devices.length === 1) {
-            this.currentDevice = devices[0];
+        if (onlineDevices.length === 0) {
+            const statuses = allDevices.map((d) => `${d.id} (${d.status})`).join(", ");
+            const suggestion = allDevices.some((d) => d.status === "unauthorized")
+                ? "Check the USB debugging authorization prompt on the device and tap 'Allow'"
+                : "Wait for the device to come online or restart it with 'adb reconnect'";
+            throw new ReplicantError(ErrorCode.DEVICE_OFFLINE, `No online devices available. Found: ${statuses}`, suggestion);
+        }
+        if (onlineDevices.length === 1) {
+            this.currentDevice = onlineDevices[0];
             return this.currentDevice;
         }
-        // Multiple devices - user must choose
-        const deviceList = devices.map((d) => d.id).join(", ");
-        throw new ReplicantError(ErrorCode.MULTIPLE_DEVICES, `${devices.length} devices connected: ${deviceList}`, `Call adb-device({ operation: 'select', deviceId: '...' }) to choose one`);
+        // Multiple online devices - user must choose
+        const deviceList = onlineDevices.map((d) => d.id).join(", ");
+        throw new ReplicantError(ErrorCode.MULTIPLE_DEVICES, `${onlineDevices.length} devices connected: ${deviceList}`, `Call adb-device({ operation: 'select', deviceId: '...' }) to choose one`);
     }
     autoSelectIfSingle(devices) {
-        if (devices.length === 1 && !this.currentDevice) {
-            this.currentDevice = devices[0];
+        const onlineDevices = devices.filter((d) => d.status === "online");
+        if (onlineDevices.length === 1 && !this.currentDevice) {
+            this.currentDevice = onlineDevices[0];
             return true;
         }
         return false;

package/dist/services/process-runner.js

@@ -24,7 +24,7 @@ const BLOCKED_SHELL_PATTERNS = [
 export class ProcessRunner {
     environment;
     defaultTimeoutMs = 30_000;
-    maxTimeoutMs = 120_000;
+    maxTimeoutMs = 600_000;
     constructor(environment) {
         this.environment = environment;
     }

package/dist/tools/adb-app.d.ts

@@ -33,7 +33,6 @@ export declare const adbAppToolDefinition: {
             };
             packageName: {
                 type: string;
-                description: string;
             };
             limit: {
                 type: string;

package/dist/tools/adb-app.js

@@ -4,7 +4,6 @@ export const adbAppInputSchema = z.object({
     operation: z.enum(["install", "uninstall", "launch", "stop", "clear-data", "list"]),
     apkPath: z.string().optional(),
     packageName: z.string().optional(),
-    // List operation options
     limit: z.number().min(1).max(100).optional(),
     filter: z.string().optional(),
     offset: z.number().min(0).optional(),
@@ -85,7 +84,7 @@ export async function handleAdbAppTool(input, context) {
 }
 export const adbAppToolDefinition = {
     name: "adb-app",
-    description: "Manage applications. Auto-selects device if only one connected. Operations: install, uninstall, launch, stop, clear-data, list.",
+    description: "Manage applications.",
     inputSchema: {
         type: "object",
         properties: {
@@ -93,19 +92,19 @@ export const adbAppToolDefinition = {
                 type: "string",
                 enum: ["install", "uninstall", "launch", "stop", "clear-data", "list"],
             },
-            apkPath: { type: "string", description: "Path to APK file (for install)" },
-            packageName: { type: "string", description: "Package name (for other operations)" },
+            apkPath: { type: "string", description: "APK path" },
+            packageName: { type: "string" },
             limit: {
                 type: "number",
-                description: "Max packages to return (default: 20, max: 100). For list operation.",
+                description: "Default: 20, max: 100",
             },
             filter: {
                 type: "string",
-                description: "Filter packages by name (case-insensitive contains). For list operation.",
+                description: "Filter by name (case-insensitive)",
             },
             offset: {
                 type: "number",
-                description: "Skip first N packages for pagination. For list operation.",
+                description: "Pagination offset",
             },
         },
         required: ["operation"],

package/dist/tools/adb-device.d.ts

@@ -24,7 +24,6 @@ export declare const adbDeviceToolDefinition: {
             };
             deviceId: {
                 type: string;
-                description: string;
             };
         };
         required: string[];

package/dist/tools/adb-device.js

@@ -26,19 +26,19 @@ async function handleSelect(input, context) {
     context.deviceState.setCurrentDevice(device);
     return { selected: device };
 }
+async function resolveDeviceId(input, context) {
+    if (input.deviceId)
+        return input.deviceId;
+    const device = await context.deviceState.ensureDevice(context.adb);
+    return device.id;
+}
 async function handleWait(input, context) {
-    const device = input.deviceId
-        ? { id: input.deviceId }
-        : await context.deviceState.ensureDevice(context.adb);
-    const deviceId = device.id;
+    const deviceId = await resolveDeviceId(input, context);
     await context.adb.waitForDevice(deviceId);
     return { status: "device ready", deviceId };
 }
 async function handleProperties(input, context) {
-    const device = input.deviceId
-        ? { id: input.deviceId }
-        : await context.deviceState.ensureDevice(context.adb);
-    const deviceId = device.id;
+    const deviceId = await resolveDeviceId(input, context);
     const props = await context.adb.getProperties(deviceId);
     const cacheId = context.cache.generateId("device-props");
     context.cache.set(cacheId, { deviceId, properties: props }, "device-props", CACHE_TTLS.DEVICE_PROPERTIES);
@@ -110,7 +110,7 @@ export async function handleAdbDeviceTool(input, context) {
 }
 export const adbDeviceToolDefinition = {
     name: "adb-device",
-    description: "Manage device connections. Operations: list, select, wait, properties, health-check.",
+    description: "Manage device connections.",
     inputSchema: {
         type: "object",
         properties: {
@@ -118,7 +118,7 @@ export const adbDeviceToolDefinition = {
                 type: "string",
                 enum: ["list", "select", "wait", "properties", "health-check"],
             },
-            deviceId: { type: "string", description: "Device ID for select/wait/properties" },
+            deviceId: { type: "string" },
         },
         required: ["operation"],
     },

package/dist/tools/adb-logcat.d.ts

@@ -28,14 +28,12 @@ export declare const adbLogcatToolDefinition: {
             };
             package: {
                 type: string;
-                description: string;
             };
             tags: {
                 type: string;
                 items: {
                     type: string;
                 };
-                description: string;
             };
             level: {
                 type: string;
@@ -43,7 +41,6 @@ export declare const adbLogcatToolDefinition: {
             };
             rawFilter: {
                 type: string;
-                description: string;
             };
             since: {
                 type: string;

package/dist/tools/adb-logcat.js

@@ -8,40 +8,36 @@ export const adbLogcatInputSchema = z.object({
     rawFilter: z.string().optional(),
     since: z.string().optional(),
 });
+function buildLogcatFilter(input) {
+    if (input.rawFilter)
+        return input.rawFilter;
+    if (!input.tags && !input.level)
+        return undefined;
+    const levelMap = {
+        verbose: "V",
+        debug: "D",
+        info: "I",
+        warn: "W",
+        error: "E",
+    };
+    const levelChar = input.level ? levelMap[input.level] : "V";
+    if (input.tags) {
+        return input.tags.map((tag) => `${tag}:${levelChar}`).join(" ") + " *:S";
+    }
+    return `*:${levelChar}`;
+}
 export async function handleAdbLogcatTool(input, context) {
     const device = await context.deviceState.ensureDevice(context.adb);
     const deviceId = device.id;
-    // Build filter string
-    let filter = "";
-    if (input.rawFilter) {
-        filter = input.rawFilter;
-    }
-    else if (input.tags || input.level) {
-        const levelMap = {
-            verbose: "V",
-            debug: "D",
-            info: "I",
-            warn: "W",
-            error: "E",
-        };
-        const levelChar = input.level ? levelMap[input.level] : "V";
-        if (input.tags) {
-            filter = input.tags.map((tag) => `${tag}:${levelChar}`).join(" ") + " *:S";
-        }
-        else {
-            filter = `*:${levelChar}`;
-        }
-    }
+    const filter = buildLogcatFilter(input);
     const output = await context.adb.logcat(deviceId, {
         lines: input.lines,
-        filter: filter || undefined,
+        filter,
         since: input.since,
         package: input.package,
     });
-    // Cache the full output and return a summary
     const logId = context.cache.generateId("logcat");
     context.cache.set(logId, { output, deviceId, filter }, "logcat", CACHE_TTLS.LOGCAT);
-    // Parse log lines
     const lines = output.split("\n").filter(Boolean);
     const errorCount = lines.filter((l) => l.includes(" E ")).length;
     const warnCount = lines.filter((l) => l.includes(" W ")).length;
@@ -58,16 +54,16 @@ export async function handleAdbLogcatTool(input, context) {
 }
 export const adbLogcatToolDefinition = {
     name: "adb-logcat",
-    description: "Read device logs. Auto-selects device if only one connected. Returns summary with logId for full output.",
+    description: "Read device logs. Returns summary with logId.",
     inputSchema: {
         type: "object",
         properties: {
-            lines: { type: "number", description: "Number of lines (default: 100)" },
-            package: { type: "string", description: "Filter by package name" },
-            tags: { type: "array", items: { type: "string" }, description: "Filter by log tags" },
+            lines: { type: "number", description: "Default: 100" },
+            package: { type: "string" },
+            tags: { type: "array", items: { type: "string" } },
             level: { type: "string", enum: ["verbose", "debug", "info", "warn", "error"] },
-            rawFilter: { type: "string", description: "Raw logcat filter string" },
-            since: { type: "string", description: "Time filter in adb logcat -T format (e.g., '01-20 15:30:00.000')" },
+            rawFilter: { type: "string" },
+            since: { type: "string", description: "e.g., '01-20 15:30:00.000'" },
         },
     },
 };

package/dist/tools/adb-shell.d.ts

@@ -17,7 +17,6 @@ export declare const adbShellToolDefinition: {
         properties: {
             command: {
                 type: string;
-                description: string;
             };
             timeout: {
                 type: string;

package/dist/tools/adb-shell.js

@@ -9,7 +9,9 @@ export const adbShellInputSchema = z.object({
 export async function handleAdbShellTool(input, context) {
     const device = await context.deviceState.ensureDevice(context.adb);
     const deviceId = device.id;
-    const result = await context.adb.shell(deviceId, input.command, input.timeout);
+    const ADB_SHELL_MAX_TIMEOUT = 120_000;
+    const timeout = input.timeout ? Math.min(input.timeout, ADB_SHELL_MAX_TIMEOUT) : undefined;
+    const result = await context.adb.shell(deviceId, input.command, timeout);
     if (input.summaryOnly) {
         const previewChars = input.previewChars ?? 200;
         return {
@@ -41,15 +43,15 @@ export async function handleAdbShellTool(input, context) {
 }
 export const adbShellToolDefinition = {
     name: "adb-shell",
-    description: "Execute shell commands with safety guards. Auto-selects device if only one connected. Dangerous commands are blocked.",
+    description: "Execute shell commands with safety guards.",
     inputSchema: {
         type: "object",
         properties: {
-            command: { type: "string", description: "Shell command to execute" },
-            timeout: { type: "number", description: "Timeout in ms (default: 30s, max: 120s)" },
-            maxChars: { type: "number", description: "Truncate stdout/stderr to at most this many characters" },
-            summaryOnly: { type: "boolean", description: "Return only compact previews and counts, omitting full stdout/stderr" },
-            previewChars: { type: "number", description: "For summaryOnly: preview length in characters (default: 200)" },
+            command: { type: "string" },
+            timeout: { type: "number", description: "ms, default: 30000, max: 120000" },
+            maxChars: { type: "number", description: "Truncate output to N chars" },
+            summaryOnly: { type: "boolean", description: "Compact preview only" },
+            previewChars: { type: "number", description: "Preview length (default: 200)" },
         },
         required: ["command"],
     },

package/dist/tools/cache.js

@@ -35,7 +35,7 @@ export async function handleCacheTool(input, cache) {
 }
 export const cacheToolDefinition = {
     name: "cache",
-    description: "Manage the cache. Operations: get-stats, clear, get-config, set-config. See rtfm for details.",
+    description: "Manage the cache. See rtfm for details.",
     inputSchema: {
         type: "object",
         properties: {
@@ -43,7 +43,7 @@ export const cacheToolDefinition = {
                 type: "string",
                 enum: ["get-stats", "clear", "get-config", "set-config"],
             },
-            key: { type: "string", description: "Specific cache key to clear" },
+            key: { type: "string", description: "Key to clear (optional)" },
             config: {
                 type: "object",
                 properties: {

package/dist/tools/emulator-device.d.ts

@@ -32,7 +32,6 @@ export declare const emulatorDeviceToolDefinition: {
             };
             avdName: {
                 type: string;
-                description: string;
             };
             device: {
                 type: string;
@@ -40,15 +39,12 @@ export declare const emulatorDeviceToolDefinition: {
             };
             systemImage: {
                 type: string;
-                description: string;
             };
             snapshotName: {
                 type: string;
-                description: string;
             };
             emulatorId: {
                 type: string;
-                description: string;
             };
         };
         required: string[];

package/dist/tools/emulator-device.js

@@ -115,7 +115,7 @@ export async function handleEmulatorDeviceTool(input, context) {
 }
 export const emulatorDeviceToolDefinition = {
     name: "emulator-device",
-    description: "Manage Android emulators. Operations: list, create, start, kill, wipe, snapshot-*",
+    description: "Manage Android emulators.",
     inputSchema: {
         type: "object",
         properties: {
@@ -133,11 +133,11 @@ export const emulatorDeviceToolDefinition = {
                     "snapshot-delete",
                 ],
             },
-            avdName: { type: "string", description: "AVD name" },
-            device: { type: "string", description: "Device profile (e.g., 'pixel_7')" },
-            systemImage: { type: "string", description: "System image" },
-            snapshotName: { type: "string", description: "Snapshot name" },
-            emulatorId: { type: "string", description: "Running emulator ID" },
+            avdName: { type: "string" },
+            device: { type: "string", description: "e.g., 'pixel_7'" },
+            systemImage: { type: "string" },
+            snapshotName: { type: "string" },
+            emulatorId: { type: "string" },
         },
         required: ["operation"],
     },

package/dist/tools/gradle-build.d.ts

@@ -27,7 +27,6 @@ export declare const gradleBuildToolDefinition: {
             };
             flavor: {
                 type: string;
-                description: string;
             };
         };
         required: string[];

package/dist/tools/gradle-build.js

@@ -7,7 +7,6 @@ export const gradleBuildInputSchema = z.object({
 });
 export async function handleGradleBuildTool(input, context) {
     const { result, fullOutput } = await context.gradle.build(input.operation, input.module, input.flavor);
-    // Cache full output for later retrieval
     const buildId = context.cache.generateId("build");
     context.cache.set(buildId, { fullOutput, result, operation: input.operation }, "build", CACHE_TTLS.BUILD_OUTPUT);
     return {
@@ -24,7 +23,7 @@ export async function handleGradleBuildTool(input, context) {
 }
 export const gradleBuildToolDefinition = {
     name: "gradle-build",
-    description: "Build an Android application. Returns summary with buildId for full logs.",
+    description: "Build. Returns summary with buildId.",
     inputSchema: {
         type: "object",
         properties: {
@@ -32,8 +31,8 @@ export const gradleBuildToolDefinition = {
                 type: "string",
                 enum: ["assembleDebug", "assembleRelease", "bundle"],
             },
-            module: { type: "string", description: "Module path (e.g., ':app')" },
-            flavor: { type: "string", description: "Product flavor" },
+            module: { type: "string", description: "e.g., ':app'" },
+            flavor: { type: "string" },
         },
         required: ["operation"],
     },

package/dist/tools/gradle-get-details.d.ts

@@ -22,12 +22,10 @@ export declare const gradleGetDetailsToolDefinition: {
         properties: {
             id: {
                 type: string;
-                description: string;
             };
             detailType: {
                 type: string;
                 enum: string[];
-                description: string;
             };
             maxChars: {
                 type: string;

package/dist/tools/gradle-get-details.js

@@ -139,15 +139,14 @@ export const gradleGetDetailsToolDefinition = {
     inputSchema: {
         type: "object",
         properties: {
-            id: { type: "string", description: "Build or test ID from previous operation" },
+            id: { type: "string" },
             detailType: {
                 type: "string",
                 enum: ["logs", "errors", "tasks", "all"],
-                description: "Type of details to retrieve",
             },
             maxChars: {
                 type: "number",
-                description: "Truncate large text fields to at most this many characters",
+                description: "Truncate to N chars",
             },
             summaryOnly: {
                 type: "boolean",

package/dist/tools/gradle-list.js

@@ -16,10 +16,8 @@ export async function handleGradleListTool(input, context) {
         }
         case "tasks": {
             const tasks = await context.gradle.listTasks(input.module);
-            // Cache full task list
             const listId = context.cache.generateId("tasks");
             context.cache.set(listId, { tasks }, "tasks", CACHE_TTLS.GRADLE_VARIANTS);
-            // Return categorized summary
             const buildTasks = tasks.filter((t) => t.includes("assemble") || t.includes("bundle"));
             const testTasks = tasks.filter((t) => t.includes("test") || t.includes("Test"));
             const cleanTasks = tasks.filter((t) => t.includes("clean"));
@@ -40,7 +38,7 @@ export async function handleGradleListTool(input, context) {
 }
 export const gradleListToolDefinition = {
     name: "gradle-list",
-    description: "Introspect project structure. Operations: modules, variants, tasks.",
+    description: "Introspect project structure.",
     inputSchema: {
         type: "object",
         properties: {
@@ -48,7 +46,7 @@ export const gradleListToolDefinition = {
                 type: "string",
                 enum: ["variants", "modules", "tasks"],
             },
-            module: { type: "string", description: "Module path (for variants/tasks)" },
+            module: { type: "string", description: "e.g., ':app'" },
         },
         required: ["operation"],
     },

package/dist/tools/gradle-test.d.ts

@@ -32,7 +32,6 @@ export declare const gradleTestToolDefinition: {
             };
             module: {
                 type: string;
-                description: string;
             };
             filter: {
                 type: string;