style: fix prettier formatting

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

dist/index.js

@@ -9982,8 +9982,74 @@ class BuildReliabilityService {
         }
         return cleaned;
     }
+    /**
+     * Get available disk space in megabytes for a given directory.
+     * Returns -1 if the check fails (unknown space).
+     *
+     * Cross-platform: uses wmic on Windows, df on Unix.
+     */
+    static getAvailableSpaceMB(directoryPath) {
+        try {
+            if (process.platform === 'win32') {
+                const drive = node_path_1.default.parse(directoryPath).root;
+                const driveLetter = drive.replace(/[:\\\/]/g, '');
+                const output = (0, node_child_process_1.execFileSync)('wmic', ['logicaldisk', 'where', `DeviceID='${driveLetter}:'`, 'get', 'FreeSpace', '/value'], { encoding: 'utf8', timeout: 10000 });
+                const match = output.match(/FreeSpace=(\d+)/);
+                return match ? Number.parseInt(match[1], 10) / (1024 * 1024) : -1;
+            }
+            else {
+                const output = (0, node_child_process_1.execFileSync)('df', ['-BM', '--output=avail', directoryPath], {
+                    encoding: 'utf8',
+                    timeout: 10000,
+                });
+                const lines = output.trim().split('\n');
+                return Number.parseInt(lines[lines.length - 1], 10);
+            }
+        }
+        catch {
+            return -1; // Unknown, caller should proceed with warning
+        }
+    }
+    /**
+     * Calculate the total size of a directory in megabytes.
+     * Returns -1 if the calculation fails.
+     */
+    static getDirectorySizeMB(directoryPath) {
+        try {
+            const stat = node_fs_1.default.statSync(directoryPath);
+            if (!stat.isDirectory()) {
+                return stat.size / (1024 * 1024);
+            }
+            let totalBytes = 0;
+            const walkDirectory = (dir) => {
+                const entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = node_path_1.default.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        walkDirectory(fullPath);
+                    }
+                    else {
+                        try {
+                            totalBytes += node_fs_1.default.statSync(fullPath).size;
+                        }
+                        catch {
+                            // Skip inaccessible files
+                        }
+                    }
+                }
+            };
+            walkDirectory(directoryPath);
+            return totalBytes / (1024 * 1024);
+        }
+        catch {
+            return -1;
+        }
+    }
     /**
      * Create a tar.gz archive of build output.
+     *
+     * Validates disk space before archiving. Skips archival with a warning
+     * if insufficient space is detected, preventing partial writes on full disks.
      */
     static archiveBuildOutput(sourcePath, archivePath) {
         if (!node_fs_1.default.existsSync(sourcePath)) {
@@ -9991,6 +10057,21 @@ class BuildReliabilityService {
             return;
         }
         node_fs_1.default.mkdirSync(archivePath, { recursive: true });
+        // Check available disk space before archiving
+        const sourceSizeMB = BuildReliabilityService.getDirectorySizeMB(sourcePath);
+        const availableSpaceMB = BuildReliabilityService.getAvailableSpaceMB(archivePath);
+        if (sourceSizeMB >= 0 && availableSpaceMB >= 0) {
+            const neededMB = Math.ceil(sourceSizeMB * 1.1); // 10% safety margin
+            if (availableSpaceMB < neededMB) {
+                core.warning(`[Reliability] Insufficient disk space for archive. ` +
+                    `Need ~${neededMB}MB, available: ${Math.floor(availableSpaceMB)}MB. Skipping archive.`);
+                return;
+            }
+            core.info(`[Reliability] Disk space check passed: need ~${neededMB}MB, available: ${Math.floor(availableSpaceMB)}MB`);
+        }
+        else if (availableSpaceMB < 0) {
+            core.warning('[Reliability] Could not determine available disk space. Proceeding with archive cautiously.');
+        }
         const timestamp = new Date().toISOString().replace(/[.:]/g, '-');
         const archiveFile = node_path_1.default.join(archivePath, `build-${timestamp}.tar.gz`);
         try {
@@ -10003,6 +10084,16 @@ class BuildReliabilityService {
         }
         catch (error) {
             core.warning(`[Reliability] Failed to archive build output: ${error.stderr?.toString() ?? error.message}`);
+            // Clean up partial archive if it exists to avoid leaving corrupted files
+            try {
+                if (node_fs_1.default.existsSync(archiveFile)) {
+                    node_fs_1.default.unlinkSync(archiveFile);
+                    core.info(`[Reliability] Cleaned up partial archive: ${archiveFile}`);
+                }
+            }
+            catch {
+                // Best-effort cleanup
+            }
         }
     }
     /**

src/model/orchestrator/services/reliability/build-reliability-service.ts

@@ -409,9 +409,7 @@ export class BuildReliabilityService {
         `[Reliability] Disk space check passed: need ~${neededMB}MB, available: ${Math.floor(availableSpaceMB)}MB`,
       );
     } else if (availableSpaceMB < 0) {
-      core.warning(
-        '[Reliability] Could not determine available disk space. Proceeding with archive cautiously.',
-      );
+      core.warning('[Reliability] Could not determine available disk space. Proceeding with archive cautiously.');
     }
 
     const timestamp = new Date().toISOString().replace(/[.:]/g, '-');