erosolar-cli 1.7.90 → 1.7.93

package/dist/core/isolatedVerifier.js

@@ -1,601 +1,129 @@
-#!/usr/bin/env node
 /**
- * Isolated Verification Runner
+ * Isolated Verification System
  *
- * This script runs in a completely separate Node.js process to verify
- * assistant responses. It receives verification requests via stdin and
- * outputs results via stdout.
- *
- * This ensures verification is completely isolated from the main CLI process:
- * - Separate memory space
- * - Separate event loop
- * - Independent error handling
- * - No shared state with main process
- *
- * @license MIT
+ * Provides runtime isolation for verification tasks by running them in separate processes.
+ * This ensures that verification failures don't affect the main CLI process.
  */
-import { createProvider } from '../providers/providerFactory.js';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-import { runVerificationTests } from './cliTestHarness.js';
-const execAsync = promisify(exec);
-// ============================================================================
-// CLAIM EXTRACTION
-// ============================================================================
-const EXTRACT_CLAIMS_PROMPT = `Extract ALL verifiable claims from this AI assistant response.
-
-RESPONSE:
----
-{RESPONSE}
----
-
-CONTEXT: {CONTEXT}
-WORKING_DIR: {WORKING_DIR}
-
-For each claim, determine:
-1. What specific assertion is being made
-2. Category: file_op (created/modified/deleted files), code (compiles/tests pass), command (executed successfully), state (something changed), behavior (feature works), fact (verifiable truth)
-3. How it can be verified (shell command, file check, etc.)
-4. Priority: critical (must verify), high (should verify), medium (nice to verify), low (optional)
-
-Return JSON array:
-[{
-  "id": "c1",
-  "statement": "the specific claim",
-  "category": "file_op|code|command|state|behavior|fact",
-  "verifiable": true,
-  "priority": "critical|high|medium|low",
-  "context": {"path": "/path/if/relevant", "command": "if relevant"}
-}]
-
-Output ONLY valid JSON array.`;
-async function extractClaims(response, workingDir, conversationHistory, llmQuery) {
-    // Try LLM-based extraction first
-    try {
-        const prompt = EXTRACT_CLAIMS_PROMPT
-            .replace('{RESPONSE}', response.slice(0, 8000))
-            .replace('{CONTEXT}', conversationHistory.slice(-3).join('\n') || '')
-            .replace('{WORKING_DIR}', workingDir);
-        const result = await llmQuery(prompt);
-        const match = result.match(/\[[\s\S]*\]/);
-        if (match) {
-            const claims = JSON.parse(match[0]);
-            if (claims.length > 0) {
-                return claims;
-            }
-        }
-    }
-    catch (err) {
-        // LLM extraction failed, fall through to pattern-based
-        process.stderr.write(`LLM claim extraction failed: ${err instanceof Error ? err.message : 'unknown'}\n`);
-    }
-    // Fallback: Pattern-based claim extraction
-    return extractClaimsWithPatterns(response, workingDir);
-}
-/**
- * Fallback pattern-based claim extraction when LLM is unavailable
- */
-function extractClaimsWithPatterns(response, workingDir) {
-    const claims = [];
-    let claimId = 1;
-    // Pattern 1: File creation/modification claims
-    // "created src/foo.ts", "wrote to file.js", "Updated package.json"
-    const filePatterns = [
-        /(?:created|wrote|updated|modified|edited|added)\s+(?:file\s+)?[`"']?([\/\w\-\.]+\.\w+)[`"']?/gi,
-        /(?:src|dist|lib|test)\/[\w\-\/]+\.\w+/g,
-    ];
-    for (const pattern of filePatterns) {
-        const matches = response.matchAll(pattern);
-        for (const match of matches) {
-            const filePath = match[1] || match[0];
-            if (filePath && !claims.some(c => c.context['path'] === filePath)) {
-                claims.push({
-                    id: `c${claimId++}`,
-                    statement: `File exists: ${filePath}`,
-                    category: 'file_op',
-                    verifiable: true,
-                    priority: 'high',
-                    context: { path: filePath.startsWith('/') ? filePath : `${workingDir}/${filePath}` }
-                });
-            }
-        }
-    }
-    // Pattern 2: Test success claims
-    // "all tests pass", "12/12 tests successful", "tests passing"
-    const testPatterns = [
-        /(\d+)\/\1\s+tests?\s+(?:pass|success)/i,
-        /all\s+tests?\s+pass/i,
-        /tests?\s+(?:are\s+)?passing/i,
-        /✅.*tests?\s+pass/i,
-    ];
-    for (const pattern of testPatterns) {
-        if (pattern.test(response)) {
-            claims.push({
-                id: `c${claimId++}`,
-                statement: 'All tests are passing',
-                category: 'code',
-                verifiable: true,
-                priority: 'critical',
-                context: { command: 'npm test' }
-            });
-            break;
-        }
-    }
-    // Pattern 3: Build success claims
-    // "build succeeded", "compiled successfully"
-    const buildPatterns = [
-        /build\s+succeed/i,
-        /compil(?:ed|ation)\s+success/i,
-        /✅.*build/i,
-    ];
-    for (const pattern of buildPatterns) {
-        if (pattern.test(response)) {
-            claims.push({
-                id: `c${claimId++}`,
-                statement: 'Build succeeds',
-                category: 'code',
-                verifiable: true,
-                priority: 'critical',
-                context: { command: 'npm run build' }
-            });
-            break;
-        }
-    }
-    // Pattern 4: Implementation complete claims
-    // "implemented", "created", "added feature"
-    const implementPatterns = [
-        /(?:successfully\s+)?implement(?:ed|ation)/i,
-        /feature\s+(?:is\s+)?(?:now\s+)?(?:complete|ready|working)/i,
-        /integration\s+ready/i,
-        /refactor\s+(?:successfully\s+)?completed?/i,
-        /delivered/i,
-    ];
-    for (const pattern of implementPatterns) {
-        if (pattern.test(response)) {
-            claims.push({
-                id: `c${claimId++}`,
-                statement: 'Implementation is complete and working',
-                category: 'behavior',
-                verifiable: true,
-                priority: 'high',
-                context: {}
-            });
-            break;
-        }
-    }
-    // Pattern 5: Paste/input handling claims
-    // "paste", "multi-line input", "input handling"
-    const pastePatterns = [
-        /(?:paste|pasted|pasting).*(?:work|handle|process)/i,
-        /multi[\s-]?line\s+(?:paste|input)/i,
-        /(?:block|chunk)\s+description/i,
-        /input\s+handling/i,
-        /graceful(?:ly)?\s+(?:handle|sent|submit)/i,
-    ];
-    for (const pattern of pastePatterns) {
-        if (pattern.test(response)) {
-            claims.push({
-                id: `c${claimId++}`,
-                statement: 'Paste handling feature works correctly',
-                category: 'cli_behavior',
-                verifiable: true,
-                priority: 'high',
-                context: {
-                    testType: 'cli_interactive',
-                    feature: 'paste_handling'
-                }
+export class IsolatedVerifier {
+    /**
+     * Verify task completion in an isolated process
+     */
+    async verifyTaskCompletion(taskName, config) {
+        const startTime = Date.now();
+        try {
+            const scriptPath = await this.createVerificationScript(config);
+            const { exec } = await import('node:child_process');
+            const { promisify } = await import('node:util');
+            const execAsync = promisify(exec);
+            const result = await execAsync(`node "${scriptPath}"`, {
+                timeout: 30000
             });
-            break;
+            const duration = Date.now() - startTime;
+            return {
+                success: true,
+                report: this.generateReport(taskName, config, result.stdout, result.stderr, duration),
+                duration
+            };
         }
-    }
-    // Pattern 6: Specific file path mentions with context suggesting they exist
-    const specificFilePattern = /[`"']?((?:src|dist|lib|test|scripts)\/[\w\-\/\.]+)[`"']?/g;
-    const fileMatches = response.matchAll(specificFilePattern);
-    for (const match of fileMatches) {
-        const filePath = match[1];
-        if (filePath && !claims.some(c => c.context['path']?.toString().includes(filePath || ''))) {
-            claims.push({
-                id: `c${claimId++}`,
-                statement: `Referenced file exists: ${filePath}`,
-                category: 'file_op',
-                verifiable: true,
-                priority: 'medium',
-                context: { path: `${workingDir}/${filePath}` }
-            });
+        catch (error) {
+            const duration = Date.now() - startTime;
+            return {
+                success: false,
+                report: this.generateErrorReport(taskName, config, error, duration),
+                error: error.message,
+                duration
+            };
         }
     }
-    return claims.slice(0, 10); // Limit to 10 claims
-}
-// ============================================================================
-// TEST GENERATION
-// ============================================================================
-const GENERATE_TESTS_PROMPT = `Generate isolated runtime tests for these claims.
-
-CLAIMS:
-{CLAIMS}
+    /**
+     * Create a verification script that runs in isolation
+     */
+    async createVerificationScript(config) {
+        const fs = await import('node:fs');
+        const os = await import('node:os');
+        const path = await import('node:path');
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'isolated-verification-'));
+        const scriptPath = path.join(tempDir, 'verification.js');
+        const scriptContent = this.generateVerificationScript(config);
+        fs.writeFileSync(scriptPath, scriptContent, 'utf8');
+        return scriptPath;
+    }
+    /**
+     * Generate the verification script content
+     */
+    generateVerificationScript(config) {
+        const fileChecks = config.expectedFiles.map(file => `  if (!require('fs').existsSync("${file}")) {
+    console.error('MISSING FILE: ${file}');
+    process.exit(1);
+  }`).join('\n');
+        const commandExecutions = config.verificationCommands.map(cmd => `  try {
+    const { execSync } = require('child_process');
+    execSync("${cmd}", { stdio: 'inherit' });
+  } catch (error) {
+    console.error('COMMAND FAILED: ${cmd}');
+    console.error(error.message);
+    process.exit(1);
+  }`).join('\n');
+        return `#!/usr/bin/env node
+/**
+ * Isolated Verification Script
+ * Generated by Erosolar CLI
+ */
 
-WORKING_DIR: {WORKING_DIR}
-PLATFORM: {PLATFORM}
+console.log('ISOLATED VERIFICATION REPORT');
+console.log('=============================');
+console.log('Task: ${config.taskDescription}');
+console.log('');
 
-For each claim, generate a test that verifies it using:
-- Shell commands (for file checks, git status, etc.)
-- Expected output patterns
+// File existence checks
+${fileChecks}
 
-Return JSON array:
-[{
-  "id": "test-1",
-  "description": "what we're testing",
-  "shellCommands": ["ls -la path", "cat file"],
-  "expectedOutputs": ["pattern1", "pattern2"],
-  "expectedBehavior": "description for LLM assessment",
-  "timeout": 30000
-}]
+// Command executions
+${commandExecutions}
 
-Use READ-ONLY commands only. No destructive operations.
-Output ONLY valid JSON array.`;
-async function generateTests(claims, workingDir, llmQuery) {
-    if (claims.length === 0)
-        return [];
-    try {
-        const prompt = GENERATE_TESTS_PROMPT
-            .replace('{CLAIMS}', JSON.stringify(claims.slice(0, 10)))
-            .replace('{WORKING_DIR}', workingDir)
-            .replace('{PLATFORM}', process.platform);
-        const result = await llmQuery(prompt);
-        const match = result.match(/\[[\s\S]*\]/);
-        if (match) {
-            return JSON.parse(match[0]);
-        }
-    }
-    catch {
-        // Fall through to basic tests
-    }
-    // Fallback: generate basic tests for all verifiable claims
-    return generateBasicTests(claims, workingDir);
-}
-/**
- * Generate basic tests without LLM assistance
- */
-function generateBasicTests(claims, workingDir) {
-    const tests = [];
-    for (const claim of claims.filter(c => c.verifiable)) {
-        const test = {
-            id: `test-${tests.length + 1}`,
-            description: claim.statement,
-            shellCommands: [],
-            expectedOutputs: [],
-            timeout: 30000
-        };
-        switch (claim.category) {
-            case 'file_op': {
-                const filePath = claim.context['path'];
-                if (filePath) {
-                    // Check if file exists
-                    test.shellCommands = [`test -f "${filePath}" && echo "FILE_EXISTS" || echo "FILE_NOT_FOUND"`];
-                    test.expectedOutputs = ['FILE_EXISTS'];
-                }
-                break;
-            }
-            case 'code': {
-                const command = claim.context['command'];
-                if (command === 'npm test') {
-                    test.shellCommands = [`cd "${workingDir}" && npm test 2>&1 | tail -20`];
-                    test.expectedOutputs = ['pass', 'passing', '0 fail'];
-                }
-                else if (command === 'npm run build') {
-                    test.shellCommands = [`cd "${workingDir}" && npm run build 2>&1`];
-                    test.expectedOutputs = ['postbuild', 'success']; // tsc typically outputs nothing on success
-                }
-                else {
-                    test.shellCommands = [`cd "${workingDir}" && npm run build 2>&1 | tail -10`];
-                }
-                break;
-            }
-            case 'behavior': {
-                // For behavior claims, check that build passes as a proxy
-                test.shellCommands = [`cd "${workingDir}" && npm run build 2>&1 | tail -5`];
-                test.expectedOutputs = ['postbuild'];
-                break;
-            }
-            case 'cli_behavior': {
-                // For CLI behavior claims, run relevant tests based on feature
-                const feature = claim.context['feature'];
-                if (feature === 'paste_handling') {
-                    // Run paste-specific tests via npm test with filter
-                    test.shellCommands = [
-                        // First run any paste/input related tests
-                        `cd "${workingDir}" && npm test -- --testPathPattern="(paste|input|multiLine)" --passWithNoTests 2>&1 | tail -30`,
-                        // Also run the RobustInputProcessor tests specifically
-                        `cd "${workingDir}" && npm test -- --testPathPattern="robustInputProcessor" --passWithNoTests 2>&1 | tail -20`,
-                    ];
-                    test.expectedOutputs = ['pass', 'passing'];
-                    test.timeout = 60000;
-                    test.expectedBehavior = 'Paste handling tests pass and verify multi-line input is processed correctly';
-                }
-                else {
-                    // Generic CLI behavior - run build
-                    test.shellCommands = [`cd "${workingDir}" && npm run build 2>&1 | tail -5`];
-                    test.expectedOutputs = ['postbuild'];
-                }
-                break;
-            }
-            default: {
-                // Generic check - just verify the project builds
-                test.shellCommands = [`cd "${workingDir}" && npm run build 2>&1 | tail -5`];
-            }
-        }
-        if (test.shellCommands && test.shellCommands.length > 0) {
-            tests.push(test);
-        }
-    }
-    return tests.slice(0, 5); // Limit to 5 tests for performance
-}
-// ============================================================================
-// TEST EXECUTION
-// ============================================================================
-/**
- * Run PTY-based CLI verification for behavior claims
- * @internal - Reserved for future use when PTY-based verification is needed
- */
-async function _runCLIBehaviorTest(claim, cwd) {
-    const feature = claim.context['feature'] || 'generic';
-    try {
-        const verification = await runVerificationTests(feature, cwd);
-        // Convert PTY test results to our TestResult format
-        const test = {
-            id: `cli-behavior-${feature}`,
-            description: claim.statement,
-            timeout: 60000,
-        };
-        const result = {
-            test,
-            success: verification.passed,
-            output: verification.results.map(r => r.output).join('\n---\n'),
-            errors: verification.results.flatMap(r => r.errors).join('\n'),
-            matchedPatterns: verification.passed ? [verification.summary] : [],
-            unmatchedPatterns: verification.passed ? [] : [verification.summary],
-            llmAssessment: `PTY Test: ${verification.summary}`,
-        };
-        return result;
-    }
-    catch (err) {
-        const test = {
-            id: `cli-behavior-${feature}`,
-            description: claim.statement,
-        };
-        return {
-            test,
-            success: false,
-            output: '',
-            errors: err instanceof Error ? err.message : String(err),
-            matchedPatterns: [],
-            unmatchedPatterns: ['PTY test failed to run'],
-        };
-    }
-}
-async function runShellCommand(cmd, cwd) {
-    // Safety check - block dangerous commands
-    const dangerous = [/\brm\s/i, /rmdir/i, /sudo/i, /chmod\s*7/i, /eval\s*\(/i, /DROP\s+TABLE/i, /DELETE\s+FROM/i];
-    for (const p of dangerous) {
-        if (p.test(cmd))
-            return { ok: false, out: `Blocked dangerous command: ${p.source}` };
-    }
-    try {
-        const { stdout, stderr } = await execAsync(cmd, { cwd, timeout: 30000 });
-        return { ok: true, out: stdout + stderr };
-    }
-    catch (e) {
-        return { ok: false, out: e instanceof Error ? e.message : 'Command failed' };
-    }
-}
-async function runTest(test, cwd, llmQuery) {
-    const result = {
-        test,
-        success: false,
-        output: '',
-        errors: '',
-        matchedPatterns: [],
-        unmatchedPatterns: []
-    };
-    try {
-        // Run shell commands
-        if (test.shellCommands && test.shellCommands.length > 0) {
-            for (const cmd of test.shellCommands) {
-                const shellResult = await runShellCommand(cmd, cwd);
-                result.output += `$ ${cmd}\n${shellResult.out}\n`;
-                if (!shellResult.ok) {
-                    result.errors += `${shellResult.out}\n`;
-                }
-            }
-        }
-        // Check expected output patterns
-        if (test.expectedOutputs) {
-            for (const pattern of test.expectedOutputs) {
-                if (result.output.includes(pattern) || new RegExp(pattern, 'i').test(result.output)) {
-                    result.matchedPatterns.push(pattern);
-                }
-                else {
-                    result.unmatchedPatterns.push(pattern);
-                }
-            }
-        }
-        // LLM assessment of behavior
-        if (test.expectedBehavior) {
-            const assessPrompt = `Assess if this output demonstrates the expected behavior.
+console.log('');
+console.log('VERIFICATION COMPLETED SUCCESSFULLY');
+`;
+    }
+    /**
+     * Generate a success report
+     */
+    generateReport(taskName, config, stdout, stderr, duration) {
+        return `ISOLATED VERIFICATION REPORT
+=============================
+Task: ${taskName}
+Description: ${config.taskDescription}
+Duration: ${duration}ms
+Status: SUCCESS
 
-EXPECTED: ${test.expectedBehavior}
+VERIFICATION STEPS:
+${config.verificationCommands.map((cmd, i) => `  ${i + 1}. ${cmd}`).join('\n')}
 
 OUTPUT:
----
-${result.output.slice(0, 4000)}
----
+${stdout}
+${stderr ? `ERRORS:\n${stderr}` : ''}
+`;
+    }
+    /**
+     * Generate an error report
+     */
+    generateErrorReport(taskName, config, error, duration) {
+        return `ISOLATED VERIFICATION REPORT
+=============================
+Task: ${taskName}
+Description: ${config.taskDescription}
+Duration: ${duration}ms
+Status: FAILED
 
-Return JSON: {"matches": true/false, "confidence": 0-100, "reasoning": "explanation"}`;
-            try {
-                const assessment = await llmQuery(assessPrompt);
-                const match = assessment.match(/\{[\s\S]*\}/);
-                if (match) {
-                    const parsed = JSON.parse(match[0]);
-                    result.llmAssessment = `${parsed.matches ? '✅' : '❌'} [${parsed.confidence}%] ${parsed.reasoning}`;
-                    if (!parsed.matches || parsed.confidence < 70) {
-                        result.unmatchedPatterns.push(`behavior: ${test.expectedBehavior}`);
-                    }
-                    else {
-                        result.matchedPatterns.push(`behavior: ${test.expectedBehavior}`);
-                    }
-                }
-            }
-            catch {
-                result.llmAssessment = 'LLM assessment failed';
-            }
-        }
-        // Determine success
-        result.success = result.unmatchedPatterns.length === 0 &&
-            (result.matchedPatterns.length > 0 || (!test.expectedOutputs?.length && !test.expectedBehavior));
-    }
-    catch (err) {
-        result.errors = err instanceof Error ? err.message : 'Unknown error';
-    }
-    return result;
-}
-// ============================================================================
-// MAIN VERIFICATION
-// ============================================================================
-async function verify(request) {
-    const timestamp = new Date().toISOString();
-    const id = `verify-${Date.now()}`;
-    // Create LLM query function using isolated provider
-    const provider = createProvider({
-        provider: request.provider,
-        model: request.model,
-    });
-    const llmQuery = async (prompt) => {
-        const response = await provider.generate([{ role: 'user', content: prompt }], [] // No tools for verification queries
-        );
-        if (response.type === 'message' && response.content) {
-            return response.content;
-        }
-        return '';
-    };
-    // Extract claims
-    const claims = await extractClaims(request.response, request.workingDirectory, request.conversationHistory, llmQuery);
-    if (claims.length === 0) {
-        return {
-            responseId: id,
-            timestamp,
-            claims: [],
-            results: [],
-            summary: { total: 0, verified: 0, failed: 0, inconclusive: 0 },
-            overallVerdict: 'unverified',
-            trustScore: 50
-        };
-    }
-    // Generate tests for non-CLI claims
-    const nonCliBehaviorClaims = claims.filter(c => c.category !== 'cli_behavior');
-    const cliBehaviorClaims = claims.filter(c => c.category === 'cli_behavior');
-    const tests = await generateTests(nonCliBehaviorClaims, request.workingDirectory, llmQuery);
-    // Run shell-based tests for non-CLI claims
-    const testResults = [];
-    for (const test of tests) {
-        const result = await runTest(test, request.workingDirectory, llmQuery);
-        testResults.push(result);
-    }
-    // Run PTY-based tests for CLI behavior claims
-    for (const claim of cliBehaviorClaims) {
-        const result = await _runCLIBehaviorTest(claim, request.workingDirectory);
-        testResults.push(result);
-    }
-    // Rebuild claims array to match test results order
-    const orderedClaims = [...nonCliBehaviorClaims, ...cliBehaviorClaims];
-    // Map results to claims
-    const results = orderedClaims.map((claim, i) => {
-        const testResult = testResults[i];
-        if (!testResult) {
-            return {
-                claim,
-                verified: false,
-                confidence: 'low',
-                evidence: 'No test generated',
-                method: 'skip',
-                timestamp
-            };
-        }
-        // Determine method based on claim category
-        const method = claim.category === 'cli_behavior' ? 'pty-runtime' : 'isolated-process';
-        return {
-            claim,
-            verified: testResult.success,
-            confidence: testResult.success ? 'high' : (testResult.matchedPatterns.length > 0 ? 'medium' : 'low'),
-            evidence: testResult.success
-                ? `Verified: ${testResult.matchedPatterns.join(', ')}`
-                : `Failed: ${testResult.unmatchedPatterns.join(', ')}`,
-            method,
-            reasoning: testResult.llmAssessment,
-            executedCode: (testResult.test.shellCommands || []).join('\n'),
-            rawOutput: testResult.output.slice(0, 2000),
-            error: testResult.errors || undefined,
-            timestamp
-        };
-    });
-    // Calculate summary
-    const verified = results.filter(r => r.verified).length;
-    const failed = results.filter(r => !r.verified && r.confidence === 'high').length;
-    const inconclusive = results.filter(r => !r.verified && r.confidence !== 'high').length;
-    // Determine verdict
-    let overallVerdict;
-    if (failed > 0) {
-        overallVerdict = 'contradicted';
-    }
-    else if (verified === claims.length && claims.length > 0) {
-        overallVerdict = 'verified';
-    }
-    else if (verified > 0) {
-        overallVerdict = 'partially_verified';
-    }
-    else {
-        overallVerdict = 'unverified';
-    }
-    const trustScore = claims.length > 0
-        ? Math.round((verified / claims.length) * 100)
-        : 50;
-    return {
-        responseId: id,
-        timestamp,
-        claims,
-        results,
-        summary: { total: claims.length, verified, failed, inconclusive },
-        overallVerdict,
-        trustScore
-    };
-}
-// ============================================================================
-// PROCESS ENTRY POINT
-// ============================================================================
-async function main() {
-    // Read request from stdin
-    let input = '';
-    process.stdin.setEncoding('utf8');
-    for await (const chunk of process.stdin) {
-        input += chunk;
-    }
-    try {
-        const request = JSON.parse(input);
-        if (request.type !== 'verify') {
-            throw new Error(`Unknown request type: ${request.type}`);
-        }
-        const report = await verify(request);
-        // Output result as JSON to stdout
-        process.stdout.write(JSON.stringify(report));
-        process.exit(0);
-    }
-    catch (error) {
-        // Output error as JSON
-        process.stdout.write(JSON.stringify({
-            error: true,
-            message: error instanceof Error ? error.message : 'Unknown error'
-        }));
-        process.exit(1);
+VERIFICATION STEPS:
+${config.verificationCommands.map((cmd, i) => `  ${i + 1}. ${cmd}`).join('\n')}
+
+ERROR:
+${error.message}
+
+STACK TRACE:
+${error.stack}
+`;
     }
 }
-main();
 //# sourceMappingURL=isolatedVerifier.js.map