ruflo 3.5.2 → 3.5.4

package/src/ruvocal/src/lib/utils/tree/convertLegacyConversation.ts

@@ -0,0 +1,36 @@
+import type { Conversation } from "$lib/types/Conversation";
+import type { Message } from "$lib/types/Message";
+import { v4 } from "uuid";
+
+export function convertLegacyConversation(
+	conv: Pick<Conversation, "messages" | "rootMessageId" | "preprompt">
+): Pick<Conversation, "messages" | "rootMessageId" | "preprompt"> {
+	if (conv.rootMessageId) return conv; // not a legacy conversation
+	if (conv.messages.length === 0) return conv; // empty conversation
+	const messages = [
+		{
+			from: "system",
+			content: conv.preprompt ?? "",
+			createdAt: new Date(),
+			updatedAt: new Date(),
+			id: v4(),
+		} satisfies Message,
+		...conv.messages,
+	];
+
+	const rootMessageId = messages[0].id;
+
+	const newMessages = messages.map((message, index) => {
+		return {
+			...message,
+			ancestors: messages.slice(0, index).map((m) => m.id),
+			children: index < messages.length - 1 ? [messages[index + 1].id] : [],
+		};
+	});
+
+	return {
+		...conv,
+		rootMessageId,
+		messages: newMessages,
+	};
+}

package/src/ruvocal/src/lib/utils/tree/isMessageId.spec.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import { isMessageId } from "./isMessageId";
+import { v4 } from "uuid";
+
+describe("isMessageId", () => {
+	it("should return true for a valid message id", () => {
+		expect(isMessageId(v4())).toBe(true);
+	});
+	it("should return false for an invalid message id", () => {
+		expect(isMessageId("1-2-3-4")).toBe(false);
+	});
+	it("should return false for an empty string", () => {
+		expect(isMessageId("")).toBe(false);
+	});
+});

package/src/ruvocal/src/lib/utils/tree/isMessageId.ts

@@ -0,0 +1,5 @@
+import type { Message } from "$lib/types/Message";
+
+export function isMessageId(id: string): id is Message["id"] {
+	return id.split("-").length === 5;
+}

package/src/ruvocal/src/lib/utils/tree/tree.d.ts

@@ -0,0 +1,14 @@
+export type TreeId = string;
+
+export type Tree<T> = {
+	rootMessageId?: TreeId;
+	messages: TreeNode<T>[];
+};
+
+export type TreeNode<T> = T & {
+	id: TreeId;
+	ancestors?: TreeId[];
+	children?: TreeId[];
+};
+
+export type NewNode<T> = Omit<TreeNode<T>, "id">;

package/src/ruvocal/src/lib/utils/tree/treeHelpers.spec.ts

@@ -0,0 +1,167 @@
+import { getCollectionsEarly } from "$lib/server/database";
+import { ObjectId } from "mongodb";
+import { describe, expect, it } from "vitest";
+
+// function used to insert conversations used for testing
+const getConversations = async () => (await getCollectionsEarly()).conversations;
+
+export const insertLegacyConversation = async () => {
+	const conversations = await getConversations();
+	const res = await conversations.insertOne({
+		_id: new ObjectId(),
+		createdAt: new Date(),
+		updatedAt: new Date(),
+		title: "legacy conversation",
+		model: "",
+
+		messages: [
+			{
+				id: "1-1-1-1-1",
+				from: "user",
+				content: "Hello, world! I am a user",
+			},
+			{
+				id: "1-1-1-1-2",
+				from: "assistant",
+				content: "Hello, world! I am an assistant.",
+			},
+			{
+				id: "1-1-1-1-3",
+				from: "user",
+				content: "Hello, world! I am a user.",
+			},
+			{
+				id: "1-1-1-1-4",
+				from: "assistant",
+				content: "Hello, world! I am an assistant.",
+			},
+		],
+	});
+	return res.insertedId;
+};
+
+export const insertLinearBranchConversation = async () => {
+	const conversations = await getConversations();
+	const res = await conversations.insertOne({
+		_id: new ObjectId(),
+		createdAt: new Date(),
+		updatedAt: new Date(),
+		title: "linear branch conversation",
+		model: "",
+
+		rootMessageId: "1-1-1-1-1",
+		messages: [
+			{
+				id: "1-1-1-1-1",
+				from: "user",
+				content: "Hello, world! I am a user",
+				ancestors: [],
+				children: ["1-1-1-1-2"],
+			},
+			{
+				id: "1-1-1-1-2",
+				from: "assistant",
+				content: "Hello, world! I am an assistant.",
+				ancestors: ["1-1-1-1-1"],
+				children: ["1-1-1-1-3"],
+			},
+			{
+				id: "1-1-1-1-3",
+				from: "user",
+				content: "Hello, world! I am a user.",
+				ancestors: ["1-1-1-1-1", "1-1-1-1-2"],
+				children: ["1-1-1-1-4"],
+			},
+			{
+				id: "1-1-1-1-4",
+				from: "assistant",
+				content: "Hello, world! I am an assistant.",
+				ancestors: ["1-1-1-1-1", "1-1-1-1-2", "1-1-1-1-3"],
+				children: [],
+			},
+		],
+	});
+	return res.insertedId;
+};
+
+export const insertSideBranchesConversation = async () => {
+	const conversations = await getConversations();
+	const res = await conversations.insertOne({
+		_id: new ObjectId(),
+		createdAt: new Date(),
+		updatedAt: new Date(),
+		title: "side branches conversation",
+		model: "",
+
+		rootMessageId: "1-1-1-1-1",
+		messages: [
+			{
+				id: "1-1-1-1-1",
+				from: "user",
+				content: "Hello, world, root message!",
+				ancestors: [],
+				children: ["1-1-1-1-2", "1-1-1-1-5"],
+			},
+			{
+				id: "1-1-1-1-2",
+				from: "assistant",
+				content: "Hello, response to root message!",
+				ancestors: ["1-1-1-1-1"],
+				children: ["1-1-1-1-3"],
+			},
+			{
+				id: "1-1-1-1-3",
+				from: "user",
+				content: "Hello, follow up question!",
+				ancestors: ["1-1-1-1-1", "1-1-1-1-2"],
+				children: ["1-1-1-1-4"],
+			},
+			{
+				id: "1-1-1-1-4",
+				from: "assistant",
+				content: "Hello, response from follow up question!",
+				ancestors: ["1-1-1-1-1", "1-1-1-1-2", "1-1-1-1-3"],
+				children: [],
+			},
+			{
+				id: "1-1-1-1-5",
+				from: "assistant",
+				content: "Hello, alternative assistant answer!",
+				ancestors: ["1-1-1-1-1"],
+				children: ["1-1-1-1-6", "1-1-1-1-7"],
+			},
+			{
+				id: "1-1-1-1-6",
+				from: "user",
+				content: "Hello, follow up question to alternative answer!",
+				ancestors: ["1-1-1-1-1", "1-1-1-1-5"],
+				children: [],
+			},
+			{
+				id: "1-1-1-1-7",
+				from: "user",
+				content: "Hello, alternative follow up question to alternative answer!",
+				ancestors: ["1-1-1-1-1", "1-1-1-1-5"],
+				children: [],
+			},
+		],
+	});
+	return res.insertedId;
+};
+
+describe("inserting conversations", () => {
+	it("should insert a legacy conversation", async () => {
+		const id = await insertLegacyConversation();
+		expect(id).toBeDefined();
+	}, 30000);
+
+	it("should insert a linear branch conversation", async () => {
+		const id = await insertLinearBranchConversation();
+		expect(id).toBeDefined();
+	}, 30000);
+
+	it("should insert a side branches conversation", async () => {
+		const id = await insertSideBranchesConversation();
+		expect(id).toBeDefined();
+	}, 30000);
+});

package/src/ruvocal/src/lib/utils/updates.ts

@@ -0,0 +1,39 @@
+// This is a debouncer for the updates from the server to the client
+// It is used to prevent the client from being overloaded with too many updates
+// It works by keeping track of the time it takes to render the updates
+// and adding a safety margin to it, to find the debounce time.
+
+class UpdateDebouncer {
+	private renderStartedAt: Date | null = null;
+	private lastRenderTimes: number[] = [];
+
+	get maxUpdateTime() {
+		if (this.lastRenderTimes.length === 0) {
+			return 50;
+		}
+
+		const averageTime =
+			this.lastRenderTimes.reduce((acc, time) => acc + time, 0) / this.lastRenderTimes.length;
+
+		return Math.min(averageTime * 3, 500);
+	}
+
+	public startRender() {
+		this.renderStartedAt = new Date();
+	}
+
+	public endRender() {
+		if (!this.renderStartedAt) {
+			return;
+		}
+
+		const timeSinceRenderStarted = new Date().getTime() - this.renderStartedAt.getTime();
+		this.lastRenderTimes.push(timeSinceRenderStarted);
+		if (this.lastRenderTimes.length > 10) {
+			this.lastRenderTimes.shift();
+		}
+		this.renderStartedAt = null;
+	}
+}
+
+export const updateDebouncer = new UpdateDebouncer();

package/src/ruvocal/src/lib/utils/urlParams.ts

@@ -0,0 +1,13 @@
+const MAX_PARAM_LENGTH = 10_000;
+
+export function sanitizeUrlParam(value: string | null): string | null {
+	if (value == null) return null;
+
+	const trimmed = value.trim();
+	if (!trimmed.length) return null;
+	if (trimmed.length > MAX_PARAM_LENGTH) return null;
+
+	return trimmed;
+}
+
+export { MAX_PARAM_LENGTH };

package/src/ruvocal/src/lib/workers/autopilotWorker.ts

@@ -0,0 +1,221 @@
+/**
+ * AutopilotWorker — Web Worker for non-blocking SSE parsing of autopilot events.
+ *
+ * Handles the SSE stream from the MCP bridge, parses structured events,
+ * and batches UI updates at ~60fps to prevent main thread jank.
+ *
+ * ADR-037 Part 3: Web Workers for Non-Blocking Execution
+ */
+
+export interface TaskState {
+	taskId: string;
+	tool: string;
+	status: "queued" | "running" | "completed" | "failed" | "blocked" | "cancelled";
+	summary?: string;
+	duration?: number;
+	detailToken?: string;
+	args?: Record<string, unknown>;
+}
+
+export interface GroupState {
+	groupId: string;
+	step: number;
+	tasks: TaskState[];
+	duration?: number;
+}
+
+// Messages FROM main thread TO worker
+export type AutopilotWorkerIncoming =
+	| { type: "start"; url: string; headers: Record<string, string>; body: unknown }
+	| { type: "stop" };
+
+// Messages FROM worker TO main thread
+export type AutopilotWorkerOutgoing =
+	| { type: "batch_update"; updates: AutopilotUIUpdate[]; groups: GroupState[] }
+	| { type: "text"; content: string }
+	| { type: "done"; groups: GroupState[] }
+	| { type: "error"; error: string }
+	| { type: "stopped"; groups: GroupState[] };
+
+export type AutopilotUIUpdate =
+	| { type: "start"; maxSteps: number }
+	| { type: "group_start"; group: GroupState }
+	| { type: "task_update"; taskId: string; status: string; summary?: string; duration?: number; detailToken?: string }
+	| { type: "group_end"; groupId: string; duration: number }
+	| { type: "text"; content: string }
+	| { type: "end"; totalSteps: number; totalTasks: number; duration: number }
+	| { type: "paused"; reason: string; tools?: string[] }
+	| { type: "error_event"; error: string };
+
+const groups: Map<string, GroupState> = new Map();
+let abortController: AbortController | null = null;
+let batchTimeout: ReturnType<typeof setTimeout> | null = null;
+let pendingUpdates: AutopilotUIUpdate[] = [];
+
+/** Batch UI updates at ~60fps to prevent main thread jank */
+function flushUpdates() {
+	if (pendingUpdates.length === 0) return;
+	const msg: AutopilotWorkerOutgoing = {
+		type: "batch_update",
+		updates: pendingUpdates,
+		groups: [...groups.values()],
+	};
+	self.postMessage(msg);
+	pendingUpdates = [];
+	batchTimeout = null;
+}
+
+function queueUpdate(update: AutopilotUIUpdate) {
+	pendingUpdates.push(update);
+	if (!batchTimeout) {
+		batchTimeout = setTimeout(flushUpdates, 16); // ~60fps
+	}
+}
+
+function handleEvent(event: Record<string, unknown>) {
+	switch (event.type) {
+		case "autopilot_start":
+			queueUpdate({ type: "start", maxSteps: (event.maxSteps as number) ?? 20 });
+			break;
+
+		case "task_group_start": {
+			const group: GroupState = {
+				groupId: event.groupId as string,
+				step: event.step as number,
+				tasks: (event.tasks as TaskState[]) ?? [],
+			};
+			groups.set(group.groupId, group);
+			queueUpdate({ type: "group_start", group });
+			break;
+		}
+
+		case "task_update":
+			for (const [, group] of groups) {
+				const task = group.tasks.find((t) => t.taskId === event.taskId);
+				if (task) {
+					if (event.status) task.status = event.status as TaskState["status"];
+					if (event.summary) task.summary = event.summary as string;
+					if (event.duration != null) task.duration = event.duration as number;
+					if (event.detailToken) task.detailToken = event.detailToken as string;
+					queueUpdate({
+						type: "task_update",
+						taskId: event.taskId as string,
+						status: event.status as string,
+						summary: event.summary as string | undefined,
+						duration: event.duration as number | undefined,
+						detailToken: event.detailToken as string | undefined,
+					});
+					break;
+				}
+			}
+			break;
+
+		case "task_group_end": {
+			const g = groups.get(event.groupId as string);
+			if (g) g.duration = event.duration as number;
+			queueUpdate({
+				type: "group_end",
+				groupId: event.groupId as string,
+				duration: (event.duration as number) ?? 0,
+			});
+			break;
+		}
+
+		case "autopilot_text":
+			queueUpdate({ type: "text", content: (event.content as string) ?? "" });
+			// Also send as a separate top-level message for immediate streaming
+			self.postMessage({ type: "text", content: (event.content as string) ?? "" });
+			break;
+
+		case "autopilot_paused":
+			queueUpdate({
+				type: "paused",
+				reason: (event.reason as string) ?? "unknown",
+				tools: event.tools as string[] | undefined,
+			});
+			break;
+
+		case "autopilot_error":
+			queueUpdate({ type: "error_event", error: (event.error as string) ?? "Unknown error" });
+			break;
+
+		case "autopilot_end":
+			queueUpdate({
+				type: "end",
+				totalSteps: (event.totalSteps as number) ?? 0,
+				totalTasks: (event.totalTasks as number) ?? 0,
+				duration: (event.duration as number) ?? 0,
+			});
+			break;
+	}
+}
+
+self.onmessage = async (e: MessageEvent<AutopilotWorkerIncoming>) => {
+	const msg = e.data;
+
+	if (msg.type === "start") {
+		abortController = new AbortController();
+		groups.clear();
+		pendingUpdates = [];
+
+		try {
+			const response = await fetch(msg.url, {
+				method: "POST",
+				headers: { ...msg.headers, "Content-Type": "application/json" },
+				body: JSON.stringify(msg.body),
+				signal: abortController.signal,
+			});
+
+			if (!response.ok) {
+				const errText = await response.text().catch(() => "Unknown error");
+				self.postMessage({ type: "error", error: `HTTP ${response.status}: ${errText}` });
+				return;
+			}
+
+			const reader = response.body!.getReader();
+			const decoder = new TextDecoder();
+			let buffer = "";
+
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+
+				buffer += decoder.decode(value, { stream: true });
+				const lines = buffer.split("\n");
+				buffer = lines.pop() || "";
+
+				for (const line of lines) {
+					if (!line.startsWith("data: ")) continue;
+					const data = line.slice(6).trim();
+					if (data === "[DONE]") {
+						flushUpdates();
+						self.postMessage({ type: "done", groups: [...groups.values()] });
+						return;
+					}
+
+					try {
+						const event = JSON.parse(data);
+						handleEvent(event);
+					} catch {
+						// Skip malformed JSON lines
+					}
+				}
+			}
+
+			// Stream ended without [DONE]
+			flushUpdates();
+			self.postMessage({ type: "done", groups: [...groups.values()] });
+		} catch (err: unknown) {
+			const error = err as Error;
+			if (error.name !== "AbortError") {
+				self.postMessage({ type: "error", error: error.message ?? "Unknown error" });
+			}
+		}
+	}
+
+	if (msg.type === "stop") {
+		abortController?.abort();
+		flushUpdates();
+		self.postMessage({ type: "stopped", groups: [...groups.values()] });
+	}
+};

package/src/ruvocal/src/lib/workers/detailFetchWorker.ts

@@ -0,0 +1,100 @@
+/**
+ * DetailFetchWorker — Web Worker for lazy-loading task details with LRU caching.
+ *
+ * Full tool results are NOT streamed inline — they are stored server-side
+ * and fetched on-demand when the user expands a task card.
+ *
+ * ADR-037 Part 3: Detail Token Lazy Loading
+ */
+
+// Messages FROM main thread TO worker
+export type DetailWorkerIncoming =
+	| { type: "fetch"; detailToken: string; bridgeUrl: string }
+	| { type: "prefetch"; detailToken: string; bridgeUrl: string }
+	| { type: "evict"; detailToken: string };
+
+// Messages FROM worker TO main thread
+export type DetailWorkerOutgoing =
+	| { type: "detail"; detailToken: string; content: string }
+	| { type: "detail_error"; detailToken: string; error: string };
+
+const cache = new Map<string, string>();
+const MAX_CACHE = 20;
+const accessOrder: string[] = [];
+
+function evictLRU() {
+	while (cache.size > MAX_CACHE) {
+		const oldest = accessOrder.shift();
+		if (oldest) cache.delete(oldest);
+	}
+}
+
+function touchAccess(token: string) {
+	const idx = accessOrder.indexOf(token);
+	if (idx > -1) accessOrder.splice(idx, 1);
+	accessOrder.push(token);
+}
+
+self.onmessage = async (e: MessageEvent<DetailWorkerIncoming>) => {
+	const msg = e.data;
+
+	if (msg.type === "fetch" || msg.type === "prefetch") {
+		// Check cache first
+		if (cache.has(msg.detailToken)) {
+			touchAccess(msg.detailToken);
+			if (msg.type === "fetch") {
+				const out: DetailWorkerOutgoing = {
+					type: "detail",
+					detailToken: msg.detailToken,
+					content: cache.get(msg.detailToken)!,
+				};
+				self.postMessage(out);
+			}
+			return;
+		}
+
+		try {
+			const res = await fetch(`${msg.bridgeUrl}/autopilot/detail/${msg.detailToken}`);
+			if (!res.ok) {
+				if (msg.type === "fetch") {
+					const out: DetailWorkerOutgoing = {
+						type: "detail_error",
+						detailToken: msg.detailToken,
+						error: `HTTP ${res.status}`,
+					};
+					self.postMessage(out);
+				}
+				return;
+			}
+
+			const data = (await res.json()) as { content: string };
+			cache.set(msg.detailToken, data.content);
+			touchAccess(msg.detailToken);
+			evictLRU();
+
+			if (msg.type === "fetch") {
+				const out: DetailWorkerOutgoing = {
+					type: "detail",
+					detailToken: msg.detailToken,
+					content: data.content,
+				};
+				self.postMessage(out);
+			}
+		} catch (err: unknown) {
+			if (msg.type === "fetch") {
+				const out: DetailWorkerOutgoing = {
+					type: "detail_error",
+					detailToken: msg.detailToken,
+					error: (err as Error).message ?? "Unknown error",
+				};
+				self.postMessage(out);
+			}
+		}
+	}
+
+	if (msg.type === "evict") {
+		cache.delete(msg.detailToken);
+		const idx = accessOrder.indexOf(msg.detailToken);
+		if (idx > -1) accessOrder.splice(idx, 1);
+	}
+};

package/src/ruvocal/src/lib/workers/markdownWorker.ts

@@ -0,0 +1,61 @@
+// Simple type to replace removed WebSearchSource
+type SimpleSource = {
+	title?: string;
+	link: string;
+};
+import { processBlocks, type BlockToken } from "$lib/utils/marked";
+
+export type IncomingMessage = {
+	type: "process";
+	content: string;
+	sources: SimpleSource[];
+	requestId: number;
+};
+
+export type OutgoingMessage = {
+	type: "processed";
+	blocks: BlockToken[];
+	requestId: number;
+};
+
+// Flag to track if the worker is currently processing a message
+let isProcessing = false;
+
+// Buffer to store the latest incoming message
+let latestMessage: IncomingMessage | null = null;
+
+// Helper function to safely handle the latest message
+async function processMessage() {
+	if (latestMessage) {
+		const nextMessage = latestMessage;
+
+		latestMessage = null;
+		isProcessing = true;
+
+		try {
+			const { content, sources, requestId } = nextMessage;
+			const processedBlocks = await processBlocks(content, sources);
+			postMessage(
+				JSON.parse(JSON.stringify({ type: "processed", blocks: processedBlocks, requestId }))
+			);
+		} finally {
+			isProcessing = false;
+
+			// After processing, check if a new message was buffered
+			await new Promise((resolve) => setTimeout(resolve, 100));
+			processMessage();
+		}
+	}
+}
+
+onmessage = (event) => {
+	if (event.data.type !== "process") {
+		return;
+	}
+
+	latestMessage = event.data as IncomingMessage;
+
+	if (!isProcessing && latestMessage) {
+		processMessage();
+	}
+};

package/src/ruvocal/src/routes/+error.svelte

@@ -0,0 +1,20 @@
+<script lang="ts">
+	import { page } from "$app/state";
+</script>
+
+<div
+	class="flex items-center justify-center bg-gradient-to-t from-gray-200 text-gray-800 dark:from-gray-700 dark:text-gray-300"
+>
+	<div
+		class="align-center -mt-24 flex flex-col justify-center rounded-xl border bg-white px-8 pb-2 pt-4 text-center dark:border-gray-700 dark:bg-gray-800"
+	>
+		<h1 class="mb-2 text-5xl font-semibold">{page.status}</h1>
+		<div class="-mx-8 my-2 h-px bg-gray-200 dark:bg-gray-700"></div>
+		<h2 class="max-w-sm text-lg">{page.error?.message}</h2>
+		{#if page.error?.errorId}
+			<div class="-mx-8 my-2 h-px bg-gray-200 dark:bg-gray-700"></div>
+			<pre class="max-w-sm whitespace-pre-wrap text-left font-mono text-xs">{page.error
+					.errorId}</pre>
+		{/if}
+	</div>
+</div>