@agi-cli/server 0.1.113 → 0.1.115

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/server",
-	"version": "0.1.113",
+	"version": "0.1.115",
 	"description": "HTTP API server for AGI CLI",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -29,8 +29,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@agi-cli/sdk": "0.1.113",
-		"@agi-cli/database": "0.1.113",
+		"@agi-cli/sdk": "0.1.115",
+		"@agi-cli/database": "0.1.115",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.1.8"

package/src/index.ts

@@ -13,6 +13,7 @@ import { registerConfigRoutes } from './routes/config/index.ts';
 import { registerFilesRoutes } from './routes/files.ts';
 import { registerGitRoutes } from './routes/git/index.ts';
 import { registerTerminalsRoutes } from './routes/terminals.ts';
+import { registerSessionFilesRoutes } from './routes/session-files.ts';
 import type { AgentConfigEntry } from './runtime/agent-registry.ts';
 
 const globalTerminalManager = new TerminalManager();
@@ -62,6 +63,7 @@ function initApp() {
 	registerFilesRoutes(app);
 	registerGitRoutes(app);
 	registerTerminalsRoutes(app, globalTerminalManager);
+	registerSessionFilesRoutes(app);
 
 	return app;
 }
@@ -127,6 +129,7 @@ export function createStandaloneApp(_config?: StandaloneAppConfig) {
 	registerFilesRoutes(honoApp);
 	registerGitRoutes(honoApp);
 	registerTerminalsRoutes(honoApp, globalTerminalManager);
+	registerSessionFilesRoutes(honoApp);
 
 	return honoApp;
 }
@@ -220,6 +223,7 @@ export function createEmbeddedApp(config: EmbeddedAppConfig = {}) {
 	registerFilesRoutes(honoApp);
 	registerGitRoutes(honoApp);
 	registerTerminalsRoutes(honoApp, globalTerminalManager);
+	registerSessionFilesRoutes(honoApp);
 
 	return honoApp;
 }

package/src/routes/session-files.ts

@@ -0,0 +1,387 @@
+import type { Hono } from 'hono';
+import { loadConfig } from '@agi-cli/sdk';
+import { getDb } from '@agi-cli/database';
+import { messages, messageParts, sessions } from '@agi-cli/database/schema';
+import { eq, and, inArray } from 'drizzle-orm';
+import { serializeError } from '../runtime/api-error.ts';
+import { logger } from '@agi-cli/sdk';
+
+const FILE_EDIT_TOOLS = [
+	'Write',
+	'ApplyPatch',
+	'Edit',
+	'write',
+	'apply_patch',
+	'edit',
+];
+
+interface FileOperation {
+	path: string;
+	operation: 'write' | 'patch' | 'edit' | 'create';
+	timestamp: number;
+	toolCallId: string;
+	toolName: string;
+	patch?: string;
+	content?: string;
+	artifact?: {
+		kind: string;
+		patch?: string;
+		summary?: { additions: number; deletions: number };
+	};
+}
+
+interface SessionFile {
+	path: string;
+	operations: FileOperation[];
+	operationCount: number;
+	firstModified: number;
+	lastModified: number;
+}
+
+interface ToolResultData {
+	path?: string;
+	args?: Record<string, unknown>;
+	files?: Array<string | { path: string }>;
+	result?: {
+		ok?: boolean;
+		artifact?: {
+			kind?: string;
+			patch?: string;
+			summary?: { additions?: number; deletions?: number };
+		};
+	};
+	artifact?: {
+		kind?: string;
+		patch?: string;
+		summary?: { additions?: number; deletions?: number };
+	};
+	patch?: string;
+}
+
+function extractFilePathFromToolCall(
+	toolName: string,
+	content: unknown,
+): string | null {
+	if (!content || typeof content !== 'object') return null;
+
+	const c = content as Record<string, unknown>;
+	const args = c.args as Record<string, unknown> | undefined;
+
+	const name = toolName.toLowerCase();
+
+	if (name === 'write' || name === 'edit') {
+		if (args && typeof args.path === 'string') return args.path;
+		if (typeof c.path === 'string') return c.path;
+	}
+
+	if (name === 'applypatch' || name === 'apply_patch') {
+		const patch = args?.patch ?? c.patch;
+		if (typeof patch === 'string') {
+			const matches = [
+				...patch.matchAll(/\*\*\* (?:Update|Add|Delete) File: (.+)/g),
+			];
+			if (matches.length > 0) return matches[0][1].trim();
+			const unifiedMatch = patch.match(/^(?:---|\+\+\+) [ab]\/(.+)$/m);
+			if (unifiedMatch) return unifiedMatch[1].trim();
+		}
+		if (args && typeof args.path === 'string') return args.path;
+		if (typeof c.path === 'string') return c.path;
+	}
+
+	return null;
+}
+
+function extractPatchFromToolCall(
+	toolName: string,
+	content: unknown,
+): string | undefined {
+	if (!content || typeof content !== 'object') return undefined;
+
+	const c = content as Record<string, unknown>;
+	const args = c.args as Record<string, unknown> | undefined;
+	const name = toolName.toLowerCase();
+
+	if (name === 'applypatch' || name === 'apply_patch') {
+		const patch = args?.patch ?? c.patch;
+		if (typeof patch === 'string') return patch;
+	}
+
+	return undefined;
+}
+
+function extractContentFromToolCall(
+	toolName: string,
+	content: unknown,
+): string | undefined {
+	if (!content || typeof content !== 'object') return undefined;
+
+	const c = content as Record<string, unknown>;
+	const args = c.args as Record<string, unknown> | undefined;
+	const name = toolName.toLowerCase();
+
+	if (name === 'write') {
+		const writeContent = args?.content ?? c.content;
+		if (typeof writeContent === 'string') return writeContent;
+	}
+
+	return undefined;
+}
+
+function extractFilesFromToolResult(
+	toolName: string,
+	content: unknown,
+): string[] {
+	if (!content || typeof content !== 'object') return [];
+
+	const c = content as ToolResultData;
+	const files: string[] = [];
+
+	if (typeof c.path === 'string') {
+		files.push(c.path);
+	}
+
+	const args = c.args;
+	if (args && typeof args.path === 'string' && !files.includes(args.path)) {
+		files.push(args.path);
+	}
+
+	if (Array.isArray(c.files)) {
+		for (const f of c.files) {
+			if (typeof f === 'string' && !files.includes(f)) files.push(f);
+			if (f && typeof f === 'object' && typeof f.path === 'string') {
+				if (!files.includes(f.path)) files.push(f.path);
+			}
+		}
+	}
+
+	const name = toolName.toLowerCase();
+	if (name === 'applypatch' || name === 'apply_patch') {
+		const patch =
+			c.patch ??
+			(args?.patch as string | undefined) ??
+			c.result?.artifact?.patch;
+		if (typeof patch === 'string') {
+			const matches = patch.matchAll(
+				/\*\*\* (?:Update|Add|Delete) File: (.+)/g,
+			);
+			for (const match of matches) {
+				const fp = match[1].trim();
+				if (!files.includes(fp)) files.push(fp);
+			}
+		}
+	}
+
+	return files;
+}
+
+function extractDataFromToolResult(
+	toolName: string,
+	content: unknown,
+): {
+	patch?: string;
+	writeContent?: string;
+	artifact?: FileOperation['artifact'];
+} {
+	if (!content || typeof content !== 'object') return {};
+
+	const c = content as ToolResultData;
+	const args = c.args as Record<string, unknown> | undefined;
+	const name = toolName.toLowerCase();
+
+	let patch: string | undefined;
+	let writeContent: string | undefined;
+	let artifact: FileOperation['artifact'] | undefined;
+
+	if (name === 'applypatch' || name === 'apply_patch') {
+		patch = (args?.patch as string | undefined) ?? c.patch;
+	}
+
+	if (name === 'write') {
+		writeContent = args?.content as string | undefined;
+	}
+
+	const rawArtifact = c.result?.artifact ?? c.artifact;
+	if (rawArtifact && typeof rawArtifact === 'object') {
+		artifact = {
+			kind: rawArtifact.kind || 'unknown',
+			patch: rawArtifact.patch,
+			summary: rawArtifact.summary
+				? {
+						additions: rawArtifact.summary.additions || 0,
+						deletions: rawArtifact.summary.deletions || 0,
+					}
+				: undefined,
+		};
+	}
+
+	return { patch, writeContent, artifact };
+}
+
+function getOperationType(
+	toolName: string,
+): 'write' | 'patch' | 'edit' | 'create' {
+	const name = toolName.toLowerCase();
+	if (name === 'write') return 'write';
+	if (name === 'applypatch' || name === 'apply_patch') return 'patch';
+	if (name === 'edit') return 'edit';
+	return 'write';
+}
+
+export function registerSessionFilesRoutes(app: Hono) {
+	app.get('/v1/sessions/:sessionId/files', async (c) => {
+		try {
+			const sessionId = c.req.param('sessionId');
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+			const db = await getDb(cfg.projectRoot);
+
+			const sessionRows = await db
+				.select()
+				.from(sessions)
+				.where(eq(sessions.id, sessionId))
+				.limit(1);
+
+			if (!sessionRows.length) {
+				return c.json({ error: 'Session not found' }, 404);
+			}
+
+			const messageRows = await db
+				.select({ id: messages.id })
+				.from(messages)
+				.where(eq(messages.sessionId, sessionId));
+
+			const messageIds = messageRows.map((m) => m.id);
+
+			if (!messageIds.length) {
+				return c.json({
+					files: [],
+					totalFiles: 0,
+					totalOperations: 0,
+				});
+			}
+
+			const parts = await db
+				.select()
+				.from(messageParts)
+				.where(
+					and(
+						inArray(messageParts.messageId, messageIds),
+						inArray(messageParts.toolName, FILE_EDIT_TOOLS),
+					),
+				);
+
+			const fileOperationsMap = new Map<string, FileOperation[]>();
+			const toolCallDataMap = new Map<
+				string,
+				{ patch?: string; content?: string }
+			>();
+
+			for (const part of parts) {
+				if (!part.toolName) continue;
+
+				let content: unknown;
+				try {
+					content = JSON.parse(part.content);
+				} catch {
+					continue;
+				}
+
+				if (part.type === 'tool_call') {
+					const callId = part.toolCallId || part.id;
+					const patch = extractPatchFromToolCall(part.toolName, content);
+					const writeContent = extractContentFromToolCall(
+						part.toolName,
+						content,
+					);
+
+					toolCallDataMap.set(callId, { patch, content: writeContent });
+
+					const path = extractFilePathFromToolCall(part.toolName, content);
+					if (path) {
+						const operation: FileOperation = {
+							path,
+							operation: getOperationType(part.toolName),
+							timestamp: part.startedAt || Date.now(),
+							toolCallId: callId,
+							toolName: part.toolName,
+							patch,
+							content: writeContent,
+						};
+
+						const existing = fileOperationsMap.get(path) || [];
+						const isDuplicate = existing.some(
+							(op) => op.toolCallId === operation.toolCallId,
+						);
+						if (!isDuplicate) {
+							existing.push(operation);
+							fileOperationsMap.set(path, existing);
+						}
+					}
+				} else if (part.type === 'tool_result') {
+					const filePaths = extractFilesFromToolResult(part.toolName, content);
+					const { patch, writeContent, artifact } = extractDataFromToolResult(
+						part.toolName,
+						content,
+					);
+					const callId = part.toolCallId || part.id;
+					const callData = toolCallDataMap.get(callId);
+
+					for (const filePath of filePaths) {
+						if (!filePath) continue;
+
+						const existing = fileOperationsMap.get(filePath) || [];
+						const existingOp = existing.find((op) => op.toolCallId === callId);
+
+						if (existingOp) {
+							existingOp.artifact = artifact;
+							existingOp.timestamp = part.completedAt || existingOp.timestamp;
+							if (!existingOp.patch && patch) {
+								existingOp.patch = patch;
+							}
+							if (!existingOp.content && writeContent) {
+								existingOp.content = writeContent;
+							}
+						} else {
+							const operation: FileOperation = {
+								path: filePath,
+								operation: getOperationType(part.toolName),
+								timestamp: part.completedAt || part.startedAt || Date.now(),
+								toolCallId: callId,
+								toolName: part.toolName,
+								patch: callData?.patch ?? patch,
+								content: callData?.content ?? writeContent,
+								artifact,
+							};
+							existing.push(operation);
+							fileOperationsMap.set(filePath, existing);
+						}
+					}
+				}
+			}
+
+			const files: SessionFile[] = [];
+			for (const [path, operations] of fileOperationsMap) {
+				operations.sort((a, b) => a.timestamp - b.timestamp);
+				files.push({
+					path,
+					operations,
+					operationCount: operations.length,
+					firstModified: operations[0]?.timestamp || 0,
+					lastModified: operations[operations.length - 1]?.timestamp || 0,
+				});
+			}
+
+			files.sort((a, b) => b.lastModified - a.lastModified);
+
+			return c.json({
+				files,
+				totalFiles: files.length,
+				totalOperations: parts.length,
+			});
+		} catch (error) {
+			logger.error('Failed to get session files', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}