@ottocode/server 0.1.173

package/src/tools/database/query-sessions.ts

@@ -0,0 +1,126 @@
+import { tool } from 'ai';
+import { z } from 'zod/v3';
+import { getDb } from '@ottocode/database';
+import { sessions, messages } from '@ottocode/database/schema';
+import { eq, desc, asc, gte, lte, and, count } from 'drizzle-orm';
+
+const inputSchema = z.object({
+	limit: z
+		.number()
+		.min(1)
+		.max(100)
+		.default(20)
+		.describe('Max sessions to return'),
+	offset: z.number().min(0).default(0).describe('Offset for pagination'),
+	agent: z.string().optional().describe('Filter by agent type'),
+	startDate: z
+		.string()
+		.optional()
+		.describe('Filter sessions created after this ISO date'),
+	endDate: z
+		.string()
+		.optional()
+		.describe('Filter sessions created before this ISO date'),
+	orderBy: z
+		.enum(['created_at', 'last_active_at', 'total_tokens'])
+		.default('last_active_at')
+		.describe('Sort field'),
+	orderDir: z.enum(['asc', 'desc']).default('desc').describe('Sort direction'),
+	sessionType: z
+		.enum(['main', 'research', 'all'])
+		.default('main')
+		.describe('Filter by session type'),
+});
+
+export function buildQuerySessionsTool(projectRoot: string) {
+	return {
+		name: 'query_sessions',
+		tool: tool({
+			description:
+				'Search and list sessions from the local database. Use to find past conversations, check what work was done, or locate specific sessions.',
+			inputSchema,
+			async execute(input) {
+				const db = await getDb(projectRoot);
+
+				const conditions = [eq(sessions.projectPath, projectRoot)];
+
+				if (input.sessionType !== 'all') {
+					conditions.push(eq(sessions.sessionType, input.sessionType));
+				}
+
+				if (input.agent) {
+					conditions.push(eq(sessions.agent, input.agent));
+				}
+
+				if (input.startDate) {
+					const startTs = new Date(input.startDate).getTime();
+					conditions.push(gte(sessions.createdAt, startTs));
+				}
+
+				if (input.endDate) {
+					const endTs = new Date(input.endDate).getTime();
+					conditions.push(lte(sessions.createdAt, endTs));
+				}
+
+				const orderField =
+					input.orderBy === 'created_at'
+						? sessions.createdAt
+						: input.orderBy === 'total_tokens'
+							? sessions.totalInputTokens
+							: sessions.lastActiveAt;
+
+				const orderFn = input.orderDir === 'asc' ? asc : desc;
+
+				const rows = await db
+					.select({
+						id: sessions.id,
+						title: sessions.title,
+						agent: sessions.agent,
+						provider: sessions.provider,
+						model: sessions.model,
+						createdAt: sessions.createdAt,
+						lastActiveAt: sessions.lastActiveAt,
+						totalInputTokens: sessions.totalInputTokens,
+						totalOutputTokens: sessions.totalOutputTokens,
+						totalCachedTokens: sessions.totalCachedTokens,
+						totalCacheCreationTokens: sessions.totalCacheCreationTokens,
+						sessionType: sessions.sessionType,
+						parentSessionId: sessions.parentSessionId,
+					})
+					.from(sessions)
+					.where(and(...conditions))
+					.orderBy(orderFn(orderField), desc(sessions.createdAt))
+					.limit(input.limit)
+					.offset(input.offset);
+
+				const countResult = await db
+					.select({ total: count() })
+					.from(sessions)
+					.where(and(...conditions));
+
+				const total = countResult[0]?.total ?? 0;
+
+				const sessionsWithCounts = await Promise.all(
+					rows.map(async (row) => {
+						const msgCount = await db
+							.select({ count: count() })
+							.from(messages)
+							.where(eq(messages.sessionId, row.id));
+						return {
+							...row,
+							messageCount: msgCount[0]?.count ?? 0,
+						};
+					}),
+				);
+
+				return {
+					ok: true,
+					sessions: sessionsWithCounts,
+					total,
+					limit: input.limit,
+					offset: input.offset,
+				};
+			},
+		}),
+	};
+}

package/src/tools/database/search-history.ts

@@ -0,0 +1,135 @@
+import { tool } from 'ai';
+import { z } from 'zod/v3';
+import { getDb } from '@ottocode/database';
+import { sessions, messages, messageParts } from '@ottocode/database/schema';
+import { eq, like, and } from 'drizzle-orm';
+
+const inputSchema = z.object({
+	query: z.string().min(1).describe('Search term to find in message content'),
+	limit: z
+		.number()
+		.min(1)
+		.max(50)
+		.default(20)
+		.describe('Max results to return'),
+});
+
+export function buildSearchHistoryTool(projectRoot: string) {
+	return {
+		name: 'search_history',
+		tool: tool({
+			description:
+				'Full-text search across all message content in session history. Find past conversations, solutions, or discussions about specific topics.',
+			inputSchema,
+			async execute(input) {
+				const db = await getDb(projectRoot);
+
+				const projectSessionIds = await db
+					.select({ id: sessions.id })
+					.from(sessions)
+					.where(eq(sessions.projectPath, projectRoot));
+
+				const sessionIdSet = new Set(projectSessionIds.map((s) => s.id));
+
+				if (sessionIdSet.size === 0) {
+					return {
+						ok: true,
+						results: [],
+						total: 0,
+					};
+				}
+
+				const searchPattern = `%${input.query}%`;
+
+				const matchingParts = await db
+					.select({
+						id: messageParts.id,
+						messageId: messageParts.messageId,
+						content: messageParts.content,
+						type: messageParts.type,
+					})
+					.from(messageParts)
+					.where(
+						and(
+							eq(messageParts.type, 'text'),
+							like(messageParts.content, searchPattern),
+						),
+					)
+					.limit(input.limit * 3);
+
+				const results: Array<{
+					sessionId: string;
+					sessionTitle: string | null;
+					messageId: string;
+					role: string;
+					matchedContent: string;
+					createdAt: number;
+				}> = [];
+
+				for (const part of matchingParts) {
+					if (results.length >= input.limit) break;
+
+					const msgRows = await db
+						.select({
+							id: messages.id,
+							sessionId: messages.sessionId,
+							role: messages.role,
+							createdAt: messages.createdAt,
+						})
+						.from(messages)
+						.where(eq(messages.id, part.messageId))
+						.limit(1);
+
+					if (msgRows.length === 0) continue;
+
+					const msg = msgRows[0];
+
+					if (!sessionIdSet.has(msg.sessionId)) continue;
+
+					const sessionRows = await db
+						.select({ title: sessions.title })
+						.from(sessions)
+						.where(eq(sessions.id, msg.sessionId))
+						.limit(1);
+
+					const content = part.content ?? '';
+					const queryLower = input.query.toLowerCase();
+					const contentLower = content.toLowerCase();
+					const matchIndex = contentLower.indexOf(queryLower);
+
+					let matchedContent: string;
+					if (matchIndex >= 0) {
+						const start = Math.max(0, matchIndex - 50);
+						const end = Math.min(
+							content.length,
+							matchIndex + input.query.length + 50,
+						);
+						const prefix = start > 0 ? '...' : '';
+						const suffix = end < content.length ? '...' : '';
+						matchedContent = prefix + content.slice(start, end) + suffix;
+					} else {
+						matchedContent =
+							content.slice(0, 150) + (content.length > 150 ? '...' : '');
+					}
+
+					results.push({
+						sessionId: msg.sessionId,
+						sessionTitle: sessionRows[0]?.title ?? null,
+						messageId: msg.id,
+						role: msg.role,
+						matchedContent,
+						createdAt: msg.createdAt,
+					});
+				}
+
+				results.sort((a, b) => b.createdAt - a.createdAt);
+
+				return {
+					ok: true,
+					results,
+					total: results.length,
+				};
+			},
+		}),
+	};
+}

package/src/types/sql-imports.d.ts

@@ -0,0 +1,5 @@
+// Type declarations for .sql file imports (Bun-specific)
+declare module '*.sql' {
+	const content: string;
+	export default content;
+}

package/sst-env.d.ts

@@ -0,0 +1,8 @@
+/* This file is auto-generated by SST. Do not edit. */
+/* tslint:disable */
+/* eslint-disable */
+/* deno-fmt-ignore-file */
+
+/// <reference path="../../sst-env.d.ts" />
+
+import 'sst';

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": {
+		"outDir": "./dist"
+	},
+	"include": ["src/**/*"]
+}