tumwater 0.1.2 → 0.2.0

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

@@ -0,0 +1,230 @@
+// vocabulary: plain
+import { bodyStructureProblem, fileEntryWithBody, OPERATOR_FILE_KINDS, splitEntryFile, tryEditEntry } from "../../backlog/backlog-write.js";
+import { stripEntryStamp } from "../../backlog/backlog-structure.js";
+import { readTextIfExists } from "../../files/files.js";
+import { submitRolePromptAndWake } from "../../operator/operator-intent.js";
+import { promptLengthProblem } from "../../inbox/inbox-submit.js";
+import { collapseWhitespace } from "../../text/text.js";
+/** The backlog pane's title editor (Ctrl+N new entry, Ctrl+E on a selected plan or bug) on the
+ * shared prompt line. It owns its target (`entryEditFor`), its plan↔bug flip, its saved-draft
+ * pair, its exit helper, and the fileEntryWithBody / tryEditEntry / commit arms, plus the
+ * position math that counts `plan`/`bug` labels. Mutually exclusive with the other editors via
+ * the session's held registry. */
+export function createEntryEditor(session) {
+    let entryEditFor = null;
+    let entryEditSavedInput = "";
+    let entryEditSavedCursor = 0;
+    // The triple state of the entry editor's prompt line: false (the title field), true (the
+    // file-path field whose contents replace the whole entry), and the draft the toggle parks
+    // when it hands the line to a different field.
+    let entryBodyFile = false;
+    let entryBodySavedInput = "";
+    let entryBodySavedCursor = 0;
+    // Leave the backlog pane's title editor (Esc, a saved edit, or Ctrl+T): the same settle
+    // contract as exitAnswerMode. Any open file mode is dropped too, so the editor always lands
+    // back in the title state on the next Ctrl+E.
+    const exitEntryEdit = () => {
+        if (!entryEditFor)
+            return;
+        entryEditFor = null;
+        entryBodyFile = false;
+        session.held.entry = null;
+        session.restorePromptFrom(entryEditSavedInput, entryEditSavedCursor);
+    };
+    const handleKey = (_str, key, ctx) => {
+        if (key.ctrl && key.name === "n") {
+            // On the Backlog view Ctrl+N files a new entry: it opens the title editor with a null
+            // position (new plan), and pressed again inside that editor flips plan <-> bug.
+            if (entryEditFor !== null && entryEditFor.position === null) {
+                const other = entryEditFor.kind === "plan" ? "bug" : "plan";
+                entryEditFor = { ...entryEditFor, kind: other };
+                session.held.entry = entryEditFor;
+                session.flashMessage(`new ${other} — Enter to file, Ctrl+N switches to ${other === "plan" ? "bug" : "plan"}, Esc cancels`);
+                return true;
+            }
+            // A Ctrl+N on any other state (not the Backlog view's new-entry slot, or an editor
+            // already holding the line) is the notebook/change/trail cycle, a pane arm the outer
+            // dispatch handles — this factory returns false so it runs.
+            if (ctx.view === ctx.roleIds.length + 1 &&
+                !session.held.budget && !session.held.rolePromptFor && !session.held.search &&
+                !session.held.pause && !session.held.queued &&
+                !session.held.answer && !entryEditFor && !session.held.retire) {
+                session.settleDraft((t) => (entryEditSavedInput = t), (n) => (entryEditSavedCursor = n));
+                entryEditFor = { kind: "plan", position: null, title: "" };
+                session.held.entry = entryEditFor;
+                session.input = "";
+                session.cursor = 0;
+                session.flashMessage("new plan — Enter to file, Ctrl+N switches to bug, Esc cancels");
+                return true;
+            }
+            return false;
+        }
+        if (key.ctrl && key.name === "e" && entryEditFor !== null && entryEditFor.position !== null) {
+            // A second Ctrl+E inside the entry editor toggles the same prompt line into the file
+            // field, whose path's contents replace the whole entry (splitEntryFile's rule) through
+            // tryEditEntry — the terminal twin of `tumwater plan|bug --edit <n> --file <path>`. A
+            // third Ctrl+E returns to the title draft, parked in the saved pair; Esc cancels all.
+            entryBodyFile = !entryBodyFile;
+            if (entryBodyFile) {
+                entryBodySavedInput = session.input;
+                entryBodySavedCursor = session.cursor;
+                session.input = "";
+                session.cursor = 0;
+                session.flashMessage(`replace ${entryEditFor.kind} #${entryEditFor.position} from a file — Enter to save, Ctrl+E back to the title, Esc cancels`);
+            }
+            else {
+                session.input = entryBodySavedInput;
+                session.cursor = entryBodySavedCursor;
+                session.flashMessage(`editing ${entryEditFor.kind} #${entryEditFor.position} title — Enter to save, Ctrl+E to replace from a file, Esc cancels`);
+            }
+            return true;
+        }
+        if (key.ctrl && key.name === "e" &&
+            !session.held.budget && !session.held.rolePromptFor && !session.held.search &&
+            !session.held.pause && !session.held.queued &&
+            !session.held.answer && !entryEditFor && !session.held.retire &&
+            ctx.view === ctx.roleIds.length + 1 && ctx.selectedEntry !== null) {
+            // Ctrl+E opens the title editor on the selected plan or bug (mnemonic: **E**dit); Enter
+            // saves through tryEditEntry, the non-exiting core the dashboard drawer shares, keeping
+            // the body and stamp. The prompt line is single-line, so only the title is editable here.
+            try {
+                const entries = session.flat();
+                const sel = Math.min(ctx.selectedEntry, entries.length - 1);
+                const picked = entries[sel];
+                if (picked === undefined) {
+                    // an emptied list has nothing to edit
+                }
+                else if (picked.label === "done" || picked.label === "fixed" || picked.label === "answered") {
+                    session.flashMessage("a done plan, fixed bug or answered question is read-only");
+                }
+                else if (picked.label === "question") {
+                    session.flashMessage("only a plan or open bug can be edited here");
+                }
+                else {
+                    const kind = picked.label === "plan" ? "plan" : "bug";
+                    const position = kind === "plan" ? sel + 1 : sel - entries.filter((e) => e.label === "plan").length + 1;
+                    session.settleDraft((t) => (entryEditSavedInput = t), (n) => (entryEditSavedCursor = n));
+                    entryEditFor = { kind, position, title: picked.title };
+                    session.held.entry = entryEditFor;
+                    session.input = stripEntryStamp(picked.title);
+                    session.cursor = session.input.length;
+                    session.flashMessage(`editing ${kind} #${position} — Enter to save, Esc to cancel`);
+                }
+            }
+            catch (err) {
+                session.flashError(err);
+            }
+            return true;
+        }
+        if (key.name === "escape" && entryEditFor) {
+            // Esc cancels the title editor, restoring the previous prompt text; nothing is written.
+            const filing = entryEditFor.position === null;
+            exitEntryEdit();
+            session.flashMessage(filing ? "new entry cancelled" : "edit cancelled");
+            return true;
+        }
+        if (key.name === "return" && entryEditFor) {
+            // Enter saves the new title through tryEditEntry with the body re-read now, so a
+            // concurrent body edit is not clobbered by a stale copy. The entry is matched by flat
+            // index and title; a mismatch is treated as moved without writing. A blank title and a
+            // throw flash and STAY in the editor so the text survives.
+            const target = entryEditFor;
+            // Shared tail of the title and file edit arms: re-read the entry by flat index and
+            // title, guard against a concurrent move (so a mismatch is treated as moved, not
+            // written), then settle the editor and commit through tryEditEntry. The only thing
+            // the two arms pass differently is the (title, body) pair taking the entry's place;
+            // an omitted body preserves the matched entry's own body (the title edit arm).
+            const applyEntryEdit = (newTitle, newBody) => {
+                try {
+                    // Both call sites (the file arm's and the title arm's Entry-save paths) run only
+                    // when `target.position` is non-null, so the position math never sees a null.
+                    const position = target.position;
+                    const entries = session.flat();
+                    const plans = entries.filter((e) => e.label === "plan").length;
+                    const entry = entries[target.kind === "plan" ? position - 1 : plans + position - 1];
+                    const outcome = entry?.label === target.kind && entry.title === target.title
+                        ? tryEditEntry(session.root, target.kind, position, target.title, newTitle, newBody ?? entry.body)
+                        : { status: "moved", title: "" };
+                    exitEntryEdit();
+                    if (outcome.status === "edited") {
+                        session.commitBacklogEdit(outcome.file, `Edit ${target.kind}: ${outcome.title}`);
+                        session.flashMessage(`edited ${target.kind} #${target.position}: ${outcome.title}`);
+                    }
+                    else {
+                        session.clearBacklogSelection();
+                        session.flashMessage(`that ${target.kind} was already removed or moved — nothing edited`);
+                    }
+                }
+                catch (err) {
+                    session.flashError(err);
+                }
+            };
+            if (entryBodyFile && target.position !== null) {
+                // File mode: the line holds a path whose contents replace title and body through the
+                // same title-checked tryEditEntry core the title edit uses, keeping the entry's
+                // position and its (planned …)/(found by …) stamp. A missing file, an empty path, a
+                // file with no title line, and a structurally unsound body all flash and stay here.
+                const p = session.input.trim();
+                if (!p) {
+                    session.flashMessage("a file path is required");
+                    return true;
+                }
+                let text;
+                try {
+                    text = readTextIfExists(p);
+                }
+                catch (err) {
+                    session.flashError(err);
+                    return true;
+                }
+                if (text === null) {
+                    session.flashMessage(`no such file: ${p}`);
+                    return true;
+                }
+                const { title: rawTitle, body } = splitEntryFile(text);
+                const newTitle = stripEntryStamp(rawTitle);
+                if (!newTitle) {
+                    session.flashMessage("the file needs a title line");
+                    return true;
+                }
+                const problem = bodyStructureProblem(body);
+                if (problem !== null) {
+                    session.flashMessage(problem);
+                    return true;
+                }
+                applyEntryEdit(newTitle, body);
+                return true;
+            }
+            if (!session.input.trim()) {
+                session.flashMessage("an entry needs a title");
+            }
+            else if (target.position === null) {
+                // New entry (Ctrl+N): file by title with an empty body and wake its loop, the same
+                // steps handleBacklogFile takes; a length problem or a throw stays in the editor.
+                try {
+                    const { role, wakeText } = OPERATOR_FILE_KINDS[target.kind];
+                    const problem = promptLengthProblem(wakeText(collapseWhitespace(session.input)), role);
+                    if (problem) {
+                        session.flashMessage(problem);
+                    }
+                    else {
+                        const filed = fileEntryWithBody(session.root, target.kind, session.input, "");
+                        session.commitBacklogEdit(filed.file, `File ${target.kind}: ${filed.title}`);
+                        submitRolePromptAndWake(session.root, role, wakeText(filed.title));
+                        exitEntryEdit();
+                        session.flashMessage(`filed ${target.kind}: ${filed.title} — woke ${role}`);
+                    }
+                }
+                catch (err) {
+                    session.flashError(err);
+                }
+            }
+            else {
+                applyEntryEdit(session.input);
+            }
+            return true;
+        }
+        return false;
+    };
+    return { handleKey, exit: exitEntryEdit };
+}

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

@@ -0,0 +1,122 @@
+// vocabulary: plain
+import { setConfigKey, unsetConfigKey } from "../../config/config-write.js";
+import { checkMinRunInterval } from "../../config/config-keys.js";
+import { baseRoleOf } from "../../roles/loop-ids.js";
+import { rawRoleField } from "../../roles/role-view.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 — 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 savedInput = "";
+    let savedCursor = 0;
+    // 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;
+        session.restorePromptFrom(savedInput, savedCursor);
+        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 ticks
+            // 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];
+            const held = session.heldEditorFlash("interval");
+            if (held) {
+                // Mutually exclusive with the other editors: all share one prompt line, so a mode may
+                // not enter while another holds it. Flash the way out first.
+                session.flashMessage(held);
+                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");
+            session.settleDraft((t) => (savedInput = t), (n) => (savedCursor = n));
+            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();
+            if (text === "") {
+                const result = unsetConfigKey(session.root, cfgKey);
+                if (result.ok) {
+                    exitIntervalMode();
+                    session.flashMessage(`${role}: min run interval cleared`);
+                }
+                else {
+                    session.flashMessage(result.error); // broken config or write failure — stay in edit mode
+                }
+                return true;
+            }
+            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(`${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,
+    };
+}

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

@@ -0,0 +1,114 @@
+// vocabulary: plain
+import { saveRoleNote } from "../../agent/role-notes-write.js";
+import { readTextIfExists } from "../../files/files.js";
+import { roleNotesPath } from "../../paths.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. */
+export function createNotesEditor(session) {
+    let notesEditFor = null;
+    let notesSavedInput = "";
+    let notesSavedCursor = 0;
+    // 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;
+        session.restorePromptFrom(notesSavedInput, notesSavedCursor);
+    };
+    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.
+            const held = session.heldEditorFlash("notes");
+            if (held) {
+                // Mutually exclusive with the other editors: all share one prompt line, so a mode may
+                // not enter while another holds it. Flash the way out instead of silently dropping
+                // the held mode's saved draft.
+                session.flashMessage(held);
+                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
+                session.settleDraft((t) => (notesSavedInput = t), (n) => (notesSavedCursor = n));
+                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;
+            const p = session.input.trim();
+            if (p === "") {
+                session.flashMessage("a file path is required");
+                return true;
+            }
+            let text;
+            try {
+                text = readTextIfExists(p);
+            }
+            catch (err) {
+                session.flashError(err);
+                return true;
+            }
+            if (text === null) {
+                session.flashMessage(`no such file: ${p}`);
+                return true;
+            }
+            try {
+                const message = saveRoleNote(roleNotesPath(session.root, role), text);
+                session.refreshNotes(role);
+                exitNotesMode();
+                session.flashMessage(message);
+            }
+            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);
+            }
+            return true;
+        }
+        return false;
+    };
+    return { handleKey, exit: exitNotesMode };
+}