diff --git a/app/lib/features/runs/domain/run_events.dart b/app/lib/features/runs/domain/run_events.dart new file mode 100644 index 00000000..5462d217 --- /dev/null +++ b/app/lib/features/runs/domain/run_events.dart @@ -0,0 +1,24 @@ +import '../../../core/api_gateway.dart'; +const _terminal = {'succeeded','failed','canceled','interrupted'}; +int _rank(dynamic s) => s == 'queued' ? 0 : {'running','waiting'}.contains(s) ? 1 : _terminal.contains(s) ? 2 : -1; +int _stepRank(dynamic s) => {'running','waiting'}.contains(s) ? 1 : {'completed','failed','canceled','interrupted'}.contains(s) ? 2 : -1; +bool _stale(dynamic a, dynamic b, int Function(dynamic) rank) => '${b ?? ''}'.trim().isNotEmpty && rank(a) >= 0 && rank(b) >= 0 && (rank(b) < rank(a) || (rank(a) == 2 && rank(b) == 2 && a != b)); +String _advance(dynamic a, dynamic b, int Function(dynamic) rank) => '${b ?? ''}'.trim().isEmpty || rank(b) < rank(a) || (rank(a) == 2 && rank(b) == 2) ? '${a ?? ''}' : '${b ?? ''}'; +({List runs, bool needsResync}) foldRunEvent(List runs, JsonMap frame) { + final id = frame['run_id']; if (id is! num || id <= 0) return (runs:runs, needsResync:false); + final i = runs.indexWhere((r) => r['id'] == id); + if (i < 0) { final pid=frame['pipeline_id']; final name=frame['name']; if (pid is! num || '${name ?? ''}'.trim().isEmpty) return (runs:runs, needsResync:true); + return (runs:[{'id':id,'pipeline_id':pid,'name':name,'title':frame['title'],'version':frame['version'] ?? 0,'status':frame['status'] ?? '', 'executing':true,'completed_steps':frame['completed_steps'] ?? 0,'created_at':frame['created_at'] ?? '', 'finished_at':frame['finished_at'] ?? '', 'resource_wait':frame['resource_wait']}, ...runs], needsResync:false); } + final current=runs[i]; if (_stale(current['status'],frame['status'],_rank) && frame['resource_wait_set'] != true) return (runs:runs, needsResync:false); + final status=frame['resource_wait_set']==true && frame['status']=='queued' && !_terminal.contains(current['status']) ? 'queued' : _advance(current['status'],frame['status'],_rank); + final updated={...current,'status':status,'executing':status=='queued'||status=='running','completed_steps':(((current['completed_steps'] as num?)??0).toInt()).clamp(((frame['completed_steps'] as num?)??0).toInt(),0x7fffffff),'resource_wait':_terminal.contains(status)?null:frame['resource_wait_set']==true?frame['resource_wait']:current['resource_wait']}; + for(final k in ['outcome','current_stage','finished_at','created_at']) { if ('${frame[k]??''}'.trim().isNotEmpty) updated[k]=frame[k]; } + final next=[...runs]; next[i]=updated; return (runs:next,needsResync:false); +} +bool runDetailNeedsFullSync(JsonMap f) => _terminal.contains(f['status']) || f['status']=='waiting' || f['cancel_requested']==true || f['cleanup_unconfirmed']==true || f['step']?['status']=='waiting' || _stepRank(f['step']?['status'])==2; +JsonMap? foldRunEventDetail(JsonMap? detail, JsonMap frame) { + if(detail==null || detail['id']!=frame['run_id'] || (_stale(detail['status'],frame['status'],_rank)&&frame['resource_wait_set']!=true)) return detail; + final folded=foldRunEvent([detail],frame).runs.single; final delta=frame['step']; + if(delta is Map) { final steps=List.from(detail['steps']??[]); final i=steps.indexWhere((s)=>s['sequence']==delta['sequence']); if(i<0){steps.add(Map.from(delta));steps.sort((a,b)=>((a['sequence'] as num?)??0).compareTo((b['sequence'] as num?)??0));} else if(!_stale(steps[i]['status'],delta['status'],_stepRank)){steps[i]={...steps[i],...Map.from(delta)};} folded['steps']=steps; } + return folded; +} diff --git a/app/lib/features/runs/domain/run_models.dart b/app/lib/features/runs/domain/run_models.dart new file mode 100644 index 00000000..5fe96a56 --- /dev/null +++ b/app/lib/features/runs/domain/run_models.dart @@ -0,0 +1,33 @@ +import '../../../core/api_gateway.dart'; + +const runStates = ['queued', 'running', 'waiting', 'succeeded', 'failed', 'canceled', 'interrupted']; +({String label, String? pipeline}) runIdentity(dynamic title, dynamic name) { + final stored = '${title ?? ''}'.trim(); + return (label: stored.isNotEmpty ? stored : '${name ?? ''}', pipeline: stored.isNotEmpty ? '${name ?? ''}' : null); +} +String runStateOf(dynamic status) => switch ('${status ?? ''}'.trim().toLowerCase()) { + 'queued' || 'running' || 'waiting' || 'active' || 'blocked' || 'skipped' => '${status ?? ''}'.trim().toLowerCase(), + 'succeeded' || 'success' || 'completed' || 'done' => 'succeeded', + 'failed' || 'error' => 'failed', 'canceled' || 'cancelled' => 'canceled', 'interrupted' => 'interrupted', _ => 'unknown', +}; +List filterRuns(List runs, {Set statuses = const {}, int? pipelineId}) => runs.where((r) => (statuses.isEmpty || statuses.contains(runStateOf(r['status']))) && (pipelineId == null || r['pipeline_id'] == pipelineId)).toList(); +List sortRuns(List runs, {String sort = 'newest_first'}) { + int time(dynamic x) => DateTime.tryParse('${x ?? ''}')?.millisecondsSinceEpoch ?? -0x7fffffffffffffff; + final result = [...runs]; + result.sort((a,b) { + final c = switch (sort) { 'oldest_first' => time(a['created_at']).compareTo(time(b['created_at'])), 'pipeline_name' => '${a['name'] ?? ''}'.toLowerCase().compareTo('${b['name'] ?? ''}'.toLowerCase()), 'status' => '${a['status'] ?? ''}'.compareTo('${b['status'] ?? ''}'), _ => time(b['created_at']).compareTo(time(a['created_at'])) }; + return c == 0 ? ((b['id'] as num?) ?? 0).compareTo((a['id'] as num?) ?? 0) : c; + }); + return result; +} +/// Null usage means unsupported/unavailable, not zero. +class RunListResult { const RunListResult(this.runs, this.usage); final List runs; final JsonMap? usage; } +class DecisionOption { const DecisionOption(this.key, {this.target = ''}); final String key; final String target; } +class DecisionDraft { const DecisionDraft({this.selected, this.feedback = ''}); final String? selected; final String feedback; bool get canSubmit => selected != null && selected!.trim().isNotEmpty; } +String attentionKey(num runId, String kind) => '$runId:$kind'; +List orderAttention(List runs, {Set dismissed = const {}}) { + final result = runs.where((r) => ['waiting','failed'].contains(r['status']) && !dismissed.contains(attentionKey(r['id'] as num, r['status'] == 'waiting' ? 'Decision' : 'Failed'))).toList(); + int at(JsonMap r) => DateTime.tryParse('${r['finished_at'] ?? r['created_at'] ?? ''}')?.millisecondsSinceEpoch ?? 0; + result.sort((a,b) { final rank = (a['status'] == 'waiting' ? 0 : 1).compareTo(b['status'] == 'waiting' ? 0 : 1); if (rank != 0) return rank; final date = at(b).compareTo(at(a)); return date != 0 ? date : (b['id'] as num).compareTo(a['id'] as num); }); + return result; +} diff --git a/app/notes/F3.md b/app/notes/F3.md new file mode 100644 index 00000000..79954b60 --- /dev/null +++ b/app/notes/F3.md @@ -0,0 +1,12 @@ +# F3 run foundation + +Public API: `run_models.dart` provides run identity/state/filter/sort helpers, +`RunListResult`, decision draft/option values, and attention ordering/identity. +`run_events.dart` provides monotonic list/detail event folds and +`runDetailNeedsFullSync`. `data/runs_repository.dart` provides `RunsRepository` +for list/get/cancel/retry/decide/title/start calls through the shared gateway. + +Focused tests cover stale lifecycle deltas, explicit resource-wait clearing, +unknown usage versus zero, decision refusal, attention identity/order, and exact +retry/start fields. This is a nonvisual foundation; browser UI captures were not +applicable. Mobile targets are unverified. diff --git a/app/test/features/runs/runs_foundation_test.dart b/app/test/features/runs/runs_foundation_test.dart new file mode 100644 index 00000000..9ad8f833 --- /dev/null +++ b/app/test/features/runs/runs_foundation_test.dart @@ -0,0 +1,59 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/runs/data/runs_repository.dart'; +import 'package:pipelines_app/features/runs/domain/run_events.dart'; +import 'package:pipelines_app/features/runs/domain/run_models.dart'; + +class FakeGateway implements ApiGateway { + String? type; + JsonMap fields = {}; + JsonMap reply = {}; + @override + Future call(String type, [JsonMap fields = const {}]) async { + this.type = type; + this.fields = Map.of(fields); + return reply; + } + @override + Stream get frames => const Stream.empty(); +} + +void main() { + test('filter/sort identities and unknown usage remain distinct', () { + expect(runIdentity(' Report ', 'Build').label, 'Report'); + final rows = [{'id': 1, 'pipeline_id': 2, 'status': 'failed', 'created_at': '2024-01-01'}, {'id': 2, 'pipeline_id': 2, 'status': 'running', 'created_at': '2025-01-01'}]; + expect(filterRuns(rows, statuses: {'failed'}).single['id'], 1); + expect(sortRuns(rows).first['id'], 2); + expect(RunListResult(const [], null).usage, isNull); + }); + + test('fold is monotonic and explicit resource wait clearing is honored', () { + final rows = [{'id': 1, 'status': 'running', 'completed_steps': 3, 'resource_wait': {'resource': 'gpu'}}]; + final stale = foldRunEvent(rows, {'run_id': 1, 'status': 'queued', 'completed_steps': 1}); + expect(stale.runs.single['status'], 'running'); + final cleared = foldRunEvent(rows, {'run_id': 1, 'status': 'queued', 'resource_wait_set': true, 'resource_wait': null}); + expect(cleared.runs.single['status'], 'queued'); + expect(cleared.runs.single['resource_wait'], isNull); + expect(cleared.runs.single['completed_steps'], 3); + expect(runDetailNeedsFullSync({'status': 'waiting'}), isTrue); + }); + + test('decision guard and attention dismissal identity', () { + expect(const DecisionDraft().canSubmit, isFalse); + expect(const DecisionDraft(selected: ' continue ').canSubmit, isTrue); + expect(attentionKey(7, 'Decision'), '7:Decision'); + final ordered = orderAttention([{'id': 8, 'status': 'failed'}, {'id': 7, 'status': 'waiting'}]); + expect(ordered.first['id'], 7); + }); + + test('repository emits exact action envelopes and requires idempotency key', () async { + final gateway = FakeGateway()..reply = {'run_detail': {'id': 3}}; + final repo = RunsRepository(gateway); + await repo.retryRun(3, requestKey: 'retry-1'); + expect(gateway.type, 'retry_run'); + expect(gateway.fields, {'run_id': 3, 'request_key': 'retry-1'}); + await repo.startRun(pipelineId: 4, version: 2, prompt: 'hello', workspace: ' /work ', requestKey: 'start-2'); + expect(gateway.fields, {'pipeline_id': 4, 'version': 2, 'request_key': 'start-2', 'workspace': '/work', 'input': {'prompt': 'hello'}}); + await expectLater(repo.decideRun(3, option: ' '), throwsA(isA())); + }); +}