@kolisachint/hoobot 0.0.3 → 0.0.5

package/src/session.ts

@@ -1,5 +1,5 @@
 /**
- * One Discord thread ⇄ one app-server thread. Translates Codex app-server
+ * One Discord space (a channel or a thread) ⇄ one app-server thread. Translates Codex app-server
  * notifications into Discord messages and approval requests into buttons.
  * Uses only standard Codex methods, so it works against `hoocode app-server`
  * and the real `codex app-server` alike.
@@ -9,16 +9,20 @@ import {
   ButtonBuilder,
   ButtonStyle,
   ComponentType,
+  StringSelectMenuBuilder,
   type Message,
 } from "discord.js";
 import { config } from "./config.ts";
 import { code, describeTool, splitMessage, truncate } from "./format.ts";
 import { CodexClient, RpcError, userInput, type Notification, type RequestId, type ServerRequest } from "./codex-client.ts";
 import type { LinkStore } from "./links.ts";
+import { TurnSummary } from "./summary.ts";
+import { changedSince, pathsInText, pickAttachments, type Attachment } from "./attachments.ts";
 
 /** The bits of a Discord thread this file uses (tests pass a fake). */
 export interface ThreadLike {
   id: string;
+  /** Resolves to a message with `edit` and `delete`. */
   send(content: any): Promise<any>;
   sendTyping(): Promise<unknown>;
 }
@@ -34,10 +38,25 @@ export class ThreadSession {
   private progressMsg: Message | null = null;
   private progressDirty = false;
   private progressTimer: ReturnType<typeof setInterval>;
+  /** Show every tool step and in-between message (`!verbose`). Off: status line + final answer. */
+  private verbose = false;
+  /** The running turn's summary and its status-line message. */
+  private live: { summary: TurnSummary; msg: Message | null; at: number } | null = null;
+  /** Latest agent message of the running turn; posted when the turn ends. */
+  private answer: string | null = null;
   private typingTimer: ReturnType<typeof setInterval> | null = null;
   private idleTimer: ReturnType<typeof setTimeout> | null = null;
   private approvals = new Map<RequestId, Approval>();
+  /** The model the server reports for the thread. */
   private model: string | null = null;
+  /** The model picked for this Discord thread (`!model`), saved in the link. */
+  private chosenModel: string | null = null;
+  /** Last Discord message the conversation has read; saved in the link. */
+  private seenId: string | null = null;
+  /** Whether the space had a conversation before this session opened. */
+  private wasLinked = false;
+  /** The message that started the running turn; the answer replies to it. */
+  private caller: { id: string } | null = null;
   /** Serialises Discord sends so replies stay in order. */
   private queue: Promise<unknown> = Promise.resolve();
   private ready: Promise<void> | null = null;
@@ -48,6 +67,8 @@ export class ThreadSession {
     private readonly client: CodexClient,
     private readonly links: LinkStore,
     private onClose: (threadId: string) => void,
+    /** The folder this thread works in (for `!status`, and files to attach). */
+    readonly workdir = config.workdir,
   ) {
     client.on("notification", this.onNotification);
     client.on("request", this.onRequest);
@@ -67,6 +88,9 @@ export class ThreadSession {
   private ensureThread(): Promise<void> {
     this.ready ??= (async () => {
       const link = this.links.get(this.linkKey);
+      this.chosenModel = link?.model ?? null;
+      this.seenId = link?.seen ?? null;
+      this.wasLinked = !!link;
       if (link) {
         try {
           const res = await this.client.request("thread/resume", { threadId: link.threadId });
@@ -75,6 +99,8 @@ export class ThreadSession {
         } catch (err) {
           console.error(`[${this.thread.id}] resume ${link.threadId} failed; starting fresh`, err);
           await this.post(`Couldn't reopen the earlier conversation (${code(errorText(err))}). Starting a new one.`);
+          this.seenId = null;
+          this.wasLinked = false;
         }
       }
       await this.startThread();
@@ -87,10 +113,34 @@ export class ThreadSession {
 
   private async startThread() {
     const params: Record<string, unknown> = {};
-    if (config.model) params.model = config.model;
+    const model = this.chosenModel ?? config.model;
+    if (model) params.model = model;
     const res = await this.client.request("thread/start", params);
     this.adopt(res);
-    this.links.set(this.linkKey, { threadId: res.thread.id });
+    this.saveLink();
+  }
+
+  private saveLink() {
+    if (!this.threadId) return;
+    this.links.set(this.linkKey, {
+      threadId: this.threadId,
+      ...(this.chosenModel ? { model: this.chosenModel } : {}),
+      ...(this.seenId ? { seen: this.seenId } : {}),
+    });
+  }
+
+  /** Read position for context: whether the space had a conversation, and its last read message. */
+  async readState(): Promise<{ linked: boolean; seen: string | null }> {
+    await this.ensureThread();
+    return { linked: this.wasLinked, seen: this.seenId };
+  }
+
+  /** Everything up to `messageId` has been sent to the conversation. */
+  markSeen(messageId: string) {
+    if (this.seenId && BigInt(this.seenId) >= BigInt(messageId)) return;
+    this.seenId = messageId;
+    this.wasLinked = true;
+    this.saveLink();
   }
 
   private adopt(res: any) {
@@ -98,13 +148,17 @@ export class ThreadSession {
     this.model = res.model ?? null;
     // A turn still running on the server (e.g. after a bot restart).
     const running = (res.thread.turns ?? []).findLast?.((t: any) => t.status === "inProgress");
-    this.turnId = running?.id ?? null;
-    if (this.turnId) this.startTyping();
+    this.turnId = null;
+    if (running) this.beginTurn(running.id);
   }
 
   // ── Input from Discord ─────────────────────────────────────────────────────
 
-  async prompt(text: string, images: { data: string; mimeType: string }[] = []) {
+  /**
+   * `caller`: the Discord message this answers; the final answer replies to it.
+   * Resolves true when the server took the message (a new turn or a steer).
+   */
+  async prompt(text: string, images: { data: string; mimeType: string }[] = [], caller?: { id: string }): Promise<boolean> {
     this.touch();
     await this.ensureThread();
     const input = userInput(text, images);
@@ -113,7 +167,7 @@ export class ThreadSession {
       try {
         await this.client.request("turn/steer", { threadId: this.threadId, input, expectedTurnId: this.turnId });
         await this.post("Queued. It'll be read after the current step.");
-        return;
+        return true;
       } catch (err) {
         // The turn ended in the meantime: start a new one below.
         if (!(err instanceof RpcError)) throw err;
@@ -121,15 +175,17 @@ export class ThreadSession {
     }
     try {
       const params: Record<string, unknown> = { threadId: this.threadId, input };
-      if (this.pendingModel) params.model = this.pendingModel;
+      // Sent every turn: the server ignores it when it's already the model,
+      // and it survives a bot restart or a server that forgot it.
+      if (this.chosenModel) params.model = this.chosenModel;
       const res = await this.client.request("turn/start", params);
-      if (this.pendingModel) {
-        this.model = this.pendingModel;
-        this.pendingModel = null;
-      }
+      if (this.chosenModel) this.model = this.chosenModel;
       this.beginTurn(res.turn.id);
+      this.caller = caller ?? null;
+      return true;
     } catch (err) {
       await this.post(`**Not sent:** ${errorText(err)}`);
+      return false;
     }
   }
 
@@ -152,6 +208,9 @@ export class ThreadSession {
     }
     if (this.threadId) await this.client.request("thread/unsubscribe", { threadId: this.threadId }).catch(() => {});
     this.turnId = null;
+    // The new conversation knows nothing: the next call reads the last 30 again.
+    this.seenId = null;
+    this.wasLinked = false;
     this.ready = this.startThread();
     try {
       await this.ready;
@@ -166,20 +225,117 @@ export class ThreadSession {
     await this.ensureThread();
     const lines = [
       "**Status**",
-      `- Model: ${code(this.pendingModel ?? this.model ?? "default")}`,
+      `- Model: ${code(this.chosenModel ?? this.model ?? "default")}${this.chosenModel && this.chosenModel !== this.model ? " (from the next message)" : ""}`,
       `- Busy: ${this.turnId ? "yes" : "no"}`,
+      `- Folder: ${code(this.workdir)}`,
       `- Thread: ${code(this.threadId ?? "none")}`,
       `- Server: ${code(this.client.endpoint)}`,
     ];
     await this.post(lines.join("\n"));
   }
 
-  private pendingModel: string | null = null;
+  /**
+   * `!model` → a dropdown of the server's models (hoocode: your
+   * `enabledModels` scope). `!model kimi` → that model if one matches,
+   * else a dropdown of the matches. Takes effect from the next message;
+   * the conversation carries on.
+   */
+  async chooseModel(query = "") {
+    await this.ensureThread();
+    let models: ModelChoice[];
+    try {
+      models = await this.listModels(query !== "");
+    } catch (err) {
+      await this.post(`**Can't list models:** ${errorText(err)}`);
+      return;
+    }
+    const q = query.toLowerCase();
+    if (q) {
+      const exact = models.find((m) => m.value.toLowerCase() === q || m.value.toLowerCase().endsWith(`/${q}`));
+      if (exact) return this.setModel(exact.value);
+      const matches = models.filter((m) => m.value.toLowerCase().includes(q) || m.label.toLowerCase().includes(q));
+      if (matches.length === 1) return this.setModel(matches[0]!.value);
+      if (matches.length === 0) {
+        await this.post(`No model matches ${code(query)}. Send \`!model\` for the list.`);
+        return;
+      }
+      // Scoped models first.
+      models = [...matches.filter((m) => !m.hidden), ...matches.filter((m) => m.hidden)];
+    }
+    if (models.length === 0) {
+      await this.post("The server lists no models.");
+      return;
+    }
+    const current = this.chosenModel ?? this.model;
+    const shown = models.slice(0, 25);
+    const menu = new StringSelectMenuBuilder()
+      .setCustomId("model")
+      .setPlaceholder("Pick a model")
+      .addOptions(
+        shown.map((m) => ({
+          label: truncate(m.label, 100),
+          value: m.value.slice(0, 100),
+          description: m.label === m.value ? undefined : truncate(m.value, 100),
+          default: m.value === current || m.value.endsWith(`/${current}`),
+        })),
+      );
+    const more = models.length > shown.length ? `\nShowing ${shown.length} of ${models.length}; narrow it with \`!model <part of name>\`.` : "";
+    const title = `**Model:** ${code(current ?? "default")}. Pick one for this thread (from the next message):${more}`;
+    const msg = (await this.enqueue(() =>
+      this.thread.send({ content: title, components: [new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(menu)] }),
+    )) as Message;
+    try {
+      const pick = await msg.awaitMessageComponent({
+        componentType: ComponentType.StringSelect,
+        time: 5 * 60_000,
+        filter: async (i) => {
+          if (config.allowedUserIds.has(i.user.id)) return true;
+          await i.reply({ content: "Only allowed users can change the model.", ephemeral: true }).catch(() => {});
+          return false;
+        },
+      });
+      const name = pick.values[0]!;
+      this.applyModel(name);
+      await pick.update({ content: modelSetText(name), components: [] });
+    } catch {
+      await msg.edit({ content: `**Model:** ${code(this.chosenModel ?? this.model ?? "default")} (not changed)`, components: [] }).catch(() => {});
+    }
+  }
+
+  private async setModel(name: string) {
+    this.applyModel(name);
+    await this.post(modelSetText(name));
+  }
+
+  private applyModel(name: string) {
+    this.chosenModel = name;
+    this.saveLink();
+  }
 
-  /** Takes effect on the next turn (`turn/start` `model`). */
-  async setModel(name: string) {
-    this.pendingModel = name;
-    await this.post(`**Model:** ${code(name)} from the next message.`);
+  /** All pages of `model/list`. */
+  private async listModels(includeHidden: boolean): Promise<ModelChoice[]> {
+    const out: ModelChoice[] = [];
+    let cursor: string | undefined;
+    for (let page = 0; page < 10; page++) {
+      const res: any = await this.client.request("model/list", { includeHidden, ...(cursor ? { cursor } : {}) });
+      for (const m of res?.data ?? []) {
+        const value = String(m.model ?? m.id);
+        out.push({ value, label: String(m.displayName || value), hidden: !!m.hidden });
+      }
+      cursor = res?.nextCursor ?? undefined;
+      if (!cursor) break;
+    }
+    return includeHidden ? out : out.filter((m) => !m.hidden);
+  }
+
+  /** Toggle the step-by-step view for this thread. */
+  async toggleVerbose() {
+    this.verbose = !this.verbose;
+    await this.post(
+      this.verbose
+        ? "**Verbose on:** every step and message is shown. `!verbose` again to turn it off."
+        : "**Verbose off:** a status line while working, then the final answer.",
+    );
   }
 
   close() {
@@ -196,6 +352,8 @@ export class ThreadSession {
     this.turnId = turnId;
     this.tools = [];
     this.progressMsg = null;
+    this.live = { summary: new TurnSummary(), msg: null, at: 0 };
+    this.answer = null;
     this.startTyping();
   }
 
@@ -217,14 +375,13 @@ export class ThreadSession {
         this.turnId = null;
         this.stopTyping();
         await this.flushProgress();
-        if (p.turn.status === "failed" && p.turn.error?.message) {
-          await this.post(`**Error:**\n${"```"}\n${truncate(p.turn.error.message, 1500)}\n${"```"}`);
-        }
+        await this.finishTurn(p.turn);
         this.touch();
         break;
       }
 
       case "item/started": {
+        this.live?.summary.started(p.item);
         const tool = toolLine(p.item);
         if (tool) {
           this.tools.push(tool);
@@ -235,6 +392,12 @@ export class ThreadSession {
 
       case "item/completed": {
         const item = p.item;
+        this.live?.summary.completed(item);
+        if (item.type === "agentMessage" && item.text?.trim() && !this.verbose) {
+          // Only the last message of the turn is posted (finishTurn).
+          this.answer = item.text;
+          break;
+        }
         if (item.type === "agentMessage" && item.text?.trim()) {
           // Text closes the current tool list; the next tools start a fresh one.
           await this.flushProgress();
@@ -257,8 +420,78 @@ export class ThreadSession {
     }
   }
 
+  /**
+   * Post the final answer with a footer (PR, commits, files, steps, time,
+   * model) and remove the status line. Errors are always posted in full.
+   */
+  private async finishTurn(turn: any) {
+    const status = this.live;
+    this.live = null;
+    const answer = this.answer;
+    this.answer = null;
+    const caller = this.caller;
+    this.caller = null;
+
+    const footer = status?.summary.footer(this.model) ?? "";
+    // Files the model wrote, named in its answer, or that changed in the work
+    // folder during the turn (shell output) go back as attachments.
+    const { files, skipped } =
+      turn.status === "completed" && status
+        ? pickAttachments(
+            [
+              ...status.summary.editedFiles,
+              ...pathsInText(answer ?? ""),
+              // Whole seconds: some filesystems store mtimes that coarse.
+              ...changedSince(this.workdir, Math.floor(status.summary.startedAt / 1000) * 1000),
+            ],
+            this.workdir,
+          )
+        : { files: [], skipped: [] };
+    const parts: string[] = [];
+    if (answer) parts.push(answer);
+    if (turn.status === "failed") {
+      parts.push(`**Error:**\n${"```"}\n${truncate(turn.error?.message ?? "the turn failed", 1500)}\n${"```"}`);
+    } else if (!answer && !this.verbose && turn.status === "completed") {
+      parts.push("Done.");
+    }
+    if (parts.length) {
+      const chunks = splitMessage(parts.join("\n\n"));
+      const last = chunks.length - 1;
+      if (footer && chunks[last]!.length + footer.length + 1 <= 2000) chunks[last] += `\n${footer}`;
+      else if (footer) chunks.push(footer);
+      // The first chunk is a Discord reply to the message that asked.
+      for (const [i, chunk] of chunks.entries()) await this.post(chunk, i === 0 ? caller : null, i === chunks.length - 1 ? files : []);
+    } else if (footer && !this.verbose && turn.status !== "interrupted") {
+      await this.post(footer, caller, files);
+    } else if (files.length) {
+      await this.post("Files:", caller, files);
+    }
+    if (skipped.length) {
+      await this.post(`-# Not attached (over Discord's 10 files / 10 MB): ${skipped.map((s) => code(s)).join(", ")}`);
+    }
+    // Queued after any in-flight status send, so that message exists by now.
+    if (status) await this.enqueue(async () => status.msg?.delete()).catch(() => {});
+  }
+
+  /** Throttled: the status line while a turn runs (non-verbose). */
+  private async flushStatus() {
+    const status = this.live;
+    if (!status || this.verbose) return;
+    const now = Date.now();
+    // Quick answers need no status line; then refresh every 3 s.
+    if (now - status.summary.startedAt < 4000 || now - status.at < 3000) return;
+    status.at = now;
+    const body = status.summary.statusLine(now);
+    await this.enqueue(async () => {
+      if (this.live !== status) return; // turn ended meanwhile
+      if (status.msg) await status.msg.edit(body).catch(() => {});
+      else status.msg = await this.thread.send(body);
+    }).catch(() => {});
+  }
+
   /** Tool activity as one message, edited in place (throttled). */
   private async flushProgress() {
+    if (!this.verbose) return this.flushStatus();
     if (!this.progressDirty || this.tools.length === 0) return;
     this.progressDirty = false;
     // Words, not just symbols, so state doesn't rely on colour or icon shape.
@@ -357,9 +590,25 @@ export class ThreadSession {
 
   // ── Helpers ────────────────────────────────────────────────────────────────
 
-  private post(text: string) {
+  /** `replyTo`: post as a Discord reply to that message (no ping); plain send if it's gone. */
+  private post(text: string, replyTo?: { id: string } | null, files: Attachment[] = []) {
     if (!text.trim()) return Promise.resolve();
-    return this.enqueue(() => this.thread.send(text)).catch((err) => console.error(`[${this.thread.id}] send failed`, err));
+    const message = (withFiles: boolean) => ({
+      content: text,
+      ...(replyTo ? { reply: { messageReference: replyTo.id, failIfNotExists: false }, allowedMentions: { repliedUser: false } } : {}),
+      ...(withFiles ? { files } : {}),
+    });
+    const send = () =>
+      !replyTo && !files.length
+        ? this.thread.send(text)
+        : this.thread.send(message(files.length > 0)).catch(async (err: unknown) => {
+            if (!files.length) throw err;
+            // e.g. over this server's upload limit: still post the text.
+            console.error(`[${this.thread.id}] upload failed`, err);
+            await this.thread.send(message(false));
+            return this.thread.send(`-# Couldn't attach ${files.map((f) => code(f.name)).join(", ")}: ${errorText(err)}`);
+          });
+    return this.enqueue(send).catch((err) => console.error(`[${this.thread.id}] send failed`, err));
   }
 
   private enqueue<T>(fn: () => Promise<T>): Promise<T> {
@@ -398,6 +647,12 @@ export class ThreadSession {
   }
 }
 
+type ModelChoice = { value: string; label: string; hidden: boolean };
+
+function modelSetText(name: string): string {
+  return `**Model:** ${code(name)} from the next message. The conversation carries on.`;
+}
+
 /** A progress line for a tool-ish item, or null for messages. */
 function toolLine(item: any): ToolLine | null {
   switch (item?.type) {

package/src/summary.ts

@@ -0,0 +1,122 @@
+/**
+ * What a turn did, boiled down for Discord: a one-line status while it runs
+ * and a short footer under the final answer (PRs, commits, files, steps,
+ * time, model). Pure: fed app-server items, no Discord or network.
+ */
+import { code, truncate } from "./format.ts";
+
+const PR_URL = /https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/pull\/\d+/g;
+/** `git commit` prints `[branch abc1234] subject`; `git push` prints `old..new  branch -> branch`. */
+const COMMIT_LINE = /^\[[^\]\s]+(?: \(root-commit\))? ([0-9a-f]{7,40})\]/gm;
+
+export class TurnSummary {
+  readonly startedAt: number;
+  private steps = new Set<string>();
+  private failed = 0;
+  private current: string | null = null;
+  private prs = new Set<string>();
+  private commits = new Set<string>();
+  private files = new Set<string>();
+
+  constructor(now = Date.now()) {
+    this.startedAt = now;
+  }
+
+  /** Paths of files edited or written this turn, in order. */
+  get editedFiles(): string[] {
+    return [...this.files];
+  }
+
+  /** An `item/started` item. */
+  started(item: any) {
+    const what = stepLabel(item);
+    if (!what) return;
+    this.steps.add(item.id);
+    this.current = what;
+  }
+
+  /** An `item/completed` item. */
+  completed(item: any) {
+    if (item?.type === "agentMessage") {
+      this.scan(item.text);
+      return;
+    }
+    if (!stepLabel(item)) return;
+    this.steps.add(item.id);
+    if (item.status === "failed" || item.status === "declined" || (item.exitCode ?? 0) !== 0) this.failed++;
+    if (item.type === "commandExecution") this.scan(item.aggregatedOutput);
+    if (item.type === "fileChange" && item.status !== "declined") {
+      for (const c of item.changes ?? []) if (c?.path) this.files.add(c.path);
+    }
+    if (item.type === "dynamicToolCall" && (item.tool === "edit" || item.tool === "write") && item.success !== false) {
+      const path = item.arguments?.path ?? item.arguments?.file_path;
+      if (path) this.files.add(String(path));
+    }
+  }
+
+  /** e.g. "⏳ Working · 4 steps · 1m 20s · bash `bun test`" */
+  statusLine(now = Date.now()): string {
+    const parts = ["⏳ Working", plural(this.steps.size, "step"), duration(now - this.startedAt)];
+    if (this.current) parts.push(this.current);
+    return parts.join(" · ");
+  }
+
+  /** e.g. "-# PR #5 · commit `abc1234` · 3 files · 12 steps · 3m 10s · `model`", or "" for a bare chat turn. */
+  footer(model: string | null, now = Date.now()): string {
+    const parts: string[] = [];
+    for (const url of this.prs) parts.push(`[PR #${url.split("/").pop()}](<${url}>)`);
+    const commits = [...this.commits];
+    if (commits.length === 1) parts.push(`commit ${code(commits[0]!.slice(0, 7))}`);
+    else if (commits.length > 1) parts.push(`${commits.length} commits`);
+    if (this.files.size === 1) parts.push(`edited ${code(truncate(basename([...this.files][0]!), 60))}`);
+    else if (this.files.size > 1) parts.push(`${this.files.size} files edited`);
+    if (this.steps.size === 0 && parts.length === 0) return "";
+    if (this.steps.size) parts.push(plural(this.steps.size, "step") + (this.failed ? ` (${this.failed} failed)` : ""));
+    parts.push(duration(now - this.startedAt));
+    if (model) parts.push(code(model));
+    return `-# ${parts.join(" · ")}`;
+  }
+
+  private scan(text: unknown) {
+    if (typeof text !== "string" || !text) return;
+    for (const m of text.matchAll(PR_URL)) this.prs.add(m[0]);
+    for (const m of text.matchAll(COMMIT_LINE)) this.commits.add(m[1]!);
+  }
+}
+
+/** Short label for a tool-ish item, or null for messages and reasoning. */
+function stepLabel(item: any): string | null {
+  switch (item?.type) {
+    case "commandExecution":
+      return `bash ${code(truncate(String(item.command ?? ""), 60))}`;
+    case "fileChange":
+      return `edit ${code(truncate(basename(item.changes?.[0]?.path ?? "?"), 60))}`;
+    case "dynamicToolCall": {
+      const a = item.arguments ?? {};
+      const arg = a.command ?? a.path ?? a.file_path ?? a.query ?? a.pattern;
+      return arg ? `${item.tool} ${code(truncate(String(arg), 60))}` : String(item.tool);
+    }
+    case "mcpToolCall":
+      return `${item.server}/${item.tool}`;
+    case "webSearch":
+      return `web search ${code(truncate(String(item.query ?? ""), 60))}`;
+    default:
+      return null;
+  }
+}
+
+function basename(path: string): string {
+  return path.split("/").pop() || path;
+}
+
+function plural(n: number, word: string): string {
+  return `${n} ${word}${n === 1 ? "" : "s"}`;
+}
+
+export function duration(ms: number): string {
+  const s = Math.max(0, Math.round(ms / 1000));
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${s % 60}s`;
+  return `${Math.floor(m / 60)}h ${m % 60}m`;
+}