dartmind 17.0.0

package/dist/agentic/ShadowRunner.js

@@ -0,0 +1,828 @@
+/**
+ * FlutterAI v8.0 Supreme Vision - Shadow Runner
+ * Background Shadow Build System
+ *
+ * Capabilities:
+ * - Creates isolated shadow copy in .fai/shadow/
+ * - Silent verification loop (dart analyze + flutter test)
+ * - Non-blocking background execution
+ * - Real-time status reporting
+ * - Automatic cleanup and state management
+ *
+ * @author FlutterAI Supreme Engine
+ * @version 8.0.0
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { EventEmitter } from 'events';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+// ============================================================================
+// TYPE DEFINITIONS
+// ============================================================================
+export var ShadowState;
+(function (ShadowState) {
+    ShadowState["IDLE"] = "IDLE";
+    ShadowState["SYNCING"] = "SYNCING";
+    ShadowState["ANALYZING"] = "ANALYZING";
+    ShadowState["TESTING"] = "TESTING";
+    ShadowState["BUILDING"] = "BUILDING";
+    ShadowState["COMPLETE"] = "COMPLETE";
+    ShadowState["ERROR"] = "ERROR";
+})(ShadowState || (ShadowState = {}));
+// ============================================================================
+// DEFAULT CONFIGURATION
+// ============================================================================
+const DEFAULT_CONFIG = {
+    projectPath: process.cwd(),
+    autoSync: true,
+    syncInterval: 5000,
+    runAnalyzer: true,
+    runTests: true,
+    runBuild: false,
+    maxRetries: 3,
+    timeout: 300000, // 5 minutes
+    excludePatterns: [
+        '.git',
+        '.dart_tool',
+        '.idea',
+        '.vscode',
+        'build',
+        '.fai',
+        'node_modules',
+        '*.lock',
+        '.packages'
+    ],
+    verbose: false
+};
+// ============================================================================
+// SHADOW RUNNER CLASS
+// ============================================================================
+export class ShadowRunner extends EventEmitter {
+    config;
+    shadowPath;
+    status;
+    isRunning = false;
+    syncTimer = null;
+    currentProcess = null;
+    fileHashes = new Map();
+    initialized = false;
+    constructor(config = {}) {
+        super();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.shadowPath = this.config.shadowPath ||
+            path.join(this.config.projectPath, '.fai', 'shadow');
+        this.status = this.createInitialStatus();
+    }
+    // ==========================================================================
+    // PUBLIC API
+    // ==========================================================================
+    /**
+     * Initialize shadow workspace
+     */
+    async initialize() {
+        this.emit('status', 'Initializing Shadow Runner...');
+        // Verify project exists
+        if (!fs.existsSync(this.config.projectPath)) {
+            throw new Error(`Project path does not exist: ${this.config.projectPath}`);
+        }
+        const pubspecPath = path.join(this.config.projectPath, 'pubspec.yaml');
+        if (!fs.existsSync(pubspecPath)) {
+            throw new Error('Not a Flutter project: pubspec.yaml not found');
+        }
+        // Create shadow directory structure
+        await this.createShadowDirectory();
+        // Initial sync
+        const syncResult = await this.syncToShadow();
+        if (!syncResult.success) {
+            throw new Error(`Initial sync failed: ${syncResult.errors.join(', ')}`);
+        }
+        // Run pub get in shadow
+        await this.runPubGet();
+        this.initialized = true;
+        this.emit('initialized', { shadowPath: this.shadowPath });
+        this.emit('status', 'Shadow Runner initialized');
+    }
+    /**
+     * Start background verification loop
+     */
+    async start() {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+        if (this.isRunning) {
+            this.emit('warning', 'Shadow Runner already running');
+            return;
+        }
+        this.isRunning = true;
+        this.emit('started');
+        // Start sync timer
+        if (this.config.autoSync) {
+            this.syncTimer = setInterval(async () => {
+                if (this.status.state === ShadowState.IDLE) {
+                    await this.runVerificationCycle();
+                }
+            }, this.config.syncInterval);
+        }
+        // Run initial verification
+        await this.runVerificationCycle();
+    }
+    /**
+     * Stop background verification
+     */
+    stop() {
+        this.isRunning = false;
+        if (this.syncTimer) {
+            clearInterval(this.syncTimer);
+            this.syncTimer = null;
+        }
+        if (this.currentProcess) {
+            this.currentProcess.kill();
+            this.currentProcess = null;
+        }
+        this.updateState(ShadowState.IDLE);
+        this.emit('stopped');
+    }
+    /**
+     * Run a single verification cycle
+     */
+    async verify() {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+        return this.runVerificationCycle();
+    }
+    /**
+     * Verify specific files only
+     */
+    async verifyFiles(files) {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+        // Sync only specified files
+        for (const file of files) {
+            await this.syncFile(file);
+        }
+        return this.runVerificationCycle();
+    }
+    /**
+     * Get current status
+     */
+    getStatus() {
+        return { ...this.status };
+    }
+    /**
+     * Check if code will pass verification
+     */
+    async willPass(code, filePath) {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+        // Write code to shadow
+        const shadowFilePath = path.join(this.shadowPath, path.relative(this.config.projectPath, filePath));
+        await this.ensureDirectory(path.dirname(shadowFilePath));
+        fs.writeFileSync(shadowFilePath, code, 'utf-8');
+        // Run analyzer on specific file
+        const result = await this.runDartAnalyze([shadowFilePath]);
+        return {
+            pass: result.success,
+            issues: result.errors.concat(result.warnings)
+        };
+    }
+    /**
+     * Clean shadow workspace
+     */
+    async clean() {
+        this.stop();
+        if (fs.existsSync(this.shadowPath)) {
+            await this.removeDirectory(this.shadowPath);
+        }
+        this.fileHashes.clear();
+        this.initialized = false;
+        this.status = this.createInitialStatus();
+        this.emit('cleaned');
+    }
+    /**
+     * Get shadow workspace path
+     */
+    getShadowPath() {
+        return this.shadowPath;
+    }
+    // ==========================================================================
+    // PRIVATE METHODS - INITIALIZATION
+    // ==========================================================================
+    createInitialStatus() {
+        return {
+            state: ShadowState.IDLE,
+            progress: 0,
+            currentTask: '',
+            lastSync: null,
+            lastAnalyze: null,
+            lastTest: null,
+            lastBuild: null,
+            errors: [],
+            warnings: [],
+            isHealthy: true,
+            metrics: {
+                syncDuration: 0,
+                analyzeDuration: 0,
+                testDuration: 0,
+                buildDuration: 0,
+                errorCount: 0,
+                warningCount: 0,
+                testsPassed: 0,
+                testsFailed: 0,
+                testsSkipped: 0,
+                coverage: 0
+            }
+        };
+    }
+    async createShadowDirectory() {
+        // Create .fai directory
+        const faiDir = path.join(this.config.projectPath, '.fai');
+        if (!fs.existsSync(faiDir)) {
+            fs.mkdirSync(faiDir, { recursive: true });
+        }
+        // Add to .gitignore
+        this.addToGitignore();
+        // Create shadow directory
+        if (!fs.existsSync(this.shadowPath)) {
+            fs.mkdirSync(this.shadowPath, { recursive: true });
+        }
+    }
+    addToGitignore() {
+        const gitignorePath = path.join(this.config.projectPath, '.gitignore');
+        let content = '';
+        if (fs.existsSync(gitignorePath)) {
+            content = fs.readFileSync(gitignorePath, 'utf-8');
+        }
+        if (!content.includes('.fai/')) {
+            content += '\n# FlutterAI Shadow Workspace\n.fai/\n';
+            fs.writeFileSync(gitignorePath, content);
+        }
+    }
+    // ==========================================================================
+    // PRIVATE METHODS - SYNC
+    // ==========================================================================
+    async syncToShadow() {
+        const startTime = Date.now();
+        this.updateState(ShadowState.SYNCING, 'Syncing files to shadow workspace...');
+        const result = {
+            success: true,
+            filesAdded: [],
+            filesModified: [],
+            filesDeleted: [],
+            errors: [],
+            duration: 0
+        };
+        try {
+            // Get all files in source
+            const sourceFiles = this.getAllFiles(this.config.projectPath);
+            const currentHashes = new Map();
+            // Sync each file
+            for (const file of sourceFiles) {
+                const relativePath = path.relative(this.config.projectPath, file);
+                // Skip excluded patterns
+                if (this.shouldExclude(relativePath))
+                    continue;
+                try {
+                    const content = fs.readFileSync(file);
+                    const hash = crypto.createHash('md5').update(content).digest('hex');
+                    currentHashes.set(relativePath, hash);
+                    const shadowFile = path.join(this.shadowPath, relativePath);
+                    const existingHash = this.fileHashes.get(relativePath);
+                    if (!existingHash) {
+                        // New file
+                        await this.copyFile(file, shadowFile);
+                        result.filesAdded.push(relativePath);
+                    }
+                    else if (existingHash !== hash) {
+                        // Modified file
+                        await this.copyFile(file, shadowFile);
+                        result.filesModified.push(relativePath);
+                    }
+                }
+                catch (error) {
+                    result.errors.push(`Failed to sync ${relativePath}: ${error}`);
+                }
+            }
+            // Find deleted files
+            for (const [relativePath] of this.fileHashes) {
+                if (!currentHashes.has(relativePath)) {
+                    const shadowFile = path.join(this.shadowPath, relativePath);
+                    if (fs.existsSync(shadowFile)) {
+                        fs.unlinkSync(shadowFile);
+                    }
+                    result.filesDeleted.push(relativePath);
+                }
+            }
+            // Update hash map
+            this.fileHashes = currentHashes;
+            this.status.lastSync = new Date();
+        }
+        catch (error) {
+            result.success = false;
+            result.errors.push(`Sync failed: ${error}`);
+        }
+        result.duration = Date.now() - startTime;
+        this.status.metrics.syncDuration = result.duration;
+        if (result.success) {
+            this.emit('synced', result);
+        }
+        else {
+            this.emit('syncError', result.errors);
+        }
+        return result;
+    }
+    async syncFile(filePath) {
+        const relativePath = path.relative(this.config.projectPath, filePath);
+        const sourcePath = path.join(this.config.projectPath, relativePath);
+        const shadowPath = path.join(this.shadowPath, relativePath);
+        if (fs.existsSync(sourcePath)) {
+            await this.copyFile(sourcePath, shadowPath);
+            const content = fs.readFileSync(sourcePath);
+            const hash = crypto.createHash('md5').update(content).digest('hex');
+            this.fileHashes.set(relativePath, hash);
+        }
+    }
+    async copyFile(source, dest) {
+        await this.ensureDirectory(path.dirname(dest));
+        fs.copyFileSync(source, dest);
+    }
+    async ensureDirectory(dir) {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    getAllFiles(dir) {
+        const files = [];
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (!this.shouldExcludeDir(entry.name)) {
+                    files.push(...this.getAllFiles(fullPath));
+                }
+            }
+            else {
+                files.push(fullPath);
+            }
+        }
+        return files;
+    }
+    shouldExclude(relativePath) {
+        for (const pattern of this.config.excludePatterns) {
+            if (pattern.includes('*')) {
+                const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+                if (regex.test(relativePath))
+                    return true;
+            }
+            else {
+                if (relativePath.includes(pattern))
+                    return true;
+            }
+        }
+        return false;
+    }
+    shouldExcludeDir(dirName) {
+        return this.config.excludePatterns.some(p => dirName === p || dirName.startsWith('.'));
+    }
+    async removeDirectory(dir) {
+        if (fs.existsSync(dir)) {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    await this.removeDirectory(fullPath);
+                }
+                else {
+                    fs.unlinkSync(fullPath);
+                }
+            }
+            fs.rmdirSync(dir);
+        }
+    }
+    // ==========================================================================
+    // PRIVATE METHODS - VERIFICATION
+    // ==========================================================================
+    async runVerificationCycle() {
+        const startTime = Date.now();
+        this.status.errors = [];
+        this.status.warnings = [];
+        const result = {
+            passed: true,
+            analyze: null,
+            test: null,
+            build: null,
+            totalDuration: 0,
+            timestamp: new Date()
+        };
+        try {
+            // Step 1: Sync
+            const syncResult = await this.syncToShadow();
+            if (!syncResult.success) {
+                result.passed = false;
+                return this.finalizeResult(result, startTime);
+            }
+            this.updateProgress(25);
+            // Step 2: Analyze
+            if (this.config.runAnalyzer) {
+                result.analyze = await this.runDartAnalyze();
+                this.status.lastAnalyze = new Date();
+                if (!result.analyze.success) {
+                    result.passed = false;
+                    for (const error of result.analyze.errors) {
+                        this.status.errors.push({
+                            type: 'analyze',
+                            message: error.message,
+                            file: error.file,
+                            line: error.line,
+                            code: error.code,
+                            timestamp: new Date()
+                        });
+                    }
+                }
+                for (const warning of result.analyze.warnings) {
+                    this.status.warnings.push({
+                        type: 'analyze',
+                        message: warning.message,
+                        file: warning.file,
+                        line: warning.line,
+                        code: warning.code
+                    });
+                }
+            }
+            this.updateProgress(50);
+            // Step 3: Test
+            if (this.config.runTests && result.passed) {
+                result.test = await this.runFlutterTest();
+                this.status.lastTest = new Date();
+                if (!result.test.success) {
+                    result.passed = false;
+                    for (const failure of result.test.failures) {
+                        this.status.errors.push({
+                            type: 'test',
+                            message: failure.message,
+                            file: failure.file,
+                            timestamp: new Date()
+                        });
+                    }
+                }
+                this.status.metrics.testsPassed = result.test.passed;
+                this.status.metrics.testsFailed = result.test.failed;
+                this.status.metrics.testsSkipped = result.test.skipped;
+                if (result.test.coverage) {
+                    this.status.metrics.coverage = result.test.coverage;
+                }
+            }
+            this.updateProgress(75);
+            // Step 4: Build (optional)
+            if (this.config.runBuild && result.passed) {
+                result.build = await this.runFlutterBuild();
+                this.status.lastBuild = new Date();
+                if (!result.build.success) {
+                    result.passed = false;
+                    for (const error of result.build.errors) {
+                        this.status.errors.push({
+                            type: 'build',
+                            message: error,
+                            timestamp: new Date()
+                        });
+                    }
+                }
+            }
+            this.updateProgress(100);
+        }
+        catch (error) {
+            result.passed = false;
+            this.status.errors.push({
+                type: 'sync',
+                message: `Verification failed: ${error}`,
+                timestamp: new Date()
+            });
+        }
+        return this.finalizeResult(result, startTime);
+    }
+    finalizeResult(result, startTime) {
+        result.totalDuration = Date.now() - startTime;
+        this.status.metrics.errorCount = this.status.errors.length;
+        this.status.metrics.warningCount = this.status.warnings.length;
+        this.status.isHealthy = result.passed;
+        this.updateState(result.passed ? ShadowState.COMPLETE : ShadowState.ERROR);
+        this.emit('verification', result);
+        // Reset to idle after a short delay
+        setTimeout(() => {
+            if (this.status.state === ShadowState.COMPLETE ||
+                this.status.state === ShadowState.ERROR) {
+                this.updateState(ShadowState.IDLE);
+            }
+        }, 1000);
+        return result;
+    }
+    // ==========================================================================
+    // PRIVATE METHODS - DART/FLUTTER COMMANDS
+    // ==========================================================================
+    async runPubGet() {
+        this.emit('status', 'Running pub get in shadow workspace...');
+        try {
+            await execAsync('flutter pub get', {
+                cwd: this.shadowPath,
+                timeout: 60000
+            });
+        }
+        catch (error) {
+            this.emit('warning', `Pub get warning: ${error}`);
+        }
+    }
+    async runDartAnalyze(files) {
+        const startTime = Date.now();
+        this.updateState(ShadowState.ANALYZING, 'Running dart analyze...');
+        const result = {
+            success: true,
+            errors: [],
+            warnings: [],
+            hints: [],
+            duration: 0
+        };
+        try {
+            const targetPath = files && files.length > 0
+                ? files.join(' ')
+                : this.shadowPath;
+            const { stdout, stderr } = await execAsync(`dart analyze --format=machine ${targetPath}`, {
+                cwd: this.shadowPath,
+                timeout: this.config.timeout,
+                maxBuffer: 10 * 1024 * 1024 // 10MB
+            });
+            // Parse machine format output
+            const output = stdout + stderr;
+            const lines = output.split('\n').filter(l => l.trim());
+            for (const line of lines) {
+                const issue = this.parseAnalyzerOutput(line);
+                if (issue) {
+                    switch (issue.severity) {
+                        case 'error':
+                            result.errors.push(issue);
+                            result.success = false;
+                            break;
+                        case 'warning':
+                            result.warnings.push(issue);
+                            break;
+                        case 'info':
+                        case 'hint':
+                            result.hints.push(issue);
+                            break;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // dart analyze returns non-zero exit code when there are errors
+            const execError = error;
+            if (execError.stdout || execError.stderr) {
+                const output = (execError.stdout || '') + (execError.stderr || '');
+                const lines = output.split('\n').filter((l) => l.trim());
+                for (const line of lines) {
+                    const issue = this.parseAnalyzerOutput(line);
+                    if (issue) {
+                        switch (issue.severity) {
+                            case 'error':
+                                result.errors.push(issue);
+                                result.success = false;
+                                break;
+                            case 'warning':
+                                result.warnings.push(issue);
+                                break;
+                            default:
+                                result.hints.push(issue);
+                        }
+                    }
+                }
+            }
+            else {
+                result.success = false;
+                result.errors.push({
+                    severity: 'error',
+                    code: 'ANALYZER_CRASH',
+                    message: `Analyzer crashed: ${execError.message || String(error)}`,
+                    file: 'unknown',
+                    line: 0,
+                    column: 0
+                });
+            }
+        }
+        result.duration = Date.now() - startTime;
+        this.status.metrics.analyzeDuration = result.duration;
+        this.emit('analyzed', result);
+        return result;
+    }
+    parseAnalyzerOutput(line) {
+        // Machine format: SEVERITY|TYPE|CODE|FILE|LINE|COLUMN|LENGTH|MESSAGE
+        const parts = line.split('|');
+        if (parts.length >= 8) {
+            const severityMap = {
+                'ERROR': 'error',
+                'WARNING': 'warning',
+                'INFO': 'info',
+                'HINT': 'hint'
+            };
+            return {
+                severity: severityMap[parts[0]] || 'info',
+                code: parts[2],
+                message: parts[7],
+                file: parts[3].replace(this.shadowPath, ''),
+                line: parseInt(parts[4]) || 0,
+                column: parseInt(parts[5]) || 0
+            };
+        }
+        // Alternative format: file:line:column: severity: message
+        const altMatch = line.match(/^(.+):(\d+):(\d+):\s*(error|warning|hint|info):\s*(.+)/i);
+        if (altMatch) {
+            return {
+                severity: altMatch[4].toLowerCase(),
+                code: 'UNKNOWN',
+                message: altMatch[5],
+                file: altMatch[1].replace(this.shadowPath, ''),
+                line: parseInt(altMatch[2]),
+                column: parseInt(altMatch[3])
+            };
+        }
+        return null;
+    }
+    async runFlutterTest() {
+        const startTime = Date.now();
+        this.updateState(ShadowState.TESTING, 'Running flutter test...');
+        const result = {
+            success: true,
+            passed: 0,
+            failed: 0,
+            skipped: 0,
+            duration: 0,
+            failures: []
+        };
+        try {
+            // Check if test directory exists
+            const testDir = path.join(this.shadowPath, 'test');
+            if (!fs.existsSync(testDir)) {
+                this.emit('status', 'No test directory found, skipping tests');
+                return result;
+            }
+            const { stdout, stderr } = await execAsync('flutter test --reporter=expanded', {
+                cwd: this.shadowPath,
+                timeout: this.config.timeout,
+                maxBuffer: 10 * 1024 * 1024
+            });
+            const output = stdout + stderr;
+            // Parse test output
+            const passedMatch = output.match(/(\d+)\s+tests?\s+passed/i);
+            const failedMatch = output.match(/(\d+)\s+tests?\s+failed/i);
+            const skippedMatch = output.match(/(\d+)\s+tests?\s+skipped/i);
+            if (passedMatch)
+                result.passed = parseInt(passedMatch[1]);
+            if (failedMatch) {
+                result.failed = parseInt(failedMatch[1]);
+                if (result.failed > 0)
+                    result.success = false;
+            }
+            if (skippedMatch)
+                result.skipped = parseInt(skippedMatch[1]);
+            // Extract failures
+            const failureMatches = output.matchAll(/FAIL:\s*(.+)\n\s*(.+)\n\s*(.+)?/g);
+            for (const match of failureMatches) {
+                result.failures.push({
+                    name: match[1].trim(),
+                    file: 'test',
+                    message: match[2].trim(),
+                    stackTrace: match[3]?.trim()
+                });
+            }
+        }
+        catch (error) {
+            result.success = false;
+            const execError = error;
+            if (execError.stdout || execError.stderr) {
+                const output = (execError.stdout || '') + (execError.stderr || '');
+                // Parse any test results from error output
+                const passedMatch = output.match(/(\d+)\s+tests?\s+passed/i);
+                const failedMatch = output.match(/(\d+)\s+tests?\s+failed/i);
+                if (passedMatch)
+                    result.passed = parseInt(passedMatch[1]);
+                if (failedMatch)
+                    result.failed = parseInt(failedMatch[1]);
+                result.failures.push({
+                    name: 'Test Suite',
+                    file: 'test',
+                    message: `Test suite failed: ${execError.message || String(error)}`
+                });
+            }
+            else {
+                result.failures.push({
+                    name: 'Test Runner',
+                    file: 'test',
+                    message: `Test runner crashed: ${execError.message || String(error)}`
+                });
+            }
+        }
+        result.duration = Date.now() - startTime;
+        this.status.metrics.testDuration = result.duration;
+        this.emit('tested', result);
+        return result;
+    }
+    async runFlutterBuild() {
+        const startTime = Date.now();
+        const target = this.config.buildTarget || 'apk';
+        this.updateState(ShadowState.BUILDING, `Building ${target}...`);
+        const result = {
+            success: true,
+            target,
+            duration: 0,
+            errors: [],
+            warnings: []
+        };
+        try {
+            let command;
+            switch (target) {
+                case 'apk':
+                    command = 'flutter build apk --debug';
+                    break;
+                case 'ios':
+                    command = 'flutter build ios --debug --no-codesign';
+                    break;
+                case 'web':
+                    command = 'flutter build web';
+                    break;
+                case 'linux':
+                    command = 'flutter build linux --debug';
+                    break;
+                case 'windows':
+                    command = 'flutter build windows --debug';
+                    break;
+                case 'macos':
+                    command = 'flutter build macos --debug';
+                    break;
+                default:
+                    command = 'flutter build apk --debug';
+            }
+            const { stdout, stderr } = await execAsync(command, {
+                cwd: this.shadowPath,
+                timeout: this.config.timeout * 2, // Build takes longer
+                maxBuffer: 50 * 1024 * 1024
+            });
+            // Extract output path
+            const outputMatch = (stdout + stderr).match(/Built\s+(.+?)\s*\(/);
+            if (outputMatch) {
+                result.outputPath = outputMatch[1];
+            }
+            // Extract warnings
+            const warningMatches = (stdout + stderr).matchAll(/warning:\s*(.+)/gi);
+            for (const match of warningMatches) {
+                result.warnings.push(match[1]);
+            }
+        }
+        catch (error) {
+            result.success = false;
+            const execError = error;
+            if (execError.stdout || execError.stderr) {
+                const output = (execError.stdout || '') + (execError.stderr || '');
+                // Extract errors
+                const errorMatches = output.matchAll(/error:\s*(.+)/gi);
+                for (const match of errorMatches) {
+                    result.errors.push(match[1]);
+                }
+                if (result.errors.length === 0) {
+                    result.errors.push(execError.message || String(error));
+                }
+            }
+            else {
+                result.errors.push(`Build crashed: ${execError.message || String(error)}`);
+            }
+        }
+        result.duration = Date.now() - startTime;
+        this.status.metrics.buildDuration = result.duration;
+        this.emit('built', result);
+        return result;
+    }
+    // ==========================================================================
+    // PRIVATE METHODS - STATE MANAGEMENT
+    // ==========================================================================
+    updateState(state, task) {
+        this.status.state = state;
+        if (task) {
+            this.status.currentTask = task;
+        }
+        this.emit('stateChange', this.status);
+    }
+    updateProgress(progress) {
+        this.status.progress = progress;
+        this.emit('progress', progress);
+    }
+}
+// ============================================================================
+// FACTORY FUNCTION
+// ============================================================================
+export function createShadowRunner(config) {
+    return new ShadowRunner(config);
+}
+export default ShadowRunner;
+//# sourceMappingURL=ShadowRunner.js.map