@agi-cli/server 0.1.119 → 0.1.120

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/server",
-	"version": "0.1.119",
+	"version": "0.1.120",
 	"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.119",
-		"@agi-cli/database": "0.1.119",
+		"@agi-cli/sdk": "0.1.120",
+		"@agi-cli/database": "0.1.120",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.1.8"

package/src/index.ts

@@ -14,6 +14,7 @@ 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 { registerBranchRoutes } from './routes/branch.ts';
 import type { AgentConfigEntry } from './runtime/agent-registry.ts';
 
 const globalTerminalManager = new TerminalManager();
@@ -64,6 +65,7 @@ function initApp() {
 	registerGitRoutes(app);
 	registerTerminalsRoutes(app, globalTerminalManager);
 	registerSessionFilesRoutes(app);
+	registerBranchRoutes(app);
 
 	return app;
 }
@@ -130,6 +132,7 @@ export function createStandaloneApp(_config?: StandaloneAppConfig) {
 	registerGitRoutes(honoApp);
 	registerTerminalsRoutes(honoApp, globalTerminalManager);
 	registerSessionFilesRoutes(honoApp);
+	registerBranchRoutes(honoApp);
 
 	return honoApp;
 }
@@ -224,6 +227,7 @@ export function createEmbeddedApp(config: EmbeddedAppConfig = {}) {
 	registerGitRoutes(honoApp);
 	registerTerminalsRoutes(honoApp, globalTerminalManager);
 	registerSessionFilesRoutes(honoApp);
+	registerBranchRoutes(honoApp);
 
 	return honoApp;
 }

package/src/routes/branch.ts

@@ -0,0 +1,106 @@
+import type { Hono } from 'hono';
+import { loadConfig } from '@agi-cli/sdk';
+import { getDb } from '@agi-cli/database';
+import { isProviderId, logger } from '@agi-cli/sdk';
+import {
+	createBranch,
+	listBranches,
+	getParentSession,
+} from '../runtime/branch.ts';
+import { serializeError } from '../runtime/api-error.ts';
+
+export function registerBranchRoutes(app: Hono) {
+	app.post('/v1/sessions/:sessionId/branch', 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 body = (await c.req.json().catch(() => ({}))) as Record<
+				string,
+				unknown
+			>;
+
+			const fromMessageId = body.fromMessageId;
+			if (typeof fromMessageId !== 'string' || !fromMessageId.trim()) {
+				return c.json({ error: 'fromMessageId is required' }, 400);
+			}
+
+			const provider =
+				typeof body.provider === 'string' && isProviderId(body.provider)
+					? body.provider
+					: undefined;
+
+			const model =
+				typeof body.model === 'string' && body.model.trim()
+					? body.model.trim()
+					: undefined;
+
+			const agent =
+				typeof body.agent === 'string' && body.agent.trim()
+					? body.agent.trim()
+					: undefined;
+
+			const title =
+				typeof body.title === 'string' && body.title.trim()
+					? body.title.trim()
+					: undefined;
+
+			const result = await createBranch({
+				db,
+				parentSessionId: sessionId,
+				fromMessageId: fromMessageId.trim(),
+				provider,
+				model,
+				agent,
+				title,
+				projectPath: cfg.projectRoot,
+			});
+
+			return c.json(result, 201);
+		} catch (err) {
+			logger.error('Failed to create branch', err);
+			const errorResponse = serializeError(err);
+			return c.json(errorResponse, errorResponse.error.status || 400);
+		}
+	});
+
+	app.get('/v1/sessions/:sessionId/branches', 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 branches = await listBranches(db, sessionId, cfg.projectRoot);
+
+			return c.json({ branches });
+		} catch (err) {
+			logger.error('Failed to list branches', err);
+			const errorResponse = serializeError(err);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.get('/v1/sessions/:sessionId/parent', 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 parent = await getParentSession(db, sessionId, cfg.projectRoot);
+
+			if (!parent) {
+				return c.json({ parent: null });
+			}
+
+			return c.json({ parent });
+		} catch (err) {
+			logger.error('Failed to get parent session', err);
+			const errorResponse = serializeError(err);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}

package/src/runtime/branch.ts

@@ -0,0 +1,277 @@
+import { eq, asc } from 'drizzle-orm';
+import type { DB } from '@agi-cli/database';
+import { sessions, messages, messageParts } from '@agi-cli/database/schema';
+import { publish } from '../events/bus.ts';
+import type { ProviderId } from '@agi-cli/sdk';
+
+type SessionRow = typeof sessions.$inferSelect;
+
+export type CreateBranchInput = {
+	db: DB;
+	parentSessionId: string;
+	fromMessageId: string;
+	provider?: ProviderId;
+	model?: string;
+	agent?: string;
+	title?: string;
+	projectPath: string;
+};
+
+export type BranchResult = {
+	session: SessionRow;
+	parentSessionId: string;
+	branchPointMessageId: string;
+	copiedMessages: number;
+	copiedParts: number;
+};
+
+export async function createBranch({
+	db,
+	parentSessionId,
+	fromMessageId,
+	provider,
+	model,
+	agent,
+	title,
+	projectPath,
+}: CreateBranchInput): Promise<BranchResult> {
+	const parentRows = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.id, parentSessionId));
+
+	if (!parentRows.length) {
+		throw new Error('Parent session not found');
+	}
+
+	const parent = parentRows[0];
+
+	if (parent.projectPath !== projectPath) {
+		throw new Error('Parent session not found in this project');
+	}
+
+	const branchPointRows = await db
+		.select()
+		.from(messages)
+		.where(eq(messages.id, fromMessageId));
+
+	if (!branchPointRows.length) {
+		throw new Error('Branch point message not found');
+	}
+
+	const branchPoint = branchPointRows[0];
+
+	if (branchPoint.sessionId !== parentSessionId) {
+		throw new Error('Branch point message does not belong to parent session');
+	}
+
+	const allMessages = await db
+		.select()
+		.from(messages)
+		.where(eq(messages.sessionId, parentSessionId))
+		.orderBy(asc(messages.createdAt));
+
+	const branchPointIndex = allMessages.findIndex((m) => m.id === fromMessageId);
+	if (branchPointIndex === -1) {
+		throw new Error('Branch point message not found in session');
+	}
+
+	const messagesToCopy = allMessages.slice(0, branchPointIndex + 1);
+
+	const newSessionId = crypto.randomUUID();
+	const now = Date.now();
+
+	const newSession: typeof sessions.$inferInsert = {
+		id: newSessionId,
+		title: title || `Branch of ${parent.title || 'Untitled'}`,
+		agent: agent || parent.agent,
+		provider: provider || parent.provider,
+		model: model || parent.model,
+		projectPath: parent.projectPath,
+		createdAt: now,
+		lastActiveAt: now,
+		parentSessionId,
+		branchPointMessageId: fromMessageId,
+		sessionType: 'branch',
+	};
+
+	await db.insert(sessions).values(newSession);
+
+	const messageIdMap = new Map<string, string>();
+	let copiedParts = 0;
+
+	for (const msg of messagesToCopy) {
+		const newMessageId = crypto.randomUUID();
+		messageIdMap.set(msg.id, newMessageId);
+
+		const newMessage: typeof messages.$inferInsert = {
+			id: newMessageId,
+			sessionId: newSessionId,
+			role: msg.role,
+			status: msg.status,
+			agent: msg.agent,
+			provider: msg.provider,
+			model: msg.model,
+			createdAt: msg.createdAt,
+			completedAt: msg.completedAt,
+			latencyMs: msg.latencyMs,
+			promptTokens: msg.promptTokens,
+			completionTokens: msg.completionTokens,
+			totalTokens: msg.totalTokens,
+			cachedInputTokens: msg.cachedInputTokens,
+			reasoningTokens: msg.reasoningTokens,
+			error: msg.error,
+			errorType: msg.errorType,
+			errorDetails: msg.errorDetails,
+			isAborted: msg.isAborted,
+		};
+
+		await db.insert(messages).values(newMessage);
+
+		const parts = await db
+			.select()
+			.from(messageParts)
+			.where(eq(messageParts.messageId, msg.id))
+			.orderBy(asc(messageParts.index));
+
+		for (const part of parts) {
+			const newPart: typeof messageParts.$inferInsert = {
+				id: crypto.randomUUID(),
+				messageId: newMessageId,
+				index: part.index,
+				stepIndex: part.stepIndex,
+				type: part.type,
+				content: part.content,
+				agent: part.agent,
+				provider: part.provider,
+				model: part.model,
+				startedAt: part.startedAt,
+				completedAt: part.completedAt,
+				compactedAt: part.compactedAt,
+				toolName: part.toolName,
+				toolCallId: part.toolCallId,
+				toolDurationMs: part.toolDurationMs,
+			};
+
+			await db.insert(messageParts).values(newPart);
+			copiedParts++;
+		}
+	}
+
+	const result: SessionRow = {
+		...newSession,
+		totalInputTokens: null,
+		totalOutputTokens: null,
+		totalCachedTokens: null,
+		totalReasoningTokens: null,
+		totalToolTimeMs: null,
+		toolCountsJson: null,
+		contextSummary: null,
+		lastCompactedAt: null,
+	};
+
+	publish({
+		type: 'session.created',
+		sessionId: newSessionId,
+		payload: result,
+	});
+
+	return {
+		session: result,
+		parentSessionId,
+		branchPointMessageId: fromMessageId,
+		copiedMessages: messagesToCopy.length,
+		copiedParts,
+	};
+}
+
+export type ListBranchesResult = Array<{
+	session: SessionRow;
+	branchPointMessageId: string | null;
+	branchPointPreview: string | null;
+	createdAt: number;
+}>;
+
+export async function listBranches(
+	db: DB,
+	sessionId: string,
+	projectPath: string,
+): Promise<ListBranchesResult> {
+	const branches = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.parentSessionId, sessionId))
+		.orderBy(asc(sessions.createdAt));
+
+	const results: ListBranchesResult = [];
+
+	for (const branch of branches) {
+		if (branch.projectPath !== projectPath) continue;
+
+		let preview: string | null = null;
+
+		if (branch.branchPointMessageId) {
+			const msgRows = await db
+				.select()
+				.from(messages)
+				.where(eq(messages.id, branch.branchPointMessageId));
+
+			if (msgRows.length > 0) {
+				const parts = await db
+					.select()
+					.from(messageParts)
+					.where(eq(messageParts.messageId, branch.branchPointMessageId))
+					.orderBy(asc(messageParts.index));
+
+				for (const part of parts) {
+					if (part.type === 'text') {
+						try {
+							const content = JSON.parse(part.content || '{}');
+							if (content.text) {
+								preview = content.text.slice(0, 100);
+								break;
+							}
+						} catch {}
+					}
+				}
+			}
+		}
+
+		results.push({
+			session: branch,
+			branchPointMessageId: branch.branchPointMessageId,
+			branchPointPreview: preview,
+			createdAt: branch.createdAt,
+		});
+	}
+
+	return results;
+}
+
+export async function getParentSession(
+	db: DB,
+	sessionId: string,
+	projectPath: string,
+): Promise<SessionRow | null> {
+	const sessionRows = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.id, sessionId));
+
+	if (!sessionRows.length) return null;
+
+	const session = sessionRows[0];
+	if (!session.parentSessionId) return null;
+
+	const parentRows = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.id, session.parentSessionId));
+
+	if (!parentRows.length) return null;
+
+	const parent = parentRows[0];
+	if (parent.projectPath !== projectPath) return null;
+
+	return parent;
+}