@aigentic/ruflo 3.7.0-alpha.69

package/src/ruvocal/src/lib/constants/rvagentPresets.ts

@@ -0,0 +1,206 @@
+/**
+ * rvAgent MCP Server Presets
+ *
+ * Pre-configured server configurations for the rvagent-mcp server
+ * with different tool group combinations. These presets correspond
+ * to the tool groups defined in ADR-112.
+ *
+ * Tool Groups:
+ * - file: read, write, edit, ls, glob, grep
+ * - shell: execute, bash
+ * - memory: semantic_search, store, retrieve
+ * - agent: spawn, status, orchestrate
+ * - git: status, commit, diff, log
+ * - web: fetch, search
+ * - brain: search, share, vote (π Brain)
+ * - task: create, list, complete
+ * - core: ping, initialize (always included)
+ */
+
+export interface RvAgentPreset {
+	/** Unique identifier for the preset */
+	id: string;
+	/** Display name */
+	name: string;
+	/** Short description */
+	description: string;
+	/** Tool groups to enable */
+	groups: string[];
+	/** Default port (user can override) */
+	defaultPort: number;
+	/** Icon/emoji for display */
+	icon: string;
+	/** Recommended use cases */
+	useCases: string[];
+}
+
+/**
+ * Pre-configured rvagent-mcp presets for common use cases
+ */
+export const RVAGENT_PRESETS: RvAgentPreset[] = [
+	{
+		id: "all-tools",
+		name: "All Tools",
+		description: "Full access to all 46+ rvAgent tools",
+		groups: ["all"],
+		defaultPort: 9000,
+		icon: "🔧",
+		useCases: ["Development", "Testing", "Full automation"],
+	},
+	{
+		id: "file-shell",
+		name: "File & Shell",
+		description: "File operations and command execution",
+		groups: ["file", "shell"],
+		defaultPort: 9001,
+		icon: "📂",
+		useCases: ["Code editing", "Build scripts", "File management"],
+	},
+	{
+		id: "memory-agent",
+		name: "Memory & Agent",
+		description: "Vector memory and multi-agent orchestration",
+		groups: ["memory", "agent"],
+		defaultPort: 9002,
+		icon: "🧠",
+		useCases: ["Knowledge retrieval", "Agent coordination", "RAG"],
+	},
+	{
+		id: "git-web",
+		name: "Git & Web",
+		description: "Version control and web operations",
+		groups: ["git", "web"],
+		defaultPort: 9003,
+		icon: "🌐",
+		useCases: ["Code review", "Research", "Documentation"],
+	},
+	{
+		id: "brain-task",
+		name: "Brain & Tasks",
+		description: "π Brain integration and task management",
+		groups: ["brain", "task"],
+		defaultPort: 9004,
+		icon: "🎯",
+		useCases: ["Knowledge sharing", "Task tracking", "Collaboration"],
+	},
+	{
+		id: "dev-minimal",
+		name: "Dev Minimal",
+		description: "Essential development tools only",
+		groups: ["file", "shell", "git"],
+		defaultPort: 9005,
+		icon: "💻",
+		useCases: ["Quick edits", "Simple scripts", "Git operations"],
+	},
+	{
+		id: "research",
+		name: "Research Mode",
+		description: "Memory, web search, and brain tools",
+		groups: ["memory", "web", "brain"],
+		defaultPort: 9006,
+		icon: "🔬",
+		useCases: ["Research", "Knowledge discovery", "Analysis"],
+	},
+	{
+		id: "orchestration",
+		name: "Orchestration",
+		description: "Agent spawning and task coordination",
+		groups: ["agent", "task", "memory"],
+		defaultPort: 9007,
+		icon: "🎭",
+		useCases: ["Multi-agent workflows", "Complex tasks", "Automation"],
+	},
+];
+
+/**
+ * Get preset by ID
+ */
+export function getPresetById(id: string): RvAgentPreset | undefined {
+	return RVAGENT_PRESETS.find((p) => p.id === id);
+}
+
+/**
+ * Build the SSE URL for a preset
+ */
+export function buildPresetUrl(preset: RvAgentPreset, host = "localhost", port?: number): string {
+	const actualPort = port ?? preset.defaultPort;
+	return `http://${host}:${actualPort}/sse`;
+}
+
+/**
+ * Build CLI command to start the server with preset configuration
+ */
+export function buildPresetCliCommand(preset: RvAgentPreset, port?: number): string {
+	const actualPort = port ?? preset.defaultPort;
+	const groupsArg = preset.groups.includes("all") ? "--all" : `--groups ${preset.groups.join(",")}`;
+
+	return `rvagent-mcp --transport sse --port ${actualPort} ${groupsArg}`;
+}
+
+/**
+ * Get all available tool group names
+ */
+export const TOOL_GROUPS = [
+	"file",
+	"shell",
+	"memory",
+	"agent",
+	"git",
+	"web",
+	"brain",
+	"task",
+	"core",
+] as const;
+
+export type ToolGroupName = (typeof TOOL_GROUPS)[number];
+
+/**
+ * Tool group descriptions for UI display
+ */
+export const TOOL_GROUP_INFO: Record<ToolGroupName, { name: string; tools: string[]; icon: string }> = {
+	file: {
+		name: "File Operations",
+		tools: ["read_file", "write_file", "edit_file", "ls", "glob", "grep"],
+		icon: "📁",
+	},
+	shell: {
+		name: "Shell Execution",
+		tools: ["execute", "bash"],
+		icon: "💻",
+	},
+	memory: {
+		name: "Vector Memory",
+		tools: ["semantic_search", "store_memory", "retrieve_memory"],
+		icon: "🧠",
+	},
+	agent: {
+		name: "Multi-Agent",
+		tools: ["spawn_agent", "agent_status", "orchestrate"],
+		icon: "🤖",
+	},
+	git: {
+		name: "Version Control",
+		tools: ["git_status", "git_commit", "git_diff", "git_log"],
+		icon: "📦",
+	},
+	web: {
+		name: "Web Operations",
+		tools: ["web_fetch", "web_search"],
+		icon: "🌐",
+	},
+	brain: {
+		name: "π Brain",
+		tools: ["brain_search", "brain_share", "brain_vote"],
+		icon: "🧪",
+	},
+	task: {
+		name: "Task Management",
+		tools: ["create_task", "list_tasks", "complete_task"],
+		icon: "✅",
+	},
+	core: {
+		name: "Core Protocol",
+		tools: ["ping", "initialize", "tools/list"],
+		icon: "⚙️",
+	},
+};

package/src/ruvocal/src/lib/createShareLink.ts

@@ -0,0 +1,27 @@
+import { base } from "$app/paths";
+import { page } from "$app/state";
+
+// Returns a public share URL for a conversation id.
+// If `id` is already a 7-char share id, no network call is made.
+export async function createShareLink(id: string): Promise<string> {
+	const prefix =
+		page.data.publicConfig.PUBLIC_SHARE_PREFIX ||
+		`${page.data.publicConfig.PUBLIC_ORIGIN || page.url.origin}${base}`;
+
+	if (id.length === 7) {
+		return `${prefix}/r/${id}`;
+	}
+
+	const res = await fetch(`${base}/conversation/${id}/share`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+	});
+
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		throw new Error(text || "Failed to create share link");
+	}
+
+	const { shareId } = await res.json();
+	return `${prefix}/r/${shareId}`;
+}

package/src/ruvocal/src/lib/jobs/refresh-conversation-stats.ts

@@ -0,0 +1,297 @@
+import type { ConversationStats } from "$lib/types/ConversationStats";
+import { CONVERSATION_STATS_COLLECTION, collections } from "$lib/server/database";
+import { logger } from "$lib/server/logger";
+import type { ObjectId } from "mongodb";
+import { acquireLock, refreshLock } from "$lib/migrations/lock";
+import { Semaphores } from "$lib/types/Semaphore";
+
+async function getLastComputationTime(): Promise<Date> {
+	const lastStats = await collections.conversationStats.findOne({}, { sort: { "date.at": -1 } });
+	return lastStats?.date?.at || new Date(0);
+}
+
+async function shouldComputeStats(): Promise<boolean> {
+	const lastComputationTime = await getLastComputationTime();
+	const oneDayAgo = new Date(Date.now() - 24 * 3_600_000);
+	return lastComputationTime < oneDayAgo;
+}
+
+export async function computeAllStats() {
+	for (const span of ["day", "week", "month"] as const) {
+		computeStats({ dateField: "updatedAt", type: "conversation", span }).catch((e) =>
+			logger.error(e, "Error computing conversation stats for updatedAt")
+		);
+		computeStats({ dateField: "createdAt", type: "conversation", span }).catch((e) =>
+			logger.error(e, "Error computing conversation stats for createdAt")
+		);
+		computeStats({ dateField: "createdAt", type: "message", span }).catch((e) =>
+			logger.error(e, "Error computing message stats for createdAt")
+		);
+	}
+}
+
+async function computeStats(params: {
+	dateField: ConversationStats["date"]["field"];
+	span: ConversationStats["date"]["span"];
+	type: ConversationStats["type"];
+}) {
+	const indexes = await collections.semaphores.listIndexes().toArray();
+	if (indexes.length <= 2) {
+		logger.info("Indexes not created, skipping stats computation");
+		return;
+	}
+
+	const lastComputed = await collections.conversationStats.findOne(
+		{ "date.field": params.dateField, "date.span": params.span, type: params.type },
+		{ sort: { "date.at": -1 } }
+	);
+
+	// If the last computed week is at the beginning of the last computed month, we need to include some days from the previous month
+	// In those cases we need to compute the stats from before the last month as everything is one aggregation
+	const minDate = lastComputed ? lastComputed.date.at : new Date(0);
+
+	logger.debug(
+		{ minDate, dateField: params.dateField, span: params.span, type: params.type },
+		"Computing conversation stats"
+	);
+
+	const dateField = params.type === "message" ? "messages." + params.dateField : params.dateField;
+
+	const pipeline = [
+		{
+			$match: {
+				[dateField]: { $gte: minDate },
+			},
+		},
+		// For message stats: use $filter to reduce data before $unwind (optimization)
+		// For conversation stats: simple projection
+		...(params.type === "message"
+			? [
+					{
+						$project: {
+							// Filter messages by date, then map to only keep the date field
+							// This avoids carrying large message payloads (content, files, etc.) through the pipeline
+							messages: {
+								$map: {
+									input: {
+										$filter: {
+											input: "$messages",
+											as: "msg",
+											cond: { $gte: [`$$msg.${params.dateField}`, minDate] },
+										},
+									},
+									as: "msg",
+									in: { [params.dateField]: `$$msg.${params.dateField}` },
+								},
+							},
+							sessionId: 1,
+							userId: 1,
+						},
+					},
+					{
+						$unwind: "$messages",
+					},
+				]
+			: [
+					{
+						$project: {
+							[dateField]: 1,
+							sessionId: 1,
+							userId: 1,
+						},
+					},
+				]),
+		{
+			$sort: {
+				[dateField]: 1,
+			},
+		},
+		{
+			$facet: {
+				userId: [
+					{
+						$match: {
+							userId: { $exists: true },
+						},
+					},
+					{
+						$group: {
+							_id: {
+								at: { $dateTrunc: { date: `$${dateField}`, unit: params.span } },
+								userId: "$userId",
+							},
+						},
+					},
+					{
+						$group: {
+							_id: "$_id.at",
+							count: { $sum: 1 },
+						},
+					},
+					{
+						$project: {
+							_id: 0,
+							date: {
+								at: "$_id",
+								field: params.dateField,
+								span: params.span,
+							},
+							distinct: "userId",
+							count: 1,
+						},
+					},
+				],
+				sessionId: [
+					{
+						$match: {
+							sessionId: { $exists: true },
+						},
+					},
+					{
+						$group: {
+							_id: {
+								at: { $dateTrunc: { date: `$${dateField}`, unit: params.span } },
+								sessionId: "$sessionId",
+							},
+						},
+					},
+					{
+						$group: {
+							_id: "$_id.at",
+							count: { $sum: 1 },
+						},
+					},
+					{
+						$project: {
+							_id: 0,
+							date: {
+								at: "$_id",
+								field: params.dateField,
+								span: params.span,
+							},
+							distinct: "sessionId",
+							count: 1,
+						},
+					},
+				],
+				userOrSessionId: [
+					{
+						$group: {
+							_id: {
+								at: { $dateTrunc: { date: `$${dateField}`, unit: params.span } },
+								userOrSessionId: { $ifNull: ["$userId", "$sessionId"] },
+							},
+						},
+					},
+					{
+						$group: {
+							_id: "$_id.at",
+							count: { $sum: 1 },
+						},
+					},
+					{
+						$project: {
+							_id: 0,
+							date: {
+								at: "$_id",
+								field: params.dateField,
+								span: params.span,
+							},
+							distinct: "userOrSessionId",
+							count: 1,
+						},
+					},
+				],
+				_id: [
+					{
+						$group: {
+							_id: { $dateTrunc: { date: `$${dateField}`, unit: params.span } },
+							count: { $sum: 1 },
+						},
+					},
+					{
+						$project: {
+							_id: 0,
+							date: {
+								at: "$_id",
+								field: params.dateField,
+								span: params.span,
+							},
+							distinct: "_id",
+							count: 1,
+						},
+					},
+				],
+			},
+		},
+		{
+			$project: {
+				stats: {
+					$concatArrays: ["$userId", "$sessionId", "$userOrSessionId", "$_id"],
+				},
+			},
+		},
+		{
+			$unwind: "$stats",
+		},
+		{
+			$replaceRoot: {
+				newRoot: "$stats",
+			},
+		},
+		{
+			$set: {
+				type: params.type,
+			},
+		},
+		{
+			$merge: {
+				into: CONVERSATION_STATS_COLLECTION,
+				on: ["date.at", "type", "date.span", "date.field", "distinct"],
+				whenMatched: "replace",
+				whenNotMatched: "insert",
+			},
+		},
+	];
+
+	await collections.conversations.aggregate(pipeline, { allowDiskUse: true }).next();
+
+	logger.debug(
+		{ minDate, dateField: params.dateField, span: params.span, type: params.type },
+		"Computed conversation stats"
+	);
+}
+
+let hasLock = false;
+let lockId: ObjectId | null = null;
+
+async function maintainLock() {
+	if (hasLock && lockId) {
+		hasLock = await refreshLock(Semaphores.CONVERSATION_STATS, lockId);
+
+		if (!hasLock) {
+			lockId = null;
+		}
+	} else if (!hasLock) {
+		lockId = (await acquireLock(Semaphores.CONVERSATION_STATS)) || null;
+		hasLock = !!lockId;
+	}
+
+	setTimeout(maintainLock, 10_000);
+}
+
+export function refreshConversationStats() {
+	const ONE_HOUR_MS = 3_600_000;
+
+	maintainLock().then(async () => {
+		if (await shouldComputeStats()) {
+			computeAllStats();
+		}
+
+		setInterval(async () => {
+			if (await shouldComputeStats()) {
+				computeAllStats();
+			}
+		}, 24 * ONE_HOUR_MS);
+	});
+}

package/src/ruvocal/src/lib/migrations/lock.ts

@@ -0,0 +1,56 @@
+import { collections } from "$lib/server/database";
+import { ObjectId } from "mongodb";
+import type { Semaphores } from "$lib/types/Semaphore";
+
+/**
+ * Returns the lock id if the lock was acquired, false otherwise
+ */
+export async function acquireLock(key: Semaphores | string): Promise<ObjectId | false> {
+	try {
+		const id = new ObjectId();
+
+		const insert = await collections.semaphores.insertOne({
+			_id: id,
+			key,
+			createdAt: new Date(),
+			updatedAt: new Date(),
+			deleteAt: new Date(Date.now() + 1000 * 60 * 3), // 3 minutes
+		});
+
+		return insert.acknowledged ? id : false; // true if the document was inserted
+	} catch (e) {
+		// unique index violation, so there must already be a lock
+		return false;
+	}
+}
+
+export async function releaseLock(key: Semaphores | string, lockId: ObjectId) {
+	await collections.semaphores.deleteOne({
+		_id: lockId,
+		key,
+	});
+}
+
+export async function isDBLocked(key: Semaphores | string): Promise<boolean> {
+	const res = await collections.semaphores.countDocuments({
+		key,
+	});
+	return res > 0;
+}
+
+export async function refreshLock(key: Semaphores | string, lockId: ObjectId): Promise<boolean> {
+	const result = await collections.semaphores.updateOne(
+		{
+			_id: lockId,
+			key,
+		},
+		{
+			$set: {
+				updatedAt: new Date(),
+				deleteAt: new Date(Date.now() + 1000 * 60 * 3), // 3 minutes
+			},
+		}
+	);
+
+	return result.matchedCount > 0;
+}

package/src/ruvocal/src/lib/migrations/migrations.spec.ts

@@ -0,0 +1,74 @@
+import { afterEach, assert, beforeAll, describe, expect, it } from "vitest";
+import { migrations } from "./routines";
+import { acquireLock, isDBLocked, refreshLock, releaseLock } from "./lock";
+import { Semaphores } from "$lib/types/Semaphore";
+import { collections, ready } from "$lib/server/database";
+
+describe(
+	"migrations",
+	{
+		retry: 3,
+	},
+	() => {
+		beforeAll(async () => {
+			await ready;
+			try {
+				await collections.semaphores.createIndex({ key: 1 }, { unique: true });
+			} catch (e) {
+				// Index might already exist, ignore error
+			}
+		}, 20000);
+
+		it("should not have duplicates guid", async () => {
+			const guids = migrations.map((m) => m._id.toString());
+			const uniqueGuids = [...new Set(guids)];
+			expect(uniqueGuids.length).toBe(guids.length);
+		});
+
+		it("should acquire only one lock on DB", async () => {
+			const results = await Promise.all(
+				new Array(1000).fill(0).map(() => acquireLock(Semaphores.TEST_MIGRATION))
+			);
+			const locks = results.filter((r) => r);
+
+			const semaphores = await collections.semaphores.find({}).toArray();
+
+			expect(locks.length).toBe(1);
+			expect(semaphores).toBeDefined();
+			expect(semaphores.length).toBe(1);
+			expect(semaphores?.[0].key).toBe(Semaphores.TEST_MIGRATION);
+		});
+
+		it("should read the lock correctly", async () => {
+			const lockId = await acquireLock(Semaphores.TEST_MIGRATION);
+			assert(lockId);
+			expect(await isDBLocked(Semaphores.TEST_MIGRATION)).toBe(true);
+			expect(!!(await acquireLock(Semaphores.TEST_MIGRATION))).toBe(false);
+			await releaseLock(Semaphores.TEST_MIGRATION, lockId);
+			expect(await isDBLocked(Semaphores.TEST_MIGRATION)).toBe(false);
+		});
+
+		it("should refresh the lock", async () => {
+			const lockId = await acquireLock(Semaphores.TEST_MIGRATION);
+
+			assert(lockId);
+
+			// get the updatedAt time
+
+			const updatedAtInitially = (await collections.semaphores.findOne({}))?.updatedAt;
+
+			await refreshLock(Semaphores.TEST_MIGRATION, lockId);
+
+			const updatedAtAfterRefresh = (await collections.semaphores.findOne({}))?.updatedAt;
+
+			expect(updatedAtInitially).toBeDefined();
+			expect(updatedAtAfterRefresh).toBeDefined();
+			expect(updatedAtInitially).not.toBe(updatedAtAfterRefresh);
+		});
+
+		afterEach(async () => {
+			await collections.semaphores.deleteMany({});
+			await collections.migrationResults.deleteMany({});
+		});
+	}
+);