thursday-agent 0.4.0 → 0.6.0

package/features/artifact/components/artifact-setting.tsx

@@ -15,7 +15,7 @@ import {
   Trash2,
   Video,
 } from "lucide-react";
-import { useState } from "react";
+import { Fragment, useState } from "react";
 import { queryKey } from "@/app/api/query-key";
 import { Button } from "@/components/ui/button";
 import { notify } from "@/components/ui/notify";
@@ -28,6 +28,8 @@ import type {
   ArtifactSet,
   ArtifactShelf,
 } from "@/features/artifact/artifact.schema";
+import type { Bot } from "@/features/bot/bot.schema";
+import { BotMark } from "@/features/bot/components/bot-mark";
 import {
   SettingError,
   SettingFilter,
@@ -44,14 +46,14 @@ import { revalidate, useServerRoute } from "@/lib/protocol/use-server-route";
 import { cn, formatBytes } from "@/lib/utils";
 
 /*
- * What the bots finished, listed the way they already file it: one entry at the
- * top of `artifacts/` is one artifact. A skill writes `artifacts/<name>.html`,
- * a job that makes a set writes `artifacts/<name>/`.
+ * What the bots finished, listed the way they file it: each bot writes into
+ * `artifacts/<bot>/`, and one entry there is one artifact. A skill writes
+ * `<name>.html`, a job that makes a set writes `<name>/`.
  *
  * So this is not Workspace pointed at one folder. There is no tree here: the
- * menu is flat and newest-first, and a folder does not open into another
- * listing — it opens as a sheet of what it holds, which is the thing a set of
- * pictures is for. Browsing a tree is Workspace's job.
+ * menu is newest-first under each bot's face, and a folder does not open into
+ * another listing — it opens as a sheet of what it holds, which is the thing a
+ * set of pictures is for. Browsing a tree is Workspace's job.
  */
 
 /** Every kind `viewKindOf` returns, plus the set. One icon table, as in Workspace. */
@@ -80,6 +82,7 @@ export function ArtifactSetting() {
     { keepPreviousData: true },
   );
 
+  const { data: bots } = useServerRoute<Bot[]>(queryKey.bot);
   const [reveal] = useServerAction(openFileAction);
 
   if (isLoading) return <SettingPanesSkeleton />;
@@ -89,7 +92,11 @@ export function ArtifactSetting() {
   const total = data?.total ?? 0;
   const needle = filter.trim().toLowerCase();
   const shown = needle
-    ? entries.filter((entry) => entry.name.toLowerCase().includes(needle))
+    ? entries.filter(
+        (entry) =>
+          entry.name.toLowerCase().includes(needle) ||
+          entry.bot?.toLowerCase().includes(needle),
+      )
     : entries;
 
   // A fresh row when the open one is still listed, so a rewrite shows through
@@ -130,13 +137,29 @@ export function ArtifactSetting() {
               {needle ? "Nothing matches" : "Nothing here yet"}
             </p>
           ) : (
-            shown.map((entry) => (
-              <MenuRow
-                key={entry.path}
-                entry={entry}
-                active={entry.path === picked?.path}
-                onPick={() => setReading({ row: entry, file: null })}
-              />
+            groupByBot(shown).map(({ bot, rows }) => (
+              <Fragment key={bot ?? ""}>
+                <span className="flex items-center gap-1.5 px-3 pt-3 pb-1 font-mono text-[10px] text-muted-foreground/60">
+                  {bot && (
+                    <BotMark
+                      size={12}
+                      seed={bot}
+                      {...markOf(bot, bots)}
+                      notify={false}
+                      className="shrink-0"
+                    />
+                  )}
+                  <span className="truncate">{bot ?? "Unsorted"}</span>
+                </span>
+                {rows.map((entry) => (
+                  <MenuRow
+                    key={entry.path}
+                    entry={entry}
+                    active={entry.path === picked?.path}
+                    onPick={() => setReading({ row: entry, file: null })}
+                  />
+                ))}
+              </Fragment>
             ))
           )}
 
@@ -170,6 +193,33 @@ export function ArtifactSetting() {
   );
 }
 
+/**
+ * Rows under the bot that made them, in the order the rows came: newest first,
+ * so the bot that handed something over last is on top. Loose rows are one group.
+ */
+function groupByBot(
+  entries: Artifact[],
+): { bot: string | null; rows: Artifact[] }[] {
+  const groups = new Map<string | null, Artifact[]>();
+  for (const entry of entries) {
+    const rows = groups.get(entry.bot) ?? [];
+    rows.push(entry);
+    groups.set(entry.bot, rows);
+  }
+  return [...groups].map(([bot, rows]) => ({ bot, rows }));
+}
+
+/** Icon from the bot list; the row only carries the name. A bot that is gone draws its seed alone. */
+function markOf(name: string, bots?: Bot[]) {
+  const icon = bots?.find((bot) => bot.name === name)?.icon;
+  return {
+    color: icon?.color,
+    shape: icon?.shape,
+    outline: icon?.outline,
+    paint: icon?.paint,
+  };
+}
+
 /** `4 artifacts · 34 files`, and what is not on screen. Counts rows, so it is free. */
 function countLine(shown: Artifact[], total: number, files: number): string {
   if (total === 0) return "empty";
@@ -247,7 +297,9 @@ function Reader({
   const confirmRemove = async (path: string) => {
     const confirmed = await notify.confirm({
       title: `Delete ${path.split("/").pop()}?`,
-      description: "It is deleted from disk for good.",
+      description: open
+        ? "It is deleted from disk for good."
+        : "The folder and everything in it are deleted from disk for good.",
       okText: "Delete",
       destructive: true,
     });
@@ -295,25 +347,23 @@ function Reader({
         >
           <FolderOpen />
         </Button>
-        {open && (
-          <Button
-            size="icon-sm"
-            variant="ghost"
-            aria-label="Delete"
-            loading={removing}
-            className="text-muted-foreground"
-            onClick={() => confirmRemove(open.path)}
-          >
-            <Trash2 />
-          </Button>
-        )}
+        <Button
+          size="icon-sm"
+          variant="ghost"
+          aria-label="Delete"
+          loading={removing}
+          className="text-muted-foreground"
+          onClick={() => confirmRemove(open?.path ?? row.path)}
+        >
+          <Trash2 />
+        </Button>
       </div>
 
       <div className="min-h-0 flex-1 overflow-auto">
         {open ? (
           <FilePreview path={open.path} bytes={open.bytes} />
         ) : (
-          <SetSheet name={row.name} onOpen={onOpen} />
+          <SetSheet path={row.path} onOpen={onOpen} />
         )}
       </div>
     </>
@@ -325,14 +375,14 @@ function Reader({
  * a set nobody opens costs one `readdir` for its count and nothing more.
  */
 function SetSheet({
-  name,
+  path,
   onOpen,
 }: {
-  name: string;
+  path: string;
   onOpen: (file: ArtifactFile) => void;
 }) {
   const { data, isLoading, error } = useServerRoute<ArtifactSet>(
-    queryKey.artifactSet(name, ARTIFACT_VIEW.setFiles),
+    queryKey.artifactSet(path, ARTIFACT_VIEW.setFiles),
   );
 
   if (isLoading) {
@@ -418,7 +468,7 @@ function Nothing({
       <p className="max-w-lg text-sm leading-relaxed text-muted-foreground">
         {empty
           ? "Nothing finished yet. When a bot ends a job with something to hand over — a page, a report, a set of pictures — it lands here."
-          : "Pick something on the left. A folder a bot filled is one row, and opens as a sheet."}
+          : "Pick something on the left. Each bot's work is under its face; a folder it filled is one row, and opens as a sheet."}
       </p>
       <Button variant="outline" onClick={onReveal}>
         <FolderOpen />

package/features/bot/bot.action.ts

@@ -7,20 +7,20 @@ import { publicError } from "@/lib/public-error";
 import {
   createBot,
   deleteBot,
-  findBot,
+  findJobBot,
   updateBot,
   writeBotMemoryOn,
 } from "./bot.query";
 import {
-  answerTask,
-  cancelTask,
-  removeFinishedTasks,
-  removeTask,
-  startTask,
+  answerThread,
+  cancelThread,
+  removeFinishedThreads,
+  removeThread,
+  startThread,
 } from "./bot.runner";
 import { BotFormSchema, botIconSchema } from "./bot.schema";
-import { findBotSeed, rollSeedColors } from "./bot.seed";
-import { markSeen, resolveTask } from "./task.query";
+import { findBotSeed, rollSeedIcons } from "./bot.seed";
+import { markSeen, resolveThread } from "./thread.query";
 
 export const createBotAction = serverAction(async (input: unknown) => {
   const form = BotFormSchema.parse(input);
@@ -41,8 +41,8 @@ const SeedPickSchema = z.object({
   name: z.string().trim().min(1).max(80),
   provider: textModelProviderSchema.nullish(),
   model: z.string().trim().min(1).max(80).nullish(),
-  /** The colour the intro already showed for this bot. Rolled here when the caller had no screen. */
-  color: botIconSchema.shape.color,
+  /** The face the intro already showed for this bot. Rolled here when the caller had no screen. */
+  icon: botIconSchema.optional(),
 });
 
 /**
@@ -53,9 +53,9 @@ const SeedPickSchema = z.object({
 export const createSeedBotsAction = serverAction(async (picks: unknown) => {
   const wanted = SeedPickSchema.array().max(20).parse(picks);
 
-  // Seeds carry no colour of their own (bot.seed); one roll covers the whole
-  // batch so bots made together never come out the same colour
-  const rolled = rollSeedColors();
+  // Seeds carry no face of their own (bot.seed); one roll covers the whole batch
+  // so bots made together never come out looking alike
+  const rolled = rollSeedIcons();
 
   const created: string[] = [];
   for (const [at, pick] of wanted.entries()) {
@@ -65,7 +65,7 @@ export const createSeedBotsAction = serverAction(async (picks: unknown) => {
       name: seed.name,
       description: seed.description,
       systemPrompt: seed.systemPrompt,
-      icon: { ...seed.icon, color: pick.color ?? rolled[at % rolled.length] },
+      icon: pick.icon ?? rolled[at % rolled.length],
       provider: pick.provider,
       model: pick.model,
       toolIds: [],
@@ -84,9 +84,9 @@ export const setBotMemoryOnAction = serverAction(async (on: unknown) => {
   await writeBotMemoryOn(on === true);
 });
 
-// Tasks are opened by the `delegate` tool during a call, or here when the user
+// Threads are opened by the `delegate` tool during a call, or here when the user
 // hands one over from the screen. Each returns at once, the run itself continues
-// in bot.runner behind `after()`.
+// as promises held by bot.runner.
 
 /** Words a label keeps; the rest of the message is the request, which the bot reads in full. */
 const LABEL_WORDS = 4;
@@ -103,14 +103,16 @@ function labelFor(request: string): string {
  * is the whole request — there is no conversation to draw the rest from, which is
  * why the box asks for a sentence rather than a word.
  */
-export const startTaskAction = serverAction(
+export const startThreadAction = serverAction(
   async (bot: string, request: string) => {
     const said = request.trim();
     if (!said) publicError("Nothing to hand over.");
-    const worker = await findBot(bot);
-    if (!worker) publicError(`No bot called "${bot}".`);
+    // Resolved as a delegated job is, so an install with no bots still has its worker
+    const worker = await findJobBot(bot);
+    if (!worker || worker.disabled)
+      publicError(`No enabled bot called "${bot}".`);
     const label = labelFor(said);
-    const id = await startTask({
+    const id = await startThread({
       bot: worker.name,
       request: said,
       label,
@@ -120,33 +122,38 @@ export const startTaskAction = serverAction(
   },
 );
 
-export const answerTaskAction = serverAction(
-  async (ref: string, answer: string) => {
-    const task = await resolveTask(ref);
-    if (!task) publicError(`No job called "${ref}".`);
+export const answerThreadAction = serverAction(
+  async (ref: string, answer: string, recipient?: string, replyTo?: string) => {
+    const thread = await resolveThread(ref);
+    if (!thread) publicError(`No job called "${ref}".`);
     if (!answer.trim()) publicError("Nothing to tell it.");
-    await answerTask(task.id, answer.trim());
-    return { id: task.id, label: task.label, status: "running" as const };
+    await answerThread(thread.id, answer.trim(), "user", recipient, replyTo);
+    return { id: thread.id, label: thread.label, status: "running" as const };
   },
 );
 
-export const cancelTaskAction = serverAction(async (ref: string) => {
-  const task = await resolveTask(ref);
-  if (!task) publicError(`No job called "${ref}".`);
-  await cancelTask(task.id);
-  return { id: task.id, label: task.label, status: "cancelled" as const };
+export const cancelThreadAction = serverAction(async (ref: string) => {
+  const thread = await resolveThread(ref);
+  if (!thread) publicError(`No job called "${ref}".`);
+  await cancelThread(thread.id);
+  return { id: thread.id, label: thread.label, status: "cancelled" as const };
 });
 
-/** Marks endings as had by the user: relayed on a call, or on a task list they opened. Batched, since both reach many at once. */
+/** Marks threads as read by the user: opened on screen. Their relays are settled with them (thread.query markSeen). */
 export const markSeenAction = serverAction(async (ids: string[]) => {
   await markSeen(ids.filter((id) => typeof id === "string" && id));
 });
 
-export const deleteTaskAction = serverAction(async (id: string) => {
-  if (!(await removeTask(id))) publicError("Task not found");
+export const deleteThreadAction = serverAction(async (id: string) => {
+  if (!(await removeThread(id))) publicError("Thread not found");
 });
 
 /** Empties the log of what is over. Running and waiting jobs are not touched. */
-export const clearFinishedTasksAction = serverAction(async () => {
-  return { removed: await removeFinishedTasks() };
+export const clearFinishedThreadsAction = serverAction(async () => {
+  return { removed: await removeFinishedThreads() };
+});
+
+export const acceptThreadRelaysAction = serverAction(async (ids: unknown) => {
+  const { acceptRoomRelays } = await import("./room.query");
+  await acceptRoomRelays(z.number().int().positive().array().parse(ids));
 });

package/features/bot/bot.memory.ts

@@ -1,6 +1,15 @@
-import { open, readdir, stat } from "node:fs/promises";
+import type { Stats } from "node:fs";
+import {
+  open,
+  readdir,
+  readFile,
+  rm,
+  stat,
+  utimes,
+  writeFile,
+} from "node:fs/promises";
 import { join } from "node:path";
-import { BOT_MEMORY_LISTED } from "@/config";
+import { BOT_MEMORY_LIMITS } from "@/config";
 import { botFolder, WORKSPACE } from "@/features/workspace/workspace";
 import type { BotMemory, BotMemoryFile } from "./bot.schema";
 
@@ -19,42 +28,150 @@ const HEAD_BYTES = 1024;
 
 /**
  * Newest first. `limit` is how many are read for their first line: the prompt lists
- * BOT_MEMORY_LISTED, the bot's page (Settings > Bots) as many as a Workspace folder shows.
+ * BOT_MEMORY_LIMITS.files, the bot's page (Settings > Bots) as many as a Workspace folder shows.
  */
 export async function listBotMemory(
   bot: string,
-  limit = BOT_MEMORY_LISTED,
+  limit = BOT_MEMORY_LIMITS.files,
 ): Promise<BotMemory> {
   const folder = botMemoryFolder(bot);
   const dir = join(WORKSPACE, folder);
-  const names = await readdir(dir).catch(() => []);
-  const found = await Promise.all(
-    names
-      .filter((name) => !name.startsWith("."))
-      .map(async (name) => {
-        const info = await stat(join(dir, name)).catch(() => null);
-        return info?.isFile()
-          ? { name, changed: info.mtimeMs, bytes: info.size }
-          : null;
-      }),
+  const files = (await readMemoryFolder(dir)).sort(
+    (a, b) => b.info.mtimeMs - a.info.mtimeMs,
   );
-  const files = found
-    .filter((file) => file !== null)
-    .sort((a, b) => b.changed - a.changed);
   const entries = await Promise.all(
     files.slice(0, limit).map(
-      async ({ name, changed, bytes }): Promise<BotMemoryFile> => ({
+      async ({ name, info }): Promise<BotMemoryFile> => ({
         file: name,
         path: `${folder}/${name}`,
         line: await firstLine(join(dir, name)),
-        at: new Date(changed),
-        bytes,
+        at: new Date(info.mtimeMs),
+        bytes: info.size,
       }),
     ),
   );
   return { folder, entries, total: files.length };
 }
 
+/** What counts as a memory file, for the listing and the limits alike: a plain file, not hidden. */
+async function readMemoryFolder(
+  dir: string,
+): Promise<{ name: string; info: Stats }[]> {
+  const names = await readdir(dir).catch(() => []);
+  const found = await Promise.all(
+    names
+      .filter((name) => !name.startsWith("."))
+      .map(async (name) => {
+        const info = await stat(join(dir, name)).catch(() => null);
+        return info?.isFile() ? { name, info } : null;
+      }),
+  );
+  return found.filter((file) => file !== null);
+}
+
+/**
+ * A bot's memory as it stood before a command, so what the command takes past
+ * BOT_MEMORY_LIMITS can be put back. A file already past the limit is held without its
+ * text: there is nothing within the limit to put back.
+ */
+export type HeldBotMemory = Map<
+  string,
+  {
+    text: string | null;
+    size: number;
+    mtimeMs: number;
+    atime: Date;
+    mtime: Date;
+  }
+>;
+
+export async function holdBotMemory(bot: string): Promise<HeldBotMemory> {
+  const dir = join(WORKSPACE, botMemoryFolder(bot));
+  const held: HeldBotMemory = new Map();
+  await Promise.all(
+    (await readMemoryFolder(dir)).map(async ({ name, info }) => {
+      // More than four bytes a character is past the limit without reading it
+      const text =
+        info.size > BOT_MEMORY_LIMITS.chars * 4
+          ? null
+          : await readFile(join(dir, name), "utf8").catch(() => null);
+      held.set(name, {
+        text:
+          text !== null && charCount(text) <= BOT_MEMORY_LIMITS.chars
+            ? text
+            : null,
+        size: info.size,
+        mtimeMs: info.mtimeMs,
+        atime: info.atime,
+        mtime: info.mtime,
+      });
+    }),
+  );
+  return held;
+}
+
+/**
+ * Puts back what was done to a bot's memory past BOT_MEMORY_LIMITS since `held`, and says
+ * so in lines the bot can act on; null when nothing went past. A file written past `chars`
+ * goes back to what it was, or is removed when it is new; new files that take the folder
+ * past `files` are removed. A file that was already past the limit stays and is named.
+ */
+export async function keepBotMemory(
+  bot: string,
+  held: HeldBotMemory,
+): Promise<string | null> {
+  const folder = botMemoryFolder(bot);
+  const dir = join(WORKSPACE, folder);
+  const { files: most, chars } = BOT_MEMORY_LIMITS;
+  const lines: string[] = [];
+  const fresh: string[] = [];
+  let count = 0;
+
+  for (const { name, info } of await readMemoryFolder(dir)) {
+    count += 1;
+    const was = held.get(name);
+    if (was && was.size === info.size && was.mtimeMs === info.mtimeMs) {
+      continue;
+    }
+    const path = join(dir, name);
+    const length = charCount(await readFile(path, "utf8").catch(() => ""));
+    if (length <= chars) {
+      if (!was) fresh.push(name);
+      continue;
+    }
+    const size = `${length.toLocaleString("en-US")} characters, past the ${chars.toLocaleString("en-US")} a memory file holds`;
+    if (!was) {
+      await rm(path, { force: true });
+      count -= 1;
+      lines.push(
+        `Not kept: \`${folder}/${name}\` came to ${size}, so it was removed. Write it again shorter.`,
+      );
+    } else if (was.text !== null) {
+      await writeFile(path, was.text);
+      await utimes(path, was.atime, was.mtime);
+      lines.push(
+        `Not kept: \`${folder}/${name}\` came to ${size}, so it is back as it was. Write it again shorter.`,
+      );
+    } else {
+      lines.push(`\`${folder}/${name}\` is ${size}. Shorten it.`);
+    }
+  }
+
+  if (count > most && fresh.length) {
+    await Promise.all(
+      fresh.map((name) => rm(join(dir, name), { force: true })),
+    );
+    const named = fresh.map((name) => `\`${folder}/${name}\``).join(", ");
+    lines.push(
+      `Not kept: your memory holds ${most} files at most and this made ${count}, so ${named} ${fresh.length === 1 ? "was" : "were"} removed. Delete or merge files no longer worth keeping, then write it again.`,
+    );
+  }
+  return lines.length ? lines.join("\n") : null;
+}
+
+/** A file's length as BOT_MEMORY_LIMITS counts it. */
+const charCount = (text: string): number => [...text.trim()].length;
+
 /**
  * The line a file is listed by: its first, without a heading's `#`. A file that opens with
  * frontmatter anyway — a shape models are trained on — is listed by its `description`, or by

package/features/bot/bot.query.ts

@@ -4,10 +4,11 @@ import {
   botMcpToolTable,
   botTable,
   mcpToolTable,
-  taskTable,
+  threadTable,
 } from "@/database/tables";
 import type { TextModelProviderId } from "@/features/ai/model.schema";
 import { readConfig, writeConfig } from "@/features/config/config.query";
+import { botFolderName } from "@/features/workspace/workspace";
 import {
   BOT_MEMORY_KEY,
   type BotForm,
@@ -98,17 +99,17 @@ export async function findAllBots() {
       })
       .from(botMcpToolTable)
       .innerJoin(mcpToolTable, eq(botMcpToolTable.toolId, mcpToolTable.id)),
-    // Grouped by name; tasks point at bots by name (tables.ts task.bot)
+    // Grouped by name; threads point at bots by name (tables.ts thread.bot)
     database
       .select({
-        bot: taskTable.bot,
-        input: sql<number>`coalesce(sum(${taskTable.inputTokens}), 0)`,
-        output: sql<number>`coalesce(sum(${taskTable.outputTokens}), 0)`,
+        bot: threadTable.bot,
+        input: sql<number>`coalesce(sum(${threadTable.inputTokens}), 0)`,
+        output: sql<number>`coalesce(sum(${threadTable.outputTokens}), 0)`,
         // Raw max over a timestamp column arrives as integer seconds
-        lastJobAt: sql<number | null>`max(${taskTable.updatedAt})`,
+        lastJobAt: sql<number | null>`max(${threadTable.updatedAt})`,
       })
-      .from(taskTable)
-      .groupBy(taskTable.bot),
+      .from(threadTable)
+      .groupBy(threadTable.bot),
   ]);
 
   const byBot = new Map<string, PinnedTool[]>();
@@ -155,9 +156,25 @@ export async function findBot(name: string) {
   return bot ?? null;
 }
 
-/** Returns null when the name is taken: two bots with one name would be a coin toss at delegate time. */
+/**
+ * Every name that has folders in the workspace: the rows, switched off or not,
+ * and DEFAULT_BOT, which works without one.
+ */
+export async function listBotNames(): Promise<string[]> {
+  const rows = await database.select({ name: botTable.name }).from(botTable);
+  return [...new Set([...rows.map((row) => row.name), DEFAULT_BOT.name])];
+}
+
+/**
+ * Returns null when the name is taken: two bots with one name would be a coin
+ * toss at delegate time, and two whose names give one folder would share their
+ * memory and artifacts (workspace.ts botFolderName).
+ */
 export async function createBot(form: BotForm) {
-  if (await findBot(form.name)) return null;
+  const folder = botFolderName(form.name).toLowerCase();
+  const rows = await database.select({ name: botTable.name }).from(botTable);
+  if (rows.some((row) => botFolderName(row.name).toLowerCase() === folder))
+    return null;
 
   const { toolIds, ...values } = pickedModel(form);
   const [bot] = await database.insert(botTable).values(values).returning();
@@ -170,7 +187,7 @@ export async function updateBot(name: string, patch: Partial<BotForm>) {
   // (pickedModel reads a missing field as null and would clear the other)
   const { toolIds, ...values } =
     "provider" in patch || "model" in patch ? pickedModel(patch) : patch;
-  // Renaming would orphan pinned tools and every task sent to the old name, so name is never patched
+  // Renaming would orphan pinned tools and every thread sent to the old name, so name is never patched
   delete (values as { name?: string }).name;
 
   const [bot] = Object.keys(values).length