irisandClaude Opus 5
32b2a4871a
The composer's settings row is outlined bubbles opening round menus, and the message box is a TextFieldValue so anything put into it without being typed -- a draft, a share, a slash command -- leaves the cursor at the end. A tap that puts a text selection away no longer also collapses the card the text was drawn in: every open and close on the session screen goes through one guard that spends such a press on the selection. The usage bar and the usage dialog were two polls of one measurement and disagreed for up to a minute at a time; they are one feed now, and the countdown rounds up to the minute in the one place both read. A working directory typed as ~/repos/ai-app was four literal characters on the local transport and as an argument on both, so the existence check refused every home-relative path. It is checked by entering the directory now, expanded for a local spawn the way the remote shell expands it, and stored short so the phone draws what somebody would write. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
68 lines
3.1 KiB
Kotlin
68 lines
3.1 KiB
Kotlin
package com.example.aiapp
|
|
|
|
import java.time.Duration
|
|
import java.time.OffsetDateTime
|
|
|
|
// How long is left in a usage window. Shared by the session bar and the usage screen: the
|
|
// arithmetic is the same in both and only the sentence around it differs, so everything here
|
|
// returns the span or the state on its own and leaves the wording to the caller.
|
|
|
|
/**
|
|
* "1d 4h", "3h 12m", "12m" -- the span alone, with no leading or trailing words.
|
|
*
|
|
* Rounded **up** to the whole minute, rather than truncated as it was. A window with 3h 12m 50s
|
|
* left is nearer four minutes past the twelve than it is to twelve, and truncating also parks the
|
|
* figure on a minute it has already spent -- so the reader watching the number decide whether to
|
|
* start something was consistently told less headroom than they had. One rule, so the session bar
|
|
* and the usage dialog cannot round a shared measurement two different ways.
|
|
*/
|
|
fun formatSpan(until: Duration): String {
|
|
val up = if (until.seconds % 60 == 0L && until.nano == 0) until else until.plusMinutes(1)
|
|
return when {
|
|
up.toHours() >= 24 -> "${up.toDays()}d ${up.toHours() % 24}h"
|
|
up.toHours() > 0 -> "${up.toHours()}h ${up.toMinutes() % 60}m"
|
|
else -> "${up.toMinutes()}m"
|
|
}
|
|
}
|
|
|
|
/**
|
|
* What is known about when a usage window ends.
|
|
*
|
|
* Three answers rather than a nullable duration, because two of them shared `null` and they are not
|
|
* the same thing at all. A window the server sent no reset time for is one that is **not running**:
|
|
* the five-hour window is anchored to the block it started in, so between sessions there is nothing
|
|
* counting down and the API says so by omitting the field -- measured against a live response on
|
|
* 2026-08-31, where the five-hour window's reset was exactly five hours after the moment work
|
|
* resumed. A timestamp that did arrive and could not be read is the genuinely unknown case, and it
|
|
* is the only one worth those words.
|
|
*
|
|
* Collapsing them put "reset time unknown" on the session bar for a machine behaving perfectly, on
|
|
* the one row somebody reads before starting something big -- and the usage dialog, looking at the
|
|
* same field, quietly drew nothing. Two rules for one missing value; this is the rule.
|
|
*/
|
|
sealed class WindowEnd {
|
|
/** No reset time was sent, so nothing is running in this window. Not a failure to find out. */
|
|
data object NotRunning : WindowEnd()
|
|
|
|
/** A timestamp arrived and could not be read. The one case that is actually unknown. */
|
|
data object Unreadable : WindowEnd()
|
|
|
|
/** How long is left. Negative once the window is past, which each caller words for itself. */
|
|
data class Ends(val until: Duration) : WindowEnd()
|
|
}
|
|
|
|
/**
|
|
* [resetsAt] as the server sent it -- absent, unreadable, or a moment -- against [now].
|
|
*
|
|
* [now] is a parameter rather than read here so a caller can drive it from state and have the
|
|
* countdown recompute on its own schedule.
|
|
*/
|
|
fun windowEnd(resetsAt: String?, now: OffsetDateTime): WindowEnd {
|
|
if (resetsAt == null) return WindowEnd.NotRunning
|
|
return try {
|
|
WindowEnd.Ends(Duration.between(now, OffsetDateTime.parse(resetsAt)))
|
|
} catch (_: Exception) {
|
|
WindowEnd.Unreadable
|
|
}
|
|
}
|