mcp-maestro-mobile-ai 1.4.0 → 1.6.0

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

@@ -11,6 +11,15 @@ import { runMaestroFlow, checkDeviceConnection, checkAppInstalled, getConfig } f
 import { validateMaestroYaml } from './validateTools.js';
 import { validateYamlStructure } from '../utils/yamlTemplate.js';
 import { generateReport, getReportsDir, listReports } from '../utils/reportGenerator.js';
+import { 
+  lookupCache, 
+  saveToCache, 
+  updateCacheUsage, 
+  listCache as listYamlCache,
+  clearCache as clearYamlCache,
+  getCacheStats,
+  deleteFromCache,
+} from '../utils/yamlCache.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -160,20 +169,55 @@ Please regenerate the YAML following these rules.
 
     logger.info(`Test ${result.success ? 'passed' : 'failed'}: ${testName}`);
 
+    // Build response
+    const response = {
+      success: result.success,
+      name: testName,
+      duration: result.duration,
+      attempts: result.attempts || 1,
+      error: result.error || null,
+      screenshot: result.screenshot || null,
+      output: result.output ? result.output.substring(0, 500) : null,
+      runId,
+    };
+
+    // If test passed and we have a prompt, automatically save to cache
+    if (result.success && options.prompt && !options.fromCache) {
+      try {
+        const cacheResult = await saveToCache(
+          options.prompt,
+          yamlContent,
+          testName,
+          appId
+        );
+        if (cacheResult.success) {
+          response.cached = true;
+          response.cacheHash = cacheResult.hash;
+          response.cacheMessage = '✅ Test passed! YAML automatically saved to cache for faster future execution.';
+          logger.info(`Auto-cached successful test: ${testName} (hash: ${cacheResult.hash})`);
+        }
+      } catch (cacheError) {
+        logger.warn(`Failed to auto-cache test: ${testName}`, { error: cacheError.message });
+      }
+    }
+
+    // If this was from cache, include that info
+    if (options.fromCache) {
+      response.fromCache = true;
+      response.cacheMessage = '⚡ Executed from cached YAML (faster execution)';
+    }
+
+    // If test failed, indicate it was not cached
+    if (!result.success) {
+      response.cached = false;
+      response.cacheMessage = '❌ Test failed - not saved to cache. Fix the issue and re-run to cache.';
+    }
+
     return {
       content: [
         {
           type: 'text',
-          text: JSON.stringify({
-            success: result.success,
-            name: testName,
-            duration: result.duration,
-            attempts: result.attempts || 1,
-            error: result.error || null,
-            screenshot: result.screenshot || null,
-            output: result.output ? result.output.substring(0, 500) : null,
-            runId,
-          }),
+          text: JSON.stringify(response),
         },
       ],
     };
@@ -526,37 +570,363 @@ export async function runTestSuiteWithReport(tests, options = {}) {
     const passed = results.filter(r => r.success).length;
     const failed = results.length - passed;
 
+    // Auto-cache successful tests
+    const cachedTests = [];
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      const test = tests[i];
+      
+      if (result.success && test.prompt) {
+        try {
+          const cacheResult = await saveToCache(
+            test.prompt,
+            test.yaml,
+            test.name,
+            options.appId
+          );
+          if (cacheResult.success) {
+            cachedTests.push({
+              name: test.name,
+              hash: cacheResult.hash,
+            });
+            logger.info(`Auto-cached successful test: ${test.name} (hash: ${cacheResult.hash})`);
+          }
+        } catch (cacheError) {
+          logger.warn(`Failed to auto-cache test: ${test.name}`, { error: cacheError.message });
+        }
+      }
+    }
+
+    // Build response
+    const response = {
+      success: failed === 0,
+      totalDuration: `${totalDuration}s`,
+      summary: {
+        total: results.length,
+        passed,
+        failed,
+        passRate: reportResult.summary.passRate,
+      },
+      report: {
+        reportId: reportResult.reportId,
+        htmlPath: reportResult.htmlPath,
+        jsonPath: reportResult.jsonPath,
+        message: `📊 Report generated: ${reportResult.htmlPath}`,
+      },
+      tests: results.map(r => ({
+        name: r.name,
+        success: r.success,
+        duration: r.duration,
+        error: r.error || null,
+      })),
+    };
+
+    // Add cache info
+    if (cachedTests.length > 0) {
+      response.cached = {
+        count: cachedTests.length,
+        tests: cachedTests,
+        message: `✅ ${cachedTests.length} successful test(s) automatically saved to cache for faster future execution.`,
+      };
+    }
+
+    if (failed > 0) {
+      response.notCached = {
+        count: failed,
+        message: `❌ ${failed} failed test(s) not saved to cache. Fix issues and re-run to cache.`,
+      };
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(response),
+        },
+      ],
+    };
+  } catch (error) {
+    logger.error('Test suite with report error', { error: error.message });
     return {
       content: [
         {
           type: 'text',
           text: JSON.stringify({
-            success: failed === 0,
-            totalDuration: `${totalDuration}s`,
-            summary: {
-              total: results.length,
-              passed,
-              failed,
-              passRate: reportResult.summary.passRate,
-            },
-            report: {
-              reportId: reportResult.reportId,
-              htmlPath: reportResult.htmlPath,
-              jsonPath: reportResult.jsonPath,
-              message: `📊 Report generated: ${reportResult.htmlPath}`,
-            },
-            tests: results.map(r => ({
-              name: r.name,
-              success: r.success,
-              duration: r.duration,
-              error: r.error || null,
-            })),
+            success: false,
+            error: error.message,
+          }),
+        },
+      ],
+    };
+  }
+}
+
+/**
+ * Run a test from cache or generate new
+ * Checks cache first, falls back to provided YAML
+ */
+export async function runTestWithCache(prompt, yamlContent, testName, options = {}) {
+  const appId = options.appId || null;
+  
+  // Check cache first
+  const cached = await lookupCache(prompt, appId);
+  
+  if (cached) {
+    logger.info(`Using cached YAML for: ${testName}`);
+    
+    // Update usage stats
+    await updateCacheUsage(cached.hash);
+    
+    // Run with cached YAML
+    return runTest(cached.yaml, testName, {
+      ...options,
+      fromCache: true,
+      promptHash: cached.hash,
+    });
+  }
+  
+  // No cache, run with provided YAML
+  return runTest(yamlContent, testName, {
+    ...options,
+    prompt,
+    fromCache: false,
+  });
+}
+
+/**
+ * Save a test to cache after successful execution
+ */
+export async function saveTestToCache(prompt, yamlContent, testName, appId = null) {
+  try {
+    const result = await saveToCache(prompt, yamlContent, testName, appId);
+    
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: result.success,
+            hash: result.hash,
+            message: result.success 
+              ? `✅ Test cached! Future runs of this prompt will use the saved YAML automatically.`
+              : `❌ Failed to cache: ${result.error}`,
+            hint: result.success 
+              ? 'When you run the same prompt again, the cached YAML will be used for faster execution.'
+              : null,
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: error.message,
+          }),
+        },
+      ],
+    };
+  }
+}
+
+/**
+ * List all cached tests
+ */
+export async function listCachedTests() {
+  try {
+    const result = await listYamlCache();
+    
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: result.success,
+            count: result.count,
+            cacheDir: result.cacheDir,
+            tests: result.entries?.map(e => ({
+              hash: e.hash,
+              testName: e.testName,
+              appId: e.appId,
+              prompt: e.prompt,
+              cachedAt: e.cachedAt,
+              lastUsed: e.lastUsed,
+              executionCount: e.executionCount,
+            })) || [],
+            message: result.count > 0 
+              ? `Found ${result.count} cached test(s). These will be reused automatically when the same prompt is run.`
+              : 'No cached tests. Run successful tests and save them for faster future execution.',
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: error.message,
+          }),
+        },
+      ],
+    };
+  }
+}
+
+/**
+ * Clear all cached tests
+ */
+export async function clearTestCache() {
+  try {
+    const result = await clearYamlCache();
+    
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: result.success,
+            cleared: result.cleared,
+            message: result.success 
+              ? `✅ Cleared ${result.cleared} cached test(s). All tests will generate fresh YAML on next run.`
+              : `❌ Failed to clear cache: ${result.error}`,
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: error.message,
+          }),
+        },
+      ],
+    };
+  }
+}
+
+/**
+ * Delete a specific cached test
+ */
+export async function deleteCachedTest(hash) {
+  try {
+    const result = await deleteFromCache(hash);
+    
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: result.success,
+            message: result.success 
+              ? `✅ Cached test deleted. A new YAML will be generated on next run.`
+              : `❌ ${result.error}`,
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: error.message,
+          }),
+        },
+      ],
+    };
+  }
+}
+
+/**
+ * Get cache statistics
+ */
+export async function getTestCacheStats() {
+  try {
+    const result = await getCacheStats();
+    
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: result.success,
+            stats: result.stats,
+            message: result.stats?.totalCached > 0
+              ? `Cache has ${result.stats.totalCached} test(s) with ${result.stats.totalExecutions} total executions.`
+              : 'Cache is empty.',
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: error.message,
+          }),
+        },
+      ],
+    };
+  }
+}
+
+/**
+ * Lookup cached YAML for a prompt
+ */
+export async function lookupCachedTest(prompt, appId = null) {
+  try {
+    const cached = await lookupCache(prompt, appId);
+    
+    if (cached) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              found: true,
+              hash: cached.hash,
+              testName: cached.testName,
+              appId: cached.appId,
+              cachedAt: cached.cachedAt,
+              lastUsed: cached.lastUsed,
+              executionCount: cached.executionCount,
+              yaml: cached.yaml,
+              message: '⚡ Found cached YAML for this prompt. Will be used for faster execution.',
+            }),
+          },
+        ],
+      };
+    }
+    
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: true,
+            found: false,
+            message: 'No cached YAML found for this prompt. A new YAML will be generated.',
           }),
         },
       ],
     };
   } catch (error) {
-    logger.error('Test suite with report error', { error: error.message });
     return {
       content: [
         {
@@ -577,4 +947,12 @@ export default {
   generateTestReport,
   listTestReports,
   runTestSuiteWithReport,
+  // Cache management
+  runTestWithCache,
+  saveTestToCache,
+  listCachedTests,
+  clearTestCache,
+  deleteCachedTest,
+  getTestCacheStats,
+  lookupCachedTest,
 };