intellitester 0.2.72 → 0.3.1

package/README.md

@@ -113,6 +113,79 @@ When execution pauses, you can:
 - Examine selectors and elements
 - Continue execution when ready
 
+### Log Action
+
+Use the `log` action to output debug information during test execution:
+
+```yaml
+steps:
+  # Log a static message
+  - type: log
+    message: "Starting checkout flow"
+
+  # Log JavaScript expression result
+  - type: log
+    eval: "document.title"
+
+  # Log element content
+  - type: log
+    target: { css: ".error-message" }
+    format: html  # text (default), html, or json
+
+  # Log inside iframe
+  - type: log
+    target: { css: ".stripe-error" }
+    frame: { css: "iframe[name='stripe']" }
+```
+
+## AI-Assisted Test Healing
+
+IntelliTester can automatically fix broken selectors using AI when tests fail.
+
+### Configuration
+
+Enable AI healing in `intellitester.config.yaml`:
+
+```yaml
+ai:
+  provider: groq  # anthropic, openai, ollama, groq, openrouter
+  model: llama-3.3-70b-versatile
+  apiKey: ${GROQ_API_KEY}
+  temperature: 0.2
+  maxTokens: 4096
+
+healing:
+  enabled: true
+  maxAttempts: 3  # 1-10
+```
+
+### Supported Providers
+
+| Provider | Env Variable | Example Model |
+|----------|--------------|---------------|
+| `anthropic` | `ANTHROPIC_API_KEY` | `claude-3-5-sonnet-20241022` |
+| `openai` | `OPENAI_API_KEY` | `gpt-4o` |
+| `groq` | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
+| `openrouter` | `OPENROUTER_API_KEY` | `anthropic/claude-3.5-sonnet` |
+| `ollama` | - | `llama3.2` |
+
+### How It Works
+
+When an action fails:
+1. AI analyzes the page HTML and error message
+2. Suggests a new selector (testId, text, role, or css)
+3. Validates the suggestion finds an element
+4. Retries the action with the fixed selector
+
+```
+[FAIL] tap - Element not found: testId="old-button-id"
+
+🔧 Attempting AI-assisted healing (max 3 attempts)...
+✅ AI found fix: {"text": "Submit Order"}
+
+[OK] tap
+```
+
 ## Iframe Targeting (frame)
 
 Target elements inside iframes using the `frame` property. Essential for payment forms (Stripe, PayPal), embedded widgets, and third-party integrations.

package/dist/{chunk-7JQTLV5I.cjs → chunk-4DYHFFIN.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkCGPHTHY4_cjs = require('./chunk-CGPHTHY4.cjs');
+var chunkN7TZR4A2_cjs = require('./chunk-N7TZR4A2.cjs');
 var chunkYNHXOSMZ_cjs = require('./chunk-YNHXOSMZ.cjs');
 var chunk2ZSINOCK_cjs = require('./chunk-2ZSINOCK.cjs');
 var uniqueNamesGenerator = require('unique-names-generator');
@@ -1039,6 +1039,56 @@ var OllamaProvider = class {
     return typeof content === "string" ? content : JSON.stringify(content);
   }
 };
+var GroqProvider = class {
+  constructor(config) {
+    this.config = config;
+    const apiKey = config.apiKey ? resolveEnvVars(config.apiKey) : process.env.GROQ_API_KEY;
+    this.client = new openai.OpenAI({
+      apiKey,
+      model: this.config.model,
+      temperature: this.config.temperature,
+      baseURL: "https://api.groq.com/openai/v1"
+    });
+  }
+  async generateCompletion(prompt, systemPrompt) {
+    const messages = [];
+    if (systemPrompt) {
+      messages.push({ role: "system", content: systemPrompt });
+    }
+    messages.push({ role: "user", content: prompt });
+    const response = await this.client.chat({ messages });
+    const content = response.message.content;
+    if (!content) {
+      throw new Error("No content in GROQ response");
+    }
+    return typeof content === "string" ? content : JSON.stringify(content);
+  }
+};
+var OpenRouterProvider = class {
+  constructor(config) {
+    this.config = config;
+    const apiKey = config.apiKey ? resolveEnvVars(config.apiKey) : process.env.OPENROUTER_API_KEY;
+    this.client = new openai.OpenAI({
+      apiKey,
+      model: this.config.model,
+      temperature: this.config.temperature,
+      baseURL: "https://openrouter.ai/api/v1"
+    });
+  }
+  async generateCompletion(prompt, systemPrompt) {
+    const messages = [];
+    if (systemPrompt) {
+      messages.push({ role: "system", content: systemPrompt });
+    }
+    messages.push({ role: "user", content: prompt });
+    const response = await this.client.chat({ messages });
+    const content = response.message.content;
+    if (!content) {
+      throw new Error("No content in OpenRouter response");
+    }
+    return typeof content === "string" ? content : JSON.stringify(content);
+  }
+};
 function createAIProvider(config) {
   switch (config.provider) {
     case "anthropic":
@@ -1047,6 +1097,10 @@ function createAIProvider(config) {
       return new OpenAIProvider(config);
     case "ollama":
       return new OllamaProvider(config);
+    case "groq":
+      return new GroqProvider(config);
+    case "openrouter":
+      return new OpenRouterProvider(config);
   }
 }
 
@@ -1143,6 +1197,178 @@ Return ONLY valid JSON, no additional text.`;
     };
   }
 }
+
+// src/ai/healingAgent.ts
+async function checkSelector(page, selector) {
+  try {
+    const count = await page.locator(selector).count();
+    if (count === 0) return { found: false, count: 0 };
+    const texts = await page.locator(selector).allTextContents();
+    return { found: true, count, texts: texts.slice(0, 5) };
+  } catch (e) {
+    return { found: false, count: 0, error: String(e) };
+  }
+}
+async function checkByText(page, text) {
+  try {
+    const locator = page.getByText(text, { exact: false });
+    const count = await locator.count();
+    if (count === 0) return { found: false, count: 0 };
+    return { found: true, count };
+  } catch (e) {
+    return { found: false, count: 0, error: String(e) };
+  }
+}
+async function checkByRole(page, role, name) {
+  try {
+    const locator = page.getByRole(role, name ? { name } : void 0);
+    const count = await locator.count();
+    if (count === 0) return { found: false, count: 0 };
+    return { found: true, count };
+  } catch (e) {
+    return { found: false, count: 0, error: String(e) };
+  }
+}
+async function checkTestId(page, testId) {
+  try {
+    const selector = `[data-testid="${testId}"], #${CSS.escape(testId)}`;
+    const count = await page.locator(selector).count();
+    return { found: count > 0, count };
+  } catch (e) {
+    return { found: false, count: 0, error: String(e) };
+  }
+}
+function extractLocatorFromResponse(response) {
+  const jsonMatch = response.match(/\{[\s\S]*?"(?:testId|text|css|role)"[\s\S]*?\}/);
+  if (!jsonMatch) return null;
+  try {
+    const parsed = JSON.parse(jsonMatch[0]);
+    if (parsed.testId || parsed.text || parsed.css || parsed.role) {
+      return parsed;
+    }
+  } catch {
+    const codeMatch = response.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
+    if (codeMatch) {
+      try {
+        const parsed = JSON.parse(codeMatch[1]);
+        if (parsed.testId || parsed.text || parsed.css || parsed.role) {
+          return parsed;
+        }
+      } catch {
+      }
+    }
+  }
+  const cssMatch = response.match(/css['":\s]+['"]([^'"]+)['"]/i);
+  if (cssMatch) return { css: cssMatch[1] };
+  const textMatch = response.match(/text['":\s]+['"]([^'"]+)['"]/i);
+  if (textMatch) return { text: textMatch[1] };
+  const testIdMatch = response.match(/testId['":\s]+['"]([^'"]+)['"]/i);
+  if (testIdMatch) return { testId: testIdMatch[1] };
+  return null;
+}
+async function runHealingAgent(context, aiConfig, maxAttempts = 3) {
+  const provider = createAIProvider(aiConfig);
+  const currentTarget = "target" in context.action ? context.action.target : null;
+  const systemPrompt = `You are debugging a failing web test action. Your goal is to analyze the page and suggest a working selector.
+
+When suggesting a selector, respond with a JSON object containing ONE of these fields:
+- testId: for data-testid attributes (most reliable)
+- text: for visible text content
+- css: for CSS selectors
+- role: for ARIA roles (with optional "name" field)
+
+Example responses:
+{"testId": "submit-button"}
+{"text": "Sign In"}
+{"css": "button.primary"}
+{"role": "button", "name": "Submit"}
+
+Prefer selectors in this order of reliability:
+1. testId - most stable, unlikely to change
+2. text - good for buttons, links
+3. role + name - good for accessible elements
+4. css - last resort, more brittle
+
+Respond ONLY with the JSON selector object, no other text.`;
+  let attempts = 0;
+  let lastExplanation = "";
+  while (attempts < maxAttempts) {
+    attempts++;
+    const validationResults = [];
+    if (currentTarget) {
+      if (currentTarget.testId) {
+        const result = await checkTestId(context.page, currentTarget.testId);
+        validationResults.push(`testId "${currentTarget.testId}": ${result.found ? `found ${result.count} elements` : "NOT FOUND"}`);
+      }
+      if (currentTarget.text) {
+        const result = await checkByText(context.page, currentTarget.text);
+        validationResults.push(`text "${currentTarget.text}": ${result.found ? `found ${result.count} elements` : "NOT FOUND"}`);
+      }
+      if (currentTarget.css) {
+        const result = await checkSelector(context.page, currentTarget.css);
+        validationResults.push(`css "${currentTarget.css}": ${result.found ? `found ${result.count} elements` : "NOT FOUND"}`);
+      }
+      if (currentTarget.role) {
+        const result = await checkByRole(context.page, currentTarget.role, currentTarget.name);
+        validationResults.push(`role "${currentTarget.role}"${currentTarget.name ? ` name="${currentTarget.name}"` : ""}: ${result.found ? `found ${result.count} elements` : "NOT FOUND"}`);
+      }
+    }
+    const prompt = `Action type: ${context.action.type}
+Error: ${context.error}
+
+Failed selector: ${JSON.stringify(currentTarget)}
+
+Validation results:
+${validationResults.length > 0 ? validationResults.join("\n") : "No current selector to validate"}
+
+Page HTML (first 6000 chars):
+${context.pageContent.slice(0, 6e3)}
+
+Based on the page content, suggest a working selector for this action. Respond with a JSON object.`;
+    try {
+      const response = await provider.generateCompletion(prompt, systemPrompt);
+      const suggestedLocator = extractLocatorFromResponse(response);
+      if (!suggestedLocator) {
+        lastExplanation = `Attempt ${attempts}: Could not parse selector from AI response`;
+        continue;
+      }
+      let isValid = false;
+      if (suggestedLocator.testId) {
+        const result = await checkTestId(context.page, suggestedLocator.testId);
+        isValid = result.found;
+      } else if (suggestedLocator.text) {
+        const result = await checkByText(context.page, suggestedLocator.text);
+        isValid = result.found;
+      } else if (suggestedLocator.css) {
+        const result = await checkSelector(context.page, suggestedLocator.css);
+        isValid = result.found;
+      } else if (suggestedLocator.role) {
+        const result = await checkByRole(context.page, suggestedLocator.role, suggestedLocator.name);
+        isValid = result.found;
+      }
+      if (isValid) {
+        const fixedAction = { ...context.action };
+        if ("target" in fixedAction) {
+          fixedAction.target = suggestedLocator;
+        }
+        return {
+          success: true,
+          fixedAction,
+          attempts,
+          explanation: `Found working selector: ${JSON.stringify(suggestedLocator)}`
+        };
+      }
+      lastExplanation = `Attempt ${attempts}: Suggested selector ${JSON.stringify(suggestedLocator)} did not find any elements`;
+    } catch (e) {
+      lastExplanation = `Attempt ${attempts}: AI error - ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+  return {
+    success: false,
+    attempts,
+    explanation: lastExplanation || "Could not find a working selector within the allowed attempts"
+  };
+}
 var SERVER_MARKER_FILE = "server.json";
 var INTELLITESTER_DIR = ".intellitester";
 var getMarkerPath = (cwd) => path4__namespace.join(cwd, INTELLITESTER_DIR, SERVER_MARKER_FILE);
@@ -1818,7 +2044,8 @@ async function handleInteractiveError(page, action, error, screenshotDir, stepIn
   return response.action || "abort";
 }
 async function executeActionWithRetry(page, action, index, options) {
-  const { baseUrl, context, screenshotDir, debugMode, interactive, aiConfig, browserName } = options;
+  const { baseUrl, context, screenshotDir, debugMode, interactive, aiConfig, browserName, healing } = options;
+  const extras = {};
   const buildTrackPayload = (stepExtras) => {
     if (!("track" in action)) return null;
     const track2 = action.track;
@@ -2231,6 +2458,50 @@ async function executeActionWithRetry(page, action, index, options) {
           }
           break;
         }
+        case "log": {
+          const logAction = action;
+          const format = logAction.format ?? "text";
+          let logOutput;
+          if (logAction.message) {
+            logOutput = interpolateVariables(logAction.message, context.variables);
+            console.log(`[LOG] ${logOutput}`);
+          } else if (logAction.eval) {
+            const interpolated = interpolateVariables(logAction.eval, context.variables);
+            try {
+              const result = await page.evaluate(interpolated);
+              logOutput = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+              console.log(`[LOG eval] ${logOutput}`);
+            } catch (evalError) {
+              logOutput = `[eval error] ${evalError instanceof Error ? evalError.message : String(evalError)}`;
+              console.log(`[LOG] ${logOutput}`);
+            }
+          } else if (logAction.target) {
+            const frameContext = getActionContext(page, logAction.frame);
+            const handle = resolveLocatorInContext(frameContext, logAction.target);
+            switch (format) {
+              case "html":
+                logOutput = await handle.innerHTML();
+                break;
+              case "json":
+                const text = await handle.textContent() ?? "";
+                try {
+                  logOutput = JSON.stringify(JSON.parse(text), null, 2);
+                } catch {
+                  logOutput = text;
+                }
+                break;
+              case "text":
+              default:
+                logOutput = await handle.textContent() ?? "";
+                break;
+            }
+            console.log(`[LOG element] ${logOutput}`);
+          } else {
+            logOutput = "(no content)";
+          }
+          extras.logOutput = logOutput;
+          break;
+        }
         case "fail": {
           const failAction = action;
           throw new Error(failAction.message);
@@ -2296,7 +2567,7 @@ async function executeActionWithRetry(page, action, index, options) {
               });
             }
           } else {
-            const { loadWorkflowDefinition, loadTestDefinition: loadTestDefinition2 } = await import('./loader-425Z4YO5.cjs');
+            const { loadWorkflowDefinition, loadTestDefinition: loadTestDefinition2 } = await import('./loader-MPGLPS4F.cjs');
             const workflowPath = path4__namespace.default.resolve(process.cwd(), branchToExecute.workflow);
             const workflowDir = path4__namespace.default.dirname(workflowPath);
             if (debugMode) {
@@ -2343,9 +2614,36 @@ async function executeActionWithRetry(page, action, index, options) {
       if (trackedPayload) {
         await chunkYNHXOSMZ_cjs.track(trackedPayload);
       }
-      return;
+      return extras;
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
+      if (healing?.enabled && aiConfig && hasTarget(action)) {
+        const maxAttempts = healing.maxAttempts ?? 3;
+        console.log(`
+\u{1F527} Attempting AI-assisted healing (max ${maxAttempts} attempts)...`);
+        try {
+          const pageContent = await page.content();
+          const healingContext = {
+            page,
+            action,
+            error: error.message,
+            pageContent
+          };
+          const healingResult = await runHealingAgent(healingContext, aiConfig, maxAttempts);
+          if (healingResult.success && healingResult.fixedAction) {
+            console.log(`\u2705 AI found fix: ${healingResult.explanation}`);
+            const fixedExtras = await executeActionWithRetry(page, healingResult.fixedAction, index, {
+              ...options,
+              healing: { enabled: false }
+            });
+            return fixedExtras;
+          } else {
+            console.log(`\u274C AI healing failed: ${healingResult.explanation}`);
+          }
+        } catch (healingError) {
+          console.log(`\u274C AI healing error: ${healingError instanceof Error ? healingError.message : String(healingError)}`);
+        }
+      }
       if (interactive && aiConfig && hasTarget(action)) {
         const choice = await handleInteractiveError(page, action, error, screenshotDir, index, aiConfig);
         switch (choice) {
@@ -2354,7 +2652,7 @@ async function executeActionWithRetry(page, action, index, options) {
             continue;
           case "skip":
             console.log("Skipping step...\n");
-            return;
+            return extras;
           case "debug":
             console.log("Opening Playwright Inspector...\n");
             await page.pause();
@@ -2732,16 +3030,17 @@ var runWebTest = async (test, options = {}) => {
             }
             continue;
           }
-          await executeActionWithRetry(page, action, index, {
+          const actionExtras = await executeActionWithRetry(page, action, index, {
             baseUrl: options.baseUrl ?? test.config?.web?.baseUrl,
             context: executionContext,
             screenshotDir,
             debugMode,
             interactive,
             aiConfig: options.aiConfig,
-            browserName
+            browserName,
+            healing: options.healing
           });
-          sizeResults.push({ action, status: "passed" });
+          sizeResults.push({ action, status: "passed", logOutput: actionExtras.logOutput });
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error);
           sizeResults.push({ action, status: "failed", error: message });
@@ -3350,7 +3649,7 @@ async function runTestInWorkflow(test, page, context, options, _workflowDir, wor
                 if (debugMode) {
                   console.log(`  [DEBUG] waitForBranch: loading workflow from ${workflowPath}`);
                 }
-                const { loadWorkflowDefinition } = await import('./loader-425Z4YO5.cjs');
+                const { loadWorkflowDefinition } = await import('./loader-MPGLPS4F.cjs');
                 const nestedWorkflow = await loadWorkflowDefinition(workflowPath);
                 if (branch.variables) {
                   for (const [key, value] of Object.entries(branch.variables)) {
@@ -3360,7 +3659,7 @@ async function runTestInWorkflow(test, page, context, options, _workflowDir, wor
                 }
                 for (const testRef of nestedWorkflow.tests) {
                   const testFilePath = path4__namespace.default.resolve(path4__namespace.default.dirname(workflowPath), testRef.file);
-                  const nestedTest = await chunkCGPHTHY4_cjs.loadTestDefinition(testFilePath);
+                  const nestedTest = await chunkN7TZR4A2_cjs.loadTestDefinition(testFilePath);
                   if (nestedTest.variables) {
                     for (const [key, value] of Object.entries(nestedTest.variables)) {
                       const interpolated = interpolateVariables(value, context.variables);
@@ -3622,7 +3921,7 @@ Starting workflow: ${workflow.name}`);
       console.log(`  Test ID: ${testRef.id}`);
     }
     try {
-      const test = await chunkCGPHTHY4_cjs.loadTestDefinition(testFilePath);
+      const test = await chunkN7TZR4A2_cjs.loadTestDefinition(testFilePath);
       if (testRef.variables) {
         for (const [key, value] of Object.entries(testRef.variables)) {
           const interpolated = interpolateWorkflowVariables(
@@ -4069,5 +4368,5 @@ exports.runWorkflowWithContext = runWorkflowWithContext;
 exports.setupAppwriteTracking = setupAppwriteTracking;
 exports.startTrackingServer = startTrackingServer;
 exports.webServerManager = webServerManager;
-//# sourceMappingURL=chunk-7JQTLV5I.cjs.map
-//# sourceMappingURL=chunk-7JQTLV5I.cjs.map
+//# sourceMappingURL=chunk-4DYHFFIN.cjs.map
+//# sourceMappingURL=chunk-4DYHFFIN.cjs.map