thursday-agent 0.2.0 → 0.4.0

package/features/thursday/thursday.action.ts

@@ -1,7 +1,6 @@
 "use server";
 
 import { asSchema } from "ai";
-import { after } from "next/server";
 import z from "zod";
 import { loadTools } from "@/features/ai/load-tools";
 import {
@@ -14,9 +13,6 @@ import { removeTask } from "@/features/bot/bot.runner";
 import { listAllTaskIds } from "@/features/bot/task.query";
 import { readConfig } from "@/features/config/config.query";
 import { deleteAllNotes } from "@/features/memory/memory.query";
-import { startTidy, stopTidy } from "@/features/memory/memory.tidy";
-import { deleteAllTidyRuns } from "@/features/memory/tidy.query";
-import { logger } from "@/lib/logger";
 import { serverAction } from "@/lib/protocol/server-action";
 import { publicError } from "@/lib/public-error";
 import { issueClientSecret } from "@/lib/realtime/client-secret";
@@ -141,13 +137,8 @@ export const saveTurnsAction = serverAction(
   },
 );
 
-/** Ending the call is what may set a read-back going (memory.tidy); it runs behind the response. */
 export const endCallAction = serverAction(async (callId: string) => {
-  if (!(await endCall(callId))) return;
-  after(async () => {
-    const outcome = await startTidy();
-    if (outcome !== "started") logger.debug(`tidy: not now (${outcome})`);
-  });
+  await endCall(callId);
 });
 
 /**
@@ -160,25 +151,29 @@ export const deleteCallAction = serverAction(async (callId: string) => {
   }
 });
 
+/**
+ * Deletes every ended call and its turns; returns how many went. A call still
+ * on the line stays, as it does for one (deleteCall).
+ */
+export const deleteEndedCallsAction = serverAction(async () =>
+  deleteEndedCalls(),
+);
+
 /**
  * Wipes what the app has kept of its own use: every ended call and its turns,
- * every job and its thread, every memory note, and the read-back log. Keys,
- * bots and connectors stay — the set `pnpm reset` calls History.
+ * every job and its thread, and every memory note. Keys, bots and connectors
+ * stay — the set `pnpm reset` calls History.
  *
  * History is not one domain, so this reaches into three and each clears its own
  * rows. Live work is stopped before its row goes: `removeTask` aborts a running
- * job and closes its shell, and a read-back in flight would otherwise write
- * notes back after they were deleted.
+ * job and closes its shell.
  */
 export const resetHistoryAction = serverAction(async () => {
-  await stopTidy("History was reset.");
-
   const taskIds = await listAllTaskIds();
   for (const id of taskIds) await removeTask(id);
 
   const calls = await deleteEndedCalls();
   const notes = await deleteAllNotes();
-  await deleteAllTidyRuns();
 
   return { calls, tasks: taskIds.length, notes };
 });

package/features/thursday/thursday.query.ts

@@ -7,12 +7,14 @@ import {
   isNotNull,
   isNull,
   lt,
+  sql,
 } from "drizzle-orm";
+import { CALL_HISTORY_PAGE } from "@/config";
 import { database } from "@/database/db";
 import { callMessageTable, callTable } from "@/database/tables";
+import { listCallJobs } from "@/features/bot/task.query";
 import { readConfig, writeConfig } from "@/features/config/config.query";
 import {
-  CALL_HISTORY_PAGE,
   type CallRecord,
   type CallTurn,
   isSkillsOn,
@@ -139,6 +141,52 @@ export async function listCallTurns(
     .map((row) => ({ role: row.role as "user" | "assistant", text: row.text }));
 }
 
+/**
+ * One page of a call, every turn in order, tool turns included; null when the
+ * call is gone. Tool turns keep their name and nothing else is read by the
+ * caller (ai/tools/memory.tool), but the row carries it all.
+ */
+export async function readCallConversation(
+  callId: string,
+  page: number,
+  size: number,
+): Promise<{
+  startedAt: Date;
+  total: number;
+  turns: {
+    role: "user" | "assistant" | "tool";
+    tool: string | null;
+    text: string;
+  }[];
+} | null> {
+  const [call] = await database
+    .select({ startedAt: callTable.startedAt })
+    .from(callTable)
+    .where(eq(callTable.id, callId));
+  if (!call) return null;
+
+  const [counted] = await database
+    .select({ total: sql<number>`count(*)` })
+    .from(callMessageTable)
+    .where(eq(callMessageTable.callId, callId));
+  const turns = await database
+    .select({
+      role: callMessageTable.role,
+      tool: callMessageTable.tool,
+      text: callMessageTable.text,
+    })
+    .from(callMessageTable)
+    .where(eq(callMessageTable.callId, callId))
+    .orderBy(asc(callMessageTable.seq))
+    .limit(size)
+    .offset((page - 1) * size);
+  return {
+    startedAt: call.startedAt,
+    total: Number(counted?.total ?? 0),
+    turns,
+  };
+}
+
 /**
  * Whether any call is open, not whether a given job's call is. A tab that
  * vanished leaves its row open, so boot runs `sweepCalls` first.
@@ -231,81 +279,24 @@ export async function listCallHistory(options: {
     else turns.set(callId, [turn]);
   }
 
+  // A job belongs to the call that opened it, and this is how the log still says
+  // what became of it once the call is over.
+  const jobs = await listCallJobs(calls.map((call) => call.id));
+
   return calls.map((call) => ({
     ...call,
     turns: turns.get(call.id) ?? [],
+    jobs: jobs
+      .filter((job) => job.callId === call.id)
+      .map((job) => ({
+        id: job.id,
+        label: job.label,
+        status: job.status,
+        outcome: job.outcome,
+      })),
   }));
 }
 
-// What reading calls back needs (features/memory/memory.tidy): the turns owed,
-// and the stamp that says they have been read.
-
-/** One spoken turn owed to a read-back, with the call it came from. */
-export type OwedTurn = {
-  callId: string;
-  startedAt: Date;
-  role: "user" | "assistant";
-  text: string;
-};
-
-/**
- * Every spoken turn of ended calls not read back yet, oldest first. Tool turns
- * are left out: they carry arguments, not anything said. A call with no user
- * turn still counts nothing towards a read but is stamped with the rest.
- */
-export async function listOwedTurns(): Promise<OwedTurn[]> {
-  const rows = await database
-    .select({
-      callId: callTable.id,
-      startedAt: callTable.startedAt,
-      role: callMessageTable.role,
-      text: callMessageTable.text,
-    })
-    .from(callTable)
-    .innerJoin(callMessageTable, eq(callMessageTable.callId, callTable.id))
-    .where(
-      and(
-        isNotNull(callTable.endedAt),
-        isNull(callTable.tidiedAt),
-        inArray(callMessageTable.role, ["user", "assistant"]),
-      ),
-    )
-    .orderBy(asc(callTable.startedAt), asc(callMessageTable.seq));
-
-  return rows.map((row) => ({
-    callId: row.callId,
-    startedAt: row.startedAt,
-    role: row.role as "user" | "assistant",
-    text: row.text,
-  }));
-}
-
-/** Ids of every ended call not read back yet. A read stamps all of them, including the ones it dropped. */
-export async function listUnreadCallIds(): Promise<string[]> {
-  const rows = await database
-    .select({ id: callTable.id })
-    .from(callTable)
-    .where(and(isNotNull(callTable.endedAt), isNull(callTable.tidiedAt)))
-    .orderBy(asc(callTable.startedAt));
-  return rows.map((row) => row.id);
-}
-
-export async function markCallsRead(ids: string[]) {
-  if (!ids.length) return;
-  await database
-    .update(callTable)
-    .set({ tidiedAt: new Date() })
-    .where(inArray(callTable.id, ids));
-}
-
-/** Stamps every ended call as read, so switching the setting on starts from now. */
-export async function markEveryCallRead() {
-  await database
-    .update(callTable)
-    .set({ tidiedAt: new Date() })
-    .where(and(isNotNull(callTable.endedAt), isNull(callTable.tidiedAt)));
-}
-
 /**
  * Every call that has ended, and its turns (cascade). A call still on the line
  * stays: its tab is still writing turns against the row (see `deleteCall`).

package/features/thursday/thursday.schema.ts

@@ -1,9 +1,10 @@
 import z from "zod";
+import { ASCII_FACE } from "@/config";
 import {
   type SpeachModelProviderId,
   speachModelRefSchema,
 } from "@/features/ai/model.schema";
-import { botIconSchema } from "@/features/bot/bot.schema";
+import { botIconSchema, type TaskStatus } from "@/features/bot/bot.schema";
 import { ASCII_CHARSETS, FACE_KINDS } from "@/features/thursday/face.const";
 import type { DateLike } from "@/lib/date-like";
 import { COMMON_VALIDATE } from "@/lib/limits";
@@ -48,10 +49,18 @@ export type CallHandshake = {
  */
 export const ThursdayFaceSchema = botIconSchema.extend({
   kind: z.enum(FACE_KINDS).default("ascii"),
-  charset: z.enum(ASCII_CHARSETS).default("ascii"),
+  charset: z.enum(ASCII_CHARSETS).default(ASCII_FACE.charset),
   /** Glyph size in px. */
-  fontSize: z.number().min(4).max(16).default(8),
-  density: z.number().min(0.6).max(2).default(1.4),
+  fontSize: z
+    .number()
+    .min(ASCII_FACE.fontSize.min)
+    .max(ASCII_FACE.fontSize.max)
+    .default(ASCII_FACE.fontSize.default),
+  density: z
+    .number()
+    .min(ASCII_FACE.density.min)
+    .max(ASCII_FACE.density.max)
+    .default(ASCII_FACE.density.default),
 });
 
 export type ThursdayFace = z.infer<typeof ThursdayFaceSchema>;
@@ -177,7 +186,11 @@ export type CallRecord = {
   /** null when the hang-up was never recorded. */
   endedAt: DateLike | null;
   turns: (CallTurn & { at: DateLike })[];
+  /** Jobs this call opened, as they stand now; the log draws each under the line that opened it. */
+  jobs: {
+    id: string;
+    label: string;
+    status: TaskStatus;
+    outcome: string | null;
+  }[];
 };
-
-/** History page size in calls, not rows; each call carries every turn. */
-export const CALL_HISTORY_PAGE = 10;

package/features/thursday/tool-line.ts

@@ -6,15 +6,56 @@ const LINES: Record<string, string> = {
   [TOOL_NAMES.memory_recall]: "Checking your notes",
   [TOOL_NAMES.memory_remember]: "Noting that down",
   [TOOL_NAMES.memory_forget]: "Forgetting that",
-  [TOOL_NAMES.memory_show]: "Putting your notes on screen",
   [TOOL_NAMES.bash]: "Doing it on this computer",
   [TOOL_NAMES.web_search]: "Searching the web",
   [TOOL_NAMES.load_skill]: "Reading how to do this",
   [TOOL_NAMES.end_call]: "Ending the call",
 };
 
+/**
+ * How much of a fact the line carries. What is being written is the one thing
+ * on this screen the user cannot check afterwards without opening the note, so
+ * it is said as it happens — but the row is one line that also carries the
+ * path and the tool's name, and a fact cut mid-word reads as a bug rather than
+ * a quotation.
+ */
+const FACT_MAX = 28;
+
+function snippet(text: string): string {
+  const said = text.trim().replace(/\s+/g, " ");
+  if (said.length <= FACT_MAX) return said;
+  const cut = said.slice(0, FACT_MAX);
+  const space = cut.lastIndexOf(" ");
+  return `${(space > FACT_MAX / 2 ? cut.slice(0, space) : cut).trimEnd()}…`;
+}
+
+/** The first fact of a `memory_remember` call, while the arguments are whole enough to read. */
+function firstFact(
+  args: Record<string, unknown>,
+): { text: string; more: number } | null {
+  if (!Array.isArray(args.facts)) return null;
+  const texts = args.facts
+    .map((fact) =>
+      fact &&
+      typeof fact === "object" &&
+      typeof (fact as { text?: unknown }).text === "string"
+        ? (fact as { text: string }).text.trim()
+        : "",
+    )
+    .filter(Boolean);
+  return texts.length ? { text: texts[0], more: texts.length - 1 } : null;
+}
+
 /** Lines that need the arguments; arguments may still be streaming in. */
 function fromArgs(name: string, args: Record<string, unknown>): string | null {
+  if (name === TOOL_NAMES.memory_remember) {
+    const path = typeof args.path === "string" ? args.path.trim() : "";
+    const fact = firstFact(args);
+    if (!path) return null;
+    if (!fact) return `Noting that under ${path}`;
+    const more = fact.more > 0 ? ` (+${fact.more})` : "";
+    return `Noting under ${path}: ${snippet(fact.text)}${more}`;
+  }
   if (name === TOOL_NAMES.delegate) {
     const bot = typeof args.bot === "string" ? args.bot.trim() : "";
     return bot ? `Handing this to ${bot}` : "Handing this over";
@@ -35,20 +76,52 @@ function fromServer(name: string): string | null {
   return `Reaching ${name.slice(0, at).replace(/[-_]/g, " ")}`;
 }
 
+/** Arguments as an object, or null while they are still streaming in. */
+function parseArgs(args?: string): Record<string, unknown> | null {
+  if (!args) return null;
+  try {
+    const value: unknown = JSON.parse(args);
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return value as Record<string, unknown>;
+    }
+  } catch {
+    // Partial or non-JSON arguments: fall back to the name-only line.
+  }
+  return null;
+}
+
 export function toolLine(name: string, args?: string): string | null {
   if (name === TOOL_NAMES.tool_search || name === TOOL_NAMES.tool_call) {
     return "Reaching a connected service";
   }
-  let parsed: Record<string, unknown> | null = null;
-  if (args) {
-    try {
-      const value: unknown = JSON.parse(args);
-      if (value && typeof value === "object" && !Array.isArray(value)) {
-        parsed = value as Record<string, unknown>;
-      }
-    } catch {
-      // Partial or non-JSON arguments: fall back to the name-only line.
-    }
-  }
+  const parsed = parseArgs(args);
   return (parsed && fromArgs(name, parsed)) ?? LINES[name] ?? fromServer(name);
 }
+
+/**
+ * The bot a call hands work to, when it names one. The row draws that bot's own
+ * face instead of a glyph: who it went to is a face everywhere else in the app.
+ */
+export function toolBot(name: string, args?: string): string | null {
+  if (name !== TOOL_NAMES.delegate && name !== TOOL_NAMES.ask_bot) return null;
+  const bot = parseArgs(args)?.bot;
+  return typeof bot === "string" && bot.trim() ? bot.trim() : null;
+}
+
+/**
+ * The label a `delegate` call was made under, or null for any other turn. It is
+ * how a job is found again from the line that opened it — in her prompt and in
+ * the call log alike.
+ */
+export function delegatedLabel(
+  tool: string | null | undefined,
+  text: string,
+): string | null {
+  if (tool !== TOOL_NAMES.delegate) return null;
+  try {
+    const said = JSON.parse(text) as { label?: unknown };
+    return typeof said.label === "string" ? said.label : null;
+  } catch {
+    return null;
+  }
+}