@ottocode/server 0.1.270 → 0.1.271

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/server",
-	"version": "0.1.270",
+	"version": "0.1.271",
 	"description": "HTTP API server for ottocode",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -61,8 +61,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@ottocode/database": "0.1.270",
-		"@ottocode/sdk": "0.1.270",
+		"@ottocode/database": "0.1.271",
+		"@ottocode/sdk": "0.1.271",
 		"@hono/zod-openapi": "^1.1.5",
 		"ai-sdk-ollama": "^3.8.3",
 		"drizzle-orm": "^0.44.5",

package/src/openapi/schemas.ts

@@ -90,6 +90,7 @@ export const schemas = {
 			projectPath: { type: 'string' },
 			createdAt: { type: 'integer', format: 'int64' },
 			lastActiveAt: { type: 'integer', format: 'int64', nullable: true },
+			lastViewedAt: { type: 'integer', format: 'int64', nullable: true },
 			totalInputTokens: { type: 'integer', nullable: true },
 			totalOutputTokens: { type: 'integer', nullable: true },
 			totalCachedTokens: { type: 'integer', nullable: true },
@@ -101,6 +102,17 @@ export const schemas = {
 				additionalProperties: { type: 'integer' },
 				nullable: true,
 			},
+			fileStats: {
+				type: 'object',
+				properties: {
+					changedFiles: { type: 'integer' },
+					additions: { type: 'integer' },
+					deletions: { type: 'integer' },
+					operations: { type: 'integer' },
+				},
+				required: ['changedFiles', 'additions', 'deletions', 'operations'],
+				nullable: true,
+			},
 			isRunning: { type: 'boolean' },
 		},
 		required: ['id', 'agent', 'provider', 'model', 'projectPath', 'createdAt'],

package/src/routes/research/service.ts

@@ -143,6 +143,7 @@ export async function createResearchSession(c: Context) {
 		projectPath: cfg.projectRoot,
 		createdAt: now,
 		lastActiveAt: now,
+		lastViewedAt: now,
 		parentSessionId: parentId,
 		sessionType: 'research',
 		totalInputTokens: null,
@@ -289,6 +290,7 @@ export async function exportResearchSession(c: Context) {
 		projectPath: cfg.projectRoot,
 		createdAt: now,
 		lastActiveAt: now,
+		lastViewedAt: now,
 		parentSessionId: null,
 		sessionType: 'main',
 		totalInputTokens: null,

package/src/routes/sessions/crud.ts

@@ -10,6 +10,7 @@ import {
 	buildSessionPreferenceUpdates,
 	deleteSessionMessagesAndParts,
 	findSessionById,
+	getSessionFileStats,
 	loadProjectDb,
 	normalizeSessionRow,
 } from './service.ts';
@@ -112,9 +113,16 @@ export function registerSessionCrudRoutes(app: Hono) {
 				.offset(offset);
 			const hasMore = rows.length > limit;
 			const page = hasMore ? rows.slice(0, limit) : rows;
-			const normalized = page.map((r) =>
-				normalizeSessionRow(r, { includeRunning: true }),
-			);
+			const fileStats = await getSessionFileStats(db, page);
+			const normalized = page.map((r) => {
+				const normalizedSession = normalizeSessionRow(r, {
+					includeRunning: true,
+				});
+				const stats = fileStats.get(r.id);
+				return stats && stats.changedFiles > 0
+					? { ...normalizedSession, fileStats: stats }
+					: normalizedSession;
+			});
 			return c.json({
 				items: normalized,
 				hasMore,
@@ -318,6 +326,83 @@ export function registerSessionCrudRoutes(app: Hono) {
 		},
 	);
 
+	// Mark session as viewed by the user
+	openApiRoute(
+		app,
+		{
+			method: 'post',
+			path: '/v1/sessions/{sessionId}/viewed',
+			tags: ['sessions'],
+			operationId: 'markSessionViewed',
+			summary: 'Mark a session as viewed',
+			parameters: [
+				{
+					in: 'path',
+					name: 'sessionId',
+					required: true,
+					schema: {
+						type: 'string',
+					},
+				},
+				{
+					in: 'query',
+					name: 'project',
+					required: false,
+					schema: {
+						type: 'string',
+					},
+					description:
+						'Project root override (defaults to current working directory).',
+				},
+			],
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								$ref: '#/components/schemas/Session',
+							},
+						},
+					},
+				},
+				'404': {
+					description: 'Not Found',
+				},
+			},
+		},
+		async (c) => {
+			try {
+				const sessionId = c.req.param('sessionId');
+				const projectRoot = c.req.query('project') || process.cwd();
+				const { cfg, db } = await loadProjectDb(projectRoot);
+				const existingSession = await findSessionById(db, sessionId);
+				if (
+					!existingSession ||
+					existingSession.projectPath !== cfg.projectRoot
+				) {
+					return c.json({ error: 'Session not found' }, 404);
+				}
+
+				await db
+					.update(sessions)
+					.set({ lastViewedAt: Date.now() })
+					.where(eq(sessions.id, sessionId));
+
+				const updatedSession = await findSessionById(db, sessionId);
+				return c.json(
+					normalizeSessionRow(updatedSession ?? existingSession, {
+						includeRunning: true,
+					}),
+				);
+			} catch (err) {
+				logger.error('Failed to mark session viewed', err);
+				const errorResponse = serializeError(err);
+				return c.json(errorResponse, errorResponse.error.status || 500);
+			}
+		},
+	);
+
 	// Update session preferences
 	openApiRoute(
 		app,

package/src/routes/sessions/service.ts

@@ -32,6 +32,26 @@ export type SessionRow = typeof sessions.$inferSelect;
 export type MessageRow = typeof messages.$inferSelect;
 export type MessagePartRow = typeof messageParts.$inferSelect;
 
+const FILE_EDIT_TOOLS = [
+	'Write',
+	'Edit',
+	'MultiEdit',
+	'CopyInto',
+	'ApplyPatch',
+	'write',
+	'edit',
+	'multiedit',
+	'copy_into',
+	'apply_patch',
+];
+
+export interface SessionFileStats {
+	changedFiles: number;
+	additions: number;
+	deletions: number;
+	operations: number;
+}
+
 export type ProjectDbContext = {
 	cfg: Awaited<ReturnType<typeof loadConfig>>;
 	db: Awaited<ReturnType<typeof getDb>>;
@@ -62,6 +82,161 @@ export function normalizeSessionRow(
 	return { ...base, isRunning };
 }
 
+function getRecord(value: unknown): Record<string, unknown> | null {
+	return value && typeof value === 'object' && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: null;
+}
+
+function getNumber(value: unknown): number {
+	return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+
+function addStringFile(files: Set<string>, value: unknown) {
+	if (typeof value === 'string' && value.trim()) {
+		files.add(value.trim());
+	}
+}
+
+function addPatchFiles(files: Set<string>, patch: unknown) {
+	if (typeof patch !== 'string') return;
+	for (const match of patch.matchAll(
+		/\*\*\* (?:Update|Add|Delete) File: (.+)/g,
+	)) {
+		addStringFile(files, match[1]);
+	}
+	const unifiedMatch = patch.match(/^(?:---|\+\+\+) [ab]\/(.+)$/m);
+	if (unifiedMatch) addStringFile(files, unifiedMatch[1]);
+}
+
+function extractFilesFromToolContent(content: unknown): Set<string> {
+	const files = new Set<string>();
+	const data = getRecord(content);
+	if (!data) return files;
+
+	const args = getRecord(data.args);
+	addStringFile(files, data.path);
+	addStringFile(files, data.targetPath);
+	addStringFile(files, args?.path);
+	addStringFile(files, args?.targetPath);
+
+	const rawFiles = data.files;
+	if (Array.isArray(rawFiles)) {
+		for (const file of rawFiles) {
+			if (typeof file === 'string') addStringFile(files, file);
+			else addStringFile(files, getRecord(file)?.path);
+		}
+	}
+
+	addPatchFiles(files, data.patch ?? args?.patch);
+	const result = getRecord(data.result);
+	const resultArtifact = getRecord(result?.artifact);
+	addPatchFiles(files, resultArtifact?.patch);
+
+	return files;
+}
+
+function extractArtifactSummary(content: unknown) {
+	const data = getRecord(content);
+	const artifact =
+		getRecord(getRecord(data?.result)?.artifact) ?? getRecord(data?.artifact);
+	const summary = getRecord(artifact?.summary);
+	return {
+		files: getNumber(summary?.files),
+		additions: getNumber(summary?.additions),
+		deletions: getNumber(summary?.deletions),
+	};
+}
+
+export async function getSessionFileStats(
+	db: ProjectDbContext['db'],
+	rows: SessionRow[],
+): Promise<Map<string, SessionFileStats>> {
+	const sessionIds = rows.map((row) => row.id);
+	const statsBySessionId = new Map<string, SessionFileStats>();
+	if (sessionIds.length === 0) return statsBySessionId;
+
+	for (const sessionId of sessionIds) {
+		statsBySessionId.set(sessionId, {
+			changedFiles: 0,
+			additions: 0,
+			deletions: 0,
+			operations: 0,
+		});
+	}
+
+	const messageRows = await db
+		.select({ id: messages.id, sessionId: messages.sessionId })
+		.from(messages)
+		.where(inArray(messages.sessionId, sessionIds));
+	if (messageRows.length === 0) return statsBySessionId;
+
+	const sessionIdByMessageId = new Map(
+		messageRows.map((message) => [message.id, message.sessionId]),
+	);
+	const parts = await db
+		.select({
+			messageId: messageParts.messageId,
+			type: messageParts.type,
+			toolName: messageParts.toolName,
+			content: messageParts.content,
+		})
+		.from(messageParts)
+		.where(
+			and(
+				inArray(
+					messageParts.messageId,
+					messageRows.map((message) => message.id),
+				),
+				inArray(messageParts.toolName, FILE_EDIT_TOOLS),
+			),
+		);
+
+	const fileSetsBySessionId = new Map<string, Set<string>>();
+	const minimumFileCounts = new Map<string, number>();
+
+	for (const part of parts) {
+		const sessionId = sessionIdByMessageId.get(part.messageId);
+		if (!sessionId || !part.toolName) continue;
+
+		let content: unknown;
+		try {
+			content = JSON.parse(part.content);
+		} catch {
+			continue;
+		}
+
+		let fileSet = fileSetsBySessionId.get(sessionId);
+		if (!fileSet) {
+			fileSet = new Set<string>();
+			fileSetsBySessionId.set(sessionId, fileSet);
+		}
+		for (const file of extractFilesFromToolContent(content)) fileSet.add(file);
+
+		if (part.type === 'tool_result') {
+			const stats = statsBySessionId.get(sessionId);
+			if (!stats) continue;
+			const summary = extractArtifactSummary(content);
+			stats.operations++;
+			stats.additions += summary.additions;
+			stats.deletions += summary.deletions;
+			minimumFileCounts.set(
+				sessionId,
+				Math.max(minimumFileCounts.get(sessionId) ?? 0, summary.files),
+			);
+		}
+	}
+
+	for (const [sessionId, stats] of statsBySessionId) {
+		stats.changedFiles = Math.max(
+			fileSetsBySessionId.get(sessionId)?.size ?? 0,
+			minimumFileCounts.get(sessionId) ?? 0,
+		);
+	}
+
+	return statsBySessionId;
+}
+
 export async function loadProjectDb(
 	projectRoot = process.cwd(),
 ): Promise<ProjectDbContext> {

package/src/runtime/session/branch.ts

@@ -90,6 +90,7 @@ export async function createBranch({
 		projectPath: parent.projectPath,
 		createdAt: now,
 		lastActiveAt: now,
+		lastViewedAt: now,
 		parentSessionId,
 		branchPointMessageId: fromMessageId,
 		sessionType: 'branch',
@@ -168,6 +169,7 @@ export async function createBranch({
 		projectPath: newSession.projectPath,
 		createdAt: newSession.createdAt,
 		lastActiveAt: newSession.lastActiveAt ?? null,
+		lastViewedAt: now,
 		totalInputTokens: null,
 		totalOutputTokens: null,
 		totalCachedTokens: null,

package/src/runtime/session/manager.ts

@@ -50,6 +50,7 @@ export async function createSession({
 		projectPath: cfg.projectRoot,
 		createdAt: now,
 		lastActiveAt: now,
+		lastViewedAt: now,
 		totalInputTokens: null,
 		totalOutputTokens: null,
 		totalCachedTokens: null,