intellitester 0.2.22 → 0.2.25

package/dist/chunk-BDSLT5FJ.js

@@ -0,0 +1,512 @@
+import fs from 'fs/promises';
+import { parse } from 'yaml';
+import { z } from 'zod';
+
+// src/core/loader.ts
+var nonEmptyString = z.string().trim().min(1, "Value cannot be empty");
+var LocatorSchema = z.object({
+  description: z.string().trim().optional().describe("AI-friendly description of the element to find"),
+  testId: z.string().trim().optional().describe("data-testid attribute value"),
+  text: z.string().trim().optional().describe("Visible text content"),
+  css: z.string().trim().optional().describe("CSS selector"),
+  xpath: z.string().trim().optional().describe("XPath selector"),
+  role: z.string().trim().optional().describe("ARIA role"),
+  name: z.string().trim().optional().describe("Accessible name")
+}).describe("Defines how to locate an element on the page. At least one selector must be provided.").refine(
+  (locator) => Boolean(
+    locator.description || locator.testId || locator.text || locator.css || locator.xpath || locator.role || locator.name
+  ),
+  { message: "Locator requires at least one selector or description" }
+);
+var navigateActionSchema = z.object({
+  type: z.literal("navigate"),
+  value: nonEmptyString.describe("URL or path to navigate to")
+}).describe("Navigate to a URL");
+var tapActionSchema = z.object({
+  type: z.literal("tap"),
+  target: LocatorSchema
+}).describe("Click or tap on an element");
+var inputActionSchema = z.object({
+  type: z.literal("input"),
+  target: LocatorSchema,
+  value: z.string().describe("Text to input (can reference variables with ${VAR_NAME})")
+}).describe("Input text into a field");
+var clearActionSchema = z.object({
+  type: z.literal("clear"),
+  target: LocatorSchema
+}).describe("Clear the contents of an input field");
+var hoverActionSchema = z.object({
+  type: z.literal("hover"),
+  target: LocatorSchema
+}).describe("Hover over an element");
+var selectActionSchema = z.object({
+  type: z.literal("select"),
+  target: LocatorSchema,
+  value: z.string().describe("Option value, label, or index to select")
+}).describe("Select an option from a dropdown");
+var checkActionSchema = z.object({
+  type: z.literal("check"),
+  target: LocatorSchema
+}).describe("Check a checkbox");
+var uncheckActionSchema = z.object({
+  type: z.literal("uncheck"),
+  target: LocatorSchema
+}).describe("Uncheck a checkbox");
+var pressActionSchema = z.object({
+  type: z.literal("press"),
+  key: nonEmptyString.describe("Key to press (e.g., Enter, Tab, Escape, ArrowDown)"),
+  target: LocatorSchema.optional().describe("Element to focus before pressing key")
+}).describe("Press a keyboard key");
+var focusActionSchema = z.object({
+  type: z.literal("focus"),
+  target: LocatorSchema
+}).describe("Focus an element");
+var assertActionSchema = z.object({
+  type: z.literal("assert"),
+  target: LocatorSchema,
+  value: z.string().optional().describe("Expected text content")
+}).describe("Assert that an element exists or contains expected text");
+var waitActionSchema = z.object({
+  type: z.literal("wait"),
+  target: LocatorSchema.optional().describe("Element to wait for"),
+  timeout: z.number().int().positive().optional().describe("Time to wait in milliseconds")
+}).describe("Wait for an element or timeout").refine((action) => action.target || action.timeout, {
+  message: "wait requires a target or timeout"
+});
+var scrollActionSchema = z.object({
+  type: z.literal("scroll"),
+  target: LocatorSchema.optional().describe("Element to scroll"),
+  direction: z.enum(["up", "down"]).optional().describe("Direction to scroll"),
+  amount: z.number().int().positive().optional().describe("Amount to scroll in pixels")
+}).describe("Scroll the page or an element");
+var screenshotActionSchema = z.object({
+  type: z.literal("screenshot"),
+  name: z.string().optional().describe("Name for the screenshot file"),
+  waitBefore: z.number().int().nonnegative().optional().describe("Milliseconds to wait before capturing for visual stability (default: 500)")
+}).describe("Take a screenshot");
+var setVarActionSchema = z.object({
+  type: z.literal("setVar"),
+  name: nonEmptyString.describe("Variable name to set"),
+  value: z.string().optional().describe("Static value to set"),
+  from: z.enum(["response", "element", "email"]).optional().describe("Extract value from a source"),
+  path: z.string().optional().describe("JSON path or selector for extraction"),
+  pattern: z.string().optional().describe("Regular expression pattern for extraction")
+}).describe("Set a variable for use in later steps");
+var emailWaitForActionSchema = z.object({
+  type: z.literal("email.waitFor"),
+  mailbox: nonEmptyString.describe("Email address or mailbox to check"),
+  timeout: z.number().int().positive().optional().describe("How long to wait for email in milliseconds"),
+  subjectContains: z.string().optional().describe("Filter by email subject")
+}).describe("Wait for an email to arrive");
+var emailExtractCodeActionSchema = z.object({
+  type: z.literal("email.extractCode"),
+  saveTo: nonEmptyString.describe("Variable name to save the extracted code"),
+  pattern: z.string().optional().describe("Regular expression to extract code")
+}).describe("Extract a verification code from email");
+var emailExtractLinkActionSchema = z.object({
+  type: z.literal("email.extractLink"),
+  saveTo: nonEmptyString.describe("Variable name to save the extracted link"),
+  pattern: z.string().optional().describe("Regular expression to match specific links")
+}).describe("Extract a link from email");
+var emailClearActionSchema = z.object({
+  type: z.literal("email.clear"),
+  mailbox: nonEmptyString.describe("Email address or mailbox to clear")
+}).describe("Clear emails from a mailbox");
+var appwriteVerifyEmailActionSchema = z.object({
+  type: z.literal("appwrite.verifyEmail")
+}).describe("Verify email using Appwrite");
+var debugActionSchema = z.object({
+  type: z.literal("debug")
+}).describe("Pause execution and open Playwright Inspector for debugging");
+var waitForSelectorActionSchema = z.object({
+  type: z.literal("waitForSelector"),
+  target: LocatorSchema,
+  state: z.enum(["enabled", "disabled", "visible", "hidden", "attached", "detached"]).describe("Element state to wait for"),
+  timeout: z.number().int().positive().optional().describe("Time to wait in milliseconds")
+}).describe("Wait for an element to reach a specific state");
+var failActionSchema = z.object({
+  type: z.literal("fail"),
+  message: nonEmptyString.describe("Error message to display when test fails")
+}).describe("Explicitly fail the test with a custom message");
+var BaseActionSchema = z.discriminatedUnion("type", [
+  navigateActionSchema,
+  tapActionSchema,
+  inputActionSchema,
+  clearActionSchema,
+  hoverActionSchema,
+  selectActionSchema,
+  checkActionSchema,
+  uncheckActionSchema,
+  pressActionSchema,
+  focusActionSchema,
+  assertActionSchema,
+  waitActionSchema,
+  scrollActionSchema,
+  screenshotActionSchema,
+  setVarActionSchema,
+  emailWaitForActionSchema,
+  emailExtractCodeActionSchema,
+  emailExtractLinkActionSchema,
+  emailClearActionSchema,
+  appwriteVerifyEmailActionSchema,
+  debugActionSchema,
+  waitForSelectorActionSchema,
+  failActionSchema
+]);
+var conditionalActionSchema = z.object({
+  type: z.literal("conditional"),
+  condition: z.object({
+    type: z.enum(["exists", "notExists", "visible", "hidden"]),
+    target: LocatorSchema
+  }).describe("Condition to check"),
+  then: z.array(BaseActionSchema).describe("Steps to execute if condition is true"),
+  else: z.array(BaseActionSchema).optional().describe("Steps to execute if condition is false")
+}).describe("Execute steps conditionally based on element state");
+var branchSchema = z.union([
+  z.array(BaseActionSchema),
+  // Inline actions
+  z.object({
+    workflow: z.string().trim().min(1).describe("Path to workflow file relative to current file"),
+    variables: z.record(z.string(), z.string()).optional().describe("Variables to pass to the workflow")
+  })
+]).describe("Actions to execute - either inline steps or a workflow file reference");
+var waitForBranchActionSchema = z.object({
+  type: z.literal("waitForBranch"),
+  target: LocatorSchema.describe("Element to wait for"),
+  timeout: z.number().int().positive().optional().describe("Maximum time to wait for element in milliseconds (default: 30000)"),
+  state: z.enum(["visible", "attached", "enabled"]).optional().describe("Element state to wait for (default: visible)"),
+  onAppear: branchSchema.describe("Actions to execute when element appears within timeout"),
+  onTimeout: branchSchema.optional().describe("Actions to execute if timeout occurs (silent continue if omitted)"),
+  pollInterval: z.number().int().positive().optional().describe("How often to check for element in milliseconds (default: 100)")
+}).describe("Wait for an element and branch based on whether it appears or times out");
+var ActionSchema = z.union([BaseActionSchema, conditionalActionSchema, waitForBranchActionSchema]);
+var defaultsSchema = z.object({
+  timeout: z.number().int().positive().optional().describe("Default timeout in milliseconds for all actions"),
+  screenshots: z.enum(["on-failure", "always", "never"]).optional().describe("When to capture screenshots during test execution")
+}).describe("Default settings that apply to all tests unless overridden");
+var webConfigSchema = z.object({
+  baseUrl: nonEmptyString.url().optional().describe("Base URL for the web application"),
+  browser: z.string().trim().optional().describe("Browser to use for testing"),
+  headless: z.boolean().optional().describe("Run browser in headless mode"),
+  timeout: z.number().int().positive().optional().describe("Timeout in milliseconds for web actions")
+}).describe("Web platform configuration");
+var androidConfigSchema = z.object({
+  appId: z.string().trim().optional().describe("Android application ID"),
+  device: z.string().trim().optional().describe("Device name or ID to run tests on")
+}).describe("Android platform configuration");
+var iosConfigSchema = z.object({
+  bundleId: z.string().trim().optional().describe("iOS bundle identifier"),
+  simulator: z.string().trim().optional().describe("Simulator name to run tests on")
+}).describe("iOS platform configuration");
+var emailConfigSchema = z.object({
+  provider: z.literal("inbucket").describe("Email testing provider"),
+  endpoint: nonEmptyString.url().optional().describe("Email service endpoint URL")
+}).describe("Email testing configuration");
+var appwriteConfigSchema = z.object({
+  endpoint: nonEmptyString.url().describe("Appwrite API endpoint"),
+  projectId: nonEmptyString.describe("Appwrite project ID"),
+  apiKey: nonEmptyString.describe("Appwrite API key with appropriate permissions"),
+  cleanup: z.boolean().optional().describe("Enable automatic cleanup of created resources"),
+  cleanupOnFailure: z.boolean().optional().describe("Clean up resources even when test fails")
+}).describe("Appwrite backend configuration");
+var healingSchema = z.object({
+  enabled: z.boolean().optional().describe("Enable self-healing capabilities"),
+  strategies: z.array(z.string().trim()).optional().describe("Healing strategies to use")
+}).describe("Self-healing test configuration");
+var webServerSchema = z.object({
+  command: nonEmptyString.optional().describe("Command to start the web server"),
+  auto: z.boolean().optional().describe("Automatically detect and run the dev server from package.json"),
+  static: z.string().optional().describe("Serve a static directory instead of running a command"),
+  url: nonEmptyString.url().describe("URL to wait for before starting tests"),
+  port: z.number().int().positive().optional().describe("Port number for the web server"),
+  reuseExistingServer: z.boolean().default(true).describe("Use existing server if already running at the specified URL"),
+  timeout: z.number().int().positive().default(3e4).describe("Timeout in milliseconds to wait for server to become available"),
+  cwd: z.string().optional().describe("Working directory for the server command")
+}).describe("Configuration for starting a web server before running tests").refine((config) => config.command || config.auto || config.static, {
+  message: "WebServerConfig requires command, auto: true, or static directory"
+});
+var aiSourceSchema = z.object({
+  pagesDir: z.string().optional().describe("Directory containing page components"),
+  componentsDir: z.string().optional().describe("Directory containing reusable components"),
+  extensions: z.array(z.string()).default([".vue", ".astro", ".tsx", ".jsx", ".svelte"]).describe("File extensions to include in source code analysis")
+}).optional().describe("Source code directories for AI to analyze when generating tests");
+var aiConfigSchema = z.object({
+  provider: z.enum(["anthropic", "openai", "ollama"]).describe("AI provider to use for test generation"),
+  model: nonEmptyString.describe("Model name to use"),
+  apiKey: z.string().trim().optional().describe("API key for the AI provider"),
+  baseUrl: z.string().trim().url().optional().describe("Base URL for the AI API (required for Ollama)"),
+  temperature: z.number().min(0).max(2).default(0.2).describe("Temperature for AI generation (0 = deterministic, 2 = very creative)"),
+  maxTokens: z.number().int().positive().default(4096).describe("Maximum tokens for AI responses"),
+  source: aiSourceSchema
+}).describe("AI configuration for test generation and healing");
+var cleanupDiscoverSchema = z.object({
+  enabled: z.boolean().default(true).describe("Enable auto-discovery of cleanup handlers in specified paths"),
+  paths: z.array(z.string()).default(["./tests/cleanup"]).describe("Directories to search for cleanup handler files"),
+  pattern: z.string().default("**/*.ts").describe("Glob pattern to match handler files")
+}).optional().describe("Auto-discovery configuration for cleanup handlers");
+var cleanupConfigSchema = z.object({
+  provider: z.string().optional().describe("Primary cleanup provider to use"),
+  parallel: z.boolean().default(false).describe("Execute cleanup operations in parallel"),
+  retries: z.number().min(1).max(10).default(3).describe("Number of retry attempts for failed cleanup operations"),
+  types: z.record(z.string(), z.string()).optional().describe("Map resource types to cleanup handler methods"),
+  handlers: z.array(z.string()).optional().describe("Explicit paths to custom cleanup handler files"),
+  discover: cleanupDiscoverSchema
+}).passthrough().describe("Comprehensive resource cleanup configuration");
+var platformsSchema = z.object({
+  web: webConfigSchema.optional(),
+  android: androidConfigSchema.optional(),
+  ios: iosConfigSchema.optional()
+}).describe("Platform-specific configurations");
+var previewConfigSchema = z.object({
+  build: z.object({
+    command: z.string().optional().describe("Command to build the project")
+  }).optional().describe("Build configuration"),
+  preview: z.object({
+    command: z.string().optional().describe("Command to start the preview server after build")
+  }).optional().describe("Preview server configuration"),
+  url: z.string().url().optional().describe("URL to wait for before starting tests"),
+  timeout: z.number().int().positive().optional().describe("Timeout in milliseconds to wait for preview server")
+}).describe("Configuration for the --preview flag (build and serve production build)");
+var TestConfigSchema = z.object({
+  defaults: defaultsSchema.optional(),
+  web: webConfigSchema.optional(),
+  android: androidConfigSchema.optional(),
+  ios: iosConfigSchema.optional(),
+  email: emailConfigSchema.optional(),
+  appwrite: appwriteConfigSchema.optional()
+}).describe("Test-specific configuration that overrides global settings");
+var TestDefinitionSchema = z.object({
+  name: nonEmptyString.describe("The name of the test"),
+  platform: z.enum(["web", "android", "ios"]).describe("The platform to run the test on"),
+  variables: z.record(z.string(), z.string()).optional().describe("Variables that can be referenced in test steps using ${VARIABLE_NAME} syntax"),
+  config: TestConfigSchema.optional(),
+  steps: z.array(ActionSchema).min(1).describe("The sequence of actions to execute in this test")
+}).describe("Schema for IntelliTester test definition files");
+var IntellitesterConfigSchema = z.object({
+  defaults: defaultsSchema.optional(),
+  ai: aiConfigSchema.optional(),
+  platforms: platformsSchema.optional(),
+  healing: healingSchema.optional(),
+  email: emailConfigSchema.optional(),
+  appwrite: appwriteConfigSchema.optional(),
+  cleanup: cleanupConfigSchema.optional(),
+  webServer: webServerSchema.optional(),
+  preview: previewConfigSchema.optional(),
+  secrets: z.record(z.string(), z.string().trim()).optional().describe("Secret values that can be referenced in tests")
+}).describe("Global configuration file for IntelliTester");
+var nonEmptyString2 = z.string().trim().min(1, "Value cannot be empty");
+var testReferenceSchema = z.object({
+  file: nonEmptyString2.describe("Path to the test file relative to the workflow file"),
+  id: nonEmptyString2.optional().describe("Optional ID for referencing this test in variables or dependencies"),
+  variables: z.record(z.string(), z.string()).optional().describe("Variables to inject or override for this specific test")
+}).describe("Reference to a test file");
+var workflowWebConfigSchema = z.object({
+  baseUrl: nonEmptyString2.url().optional().describe("Base URL for all tests in this workflow"),
+  browser: z.enum(["chromium", "firefox", "webkit"]).optional().describe("Browser to use for all web tests"),
+  headless: z.boolean().optional().describe("Run browser in headless mode")
+}).describe("Web platform configuration for the workflow");
+var workflowAppwriteConfigSchema = z.object({
+  endpoint: nonEmptyString2.url().describe("Appwrite API endpoint"),
+  projectId: nonEmptyString2.describe("Appwrite project ID"),
+  apiKey: nonEmptyString2.describe("Appwrite API key"),
+  cleanup: z.boolean().default(true).describe("Enable automatic cleanup of created resources"),
+  cleanupOnFailure: z.boolean().default(true).describe("Clean up resources even when tests fail")
+}).describe("Appwrite backend configuration for the workflow");
+var workflowCleanupDiscoverSchema = z.object({
+  enabled: z.boolean().default(true).describe("Enable auto-discovery of cleanup handlers"),
+  paths: z.array(z.string()).default(["./tests/cleanup"]).describe("Directories to search for cleanup handlers"),
+  pattern: z.string().default("**/*.ts").describe("Glob pattern for handler files")
+}).optional().describe("Auto-discovery configuration for cleanup handlers");
+var workflowCleanupConfigSchema = z.object({
+  provider: z.string().optional().describe("Cleanup provider to use"),
+  parallel: z.boolean().default(false).describe("Run cleanup tasks in parallel"),
+  retries: z.number().min(1).max(10).default(3).describe("Number of retry attempts for failed cleanup operations"),
+  types: z.record(z.string(), z.string()).optional().describe("Map resource types to cleanup handler methods"),
+  handlers: z.array(z.string()).optional().describe("Explicit paths to custom cleanup handler files"),
+  discover: workflowCleanupDiscoverSchema
+}).passthrough().describe("Resource cleanup configuration");
+var workflowWebServerSchema = z.object({
+  command: nonEmptyString2.optional().describe("Command to start the web server"),
+  auto: z.boolean().optional().describe("Auto-detect server start command from package.json"),
+  url: nonEmptyString2.url().describe("URL to wait for before starting tests"),
+  reuseExistingServer: z.boolean().default(true).describe("Use existing server if already running at the URL"),
+  timeout: z.number().int().positive().default(3e4).describe("Timeout in milliseconds to wait for server to start")
+}).describe("Configuration for starting a web server before tests");
+var workflowConfigSchema = z.object({
+  web: workflowWebConfigSchema.optional(),
+  appwrite: workflowAppwriteConfigSchema.optional(),
+  cleanup: workflowCleanupConfigSchema.optional(),
+  webServer: workflowWebServerSchema.optional()
+}).describe("Workflow-level configuration that applies to all tests");
+var WorkflowDefinitionSchema = z.object({
+  name: nonEmptyString2.describe("The name of the workflow"),
+  platform: z.enum(["web", "android", "ios"]).default("web").describe("The platform to run the workflow on"),
+  variables: z.record(z.string(), z.string()).optional().describe("Workflow-level variables available to all tests"),
+  config: workflowConfigSchema.optional(),
+  continueOnFailure: z.boolean().default(false).describe("Continue running subsequent tests even if a test fails"),
+  tests: z.array(testReferenceSchema).min(1, "Workflow must contain at least one test").describe("List of test files to execute in this workflow")
+}).describe("Schema for IntelliTester workflow files that orchestrate multiple tests");
+var nonEmptyString3 = z.string().trim().min(1, "Value cannot be empty");
+var workflowReferenceSchema = z.object({
+  file: nonEmptyString3.describe("Path to the workflow file"),
+  id: nonEmptyString3.optional().describe("Optional ID for referencing this workflow in dependencies"),
+  depends_on: z.array(nonEmptyString3).optional().describe("IDs of workflows that must complete before this one"),
+  on_failure: z.enum(["skip", "fail", "ignore"]).optional().describe("How to handle failure of this workflow"),
+  variables: z.record(z.string(), z.string()).optional().describe("Variables to inject or override for this workflow")
+}).describe("Reference to a workflow file");
+var pipelineWebConfigSchema = z.object({
+  baseUrl: nonEmptyString3.url().optional().describe("Base URL for all workflows in this pipeline"),
+  browser: z.enum(["chromium", "firefox", "webkit"]).optional().describe("Browser to use for all web tests"),
+  headless: z.boolean().optional().describe("Run browser in headless mode")
+}).describe("Web platform configuration for the pipeline");
+var pipelineAppwriteConfigSchema = z.object({
+  endpoint: nonEmptyString3.url().describe("Appwrite API endpoint"),
+  projectId: nonEmptyString3.describe("Appwrite project ID"),
+  apiKey: nonEmptyString3.describe("Appwrite API key"),
+  cleanup: z.boolean().default(true).describe("Enable automatic cleanup of created resources"),
+  cleanupOnFailure: z.boolean().default(true).describe("Clean up resources even when workflows fail")
+}).describe("Appwrite backend configuration for the pipeline");
+var pipelineCleanupDiscoverSchema = z.object({
+  enabled: z.boolean().default(true).describe("Enable auto-discovery of cleanup handlers"),
+  paths: z.array(z.string()).default(["./tests/cleanup"]).describe("Directories to search for cleanup handlers"),
+  pattern: z.string().default("**/*.ts").describe("Glob pattern for handler files")
+}).optional().describe("Auto-discovery configuration for cleanup handlers");
+var pipelineCleanupConfigSchema = z.object({
+  provider: z.string().optional().describe("Cleanup provider to use"),
+  parallel: z.boolean().default(false).describe("Run cleanup tasks in parallel"),
+  retries: z.number().min(1).max(10).default(3).describe("Number of retry attempts for failed cleanup operations"),
+  types: z.record(z.string(), z.string()).optional().describe("Map resource types to cleanup handler methods"),
+  handlers: z.array(z.string()).optional().describe("Explicit paths to custom cleanup handler files"),
+  discover: pipelineCleanupDiscoverSchema,
+  on_failure: z.boolean().default(true).describe("Run cleanup even if pipeline fails")
+}).passthrough().describe("Resource cleanup configuration");
+var pipelineWebServerSchema = z.object({
+  command: nonEmptyString3.optional().describe("Command to start the web server"),
+  auto: z.boolean().optional().describe("Auto-detect server start command from package.json"),
+  url: nonEmptyString3.url().describe("URL to wait for before starting workflows"),
+  reuseExistingServer: z.boolean().default(true).describe("Use existing server if already running at the URL"),
+  timeout: z.number().int().positive().default(3e4).describe("Timeout in milliseconds to wait for server to start")
+}).describe("Configuration for starting a web server before workflows");
+var pipelineConfigSchema = z.object({
+  web: pipelineWebConfigSchema.optional(),
+  appwrite: pipelineAppwriteConfigSchema.optional(),
+  cleanup: pipelineCleanupConfigSchema.optional(),
+  webServer: pipelineWebServerSchema.optional()
+}).describe("Pipeline-level configuration that applies to all workflows");
+var PipelineDefinitionSchema = z.object({
+  name: nonEmptyString3.describe("The name of the pipeline"),
+  platform: z.enum(["web", "android", "ios"]).default("web").describe("The platform to run the pipeline on"),
+  config: pipelineConfigSchema.optional(),
+  on_failure: z.enum(["skip", "fail", "ignore"]).default("skip").describe("Default failure handling for workflows"),
+  cleanup_on_failure: z.boolean().default(true).describe("Run cleanup even when pipeline fails"),
+  workflows: z.array(workflowReferenceSchema).min(1, "Pipeline must contain at least one workflow").describe("List of workflow files to execute in this pipeline")
+}).describe("Schema for IntelliTester pipeline files that orchestrate multiple workflows");
+
+// src/core/loader.ts
+var formatIssues = (issues) => issues.map((issue) => {
+  const path = issue.path.join(".") || "<root>";
+  return `${path}: ${issue.message}`;
+}).join("; ");
+var interpolateEnvVars = (obj) => {
+  if (typeof obj === "string") {
+    return obj.replace(/\$\{([^}]+)\}/g, (_, varName) => {
+      const value = process.env[varName];
+      if (value === void 0) {
+        throw new Error(`Environment variable ${varName} is not defined`);
+      }
+      return value;
+    });
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(interpolateEnvVars);
+  }
+  if (obj !== null && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = interpolateEnvVars(value);
+    }
+    return result;
+  }
+  return obj;
+};
+var parseWithSchema = (content, schema, subject) => {
+  let parsed;
+  try {
+    parsed = parse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid YAML for ${subject}: ${message}`);
+  }
+  const interpolated = interpolateEnvVars(parsed);
+  const result = schema.safeParse(interpolated);
+  if (!result.success) {
+    throw new Error(`Invalid ${subject}: ${formatIssues(result.error.issues)}`);
+  }
+  return result.data;
+};
+var parseTestDefinition = (content) => parseWithSchema(content, TestDefinitionSchema, "test definition");
+var loadTestDefinition = async (filePath) => {
+  const fileContent = await fs.readFile(filePath, "utf8");
+  return parseTestDefinition(fileContent);
+};
+var parseIntellitesterConfig = (content) => parseWithSchema(content, IntellitesterConfigSchema, "config");
+var loadIntellitesterConfig = async (filePath) => {
+  const fileContent = await fs.readFile(filePath, "utf8");
+  return parseIntellitesterConfig(fileContent);
+};
+var parseWorkflowDefinition = (content) => parseWithSchema(content, WorkflowDefinitionSchema, "workflow definition");
+var loadWorkflowDefinition = async (filePath) => {
+  const fileContent = await fs.readFile(filePath, "utf8");
+  return parseWorkflowDefinition(fileContent);
+};
+var isWorkflowFile = (filePath) => {
+  return filePath.endsWith(".workflow.yaml") || filePath.endsWith(".workflow.yml");
+};
+var isPipelineFile = (filePath) => {
+  return filePath.endsWith(".pipeline.yaml") || filePath.endsWith(".pipeline.yml");
+};
+var parsePipelineDefinition = (content) => parseWithSchema(content, PipelineDefinitionSchema, "pipeline definition");
+var loadPipelineDefinition = async (filePath) => {
+  const fileContent = await fs.readFile(filePath, "utf8");
+  return parsePipelineDefinition(fileContent);
+};
+var collectMissingEnvVars = (obj) => {
+  const missing = [];
+  const collect = (value) => {
+    if (typeof value === "string") {
+      const matches = value.matchAll(/\$\{([^}]+)\}/g);
+      for (const match of matches) {
+        const varName = match[1];
+        if (process.env[varName] === void 0 && !missing.includes(varName)) {
+          missing.push(varName);
+        }
+      }
+    } else if (Array.isArray(value)) {
+      value.forEach(collect);
+    } else if (value !== null && typeof value === "object") {
+      Object.values(value).forEach(collect);
+    }
+  };
+  collect(obj);
+  return missing;
+};
+var isWorkflowContent = (content) => {
+  try {
+    const parsed = parse(content);
+    return parsed && Array.isArray(parsed.tests) && !parsed.steps && !parsed.workflows;
+  } catch {
+    return false;
+  }
+};
+var isPipelineContent = (content) => {
+  try {
+    const parsed = parse(content);
+    return parsed && Array.isArray(parsed.workflows) && !parsed.steps;
+  } catch {
+    return false;
+  }
+};
+
+export { ActionSchema, IntellitesterConfigSchema, LocatorSchema, TestConfigSchema, TestDefinitionSchema, cleanupConfigSchema, cleanupDiscoverSchema, collectMissingEnvVars, isPipelineContent, isPipelineFile, isWorkflowContent, isWorkflowFile, loadIntellitesterConfig, loadPipelineDefinition, loadTestDefinition, loadWorkflowDefinition, parseIntellitesterConfig, parsePipelineDefinition, parseTestDefinition, parseWorkflowDefinition, previewConfigSchema };
+//# sourceMappingURL=chunk-BDSLT5FJ.js.map
+//# sourceMappingURL=chunk-BDSLT5FJ.js.map