// view.js - the parts of the composer that need no GPUI and no app. // // Pure: no gpui-kit, no herdr, no IO, no clock. The view (main.js) asks its // questions here, so that Node can check the answers (tests/main.test.mjs) // without a running Herdr. // // The composer talks to one agent at a time - the focused one. Everything that // belongs to an agent (the draft, the queue, the attachments) is keyed by the // agent's address, so two Claude Code agents never share a draft. import { drain, gateAfter } from "./delivery.js"; import { LIMITS } from "./attachments.js"; /** * The agent the composer talks to. * * The focused terminal's agent first - that is the pane the person is * looking at. An agent block that is shown (a layout that draws one agent) * counts when no terminal has the focus. Without either there is nobody to * write to, and the composer stays inactive. * * @param {object[]} agents - the live agents of the app * @param {object|null} focused - the live focus of the window * @returns {object|null} the agent, or null */ export function targetAgent(agents, focused) { const list = Array.isArray(agents) ? agents : []; if (!focused || typeof focused !== "object") return null; const byTerminal = list.find((agent) => agent && agent.address === focused.terminal); if (byTerminal) return byTerminal; const byAgent = list.find((agent) => agent && agent.address === focused.agent); return byAgent ?? null; } /** * The key a draft, a queue and a set of attachments belong to. * * The address of the agent, not the name of its program: two Claude Code * agents are two agents, and their drafts and queues must not mix. * * @param {object} agent * @returns {string} */ export function agentKey(agent) { if (!agent || typeof agent !== "object") return ""; const address = typeof agent.address === "string" ? agent.address.trim() : ""; if (address) return address; return agentName(agent); } /** * The name of the agent's program ("claude-code") - what the catalog of the * built-in commands knows. * * @param {object} agent * @returns {string} */ export function agentName(agent) { if (!agent || typeof agent !== "object") return "default"; const app = typeof agent.app === "string" ? agent.app.trim() : ""; if (app) return app; const key = typeof agent.program?.key === "string" ? agent.program.key.trim() : ""; return key || "default"; } /** * The status of an agent: "idle" when there is none to be had. * * @param {object} agent * @returns {string} */ export function agentStatus(agent) { const status = agent && typeof agent.status === "string" ? agent.status.trim() : ""; return status || "idle"; } /** * The turn gate of one agent. * * @returns {{sawWorking:boolean, open:boolean}} */ export function createGate() { return { sawWorking: false, open: false }; } /** * May the next message go out? * * The gate opens after a whole turn was seen - the agent was working and came * back to idle. A send outside a turn (the "Wyślij teraz" button) opens it * outright, because it does not wait for a turn at all. * * @param {{sawWorking?:boolean, open?:boolean}} gate * @param {string} status * @returns {boolean} */ export function gatePasses(gate, status) { if (!gate || typeof gate !== "object") return false; if (gate.open === true) return true; return gateAfter(status, gate.sawWorking === true); } /** * The gate of an agent with the turn step aside. * * @param {{sawWorking?:boolean, open?:boolean}} gate * @returns {{sawWorking:boolean, open:boolean}} */ export function openGate(gate) { return { ...(gate ?? createGate()), open: true }; } /** * The gate closes again: the next message waits for the next turn. * * @param {{sawWorking?:boolean, open?:boolean}} gate * @returns {{sawWorking:boolean, open:boolean}} */ export function closeGate(gate) { return { ...(gate ?? createGate()), sawWorking: false, open: false }; } /** * Is this the Enter that sends the message? * * Shift+Enter is a new line. The secondary Enter - the one an IME sends when * it confirms a composition - does not send either (Ovis: "IME Enter ignored"). * * @param {{shift?:boolean, secondary?:boolean}} event * @returns {boolean} */ export function isPlainEnter(event) { if (!event) return false; if (event.shift === true) return false; if (event.secondary === true) return false; return true; } /** * The caret one line up or down. * * The field of this app version (gpui-base in herdr-app 0.1.16) does not move * the cursor up and down by itself, so the composer does it: the caret goes to * the same column of the line above (or below) and never leaves the text. * * @param {string} text * @param {number} caret * @param {number} step - negative for up, positive for down * @returns {number} the new caret */ export function moveCaret(text, caret, step) { const source = typeof text === "string" ? text : ""; const at = Number.isInteger(caret) ? caret : 0; const here = Math.max(0, Math.min(at, source.length)); const lineStart = source.lastIndexOf("\n", here - 1) + 1; const column = here - lineStart; if (step < 0) { if (lineStart === 0) return here; // there is no line above const aboveEnd = lineStart - 1; // the newline of the line above const aboveStart = source.lastIndexOf("\n", aboveEnd - 1) + 1; return aboveStart + Math.min(column, aboveEnd - aboveStart); } const lineEnd = source.indexOf("\n", here); if (lineEnd < 0) return here; // there is no line below const belowStart = lineEnd + 1; const nextBreak = source.indexOf("\n", belowStart); const belowEnd = nextBreak < 0 ? source.length : nextBreak; return belowStart + Math.min(column, belowEnd - belowStart); } /** * What a key of the menu does. * * "none" — the composer does not touch the key: another field of the app has * the keyboard, or there is no menu to move. * "menu" — the arrows move the menu. * "accept" — Tab takes the picked row. * * @param {boolean} hasKeyboard - does the composer's own field have the keyboard? * @param {object|null} menu * @param {string} key - "up", "down" or "tab" * @returns {"none"|"menu"|"accept"} */ export function menuAction(hasKeyboard, menu, key) { if (!hasKeyboard) return "none"; if (!menu || !(menu.items ?? []).length) return "none"; if (key === "up" || key === "down") return "menu"; if (key === "tab") return "accept"; return "none"; } /** * The JSON of a `--json` payload, or null when it is not JSON at all. * * @param {string} text * @returns {object|null} */ export function parseJson(text) { if (typeof text !== "string" || text.trim() === "") return null; try { const value = JSON.parse(text); return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null; } catch { return null; } } /** * May the composer count on this result of `hc`? * * `hc` exits 0 even when it fails, so the payload decides - and a payload * that is not JSON at all is an unknown result, not a success (the same rule * the delivery layer follows). * * @param {{code?:number, stdout?:string}|null} result * @returns {boolean} */ export function hcOk(result) { if (!result || result.code !== 0) return false; const payload = parseJson(result.stdout); return payload !== null && !payload.error; } /** * What a send whose hook failed means. * * The hook of the delivery reports the states of the queue; a failure in it * after the message went on the wire must not send the message again. The * entry left the queue, so it is sent; an entry that is still there is * uncertain. * * @param {object[]} queue - the queue of the agent * @param {string} id * @returns {"sent"|"uncertain"} */ export function failedHookOutcome(queue, id) { const still = (Array.isArray(queue) ? queue : []).some((item) => item.id === id); return still ? "uncertain" : "sent"; } /** * The queue goes out - one message after another, while the gate is open. * * `drain` sends one entry and leaves the gate as it was; the loop asks for the * next one until the queue is empty or the gate closes. The caller keeps the * "one drain in flight" flag for the whole loop: two drains on the same state * would send the same message twice. * * @param {object} ctx - the ctx of `delivery.drain` * @param {object} state * @returns {Promise<{state:object, sent:number}>} */ export async function drainAll(ctx, state) { let current = state; let sent = 0; for (;;) { const result = await drain(ctx, current); current = result.state; if (!result.sent) break; sent += 1; } return { state: current, sent }; } /** * What the composer says about an agent's status. * * @param {string} status * @returns {string} */ export function statusText(status) { switch (status) { case "working": return "pracuje"; case "blocked": return "czeka na Ciebie"; case "done": return "skończył"; default: return "gotowy"; } } /** * The label of a queue row. * * @param {{state?:string}} item * @returns {string} */ export function queueLabel(item) { switch (item?.state) { case "queued": return "Następna tura"; case "held": return "Wstrzymana — wyślij ręcznie"; case "sending": return "Wysyłanie…"; case "uncertain": return "Nie potwierdzono"; case "countdown": return `Wysyłam za ${item.left} s`; default: return ""; } } /** * The text and the caret after a suggestion is accepted. * * The token at the caret is replaced by what the item inserts; the caret lands * behind it, so the next word continues where the person was typing. * * @param {string} text * @param {number} caret * @param {{start?:number}} token - the trigger of the suggestion * @param {string} insert * @returns {{value:string, caret:number}} */ export function applySuggestion(text, caret, token, insert) { const source = typeof text === "string" ? text : ""; const at = Number.isInteger(caret) ? caret : 0; const start = Number.isInteger(token?.start) ? token.start : at; const value = source.slice(0, start) + String(insert ?? "") + source.slice(at); return { value, caret: start + String(insert ?? "").length }; } /** * The newline that Enter put into the field. * * The composer sends on Enter, and the field puts a newline in before the * submit arrives. The message is the text as it was before that newline - and * the caret is where the newline went in. * * @param {string} previous - the text before the change * @param {string} next - the text after the change * @returns {{index:number}|null} where the newline went in, or null */ export function insertedNewline(previous, next) { if (typeof previous !== "string" || typeof next !== "string") return null; if (next.length !== previous.length + 1) return null; for (let index = 0; index < next.length; index += 1) { if (next[index] !== "\n") continue; if (next.slice(0, index) + next.slice(index + 1) === previous) return { index }; } return null; } /** * The mentions of the files, at the start of the message. * * A leading command keeps the first place - the mentions follow it. * * @param {string} text * @param {string[]} tokens - the mentions ("@src/a.rs") * @returns {{value:string, caret:number}} */ export function insertMentions(text, tokens) { const source = typeof text === "string" ? text : ""; const list = (Array.isArray(tokens) ? tokens : []).filter(Boolean); if (list.length === 0) return { value: source, caret: source.length }; const command = /^\/[^\s]*\s*/.exec(source); const at = command ? command[0].length : 0; const mentions = list.map((token) => `${token} `).join(""); return { value: source.slice(0, at) + mentions + source.slice(at), caret: at + mentions.length, }; } /** * The items of the catalog, grouped by their group. * * @param {object[]} items * @returns {Record} */ export function groupItems(items) { const groups = {}; for (const item of Array.isArray(items) ? items : []) { if (!item) continue; const name = typeof item.group === "string" && item.group !== "" ? item.group : ""; if (!groups[name]) groups[name] = []; groups[name].push(item); } return groups; } /** * The folder and the branch of the pane the composer talks to. * * @param {object[]} panes * @param {string} terminal * @returns {{cwd:string|null, branch:string|null}} */ export function paneContext(panes, terminal) { const list = Array.isArray(panes) ? panes : []; const pane = list.find((entry) => entry && entry.terminal === terminal); return { cwd: pane?.cwd ?? null, branch: pane?.branch ?? null }; } /** * The last parts of a path - the folder the person knows by heart. * * @param {string} path * @returns {string} */ export function shortPath(path) { const parts = String(path ?? "") .split(/[\\/]/) .filter(Boolean); if (parts.length <= 2) return parts.join("/"); return parts.slice(-2).join("/"); } /** * A store that never writes back a list it failed to read. * * The reader of storage.js swallows a failing read and answers with an empty * list - writing that list back would wipe what is really there. The store * remembers which keys failed and refuses to write them. * * @param {{get:(key:string)=>unknown, set:(key:string, value:unknown)=>unknown}} raw * @returns {{get:(key:string)=>unknown, set:(key:string, value:unknown)=>void, failed:(key:string)=>boolean}} */ export function guardedStore(raw) { const failed = new Set(); return { get(key) { try { const value = raw.get(key); return value ?? null; } catch { failed.add(key); return null; } }, set(key, value) { if (failed.has(key)) return; raw.set(key, value); }, failed(key) { return failed.has(key); }, }; } /** * How many characters the text has over the limit (0 when it fits). * * @param {string} text * @returns {number} */ export function overLimit(text) { const length = typeof text === "string" ? text.length : 0; return Math.max(0, length - LIMITS.messageChars); } /** * May the composer send on its own for this agent? Only after its draft and * the identity of its terminal were checked (see main.js `restoreDraft`): the * queue comes back from the disk before that, and an address can belong to a * different terminal now. * * @param {Set|null} ready - the agents whose check is done * @param {string} key * @returns {boolean} */ export function canAutoSend(ready, key) { return ready instanceof Set && ready.has(key); } /** * Is the composer still talking to the agent whose draft the field shows? * * The field shows the draft of `before` (the agent the composer was synced to * when an event began). After a sync the focus may have moved: then the event * belongs to an agent that is not the target any more, and it must not touch * the draft or the queue of the new one. * * @param {{before:string, after:string, target:string}} keys - `before`: the * key the composer had before the sync; `after`: the key it has now; * `target`: the key of the agent under the focus ("" for none) * @returns {boolean} */ export function stillSameAgent({ before, after, target }) { return before !== "" && before === after && before === target; }