@kolisachint/hoobot 0.0.3 → 0.0.5

package/src/index.ts

@@ -1,10 +1,12 @@
 #!/usr/bin/env bun
 /**
- * hoo-discord-bot: talk to hoocode from Discord.
+ * hoobot: talk to hoocode from Discord.
  *
- * - Mention the bot in a channel → it opens a thread and answers there.
- * - Every message in that thread goes to the same hoocode session.
- * - Commands inside a thread: !stop  !new  !status  !model <pattern>  !help
+ * - Every channel and thread is a shared space with its own hoocode conversation.
+ * - Mention the bot (or reply to it) → it reads what was said since it last
+ *   looked (up to 30 messages) and answers right there.
+ * - Commands inside a thread: !stop  !new  !status  !model [name]  !verbose  !help
+ * - Each channel in WORKSPACES works in its own folder with its own app-server.
  */
 import {
   ChannelType,
@@ -13,14 +15,29 @@ import {
   GatewayIntentBits,
   Partials,
   type Message,
+  type TextChannel,
   type ThreadChannel,
 } from "discord.js";
-import { config, prepareWorkspace } from "./config.ts";
+import { allWorkdirs, config, prepareWorkspace, workdirFor } from "./config.ts";
 import { CodexClient } from "./codex-client.ts";
 import { LinkStore } from "./links.ts";
 import { ThreadSession } from "./session.ts";
+import { authorName, buildPrompt, gatherContext, toContext, type ContextMessage, type SpaceLike } from "./context.ts";
+import { clearSpace, formatAttachments, imageInputs, pruneInbox, saveAttachments, type SavedFile, type SkippedFile } from "./inbound.ts";
 
-prepareWorkspace();
+for (const dir of allWorkdirs()) prepareWorkspace(dir);
+// Files sent on Discord are kept a week.
+const prune = () => {
+  for (const dir of allWorkdirs()) {
+    try {
+      pruneInbox(dir);
+    } catch (err) {
+      console.error(`Can't clean ${dir}/.discord: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+};
+prune();
+setInterval(prune, 60 * 60 * 1000).unref();
 
 const links = new LinkStore(config.linksFile);
 const sessions = new Map<string, ThreadSession>();
@@ -31,35 +48,36 @@ function endpoint(): string {
   return `stdio:${config.hoocodeBin} app-server ${config.hoocodeArgs.join(" ")}`;
 }
 
-let app: Promise<CodexClient> | null = null;
+/** One app-server per folder, started on first use. */
+const apps = new Map<string, Promise<CodexClient>>();
 
-/** The shared app-server connection; reconnects after it drops. */
-function appServer(): Promise<CodexClient> {
-  app ??= (async () => {
+/** The app-server for `workdir`; reconnects after it drops. */
+function appServer(workdir: string): Promise<CodexClient> {
+  let app = apps.get(workdir);
+  if (app) return app;
+  app = (async () => {
     // A stdio server runs in the work folder; a socket server has its own.
     const client = await CodexClient.connect(
       endpoint(),
       { name: "hoobot", version: "0.1.0" },
-      { cwd: config.workdir },
+      { cwd: workdir },
     );
-    console.log(`Connected to app-server ${client.endpoint}`);
+    console.log(`Connected to app-server ${client.endpoint} in ${workdir}`);
     client.on("close", (reason: string) => {
-      console.error(`app-server connection closed: ${reason}`);
-      app = null;
-      // Sessions hold the old client; drop them. Threads resume on the next message.
-      for (const s of [...sessions.values()]) s.close();
+      console.error(`app-server for ${workdir} closed: ${reason}`);
+      apps.delete(workdir);
+      // Its sessions hold the old client; drop them. Threads resume on the next message.
+      for (const s of [...sessions.values()]) if (s.workdir === workdir) s.close();
     });
     return client;
   })().catch((err) => {
-    console.error(`Can't reach app-server: ${err instanceof Error ? err.message : String(err)}`);
-    app = null;
+    console.error(`Can't reach app-server for ${workdir}: ${err instanceof Error ? err.message : String(err)}`);
+    apps.delete(workdir);
     throw err;
   });
+  apps.set(workdir, app);
   return app;
 }
-/** Threads this bot created, so it only listens in its own threads. */
-const ownThreads = new Set<string>();
-
 const client = new Client({
   intents: [
     GatewayIntentBits.Guilds,
@@ -72,23 +90,31 @@ const client = new Client({
 const HELP = [
   "**hoo: hoocode in Discord**",
   "",
-  "**Start:** mention me with a request. I'll open a thread.",
-  "**Continue:** just type in the thread.",
+  "**Call me:** mention me, or reply to one of my messages. I answer right here.",
+  "Every channel and thread is a shared space: anyone can talk, and when I'm called",
+  "I read what was said since I last looked (up to 30 messages).",
+  "Open a thread for a side task; it has its own conversation in the same folder.",
+  "Attach files (or reply to a message with files): I save them in the work folder and read them.",
   "",
-  "**Commands (inside a thread)**",
+  "**Commands** (for this channel or thread)",
   "- `!stop`: stop the current run",
-  "- `!new`: forget this conversation, start fresh",
+  "- `!new`: start a fresh conversation here (for everyone; deletes files sent here)",
   "- `!status`: model, busy or not, folder",
-  "- `!model <name>`: switch model from the next message, e.g. `!model anthropic/claude-sonnet-4-5`",
+  "- `!model`: pick the model here from a list (from the next message; the conversation carries on)",
+  "- `!model <part of name>`: pick it directly, e.g. `!model kimi`",
+  "- `!verbose`: show every step here (again to turn off)",
   "- `!help`: this message",
   "",
-  "Typing while I'm busy steers the current run.",
-  "Commands that change files or run shell ask for approval with buttons.",
+  "Calling me while I'm busy steers the current run.",
+  "While I work you see one status line; then the answer with a short",
+  "summary (PR, commits, files, steps, time, model).",
+  ...(config.approvals === "ask" ? ["Commands that change files or run shell ask for approval with buttons."] : []),
 ].join("\n");
 
 client.once(Events.ClientReady, (c) => {
   console.log(`Logged in as ${c.user.tag}`);
   console.log(`Working folder: ${config.workdir}`);
+  for (const [channel, dir] of config.workspaces) console.log(`  channel ${channel} → ${dir}`);
   console.log(`Allowed users: ${[...config.allowedUserIds].join(", ")}`);
 });
 
@@ -106,22 +132,23 @@ async function onMessage(message: Message) {
   if (config.guildId && message.guildId !== config.guildId) return;
 
   const channel = message.channel;
-  const inOwnThread = channel.isThread() && isOwnThread(channel);
-  // Discord's autocomplete often picks the bot's auto-created *role* (also
-  // named after the bot) instead of the bot user, so accept either.
+  if (channel.type !== ChannelType.GuildText && !channel.isThread()) return;
+  const parentId = channel.isThread() ? channel.parentId : channel.id;
+  if (config.channelIds.size && (!parentId || !(config.channelIds.has(parentId) || config.workspaces.has(parentId)))) return;
+
+  // Called by a mention (the bot user, or its auto-created role that Discord's
+  // autocomplete often picks), or by replying to one of the bot's messages.
   const botRoleId = message.guild?.members.me?.roles.botRole?.id;
-  const mentioned =
+  const called =
     message.mentions.users.has(client.user.id) ||
-    (!!botRoleId && message.mentions.roles.has(botRoleId));
-
-  if (!inOwnThread && !mentioned) return;
+    (!!botRoleId && message.mentions.roles.has(botRoleId)) ||
+    message.mentions.repliedUser?.id === client.user.id;
+  if (!called) return;
   console.log(`[msg] ${message.author.username} (${message.author.id}) in ${channel.id}: ${message.content.slice(0, 80)}`);
 
-  const parentId = channel.isThread() ? channel.parentId : channel.id;
-  if (config.channelIds.size && (!parentId || !config.channelIds.has(parentId))) return;
-
+  // Only allowed users can call the bot (everyone's messages still count as context).
   if (!config.allowedUserIds.has(message.author.id)) {
-    if (mentioned) await message.reply("Sorry, you're not on this bot's allow list.");
+    await message.reply("Sorry, you're not on this bot's allow list.");
     return;
   }
 
@@ -129,93 +156,114 @@ async function onMessage(message: Message) {
     .replace(new RegExp(`<@!?${client.user.id}>`, "g"), "")
     .replace(botRoleId ? new RegExp(`<@&${botRoleId}>`, "g") : /$^/, "")
     .trim();
-  const images = await imageAttachments(message);
-
-  if (!text && images.length === 0) {
+  if (!text && message.attachments.size === 0) {
     await message.reply(HELP);
     return;
   }
 
-  // Resolve (or create) the thread for this conversation.
-  let thread: ThreadChannel;
-  if (channel.isThread()) {
-    thread = channel;
-    ownThreads.add(thread.id);
-  } else if (channel.type === ChannelType.GuildText) {
-    thread = await message.startThread({
-      name: (text || "hoocode").replace(/\s+/g, " ").slice(0, 90),
-      autoArchiveDuration: 1440,
-    });
-    ownThreads.add(thread.id);
-  } else {
-    await message.reply("Mention me in a normal text channel and I'll open a thread.");
-    return;
-  }
-
   // Commands.
   const [cmd, ...rest] = text.split(/\s+/);
   const arg = rest.join(" ").trim();
   if (cmd?.toLowerCase() === "!help") {
-    await thread.send(HELP);
+    await message.reply(HELP);
     return;
   }
+  const space = channel as TextChannel | ThreadChannel;
   let session: ThreadSession;
   try {
-    session = await getSession(thread);
+    session = await getSession(space, workdirFor(parentId));
   } catch (err) {
-    await thread.send(`**Can't reach hoocode:** ${err instanceof Error ? err.message : String(err)}`);
+    await message.reply(`**Can't reach hoocode:** ${err instanceof Error ? err.message : String(err)}`);
     return;
   }
   switch (cmd?.toLowerCase()) {
     case "!stop":
-      await session.abort();
-      return;
+      return session.abort();
     case "!new":
-      await session.newSession();
-      return;
+      clearSpace(session.workdir, space.id);
+      return session.newSession();
     case "!status":
-      await session.status();
-      return;
+      return session.status();
+    case "!verbose":
+      return session.toggleVerbose();
     case "!model":
-      if (!arg) await thread.send("Usage: `!model provider/model-id`");
-      else await session.setModel(arg);
-      return;
+      return session.chooseModel(arg);
   }
 
-  await session.prompt(text || "(see attached image)", images);
+  // One call at a time per space, so read positions advance in order.
+  await inOrder(space.id, async () => {
+    // What was said here since the conversation last read, plus the message replied to.
+    const { linked, seen } = await session.readState();
+    const [context, reply] = await Promise.all([
+      gatherContext({ space: space as unknown as SpaceLike, before: message.id, botId: client.user!.id, linked, seen }),
+      fetchReplyTo(message, client.user!.id),
+    ]);
+    // Files on the calling message and on the message it replies to are
+    // saved in the work folder; small text ones are pasted in too.
+    const saved: SavedFile[] = [];
+    const skipped: SkippedFile[] = [];
+    for (const m of [reply?.message, message]) {
+      if (!m?.attachments.size) continue;
+      const r = await saveAttachments({
+        workdir: session.workdir,
+        spaceId: space.id,
+        messageId: m.id,
+        author: authorName(m),
+        attachments: m.attachments.values(),
+      });
+      saved.push(...r.saved);
+      skipped.push(...r.skipped);
+    }
+    const prompt = buildPrompt({
+      context,
+      replyTo: reply?.context,
+      attachments: formatAttachments(saved, skipped),
+      author: authorName(message),
+      text: text || "(see the attached files)",
+    });
+    if (await session.prompt(prompt, imageInputs(saved), message)) session.markSeen(message.id);
+  });
 }
 
-async function getSession(thread: ThreadChannel): Promise<ThreadSession> {
-  const client = await appServer();
-  let s = sessions.get(thread.id);
-  if (!s) {
-    s = new ThreadSession(thread, client, links, (id) => sessions.delete(id));
-    sessions.set(thread.id, s);
-  }
-  return s;
+/** Per-space promise chains. */
+const lanes = new Map<string, Promise<unknown>>();
+function inOrder(key: string, fn: () => Promise<unknown>): Promise<unknown> {
+  const next = (lanes.get(key) ?? Promise.resolve()).then(fn, fn);
+  const tail = next.catch(() => {});
+  lanes.set(key, tail);
+  tail.then(() => lanes.get(key) === tail && lanes.delete(key));
+  return next;
 }
 
-/** A thread counts as ours if we created it or already hold a session for it. */
-function isOwnThread(thread: ThreadChannel): boolean {
-  return ownThreads.has(thread.id) || sessions.has(thread.id) || thread.ownerId === client.user?.id;
+/**
+ * The message `message` replies to, unless it's the bot's own (already in the
+ * conversation, and its files are already in the work folder).
+ */
+async function fetchReplyTo(message: Message, botId: string): Promise<{ message: Message; context: ContextMessage | null } | null> {
+  if (!message.reference?.messageId || message.mentions.repliedUser?.id === botId) return null;
+  try {
+    const ref = await message.fetchReference();
+    if (ref.author.id === botId) return null;
+    return { message: ref, context: toContext(ref, botId) };
+  } catch {
+    return null;
+  }
 }
 
-async function imageAttachments(message: Message) {
-  const out: { data: string; mimeType: string }[] = [];
-  for (const att of message.attachments.values()) {
-    const mime = att.contentType?.split(";")[0] ?? "";
-    if (!mime.startsWith("image/") || att.size > 5_000_000) continue;
-    const res = await fetch(att.url);
-    if (!res.ok) continue;
-    out.push({ data: Buffer.from(await res.arrayBuffer()).toString("base64"), mimeType: mime });
+async function getSession(space: TextChannel | ThreadChannel, workdir: string): Promise<ThreadSession> {
+  const client = await appServer(workdir);
+  let s = sessions.get(space.id);
+  if (!s) {
+    s = new ThreadSession(space, client, links, (id) => sessions.delete(id), workdir);
+    sessions.set(space.id, s);
   }
-  return out;
+  return s;
 }
 
 function shutdown() {
   console.log("Shutting down…");
   for (const s of [...sessions.values()]) s.close();
-  app?.then((c) => c.close()).catch(() => {});
+  for (const app of apps.values()) app.then((c) => c.close()).catch(() => {});
   client.destroy().finally(() => process.exit(0));
 }
 process.on("SIGINT", shutdown);

package/src/links.ts

@@ -5,7 +5,13 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 
-export type Link = { threadId: string };
+export type Link = {
+  threadId: string;
+  /** Model picked with `!model` for this space; sent on every turn. */
+  model?: string;
+  /** Last Discord message this conversation has read (context starts after it). */
+  seen?: string;
+};
 
 export class LinkStore {
   private links: Record<string, Link> = {};