@kolisachint/hoobot 0.0.5 → 0.0.7

package/src/index.ts

@@ -1,272 +1,57 @@
 #!/usr/bin/env bun
 /**
- * hoobot: talk to hoocode from Discord.
+ * hoobot: talk to hoocode from Discord and Slack.
  *
  * - 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
+ * - Mention the bot (or, on Discord, reply to it) → it reads what was said
+ *   since it last looked (up to 30 messages) and answers right there.
+ * - Commands: !stop  !new  !status  !model [name]  !verbose  !help
  * - Each channel in WORKSPACES works in its own folder with its own app-server.
+ * - Discord runs when DISCORD_TOKEN is set; Slack when SLACK_BOT_TOKEN and
+ *   SLACK_APP_TOKEN are. Both share the app-servers and the links file.
  */
-import {
-  ChannelType,
-  Client,
-  Events,
-  GatewayIntentBits,
-  Partials,
-  type Message,
-  type TextChannel,
-  type ThreadChannel,
-} from "discord.js";
-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";
+import { allWorkdirs, config, prepareWorkspace, surfaces } from "./config.ts";
+import { closeAll } from "./core.ts";
+import { INBOX_DIRS, pruneInbox } from "./inbound.ts";
 
 for (const dir of allWorkdirs()) prepareWorkspace(dir);
-// Files sent on Discord are kept a week.
+// Files sent on a chat 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)}`);
+      console.error(`Can't clean ${dir}/{${Object.values(INBOX_DIRS).join(",")}}: ${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>();
+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(", ")}`);
 
-/** `unix://PATH`, or `hoocode app-server` over stdio in the work folder. */
-function endpoint(): string {
-  if (config.appServer) return config.appServer;
-  return `stdio:${config.hoocodeBin} app-server ${config.hoocodeArgs.join(" ")}`;
-}
-
-/** One app-server per folder, started on first use. */
-const apps = new Map<string, Promise<CodexClient>>();
-
-/** 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: workdir },
-    );
-    console.log(`Connected to app-server ${client.endpoint} in ${workdir}`);
-    client.on("close", (reason: string) => {
-      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 for ${workdir}: ${err instanceof Error ? err.message : String(err)}`);
-    apps.delete(workdir);
-    throw err;
-  });
-  apps.set(workdir, app);
-  return app;
-}
-const client = new Client({
-  intents: [
-    GatewayIntentBits.Guilds,
-    GatewayIntentBits.GuildMessages,
-    GatewayIntentBits.MessageContent,
-  ],
-  partials: [Partials.Channel],
-});
-
-const HELP = [
-  "**hoo: hoocode in Discord**",
-  "",
-  "**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** (for this channel or thread)",
-  "- `!stop`: stop the current run",
-  "- `!new`: start a fresh conversation here (for everyone; deletes files sent here)",
-  "- `!status`: model, busy or not, folder",
-  "- `!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",
-  "",
-  "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(", ")}`);
-});
-
-client.on(Events.MessageCreate, async (message) => {
-  try {
-    await onMessage(message);
-  } catch (err) {
-    console.error("message handler failed", err);
-    await message.reply("Something went wrong on my side. Check the bot's terminal.").catch(() => {});
-  }
+const stops: (() => Promise<void>)[] = [];
+// Loaded only when used, so a Slack-only bot never loads discord.js and the other way round.
+const starters = {
+  discord: async () => (await import("./discord.ts")).startDiscord(),
+  slack: async () => (await import("./slack.ts")).startSlack(),
+};
+const results = await Promise.allSettled(surfaces().map(async (s) => stops.push(await starters[s]())));
+results.forEach((r, i) => {
+  if (r.status === "rejected") console.error(`Can't connect to ${surfaces()[i]}: ${r.reason instanceof Error ? r.reason.message : String(r.reason)}`);
 });
-
-async function onMessage(message: Message) {
-  if (message.author.bot || !client.user) return;
-  if (config.guildId && message.guildId !== config.guildId) return;
-
-  const channel = message.channel;
-  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 called =
-    message.mentions.users.has(client.user.id) ||
-    (!!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)}`);
-
-  // Only allowed users can call the bot (everyone's messages still count as context).
-  if (!config.allowedUserIds.has(message.author.id)) {
-    await message.reply("Sorry, you're not on this bot's allow list.");
-    return;
-  }
-
-  const text = message.content
-    .replace(new RegExp(`<@!?${client.user.id}>`, "g"), "")
-    .replace(botRoleId ? new RegExp(`<@&${botRoleId}>`, "g") : /$^/, "")
-    .trim();
-  if (!text && message.attachments.size === 0) {
-    await message.reply(HELP);
-    return;
-  }
-
-  // Commands.
-  const [cmd, ...rest] = text.split(/\s+/);
-  const arg = rest.join(" ").trim();
-  if (cmd?.toLowerCase() === "!help") {
-    await message.reply(HELP);
-    return;
-  }
-  const space = channel as TextChannel | ThreadChannel;
-  let session: ThreadSession;
-  try {
-    session = await getSession(space, workdirFor(parentId));
-  } catch (err) {
-    await message.reply(`**Can't reach hoocode:** ${err instanceof Error ? err.message : String(err)}`);
-    return;
-  }
-  switch (cmd?.toLowerCase()) {
-    case "!stop":
-      return session.abort();
-    case "!new":
-      clearSpace(session.workdir, space.id);
-      return session.newSession();
-    case "!status":
-      return session.status();
-    case "!verbose":
-      return session.toggleVerbose();
-    case "!model":
-      return session.chooseModel(arg);
-  }
-
-  // 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);
-  });
-}
-
-/** 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;
+if (stops.length === 0) {
+  console.error("No chat connected. Check the tokens in .env.");
+  process.exit(1);
 }
 
-/**
- * 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 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 s;
-}
-
-function shutdown() {
+async function shutdown() {
   console.log("Shutting down…");
-  for (const s of [...sessions.values()]) s.close();
-  for (const app of apps.values()) app.then((c) => c.close()).catch(() => {});
-  client.destroy().finally(() => process.exit(0));
+  await closeAll();
+  await Promise.allSettled(stops.map((stop) => stop()));
+  process.exit(0);
 }
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
-
-client.login(config.token);

package/src/mrkdwn.ts

@@ -0,0 +1,95 @@
+/**
+ * Discord-flavoured Markdown (what the session writes and the model answers
+ * in) → Slack mrkdwn.
+ *
+ * - `**bold**` → `*bold*`, `*italic*` / `_italic_` → `_italic_`, `~~x~~` → `~x~`
+ * - `# Heading` → `*Heading*`, `-# small` → plain line
+ * - `[text](<url>)` / `[text](url)` → `<url|text>`; bare URLs stay as they are
+ * - fenced code keeps its fence, minus the language (Slack shows it as text)
+ * - `&`, `<`, `>` are escaped everywhere, as Slack requires
+ */
+
+const escape = (s: string) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+/** Bold/italic markers become these while converting, so `*x*` from `**x**` isn't read as italic. */
+const B = "\u0001";
+
+export function toMrkdwn(md: string): string {
+  const out: string[] = [];
+  let inFence = false;
+  for (const line of md.split("\n")) {
+    const fence = line.trim().match(/^```/);
+    if (fence) {
+      // Slack has no language tags: ```ts → ```
+      out.push(inFence ? "```" : "```");
+      inFence = !inFence;
+      continue;
+    }
+    out.push(inFence ? escape(line) : convertLine(line));
+  }
+  return out.join("\n");
+}
+
+function convertLine(line: string): string {
+  const heading = line.match(/^#{1,6}\s+(.*)$/);
+  if (heading) return wrapBold(inline(heading[1]!));
+  const small = line.match(/^-#\s+(.*)$/);
+  if (small) return inline(small[1]!);
+  return inline(line);
+}
+
+/** A whole line in bold, unless it's bold already. */
+function wrapBold(text: string): string {
+  return /^\*[^*]+\*$/.test(text) ? text : `*${text}*`;
+}
+
+/** Inline formatting outside code spans; code spans are only escaped. */
+function inline(text: string): string {
+  return text
+    .split(/(`[^`]*`)/)
+    .map((part, i) => (i % 2 === 1 ? escape(part) : prose(part)))
+    .join("");
+}
+
+function prose(text: string): string {
+  const links: string[] = [];
+  // Links first (their text and URL must not be touched by escaping or emphasis).
+  let s = text.replace(/\[([^\]]+)\]\(<?([^)\s>]+)>?\)/g, (_, label: string, url: string) => {
+    links.push(`<${url.replace(/[<>|]/g, encodeURIComponent)}|${escape(label).replace(/\|/g, "¦")}>`);
+    return `\u0002${links.length - 1}\u0002`;
+  });
+  // Slack mentions (`<@U123>`) stay as they are, so a bot can tag another.
+  const mentions: string[] = [];
+  s = s.replace(/<@([UW][A-Z0-9]+)>/g, (m) => {
+    mentions.push(m);
+    return `\u0003${mentions.length - 1}\u0003`;
+  });
+  s = escape(s);
+  s = s
+    .replace(/\*\*(?=\S)(.+?)(?<=\S)\*\*/g, `${B}$1${B}`)
+    .replace(/__(?=\S)(.+?)(?<=\S)__/g, `${B}$1${B}`)
+    .replace(/(^|[^\w*])\*(?=\S)([^*]+?)(?<=\S)\*(?![\w*])/g, "$1_$2_")
+    .replace(/~~(?=\S)(.+?)(?<=\S)~~/g, "~$1~")
+    .replaceAll(B, "*");
+  return s
+    .replace(/\u0002(\d+)\u0002/g, (_, i: string) => links[Number(i)]!)
+    .replace(/\u0003(\d+)\u0003/g, (_, i: string) => mentions[Number(i)]!);
+}
+
+/**
+ * Slack message text (as typed by people) → plain text for the model:
+ * `<@U1>` → `@name`, `<#C1|dev>` → `#dev`, `<url|text>` → `text (url)`,
+ * entities unescaped. `name` resolves user ids (unknown ones stay as ids).
+ */
+export function fromMrkdwn(text: string, name: (userId: string) => string | undefined = () => undefined): string {
+  return text
+    .replace(/<@([UW][A-Z0-9]+)(?:\|([^>]+))?>/g, (_, id: string, label?: string) => `@${label ?? name(id) ?? id}`)
+    .replace(/<#([CG][A-Z0-9]+)(?:\|([^>]*))?>/g, (_, id: string, label?: string) => `#${label || id}`)
+    .replace(/<!(here|channel|everyone)(?:\|[^>]*)?>/g, "@$1")
+    .replace(/<!subteam\^[A-Z0-9]+(?:\|([^>]+))?>/g, (_, label?: string) => label ?? "@group")
+    .replace(/<(https?:[^>|]+)\|([^>]+)>/g, (_, url: string, label: string) => (label === url ? url : `${label} (${url})`))
+    .replace(/<(https?:[^>]+|mailto:[^>]+)>/g, "$1")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&amp;/g, "&");
+}

package/src/peers.ts

@@ -0,0 +1,65 @@
+/**
+ * Peer bots: other bots (e.g. a companion hoobot) that may call this one.
+ *
+ * Bots answering bots can loop forever, so each thread has a budget: a
+ * peer gets `PEER_TURNS` answers per thread. When it's used up, an allowed
+ * user is asked (Yes / No buttons) whether to grant `PEER_TURNS` more.
+ * A call from a person in the thread starts a fresh budget.
+ */
+export class TurnBudget {
+  private spaces = new Map<string, { used: number; limit: number }>();
+
+  constructor(readonly turns: number) {}
+
+  private get(space: string) {
+    let s = this.spaces.get(space);
+    if (!s) {
+      s = { used: 0, limit: this.turns };
+      this.spaces.set(space, s);
+      if (this.spaces.size > 1000) this.spaces.delete(this.spaces.keys().next().value!);
+    }
+    return s;
+  }
+
+  /** Use one peer turn; `false` when the budget is spent (nothing is used). */
+  take(space: string): boolean {
+    const s = this.get(space);
+    if (s.used >= s.limit) return false;
+    s.used++;
+    return true;
+  }
+
+  /** Allow `turns` more peer turns here. */
+  grant(space: string): void {
+    this.get(space).limit += this.turns;
+  }
+
+  /** A person called: start over. */
+  reset(space: string): void {
+    this.spaces.delete(space);
+  }
+
+  used(space: string): number {
+    return this.spaces.get(space)?.used ?? 0;
+  }
+}
+
+/**
+ * `@name` for a known peer → a real Slack mention (`<@U123>`), so the model
+ * can tag the other bot by name. Runs on mrkdwn (after conversion).
+ */
+export function linkMentions(mrkdwn: string, peers: Map<string, string>): string {
+  if (!peers.size) return mrkdwn;
+  // Code (fenced or inline) is left alone.
+  return mrkdwn
+    .split(/(```[\s\S]*?```|`[^`\n]*`)/)
+    .map((part, i) => {
+      if (i % 2 === 1) return part;
+      for (const [name, id] of peers) {
+        const re = new RegExp(`(^|[^\\w<@])@${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w-])`, "gi");
+        part = part.replace(re, `$1<@${id}>`);
+      }
+      return part;
+    })
+    .join("");
+}