519 lines
16 KiB
JavaScript
519 lines
16 KiB
JavaScript
// 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, queueBlocksDirectSend } 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<string, object[]>}
|
|
*/
|
|
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<string>|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;
|
|
}
|
|
|
|
/**
|
|
* Must a message that could go out now wait behind what is already in flight
|
|
* or in the queue?
|
|
*
|
|
* - a message on the wire always goes first (`draining`);
|
|
* - Ctrl+Enter (`mode "now"`) is the person's own order and does not wait;
|
|
* - an answer to an agent that is `blocked` does not wait either: the queue
|
|
* does not start while the agent waits for the person, so queueing the
|
|
* answer would leave the agent waiting for ever - it goes ahead (with
|
|
* `--force`) and the queue stays as it is;
|
|
* - otherwise it waits when a message is queued or counting down.
|
|
*
|
|
* @param {{draining:boolean, mode:string, status:string, queue:object[]|undefined}} input
|
|
* @returns {boolean}
|
|
*/
|
|
export function directSendBlocked({ draining, mode, status, queue }) {
|
|
if (draining) return true;
|
|
if (mode === "now" || status === "blocked") return false;
|
|
return queueBlocksDirectSend(queue);
|
|
}
|