tumwater 0.1.2 → 0.2.0

package/dist/src/ui/tui/tui-input.js

@@ -1,3 +1,4 @@
+// vocabulary: plain
 import { parseDurationMs } from "../../cli/cli-args.js";
 import { PAUSE_FOR_MAX_MS } from "../../operator/operator-intent.js";
 import { cutSplitsSurrogatePair, gotSuffix } from "../../text/text.js";
@@ -106,6 +107,14 @@ export function applyKey(text, cursor, str, key) {
     }
     return { text, cursor: c };
 }
+/** Five parsers below signal an invalid value through the same `{ ok: false, error }` arm
+ * of a `{ ok: true, … } | { ok: false, error: string }` result. `fail` is that arm's one
+ * constructor — the same-named error-arm helper quiet-hours.ts's parseQuietHours uses — so
+ * the error shape each parser returns cannot drift from the others (a prior copy pasted the
+ * same rejection line twice before the shape had a single home). */
+function fail(error) {
+    return { ok: false, error };
+}
 /** Parse a daily cost budget cap from the TUI's Ctrl+B edit line: empty → 0 (disabled —
  * empty means "no cap" on save), otherwise a plain decimal number ≥ 0 with fractional
  * dollars allowed ("25", "12.34", ".5") — hex and exponent notation are rejected, so the
@@ -132,37 +141,35 @@ export function parseBudgetInput(text) {
     // DOLLAR_CAP wording ("a number of 0 or more, at most …").
     if (!/^\d*\.?\d+$/.test(t) ||
         !Number.isFinite(n) || n < 0 || n > Number.MAX_SAFE_INTEGER)
-        return {
-            ok: false,
-            error: `budget must be a number of 0 or more, at most ${Number.MAX_SAFE_INTEGER}${gotSuffix(text)}`,
-        };
+        return fail(`budget must be a number of 0 or more, at most ${Number.MAX_SAFE_INTEGER}${gotSuffix(text)}`);
     return { ok: true, value: n };
 }
-/** Parse the TUI's Ctrl+L defer line: empty → null (clear the pending delay; deliver now),
- * otherwise a parseDurationMs duration at or under the 90d cap — the same grammar and cap
- * `tumwater prompt --at` and the dashboard composer's defer field admit, so the three
- * surfaces cannot disagree. Invalid spellings and over-cap values return an actionable error
- * so the flash can show it and the editor stays open for a fix. Pure, like parseBudgetInput;
- * the pending delay itself (a session-scoped duration applied at submit) lives in
- * tui-keys.ts. */
-export function parseDeferInput(text) {
-    const t = text.trim();
-    if (t === "")
-        return { ok: true, ms: null };
+/** The 90d cap refusal every duration editor shares — the same over-cap arm (`ms` past
+ * PAUSE_FOR_MAX_MS, the limit `pause --for`/`wake --in`/`stop --in` all admit), spelled once
+ * per verb so the wording cannot drift between the four parsers. Returns the error result
+ * when `ms` exceeds the cap, else null so the caller keeps its ok result. */
+function overDurationCap(ms, verb) {
+    return ms > PAUSE_FOR_MAX_MS ? fail(`${verb} is capped at 90d`) : null;
+}
+/** Parse a duration with parseDurationMs and apply the shared 90d cap in one step, mapping
+ * both a non-duration spelling (`bad`, caller-specific wording) and an over-cap value to an
+ * error result — the same parse-then-cap tail the role-pause, role-wake and stop-in parsers
+ * each repeated, so the three cannot drift on the cap arm. Callers that keep their own
+ * ok-tails (forMs/inMs/ms) flatten this result before returning it. */
+function parseDurationOrFail(t, verb, bad) {
     const ms = parseDurationMs(t);
     if (ms === null)
-        return { ok: false, error: `defer needs a duration like 45s, 90m, 1h30m, or 2d${gotSuffix(text)}` };
-    // The dashboard composer's server check caps the same duration at the same limit, so the
-    // TUI refuses it inline with the identical wording instead of queueing a marker past the cap.
-    if (ms > PAUSE_FOR_MAX_MS)
-        return { ok: false, error: "defer is capped at 90d" };
+        return fail(bad);
+    const over = overDurationCap(ms, verb);
+    if (over)
+        return over;
     return { ok: true, ms };
 }
 /** Parse the TUI's Ctrl+F pause line: "[duration] [reason]". Empty is a standing pause with no
  * reason; a leading parseDurationMs word is the duration (`forMs`, not an epoch, so this stays
  * pure) and the rest the reason; otherwise the whole text is the reason. Durations over the
  * 90d cap `pause --for` and /api/pause enforce are refused. The reason is left raw —
- * pauseFleet folds and caps it. */
+ * pauseTeam folds and caps it. */
 export function parsePauseInput(text) {
     const t = text.trim();
     if (t === "")
@@ -171,8 +178,9 @@ export function parsePauseInput(text) {
     const ms = parseDurationMs(m[1]);
     if (ms === null)
         return { ok: true, reason: t };
-    if (ms > PAUSE_FOR_MAX_MS)
-        return { ok: false, error: "pause is capped at 90d" };
+    const over = overDurationCap(ms, "pause");
+    if (over)
+        return over;
     const reason = (m[2] ?? "").trim();
     return reason ? { ok: true, forMs: ms, reason } : { ok: true, forMs: ms };
 }
@@ -183,16 +191,10 @@ export function parseRolePauseInput(text) {
     const t = text.trim();
     if (t === "")
         return { ok: true };
-    const ms = parseDurationMs(t);
-    if (ms === null) {
-        return {
-            ok: false,
-            error: "a loop pause takes only a duration like 45m or 2h (empty pauses until resumed) — reasons are fleet-wide, use Ctrl+F",
-        };
-    }
-    if (ms > PAUSE_FOR_MAX_MS)
-        return { ok: false, error: "pause is capped at 90d" };
-    return { ok: true, forMs: ms };
+    const r = parseDurationOrFail(t, "pause", "a role pause takes only a duration like 45m or 2h (empty pauses until resumed) — reasons are team-wide, use Ctrl+F");
+    if (!r.ok)
+        return r;
+    return { ok: true, forMs: r.ms };
 }
 /** Parse the TUI's Ctrl+W per-loop wake line: empty wakes the loop now, a duration schedules
  * the wake, `cancel` drops its pending scheduled wakes. Anything else is refused rather than
@@ -203,16 +205,19 @@ export function parseRoleWakeInput(text) {
         return { ok: true };
     if (t.toLowerCase() === "cancel")
         return { ok: true, cancel: true };
-    const ms = parseDurationMs(t);
-    if (ms === null) {
-        return {
-            ok: false,
-            error: 'a loop wake takes a duration like 45m or 2h, "cancel" to drop its scheduled wakes, or empty to wake now',
-        };
-    }
-    if (ms > PAUSE_FOR_MAX_MS)
-        return { ok: false, error: "wake is capped at 90d" };
-    return { ok: true, inMs: ms };
+    const r = parseDurationOrFail(t, "wake", 'a role wake takes a duration like 45m or 2h, "cancel" to drop its scheduled wakes, or empty to wake now');
+    if (!r.ok)
+        return r;
+    return { ok: true, inMs: r.ms };
+}
+/** Parse the TUI's Ctrl+Q scheduled-stop line: a duration, same 90d cap `tumwater stop --in`
+ * enforces. Empty is refused on purpose — an immediate stop has its own command, and this key
+ * must never mean "stop now". */
+export function parseStopInInput(text) {
+    const r = parseDurationOrFail(text.trim(), "stop", "a scheduled stop takes a duration like 45m or 2h — Esc to cancel");
+    if (!r.ok)
+        return r;
+    return { ok: true, inMs: r.ms };
 }
 /** Parse the TUI's Ctrl+R role-prompt line: the trimmed text when non-empty, otherwise an
  * error so the flash can show it and the editor stays open for a fix — whitespace-only input
@@ -223,7 +228,7 @@ export function parseRoleWakeInput(text) {
 export function parseRolePromptInput(text) {
     const t = text.trim();
     if (!t)
-        return { ok: false, error: "prompt text is empty — type something, or Esc to cancel" };
+        return fail("prompt text is empty — type something, or Esc to cancel");
     return { ok: true, value: t };
 }
 /** The visible slice of the prompt line for a terminal `width` columns: the whole text

package/dist/src/ui/tui/tui-keymap.js

@@ -1,3 +1,4 @@
+// vocabulary: plain
 /** The ink→readline key-mapping layer of the TUI (extracted from tui-keys.ts): ink's
  * `useInput` delivers parsed (input, key) pairs, while the keypress dispatch in
  * tui-keys.ts's createTuiKeys consumes the readline (str, key) shape — this module mints