import '../../../core/api_gateway.dart'; import 'change_capture.dart'; import 'file_change.dart'; /// The run-level final-state aggregate of recorded file captures. Ported from /// `web/src/changes.js` `runChanges`: /// /// * a null `file_changes` is missing evidence (pending while the step is /// running/waiting), never "no changes"; /// * a present capture with no files is a real, observed no-change; /// * a path recorded by several visits is one entry, in first-seen order, whose /// per-file facts come from the last recorded visit (the run's final state); /// * capture counters and caveats describe every contributing step. class RunChanges { const RunChanges({ required this.files, required this.stepsWithChanges, required this.stepsPending, required this.added, required this.removed, required this.partial, required this.unavailable, required this.pending, required this.missingCaptures, required this.skipped, required this.omitted, required this.diagnostic, }); final List files; final int stepsWithChanges; final int stepsPending; final int added; final int removed; final bool partial; final bool unavailable; final bool pending; final int missingCaptures; final int skipped; final int omitted; final String diagnostic; } RunChanges runChanges(List steps) => runChangesFor(stageCaptures(steps)); /// Whether the run-wide final-state aggregate may be presented. Ported from /// `web/src/changes.js` `showRunChangesSummary`: only a settled succeeded run /// has a final workspace state. A failed or running run keeps its evidence in /// each visit's own captured section instead of claiming a settled summary. bool showRunChangesSummary(Object? status) => status != null && '$status'.trim().toLowerCase() == 'succeeded'; /// The same aggregate over already-derived [stageCaptures], so a caller that /// shows both the summary and the sections parses each capture only once. RunChanges runChangesFor(List visits) { final entries = {}; var stepsWithChanges = 0; var stepsPending = 0; var partial = false; var unavailable = false; var missingCaptures = 0; var skipped = 0; var omitted = 0; var truncatedSeen = false; final diagnostics = {}; for (final visit in visits) { final capture = visit.capture; if (capture == null) { final status = visit.stepStatus.trim().toLowerCase(); if (status == 'running' || status == 'waiting') { stepsPending++; } else { missingCaptures++; } continue; } stepsWithChanges++; if (capture.unavailable) unavailable = true; if (capture.partial) partial = true; if (capture.diagnostic.isNotEmpty) diagnostics.add(capture.diagnostic); skipped += capture.skipped; omitted += capture.omitted; for (final file in capture.files) { if (file.truncated) truncatedSeen = true; final existing = entries[file.path]; final names = existing == null ? [] : [...existing.steps]; if (!names.contains(visit.stage)) names.add(visit.stage); entries[file.path] = file.withSteps(names); } } final files = entries.values.toList(growable: false); return RunChanges( files: List.unmodifiable(files), stepsWithChanges: stepsWithChanges, stepsPending: stepsPending, added: files.fold(0, (sum, file) => sum + file.added), removed: files.fold(0, (sum, file) => sum + file.removed), partial: partial || truncatedSeen || omitted > 0, unavailable: unavailable, pending: stepsWithChanges == 0 && stepsPending > 0, missingCaptures: missingCaptures, skipped: skipped, omitted: omitted, diagnostic: diagnostics.join(' '), ); }