diff options
Diffstat (limited to 'crates')
| -rw-r--r-- | crates/dinggerd/assets/pi/pi-agent-state.ts | 229 |
1 files changed, 229 insertions, 0 deletions
diff --git a/crates/dinggerd/assets/pi/pi-agent-state.ts b/crates/dinggerd/assets/pi/pi-agent-state.ts index 0575ba9..d86f812 100644 --- a/crates/dinggerd/assets/pi/pi-agent-state.ts +++ b/crates/dinggerd/assets/pi/pi-agent-state.ts @@ -2,6 +2,7 @@ // managed by dingger; reinstalling or updating the integration overwrites this file. // add custom hooks/plugins beside this file instead of editing it. +import crypto from "node:crypto"; import fs from "node:fs"; import net from "node:net"; import path from "node:path"; @@ -252,7 +253,235 @@ async function drainStateQueue(): Promise<void> { } } +// ---- Session names ----------------------------------------------------- +// +// Every session gets a short name of what it is about, from the model, +// after its first run settles, refreshed every few of your messages, and +// for an old unnamed session when you resume it. A name you give it +// (/name, `pi --name`, /autoname <name>) is never replaced. This runs in +// every pi session (print and JSON runs too, outside tmux too), not only +// where dingger watches. PI_AUTONAME_MODEL="provider/model-id" picks a +// (cheaper) model; the session's own model otherwise. +// +// It replaces the pi-auto-session-name package and reads the marker that +// package saved in sessions, so names it gave stay automatic. + +/** A session entry recording an automatic name, and how many of your messages it covered. */ +const autoNameEntry = "auto-session-name"; +const nameChars = 100; +const renameEvery = 8; +const namePromptChars = 4000; +const nameMessageChars = 350; +const nameTimeoutMs = 30_000; + +type Said = { role: "user" | "assistant"; text: string }; + +/** Message text without injected context blocks, on one line. */ +function plainText(content: unknown): string { + const text = + typeof content === "string" + ? content + : Array.isArray(content) + ? content + .filter((part) => part?.type === "text" && typeof part.text === "string") + .map((part) => part.text) + .join("\n") + : ""; + return text + .replace(/<(system-reminder|selected-context|environment_context)>[\s\S]*?<\/\1>/gi, "") + .replace(/\s+/g, " ") + .trim(); +} + +/** At most `max` characters, cut at a word when one is near. */ +function clip(text: string, max: number): string { + if (text.length <= max) { + return text; + } + const cut = text.slice(0, max); + const space = cut.lastIndexOf(" "); + return (space > max / 2 ? cut.slice(0, space) : cut).trim(); +} + +/** What was said on the session's branch. */ +function conversation(entries: any[]): Said[] { + return entries + .filter((entry) => entry?.type === "message" && ["user", "assistant"].includes(entry.message?.role)) + .map((entry) => ({ role: entry.message.role, text: plainText(entry.message.content) })) + .filter((said) => said.text); +} + +/** The first message (what it set out to do) and the latest ones, within budget. */ +function excerpt(said: Said[]): Said[] { + const short = (one: Said) => ({ role: one.role, text: clip(one.text, nameMessageChars) }); + const first = short(said[0]); + const latest: Said[] = []; + let used = first.text.length; + for (const one of said.slice(1).reverse()) { + const next = short(one); + if (used + next.text.length > namePromptChars || latest.length >= 8) { + break; + } + latest.unshift(next); + used += next.text.length; + } + return [first, ...latest]; +} + +export function namePrompt(said: Said[]): string { + return [ + "Name this coding-agent session for a list of sessions.", + "Answer with the name alone: one line of at most 14 words, without quotes or a final period.", + 'Say what the task or topic is, concretely (like "Fix the sidecar\'s reconnect after a daemon restart").', + "Write it in the conversation's language.", + "", + "<conversation>", + ...excerpt(said).map((one) => `${one.role === "user" ? "User" : "Assistant"}: ${one.text}`), + "</conversation>", + ].join("\n"); +} + +/** A model's answer as a name: one line, no quotes or label, no final punctuation. */ +export function nameFrom(answer: string): string { + const name = plainText(answer) + .replace(/^(title|name):\s*/i, "") + .replace(/^["'`“”«»]+|["'`“”«»]+$/g, "") + .replace(/[.!?]+$/, "") + .trim(); + return clip(name, nameChars); +} + +function autoName(pi) { + let yours = false; // you named it: never rename + let given: string | undefined; // the name this gave it + let namedAt = 0; // your messages when it was named + let pending: string | undefined; // a name just set, until pi says so + let naming = false; + + function nameModel(ctx) { + const spec = process.env.PI_AUTONAME_MODEL?.trim() ?? ""; + const slash = spec.indexOf("/"); + const chosen = slash > 0 ? ctx.modelRegistry.find(spec.slice(0, slash), spec.slice(slash + 1)) : undefined; + return [chosen, ctx.model].find((model) => model && ctx.modelRegistry.hasConfiguredAuth(model)); + } + + async function ask(ctx, said: Said[]): Promise<string> { + const model = nameModel(ctx); + if (model) { + try { + const call = ctx.modelRegistry.complete( + model, + { messages: [{ role: "user", content: [{ type: "text", text: namePrompt(said) }], timestamp: Date.now() }] }, + { reasoningEffort: "low", cacheRetention: "none", sessionId: crypto.randomUUID() }, + ); + call.catch(() => {}); + const timeout = new Promise<never>((_, reject) => setTimeout(() => reject(new Error("timeout")), nameTimeoutMs).unref?.()); + const answer = await Promise.race([call, timeout]); + const name = nameFrom( + (answer?.content ?? []).filter((block) => block.type === "text").map((block) => block.text).join(" "), + ); + if (name.length >= 3) { + return name; + } + } catch { + // The first message, then. + } + } + return clip(said.find((one) => one.role === "user")?.text ?? "", nameChars); + } + + async function nameSession(ctx, now = false): Promise<void> { + if (naming || !ctx.sessionManager.getSessionFile()) { + return; + } + const said = conversation(ctx.sessionManager.getBranch()); + const yourMessages = said.filter((one) => one.role === "user").length; + if (yourMessages === 0 || (yours && !now)) { + return; + } + if (!now && namedAt > 0 && yourMessages - namedAt < renameEvery) { + return; + } + naming = true; + try { + const name = await ask(ctx, said); + if (!name || (yours && !now)) { + return; + } + pending = name; + given = name; + namedAt = yourMessages; + pi.setSessionName(name); + pi.appendEntry(autoNameEntry, { name, count: yourMessages }); + if (ctx.hasUI) { + ctx.ui.notify(`Session named: ${name}`, "info"); + } + } catch { + // Naming never breaks a session. + } finally { + naming = false; + } + } + + // In print and JSON runs, before pi exits. + const finish = (ctx, naming: Promise<void>) => (ctx.mode === "print" || ctx.mode === "json" ? naming : undefined); + + pi.on("session_start", async (_event, ctx) => { + yours = false; + given = undefined; + namedAt = 0; + pending = undefined; + naming = false; + for (const entry of ctx.sessionManager.getEntries()) { + if (entry?.type === "custom" && entry.customType === autoNameEntry && entry.data) { + given = typeof entry.data.name === "string" ? entry.data.name : given; + namedAt = typeof entry.data.count === "number" ? entry.data.count : namedAt; + } + } + const current = pi.getSessionName?.(); + yours = !!current && current !== given; + // An old session never named: name it now. + if (!yours && namedAt === 0) { + await finish(ctx, nameSession(ctx).catch(() => {})); + } + }); + + pi.on("session_info_changed", (event) => { + if (pending !== undefined && event?.name === pending) { + pending = undefined; + return; + } + // Cleared: name it again; anything else is yours. + yours = event?.name !== undefined; + }); + + pi.on("agent_settled", async (_event, ctx) => { + await finish(ctx, nameSession(ctx).catch(() => {})); + }); + + pi.registerCommand("autoname", { + description: "Name this session now, or give it a name: /autoname [name]", + handler: async (args, ctx) => { + const name = (args ?? "").trim(); + if (name) { + yours = true; + pi.setSessionName(name); + if (ctx.hasUI) { + ctx.ui.notify(`Session named: ${name}`, "info"); + } + return; + } + if (ctx.hasUI) { + ctx.ui.notify("Naming this session…", "info"); + } + await nameSession(ctx, true); + }, + }); +} + export default function (pi) { + // Everywhere pi runs, not only in tmux. + autoName(pi); if (!enabled()) { return; } |