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;
   }