bunnyquery 1.6.2 → 1.8.0

package/src/engine/time.ts

@@ -0,0 +1,34 @@
+/**
+ * Chat timestamp formatting, shared so agent.vue and the widget render an
+ * identical "small text under the bubble". Pure and locale-aware: it formats a
+ * given epoch-ms value, it never reads the current time, so it stays testable and
+ * DOM-free.
+ */
+
+/** Wall-clock epoch ms. Separate from the engine's monotonic nowMs() (which is
+ *  performance.now() when available and therefore NOT epoch): a displayed
+ *  timestamp must be wall time. */
+export function wallClockNow(): number {
+	return Date.now();
+}
+
+/**
+ * "Jul 24, 2026, 3:42:07 PM" (locale-formatted). Empty string for a missing or
+ * non-finite value, so a caller can gate rendering on the result being truthy and
+ * a pending bubble (no timestamp yet) simply shows nothing.
+ */
+export function formatChatTimestamp(ms?: number): string {
+	if (typeof ms !== 'number' || !isFinite(ms) || ms <= 0) return '';
+	try {
+		return new Date(ms).toLocaleString(undefined, {
+			year: 'numeric',
+			month: 'short',
+			day: 'numeric',
+			hour: 'numeric',
+			minute: '2-digit',
+			second: '2-digit',
+		});
+	} catch (e) {
+		return '';
+	}
+}

package/src/engine/viewport_fill.ts

@@ -0,0 +1,186 @@
+/**
+ * Keep older history REACHABLE by paging until the message box actually gains
+ * something to scroll to.
+ *
+ * Older history is paged in by one trigger only: the user scrolling to the top
+ * of the message box. That trigger has two ways to die, and collapsed indexing
+ * rows cause both:
+ *
+ *   1. The box never scrolls. A file's every indexing pass (the first plus every
+ *      CONTINUE pass, request AND response bubble each) folds into ONE row, so a
+ *      full history page — twenty-plus messages — can render as a single line.
+ *      Content shorter than the viewport fires no scroll event, so page 2 is
+ *      never requested and any conversation the user had before that upload is
+ *      permanently out of reach.
+ *   2. The fetched page adds no height. A page that is entirely the same file's
+ *      earlier passes joins the collapsed row already on screen and renders
+ *      nothing new. The user, sitting at scrollTop 0, scrolls up again — and
+ *      because the position never changed, no further scroll event fires.
+ *
+ * Both are the same shape: fetch, re-measure, and keep going until the user
+ * genuinely gained reachable content, history ran out, or the pager stopped
+ * advancing. `isSatisfied` is what differs between the two (can the box scroll
+ * at all / did it grow), so the loop below takes it as a predicate.
+ *
+ * DOM-free like the rest of the engine — the caller supplies the measurement and
+ * awaits its own render before measuring, so agent.vue and the widget run the
+ * identical loop over their own pagers.
+ */
+
+/** Overflow (px) that counts as "the user can scroll here". Comfortably more
+ *  than the 60px top threshold that triggers the next page, so a filled box has
+ *  real room to scroll rather than sitting one pixel from the trigger. */
+export const HISTORY_FILL_SLACK_PX = 64;
+
+/** Pages one fill pass will request before giving up. Reached only by a chat
+ *  whose history really is dozens of pages of one file's indexing passes; the
+ *  cap exists so a pager that stops advancing can never spin forever. */
+export const MAX_HISTORY_FILL_PAGES = 24;
+
+export type FillHistoryViewportOptions = {
+	/** The user has reachable content and paging can stop. Called AFTER the
+	 *  caller's own render has settled (nextTick / rAF), since only the caller
+	 *  knows when its view has painted — hence the allowance for a promise. */
+	isSatisfied: () => boolean | Promise<boolean>;
+	/** All history is loaded — nothing left to page in. */
+	isEndOfList: () => boolean;
+	/** A history request is already in flight. Waited out, not treated as a stop
+	 *  condition: a background first-page refresh (the queue-detect tick fires one
+	 *  every couple of seconds while a file is indexing) would otherwise swallow
+	 *  the user's scroll-up entirely, and scrolling up again from scrollTop 0
+	 *  produces no second event to retry with. */
+	isLoading: () => boolean;
+	/** Messages currently loaded. Used to detect a page that added nothing, which
+	 *  means the pager is not advancing and looping would never terminate. */
+	messageCount: () => number;
+	/** Fetch ONE older page (the caller's own fetchMore path, scroll-restore and
+	 *  all). Return `false` when the request was NOT issued (the caller's own
+	 *  single-flight guard swallowed it) so the loop retries instead of reading
+	 *  the unchanged message count as an exhausted pager. Anything else, including
+	 *  undefined, means it was attempted. */
+	fetchOlder: () => Promise<boolean | void | any>;
+	/** The chat this fill was started for is gone (project switched, view
+	 *  unmounted, gate token bumped). Checked between pages so a stale fill can
+	 *  never keep paging another chat's history. */
+	isStale?: () => boolean;
+	maxPages?: number;
+};
+
+/** How long to wait out an in-flight history request before giving up on it. */
+const IDLE_WAIT_STEP_MS = 120;
+const IDLE_WAIT_MAX_MS = 15000;
+
+/** Resolve once no history request is in flight. False if the wait timed out or
+ *  the chat went stale, in which case the caller should stop. */
+async function waitForIdle(
+	opts: FillHistoryViewportOptions,
+	stale: () => boolean,
+): Promise<boolean> {
+	var waited = 0;
+	while (opts.isLoading()) {
+		if (stale() || waited >= IDLE_WAIT_MAX_MS) return false;
+		await new Promise(function (r) { setTimeout(r, IDLE_WAIT_STEP_MS); });
+		waited += IDLE_WAIT_STEP_MS;
+	}
+	return !stale();
+}
+
+/**
+ * Page older history until `isSatisfied`, until history runs out, or until the
+ * pager stops advancing. Never throws: a failed page ends the fill, and the
+ * user's own scrolling remains the fallback trigger.
+ */
+export async function fillHistoryViewport(opts: FillHistoryViewportOptions): Promise<void> {
+	var maxPages = typeof opts.maxPages === 'number' ? opts.maxPages : MAX_HISTORY_FILL_PAGES;
+	var stale = function () { return !!(opts.isStale && opts.isStale()); };
+	var swallowed = 0;
+
+	for (var page = 0; page < maxPages; page++) {
+		if (stale() || opts.isEndOfList()) return;
+		if (!(await waitForIdle(opts, stale))) return;
+		var satisfied = false;
+		try {
+			satisfied = !!(await opts.isSatisfied());
+		} catch {
+			return; // cannot measure (view torn down mid-fill) — stop.
+		}
+		if (satisfied || stale()) return;
+
+		// Re-check immediately before dispatching: measuring above yields for a
+		// frame, and a background first-page refresh landing in that gap would make
+		// the caller's own single-flight guard swallow this request. A swallowed
+		// page adds no messages, which used to read as "the pager is exhausted" and
+		// abandoned the fill for good.
+		if (!(await waitForIdle(opts, stale))) return;
+		var before = opts.messageCount();
+		var attempted: boolean | void;
+		try {
+			attempted = await opts.fetchOlder();
+		} catch {
+			return; // history is optional; the scroll trigger stays as the fallback.
+		}
+		if (stale()) return;
+		if (attempted === false) {
+			// The caller reported it never issued the request. Retry it rather than
+			// mistaking it for an exhausted pager, but not forever.
+			if (++swallowed > 3) return;
+			page--;
+			continue;
+		}
+		// The page came back with nothing new. Either the pager is exhausted (and
+		// endOfList simply has not been set) or it is stuck; either way another
+		// round would request the same page again.
+		if (opts.messageCount() <= before) return;
+	}
+}
+
+/**
+ * One fill loop per view, with predicates COMBINED rather than dropped.
+ *
+ * Fills come from several places at once — a first page finishing, a window
+ * resize, a row being collapsed, and the user's own scroll to the top — and a
+ * plain "one at a time, drop the rest" guard picks the wrong winner: a resize
+ * fill (satisfied the moment the box can scroll at all) would swallow the user's
+ * scroll-up (which needs content specifically ABOVE them), and the scroll-up
+ * cannot be retried, because a reader parked at scrollTop 0 produces no further
+ * scroll event. Dropping the guard entirely is no better: every frame of a
+ * window drag would start its own 24-page loop.
+ *
+ * So a request that arrives mid-loop ANDs its predicate into the running one:
+ * the loop then keeps paging until EVERY caller is satisfied. Predicates that
+ * come true are dropped as it goes, so the cost stays flat.
+ */
+export function createHistoryFiller(
+	base: Omit<FillHistoryViewportOptions, 'isSatisfied'>,
+): { fill: (isSatisfied: () => boolean | Promise<boolean>) => Promise<void>; isRunning: () => boolean } {
+	var pending: Array<() => boolean | Promise<boolean>> = [];
+	var running = false;
+
+	async function allSatisfied(): Promise<boolean> {
+		var next: Array<() => boolean | Promise<boolean>> = [];
+		for (var i = 0; i < pending.length; i++) {
+			if (!(await pending[i]())) next.push(pending[i]);
+		}
+		pending = next;
+		return pending.length === 0;
+	}
+
+	return {
+		isRunning: function () { return running; },
+		fill: function (isSatisfied) {
+			pending.push(isSatisfied);
+			if (running) return Promise.resolve();
+			running = true;
+			var done = function () { running = false; pending = []; };
+			return fillHistoryViewport({
+				isSatisfied: allSatisfied,
+				isEndOfList: base.isEndOfList,
+				isLoading: base.isLoading,
+				messageCount: base.messageCount,
+				fetchOlder: base.fetchOlder,
+				isStale: base.isStale,
+				maxPages: base.maxPages,
+			}).then(done, done);
+		},
+	};
+}

package/styles/chat.css

@@ -76,6 +76,18 @@
     font-style: italic;
     clear: both;
 }
+/* Timestamp under a settled bubble (created for a user turn, response time for an
+   assistant turn). Muted and small so it never competes with the message. */
+.bq-msg-time {
+    display: block;
+    margin-top: 0.25rem;
+    font-size: 0.62rem;
+    line-height: 1;
+    color: var(--bq-muted);
+    opacity: 0.7;
+    clear: both;
+}
+.bq-message.is-user .bq-msg-time { text-align: right; }
 .bq-cancel-queue-btn {
     float: right;
     margin: -0.25rem -0.25rem 0.2rem 0.4rem;
@@ -99,6 +111,128 @@
 .bq-cancel-queue-btn:hover:not(.is-disabled) { background: var(--bq-warning-bg); color: var(--bq-warning); }
 .bq-cancel-queue-btn.is-disabled { opacity: 0.3; cursor: not-allowed; pointer-events: none; }
 
+/* ---- collapsed background-indexing group ---------------------------------*/
+/* One file's many indexing passes (first pass + every CONTINUE pass, each with
+   a request AND a response bubble) render as a single status row instead of
+   filling the conversation with the same turn over and over. The row is a full
+   width strip rather than a bubble: it is chat CHROME, not something anyone
+   said. See engine/indexing_groups.ts for the grouping itself. */
+.bq-index-group {
+    display: block;
+    margin-bottom: 0.5rem;
+    border: 1px solid var(--bq-line);
+    background: rgba(127, 127, 127, 0.05);
+}
+.bq-index-group.is-active { border-color: var(--bq-warning-border); background: var(--bq-warning-bg); }
+.bq-index-group.is-error { border-color: var(--bq-danger); background: var(--bq-danger-bg); }
+
+.bq-index-head {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    width: 100%;
+    padding: 0.45rem 0.6rem;
+    border: 0;
+    border-radius: 0;
+    box-shadow: none;
+    background: transparent;
+    color: var(--bq-muted);
+    font: inherit;
+    font-size: 0.78rem;
+    line-height: 1.35;
+    text-align: left;
+    cursor: pointer;
+    min-height: 0;
+}
+.bq-index-head:hover { background: rgba(127, 127, 127, 0.08); color: var(--bq-muted); }
+.bq-index-group.is-active .bq-index-head { color: var(--bq-warning); }
+.bq-index-group.is-error .bq-index-head { color: var(--bq-danger); }
+
+/* Status glyph. The active one is a circular-arrow SVG the consumer inlines
+   (never an icon font: agent.vue's Material Symbols build gates glyphs behind
+   an icon_names allowlist, which a shared stylesheet cannot reach). */
+.bq-index-icon {
+    flex: 0 0 auto;
+    width: 0.95rem;
+    height: 0.95rem;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+}
+.bq-index-icon svg { width: 100%; height: 100%; display: block; }
+.bq-index-group.is-active .bq-index-icon svg { animation: bq-index-spin 1.1s linear infinite; }
+@keyframes bq-index-spin { to { transform: rotate(360deg); } }
+@media (prefers-reduced-motion: reduce) {
+    .bq-index-group.is-active .bq-index-icon svg { animation-duration: 3s; }
+}
+
+.bq-index-label {
+    flex: 1 1 auto;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+.bq-index-label .bq-link-button { max-width: 100%; font-size: inherit; }
+/* The label runs through the same markdown renderer as a bubble, which wraps it
+   in a block <p>. Inline it so the row stays one line high. */
+.bq-index-label .bq-md,
+.bq-index-label .bq-md p { display: inline; margin: 0; }
+/* Passes LOADED, never a server-side total: history pages newest-first, so any
+   total derived from what is on screen is a lower bound. */
+.bq-index-count { flex: 0 0 auto; opacity: 0.75; font-size: 0.72rem; }
+/* Stop indexing. Only ever rendered while a file has a queued/running pass, so
+   it never competes with the row's normal (collapsed, finished) look. Sized off
+   the row's own font so it stays a thin strip, not a chat action button. */
+.bq-index-cancel {
+    flex: 0 0 auto;
+    padding: 0.1rem 0.4rem;
+    min-height: 0;
+    border: 1px solid currentColor;
+    border-radius: 0;
+    background: transparent;
+    color: inherit;
+    font: inherit;
+    font-size: 0.68rem;
+    line-height: 1.3;
+    letter-spacing: 0.02em;
+    cursor: pointer;
+    box-shadow: none;
+    opacity: 0.8;
+}
+.bq-index-cancel:hover:not(.is-disabled) { background: var(--bq-warning-bg); color: var(--bq-warning); opacity: 1; }
+.bq-index-cancel.is-disabled { opacity: 0.45; cursor: default; pointer-events: none; }
+.bq-index-chevron {
+    flex: 0 0 auto;
+    font-size: 0.62rem;
+    opacity: 0.7;
+    transition: transform 0.15s ease;
+}
+.bq-index-group.is-open .bq-index-chevron { transform: rotate(90deg); }
+
+/* Expanded: the file's own turns, in order, rendered as ordinary messages
+   directly under the row they collapsed into (they are scattered through the
+   conversation otherwise). Rendered as SIBLINGS of the row, not children, so
+   both consumers keep exactly one copy of the message-bubble markup. */
+.bq-index-group.is-open { margin-bottom: 0.35rem; }
+.bq-message.bq-index-pass {
+    margin-bottom: 0.3rem;
+    margin-left: 0.7rem;
+    padding-left: 0.7rem;
+    border-left: 2px solid var(--bq-line);
+}
+.bq-message.bq-index-pass .bq-bubble { font-size: 0.78rem; }
+/* Close the run: the next ordinary message needs its normal breathing room. */
+.bq-message.bq-index-pass + :not(.bq-index-pass) { margin-top: 0.55rem; }
+.bq-index-note {
+    padding: 0 0.6rem 0.45rem;
+    font-size: 0.7rem;
+    font-style: italic;
+    color: var(--bq-muted);
+}
+/* A cancel that the server refused (the pass had already finished). */
+.bq-index-note.is-error { color: var(--bq-danger); }
+
 /* ---- in-bubble file / link anchors --------------------------------------*/
 .bq-file-download,
 .bq-link-button {