@testsmith/perfornium 0.1.0

package/dist/cli/commands/distributed.js

@@ -0,0 +1,179 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distributedCommand = distributedCommand;
+const coordinator_1 = require("../../distributed/coordinator");
+const config_1 = require("../../config");
+const validator_1 = require("../../config/validator");
+const logger_1 = require("../../utils/logger");
+const timestamp_helper_1 = require("../../utils/timestamp-helper");
+const fs = __importStar(require("fs"));
+async function distributedCommand(configPath, options) {
+    try {
+        // Set log level: default=WARN, --verbose=INFO, --debug=DEBUG
+        if (options.debug) {
+            logger_1.logger.setLevel(logger_1.LogLevel.DEBUG);
+        }
+        else if (options.verbose) {
+            logger_1.logger.setLevel(logger_1.LogLevel.INFO);
+        }
+        // Parse test configuration
+        const parser = new config_1.ConfigParser();
+        const testConfig = await parser.parse(configPath, options.env);
+        // Validate configuration
+        const validator = new validator_1.ConfigValidator();
+        const validation = validator.validate(testConfig);
+        if (!validation.valid) {
+            logger_1.logger.error('❌ Configuration validation failed:');
+            validation.errors.forEach(error => logger_1.logger.error(`  - ${error}`));
+            process.exit(1);
+        }
+        // Parse worker configurations
+        const workers = parseWorkerConfigs(options.workers, options.workersFile);
+        if (workers.length === 0) {
+            logger_1.logger.error('❌ No workers specified');
+            process.exit(1);
+        }
+        // Create distributed test configuration
+        const distributedConfig = {
+            workers,
+            strategy: options.strategy || 'capacity_based',
+            sync_start: options.syncStart || false,
+            heartbeat_interval: 30000,
+            timeout: 300000,
+            retry_failed: true
+        };
+        // Initialize and run distributed test
+        const coordinator = new coordinator_1.DistributedCoordinator(distributedConfig);
+        // Set up graceful shutdown
+        process.on('SIGINT', async () => {
+            logger_1.logger.info('🛑 Received SIGINT, stopping distributed test...');
+            await coordinator.stop();
+            await coordinator.cleanup();
+            process.exit(0);
+        });
+        await coordinator.initialize();
+        logger_1.logger.info(`🚀 Starting distributed test with ${workers.length} workers`);
+        logger_1.logger.info(`📊 Strategy: ${distributedConfig.strategy}`);
+        logger_1.logger.info(`🔄 Sync start: ${distributedConfig.sync_start ? 'Yes' : 'No'}`);
+        await coordinator.executeTest(testConfig);
+        // Get aggregated results
+        const results = coordinator.getAggregatedResults();
+        logger_1.logger.info('📊 Distributed Test Results:');
+        logger_1.logger.info(`   Total Requests: ${results.summary.total_requests}`);
+        logger_1.logger.info(`   Success Rate: ${results.summary.success_rate.toFixed(2)}%`);
+        logger_1.logger.info(`   Avg Response Time: ${results.summary.avg_response_time.toFixed(2)}ms`);
+        logger_1.logger.info(`   Requests/sec: ${results.summary.requests_per_second.toFixed(2)}`);
+        // Output results if specified
+        if (options.output) {
+            const outputPath = options.output.endsWith('.json') ? options.output : `${options.output}/distributed-results.json`;
+            fs.writeFileSync(outputPath, JSON.stringify(results, null, 2));
+            logger_1.logger.success(`📄 Results written to: ${outputPath}`);
+        }
+        // Generate report if requested
+        if (options.report || testConfig.report?.generate) {
+            try {
+                const { EnhancedHTMLReportGenerator } = await Promise.resolve().then(() => __importStar(require('../../reporting/enhanced-html-generator')));
+                const generator = new EnhancedHTMLReportGenerator();
+                const timestamp = timestamp_helper_1.TimestampHelper.getTimestamp('file');
+                const reportFilename = `distributed-report-${timestamp}.html`;
+                // Always use timestamped filename for distributed reports in reports folder
+                const reportPath = options.output ?
+                    `${options.output}/${reportFilename}` :
+                    `reports/${reportFilename}`;
+                await generator.generate({
+                    testName: `${testConfig.name} (Distributed)`,
+                    summary: results.summary,
+                    results: results.results
+                }, reportPath);
+                logger_1.logger.success(`📋 Report generated: ${reportPath}`);
+            }
+            catch (error) {
+                logger_1.logger.error(`❌ Report generation failed: ${error}`);
+            }
+        }
+        await coordinator.cleanup();
+    }
+    catch (error) {
+        logger_1.logger.error(`❌ Distributed test failed: ${error.message}`);
+        if (options.verbose || options.debug) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+function parseWorkerConfigs(workersString, workersFile) {
+    const workers = [];
+    // Parse from command line
+    if (workersString) {
+        const workerAddresses = workersString.split(',').map(w => w.trim());
+        workerAddresses.forEach(address => {
+            const [host, portStr] = address.split(':');
+            const port = parseInt(portStr || '8080');
+            workers.push({
+                host: host.trim(),
+                port,
+                capacity: 100, // Default capacity
+                region: 'default'
+            });
+        });
+    }
+    // Parse from file
+    if (workersFile) {
+        try {
+            const fileContent = fs.readFileSync(workersFile, 'utf8');
+            const fileWorkers = JSON.parse(fileContent);
+            if (Array.isArray(fileWorkers)) {
+                // Apply defaults to workers from file
+                fileWorkers.forEach((w) => {
+                    workers.push({
+                        host: w.host || 'localhost',
+                        port: w.port || 8080,
+                        capacity: w.capacity ?? 100, // Default capacity if not specified
+                        region: w.region || 'default'
+                    });
+                });
+            }
+            else {
+                throw new Error('Workers file must contain an array of worker configurations');
+            }
+        }
+        catch (error) {
+            logger_1.logger.error(`❌ Failed to parse workers file ${workersFile}:`, error);
+            throw error;
+        }
+    }
+    return workers;
+}

package/dist/cli/commands/import.d.ts

@@ -0,0 +1,23 @@
+interface ImportOptions {
+    output: string;
+    format: 'yaml' | 'typescript';
+    verbose?: boolean;
+    interactive?: boolean;
+    autoCorrelate?: boolean;
+    baseUrl?: string;
+    sourceFile?: string;
+    tags?: string;
+    excludeTags?: string;
+    paths?: string;
+    methods?: string;
+    filterDomains?: string;
+    excludeDomains?: string;
+    services?: string;
+    operations?: string;
+    folders?: string;
+    scenariosPerFile?: string;
+    confidence?: string;
+    [key: string]: any;
+}
+export declare function importCommand(type: 'openapi' | 'wsdl' | 'har' | 'postman', sourceFile: string, options: ImportOptions): Promise<void>;
+export {};

package/dist/cli/commands/import.js

@@ -0,0 +1,461 @@
+"use strict";
+// src/commands/import.ts
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importCommand = importCommand;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const open_api_importer_1 = require("../../importers/open-api-importer");
+const wsdl_importer_1 = require("../../importers/wsdl-importer");
+const har_importer_1 = require("../../importers/har-importer");
+const test_output_writer_1 = require("../../utils/test-output-writer");
+async function importCommand(type, sourceFile, options) {
+    const spinner = (0, ora_1.default)(`Loading ${type.toUpperCase()} from ${sourceFile}`).start();
+    try {
+        // Validate source file exists
+        await fs.access(sourceFile);
+        let importer;
+        let endpoints = [];
+        // Create appropriate importer
+        switch (type) {
+            case 'openapi':
+                importer = await createOpenAPIImporter(sourceFile, options);
+                endpoints = importer.extractEndpoints();
+                break;
+            case 'wsdl':
+                importer = await createWSDLImporter(sourceFile, options);
+                endpoints = importer.extractServices();
+                break;
+            case 'har':
+                importer = await createHARImporter(sourceFile, options);
+                endpoints = importer.extractEndpoints();
+                break;
+            // case 'postman':
+            //     importer = await createPostmanImporter(sourceFile, options);
+            //     endpoints = importer.extractRequests();
+            //     break;
+            default:
+                throw new Error(`Unsupported import type: ${type}`);
+        }
+        spinner.succeed(`Found ${endpoints.length} ${type === 'wsdl' ? 'services' : 'endpoints'}`);
+        if (endpoints.length === 0) {
+            console.log(chalk_1.default.yellow('No endpoints found to import'));
+            return;
+        }
+        // Apply filters
+        endpoints = applyFilters(endpoints, type, options);
+        if (endpoints.length === 0) {
+            console.log(chalk_1.default.yellow('No endpoints match the specified filters'));
+            return;
+        }
+        console.log(chalk_1.default.blue(`${endpoints.length} endpoints after filtering`));
+        // Interactive selection if enabled
+        let selectedEndpoints = endpoints;
+        if (options.interactive) {
+            selectedEndpoints = await interactiveEndpointSelection(endpoints, type);
+        }
+        if (selectedEndpoints.length === 0) {
+            console.log(chalk_1.default.yellow('No endpoints selected'));
+            return;
+        }
+        // Generate scenarios
+        console.log(chalk_1.default.blue(`Generating scenarios for ${selectedEndpoints.length} endpoints...`));
+        let scenarios = importer.generateScenarios(selectedEndpoints);
+        // Apply correlations if enabled
+        if (options.autoCorrelate) {
+            console.log(chalk_1.default.blue('Analyzing data correlations...'));
+            scenarios = await applyCorrelations(scenarios, options);
+        }
+        // Generate output files
+        await generateOutputFiles(scenarios, type, options);
+        console.log(chalk_1.default.green(`Successfully imported ${scenarios.length} scenarios to ${options.output}/`));
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        spinner.fail(`Import failed: ${errorMessage}`);
+        if (options.verbose && error instanceof Error) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+async function createOpenAPIImporter(sourceFile, options) {
+    const content = await fs.readFile(sourceFile, 'utf8');
+    let spec;
+    if (sourceFile.endsWith('.json')) {
+        spec = JSON.parse(content);
+    }
+    else {
+        spec = yaml.load(content);
+    }
+    // Apply base URL override
+    if (options.baseUrl && spec.servers) {
+        spec.servers[0].url = options.baseUrl;
+    }
+    return new open_api_importer_1.OpenAPIImporter(spec);
+}
+async function createWSDLImporter(sourceFile, _options) {
+    const content = await fs.readFile(sourceFile, 'utf8');
+    return new wsdl_importer_1.WSDLImporter(content);
+}
+async function createHARImporter(sourceFile, _options) {
+    const content = await fs.readFile(sourceFile, 'utf8');
+    const har = JSON.parse(content);
+    return new har_importer_1.HARImporter(har);
+}
+// async function createPostmanImporter(sourceFile: string, options: ImportOptions): Promise<PostmanImporter> {
+//     const content = await fs.readFile(sourceFile, 'utf8');
+//     const collection = JSON.parse(content);
+//
+//     let environment = {};
+//     if (options.environment) {
+//         const envContent = await fs.readFile(options.environment, 'utf8');
+//         environment = JSON.parse(envContent);
+//     }
+//
+//     return new PostmanImporter(collection, environment);
+// }
+function applyFilters(endpoints, type, options) {
+    let filtered = [...endpoints];
+    // Apply type-specific filters
+    switch (type) {
+        case 'openapi':
+            filtered = applyOpenAPIFilters(filtered, options);
+            break;
+        case 'har':
+            filtered = applyHARFilters(filtered, options);
+            break;
+        case 'wsdl':
+            filtered = applyWSDLFilters(filtered, options);
+            break;
+        case 'postman':
+            filtered = applyPostmanFilters(filtered, options);
+            break;
+    }
+    return filtered;
+}
+function applyOpenAPIFilters(endpoints, options) {
+    let filtered = endpoints;
+    // Filter by tags
+    if (options.tags) {
+        const includeTags = options.tags.split(',').map((t) => t.trim());
+        filtered = filtered.filter(ep => ep.tags && ep.tags.some((tag) => includeTags.includes(tag)));
+    }
+    if (options.excludeTags) {
+        const excludeTags = options.excludeTags.split(',').map((t) => t.trim());
+        filtered = filtered.filter(ep => !ep.tags || !ep.tags.some((tag) => excludeTags.includes(tag)));
+    }
+    // Filter by paths
+    if (options.paths) {
+        const pathPatterns = options.paths.split(',').map((p) => new RegExp(p.trim()));
+        filtered = filtered.filter(ep => pathPatterns.some((pattern) => pattern.test(ep.path)));
+    }
+    // Filter by methods
+    if (options.methods) {
+        const methods = options.methods.split(',').map((m) => m.trim().toUpperCase());
+        filtered = filtered.filter(ep => methods.includes(ep.method));
+    }
+    return filtered;
+}
+function applyHARFilters(endpoints, options) {
+    let filtered = endpoints;
+    // Filter by domains
+    if (options.filterDomains) {
+        const domains = options.filterDomains.split(',').map((d) => d.trim());
+        filtered = filtered.filter(ep => domains.some((domain) => ep.path.includes(domain) || (ep.description && ep.description.includes(domain))));
+    }
+    if (options.excludeDomains) {
+        const excludeDomains = options.excludeDomains.split(',').map((d) => d.trim());
+        filtered = filtered.filter(ep => !excludeDomains.some((domain) => ep.path.includes(domain) || (ep.description && ep.description.includes(domain))));
+    }
+    // Filter by methods
+    if (options.methods) {
+        const methods = options.methods.split(',').map((m) => m.trim().toUpperCase());
+        filtered = filtered.filter(ep => methods.includes(ep.method));
+    }
+    return filtered;
+}
+function applyWSDLFilters(services, options) {
+    let filtered = services;
+    if (options.services) {
+        const serviceNames = options.services.split(',').map((s) => s.trim());
+        filtered = filtered.filter(svc => svc.name && serviceNames.some((name) => svc.name.includes(name)));
+    }
+    if (options.operations) {
+        const operationNames = options.operations.split(',').map((op) => op.trim());
+        filtered = filtered.filter(svc => svc.name && operationNames.some((name) => svc.name.includes(name)));
+    }
+    return filtered;
+}
+function applyPostmanFilters(requests, options) {
+    let filtered = requests;
+    if (options.folders) {
+        const folderNames = options.folders.split(',').map((f) => f.trim());
+        filtered = filtered.filter(req => req.folder && folderNames.includes(req.folder));
+    }
+    return filtered;
+}
+async function interactiveEndpointSelection(endpoints, type) {
+    // Group endpoints for better presentation
+    const grouped = groupEndpoints(endpoints, type);
+    const selected = [];
+    for (const [groupName, groupEndpoints] of Object.entries(grouped)) {
+        console.log(chalk_1.default.blue(`\n📁 ${groupName} (${groupEndpoints.length} ${type === 'wsdl' ? 'services' : 'endpoints'})`));
+        // Show endpoints in the group
+        groupEndpoints.forEach((ep, index) => {
+            const method = type === 'wsdl' ? 'SOAP' : ep.method;
+            console.log(`  ${index + 1}. ${chalk_1.default.cyan(method.padEnd(6))} ${ep.path}`);
+            if (ep.description) {
+                console.log(`     ${chalk_1.default.gray(ep.description.substring(0, 80))}${ep.description.length > 80 ? '...' : ''}`);
+            }
+        });
+        // Prompt for selection
+        const { selection } = await inquirer_1.default.prompt([{
+                type: 'input',
+                name: 'selection',
+                message: `Select from ${groupName} (numbers separated by commas, 'all', or 'skip'):`,
+                default: 'skip'
+            }]);
+        if (selection.toLowerCase() === 'skip')
+            continue;
+        if (selection.toLowerCase() === 'all') {
+            selected.push(...groupEndpoints);
+            continue;
+        }
+        // Parse selection
+        const indices = selection.split(',')
+            .map((s) => parseInt(s.trim()) - 1)
+            .filter((i) => i >= 0 && i < groupEndpoints.length);
+        for (const index of indices) {
+            selected.push(groupEndpoints[index]);
+        }
+    }
+    return selected;
+}
+function groupEndpoints(endpoints, type) {
+    const groups = {};
+    endpoints.forEach(endpoint => {
+        let groupName = 'Other';
+        switch (type) {
+            case 'openapi':
+                groupName = endpoint.tags && endpoint.tags.length > 0
+                    ? endpoint.tags[0]
+                    : extractPathGroup(endpoint.path);
+                break;
+            case 'har':
+                groupName = extractDomainFromEndpoint(endpoint);
+                break;
+            case 'wsdl':
+                groupName = endpoint.name ? extractServiceGroup(endpoint.name) : 'Unknown';
+                break;
+            case 'postman':
+                groupName = endpoint.folder || 'Root';
+                break;
+        }
+        if (!groups[groupName]) {
+            groups[groupName] = [];
+        }
+        groups[groupName].push(endpoint);
+    });
+    return groups;
+}
+function extractPathGroup(path) {
+    const parts = path.split('/').filter(p => p && !p.startsWith('{'));
+    return parts.length > 0 ? parts[0] : 'Root';
+}
+function extractDomainFromEndpoint(endpoint) {
+    if (endpoint.description && endpoint.description.includes('://')) {
+        try {
+            const url = new URL(endpoint.description.split(' ').find((part) => part.includes('://')) || '');
+            return url.hostname;
+        }
+        catch {
+            return 'Unknown';
+        }
+    }
+    return extractPathGroup(endpoint.path);
+}
+function extractServiceGroup(serviceName) {
+    const parts = serviceName.split('.');
+    return parts.length > 1 ? parts[0] : serviceName;
+}
+async function applyCorrelations(scenarios, _options) {
+    // Note: DataCorrelationAnalyzer is not available, so we'll skip this functionality for now
+    // You'll need to import and implement this class or remove this feature
+    console.log(chalk_1.default.yellow('Data correlation analysis is not available - skipping'));
+    return scenarios;
+    /* Commented out until DataCorrelationAnalyzer is available:
+    const analyzer = new DataCorrelationAnalyzer();
+    const correlatedScenarios: Scenario[] = [];
+
+    for (const scenario of scenarios) {
+        console.log(`Analyzing correlations for: ${scenario.name}`);
+
+        const dependencies = analyzer.analyzeSteps(scenario.steps);
+
+        if (dependencies.length > 0) {
+            console.log(`  Found ${dependencies.length} potential correlations`);
+
+            if (options.interactive) {
+                // Interactive correlation review
+                const approvedDeps = await reviewCorrelations(dependencies, scenario.name);
+                scenario.steps = analyzer.applyCorrelations(scenario.steps, approvedDeps);
+            } else {
+                // Auto-apply with confidence threshold
+                const threshold = parseFloat(options.confidence || '0.6');
+                const highConfidenceDeps = dependencies.filter((dep: Dependency) =>
+                    dep.required || (dep.description && dep.description.includes('confidence:') &&
+                        parseFloat(dep.description.match(/confidence:\s*(\d*\.?\d+)/)?.[1] || '0') >= threshold)
+                );
+
+                if (highConfidenceDeps.length > 0) {
+                    console.log(`  Applying ${highConfidenceDeps.length} high-confidence correlations`);
+                    scenario.steps = analyzer.applyCorrelations(scenario.steps, highConfidenceDeps);
+                }
+            }
+
+            // Generate correlation report
+            if (dependencies.length > 0 && options.output) {
+                const report = analyzer.generateCorrelationReport(dependencies);
+                const reportPath = path.join(options.output, `${scenario.name}-correlations.md`);
+                await ensureDirectory(path.dirname(reportPath));
+                await fs.writeFile(reportPath, report, 'utf8');
+            }
+        }
+
+        correlatedScenarios.push(scenario);
+    }
+
+    return correlatedScenarios;
+    */
+}
+async function reviewCorrelations(dependencies, scenarioName) {
+    console.log(chalk_1.default.blue(`\nReviewing correlations for: ${scenarioName}`));
+    const approved = [];
+    for (const dep of dependencies) {
+        console.log(chalk_1.default.yellow(`\nCorrelation: ${dep.sourceStep} → ${dep.targetStep}`));
+        console.log(`  Extract: ${dep.sourceField}`);
+        console.log(`  Use in: ${dep.targetLocation} as ${dep.targetField}`);
+        console.log(`  ${dep.description}`);
+        const { apply } = await inquirer_1.default.prompt([{
+                type: 'confirm',
+                name: 'apply',
+                message: 'Apply this correlation?',
+                default: dep.required
+            }]);
+        if (apply) {
+            approved.push(dep);
+        }
+    }
+    return approved;
+}
+async function generateOutputFiles(scenarios, type, options) {
+    await ensureDirectory(options.output);
+    // Group scenarios into files based on scenariosPerFile option
+    const scenariosPerFile = parseInt(options.scenariosPerFile || '10');
+    const groups = [];
+    for (let i = 0; i < scenarios.length; i += scenariosPerFile) {
+        groups.push(scenarios.slice(i, i + scenariosPerFile));
+    }
+    // Determine output format - now supports typescript
+    const format = options.format === 'typescript'
+        ? 'typescript'
+        : options.format || 'yaml';
+    for (let i = 0; i < groups.length; i++) {
+        const group = groups[i];
+        const testName = groups.length > 1
+            ? `${type.toUpperCase()} Import (Part ${i + 1})`
+            : `${type.toUpperCase()} Import`;
+        // Determine file extension based on format
+        const extension = format === 'typescript' ? '.spec.ts' : `.${format}`;
+        const filename = groups.length > 1
+            ? `${type}-import-${i + 1}${extension}`
+            : `${type}-import${extension}`;
+        const initialPath = path.join(options.output, filename);
+        const filepath = await test_output_writer_1.TestOutputWriter.getSafeFilename(initialPath);
+        // Use the generic TestOutputWriter
+        const writer = new test_output_writer_1.TestOutputWriter({
+            name: testName,
+            description: `Generated test configuration from ${type.toUpperCase()} import`,
+            baseUrl: options.baseUrl || '{{env.BASE_URL}}',
+            scenarios: group,
+            format: format,
+            outputPath: filepath,
+            sourceType: type,
+            metadata: {
+                importedFrom: options.sourceFile,
+                importedAt: new Date().toISOString(),
+                totalEndpoints: scenarios.length,
+                groupIndex: i + 1,
+                totalGroups: groups.length,
+                filters: {
+                    tags: options.tags,
+                    excludeTags: options.excludeTags,
+                    paths: options.paths,
+                    methods: options.methods,
+                    domains: options.filterDomains,
+                    excludeDomains: options.excludeDomains,
+                    services: options.services,
+                    operations: options.operations,
+                    folders: options.folders
+                }
+            }
+        }, {
+            // DSL options for importers
+            includeDataGeneration: true,
+            includeCSVSupport: true,
+            includeHooks: true,
+            includeCustomLogic: type !== 'wsdl', // Less custom logic for SOAP
+            includeMultipleLoadPatterns: true
+        });
+        const savedPath = await writer.write();
+        console.log(chalk_1.default.green(`✅ Generated: ${savedPath}`));
+    }
+}
+async function ensureDirectory(dirPath) {
+    try {
+        await fs.mkdir(dirPath, { recursive: true });
+    }
+    catch {
+        // Directory might already exist
+    }
+}

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,7 @@
+export interface InitOptions {
+    template?: string;
+    examples?: boolean;
+    force?: boolean;
+    dryRun?: boolean;
+}
+export declare function initCommand(directory: string, options: InitOptions): Promise<void>;