mcp-maestro-mobile-ai 1.1.0

package/src/mcp-server/tools/contextTools.js

@@ -0,0 +1,194 @@
+/**
+ * App Context Tools
+ * MCP tools for managing app context/training data
+ */
+
+import {
+  loadAppContext,
+  registerElements,
+  registerScreen,
+  saveSuccessfulFlow,
+  getSavedFlows,
+  deleteFlow,
+  generateAIPromptContext,
+  clearAppContext,
+  listAppContexts,
+} from "../utils/appContext.js";
+
+/**
+ * Format result as MCP response
+ */
+function formatResponse(result) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(result, null, 2),
+      },
+    ],
+  };
+}
+
+/**
+ * Register UI elements for better AI generation
+ */
+export async function registerAppElements(appId, elements) {
+  if (!appId) {
+    return formatResponse({
+      success: false,
+      error: "appId is required",
+    });
+  }
+
+  if (!elements || typeof elements !== "object") {
+    return formatResponse({
+      success: false,
+      error: "elements must be an object with element definitions",
+      example: {
+        loginButton: {
+          testId: "login-button",
+          type: "button",
+          description: "Main login button",
+        },
+        usernameInput: {
+          testId: "username-input",
+          accessibilityLabel: "Username",
+          type: "textfield",
+        },
+      },
+    });
+  }
+
+  const result = await registerElements(appId, elements);
+  return formatResponse(result);
+}
+
+/**
+ * Register a screen with its elements and actions
+ */
+export async function registerAppScreen(appId, screenName, screenData) {
+  if (!appId || !screenName) {
+    return formatResponse({
+      success: false,
+      error: "appId and screenName are required",
+    });
+  }
+
+  const result = await registerScreen(appId, screenName, screenData);
+  return formatResponse(result);
+}
+
+/**
+ * Save a successful flow for future reference
+ * Call this after a test passes to help AI learn patterns
+ */
+export async function saveFlow(appId, flowName, yamlContent, description) {
+  if (!appId || !flowName || !yamlContent) {
+    return formatResponse({
+      success: false,
+      error: "appId, flowName, and yamlContent are required",
+    });
+  }
+
+  const result = await saveSuccessfulFlow(appId, flowName, yamlContent, description);
+  return formatResponse(result);
+}
+
+/**
+ * Get saved flows for an app
+ */
+export async function getFlows(appId) {
+  if (!appId) {
+    return formatResponse({
+      success: false,
+      error: "appId is required",
+    });
+  }
+
+  const result = await getSavedFlows(appId);
+  return formatResponse(result);
+}
+
+/**
+ * Delete a saved flow
+ */
+export async function removeFlow(appId, flowName) {
+  if (!appId || !flowName) {
+    return formatResponse({
+      success: false,
+      error: "appId and flowName are required",
+    });
+  }
+
+  const result = await deleteFlow(appId, flowName);
+  return formatResponse(result);
+}
+
+/**
+ * Get AI prompt context - the formatted context for AI to use
+ */
+export async function getAIContext(appId) {
+  if (!appId) {
+    return formatResponse({
+      success: false,
+      error: "appId is required",
+    });
+  }
+
+  const result = await generateAIPromptContext(appId);
+  return formatResponse(result);
+}
+
+/**
+ * Get the full app context
+ */
+export async function getAppContext(appId) {
+  if (!appId) {
+    return formatResponse({
+      success: false,
+      error: "appId is required",
+    });
+  }
+
+  const context = await loadAppContext(appId);
+  return formatResponse({
+    success: true,
+    context,
+  });
+}
+
+/**
+ * Clear app context
+ */
+export async function clearContext(appId) {
+  if (!appId) {
+    return formatResponse({
+      success: false,
+      error: "appId is required",
+    });
+  }
+
+  const result = await clearAppContext(appId);
+  return formatResponse(result);
+}
+
+/**
+ * List all apps with saved context
+ */
+export async function listContexts() {
+  const result = await listAppContexts();
+  return formatResponse(result);
+}
+
+export default {
+  registerAppElements,
+  registerAppScreen,
+  saveFlow,
+  getFlows,
+  removeFlow,
+  getAIContext,
+  getAppContext,
+  clearContext,
+  listContexts,
+};
+

package/src/mcp-server/tools/promptTools.js

@@ -0,0 +1,191 @@
+/**
+ * Prompt File Tools
+ * Read and list prompt files for test generation
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { logger } from '../utils/logger.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PROJECT_ROOT = join(__dirname, '../../..');
+
+/**
+ * Read prompts from a .txt or .md file
+ * Each non-empty line (excluding comments) is treated as a prompt
+ */
+export async function readPromptFile(filePath) {
+  try {
+    const fullPath = path.isAbsolute(filePath) 
+      ? filePath 
+      : join(PROJECT_ROOT, filePath);
+
+    logger.info(`Reading prompt file: ${fullPath}`);
+
+    // Check if file exists
+    try {
+      await fs.access(fullPath);
+    } catch {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              success: false,
+              error: `File not found: ${filePath}`,
+              hint: 'Use list_prompt_files to see available prompt files',
+            }),
+          },
+        ],
+      };
+    }
+
+    // Read file content
+    const content = await fs.readFile(fullPath, 'utf8');
+    
+    // Parse prompts (one per line, skip empty lines and comments)
+    const prompts = content
+      .split('\n')
+      .map(line => line.trim())
+      .filter(line => line.length > 0)
+      .filter(line => !line.startsWith('#'))
+      .filter(line => !line.startsWith('//'));
+
+    logger.info(`Found ${prompts.length} prompts in ${filePath}`);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: true,
+            file: filePath,
+            count: prompts.length,
+            prompts: prompts,
+            instructions: `
+Found ${prompts.length} test prompts. For each prompt, you should:
+1. Generate a valid Maestro YAML flow based on the prompt
+2. Use the validate_maestro_yaml tool to verify the YAML
+3. Use the run_test tool to execute the test
+4. Report the results back to the user
+
+IMPORTANT: When generating Maestro YAML, always include:
+- appId at the top (use get_app_config to get the configured appId)
+- Proper waits using extendedWaitUntil
+- Clear step descriptions
+
+Example Maestro YAML format:
+\`\`\`yaml
+appId: com.example.app
+---
+- launchApp
+- extendedWaitUntil:
+    visible: "Element Text"
+    timeout: 10000
+- tapOn: "Button Text"
+\`\`\`
+            `.trim(),
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    logger.error('Error reading prompt file', { error: error.message });
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: error.message,
+          }),
+        },
+      ],
+    };
+  }
+}
+
+/**
+ * List available prompt files in a directory
+ */
+export async function listPromptFiles(directory = 'prompts') {
+  try {
+    const fullPath = path.isAbsolute(directory)
+      ? directory
+      : join(PROJECT_ROOT, directory);
+
+    logger.info(`Listing prompt files in: ${fullPath}`);
+
+    // Check if directory exists
+    try {
+      await fs.access(fullPath);
+    } catch {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              directory: directory,
+              files: [],
+              message: `Directory "${directory}" does not exist. Create it and add .txt or .md files with test prompts.`,
+            }),
+          },
+        ],
+      };
+    }
+
+    // Read directory
+    const entries = await fs.readdir(fullPath, { withFileTypes: true });
+    
+    // Filter for .txt and .md files
+    const promptFiles = entries
+      .filter(entry => entry.isFile())
+      .filter(entry => 
+        entry.name.endsWith('.txt') || 
+        entry.name.endsWith('.md')
+      )
+      .map(entry => entry.name);
+
+    logger.info(`Found ${promptFiles.length} prompt files`);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: true,
+            directory: directory,
+            files: promptFiles,
+            count: promptFiles.length,
+            usage: promptFiles.length > 0
+              ? `Use read_prompt_file with one of these files to get the test prompts.`
+              : `No prompt files found. Create .txt or .md files in the "${directory}" folder.`,
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    logger.error('Error listing prompt files', { error: error.message });
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: error.message,
+          }),
+        },
+      ],
+    };
+  }
+}
+
+export default {
+  readPromptFile,
+  listPromptFiles,
+};
+