tumwater 0.4.0 → 0.4.2

package/dist/src/ui/tui/tui-editor-interval.js

@@ -1,99 +1,36 @@
 import { setConfigKey, unsetConfigKey } from "../../config/config-write.js";
 import { checkMinRunInterval } from "../../config/config-keys.js";
-import { baseRoleOf } from "../../roles/runner-ids.js";
 import { rawRoleField } from "../../roles/role-view.js";
 import { gotSuffix } from "../../text/text.js";
+import { createRoleKeyEditor } from "./tui-editor-role-key.js";
 /** The Ctrl+S min-run-interval editor on the shared prompt line, the terminal twin of
  * `tumwater role <id> --min-run-interval` and the dashboard role drawer's `Min run interval`
- * row. It owns its mode flag, its saved-draft pair, and the role pinned when it opened, so a
- * roster shift cannot redirect the write. Enter writes through the shared
- * setConfigKey/unsetConfigKey family the CLI and the drawer use — so checkMinRunInterval
- * (naming `roles.<base>.minRunIntervalSeconds`) and validateConfig own the value's truth — a
- * non-plain-decimal spelling (hex/exponent, negative, or non-numeric) flashes the editor's own
- * shape message first, mirroring the budget editor's plain-decimal rule, and stays open — and
- * Esc, Ctrl+S again, and Ctrl+T cancel by restoring the prompt draft. Unlike the quiet editor
- * there is no director refusal: `tumwater role director --min-run-interval` is accepted, so the
- * director edits too. Mutually exclusive with the other editors on the one prompt line via the
- * session's held registry. */
+ * row, from the same createRoleKeyEditor factory the role-model and instance-count editors
+ * share. It owns its held-marker slot and the role pinned when it opened, so a roster shift
+ * cannot redirect the write. Enter writes through the shared setConfigKey/unsetConfigKey family
+ * the CLI and the drawer use — so checkMinRunInterval (naming `roles.<base>.minRunIntervalSeconds`)
+ * and validateConfig own the value's truth — a non-plain-decimal spelling (hex/exponent,
+ * negative, or non-numeric) flashes the editor's own shape message first, mirroring the budget
+ * editor's plain-decimal rule, and stays open — and Esc, Ctrl+S again, and Ctrl+T cancel by
+ * restoring the prompt draft. Unlike the quiet editor there is no director refusal:
+ * `tumwater role director --min-run-interval` is accepted, so the director edits too. Mutually
+ * exclusive with the other editors on the one prompt line via the session's held registry. */
 export function createIntervalEditor(session) {
-    let intervalMode = false;
-    let restoreDraft = () => { };
-    // The role pinned when the editor opened, so Enter writes the same role's override even if
-    // syncRoster shrinks or reorders the roster while the editor is open.
-    let lockedRole = null;
-    // Leave min-run-interval mode (Esc, Ctrl+S again, or Ctrl+T): restore the saved prompt text.
-    const exitIntervalMode = () => {
-        if (!intervalMode)
-            return;
-        intervalMode = false;
-        session.held.interval = false;
-        restoreDraft();
-        lockedRole = null;
-    };
-    const handleKey = (_str, key, ctx) => {
-        if (key.ctrl && key.name === "s") {
-            // Ctrl+S edits the viewed role's own min-run-interval override on its Transcript view.
-            // Every non-transcript view keeps Ctrl+S — the guard below lets the key fall through to
-            // the pane arms (History's trailing-window cycle) unless the interval editor already
-            // holds the line, in which case Ctrl+S is the toggle-out arm. Entering pre-fills the
-            // override from the FILE's raw `roles.<base>.minRunIntervalSeconds` (empty when unset —
-            // empty means "clear it, fall back to the team-wide interval" on save) and saves the
-            // prompt text; leaving restores it. There is no director exemption: the director runs
-            // on the same clock, so `--min-run-interval` is accepted for it too.
-            if (!intervalMode && !(ctx.view >= 1 && ctx.view <= ctx.roleIds.length))
-                return false;
-            const role = ctx.roleIds[ctx.view - 1];
-            if (session.editorEntryDenied("interval"))
-                return true;
-            if (intervalMode) {
-                exitIntervalMode();
-                return true;
-            }
-            // Pin the role first so the write below is safe against a mid-edit roster shift, then
-            // pre-fill from the file's own entry — one fresh read per open is the smallest honest
-            // source; a broken config degrades to no pre-fill and the write reports the error. The
-            // FILE (rawRoleField) is the source of truth, not the merged config: overlayDefaults
-            // seeds every built-in role's minRunIntervalSeconds from the catalog, so the merged
-            // value cannot tell an operator override from a seeded default, and clearing a role that
-            // only has the seed would otherwise be a no-op the operator could not see.
-            lockedRole = role;
-            const base = baseRoleOf(role);
-            const existing = rawRoleField(session.root, base, "minRunIntervalSeconds");
-            restoreDraft = session.takeDraft();
-            intervalMode = true;
-            session.held.interval = true;
-            session.input = typeof existing === "number" ? String(existing) : "";
-            session.cursor = session.input.length;
-            session.flashMessage(`edit ${role}'s min run interval in seconds (0 allows back-to-back runs, empty clears): Enter to save, Esc to cancel`);
-            return true;
-        }
-        if (key.name === "escape" && intervalMode) {
-            // Esc cancels min-run-interval mode, restoring the previous prompt text.
-            exitIntervalMode();
-            return true;
-        }
-        if (key.name === "return" && intervalMode) {
-            // Enter commits the override through the shared setter family the CLI's
-            // `--min-run-interval` and the dashboard drawer use: an empty or whitespace-only line
-            // clears the key (`unsetConfigKey`), otherwise checkMinRunInterval (naming the dotted
-            // key) screens the value and `setConfigKey` writes `roles.<base>.minRunIntervalSeconds`
-            // as a JSON number. An invalid or rejected value flashes and STAYS in edit mode so the
-            // operator can fix it; success restores the saved prompt text.
-            const role = lockedRole;
-            const cfgKey = `roles.${baseRoleOf(role)}.minRunIntervalSeconds`;
-            const text = session.input.trim();
+    return createRoleKeyEditor(session, {
+        mode: "interval",
+        openCtrl: "s",
+        prefill: (s, base) => {
+            const existing = rawRoleField(s.root, base, "minRunIntervalSeconds");
+            return typeof existing === "number" ? String(existing) : "";
+        },
+        openFlash: (role) => `edit ${role}'s min run interval in seconds (0 allows back-to-back runs, empty clears): Enter to save, Esc to cancel`,
+        commit: (s, base, text) => {
+            const cfgKey = `roles.${base}.minRunIntervalSeconds`;
+            // An empty or whitespace-only line clears the override (a no-op success when the file
+            // never set it, so the operator sees "is not set").
             if (text === "") {
-                const result = unsetConfigKey(session.root, cfgKey);
-                if (result.ok) {
-                    exitIntervalMode();
-                    session.flashMessage(result.oldValue === undefined
-                        ? `${role}: min run interval is not set in tumwater.json, so nothing was cleared`
-                        : `${role}: min run interval cleared`);
-                }
-                else {
-                    session.flashMessage(result.error); // broken config or write failure — stay in edit mode
-                }
-                return true;
+                const r = unsetConfigKey(s.root, cfgKey);
+                return r.ok && r.oldValue === undefined ? { ok: true, noop: true } : r;
             }
             // Plain decimal seconds only — bare Number() would also read hex ("0x10" → 16) and
             // exponent ("1e2" → 100) as an interval, neither of which an operator means when
@@ -105,31 +42,21 @@ export function createIntervalEditor(session) {
             // editor was about to write — and STAY in edit mode (negative and non-numeric text hit
             // this shape arm too, so the operator sees one consistent message).
             if (!/^\d*\.?\d+$/.test(text)) {
-                session.flashMessage(`${cfgKey} must be a plain second count like 300, 0.5, or .5 — no +/-, exponent, or hex notation${gotSuffix(text)}`);
-                return true;
+                return {
+                    ok: false,
+                    error: `${cfgKey} must be a plain second count like 300, 0.5, or .5 — no +/-, exponent, or hex notation${gotSuffix(text)}`,
+                };
             }
             const value = Number(text);
             const invalid = checkMinRunInterval(value, cfgKey);
-            if (invalid) {
-                session.flashMessage(invalid); // name the rejected value and stay open
-                return true;
-            }
-            const result = setConfigKey(session.root, cfgKey, JSON.stringify(value));
-            if (result.ok) {
-                exitIntervalMode();
-                session.flashMessage(result.unchanged
-                    ? `${role}: min run interval is already ${text}s, so tumwater.json was not written`
-                    : `${role}: min run interval set to ${text}s`);
-            }
-            else {
-                session.flashMessage(result.error); // broken config or write failure — stay in edit mode
-            }
-            return true;
-        }
-        return false;
-    };
-    return {
-        handleKey,
-        exit: exitIntervalMode,
-    };
+            if (invalid)
+                return { ok: false, error: invalid };
+            const result = setConfigKey(s.root, cfgKey, JSON.stringify(value));
+            return result.ok && result.unchanged ? { ok: true, noop: true } : result;
+        },
+        savedFlash: (role, text) => text === "" ? `${role}: min run interval cleared` : `${role}: min run interval set to ${text}s`,
+        noopFlash: (role, text) => text === ""
+            ? `${role}: min run interval is not set in tumwater.json, so nothing was cleared`
+            : `${role}: min run interval is already ${text}s, so tumwater.json was not written`,
+    });
 }

package/dist/src/ui/tui/tui-editor-notes.js

@@ -1,94 +1,38 @@
 import { saveRoleNote } from "../../agent/role-notes-write.js";
 import { roleNotesPath } from "../../paths.js";
-import { readEditorPath } from "./tui-editor-session.js";
+import { createRoleFileEditor } from "./tui-editor-role-file.js";
 /** The notes view's Ctrl+E replace-notes-from-a-file editor on the shared prompt line, the
  * terminal twin of `tumwater role <id> --notes-file <path>` and the dashboard drawer's
- * textarea. It owns its `notesEditFor` flag, its saved-draft pair, and the handleKey arms for
- * its key (the toggle with the `heldEditorFlash(entering)` guard clause — the shared guard
- * priority lives in the session module — plus Esc, Ctrl+E again, and Enter). Guarded to the
- * notes view (`ctx.noteMode`), so the Report window's Ctrl+E arm keeps the key on its own
- * views. The prompt line is single-line and a note may be multiline up to ROLE_NOTES_MAX_BYTES,
- * so the editor takes a file path and reads it verbatim — exactly the CLI's own
- * non-interactive replacement, the way the Activity view's Ctrl+V attach editor also takes a
- * path. The write goes through saveRoleNote (the same write the CLI and the dashboard drawer
- * make), so the 4 KB cap and its wording cannot drift; the fresh read is repainted through the
- * session's refreshNotes seam. */
+ * textarea. Guarded to the notes view (`ctx.noteMode`), so the Report window's Ctrl+E arm keeps
+ * the key on its own views. The prompt line is single-line and a note may be multiline up to
+ * ROLE_NOTES_MAX_BYTES, so the editor takes a file path and reads it verbatim — exactly the
+ * CLI's own non-interactive replacement, the way the Activity view's Ctrl+V attach editor also
+ * takes a path. The write goes through saveRoleNote (the same write the CLI and the dashboard
+ * drawer make), so the 4 KB cap and its wording cannot drift; the fresh read is repainted
+ * through the session's refreshNotes seam. The open/exit/read framing lives in the shared
+ * createRoleFileEditor helper that also serves the instructions editor. */
 export function createNotesEditor(session) {
-    let notesEditFor = null;
-    let restoreDraft = () => { };
-    // Leave the notes editor (Esc, Ctrl+E again, or Ctrl+T): restore the saved prompt text with
-    // no note written.
-    const exitNotesMode = () => {
-        if (notesEditFor === null)
-            return;
-        notesEditFor = null;
-        session.held.notes = null;
-        restoreDraft();
-    };
-    const handleKey = (_str, key, ctx) => {
-        if (key.ctrl && key.name === "e" && ctx.noteMode &&
-            // The pane's noteMode closure goes stale when syncRoster shrinks the roster past the
-            // viewed role (it never resets the pane's flags), so the same in-range guard every
-            // transcript editor arm carries must hold here too before its view indexes roleIds.
-            ctx.roleIds.length > 0 && ctx.view >= 1 && ctx.view <= ctx.roleIds.length) {
-            // Ctrl+E toggles the replace-notes editor on the notes view's prompt line (mnemonic:
-            // **e**dit notes — the same key the Report window's window-cycle arm and the Queued
-            // pane's row-edit arm use on their own views, guarded away here by ctx.noteMode). The
-            // line edits one file path that becomes the role's whole note through the same
-            // saveRoleNote write the CLI and the dashboard drawer use. Entering saves the prompt
-            // draft and blanks the line; leaving restores it.
-            if (session.editorEntryDenied("notes"))
-                return true;
-            if (notesEditFor !== null) {
-                exitNotesMode();
-            }
-            else {
-                // Mid-recall, hand the arrows' saved draft back before the notes editor takes the
-                // line — the same settle the role editors do — so leaving restores the
-                // draft, not a history entry, with no stale recall state riding along.
-                const role = ctx.roleIds[ctx.view - 1]; // defined: the open-arm range guard above pins the view into roleIds
-                restoreDraft = session.takeDraft();
-                notesEditFor = role;
-                session.held.notes = role;
-                session.input = "";
-                session.cursor = 0;
-                session.flashMessage(`replace ${role}'s notes from a file — Enter to save, Esc to cancel`);
-            }
-            return true;
-        }
-        if (key.name === "escape" && notesEditFor !== null) {
-            // Esc cancels the notes editor, restoring the previous prompt text and writing nothing.
-            exitNotesMode();
-            session.flashMessage("notes edit cancelled");
-            return true;
-        }
-        if (key.name === "return" && notesEditFor !== null) {
-            // Enter reads the typed path whole and saves it through saveRoleNote — the shared write
-            // the CLI's `--notes-file` and the dashboard drawer make, so the 4 KB cap and its wording
-            // cannot drift. An empty path, a missing file, an unreadable file, and an over-cap note
-            // all flash and STAY in the editor so the operator can fix the path; an empty file
-            // clears the note. On success the notes view repaints the new note without leaving and
-            // re-entering, and the editor exits with the shared success wording.
-            const role = notesEditFor;
-            // The trim/read/refuse prologue is shared with the brief, instructions and backlog-entry
-            // editors (readEditorPath), which read one typed path the same way.
-            const text = readEditorPath(session);
-            if (text === null)
-                return true;
+    return createRoleFileEditor(session, {
+        held: "notes",
+        openCtrl: "e",
+        mayOpen: (ctx) => 
+        // The pane's noteMode closure goes stale when syncRoster shrinks the roster past the
+        // viewed role (it never resets the pane's flags), so the same in-range guard every
+        // transcript editor arm carries must hold here too before its view indexes roleIds.
+        ctx.noteMode && ctx.roleIds.length > 0 && ctx.view >= 1 && ctx.view <= ctx.roleIds.length,
+        openFlash: (role) => `replace ${role}'s notes from a file — Enter to save, Esc to cancel`,
+        cancelFlash: "notes edit cancelled",
+        commit: (s, role, text) => {
             try {
-                const message = saveRoleNote(roleNotesPath(session.root, role), text);
-                session.refreshNotes(role);
-                exitNotesMode();
-                session.flashMessage(message);
+                return { ok: true, message: saveRoleNote(roleNotesPath(s.root, role), text) };
             }
             catch (err) {
-                // The write or the 4 KB cap refused the note: flash the reason and stay in the editor
-                // so the operator can fix the path.
-                session.flashError(err);
+                // The write or the 4 KB cap refused the note: return the reason so the caller flashes
+                // it and stays in the editor for the operator to fix the path.
+                return { ok: false, reason: err };
             }
-            return true;
-        }
-        return false;
-    };
-    return { handleKey, exit: exitNotesMode };
+        },
+        flashFailure: (s, reason) => s.flashError(reason),
+        refresh: (s, role) => s.refreshNotes(role),
+    });
 }