intellitester 0.2.1 → 0.2.12

package/dist/{chunk-ZWHIDROO.cjs → chunk-H34IO3AV.cjs}

@@ -24,14 +24,14 @@ var prompts__default = /*#__PURE__*/_interopDefault(prompts);
 
 var nonEmptyString = zod.z.string().trim().min(1, "Value cannot be empty");
 var LocatorSchema = zod.z.object({
-  description: zod.z.string().trim().optional(),
-  testId: zod.z.string().trim().optional(),
-  text: zod.z.string().trim().optional(),
-  css: zod.z.string().trim().optional(),
-  xpath: zod.z.string().trim().optional(),
-  role: zod.z.string().trim().optional(),
-  name: zod.z.string().trim().optional()
-}).refine(
+  description: zod.z.string().trim().optional().describe("AI-friendly description of the element to find"),
+  testId: zod.z.string().trim().optional().describe("data-testid attribute value"),
+  text: zod.z.string().trim().optional().describe("Visible text content"),
+  css: zod.z.string().trim().optional().describe("CSS selector"),
+  xpath: zod.z.string().trim().optional().describe("XPath selector"),
+  role: zod.z.string().trim().optional().describe("ARIA role"),
+  name: zod.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
   ),
@@ -39,73 +39,73 @@ var LocatorSchema = zod.z.object({
 );
 var navigateActionSchema = zod.z.object({
   type: zod.z.literal("navigate"),
-  value: nonEmptyString
-});
+  value: nonEmptyString.describe("URL or path to navigate to")
+}).describe("Navigate to a URL");
 var tapActionSchema = zod.z.object({
   type: zod.z.literal("tap"),
   target: LocatorSchema
-});
+}).describe("Click or tap on an element");
 var inputActionSchema = zod.z.object({
   type: zod.z.literal("input"),
   target: LocatorSchema,
-  value: zod.z.string()
-});
+  value: zod.z.string().describe("Text to input (can reference variables with ${VAR_NAME})")
+}).describe("Input text into a field");
 var assertActionSchema = zod.z.object({
   type: zod.z.literal("assert"),
   target: LocatorSchema,
-  value: zod.z.string().optional()
-});
+  value: zod.z.string().optional().describe("Expected text content")
+}).describe("Assert that an element exists or contains expected text");
 var waitActionSchema = zod.z.object({
   type: zod.z.literal("wait"),
-  target: LocatorSchema.optional(),
-  timeout: zod.z.number().int().positive().optional()
-}).refine((action) => action.target || action.timeout, {
+  target: LocatorSchema.optional().describe("Element to wait for"),
+  timeout: zod.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 = zod.z.object({
   type: zod.z.literal("scroll"),
-  target: LocatorSchema.optional(),
-  direction: zod.z.enum(["up", "down"]).optional(),
-  amount: zod.z.number().int().positive().optional()
-});
+  target: LocatorSchema.optional().describe("Element to scroll"),
+  direction: zod.z.enum(["up", "down"]).optional().describe("Direction to scroll"),
+  amount: zod.z.number().int().positive().optional().describe("Amount to scroll in pixels")
+}).describe("Scroll the page or an element");
 var screenshotActionSchema = zod.z.object({
   type: zod.z.literal("screenshot"),
-  name: zod.z.string().optional()
-});
+  name: zod.z.string().optional().describe("Name for the screenshot file")
+}).describe("Take a screenshot");
 var setVarActionSchema = zod.z.object({
   type: zod.z.literal("setVar"),
-  name: nonEmptyString,
-  value: zod.z.string().optional(),
-  from: zod.z.enum(["response", "element", "email"]).optional(),
-  path: zod.z.string().optional(),
-  pattern: zod.z.string().optional()
-});
+  name: nonEmptyString.describe("Variable name to set"),
+  value: zod.z.string().optional().describe("Static value to set"),
+  from: zod.z.enum(["response", "element", "email"]).optional().describe("Extract value from a source"),
+  path: zod.z.string().optional().describe("JSON path or selector for extraction"),
+  pattern: zod.z.string().optional().describe("Regular expression pattern for extraction")
+}).describe("Set a variable for use in later steps");
 var emailWaitForActionSchema = zod.z.object({
   type: zod.z.literal("email.waitFor"),
-  mailbox: nonEmptyString,
-  timeout: zod.z.number().int().positive().optional(),
-  subjectContains: zod.z.string().optional()
-});
+  mailbox: nonEmptyString.describe("Email address or mailbox to check"),
+  timeout: zod.z.number().int().positive().optional().describe("How long to wait for email in milliseconds"),
+  subjectContains: zod.z.string().optional().describe("Filter by email subject")
+}).describe("Wait for an email to arrive");
 var emailExtractCodeActionSchema = zod.z.object({
   type: zod.z.literal("email.extractCode"),
-  saveTo: nonEmptyString,
-  pattern: zod.z.string().optional()
-});
+  saveTo: nonEmptyString.describe("Variable name to save the extracted code"),
+  pattern: zod.z.string().optional().describe("Regular expression to extract code")
+}).describe("Extract a verification code from email");
 var emailExtractLinkActionSchema = zod.z.object({
   type: zod.z.literal("email.extractLink"),
-  saveTo: nonEmptyString,
-  pattern: zod.z.string().optional()
-});
+  saveTo: nonEmptyString.describe("Variable name to save the extracted link"),
+  pattern: zod.z.string().optional().describe("Regular expression to match specific links")
+}).describe("Extract a link from email");
 var emailClearActionSchema = zod.z.object({
   type: zod.z.literal("email.clear"),
-  mailbox: nonEmptyString
-});
+  mailbox: nonEmptyString.describe("Email address or mailbox to clear")
+}).describe("Clear emails from a mailbox");
 var appwriteVerifyEmailActionSchema = zod.z.object({
   type: zod.z.literal("appwrite.verifyEmail")
-});
+}).describe("Verify email using Appwrite");
 var debugActionSchema = zod.z.object({
   type: zod.z.literal("debug")
-});
+}).describe("Pause execution and open Playwright Inspector for debugging");
 var ActionSchema = zod.z.discriminatedUnion("type", [
   navigateActionSchema,
   tapActionSchema,
@@ -123,96 +123,92 @@ var ActionSchema = zod.z.discriminatedUnion("type", [
   debugActionSchema
 ]);
 var defaultsSchema = zod.z.object({
-  timeout: zod.z.number().int().positive().optional(),
-  screenshots: zod.z.enum(["on-failure", "always", "never"]).optional()
-});
+  timeout: zod.z.number().int().positive().optional().describe("Default timeout in milliseconds for all actions"),
+  screenshots: zod.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 = zod.z.object({
-  baseUrl: nonEmptyString.url().optional(),
-  browser: zod.z.string().trim().optional(),
-  headless: zod.z.boolean().optional(),
-  timeout: zod.z.number().int().positive().optional()
-});
+  baseUrl: nonEmptyString.url().optional().describe("Base URL for the web application"),
+  browser: zod.z.string().trim().optional().describe("Browser to use for testing"),
+  headless: zod.z.boolean().optional().describe("Run browser in headless mode"),
+  timeout: zod.z.number().int().positive().optional().describe("Timeout in milliseconds for web actions")
+}).describe("Web platform configuration");
 var androidConfigSchema = zod.z.object({
-  appId: zod.z.string().trim().optional(),
-  device: zod.z.string().trim().optional()
-});
+  appId: zod.z.string().trim().optional().describe("Android application ID"),
+  device: zod.z.string().trim().optional().describe("Device name or ID to run tests on")
+}).describe("Android platform configuration");
 var iosConfigSchema = zod.z.object({
-  bundleId: zod.z.string().trim().optional(),
-  simulator: zod.z.string().trim().optional()
-});
+  bundleId: zod.z.string().trim().optional().describe("iOS bundle identifier"),
+  simulator: zod.z.string().trim().optional().describe("Simulator name to run tests on")
+}).describe("iOS platform configuration");
 var emailConfigSchema = zod.z.object({
-  provider: zod.z.literal("inbucket"),
-  endpoint: nonEmptyString.url().optional()
-});
+  provider: zod.z.literal("inbucket").describe("Email testing provider"),
+  endpoint: nonEmptyString.url().optional().describe("Email service endpoint URL")
+}).describe("Email testing configuration");
 var appwriteConfigSchema = zod.z.object({
-  endpoint: nonEmptyString.url(),
-  projectId: nonEmptyString,
-  apiKey: nonEmptyString,
-  cleanup: zod.z.boolean().optional(),
-  cleanupOnFailure: zod.z.boolean().optional()
-});
+  endpoint: nonEmptyString.url().describe("Appwrite API endpoint"),
+  projectId: nonEmptyString.describe("Appwrite project ID"),
+  apiKey: nonEmptyString.describe("Appwrite API key with appropriate permissions"),
+  cleanup: zod.z.boolean().optional().describe("Enable automatic cleanup of created resources"),
+  cleanupOnFailure: zod.z.boolean().optional().describe("Clean up resources even when test fails")
+}).describe("Appwrite backend configuration");
 var healingSchema = zod.z.object({
-  enabled: zod.z.boolean().optional(),
-  strategies: zod.z.array(zod.z.string().trim()).optional()
-});
+  enabled: zod.z.boolean().optional().describe("Enable self-healing capabilities"),
+  strategies: zod.z.array(zod.z.string().trim()).optional().describe("Healing strategies to use")
+}).describe("Self-healing test configuration");
 var webServerSchema = zod.z.object({
-  // Option 1: Explicit command
-  command: nonEmptyString.optional(),
-  // Option 2: Auto-detect
-  auto: zod.z.boolean().optional(),
-  // Option 3: Static directory
-  static: zod.z.string().optional(),
-  // Required
-  url: nonEmptyString.url(),
-  port: zod.z.number().int().positive().optional(),
-  reuseExistingServer: zod.z.boolean().default(true),
-  timeout: zod.z.number().int().positive().default(3e4),
-  cwd: zod.z.string().optional()
-}).refine((config) => config.command || config.auto || config.static, {
+  command: nonEmptyString.optional().describe("Command to start the web server"),
+  auto: zod.z.boolean().optional().describe("Automatically detect and run the dev server from package.json"),
+  static: zod.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: zod.z.number().int().positive().optional().describe("Port number for the web server"),
+  reuseExistingServer: zod.z.boolean().default(true).describe("Use existing server if already running at the specified URL"),
+  timeout: zod.z.number().int().positive().default(3e4).describe("Timeout in milliseconds to wait for server to become available"),
+  cwd: zod.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 = zod.z.object({
-  pagesDir: zod.z.string().optional(),
-  componentsDir: zod.z.string().optional(),
-  extensions: zod.z.array(zod.z.string()).default([".vue", ".astro", ".tsx", ".jsx", ".svelte"])
-}).optional();
+  pagesDir: zod.z.string().optional().describe("Directory containing page components"),
+  componentsDir: zod.z.string().optional().describe("Directory containing reusable components"),
+  extensions: zod.z.array(zod.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 = zod.z.object({
-  provider: zod.z.enum(["anthropic", "openai", "ollama"]),
-  model: nonEmptyString,
-  apiKey: zod.z.string().trim().optional(),
-  baseUrl: zod.z.string().trim().url().optional(),
-  temperature: zod.z.number().min(0).max(2).default(0.2),
-  maxTokens: zod.z.number().int().positive().default(4096),
+  provider: zod.z.enum(["anthropic", "openai", "ollama"]).describe("AI provider to use for test generation"),
+  model: nonEmptyString.describe("Model name to use"),
+  apiKey: zod.z.string().trim().optional().describe("API key for the AI provider"),
+  baseUrl: zod.z.string().trim().url().optional().describe("Base URL for the AI API (required for Ollama)"),
+  temperature: zod.z.number().min(0).max(2).default(0.2).describe("Temperature for AI generation (0 = deterministic, 2 = very creative)"),
+  maxTokens: zod.z.number().int().positive().default(4096).describe("Maximum tokens for AI responses"),
   source: aiSourceSchema
-});
+}).describe("AI configuration for test generation and healing");
 var cleanupDiscoverSchema = zod.z.object({
-  enabled: zod.z.boolean().default(true),
-  paths: zod.z.array(zod.z.string()).default(["./tests/cleanup"]),
-  pattern: zod.z.string().default("**/*.ts")
-}).optional();
+  enabled: zod.z.boolean().default(true).describe("Enable auto-discovery of cleanup handlers in specified paths"),
+  paths: zod.z.array(zod.z.string()).default(["./tests/cleanup"]).describe("Directories to search for cleanup handler files"),
+  pattern: zod.z.string().default("**/*.ts").describe("Glob pattern to match handler files")
+}).optional().describe("Auto-discovery configuration for cleanup handlers");
 var cleanupConfigSchema = zod.z.object({
-  provider: zod.z.string().optional(),
-  parallel: zod.z.boolean().default(false),
-  retries: zod.z.number().min(1).max(10).default(3),
-  types: zod.z.record(zod.z.string(), zod.z.string()).optional(),
-  handlers: zod.z.array(zod.z.string()).optional(),
+  provider: zod.z.string().optional().describe("Primary cleanup provider to use"),
+  parallel: zod.z.boolean().default(false).describe("Execute cleanup operations in parallel"),
+  retries: zod.z.number().min(1).max(10).default(3).describe("Number of retry attempts for failed cleanup operations"),
+  types: zod.z.record(zod.z.string(), zod.z.string()).optional().describe("Map resource types to cleanup handler methods"),
+  handlers: zod.z.array(zod.z.string()).optional().describe("Explicit paths to custom cleanup handler files"),
   discover: cleanupDiscoverSchema
-}).passthrough();
+}).passthrough().describe("Comprehensive resource cleanup configuration");
 var platformsSchema = zod.z.object({
   web: webConfigSchema.optional(),
   android: androidConfigSchema.optional(),
   ios: iosConfigSchema.optional()
-});
+}).describe("Platform-specific configurations");
 var previewConfigSchema = zod.z.object({
   build: zod.z.object({
-    command: zod.z.string().optional()
-  }).optional(),
+    command: zod.z.string().optional().describe("Command to build the project")
+  }).optional().describe("Build configuration"),
   preview: zod.z.object({
-    command: zod.z.string().optional()
-  }).optional(),
-  url: zod.z.string().url().optional(),
-  timeout: zod.z.number().int().positive().optional()
-});
+    command: zod.z.string().optional().describe("Command to start the preview server after build")
+  }).optional().describe("Preview server configuration"),
+  url: zod.z.string().url().optional().describe("URL to wait for before starting tests"),
+  timeout: zod.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 = zod.z.object({
   defaults: defaultsSchema.optional(),
   web: webConfigSchema.optional(),
@@ -220,14 +216,14 @@ var TestConfigSchema = zod.z.object({
   ios: iosConfigSchema.optional(),
   email: emailConfigSchema.optional(),
   appwrite: appwriteConfigSchema.optional()
-});
+}).describe("Test-specific configuration that overrides global settings");
 var TestDefinitionSchema = zod.z.object({
-  name: nonEmptyString,
-  platform: zod.z.enum(["web", "android", "ios"]),
-  variables: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+  name: nonEmptyString.describe("The name of the test"),
+  platform: zod.z.enum(["web", "android", "ios"]).describe("The platform to run the test on"),
+  variables: zod.z.record(zod.z.string(), zod.z.string()).optional().describe("Variables that can be referenced in test steps using ${VARIABLE_NAME} syntax"),
   config: TestConfigSchema.optional(),
-  steps: zod.z.array(ActionSchema).min(1)
-});
+  steps: zod.z.array(ActionSchema).min(1).describe("The sequence of actions to execute in this test")
+}).describe("Schema for IntelliTester test definition files");
 var IntellitesterConfigSchema = zod.z.object({
   defaults: defaultsSchema.optional(),
   ai: aiConfigSchema.optional(),
@@ -238,119 +234,114 @@ var IntellitesterConfigSchema = zod.z.object({
   cleanup: cleanupConfigSchema.optional(),
   webServer: webServerSchema.optional(),
   preview: previewConfigSchema.optional(),
-  secrets: zod.z.record(zod.z.string(), zod.z.string().trim()).optional()
-});
+  secrets: zod.z.record(zod.z.string(), zod.z.string().trim()).optional().describe("Secret values that can be referenced in tests")
+}).describe("Global configuration file for IntelliTester");
 var nonEmptyString2 = zod.z.string().trim().min(1, "Value cannot be empty");
 var testReferenceSchema = zod.z.object({
-  file: nonEmptyString2,
-  id: nonEmptyString2.optional(),
-  // Optional ID for referencing in variables
-  variables: zod.z.record(zod.z.string(), zod.z.string()).optional()
-  // Override/inject variables
-});
+  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: zod.z.record(zod.z.string(), zod.z.string()).optional().describe("Variables to inject or override for this specific test")
+}).describe("Reference to a test file");
 var workflowWebConfigSchema = zod.z.object({
-  baseUrl: nonEmptyString2.url().optional(),
-  browser: zod.z.enum(["chromium", "firefox", "webkit"]).optional(),
-  headless: zod.z.boolean().optional()
-});
+  baseUrl: nonEmptyString2.url().optional().describe("Base URL for all tests in this workflow"),
+  browser: zod.z.enum(["chromium", "firefox", "webkit"]).optional().describe("Browser to use for all web tests"),
+  headless: zod.z.boolean().optional().describe("Run browser in headless mode")
+}).describe("Web platform configuration for the workflow");
 var workflowAppwriteConfigSchema = zod.z.object({
-  endpoint: nonEmptyString2.url(),
-  projectId: nonEmptyString2,
-  apiKey: nonEmptyString2,
-  cleanup: zod.z.boolean().default(true),
-  // Backwards compatibility
-  cleanupOnFailure: zod.z.boolean().default(true)
-  // Backwards compatibility
-});
+  endpoint: nonEmptyString2.url().describe("Appwrite API endpoint"),
+  projectId: nonEmptyString2.describe("Appwrite project ID"),
+  apiKey: nonEmptyString2.describe("Appwrite API key"),
+  cleanup: zod.z.boolean().default(true).describe("Enable automatic cleanup of created resources"),
+  cleanupOnFailure: zod.z.boolean().default(true).describe("Clean up resources even when tests fail")
+}).describe("Appwrite backend configuration for the workflow");
 var workflowCleanupDiscoverSchema = zod.z.object({
-  enabled: zod.z.boolean().default(true),
-  paths: zod.z.array(zod.z.string()).default(["./tests/cleanup"]),
-  pattern: zod.z.string().default("**/*.ts")
-}).optional();
+  enabled: zod.z.boolean().default(true).describe("Enable auto-discovery of cleanup handlers"),
+  paths: zod.z.array(zod.z.string()).default(["./tests/cleanup"]).describe("Directories to search for cleanup handlers"),
+  pattern: zod.z.string().default("**/*.ts").describe("Glob pattern for handler files")
+}).optional().describe("Auto-discovery configuration for cleanup handlers");
 var workflowCleanupConfigSchema = zod.z.object({
-  provider: zod.z.string().optional(),
-  parallel: zod.z.boolean().default(false),
-  retries: zod.z.number().min(1).max(10).default(3),
-  types: zod.z.record(zod.z.string(), zod.z.string()).optional(),
-  handlers: zod.z.array(zod.z.string()).optional(),
+  provider: zod.z.string().optional().describe("Cleanup provider to use"),
+  parallel: zod.z.boolean().default(false).describe("Run cleanup tasks in parallel"),
+  retries: zod.z.number().min(1).max(10).default(3).describe("Number of retry attempts for failed cleanup operations"),
+  types: zod.z.record(zod.z.string(), zod.z.string()).optional().describe("Map resource types to cleanup handler methods"),
+  handlers: zod.z.array(zod.z.string()).optional().describe("Explicit paths to custom cleanup handler files"),
   discover: workflowCleanupDiscoverSchema
-}).passthrough();
+}).passthrough().describe("Resource cleanup configuration");
 var workflowWebServerSchema = zod.z.object({
-  command: nonEmptyString2.optional(),
-  auto: zod.z.boolean().optional(),
-  url: nonEmptyString2.url(),
-  reuseExistingServer: zod.z.boolean().default(true),
-  timeout: zod.z.number().int().positive().default(3e4)
-});
+  command: nonEmptyString2.optional().describe("Command to start the web server"),
+  auto: zod.z.boolean().optional().describe("Auto-detect server start command from package.json"),
+  url: nonEmptyString2.url().describe("URL to wait for before starting tests"),
+  reuseExistingServer: zod.z.boolean().default(true).describe("Use existing server if already running at the URL"),
+  timeout: zod.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 = zod.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 = zod.z.object({
-  name: nonEmptyString2,
-  platform: zod.z.enum(["web", "android", "ios"]).default("web"),
+  name: nonEmptyString2.describe("The name of the workflow"),
+  platform: zod.z.enum(["web", "android", "ios"]).default("web").describe("The platform to run the workflow on"),
   config: workflowConfigSchema.optional(),
-  continueOnFailure: zod.z.boolean().default(false),
-  tests: zod.z.array(testReferenceSchema).min(1, "Workflow must contain at least one test")
-});
+  continueOnFailure: zod.z.boolean().default(false).describe("Continue running subsequent tests even if a test fails"),
+  tests: zod.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 = zod.z.string().trim().min(1, "Value cannot be empty");
 var workflowReferenceSchema = zod.z.object({
-  file: nonEmptyString3,
-  id: nonEmptyString3.optional(),
-  depends_on: zod.z.array(nonEmptyString3).optional(),
-  on_failure: zod.z.enum(["skip", "fail", "ignore"]).optional(),
-  variables: zod.z.record(zod.z.string(), zod.z.string()).optional()
-});
+  file: nonEmptyString3.describe("Path to the workflow file"),
+  id: nonEmptyString3.optional().describe("Optional ID for referencing this workflow in dependencies"),
+  depends_on: zod.z.array(nonEmptyString3).optional().describe("IDs of workflows that must complete before this one"),
+  on_failure: zod.z.enum(["skip", "fail", "ignore"]).optional().describe("How to handle failure of this workflow"),
+  variables: zod.z.record(zod.z.string(), zod.z.string()).optional().describe("Variables to inject or override for this workflow")
+}).describe("Reference to a workflow file");
 var pipelineWebConfigSchema = zod.z.object({
-  baseUrl: nonEmptyString3.url().optional(),
-  browser: zod.z.enum(["chromium", "firefox", "webkit"]).optional(),
-  headless: zod.z.boolean().optional()
-});
+  baseUrl: nonEmptyString3.url().optional().describe("Base URL for all workflows in this pipeline"),
+  browser: zod.z.enum(["chromium", "firefox", "webkit"]).optional().describe("Browser to use for all web tests"),
+  headless: zod.z.boolean().optional().describe("Run browser in headless mode")
+}).describe("Web platform configuration for the pipeline");
 var pipelineAppwriteConfigSchema = zod.z.object({
-  endpoint: nonEmptyString3.url(),
-  projectId: nonEmptyString3,
-  apiKey: nonEmptyString3,
-  cleanup: zod.z.boolean().default(true),
-  cleanupOnFailure: zod.z.boolean().default(true)
-});
+  endpoint: nonEmptyString3.url().describe("Appwrite API endpoint"),
+  projectId: nonEmptyString3.describe("Appwrite project ID"),
+  apiKey: nonEmptyString3.describe("Appwrite API key"),
+  cleanup: zod.z.boolean().default(true).describe("Enable automatic cleanup of created resources"),
+  cleanupOnFailure: zod.z.boolean().default(true).describe("Clean up resources even when workflows fail")
+}).describe("Appwrite backend configuration for the pipeline");
 var pipelineCleanupDiscoverSchema = zod.z.object({
-  enabled: zod.z.boolean().default(true),
-  paths: zod.z.array(zod.z.string()).default(["./tests/cleanup"]),
-  pattern: zod.z.string().default("**/*.ts")
-}).optional();
+  enabled: zod.z.boolean().default(true).describe("Enable auto-discovery of cleanup handlers"),
+  paths: zod.z.array(zod.z.string()).default(["./tests/cleanup"]).describe("Directories to search for cleanup handlers"),
+  pattern: zod.z.string().default("**/*.ts").describe("Glob pattern for handler files")
+}).optional().describe("Auto-discovery configuration for cleanup handlers");
 var pipelineCleanupConfigSchema = zod.z.object({
-  provider: zod.z.string().optional(),
-  parallel: zod.z.boolean().default(false),
-  retries: zod.z.number().min(1).max(10).default(3),
-  types: zod.z.record(zod.z.string(), zod.z.string()).optional(),
-  handlers: zod.z.array(zod.z.string()).optional(),
+  provider: zod.z.string().optional().describe("Cleanup provider to use"),
+  parallel: zod.z.boolean().default(false).describe("Run cleanup tasks in parallel"),
+  retries: zod.z.number().min(1).max(10).default(3).describe("Number of retry attempts for failed cleanup operations"),
+  types: zod.z.record(zod.z.string(), zod.z.string()).optional().describe("Map resource types to cleanup handler methods"),
+  handlers: zod.z.array(zod.z.string()).optional().describe("Explicit paths to custom cleanup handler files"),
   discover: pipelineCleanupDiscoverSchema,
-  on_failure: zod.z.boolean().default(true)
-  // Run cleanup even if pipeline fails
-}).passthrough();
+  on_failure: zod.z.boolean().default(true).describe("Run cleanup even if pipeline fails")
+}).passthrough().describe("Resource cleanup configuration");
 var pipelineWebServerSchema = zod.z.object({
-  command: nonEmptyString3.optional(),
-  auto: zod.z.boolean().optional(),
-  url: nonEmptyString3.url(),
-  reuseExistingServer: zod.z.boolean().default(true),
-  timeout: zod.z.number().int().positive().default(3e4)
-});
+  command: nonEmptyString3.optional().describe("Command to start the web server"),
+  auto: zod.z.boolean().optional().describe("Auto-detect server start command from package.json"),
+  url: nonEmptyString3.url().describe("URL to wait for before starting workflows"),
+  reuseExistingServer: zod.z.boolean().default(true).describe("Use existing server if already running at the URL"),
+  timeout: zod.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 = zod.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 = zod.z.object({
-  name: nonEmptyString3,
-  platform: zod.z.enum(["web", "android", "ios"]).default("web"),
+  name: nonEmptyString3.describe("The name of the pipeline"),
+  platform: zod.z.enum(["web", "android", "ios"]).default("web").describe("The platform to run the pipeline on"),
   config: pipelineConfigSchema.optional(),
-  on_failure: zod.z.enum(["skip", "fail", "ignore"]).default("skip"),
-  cleanup_on_failure: zod.z.boolean().default(true),
-  workflows: zod.z.array(workflowReferenceSchema).min(1, "Pipeline must contain at least one workflow")
-});
+  on_failure: zod.z.enum(["skip", "fail", "ignore"]).default("skip").describe("Default failure handling for workflows"),
+  cleanup_on_failure: zod.z.boolean().default(true).describe("Run cleanup even when pipeline fails"),
+  workflows: zod.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) => {
@@ -2578,5 +2569,5 @@ exports.runWorkflowWithContext = runWorkflowWithContext;
 exports.setupAppwriteTracking = setupAppwriteTracking;
 exports.startTrackingServer = startTrackingServer;
 exports.startWebServer = startWebServer;
-//# sourceMappingURL=chunk-ZWHIDROO.cjs.map
-//# sourceMappingURL=chunk-ZWHIDROO.cjs.map
+//# sourceMappingURL=chunk-H34IO3AV.cjs.map
+//# sourceMappingURL=chunk-H34IO3AV.cjs.map