feat(app): add run foundation repository and models

This commit is contained in:
2026-10-21 13:21:30 +01:00
parent 264f64c0bb
commit 444bd62996
4 changed files with 128 additions and 0 deletions
@@ -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<JsonMap> runs, bool needsResync}) foldRunEvent(List<JsonMap> 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=<String,dynamic>{...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<JsonMap>.from(detail['steps']??[]); final i=steps.indexWhere((s)=>s['sequence']==delta['sequence']); if(i<0){steps.add(Map<String,dynamic>.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<String,dynamic>.from(delta)};} folded['steps']=steps; }
return folded;
}
@@ -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<JsonMap> filterRuns(List<JsonMap> runs, {Set<String> statuses = const {}, int? pipelineId}) => runs.where((r) => (statuses.isEmpty || statuses.contains(runStateOf(r['status']))) && (pipelineId == null || r['pipeline_id'] == pipelineId)).toList();
List<JsonMap> sortRuns(List<JsonMap> 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<JsonMap> 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<JsonMap> orderAttention(List<JsonMap> runs, {Set<String> 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;
}
+12
View File
@@ -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.
@@ -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<JsonMap> call(String type, [JsonMap fields = const {}]) async {
this.type = type;
this.fields = Map.of(fields);
return reply;
}
@override
Stream<JsonMap> 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 = <JsonMap>[{'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<RunsRepositoryException>()));
});
}