dartmind 17.0.0

package/dist/gates/DryRunBuildGate.js

@@ -0,0 +1,790 @@
+/**
+ * DartMind V17 - Dry-Run Build Gate (G13)
+ * Day 11: Sandbox-based Dependency Validation
+ *
+ * Validates dependency changes in an isolated sandbox environment
+ * using flutter pub get --dry-run and optional headless builds.
+ *
+ * @module gates/DryRunBuildGate
+ * @version 17.0.0
+ */
+import { EventEmitter } from 'events';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs';
+import * as path from 'path';
+import { DEFAULT_DRY_RUN_BUILD_CONFIG, generateSandboxId, } from './DryRunBuildTypes.js';
+const execAsync = promisify(exec);
+const fsPromises = fs.promises;
+// ============================================================================
+// Sandbox Manager
+// ============================================================================
+/**
+ * Manages sandbox environments for isolated dependency testing
+ */
+export class SandboxManager extends EventEmitter {
+    config;
+    activeSandboxes = new Map();
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    /**
+     * Create a new sandbox from a Flutter project
+     */
+    async createSandbox(projectPath) {
+        const id = generateSandboxId();
+        const sandboxPath = path.join(this.config.baseDir, id);
+        const sandbox = {
+            id,
+            path: sandboxPath,
+            status: 'initializing',
+            createdAt: Date.now(),
+            projectPath,
+            pubspecModified: false,
+        };
+        this.activeSandboxes.set(id, sandbox);
+        try {
+            // Create sandbox directory
+            await fsPromises.mkdir(sandboxPath, { recursive: true });
+            // Copy essential files
+            await this.copyProjectFiles(projectPath, sandboxPath);
+            sandbox.status = 'ready';
+            return sandbox;
+        }
+        catch (error) {
+            sandbox.status = 'failed';
+            sandbox.error = error instanceof Error ? error.message : String(error);
+            throw error;
+        }
+    }
+    /**
+     * Copy essential Flutter project files to sandbox
+     */
+    async copyProjectFiles(source, dest) {
+        const essentialFiles = ['pubspec.yaml', 'pubspec.lock', 'analysis_options.yaml'];
+        const essentialDirs = ['lib'];
+        // Copy files
+        for (const file of essentialFiles) {
+            const srcPath = path.join(source, file);
+            const destPath = path.join(dest, file);
+            try {
+                await fsPromises.copyFile(srcPath, destPath);
+            }
+            catch {
+                // File may not exist (e.g., pubspec.lock for new projects)
+            }
+        }
+        // Copy directories recursively (shallow for lib)
+        for (const dir of essentialDirs) {
+            const srcDir = path.join(source, dir);
+            const destDir = path.join(dest, dir);
+            try {
+                await this.copyDirectory(srcDir, destDir);
+            }
+            catch {
+                // Directory may not exist
+            }
+        }
+    }
+    /**
+     * Recursively copy a directory
+     */
+    async copyDirectory(src, dest) {
+        await fsPromises.mkdir(dest, { recursive: true });
+        const entries = await fsPromises.readdir(src, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+                await this.copyDirectory(srcPath, destPath);
+            }
+            else {
+                await fsPromises.copyFile(srcPath, destPath);
+            }
+        }
+    }
+    /**
+     * Apply pubspec changes to sandbox
+     */
+    async applyPubspecChanges(sandbox, changes, originalPubspec) {
+        const pubspecPath = path.join(sandbox.path, 'pubspec.yaml');
+        try {
+            // Read current pubspec
+            let content = originalPubspec;
+            if (!content) {
+                content = await fsPromises.readFile(pubspecPath, 'utf-8');
+            }
+            // Apply changes
+            const modified = this.applyChangesToYaml(content, changes);
+            // Write modified pubspec
+            await fsPromises.writeFile(pubspecPath, modified, 'utf-8');
+            sandbox.pubspecModified = true;
+            return {
+                success: true,
+                content: modified,
+                changes,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                changes,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Apply changes to pubspec YAML content
+     */
+    applyChangesToYaml(content, changes) {
+        const lines = content.split('\n');
+        let inDependencies = false;
+        let inDevDependencies = false;
+        let dependenciesIndent = 0;
+        const result = [];
+        const addedDeps = new Set();
+        const removedDeps = new Set();
+        // Track dependencies to add/remove
+        for (const change of changes) {
+            if (change.type === 'remove') {
+                removedDeps.add(change.dependency.name);
+            }
+        }
+        // Process existing lines
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmed = line.trim();
+            // Track section
+            if (trimmed === 'dependencies:') {
+                inDependencies = true;
+                inDevDependencies = false;
+                dependenciesIndent = line.indexOf('dependencies:');
+                result.push(line);
+                continue;
+            }
+            else if (trimmed === 'dev_dependencies:') {
+                inDependencies = false;
+                inDevDependencies = true;
+                dependenciesIndent = line.indexOf('dev_dependencies:');
+                result.push(line);
+                continue;
+            }
+            else if (trimmed.endsWith(':') && !trimmed.startsWith(' ') && !trimmed.startsWith('\t')) {
+                // New top-level section
+                inDependencies = false;
+                inDevDependencies = false;
+            }
+            // Check if this is a dependency line to modify/remove
+            if ((inDependencies || inDevDependencies) && trimmed.length > 0) {
+                const depMatch = trimmed.match(/^(\w+):/);
+                if (depMatch) {
+                    const depName = depMatch[1];
+                    // Skip removed dependencies
+                    if (removedDeps.has(depName)) {
+                        // Also skip subsequent lines that are part of this dep (git, path, etc.)
+                        while (i + 1 < lines.length) {
+                            const nextLine = lines[i + 1];
+                            const nextTrimmed = nextLine.trim();
+                            if (nextTrimmed.startsWith('git:') ||
+                                nextTrimmed.startsWith('path:') ||
+                                nextTrimmed.startsWith('url:') ||
+                                nextTrimmed.startsWith('ref:') ||
+                                nextTrimmed.startsWith('version:')) {
+                                i++;
+                            }
+                            else {
+                                break;
+                            }
+                        }
+                        continue;
+                    }
+                    // Check for update
+                    const updateChange = changes.find((c) => c.type === 'update' && c.dependency.name === depName);
+                    if (updateChange) {
+                        const indent = ' '.repeat(dependenciesIndent + 2);
+                        result.push(`${indent}${formatDependencyYaml(updateChange.dependency)}`);
+                        addedDeps.add(depName);
+                        // Skip subsequent lines if multi-line dep
+                        while (i + 1 < lines.length) {
+                            const nextLine = lines[i + 1];
+                            const nextTrimmed = nextLine.trim();
+                            if (nextTrimmed.startsWith('git:') ||
+                                nextTrimmed.startsWith('path:') ||
+                                nextTrimmed.startsWith('url:') ||
+                                nextTrimmed.startsWith('ref:') ||
+                                nextTrimmed.startsWith('version:')) {
+                                i++;
+                            }
+                            else {
+                                break;
+                            }
+                        }
+                        continue;
+                    }
+                }
+            }
+            result.push(line);
+        }
+        // Add new dependencies
+        const depsToAdd = changes.filter((c) => c.type === 'add' && !c.dependency.isDev && !addedDeps.has(c.dependency.name));
+        const devDepsToAdd = changes.filter((c) => c.type === 'add' && c.dependency.isDev && !addedDeps.has(c.dependency.name));
+        let output = result.join('\n');
+        if (depsToAdd.length > 0) {
+            // Find dependencies section or add one
+            if (!output.includes('dependencies:')) {
+                output += '\n\ndependencies:\n';
+            }
+            const depsIndex = output.indexOf('dependencies:');
+            const insertPoint = output.indexOf('\n', depsIndex) + 1;
+            const newDeps = depsToAdd.map((c) => `  ${formatDependencyYaml(c.dependency)}`).join('\n');
+            output = output.slice(0, insertPoint) + newDeps + '\n' + output.slice(insertPoint);
+        }
+        if (devDepsToAdd.length > 0) {
+            // Find dev_dependencies section or add one
+            if (!output.includes('dev_dependencies:')) {
+                output += '\n\ndev_dependencies:\n';
+            }
+            const devDepsIndex = output.indexOf('dev_dependencies:');
+            const insertPoint = output.indexOf('\n', devDepsIndex) + 1;
+            const newDevDeps = devDepsToAdd
+                .map((c) => `  ${formatDependencyYaml(c.dependency)}`)
+                .join('\n');
+            output = output.slice(0, insertPoint) + newDevDeps + '\n' + output.slice(insertPoint);
+        }
+        return output;
+    }
+    /**
+     * Clean up a sandbox
+     */
+    async cleanupSandbox(sandbox) {
+        try {
+            await fsPromises.rm(sandbox.path, { recursive: true, force: true });
+            sandbox.status = 'cleaned';
+            this.activeSandboxes.delete(sandbox.id);
+        }
+        catch (error) {
+            sandbox.error = error instanceof Error ? error.message : String(error);
+        }
+    }
+    /**
+     * Clean up all active sandboxes
+     */
+    async cleanupAll() {
+        const cleanups = Array.from(this.activeSandboxes.values()).map((s) => this.cleanupSandbox(s));
+        await Promise.all(cleanups);
+    }
+    /**
+     * Get sandbox by ID
+     */
+    getSandbox(id) {
+        return this.activeSandboxes.get(id);
+    }
+}
+/**
+ * Format a dependency for YAML output
+ */
+function formatDependencyYaml(dep) {
+    if (dep.git) {
+        let yaml = `${dep.name}:\n    git:\n      url: ${dep.git.url}`;
+        if (dep.git.ref)
+            yaml += `\n      ref: ${dep.git.ref}`;
+        if (dep.git.path)
+            yaml += `\n      path: ${dep.git.path}`;
+        return yaml;
+    }
+    if (dep.path) {
+        return `${dep.name}:\n    path: ${dep.path}`;
+    }
+    return `${dep.name}: ${dep.version}`;
+}
+// ============================================================================
+// Flutter Command Runner
+// ============================================================================
+/**
+ * Runs Flutter commands in sandbox
+ */
+export class FlutterCommandRunner {
+    flutterPath;
+    constructor(flutterPath) {
+        this.flutterPath = flutterPath || 'flutter';
+    }
+    /**
+     * Run flutter pub get --dry-run
+     */
+    async runDryRun(sandboxPath, timeout) {
+        const startTime = Date.now();
+        try {
+            const { stdout, stderr } = await execAsync(`${this.flutterPath} pub get --dry-run`, {
+                cwd: sandboxPath,
+                timeout,
+            });
+            const duration = Date.now() - startTime;
+            const result = this.parseDryRunOutput(stdout, stderr);
+            return {
+                success: true,
+                exitCode: 0,
+                stdout,
+                stderr,
+                duration,
+                ...result,
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const execError = error;
+            return {
+                success: false,
+                exitCode: execError.code || 1,
+                stdout: execError.stdout || '',
+                stderr: execError.stderr || execError.message || String(error),
+                duration,
+                conflicts: this.parseConflicts(execError.stderr || ''),
+                suggestions: this.generateSuggestions(execError.stderr || ''),
+            };
+        }
+    }
+    /**
+     * Parse dry-run output to extract resolved dependencies
+     */
+    parseDryRunOutput(stdout, stderr) {
+        const dependencies = [];
+        // Parse stdout for resolved versions
+        // Example: "+ http 0.13.5"
+        const addPattern = /^\+\s+(\S+)\s+(\S+)/gm;
+        let match;
+        while ((match = addPattern.exec(stdout)) !== null) {
+            dependencies.push({
+                name: match[1],
+                version: match[2],
+                constraint: match[2], // Dry run shows resolved version
+                isDirect: false, // Would need pubspec to determine
+                source: 'hosted',
+            });
+        }
+        return { resolvedDependencies: dependencies };
+    }
+    /**
+     * Parse error output for version conflicts
+     */
+    parseConflicts(stderr) {
+        const conflicts = [];
+        // Pattern: "Because X requires Y ^1.0.0 and Z requires Y ^2.0.0"
+        const conflictPattern = /Because\s+(\S+)\s+requires\s+(\S+)\s+(\S+)\s+.*?and\s+(\S+)\s+requires\s+\2\s+(\S+)/gi;
+        let match;
+        while ((match = conflictPattern.exec(stderr)) !== null) {
+            conflicts.push({
+                package: match[2],
+                requestedVersion: match[3],
+                conflictingVersion: match[5],
+                requiredBy: match[4],
+                suggestion: `Try finding a version of ${match[2]} compatible with both ${match[1]} and ${match[4]}`,
+            });
+        }
+        return conflicts;
+    }
+    /**
+     * Generate suggestions for failed resolution
+     */
+    generateSuggestions(stderr) {
+        const suggestions = [];
+        // Pattern: "The current SDK version is X, but Y requires Z"
+        const sdkPattern = /current\s+.*?SDK.*?(\d+\.\d+\.\d+).*?requires.*?(\d+\.\d+\.\d+)/i;
+        const sdkMatch = stderr.match(sdkPattern);
+        if (sdkMatch) {
+            suggestions.push({
+                package: 'dart-sdk',
+                suggestedVersion: sdkMatch[2],
+                reason: 'SDK version constraint not met',
+                confidence: 0.9,
+            });
+        }
+        // Pattern: "Could not find package X"
+        const notFoundPattern = /Could not find package\s+["']?(\S+)["']?/gi;
+        let match;
+        while ((match = notFoundPattern.exec(stderr)) !== null) {
+            suggestions.push({
+                package: match[1],
+                suggestedVersion: 'any',
+                reason: 'Package not found - check spelling or source',
+                confidence: 0.7,
+            });
+        }
+        return suggestions;
+    }
+    /**
+     * Run flutter build
+     */
+    async runBuild(sandboxPath, config) {
+        const startTime = Date.now();
+        // Build command based on config
+        let command = `${this.flutterPath} build`;
+        if (config.target) {
+            command += ` ${config.target}`;
+        }
+        command += ` --${config.mode}`;
+        if (config.extraArgs) {
+            command += ` ${config.extraArgs.join(' ')}`;
+        }
+        try {
+            // Run analysis first if configured
+            let analysisIssues = [];
+            if (config.runAnalysis) {
+                analysisIssues = await this.runAnalysis(sandboxPath);
+            }
+            const { stdout, stderr } = await execAsync(command, {
+                cwd: sandboxPath,
+                timeout: config.timeout,
+            });
+            const duration = Date.now() - startTime;
+            return {
+                success: true,
+                exitCode: 0,
+                stdout,
+                stderr,
+                duration,
+                analysisIssues,
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const execError = error;
+            return {
+                success: false,
+                exitCode: execError.code || 1,
+                stdout: execError.stdout || '',
+                stderr: execError.stderr || execError.message || String(error),
+                duration,
+                analysisIssues: [],
+            };
+        }
+    }
+    /**
+     * Run flutter analyze
+     */
+    async runAnalysis(sandboxPath) {
+        const issues = [];
+        try {
+            const { stdout } = await execAsync(`${this.flutterPath} analyze --no-fatal-infos`, {
+                cwd: sandboxPath,
+                timeout: 120000,
+            });
+            // Parse analysis output
+            // Example: "lib/main.dart:10:5 - warning: Unused import"
+            const issuePattern = /(\S+):(\d+):(\d+)\s+-\s+(error|warning|info):\s+(.+)/g;
+            let match;
+            while ((match = issuePattern.exec(stdout)) !== null) {
+                issues.push({
+                    severity: match[4],
+                    message: match[5],
+                    file: match[1],
+                    line: parseInt(match[2]),
+                    column: parseInt(match[3]),
+                });
+            }
+        }
+        catch {
+            // Analysis may fail if project doesn't compile
+        }
+        return issues;
+    }
+}
+// ============================================================================
+// Dry-Run Build Gate
+// ============================================================================
+/**
+ * G13: Dry-Run Build Gate
+ *
+ * Validates dependency changes in an isolated sandbox environment.
+ * Runs flutter pub get --dry-run to verify resolution without
+ * modifying the actual project.
+ */
+export class DryRunBuildGate extends EventEmitter {
+    id = 'G13';
+    name = 'Dry-Run Build Gate';
+    description = 'Validates dependency changes in sandbox using flutter pub get --dry-run';
+    required = true;
+    timeoutMs;
+    config;
+    sandboxManager;
+    commandRunner;
+    constructor(config = {}) {
+        super();
+        this.config = { ...DEFAULT_DRY_RUN_BUILD_CONFIG, ...config };
+        this.timeoutMs = this.config.sandbox.timeout + this.config.build.timeout;
+        this.sandboxManager = new SandboxManager(this.config.sandbox);
+        this.commandRunner = new FlutterCommandRunner(this.config.sandbox.flutterSdkPath);
+    }
+    /**
+     * Add event listener
+     */
+    onEvent(handler) {
+        this.on('event', handler);
+    }
+    /**
+     * Emit typed event
+     */
+    emitEvent(event) {
+        this.emit('event', event);
+    }
+    /**
+     * Execute the gate - V16Gate interface
+     */
+    async execute(input) {
+        const startTime = Date.now();
+        // Extract dry-run specific input from metadata
+        const dryRunInput = {
+            pubspecChanges: input.metadata?.pubspecChanges || [],
+            projectPath: input.projectPath || process.cwd(),
+            originalPubspec: input.metadata?.originalPubspec,
+            runBuild: input.metadata?.runBuild,
+            buildConfig: input.metadata?.buildConfig,
+        };
+        try {
+            const result = await this.validate(dryRunInput);
+            return {
+                gateId: this.id,
+                passed: result.passed,
+                executionTimeMs: result.executionTimeMs,
+                violations: this.resultToViolations(result),
+                warnings: [],
+                infos: [],
+                summary: result.summary,
+                metadata: {
+                    sandbox: result.sandbox,
+                    dryRun: result.dryRun,
+                    build: result.build,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                gateId: this.id,
+                passed: false,
+                executionTimeMs: Date.now() - startTime,
+                violations: [
+                    {
+                        id: 'G13-ERROR',
+                        message: error instanceof Error ? error.message : String(error),
+                        severity: 'BLOCK',
+                    },
+                ],
+                warnings: [],
+                infos: [],
+                summary: `Dry-run build gate failed with error: ${error}`,
+            };
+        }
+    }
+    /**
+     * Validate dependency changes
+     */
+    async validate(input) {
+        const startTime = Date.now();
+        this.emitEvent({ type: 'gate:started', input, timestamp: Date.now() });
+        let sandbox;
+        try {
+            // 1. Create sandbox
+            this.emitEvent({
+                type: 'sandbox:creating',
+                projectPath: input.projectPath,
+                timestamp: Date.now(),
+            });
+            sandbox = await this.sandboxManager.createSandbox(input.projectPath);
+            this.emitEvent({ type: 'sandbox:ready', sandbox, timestamp: Date.now() });
+            // 2. Apply pubspec changes
+            if (input.pubspecChanges.length > 0) {
+                this.emitEvent({
+                    type: 'pubspec:modifying',
+                    changes: input.pubspecChanges,
+                    timestamp: Date.now(),
+                });
+                const modResult = await this.sandboxManager.applyPubspecChanges(sandbox, input.pubspecChanges, input.originalPubspec);
+                this.emitEvent({ type: 'pubspec:modified', result: modResult, timestamp: Date.now() });
+                if (!modResult.success) {
+                    return this.buildFailureResult(startTime, sandbox, {
+                        success: false,
+                        exitCode: 1,
+                        stdout: '',
+                        stderr: modResult.error || 'Failed to modify pubspec',
+                        duration: 0,
+                    });
+                }
+            }
+            // 3. Run dry-run
+            this.emitEvent({ type: 'dryrun:starting', timestamp: Date.now() });
+            const dryRunResult = await this.commandRunner.runDryRun(sandbox.path, this.config.maxResolutionTime);
+            this.emitEvent({ type: 'dryrun:complete', result: dryRunResult, timestamp: Date.now() });
+            if (!dryRunResult.success) {
+                return this.buildFailureResult(startTime, sandbox, dryRunResult);
+            }
+            // 4. Optionally run build
+            let buildResult;
+            if (input.runBuild && !this.config.skipBuild) {
+                const buildConfig = {
+                    ...this.config.build,
+                    ...input.buildConfig,
+                };
+                this.emitEvent({ type: 'build:starting', config: buildConfig, timestamp: Date.now() });
+                buildResult = await this.commandRunner.runBuild(sandbox.path, buildConfig);
+                this.emitEvent({ type: 'build:complete', result: buildResult, timestamp: Date.now() });
+                if (!buildResult.success) {
+                    return this.buildResult(startTime, sandbox, dryRunResult, buildResult, false);
+                }
+                // Check for analysis warnings if configured
+                if (this.config.failOnWarnings && buildResult.analysisIssues) {
+                    const hasWarnings = buildResult.analysisIssues.some((i) => i.severity === 'warning');
+                    if (hasWarnings) {
+                        return this.buildResult(startTime, sandbox, dryRunResult, buildResult, false);
+                    }
+                }
+            }
+            // 5. Cleanup
+            await this.cleanup(sandbox);
+            const result = this.buildResult(startTime, sandbox, dryRunResult, buildResult, true);
+            this.emitEvent({ type: 'gate:complete', result, timestamp: Date.now() });
+            return result;
+        }
+        catch (error) {
+            this.emitEvent({
+                type: 'gate:error',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: Date.now(),
+            });
+            // Cleanup on error
+            if (sandbox) {
+                await this.cleanup(sandbox);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Build success/failure result
+     */
+    buildResult(startTime, sandbox, dryRun, build, passed) {
+        const suggestions = [];
+        if (dryRun.suggestions) {
+            suggestions.push(...dryRun.suggestions);
+        }
+        // Generate suggestions from conflicts
+        if (dryRun.conflicts) {
+            for (const conflict of dryRun.conflicts) {
+                if (conflict.suggestion) {
+                    suggestions.push({
+                        package: conflict.package,
+                        suggestedVersion: 'compatible version',
+                        reason: conflict.suggestion,
+                        confidence: 0.6,
+                    });
+                }
+            }
+        }
+        let summary;
+        if (passed) {
+            summary = 'Dependency validation passed';
+            if (dryRun.resolvedDependencies?.length) {
+                summary += ` - ${dryRun.resolvedDependencies.length} packages resolved`;
+            }
+            if (build) {
+                summary += ', build successful';
+            }
+        }
+        else {
+            summary = 'Dependency validation failed';
+            if (dryRun.conflicts?.length) {
+                summary += ` - ${dryRun.conflicts.length} version conflicts`;
+            }
+            if (build && !build.success) {
+                summary += ', build failed';
+            }
+        }
+        return {
+            gateId: 'G13',
+            passed,
+            executionTimeMs: Date.now() - startTime,
+            sandbox,
+            dryRun,
+            build,
+            summary,
+            suggestions,
+        };
+    }
+    /**
+     * Build failure result
+     */
+    buildFailureResult(startTime, sandbox, dryRun) {
+        return this.buildResult(startTime, sandbox, dryRun, undefined, false);
+    }
+    /**
+     * Convert result to V16 violations
+     */
+    resultToViolations(result) {
+        const violations = [];
+        if (!result.passed) {
+            // Add conflict violations
+            if (result.dryRun.conflicts) {
+                for (const conflict of result.dryRun.conflicts) {
+                    violations.push({
+                        id: `G13-CONFLICT-${conflict.package}`,
+                        message: `Version conflict: ${conflict.package} requires ${conflict.requestedVersion} but ${conflict.requiredBy} requires ${conflict.conflictingVersion}`,
+                        severity: 'BLOCK',
+                        suggestion: conflict.suggestion,
+                    });
+                }
+            }
+            // Add build errors
+            if (result.build && !result.build.success) {
+                violations.push({
+                    id: 'G13-BUILD-FAILED',
+                    message: `Build failed: ${result.build.stderr.substring(0, 200)}`,
+                    severity: 'BLOCK',
+                });
+            }
+            // Add general error if no specific violations
+            if (violations.length === 0) {
+                violations.push({
+                    id: 'G13-RESOLUTION-FAILED',
+                    message: `Dependency resolution failed: ${result.dryRun.stderr.substring(0, 200)}`,
+                    severity: 'BLOCK',
+                });
+            }
+        }
+        return violations;
+    }
+    /**
+     * Clean up sandbox
+     */
+    async cleanup(sandbox) {
+        if (this.config.sandbox.autoCleanup) {
+            this.emitEvent({ type: 'sandbox:cleaning', timestamp: Date.now() });
+            await this.sandboxManager.cleanupSandbox(sandbox);
+            this.emitEvent({ type: 'sandbox:cleaned', timestamp: Date.now() });
+        }
+    }
+    /**
+     * Check if a violation can be auto-fixed
+     */
+    canAutoFix(violation) {
+        // Can potentially auto-fix version conflicts by adjusting constraints
+        return violation.id.startsWith('G13-CONFLICT-');
+    }
+    /**
+     * Apply auto-fix to pubspec
+     */
+    async autoFix(violation, code) {
+        // Auto-fix would need to analyze the conflict and suggest compatible versions
+        // This is a complex operation that would need pub.dev API integration
+        // For now, return the code unchanged
+        return code;
+    }
+}
+// ============================================================================
+// Factory & Defaults
+// ============================================================================
+/**
+ * Create a DryRunBuildGate with default configuration
+ */
+export function createDryRunBuildGate(config) {
+    return new DryRunBuildGate(config);
+}
+export default DryRunBuildGate;
+//# sourceMappingURL=DryRunBuildGate.js.map