Flow, at a glance; New repository with an assistant to start it (closes #26, closes #27, refs andymccall/oxygenhub#347) 821035db5a1c

package io.oxygenhub.android.ui.flow

import androidx.compose.foundation.Canvas

import androidx.compose.foundation.clickable

import androidx.compose.foundation.layout.Arrangement

import androidx.compose.foundation.layout.Column

import androidx.compose.foundation.layout.Row

import androidx.compose.foundation.layout.fillMaxSize

import androidx.compose.foundation.layout.fillMaxWidth

import androidx.compose.foundation.layout.height

import androidx.compose.foundation.layout.padding

import androidx.compose.foundation.lazy.LazyColumn

import androidx.compose.foundation.lazy.items

import androidx.compose.material.icons.Icons

import androidx.compose.material.icons.outlined.RocketLaunch

import androidx.compose.material3.FilterChip

import androidx.compose.material3.MaterialTheme

import androidx.compose.material3.Text

import androidx.compose.runtime.Composable

import androidx.compose.runtime.LaunchedEffect

import androidx.compose.runtime.getValue

import androidx.compose.runtime.mutableStateOf

import androidx.compose.runtime.saveable.rememberSaveable

import androidx.compose.runtime.setValue

import androidx.compose.ui.Alignment

import androidx.compose.ui.Modifier

import androidx.compose.ui.graphics.Color

import androidx.compose.ui.text.font.FontWeight

import androidx.compose.ui.text.style.TextOverflow

import androidx.compose.ui.unit.dp

import androidx.lifecycle.ViewModel

import androidx.lifecycle.compose.collectAsStateWithLifecycle

import io.oxygenhub.android.api.FlowRun

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.UserFlowRun

import io.oxygenhub.android.api.UserSky

import io.oxygenhub.android.ui.backdrop.Backdrop

import io.oxygenhub.android.ui.backdrop.skyScene

import io.oxygenhub.android.ui.common.AppScreen

import io.oxygenhub.android.ui.common.EmptyState

import io.oxygenhub.android.ui.common.Load

import io.oxygenhub.android.ui.common.LoadContent

import io.oxygenhub.android.ui.common.Panel

import io.oxygenhub.android.ui.common.load

import io.oxygenhub.android.ui.common.panelColors

import io.oxygenhub.android.ui.common.relativeTime

import io.oxygenhub.android.ui.theme.LocalStatusColors

import kotlinx.coroutines.Job

import kotlinx.coroutines.delay

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

/** The runs of your repositories, newest first (#26), from the hub's `GET /user/flow/runs`. */

class FlowMonitorViewModel(private val api: HubApi) : ViewModel() {

    private val _state = MutableStateFlow<Load<List<UserFlowRun>>>(Load.Loading)

    val state: StateFlow<Load<List<UserFlowRun>>> = _state.asStateFlow()

    private var job: Job? = null

    init {

        refresh()

    }

    fun refresh() {

        job = load(_state, job) { api.userFlowRuns() }

    }

    /** Whether any run shown is still going: the screen then refreshes often. */

    val live: Boolean get() = (_state.value as? Load.Ready)?.value?.any { it.run.live } == true

}

/** What the monitor shows. */

enum class RunFilter(val label: String) { All("All"), Live("Live"), Failed("Failed") }

internal fun filtered(runs: List<UserFlowRun>, f: RunFilter): List<UserFlowRun> = when (f) {

    RunFilter.All -> runs

    RunFilter.Live -> runs.filter { it.run.live }

    RunFilter.Failed -> runs.filter { it.run.status == "failed" || it.run.status == "error" }

}

/** The runs as Your sky draws Flow runs: each repository a cluster, each run a mark (kind 4). */

internal fun runSky(runs: List<UserFlowRun>, now: Long): UserSky {

    val repos = runs.map { it.repository }.distinct()

    return UserSky(now = now, repos = repos, events = runs.map { listOf(repos.indexOf(it.repository).toLong(), 4L, it.run.createdMs, 1L) })

}

/** How long a run took, or has taken so far: "3 min 12 s". */

internal fun took(r: FlowRun, now: Long): String {

    if (r.createdMs <= 0) return ""

    val s = (((r.finishedMs ?: now) - r.createdMs) / 1000).coerceAtLeast(0)

    return when {

        s < 60 -> "$s s"

        s < 3600 -> "${s / 60} min ${s % 60} s"

        else -> "${s / 3600} h ${(s % 3600) / 60} min"

    }

}

@Composable

fun FlowMonitorScreen(vm: FlowMonitorViewModel, onOpenRun: (owner: String, name: String, number: Long) -> Unit) {

    val state by vm.state.collectAsStateWithLifecycle()

    var filter by rememberSaveable { mutableStateOf(RunFilter.All) }

    // Live while anything runs; a quiet look now and then otherwise. Only while shown.

    LaunchedEffect(vm) {

        while (true) {

            delay(if (vm.live) 5_000 else 30_000)

            vm.refresh()

        }

    }

    AppScreen(title = "Flow", subtitle = "your repositories' runs") {

        LoadContent(state, onRefresh = vm::refresh) { runs ->

            if (runs.isEmpty()) {

                EmptyState(Icons.Outlined.RocketLaunch, "No runs yet", "A push to one of your repositories with a .flow/pipeline.kdl starts one.")

                return@LoadContent

            }

            val now = System.currentTimeMillis()

            val shown = filtered(runs, filter)

            LazyColumn(Modifier.fillMaxSize(), verticalArrangement = Arrangement.spacedBy(8.dp)) {

                item(key = "sky") {

                    Backdrop(key = runs.map { it.repository to it.run.number }, make = { still -> skyScene(runSky(runs, now), still) }, modifier = Modifier.fillMaxWidth().height(120.dp)) {

                        Tally(runs, Modifier.align(Alignment.BottomStart).padding(16.dp))

                    }

                }

                item(key = "filters") {

                    Row(Modifier.padding(horizontal = 12.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) {

                        RunFilter.entries.forEach { f -> FilterChip(selected = filter == f, onClick = { filter = f }, label = { Text(f.label) }) }

                    }

                }

                if (shown.isEmpty()) {

                    item(key = "none") { Text("None ${filter.label.lowercase()} now.", Modifier.padding(16.dp), color = MaterialTheme.colorScheme.onSurfaceVariant) }

                }

                items(shown, key = { "${it.repository}#${it.run.number}" }) { r ->

                    RunCard(r, now, Modifier.padding(horizontal = 12.dp)) { onOpenRun(r.owner, r.name, r.run.number) }

                }

                item(key = "end") { Text("", Modifier.height(8.dp)) }

            }

        }

    }

}

/** Live, passed and failed among the runs shown, big, in their colours. */

@Composable

private fun Tally(runs: List<UserFlowRun>, modifier: Modifier = Modifier) {

    val s = LocalStatusColors.current

    Row(modifier, horizontalArrangement = Arrangement.spacedBy(20.dp)) {

        Count(runs.count { it.run.live }, "live", s.warn)

        Count(runs.count { it.run.status == "passed" }, "passed", s.ok)

        Count(runs.count { it.run.status == "failed" || it.run.status == "error" }, "failed", s.bad)

    }

}

@Composable

private fun Count(n: Int, what: String, colour: Color) {

    Column {

        Text("$n", style = MaterialTheme.typography.headlineMedium, fontWeight = FontWeight.Bold, color = colour)

        Text(what, style = MaterialTheme.typography.labelMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)

    }

}

@Composable

private fun RunCard(r: UserFlowRun, now: Long, modifier: Modifier, onClick: () -> Unit) {

    val (icon, colour) = statusLook(r.run.status)

    Panel(modifier.fillMaxWidth().clickable(onClick = onClick), colors = panelColors()) {

        Row(Modifier.padding(12.dp), horizontalArrangement = Arrangement.spacedBy(12.dp), verticalAlignment = Alignment.CenterVertically) {

            StatusIcon(r.run.status, icon, colour)

            Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) {

                Text("${r.repository} #${r.run.number}", style = MaterialTheme.typography.titleSmall, maxLines = 1, overflow = TextOverflow.Ellipsis)

                Text(

                    listOf(r.run.bookmark, r.run.trigger.substringBefore(':'), r.run.actor).filter { it.isNotBlank() }.joinToString(" · "),

                    style = MaterialTheme.typography.bodySmall,

                    color = MaterialTheme.colorScheme.onSurfaceVariant,

                    maxLines = 1,

                    overflow = TextOverflow.Ellipsis,

                )

                if (r.run.jobs.isNotEmpty()) JobDots(r.run)

            }

            Column(horizontalAlignment = Alignment.End) {

                Text(relativeTime(r.run.createdMs, now), style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSurfaceVariant)

                Text(took(r.run, now), style = MaterialTheme.typography.labelSmall, color = colour)

            }

        }

    }

}

/** One dot per job, in its status's colour: the run's shape at a glance. */

@Composable

private fun JobDots(run: FlowRun) {

    val colours = run.jobs.map { statusLook(it.status).second }

    Canvas(Modifier.padding(top = 4.dp).height(8.dp).fillMaxWidth()) {

        val d = size.height

        colours.forEachIndexed { i, c -> drawCircle(c, d / 2, androidx.compose.ui.geometry.Offset(d / 2 + i * d * 1.6f, d / 2)) }

    }

}

package io.oxygenhub.android.ui.repos

import androidx.compose.animation.core.LinearOutSlowInEasing

import androidx.compose.animation.core.animateFloat

import androidx.compose.animation.core.infiniteRepeatable

import androidx.compose.animation.core.rememberInfiniteTransition

import androidx.compose.animation.core.tween

import androidx.compose.foundation.layout.Arrangement

import androidx.compose.foundation.layout.Column

import androidx.compose.foundation.layout.Row

import androidx.compose.foundation.layout.fillMaxWidth

import androidx.compose.foundation.layout.imePadding

import androidx.compose.foundation.layout.padding

import androidx.compose.foundation.rememberScrollState

import androidx.compose.foundation.verticalScroll

import androidx.compose.material.icons.Icons

import androidx.compose.material.icons.automirrored.outlined.InsertDriveFile

import androidx.compose.material.icons.outlined.AutoAwesome

import androidx.compose.material3.Button

import androidx.compose.material3.FilterChip

import androidx.compose.material3.Icon

import androidx.compose.material3.LinearProgressIndicator

import androidx.compose.material3.ListItem

import androidx.compose.material3.MaterialTheme

import androidx.compose.material3.OutlinedTextField

import androidx.compose.material3.Text

import androidx.compose.material3.TextButton

import androidx.compose.runtime.Composable

import androidx.compose.runtime.LaunchedEffect

import androidx.compose.runtime.getValue

import androidx.compose.runtime.mutableStateOf

import androidx.compose.runtime.saveable.rememberSaveable

import androidx.compose.runtime.setValue

import androidx.compose.ui.Modifier

import androidx.compose.ui.draw.alpha

import androidx.compose.ui.unit.dp

import androidx.lifecycle.ViewModel

import androidx.lifecycle.compose.collectAsStateWithLifecycle

import androidx.lifecycle.viewModelScope

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.HubException

import io.oxygenhub.android.api.Repository

import io.oxygenhub.android.api.StarterAssistant

import io.oxygenhub.android.api.Visibility

import io.oxygenhub.android.api.userMessage

import io.oxygenhub.android.ui.common.AppScreen

import io.oxygenhub.android.ui.common.Panel

import io.oxygenhub.android.ui.theme.Tones

import kotlinx.coroutines.CancellationException

import kotlinx.coroutines.Job

import kotlinx.coroutines.delay

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

import kotlinx.coroutines.launch

/** Where making a repository stands (#27): its starter drafted by an assistant when asked (oxygenhub#347). */

sealed interface Making {

    data object Idle : Making

    data object Creating : Making

    data class Drafting(val repo: Repository, val assistant: String) : Making

    data class Done(val repo: Repository, val files: List<String>, val assistant: String) : Making

    data class Failed(val message: String, val repo: Repository? = null) : Making

}

/** A new repository: its owner (you or an organisation you belong to), name, description, visibility, and what to start it with. */

class NewRepositoryViewModel(

    private val api: HubApi,

    val username: String,

    private val pollMs: Long = 2_000,

    private val pollFor: Int = 180,

) : ViewModel() {

    private val _owners = MutableStateFlow(listOf(username))

    val owners: StateFlow<List<String>> = _owners.asStateFlow()

    private val _assistants = MutableStateFlow<List<StarterAssistant>>(emptyList())

    val assistants: StateFlow<List<StarterAssistant>> = _assistants.asStateFlow()

    private val _making = MutableStateFlow<Making>(Making.Idle)

    val making: StateFlow<Making> = _making.asStateFlow()

    private var asking: Job? = null

    init {

        viewModelScope.launch {

            try {

                _owners.value = listOf(username) + api.userOrgs().map { it.name }.filter { it != username }

            } catch (e: CancellationException) {

                throw e

            } catch (_: Exception) {

                // Without the call, only the account itself.

            }

        }

        assistantsFor(username)

    }

    /** Which assistants a repository under [owner] may ask; none when the hub cannot say. */

    fun assistantsFor(owner: String) {

        asking?.cancel()

        asking = viewModelScope.launch {

            _assistants.value = try {

                api.starterAssistants(owner)

            } catch (e: CancellationException) {

                throw e

            } catch (_: Exception) {

                emptyList()

            }

        }

    }

    fun create(owner: String, name: String, description: String, visibility: Visibility, ask: String) {

        if (_making.value == Making.Creating || name.isBlank()) return

        _making.value = Making.Creating

        viewModelScope.launch {

            val repo = try {

                api.createRepository(owner, name.trim(), description.trim(), visibility)

            } catch (e: CancellationException) {

                throw e

            } catch (e: HubException.Http) {

                _making.value = Making.Failed(

                    if (e.status == 403) "${e.userMessage()} (making repositories needs this phone to be allowed repo:admin: sign out and in again to allow it)" else e.userMessage(),

                )

                return@launch

            } catch (e: Exception) {

                _making.value = Making.Failed(e.userMessage())

                return@launch

            }

            val assistant = _assistants.value.firstOrNull()

            if (ask.isBlank() || assistant == null) {

                _making.value = Making.Done(repo, emptyList(), "")

                return@launch

            }

            draft(repo, ask.trim(), assistant.name)

        }

    }

    private suspend fun draft(repo: Repository, ask: String, assistant: String) {

        try {

            api.startStarter(repo.owner, repo.name, ask)

        } catch (e: CancellationException) {

            throw e

        } catch (e: Exception) {

            _making.value = Making.Failed("The repository was made, but its starter was not: ${e.userMessage()}", repo)

            return

        }

        _making.value = Making.Drafting(repo, assistant)

        repeat(pollFor) {

            delay(pollMs)

            val s = try {

                api.starterStatus(repo.owner, repo.name)

            } catch (e: CancellationException) {

                throw e

            } catch (_: Exception) {

                return@repeat

            }

            when (s.status) {

                "done" -> {

                    _making.value = Making.Done(repo, s.files, s.assistant.ifBlank { assistant })

                    return

                }

                "failed" -> {

                    _making.value = Making.Failed("The repository was made, but ${s.assistant.ifBlank { assistant }} could not draft it: ${s.error}", repo)

                    return

                }

                "none" -> {

                    _making.value = Making.Failed("The repository was made; the hub restarted while its starter was drafted, so it has no files yet.", repo)

                    return

                }

            }

        }

        _making.value = Making.Failed("The repository was made; its starter is taking long, and may still arrive.", repo)

    }

}

@Composable

fun NewRepositoryScreen(vm: NewRepositoryViewModel, canCreate: Boolean, onBack: () -> Unit, onOpen: (Repository) -> Unit) {

    val owners by vm.owners.collectAsStateWithLifecycle()

    val assistants by vm.assistants.collectAsStateWithLifecycle()

    val making by vm.making.collectAsStateWithLifecycle()

    var owner by rememberSaveable { mutableStateOf(vm.username) }

    var name by rememberSaveable { mutableStateOf("") }

    var description by rememberSaveable { mutableStateOf("") }

    var visibility by rememberSaveable { mutableStateOf(Visibility.Public) }

    var ask by rememberSaveable { mutableStateOf("") }

    LaunchedEffect(owner) { vm.assistantsFor(owner) }

    AppScreen(title = "New repository", onBack = onBack) {

        Column(

            Modifier.verticalScroll(rememberScrollState()).padding(16.dp).imePadding(),

            verticalArrangement = Arrangement.spacedBy(12.dp),

        ) {

            when (val m = making) {

                is Making.Drafting -> {

                    Drafting(m.assistant, "${m.repo.owner}/${m.repo.name}")

                    return@Column

                }

                is Making.Done -> {

                    Made(m, onOpen)

                    return@Column

                }

                else -> {}

            }

            if (!canCreate) {

                Text(

                    "This phone was signed in without repo:admin, which making a repository needs. Sign out and in again, and allow it on the hub's page.",

                    color = MaterialTheme.colorScheme.error,

                    style = MaterialTheme.typography.bodyMedium,

                )

            }

            if (owners.size > 1) {

                Text("Owner", style = MaterialTheme.typography.labelLarge)

                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {

                    owners.forEach { o -> FilterChip(selected = owner == o, onClick = { owner = o }, label = { Text(o) }) }

                }

            }

            OutlinedTextField(name, { name = it }, label = { Text("Name") }, prefix = { Text("$owner/") }, singleLine = true, modifier = Modifier.fillMaxWidth())

            OutlinedTextField(description, { description = it }, label = { Text("Description (optional)") }, singleLine = true, modifier = Modifier.fillMaxWidth())

            Text("Visibility", style = MaterialTheme.typography.labelLarge)

            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {

                Visibility.entries.forEach { v ->

                    FilterChip(selected = visibility == v, onClick = { visibility = v }, label = { Text(v.name) })

                }

            }

            assistants.firstOrNull()?.let { a ->

                Panel(Modifier.fillMaxWidth()) {

                    Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {

                        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {

                            Icon(Icons.Outlined.AutoAwesome, contentDescription = null, tint = Tones.release)

                            Text("Start it with ${a.name}", style = MaterialTheme.typography.titleSmall)

                        }

                        OutlinedTextField(

                            ask,

                            { ask = it },

                            placeholder = { Text("Describe what you want to create…") },

                            minLines = 3,

                            modifier = Modifier.fillMaxWidth(),

                        )

                        Text(

                            "${a.name} (${a.model}, from ${a.from}) drafts a README, build files, a source layout and a first test, committed as you. Leave it empty for an empty repository.",

                            style = MaterialTheme.typography.bodySmall,

                            color = MaterialTheme.colorScheme.onSurfaceVariant,

                        )

                    }

                }

            }

            (making as? Making.Failed)?.let { f ->

                Text(f.message, color = MaterialTheme.colorScheme.error)

                f.repo?.let { r -> TextButton(onClick = { onOpen(r) }) { Text("Open ${r.owner}/${r.name}") } }

            }

            Button(

                enabled = canCreate && name.isNotBlank() && making != Making.Creating,

                onClick = { vm.create(owner, name, description, visibility, ask) },

                modifier = Modifier.fillMaxWidth(),

            ) { Text(if (ask.isNotBlank() && assistants.isNotEmpty()) "Create and draft" else "Create repository") }

            if (making == Making.Creating) LinearProgressIndicator(Modifier.fillMaxWidth())

        }

    }

}

/** An assistant at work: its name, the repository, and a breathing sparkle. */

@Composable

private fun Drafting(assistant: String, slug: String) {

    val pulse by rememberInfiniteTransition(label = "drafting").animateFloat(

        0.35f,

        1f,

        infiniteRepeatable(tween(900, easing = LinearOutSlowInEasing), androidx.compose.animation.core.RepeatMode.Reverse),

        label = "pulse",

    )

    Panel(Modifier.fillMaxWidth()) {

        Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {

            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {

                Icon(Icons.Outlined.AutoAwesome, contentDescription = null, tint = Tones.release, modifier = Modifier.alpha(pulse))

                Text("$assistant is drafting $slug…", style = MaterialTheme.typography.titleSmall)

            }

            LinearProgressIndicator(Modifier.fillMaxWidth())

            Text(

                "The repository is made; its first files arrive when the model has written them. You can leave this screen: they land on the repository either way.",

                style = MaterialTheme.typography.bodySmall,

                color = MaterialTheme.colorScheme.onSurfaceVariant,

            )

        }

    }

}

@Composable

private fun Made(m: Making.Done, onOpen: (Repository) -> Unit) {

    Panel(Modifier.fillMaxWidth()) {

        Column(Modifier.padding(vertical = 8.dp)) {

            Text(

                if (m.files.isEmpty()) "${m.repo.owner}/${m.repo.name} is made" else "${m.assistant} drafted ${m.files.size} files",

                style = MaterialTheme.typography.titleMedium,

                modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),

            )

            m.files.forEach { f ->

                ListItem(

                    leadingContent = { Icon(Icons.AutoMirrored.Outlined.InsertDriveFile, contentDescription = null, tint = Tones.info) },

                    headlineContent = { Text(f) },

                )

            }

            TextButton(onClick = { onOpen(m.repo) }, modifier = Modifier.padding(horizontal = 8.dp)) { Text("Open ${m.repo.owner}/${m.repo.name}") }

        }

    }

}

package io.oxygenhub.android.ui

import io.oxygenhub.android.FakeHubApi

import io.oxygenhub.android.MainDispatcherRule

import io.oxygenhub.android.api.FlowJob

import io.oxygenhub.android.api.FlowRun

import io.oxygenhub.android.api.HubException

import io.oxygenhub.android.api.StarterAssistant

import io.oxygenhub.android.api.StarterStatus

import io.oxygenhub.android.api.UserFlowRun

import io.oxygenhub.android.api.Visibility

import io.oxygenhub.android.ui.flow.RunFilter

import io.oxygenhub.android.ui.flow.filtered

import io.oxygenhub.android.ui.flow.runSky

import io.oxygenhub.android.ui.flow.took

import io.oxygenhub.android.ui.repos.Making

import io.oxygenhub.android.ui.repos.NewRepositoryViewModel

import org.junit.Assert.assertEquals

import org.junit.Assert.assertTrue

import org.junit.Rule

import org.junit.Test

class NewRepositoryAndFlowTest {

    @get:Rule val main = MainDispatcherRule()

    private val api = FakeHubApi()

    @Test

    fun aRepositoryIsMadeUnderYouOrAnOrganisationYouBelongTo() {

        val vm = NewRepositoryViewModel(api, "andymccall")

        assertEquals(listOf("andymccall", "doomsdayone"), vm.owners.value)

        vm.create("doomsdayone", " pong ", " A game ", Visibility.Private, ask = "")

        val done = vm.making.value as Making.Done

        assertEquals(("doomsdayone" to "pong"), done.repo.owner to done.repo.name)

        assertEquals(Visibility.Private, done.repo.visibility)

        assertTrue("no starter without an assistant: ${api.calls}", api.calls.none { it.startsWith("start starter") })

    }

    @Test

    fun anAssistantDraftsTheStarterAndTheScreenFollowsIt() {

        api.starterAssistants = { listOf(StarterAssistant("Helper", "m1", "the site")) }

        api.starterStatuses = mutableListOf(StarterStatus("running", "Helper"), StarterStatus("done", "Helper", "abc", listOf("README.md", "src/main.rs")))

        val vm = NewRepositoryViewModel(api, "andymccall", pollMs = 10)

        vm.create("andymccall", "pong", "", Visibility.Public, ask = "A pong game in Rust")

        assertTrue(vm.making.value is Making.Drafting)

        main.dispatcher.scheduler.advanceUntilIdle()

        val done = vm.making.value as Making.Done

        assertEquals(listOf("README.md", "src/main.rs"), done.files)

        assertEquals("Helper", done.assistant)

    }

    @Test

    fun aFailedDraftStillOpensTheRepositoryAndSaysWhy() {

        api.starterAssistants = { listOf(StarterAssistant("Helper")) }

        api.starterStatuses = mutableListOf(StarterStatus("failed", "Helper", error = "the assistant answered without any files"))

        val vm = NewRepositoryViewModel(api, "andymccall", pollMs = 10)

        vm.create("andymccall", "pong", "", Visibility.Public, ask = "something")

        main.dispatcher.scheduler.advanceUntilIdle()

        val failed = vm.making.value as Making.Failed

        assertTrue(failed.message, failed.message.contains("without any files"))

        assertEquals("pong", failed.repo?.name)

    }

    @Test

    fun aPhoneWithoutRepoAdminIsToldHowToAllowIt() {

        api.createRepository = { _, _, _, _ -> throw HubException.Http(403, "this token lacks the repo:admin scope") }

        val vm = NewRepositoryViewModel(api, "andymccall")

        vm.create("andymccall", "pong", "", Visibility.Public, ask = "")

        val failed = vm.making.value as Making.Failed

        assertTrue(failed.message, failed.message.contains("sign out and in again"))

    }

    private fun run(repo: String, n: Long, status: String, created: Long, finished: Long? = null, jobs: List<String> = emptyList()) =

        UserFlowRun(repo, FlowRun(number = n, status = status, createdMs = created, finishedMs = finished, jobs = jobs.map { FlowJob(name = it, status = status) }))

    @Test

    fun theMonitorFiltersDrawsAndTimesRuns() {

        val runs = listOf(

            run("andy/a", 3, "running", 9_000),

            run("andy/b", 2, "failed", 5_000, 8_000),

            run("andy/a", 1, "passed", 1_000, 200_000, jobs = listOf("build", "test")),

        )

        assertEquals(listOf(3L), filtered(runs, RunFilter.Live).map { it.run.number })

        assertEquals(listOf(2L), filtered(runs, RunFilter.Failed).map { it.run.number })

        assertEquals(3, filtered(runs, RunFilter.All).size)

        val sky = runSky(runs, now = 10_000)

        assertEquals(listOf("andy/a", "andy/b"), sky.repos)

        assertEquals(listOf(listOf(0L, 4L, 9_000L, 1L), listOf(1L, 4L, 5_000L, 1L), listOf(0L, 4L, 1_000L, 1L)), sky.events)

        assertEquals("3 s", took(runs[1].run, now = 10_000))

        assertEquals("3 min 19 s", took(runs[2].run, now = 0))

        assertEquals("1 s", took(runs[0].run, now = 10_000), )

    }

}

- **Flow, at a glance (#26):** a Flow destination in the navigation: the runs of all your repositories, newest first, over a band of their sky (each repository a cluster, each run a mark) with how many are live, passed and failed; filters for live and failed; each run with its pulsing status, bookmark, trigger, who, when, how long, and a dot per job in its colour; tap for the run. Live runs refresh every 5 s while it is open. From OxygenHub's `GET /user/flow/runs`.

- **New repository, and an assistant to start it (#27, oxygenhub#347):** Repositories has a + for a new repository: under you or an organisation you belong to, with a description and visibility. When the owner has an assistant set up, "Describe what you want to create…" asks it for a starting point (a README, build files, a source layout and a first test), drafted on the hub and committed as you; the screen follows it and lists the files. The app now asks for `repo:admin` at sign-in (making repositories needs it); a phone signed in before says to sign in again.

val AppScopes: List<String> = listOf("repo:read", "repo:write", "repo:admin", "user:read")

/** Makes repositories (#27); asked for since 0.1.1. */

const val AdminScope = "repo:admin"

    /** The organisations the account belongs to (oxygenhub#302). */

    suspend fun userOrgs(): List<UserOrg>

    /** Create a repository (#27): `repo:admin`. */

    suspend fun createRepository(owner: String, name: String, description: String, visibility: Visibility): Repository

    /** The assistants a new repository under [owner] may ask for its starting files (oxygenhub#347). */

    suspend fun starterAssistants(owner: String): List<StarterAssistant>

    /** Ask an assistant for an empty repository's starting files; it works in the background. */

    suspend fun startStarter(owner: String, name: String, description: String): StarterStatus

    suspend fun starterStatus(owner: String, name: String): StarterStatus

    /** The newest runs of your repositories, with their jobs (#26); [before] (ms) pages back. */

    suspend fun userFlowRuns(before: Long? = null): List<UserFlowRun>

    override suspend fun userOrgs(): List<UserOrg> = get(url("user", "orgs"), ListSerializer(UserOrg.serializer()))

    override suspend fun createRepository(owner: String, name: String, description: String, visibility: Visibility): Repository {

        val json = buildJsonObject {

            put("owner", owner)

            put("name", name)

            put("description", description)

            put("visibility", HubJson.encodeToJsonElement(Visibility.serializer(), visibility))

        }

        return sendJson("POST", url("repos"), json, Repository.serializer())

    }

    override suspend fun starterAssistants(owner: String): List<StarterAssistant> =

        get(url("user", "starter") { addQueryParameter("owner", owner) }, StarterAssistants.serializer()).assistants

    override suspend fun startStarter(owner: String, name: String, description: String): StarterStatus =

        sendJson("POST", url("repos", owner, name, "starter"), buildJsonObject { put("description", description) }, StarterStatus.serializer())

    override suspend fun starterStatus(owner: String, name: String): StarterStatus =

        get(url("repos", owner, name, "starter"), StarterStatus.serializer())

    override suspend fun userFlowRuns(before: Long?): List<UserFlowRun> =

        get(url("user", "flow", "runs") { before?.let { addQueryParameter("before", it.toString()) } }, ListSerializer(JsonObject.serializer()))

            .map { o -> UserFlowRun((o["repository"] as? JsonPrimitive)?.content.orEmpty(), HubJson.decodeFromJsonElement(FlowRun.serializer(), o)) }

/** `GET /api/v1/user/orgs`: an organisation the caller belongs to, and their role in it. */

@Serializable

data class UserOrg(

    val name: String,

    @SerialName("display_name") val displayName: String = "",

    val role: String = "",

)

/** `GET /api/v1/user/starter?owner=X` (#27, oxygenhub#347): an assistant a new repository may ask. */

@Serializable

data class StarterAssistant(val name: String, val model: String = "", val from: String = "")

@Serializable

data class StarterAssistants(val assistants: List<StarterAssistant> = emptyList())

/** Where a repository's starter stands: `running`, `done`, `failed` or `none`. */

@Serializable

data class StarterStatus(

    val status: String = "none",

    val assistant: String = "",

    val change: String = "",

    val files: List<String> = emptyList(),

    val error: String = "",

)

/** `GET /api/v1/user/flow/runs` (#26): a run of one of your repositories. */

data class UserFlowRun(val repository: String, val run: FlowRun) {

    val owner: String get() = repository.substringBefore('/')

    val name: String get() = repository.substringAfter('/')

}

    /** Whether the token may make repositories (#27); a sign-in before 0.1.1 was not asked for it. */

    val canCreate: Boolean get() = scopes.isEmpty() || io.oxygenhub.android.api.AdminScope in scopes

import androidx.compose.material.icons.filled.RocketLaunch

import androidx.compose.material.icons.outlined.RocketLaunch

import io.oxygenhub.android.ui.flow.FlowMonitorScreen

import io.oxygenhub.android.ui.flow.FlowMonitorViewModel

import io.oxygenhub.android.ui.repos.NewRepositoryScreen

import io.oxygenhub.android.ui.repos.NewRepositoryViewModel

@Serializable data object NewRepositoryRoute

@Serializable data object FlowRoute

    Flow("Flow", Icons.Outlined.RocketLaunch, Icons.Filled.RocketLaunch, FlowRoute, FlowRoute::class),

                RepositoriesScreen(

                    rememberViewModel { RepositoriesViewModel(api, session.username) },

                    selectedRepository,

                    onNew = { nav.navigate(NewRepositoryRoute) },

                ) { slug, onBack ->

            }

            composable<FlowRoute> {

                FlowMonitorScreen(rememberViewModel { FlowMonitorViewModel(api) }) { owner, name, number -> nav.navigate(RunRoute(owner, name, number)) }

            }

            composable<NewRepositoryRoute> {

                NewRepositoryScreen(

                    rememberViewModel { NewRepositoryViewModel(api, session.username) },

                    canCreate = session.canCreate,

                    onBack = { nav.popBackStack() },

                    onOpen = { r -> nav.navigate(IssuesRoute(r.owner, r.name)) { popUpTo<NewRepositoryRoute> { inclusive = true } } },

                )

import androidx.compose.foundation.gestures.awaitEachGesture

import androidx.compose.foundation.gestures.awaitFirstDown

import androidx.compose.material.icons.outlined.Add

import androidx.compose.material3.IconButton

import androidx.compose.runtime.rememberCoroutineScope

import androidx.compose.ui.Modifier

    /** New repository (#27), when this phone may make one. */

    onNew: (() -> Unit)? = null,

                }, onNew = onNew)

private fun RepositoryList(vm: RepositoriesViewModel, selected: String?, onOpen: (Repository) -> Unit, onNew: (() -> Unit)? = null) {

    AppScreen(

        title = "Repositories",

        actions = {

            onNew?.let { IconButton(onClick = it) { Icon(Icons.Outlined.Add, contentDescription = "New repository") } }

        },

    ) {

    var userOrgs: () -> List<io.oxygenhub.android.api.UserOrg> = { listOf(io.oxygenhub.android.api.UserOrg("doomsdayone", role = "owner")) }

    override suspend fun userOrgs() = userOrgs.invoke().also { calls += "user orgs" }

    var createRepository: (String, String, String, io.oxygenhub.android.api.Visibility) -> Repository = { o, n, d, v ->

        Repository(owner = o, name = n, description = d, visibility = v)

    }

    override suspend fun createRepository(owner: String, name: String, description: String, visibility: io.oxygenhub.android.api.Visibility) =

        createRepository.invoke(owner, name, description, visibility).also { calls += "create $owner/$name" }

    var starterAssistants: (String) -> List<io.oxygenhub.android.api.StarterAssistant> = { emptyList() }

    override suspend fun starterAssistants(owner: String) = starterAssistants.invoke(owner).also { calls += "starter assistants $owner" }

    var startStarter: (String) -> io.oxygenhub.android.api.StarterStatus = { io.oxygenhub.android.api.StarterStatus("running") }

    override suspend fun startStarter(owner: String, name: String, description: String) =

        startStarter.invoke(description).also { calls += "start starter $owner/$name" }

    /** Each call answers the next status in the list (the last one repeats). */

    var starterStatuses: MutableList<io.oxygenhub.android.api.StarterStatus> = mutableListOf()

    override suspend fun starterStatus(owner: String, name: String): io.oxygenhub.android.api.StarterStatus {

        calls += "starter status $owner/$name"

        return if (starterStatuses.size > 1) starterStatuses.removeAt(0) else starterStatuses.firstOrNull() ?: io.oxygenhub.android.api.StarterStatus()

    }

    var userFlowRuns: () -> List<io.oxygenhub.android.api.UserFlowRun> = { emptyList() }

    override suspend fun userFlowRuns(before: Long?) = userFlowRuns.invoke().also { calls += "user flow runs" }