@webpresso/agent-kit 0.21.0

package/dist/esm/docs-linter/blueprint-plan.js

@@ -0,0 +1,427 @@
+/**
+ * Blueprint Plan Format Validator
+ *
+ * Validates that implementation plans follow the Blueprint (Distributed Parallel Reproducible Execution) format.
+ * See: docs/templates/blueprint.md for specification.
+ *
+ * Rules enforced:
+ * 1. Tasks must use #### (4 hashes), not ### (3 hashes)
+ * 2. Task IDs must follow numeric X.Y format
+ * 3. Dependencies must use "Task X.Y" format, not bare "X.Y"
+ * 4. Executable blueprints must use canonical lifecycle statuses only
+ * 5. Every executable task must include explicit **Status:**
+ */
+const TASK_ID_SOURCE = String.raw `\d+(?:\.\d+)+(?:[a-z])?`;
+const TASK_ID_REGEX = new RegExp(`^${TASK_ID_SOURCE}$`);
+const THREE_HASH_TASK_HEADER_REGEX = new RegExp(String.raw `^###\s+(?:\[[^\]]+\]\s+)?Task\s+(${TASK_ID_SOURCE}):`, 'gm');
+const THREE_HASH_TASK_HEADER_LINE_REGEX = new RegExp(String.raw `^###\s+(?:\[[^\]]+\]\s+)?Task\s+${TASK_ID_SOURCE}:`);
+const FOUR_HASH_TASK_BLOCK_REGEX = new RegExp(String.raw `^####\s+(?:\[[^\]]+\]\s+)?Task\s+(${TASK_ID_SOURCE})\s*:\s*(.+)$`, 'gm');
+const EXECUTABLE_BLUEPRINT_STATUSES = new Set([
+    'draft',
+    'planned',
+    'parked',
+    'in-progress',
+    'completed',
+    'archived',
+]);
+const TASK_STATUSES = new Set(['todo', 'in_progress', 'blocked', 'done']);
+/**
+ * Find tasks using ### (3 hashes) instead of #### (4 hashes).
+ * Exported for testability.
+ */
+export function findWrongTaskHeaders(content) {
+    const wrongHeaderMatches = content.match(THREE_HASH_TASK_HEADER_REGEX);
+    if (!wrongHeaderMatches || !wrongHeaderMatches.length) {
+        return { count: 0, firstLineNumber: null };
+    }
+    // Find line number of first occurrence
+    const lines = content.split('\n');
+    const firstLineNumber = lines.findIndex((line) => THREE_HASH_TASK_HEADER_LINE_REGEX.test(line)) + 1;
+    return {
+        count: wrongHeaderMatches.length,
+        firstLineNumber: firstLineNumber || null,
+    };
+}
+/**
+ * Find malformed task IDs (#### Task without X.Y format).
+ * Exported for testability.
+ */
+export function findMalformedTaskIds(content) {
+    const taskHeaderMatches = content.matchAll(/^####\s+(?:\[[^\]]+\]\s+)?Task\s+([^:\s]+(?:\.[^:\s]+)*)\s*:/gm);
+    let malformedCount = 0;
+    for (const match of taskHeaderMatches) {
+        const taskId = match[1]?.trim();
+        if (!taskId || !TASK_ID_REGEX.test(taskId)) {
+            malformedCount += 1;
+        }
+    }
+    return malformedCount;
+}
+/**
+ * Check if dependencies use bare "X.Y" instead of "Task X.Y".
+ * Exported for testability.
+ */
+export function checkDependencyFormat(content) {
+    const dependsLines = content.match(/\*\*Depends:\*\*\s*(.+)/gi) || [];
+    for (const line of dependsLines) {
+        const dependsContent = line.replace(/\*\*Depends:\*\*\s*/i, '').trim();
+        // Skip "None" or empty
+        if (dependsContent.toLowerCase() === 'none' || dependsContent === '') {
+            continue;
+        }
+        // Match bare task IDs not preceded by "Task "
+        // Uses negative lookbehind to exclude "Task 1.1" or "Task 1.0.1" but match "1.1" or "1.0.1"
+        // Supports both 2-level (X.Y) and 3-level (X.Y.Z) task IDs
+        // Must not be preceded by a digit to avoid matching "0.1" in "1.0.1" or "Task 1.0.1"
+        const bareNumberPattern = /(?<![Tt]ask\s)(?<!\d\.)(\d+\.\d+(?:\.\d+)*(?:[a-z])?)\b/g;
+        if (bareNumberPattern.test(dependsContent)) {
+            return {
+                hasBareReferences: true,
+                exampleLine: dependsContent,
+            };
+        }
+    }
+    return {
+        hasBareReferences: false,
+        exampleLine: null,
+    };
+}
+/**
+ * Extract frontmatter from document content.
+ * Exported for testability.
+ */
+export function extractFrontmatter(content) {
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch || !frontmatterMatch[1]) {
+        return null;
+    }
+    const frontmatter = frontmatterMatch[1];
+    const result = {};
+    // Parse YAML-like key-value pairs
+    const lines = frontmatter.split('\n');
+    for (const line of lines) {
+        const match = line.match(/^(\w+):\s*(.+)$/);
+        if (match?.[1] && match[2]) {
+            const key = match[1];
+            const value = match[2].trim();
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Detect if plan is completed based on frontmatter and file path.
+ * Exported for testability.
+ */
+export function isCompleted(filePath, content) {
+    // Priority 1: Check frontmatter status
+    const frontmatter = extractFrontmatter(content);
+    if (frontmatter?.status) {
+        const status = frontmatter.status.toLowerCase().trim();
+        return status === 'completed';
+    }
+    // Priority 2: Check if file path contains /completed/
+    return filePath.includes('/completed/');
+}
+function extractTaskBlocks(content) {
+    const matches = Array.from(content.matchAll(FOUR_HASH_TASK_BLOCK_REGEX));
+    return matches.map((match, index) => {
+        const start = match.index ?? 0;
+        let next = matches[index + 1]?.index ?? content.length;
+        // Final task: slice stops at EOF today, which incorrectly absorbs global `## ...` sections
+        // (Critical Files, Verification, Zero-Defect, Completion Summary). Truncate at first H2.
+        if (next === content.length) {
+            const tail = content.slice(start);
+            const globalH2 = tail.search(/\n## [^#\s]/);
+            if (globalH2 !== -1) {
+                next = start + globalH2;
+            }
+        }
+        return {
+            id: match[1] ?? '',
+            section: content.slice(start, next),
+        };
+    });
+}
+/**
+ * Extract complexity from frontmatter, defaulting to 'M'.
+ * Exported for testability.
+ */
+export function extractComplexity(content) {
+    const frontmatter = extractFrontmatter(content);
+    if (frontmatter?.complexity) {
+        return frontmatter.complexity.toUpperCase().trim();
+    }
+    return 'M'; // Default to M
+}
+/**
+ * Check if Completion Summary section exists.
+ * Exported for testability.
+ */
+export function hasCompletionSummary(content) {
+    const pattern = /^## Completion Summary\s*$/m;
+    return pattern.test(content);
+}
+/**
+ * Extract Lessons Learned content from document.
+ * Returns null if section not found, otherwise returns content after heading.
+ * Exported for testability.
+ */
+export function extractLessonsLearnedContent(content) {
+    const pattern = /^### Lessons Learned\s*$/m;
+    const match = content.match(pattern);
+    if (!match || match.index === undefined) {
+        return null;
+    }
+    const startIndex = match.index + match[0].length;
+    // Extract content until next heading (###, ##, #) or end of file
+    const afterHeading = content.slice(startIndex);
+    const nextHeadingMatch = afterHeading.match(/^#{1,3}\s+/m);
+    const contentEnd = nextHeadingMatch?.index === undefined ? afterHeading.length : nextHeadingMatch.index;
+    const sectionContent = afterHeading.slice(0, contentEnd).trim();
+    return sectionContent;
+}
+/**
+ * Validate Lessons Learned content length (≥50 non-whitespace chars).
+ * Exported for testability.
+ */
+export function validateLessonsLearnedContent(content) {
+    if (content === null) {
+        return false;
+    }
+    // Remove all whitespace and count characters
+    const nonWhitespaceContent = content.replace(/\s+/g, '');
+    return nonWhitespaceContent.length >= 50;
+}
+/**
+ * Check if Lessons Learned appears after Completion Summary.
+ * Exported for testability.
+ */
+export function validateLessonsLearnedPlacement(content) {
+    const completionMatch = content.match(/^## Completion Summary\s*$/m);
+    const lessonsMatch = content.match(/^### Lessons Learned\s*$/m);
+    if (!completionMatch || !lessonsMatch) {
+        return false; // Missing sections handled separately
+    }
+    if (completionMatch.index === undefined || lessonsMatch.index === undefined) {
+        return false;
+    }
+    return lessonsMatch.index > completionMatch.index;
+}
+/**
+ * Create validation error for missing Completion Summary.
+ */
+function createMissingCompletionSummaryError(filePath) {
+    return {
+        file: filePath,
+        severity: 'error',
+        source: 'blueprint-format',
+        message: 'Completed plan missing required "## Completion Summary" section. ' +
+            'Add this section with Deliverables and Impact subsections.',
+        ruleId: 'blueprint-completion-summary',
+    };
+}
+/**
+ * Create validation error for wrong task headers.
+ */
+function createWrongHeaderError(filePath, count, lineNumber) {
+    return {
+        file: filePath,
+        line: lineNumber ?? undefined,
+        severity: 'error',
+        source: 'blueprint-format',
+        message: `Found ${count} task(s) using '### Task' (3 hashes). ` +
+            `Blueprint plans require '#### Task' (4 hashes). See docs/templates/blueprint.md`,
+        ruleId: 'blueprint-task-format',
+    };
+}
+/**
+ * Create validation error for malformed task IDs.
+ */
+function createMalformedTaskIdError(filePath, count) {
+    return {
+        file: filePath,
+        severity: 'error',
+        source: 'blueprint-format',
+        message: `Found ${count} malformed task ID(s). Tasks must use numeric format: '#### Task 1.1: Title'`,
+        ruleId: 'blueprint-task-id-format',
+    };
+}
+/**
+ * Create validation error for bare dependency references.
+ */
+function createBareDepError(filePath, exampleLine) {
+    return {
+        file: filePath,
+        severity: 'error',
+        source: 'blueprint-format',
+        message: `Invalid depends format: '${exampleLine}'. Use 'Task X.Y' format, not just 'X.Y'.`,
+        ruleId: 'blueprint-depends-format',
+    };
+}
+function createBlueprintStatusError(filePath, status) {
+    return {
+        file: filePath,
+        severity: 'error',
+        source: 'blueprint-format',
+        message: `Blueprint status "${status}" is not allowed. Use only: draft, planned, parked, in-progress, completed, archived.`,
+        ruleId: 'blueprint-status',
+    };
+}
+function createTaskStatusMissingError(filePath, taskId) {
+    return {
+        file: filePath,
+        severity: 'error',
+        source: 'blueprint-format',
+        message: `Task ${taskId} is missing required **Status:** line.`,
+        ruleId: 'blueprint-task-status-required',
+    };
+}
+function createTaskStatusInvalidError(filePath, taskId, status) {
+    return {
+        file: filePath,
+        severity: 'error',
+        source: 'blueprint-format',
+        message: `Task ${taskId} has invalid status "${status}". Use only: todo, in_progress, blocked, done.`,
+        ruleId: 'blueprint-task-status-invalid',
+    };
+}
+function createBlockedReasonRequiredError(filePath, taskId) {
+    return {
+        file: filePath,
+        severity: 'error',
+        source: 'blueprint-format',
+        message: `Task ${taskId} is blocked but missing non-empty **Blocked:** reason.`,
+        ruleId: 'blueprint-task-blocked-reason-required',
+    };
+}
+function createBlockedReasonMismatchError(filePath, taskId, status) {
+    return {
+        file: filePath,
+        severity: 'error',
+        source: 'blueprint-format',
+        message: `Task ${taskId} has **Blocked:** reason but status is ${status}.`,
+        ruleId: 'blueprint-task-blocked-reason-mismatch',
+    };
+}
+function createDoneAcceptanceMismatchError(filePath, taskId, checked, total) {
+    return {
+        file: filePath,
+        severity: 'error',
+        source: 'blueprint-format',
+        message: `Task ${taskId} is done but acceptance is ${checked}/${total}.`,
+        ruleId: 'blueprint-task-done-acceptance',
+    };
+}
+function createCompletedRequiresAllDoneError(filePath, taskId, taskStatus) {
+    return {
+        file: filePath,
+        severity: 'error',
+        source: 'blueprint-format',
+        message: `Blueprint status is completed but task ${taskId} is "${taskStatus}" (expected "done").`,
+        ruleId: 'blueprint-completed-requires-all-done',
+    };
+}
+function validateLifecycleContract(filePath, content) {
+    const errors = [];
+    const frontmatter = extractFrontmatter(content);
+    const status = frontmatter?.status?.trim();
+    if (!status || !EXECUTABLE_BLUEPRINT_STATUSES.has(status)) {
+        errors.push(createBlueprintStatusError(filePath, status ?? '(missing)'));
+        return errors;
+    }
+    const taskBlocks = extractTaskBlocks(content);
+    for (const task of taskBlocks) {
+        const statusMatch = task.section.match(/\*\*Status:\*\*\s*(.+)/i);
+        const blockedMatch = task.section.match(/\*\*Blocked:\*\*\s*(.+)/i);
+        const checkboxMatches = Array.from(task.section.matchAll(/^- \[([ x])\]/gm));
+        const total = checkboxMatches.length;
+        const checked = checkboxMatches.filter((match) => match[1] === 'x').length;
+        if (!statusMatch?.[1]) {
+            errors.push(createTaskStatusMissingError(filePath, task.id));
+            continue;
+        }
+        const taskStatus = statusMatch[1].trim();
+        if (!TASK_STATUSES.has(taskStatus)) {
+            errors.push(createTaskStatusInvalidError(filePath, task.id, taskStatus));
+            continue;
+        }
+        const blockedReason = blockedMatch?.[1]?.trim() ?? '';
+        if (taskStatus === 'blocked' && !blockedReason) {
+            errors.push(createBlockedReasonRequiredError(filePath, task.id));
+        }
+        if (taskStatus !== 'blocked' && blockedReason) {
+            errors.push(createBlockedReasonMismatchError(filePath, task.id, taskStatus));
+        }
+        if (taskStatus === 'done' && total > 0 && checked !== total) {
+            errors.push(createDoneAcceptanceMismatchError(filePath, task.id, checked, total));
+        }
+    }
+    if (status === 'completed') {
+        for (const task of taskBlocks) {
+            const statusMatch = task.section.match(/\*\*Status:\*\*\s*(.+)/i);
+            const taskStatus = statusMatch?.[1]?.trim();
+            if (!taskStatus || !TASK_STATUSES.has(taskStatus)) {
+                continue;
+            }
+            if (taskStatus !== 'done') {
+                errors.push(createCompletedRequiresAllDoneError(filePath, task.id, taskStatus));
+            }
+        }
+    }
+    return errors;
+}
+/**
+ * Validate task format (headers, IDs, dependencies).
+ * Extracted to reduce complexity.
+ */
+function validateTaskFormat(filePath, content) {
+    const errors = [];
+    // Check for ### Task instead of #### Task
+    const wrongHeaderResult = findWrongTaskHeaders(content);
+    if (wrongHeaderResult.count > 0) {
+        errors.push(createWrongHeaderError(filePath, wrongHeaderResult.count, wrongHeaderResult.firstLineNumber));
+    }
+    // Check for malformed task IDs
+    const malformedCount = findMalformedTaskIds(content);
+    if (malformedCount > 0) {
+        errors.push(createMalformedTaskIdError(filePath, malformedCount));
+    }
+    // Check for bare dependency references
+    const depCheckResult = checkDependencyFormat(content);
+    if (depCheckResult.hasBareReferences && depCheckResult.exampleLine) {
+        errors.push(createBareDepError(filePath, depCheckResult.exampleLine));
+    }
+    return errors;
+}
+/**
+ * Validate Blueprint plan format for implementation plans.
+ *
+ * Only runs on files with doc type `blueprint`.
+ * Returns array of validation errors found.
+ *
+ * @param filePath - File path for error reporting
+ * @param content - File content to validate
+ * @param docType - Document type from frontmatter
+ * @returns Array of validation errors (empty if valid)
+ */
+export function validateBlueprintPlan(filePath, content, docType) {
+    if (docType !== 'blueprint') {
+        return [];
+    }
+    // Validate blueprint/task lifecycle contract and task format
+    const errors = [
+        ...validateTaskFormat(filePath, content),
+        ...validateLifecycleContract(filePath, content),
+    ];
+    // Only validate Completion Summary and Lessons Learned for completed plans
+    if (!isCompleted(filePath, content)) {
+        return errors;
+    }
+    // Validate Completion Summary presence (required for ALL completed plans)
+    if (!hasCompletionSummary(content)) {
+        errors.push(createMissingCompletionSummaryError(filePath));
+    }
+    return errors;
+}
+//# sourceMappingURL=blueprint-plan.js.map

package/dist/esm/docs-linter/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Docs linter — blueprint plan validation.
+ *
+ * Re-exports the public API of the blueprint-plan validator.
+ */
+export { checkDependencyFormat, extractComplexity, extractFrontmatter, extractLessonsLearnedContent, findMalformedTaskIds, findWrongTaskHeaders, hasCompletionSummary, isCompleted, validateBlueprintPlan, validateLessonsLearnedContent, validateLessonsLearnedPlacement, } from './blueprint-plan.js';
+export type { ValidationError } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/docs-linter/index.js

@@ -0,0 +1,7 @@
+/**
+ * Docs linter — blueprint plan validation.
+ *
+ * Re-exports the public API of the blueprint-plan validator.
+ */
+export { checkDependencyFormat, extractComplexity, extractFrontmatter, extractLessonsLearnedContent, findMalformedTaskIds, findWrongTaskHeaders, hasCompletionSummary, isCompleted, validateBlueprintPlan, validateLessonsLearnedContent, validateLessonsLearnedPlacement, } from './blueprint-plan.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/docs-linter/types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Docs-linter validation error type.
+ *
+ * Inlined subset of the upstream docs-linter `types.ts` — only the
+ * `ValidationError` interface is needed by the blueprint-plan validator.
+ */
+export interface ValidationError {
+    file: string;
+    line?: number;
+    column?: number;
+    severity: 'error' | 'warning';
+    source: 'schema' | 'markdownlint' | 'vale' | 'structure' | 'context-limits' | 'blueprint-format';
+    message: string;
+    ruleId?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/docs-linter/types.js

@@ -0,0 +1,8 @@
+/**
+ * Docs-linter validation error type.
+ *
+ * Inlined subset of the upstream docs-linter `types.ts` — only the
+ * `ValidationError` interface is needed by the blueprint-plan validator.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/e2e/command-builder.d.ts

@@ -0,0 +1,3 @@
+import type { CommandConfig, E2eStepCommandOptions } from './types.js';
+export declare function buildE2eCommand(options: E2eStepCommandOptions): CommandConfig;
+//# sourceMappingURL=command-builder.d.ts.map

package/dist/esm/e2e/command-builder.js

@@ -0,0 +1,98 @@
+import path from 'node:path';
+export function buildE2eCommand(options) {
+    switch (options.step.runner) {
+        case 'playwright':
+            return buildPlaywrightCommand(options);
+        case 'vitest':
+            return buildVitestE2eCommand(options);
+        case 'command':
+            return buildCustomCommand(options);
+    }
+}
+function buildPlaywrightCommand(options) {
+    const { step } = options;
+    if (!step.configPath) {
+        throw new Error(`Step ${step.logName} uses runner "playwright" but does not define configPath.`);
+    }
+    const { baseDir, configArg, files } = resolveRunnerPaths(step.configPath, options.files ?? []);
+    const args = [...buildPnpmExecPrefix(baseDir), 'playwright', 'test', '--config', configArg];
+    appendPlaywrightFlags(args, options);
+    args.push(...(step.fixedArgs ?? []), ...files, ...(options.passthrough ?? []));
+    return { command: 'pnpm', args };
+}
+function buildVitestE2eCommand(options) {
+    const { step } = options;
+    if (!step.configPath) {
+        throw new Error(`Step ${step.logName} uses runner "vitest" but does not define configPath.`);
+    }
+    const { baseDir, configArg, files } = resolveRunnerPaths(step.configPath, options.files ?? []);
+    const args = [...buildPnpmExecPrefix(baseDir), 'vitest', 'run', '--config', configArg];
+    if (options.workers !== undefined) {
+        args.push('--poolOptions.threads.maxThreads', String(options.workers));
+    }
+    args.push(...(step.fixedArgs ?? []), ...files, ...(options.passthrough ?? []));
+    return { command: 'pnpm', args };
+}
+function buildCustomCommand(options) {
+    const { step } = options;
+    const commandArgs = step.commandArgs;
+    if (!commandArgs?.length) {
+        throw new Error(`Step ${step.logName} uses runner "command" but does not define commandArgs.`);
+    }
+    return {
+        command: commandArgs[0],
+        args: [
+            ...commandArgs.slice(1),
+            ...(step.fixedArgs ?? []),
+            ...(options.files ?? []),
+            ...(options.passthrough ?? []),
+        ],
+    };
+}
+function appendPlaywrightFlags(args, options) {
+    if (options.headed) {
+        if (options.step.supportsHeaded === false) {
+            throw new Error(`Step ${options.step.logName} does not support headed mode.`);
+        }
+        args.push('--headed');
+    }
+    if (options.debug) {
+        if (options.step.supportsDebug === false) {
+            throw new Error(`Step ${options.step.logName} does not support debug mode.`);
+        }
+        args.push('--debug');
+    }
+    if (options.workers !== undefined) {
+        args.push('--workers', String(options.workers));
+    }
+    if (options.testList) {
+        args.push('--test-list', options.testList);
+    }
+}
+function buildPnpmExecPrefix(baseDir) {
+    return baseDir === '.' ? ['exec'] : ['--dir', baseDir, 'exec'];
+}
+function resolveRunnerPaths(configPath, files) {
+    const normalizedConfigPath = configPath.replace(/\\/gu, '/');
+    const baseDir = path.posix.dirname(normalizedConfigPath);
+    const configArg = path.posix.basename(normalizedConfigPath);
+    if (baseDir === '.') {
+        return {
+            baseDir,
+            configArg: normalizedConfigPath,
+            files: [...files],
+        };
+    }
+    return {
+        baseDir,
+        configArg,
+        files: files.map((file) => {
+            const normalizedFile = file.replace(/\\/gu, '/');
+            if (path.posix.isAbsolute(normalizedFile) || normalizedFile.startsWith(`${baseDir}/`)) {
+                return path.posix.relative(baseDir, normalizedFile);
+            }
+            return normalizedFile;
+        }),
+    };
+}
+//# sourceMappingURL=command-builder.js.map

package/dist/esm/e2e/command-host-adapter.d.ts

@@ -0,0 +1,30 @@
+import type { E2eExecutionRequest, E2eHostAdapter, E2eStepDefinition, E2eSuiteDefinition, ResolvedE2eFile } from './types.js';
+export interface CommandHostAdapterRunDefinition {
+    batchKey: string;
+    logName: string;
+    command: string;
+    args: string[];
+    suiteId?: string;
+    envProfile?: string;
+    env?: Record<string, string>;
+    reportDir?: string;
+}
+export interface CommandHostAdapterGroupDefinition {
+    batchKey: string;
+    envProfile?: string;
+    env?: Record<string, string>;
+    run: CommandHostAdapterRunDefinition;
+}
+export interface CreateCommandE2eHostAdapterOptions {
+    listSuites: () => readonly E2eSuiteDefinition[];
+    resolveSuiteId: (name: string) => string | null;
+    resolveSuiteGroup?: (name: string) => readonly string[] | null;
+    normalizeFilePath: (filePath: string) => string;
+    resolveSuiteForFile: (filePath: string) => ResolvedE2eFile | null;
+    defaultSuiteId: string;
+    buildCommandGroup: (request: E2eExecutionRequest) => CommandHostAdapterGroupDefinition;
+}
+export declare function createCommandE2eHostAdapter(options: CreateCommandE2eHostAdapterOptions): E2eHostAdapter;
+export declare function cloneE2eStepDefinition(step: E2eStepDefinition): E2eStepDefinition;
+export declare function cloneE2eSuiteDefinition(suite: E2eSuiteDefinition): E2eSuiteDefinition;
+//# sourceMappingURL=command-host-adapter.d.ts.map

package/dist/esm/e2e/command-host-adapter.js

@@ -0,0 +1,70 @@
+export function createCommandE2eHostAdapter(options) {
+    return {
+        listSuites() {
+            return options.listSuites().map(cloneE2eSuiteDefinition);
+        },
+        resolveSuiteId: options.resolveSuiteId,
+        resolveSuiteGroup: options.resolveSuiteGroup,
+        normalizeFilePath: options.normalizeFilePath,
+        resolveSuiteForFile: options.resolveSuiteForFile,
+        buildExecutionPlan(request) {
+            return [
+                toPlannedRunGroup(options.buildCommandGroup(request), request, options.defaultSuiteId),
+            ];
+        },
+    };
+}
+export function cloneE2eStepDefinition(step) {
+    return {
+        runner: step.runner,
+        logName: step.logName,
+        configPath: step.configPath,
+        fixedFiles: step.fixedFiles ? [...step.fixedFiles] : undefined,
+        fixedArgs: step.fixedArgs ? [...step.fixedArgs] : undefined,
+        commandArgs: step.commandArgs ? [...step.commandArgs] : undefined,
+        supportsHeaded: step.supportsHeaded,
+        supportsDebug: step.supportsDebug,
+        batchKey: step.batchKey,
+        envProfile: step.envProfile,
+        reportDir: step.reportDir,
+        env: cloneEnv(step.env),
+    };
+}
+export function cloneE2eSuiteDefinition(suite) {
+    return {
+        id: suite.id,
+        aliases: suite.aliases ? [...suite.aliases] : undefined,
+        fileMatchers: [...suite.fileMatchers],
+        batchKey: suite.batchKey,
+        envProfile: suite.envProfile,
+        steps: suite.steps.map(cloneE2eStepDefinition),
+        env: cloneEnv(suite.env),
+    };
+}
+function toPlannedRunGroup(group, request, defaultSuiteId) {
+    return {
+        batchKey: group.batchKey,
+        envProfile: group.envProfile,
+        env: cloneEnv(group.env),
+        runs: [
+            {
+                suiteId: group.run.suiteId ?? request.suite ?? defaultSuiteId,
+                batchKey: group.run.batchKey,
+                envProfile: group.run.envProfile,
+                env: cloneEnv(group.run.env),
+                runner: 'command',
+                logName: group.run.logName,
+                reportDir: group.run.reportDir,
+                command: group.run.command,
+                args: [...group.run.args],
+            },
+        ],
+    };
+}
+function cloneEnv(env) {
+    if (!env || Object.keys(env).length === 0) {
+        return undefined;
+    }
+    return { ...env };
+}
+//# sourceMappingURL=command-host-adapter.js.map