@saadnvd1/agent-os 0.3.673 → 0.3.680

package/lib/search/conversations/searchConversations.ts

@@ -0,0 +1,151 @@
+import { getDb } from "@/lib/db";
+import { buildMatchQuery } from "./buildMatchQuery";
+import { indexProgress } from "./backfill";
+import type {
+  ConversationGroup,
+  ConversationHit,
+  SearchResponse,
+  SearchScope,
+  SnippetSegment,
+} from "./types";
+
+// Best matches pulled before they are grouped by conversation.
+const CANDIDATES = 200;
+const HITS_PER_SESSION = 3;
+export const MAX_GROUPS = 30;
+
+const OPEN = "\u0002";
+const CLOSE = "\u0003";
+
+interface Row {
+  session_id: string;
+  item_id: string;
+  snippet: string;
+  kind: "user" | "assistant";
+  created_at: number | null;
+  name: string;
+  status: string;
+  task_status: string | null;
+  archived_at: string | null;
+  updated_at: string | null;
+  project_id: string | null;
+  project_name: string | null;
+  workspace_id: string | null;
+  workspace_name: string | null;
+}
+
+export function parseSnippet(raw: string): SnippetSegment[] {
+  const out: SnippetSegment[] = [];
+  let hit = false;
+  let text = "";
+  for (const ch of raw) {
+    if (ch === OPEN || ch === CLOSE) {
+      if (text) out.push({ text, hit });
+      text = "";
+      hit = ch === OPEN;
+    } else text += ch;
+  }
+  if (text) out.push({ text, hit });
+  return out;
+}
+
+// done/dropped/merged tasks and archived sessions keep their conversation,
+// so the label says what became of the session.
+function statusOf(r: Row): string {
+  if (r.archived_at) return "archived";
+  if (r.task_status && r.task_status !== "running") return r.task_status;
+  return r.status;
+}
+
+export function searchConversations(
+  q: string,
+  scope: SearchScope,
+  page: { offset?: number; limit?: number } = {}
+): SearchResponse {
+  const started = performance.now();
+  const parsed = buildMatchQuery(q);
+  const empty: SearchResponse = {
+    groups: [],
+    more: false,
+    tookMs: 0,
+    indexing: indexProgress(),
+    terms: [],
+  };
+  if (!parsed) return empty;
+
+  const where: string[] = [];
+  const args: unknown[] = [parsed.match];
+  if (scope.workspace !== "all") {
+    where.push(`COALESCE(s.workspace_id, p.workspace_id) = ?`);
+    args.push(scope.workspace);
+  }
+  if (scope.project) {
+    where.push(`s.project_id = ?`);
+    args.push(scope.project);
+  }
+  args.push(CANDIDATES);
+  const rows = getDb()
+    .prepare(
+      `WITH hits AS (
+         SELECT k.session_id, k.item_id, bm25(chat_search) AS rank,
+                snippet(chat_search, 0, '${OPEN}', '${CLOSE}', '…', 18) AS snippet
+         FROM chat_search
+         JOIN chat_search_keys k ON k.id = chat_search.rowid
+         JOIN sessions s ON s.id = k.session_id
+         LEFT JOIN projects p ON p.id = s.project_id
+         WHERE chat_search MATCH ? ${where.map((w) => `AND ${w}`).join(" ")}
+         ORDER BY rank LIMIT ?
+       )
+       SELECT h.session_id, h.item_id, h.snippet, c.kind,
+              json_extract(c.data, '$.createdAt') AS created_at,
+              s.name, s.status, s.task_status, s.archived_at, s.updated_at,
+              s.project_id, p.name AS project_name,
+              COALESCE(s.workspace_id, p.workspace_id) AS workspace_id,
+              w.name AS workspace_name
+       FROM hits h
+       JOIN chat_items c ON c.session_id = h.session_id AND c.item_id = h.item_id
+       JOIN session_rows s ON s.id = h.session_id
+       LEFT JOIN projects p ON p.id = s.project_id
+       LEFT JOIN workspaces w ON w.id = COALESCE(s.workspace_id, p.workspace_id)
+       ORDER BY h.rank`
+    )
+    .all(...args) as Row[];
+
+  const groups = new Map<string, ConversationGroup>();
+  for (const r of rows) {
+    let g = groups.get(r.session_id);
+    if (!g) {
+      g = {
+        sessionId: r.session_id,
+        name: r.name,
+        projectId: r.project_id,
+        projectName: r.project_name,
+        workspaceId: r.workspace_id,
+        workspaceName: r.workspace_name,
+        status: statusOf(r),
+        updatedAt: r.updated_at,
+        hits: [],
+      };
+      groups.set(r.session_id, g);
+    }
+    if (g.hits.length < HITS_PER_SESSION) {
+      const hit: ConversationHit = {
+        itemId: r.item_id,
+        role: r.kind,
+        createdAt: r.created_at,
+        snippet: parseSnippet(r.snippet),
+      };
+      g.hits.push(hit);
+    }
+  }
+  const all = [...groups.values()];
+  const offset = Math.max(0, page.offset ?? 0);
+  const limit = Math.min(MAX_GROUPS, Math.max(1, page.limit ?? 20));
+  return {
+    groups: all.slice(offset, offset + limit),
+    more: all.length > offset + limit,
+    tookMs: Math.round((performance.now() - started) * 10) / 10,
+    indexing: indexProgress(),
+    terms: parsed.terms,
+  };
+}

package/lib/search/conversations/types.ts

@@ -0,0 +1,45 @@
+export type SnippetSegment = { text: string; hit: boolean };
+
+export interface ConversationHit {
+  itemId: string;
+  role: "user" | "assistant";
+  createdAt: number | null;
+  snippet: SnippetSegment[];
+}
+
+export interface ConversationGroup {
+  sessionId: string;
+  name: string;
+  projectId: string | null;
+  projectName: string | null;
+  workspaceId: string | null;
+  workspaceName: string | null;
+  status: string;
+  updatedAt: string | null;
+  hits: ConversationHit[];
+}
+
+export interface SearchScope {
+  // A workspace id, or "all".
+  workspace: string;
+  project?: string;
+}
+
+export interface SearchResponse {
+  groups: ConversationGroup[];
+  // More sessions exist past this page.
+  more: boolean;
+  tookMs: number;
+  // The first backfill is still running, so older conversations may be missing.
+  indexing: number | null;
+  // The words to mark in a preview.
+  terms: string[];
+}
+
+export interface ContextItem {
+  id: string;
+  role: "user" | "assistant";
+  text: string;
+  createdAt: number | null;
+  hit: boolean;
+}

package/lib/sidebar/row-actions.ts

@@ -1,19 +1,30 @@
 import type { Session } from "@/lib/db/types";
+import { isOverTask, isRestorableTask } from "@/lib/tasks/restorable";
+import type { TaskState } from "@/lib/tasks/state";
 
 // What a row's ⋯ menu offers to finish it: Done (merge through the gates,
-// stop, leave it on the Done shelf) for a task, Archive (put it away) for
-// every session but an orchestrator. A plain session is finished with Mark
-// done, so it only gets Archive here. A task that is already done is
-// restored instead (its worktree and conversation come back).
+// stop, leave it on the Done shelf) for a live task, Archive (put it away)
+// for every session but an orchestrator. A plain session is finished with
+// Mark done, so it only gets Archive here. A task that has ended is never
+// finished again: a dropped or done one is restored (exactly what
+// resurrectSession accepts), a merged or moved one only archived.
 export type FinishAction = "done" | "restore" | "archive";
 
 export function finishActions(
   session: Pick<Session, "role" | "task_status">,
-  plain: boolean
+  plain: boolean,
+  derived?: TaskState
 ): FinishAction[] {
   if (session.role === "orchestrator") return [];
   if (plain) return ["archive"];
-  return session.task_status === "done"
-    ? ["restore", "archive"]
-    : ["done", "archive"];
+  if (isRestorableTask(session.task_status)) return ["restore", "archive"];
+  // The PR can merge before the status catches up.
+  if (
+    isOverTask(session.task_status) ||
+    derived === "merged" ||
+    derived === "dropped" ||
+    derived === "done"
+  )
+    return ["archive"];
+  return ["done", "archive"];
 }

package/lib/sidebar/row-menu.ts

@@ -94,7 +94,7 @@ function group(
 export function rowMenu(input: RowMenuInput): RowMenuPlan {
   const { session: s, row, remote } = input;
   const plain = !!row && !row.task && !s.task_status;
-  const finish = finishActions(s, plain);
+  const finish = finishActions(s, plain, row?.task);
   const sections: RowMenuEntry[][] = [];
 
   // A quick change has no agent: its PR and the ways to finish it.

package/lib/tasks/restorable.ts

@@ -0,0 +1,16 @@
+// Which task statuses are over, and which of those resurrect will bring
+// back. One rule for the Restore button and for resurrectSession.
+// Client-safe: no database.
+
+// A dropped or done task keeps its branch and conversation, so it restores.
+export const RESTORABLE_TASK = new Set(["dropped", "done"]);
+
+// A merged task's work is in the base branch; a moved one runs elsewhere.
+// Neither restores, and neither is finished again.
+const OVER_TASK = new Set([...RESTORABLE_TASK, "merged", "moved"]);
+
+export const isRestorableTask = (status: string | null | undefined) =>
+  !!status && RESTORABLE_TASK.has(status);
+
+export const isOverTask = (status: string | null | undefined) =>
+  !!status && OVER_TASK.has(status);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.673",
+  "version": "0.3.680",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/scripts/bench-conversation-search.ts

@@ -0,0 +1,73 @@
+// Times conversation search on a copy of a real database.
+//   npx tsx scripts/bench-conversation-search.ts <path to agent-os.db>
+// The source is only read (SQLite's online backup); everything else happens on
+// the copy, which is removed afterwards.
+import Database from "better-sqlite3";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const source = process.argv[2];
+if (!source) {
+  console.error("usage: bench-conversation-search.ts <agent-os.db>");
+  process.exit(2);
+}
+const dir = mkdtempSync(join(tmpdir(), "aos-bench-"));
+const copy = join(dir, "bench.db");
+
+const QUERIES = [
+  "co",
+  "the",
+  "compac",
+  "worktree",
+  '"merge gate"',
+  "sqlite fts",
+  "orchestrator brake",
+  "pull request",
+  "a-b: c++",
+  "xyzzyplugh",
+];
+const RUNS = 20;
+
+async function main() {
+  const src = new Database(source, { readonly: true });
+  await src.backup(copy);
+  src.close();
+  process.env.DB_PATH = copy;
+  const { getDb } = await import("../lib/db");
+  const { backfillStep } = await import("../lib/search/conversations/backfill");
+  const { searchConversations } =
+    await import("../lib/search/conversations/searchConversations");
+  const db = getDb();
+  const t0 = performance.now();
+  while (!backfillStep(db));
+  const backfillMs = Math.round(performance.now() - t0);
+  const rows = db
+    .prepare(`SELECT COUNT(*) AS n FROM chat_search_keys`)
+    .get() as { n: number };
+  const size = db
+    .prepare(
+      `SELECT SUM(pgsize) AS b FROM dbstat WHERE name LIKE 'chat_search%'`
+    )
+    .get() as { b: number };
+  console.log(
+    `indexed ${rows.n} messages in ${backfillMs} ms; index ${(size.b / 1048576).toFixed(1)} MB`
+  );
+  for (const q of QUERIES) {
+    const ms: number[] = [];
+    let groups = 0;
+    for (let i = 0; i < RUNS; i++) {
+      const t = performance.now();
+      groups = searchConversations(q, { workspace: "all" }).groups.length;
+      ms.push(performance.now() - t);
+    }
+    ms.sort((a, b) => a - b);
+    const at = (p: number) =>
+      ms[Math.min(ms.length - 1, Math.floor(p * ms.length))];
+    console.log(
+      `${q.padEnd(22)} p50 ${at(0.5).toFixed(1).padStart(5)} ms  p95 ${at(0.95).toFixed(1).padStart(5)} ms  ${groups} sessions`
+    );
+  }
+}
+
+main().finally(() => rmSync(dir, { recursive: true, force: true }));

package/server.ts

@@ -9,6 +9,7 @@ import { reattachChats } from "./lib/chat/runner";
 import { serveChatSocket } from "./lib/chat/socket";
 import { startStackWatcher } from "./lib/stacks";
 import { startPauseWatcher } from "./lib/tasks/pause";
+import { startConversationBackfill } from "./lib/search/conversations/backfill";
 import { setStartGate } from "./lib/stacks/tick";
 import { stackStartGate } from "./lib/orchestrator/brakes";
 import { buildId } from "./lib/build";
@@ -433,6 +434,8 @@ app.prepare().then(async () => {
   setInterval(sweepSims, 5 * 60_000);
   // Chat turns that kept running through a restart.
   void reattachChats().finally(() => startPauseWatcher());
+  // Older chats get into the search index in the background, a batch at a time.
+  if (process.env.AGENTOS_SEARCH_INDEX !== "off") startConversationBackfill();
   // Reviews this restart cut off run again and deliver their verdicts.
   if (process.env.AGENTOS_ORCHESTRATOR !== "off")
     resumeReviews().catch((error) =>

package/stores/chatJump.ts

@@ -0,0 +1,10 @@
+import { hrefWithSession } from "@/lib/session-url";
+import { bookmarksUiActions } from "@/stores/bookmarksUi";
+
+// Opens a chat by its address, then takes it to one message (bookmarks and
+// search both end here). The chat takes the jump once it is on screen.
+export function openChatAt(sessionId: string, itemId: string): void {
+  window.history.pushState(null, "", hrefWithSession(location.href, sessionId));
+  window.dispatchEvent(new PopStateEvent("popstate"));
+  bookmarksUiActions.jump(sessionId, itemId);
+}

package/stores/palette.ts

@@ -8,20 +8,38 @@ export interface PalettePicker {
   items: PaletteCommand[];
 }
 
-export const paletteUi = proxy<{ open: boolean; picker: PalettePicker | null }>(
-  { open: false, picker: null }
-);
+export type PaletteMode = "commands" | "conversations";
+
+export const paletteUi = proxy<{
+  open: boolean;
+  picker: PalettePicker | null;
+  mode: PaletteMode;
+  // What was typed when the mode changed, so the other mode starts with it.
+  query: string;
+}>({ open: false, picker: null, mode: "commands", query: "" });
 
 export const paletteActions = {
   open: () => {
     paletteUi.picker = null;
+    paletteUi.mode = "commands";
+    paletteUi.query = "";
     paletteUi.open = true;
   },
   setOpen: (open: boolean) => {
     paletteUi.open = open;
-    if (!open) paletteUi.picker = null;
+    if (!open) {
+      paletteUi.picker = null;
+      paletteUi.mode = "commands";
+      paletteUi.query = "";
+    }
+  },
+  setMode: (mode: PaletteMode, query = "") => {
+    paletteUi.picker = null;
+    paletteUi.mode = mode;
+    paletteUi.query = query;
   },
   pick: (placeholder: string, items: PaletteCommand[]) => {
+    paletteUi.mode = "commands";
     paletteUi.picker = ref({
       placeholder,
       items: items.map((c, i) => (i < 9 ? { ...c, hint: `⌘${i + 1}` } : c)),