@ottocode/server 0.1.173

package/src/routes/git/utils.ts

@@ -0,0 +1,249 @@
+import { execFile } from 'node:child_process';
+import { extname, join } from 'node:path';
+import { promisify } from 'node:util';
+import type { GitFile, GitRoot, GitError } from './types.ts';
+
+const execFileAsync = promisify(execFile);
+
+const LANGUAGE_MAP: Record<string, string> = {
+	js: 'javascript',
+	jsx: 'jsx',
+	ts: 'typescript',
+	tsx: 'tsx',
+	py: 'python',
+	rb: 'ruby',
+	go: 'go',
+	rs: 'rust',
+	java: 'java',
+	c: 'c',
+	cpp: 'cpp',
+	h: 'c',
+	hpp: 'cpp',
+	cs: 'csharp',
+	php: 'php',
+	sh: 'bash',
+	bash: 'bash',
+	zsh: 'bash',
+	sql: 'sql',
+	json: 'json',
+	yaml: 'yaml',
+	yml: 'yaml',
+	xml: 'xml',
+	html: 'html',
+	css: 'css',
+	scss: 'scss',
+	md: 'markdown',
+	txt: 'plaintext',
+	svelte: 'svelte',
+};
+
+export function inferLanguage(filePath: string): string {
+	const extension = extname(filePath).toLowerCase().replace('.', '');
+	if (!extension) {
+		return 'plaintext';
+	}
+	return LANGUAGE_MAP[extension] ?? 'plaintext';
+}
+
+export function summarizeDiff(diff: string): {
+	insertions: number;
+	deletions: number;
+	binary: boolean;
+} {
+	let insertions = 0;
+	let deletions = 0;
+	let binary = false;
+
+	for (const line of diff.split('\n')) {
+		if (line.startsWith('Binary files ') || line.includes('GIT binary patch')) {
+			binary = true;
+			break;
+		}
+
+		if (line.startsWith('+') && !line.startsWith('+++')) {
+			insertions++;
+		} else if (line.startsWith('-') && !line.startsWith('---')) {
+			deletions++;
+		}
+	}
+
+	return { insertions, deletions, binary };
+}
+
+export async function validateAndGetGitRoot(
+	requestedPath: string,
+): Promise<GitRoot | GitError> {
+	try {
+		const { stdout: gitRoot } = await execFileAsync(
+			'git',
+			['rev-parse', '--show-toplevel'],
+			{
+				cwd: requestedPath,
+			},
+		);
+		return { gitRoot: gitRoot.trim() };
+	} catch {
+		return {
+			error: 'Not a git repository',
+			code: 'NOT_A_GIT_REPO',
+		};
+	}
+}
+
+export async function checkIfNewFile(
+	gitRoot: string,
+	file: string,
+): Promise<boolean> {
+	try {
+		await execFileAsync('git', ['ls-files', '--error-unmatch', file], {
+			cwd: gitRoot,
+		});
+		return false;
+	} catch {
+		return true;
+	}
+}
+
+function getStatusFromCodeV2(code: string): GitFile['status'] {
+	switch (code) {
+		case 'M':
+			return 'modified';
+		case 'A':
+			return 'added';
+		case 'D':
+			return 'deleted';
+		case 'R':
+			return 'renamed';
+		case 'C':
+			return 'modified';
+		default:
+			return 'modified';
+	}
+}
+
+function getConflictType(xy: string): GitFile['conflictType'] {
+	switch (xy) {
+		case 'UU':
+			return 'both-modified';
+		case 'AA':
+			return 'both-added';
+		case 'DD':
+			return 'both-deleted';
+		case 'DU':
+		case 'UD':
+			return 'deleted-by-us';
+		case 'AU':
+		case 'UA':
+			return 'deleted-by-them';
+		default:
+			return 'both-modified';
+	}
+}
+
+export function parseGitStatus(
+	statusOutput: string,
+	gitRoot: string,
+): {
+	staged: GitFile[];
+	unstaged: GitFile[];
+	untracked: GitFile[];
+	conflicted: GitFile[];
+} {
+	const lines = statusOutput.trim().split('\n').filter(Boolean);
+	const staged: GitFile[] = [];
+	const unstaged: GitFile[] = [];
+	const untracked: GitFile[] = [];
+	const conflicted: GitFile[] = [];
+
+	for (const line of lines) {
+		if (line.startsWith('1 ') || line.startsWith('2 ')) {
+			const parts = line.split(' ');
+			if (parts.length < 9) continue;
+
+			const xy = parts[1];
+			const x = xy[0];
+			const y = xy[1];
+			const path = parts.slice(8).join(' ');
+			const absPath = join(gitRoot, path);
+
+			if (x !== '.') {
+				staged.push({
+					path,
+					absPath,
+					status: getStatusFromCodeV2(x),
+					staged: true,
+					isNew: x === 'A',
+				});
+			}
+
+			if (y !== '.') {
+				unstaged.push({
+					path,
+					absPath,
+					status: getStatusFromCodeV2(y),
+					staged: false,
+					isNew: false,
+				});
+			}
+		} else if (line.startsWith('? ')) {
+			const path = line.slice(2);
+			const absPath = join(gitRoot, path);
+			untracked.push({
+				path,
+				absPath,
+				status: 'untracked',
+				staged: false,
+				isNew: true,
+			});
+		} else if (line.startsWith('u ')) {
+			const parts = line.split(' ');
+			if (parts.length < 11) continue;
+
+			const xy = parts[1];
+			const path = parts.slice(10).join(' ');
+			const absPath = join(gitRoot, path);
+
+			conflicted.push({
+				path,
+				absPath,
+				status: 'conflicted',
+				staged: false,
+				isNew: false,
+				conflictType: getConflictType(xy),
+			});
+		}
+	}
+
+	return { staged, unstaged, untracked, conflicted };
+}
+
+export async function getAheadBehind(
+	gitRoot: string,
+): Promise<{ ahead: number; behind: number }> {
+	try {
+		const { stdout } = await execFileAsync(
+			'git',
+			['rev-list', '--left-right', '--count', 'HEAD...@{upstream}'],
+			{ cwd: gitRoot },
+		);
+		const [ahead, behind] = stdout.trim().split(/\s+/).map(Number);
+		return { ahead: ahead || 0, behind: behind || 0 };
+	} catch {
+		return { ahead: 0, behind: 0 };
+	}
+}
+
+export async function getCurrentBranch(gitRoot: string): Promise<string> {
+	try {
+		const { stdout } = await execFileAsync(
+			'git',
+			['branch', '--show-current'],
+			{
+				cwd: gitRoot,
+			},
+		);
+		return stdout.trim();
+	} catch {
+		return 'unknown';
+	}
+}

package/src/routes/openapi.ts

@@ -0,0 +1,6 @@
+import type { Hono } from 'hono';
+import { getOpenAPISpec } from '../openapi/spec.ts';
+
+export function registerOpenApiRoute(app: Hono) {
+	app.get('/openapi.json', (c) => c.json(getOpenAPISpec()));
+}

package/src/routes/research.ts

@@ -0,0 +1,392 @@
+import type { Hono } from 'hono';
+import { loadConfig } from '@ottocode/sdk';
+import { getDb } from '@ottocode/database';
+import { sessions, messages, messageParts } from '@ottocode/database/schema';
+import { desc, eq, and, asc, count } from 'drizzle-orm';
+import type { ProviderId } from '@ottocode/sdk';
+import { isProviderId } from '@ottocode/sdk';
+import { serializeError } from '../runtime/errors/api-error.ts';
+import { logger } from '@ottocode/sdk';
+import { publish } from '../events/bus.ts';
+
+export function registerResearchRoutes(app: Hono) {
+	app.get('/v1/sessions/:parentId/research', async (c) => {
+		const parentId = c.req.param('parentId');
+		const projectRoot = c.req.query('project') || process.cwd();
+		const cfg = await loadConfig(projectRoot);
+		const db = await getDb(cfg.projectRoot);
+
+		const parentRows = await db
+			.select()
+			.from(sessions)
+			.where(eq(sessions.id, parentId))
+			.limit(1);
+
+		if (!parentRows.length || parentRows[0].projectPath !== cfg.projectRoot) {
+			return c.json({ error: 'Parent session not found' }, 404);
+		}
+
+		const researchRows = await db
+			.select({
+				id: sessions.id,
+				title: sessions.title,
+				createdAt: sessions.createdAt,
+				lastActiveAt: sessions.lastActiveAt,
+				provider: sessions.provider,
+				model: sessions.model,
+				totalInputTokens: sessions.totalInputTokens,
+				totalOutputTokens: sessions.totalOutputTokens,
+				totalCachedTokens: sessions.totalCachedTokens,
+				totalCacheCreationTokens: sessions.totalCacheCreationTokens,
+			})
+			.from(sessions)
+			.where(
+				and(
+					eq(sessions.parentSessionId, parentId),
+					eq(sessions.sessionType, 'research'),
+				),
+			)
+			.orderBy(desc(sessions.lastActiveAt), desc(sessions.createdAt));
+
+		const sessionsWithCounts = await Promise.all(
+			researchRows.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 c.json({ sessions: sessionsWithCounts });
+	});
+
+	app.post('/v1/sessions/:parentId/research', async (c) => {
+		const parentId = c.req.param('parentId');
+		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 parentRows = await db
+			.select()
+			.from(sessions)
+			.where(eq(sessions.id, parentId))
+			.limit(1);
+
+		if (!parentRows.length || parentRows[0].projectPath !== cfg.projectRoot) {
+			return c.json({ error: 'Parent session not found' }, 404);
+		}
+
+		const parent = parentRows[0];
+
+		const providerCandidate =
+			typeof body.provider === 'string' ? body.provider : undefined;
+		const provider: ProviderId = (() => {
+			if (providerCandidate && isProviderId(providerCandidate))
+				return providerCandidate;
+			return parent.provider as ProviderId;
+		})();
+
+		const modelCandidate =
+			typeof body.model === 'string' ? body.model.trim() : undefined;
+		const model = modelCandidate?.length ? modelCandidate : parent.model;
+
+		const id = crypto.randomUUID();
+		const now = Date.now();
+		const title = typeof body.title === 'string' ? body.title : null;
+
+		const row = {
+			id,
+			title,
+			agent: 'research',
+			provider,
+			model,
+			projectPath: cfg.projectRoot,
+			createdAt: now,
+			lastActiveAt: now,
+			parentSessionId: parentId,
+			sessionType: 'research',
+			totalInputTokens: null,
+			totalOutputTokens: null,
+			totalCachedTokens: null,
+			totalCacheCreationTokens: null,
+			totalReasoningTokens: null,
+			totalToolTimeMs: null,
+			toolCountsJson: null,
+		};
+
+		try {
+			await db.insert(sessions).values(row);
+			publish({ type: 'session.created', sessionId: id, payload: row });
+			return c.json({ session: row, parentSessionId: parentId }, 201);
+		} catch (err) {
+			logger.error('Failed to create research session', err);
+			const errorResponse = serializeError(err);
+			return c.json(errorResponse, errorResponse.error.status || 400);
+		}
+	});
+
+	app.delete('/v1/research/:researchId', async (c) => {
+		const researchId = c.req.param('researchId');
+		const projectRoot = c.req.query('project') || process.cwd();
+		const cfg = await loadConfig(projectRoot);
+		const db = await getDb(cfg.projectRoot);
+
+		const rows = await db
+			.select()
+			.from(sessions)
+			.where(eq(sessions.id, researchId))
+			.limit(1);
+
+		if (!rows.length) {
+			return c.json({ error: 'Research session not found' }, 404);
+		}
+
+		const session = rows[0];
+		if (session.projectPath !== cfg.projectRoot) {
+			return c.json(
+				{ error: 'Research session not found in this project' },
+				404,
+			);
+		}
+
+		if (session.sessionType !== 'research') {
+			return c.json({ error: 'Session is not a research session' }, 400);
+		}
+
+		await db.delete(sessions).where(eq(sessions.id, researchId));
+		publish({
+			type: 'session.deleted',
+			sessionId: researchId,
+			payload: { id: researchId },
+		});
+
+		return c.json({ success: true });
+	});
+
+	app.post('/v1/sessions/:parentId/inject', async (c) => {
+		const parentId = c.req.param('parentId');
+		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 researchSessionId =
+			typeof body.researchSessionId === 'string' ? body.researchSessionId : '';
+		const label =
+			typeof body.label === 'string' ? body.label : 'Research context';
+
+		if (!researchSessionId) {
+			return c.json({ error: 'researchSessionId is required' }, 400);
+		}
+
+		const [parentRows, researchRows] = await Promise.all([
+			db.select().from(sessions).where(eq(sessions.id, parentId)).limit(1),
+			db
+				.select()
+				.from(sessions)
+				.where(eq(sessions.id, researchSessionId))
+				.limit(1),
+		]);
+
+		if (!parentRows.length || parentRows[0].projectPath !== cfg.projectRoot) {
+			return c.json({ error: 'Parent session not found' }, 404);
+		}
+
+		if (!researchRows.length || researchRows[0].sessionType !== 'research') {
+			return c.json({ error: 'Research session not found' }, 404);
+		}
+
+		const _researchSession = researchRows[0];
+
+		const researchMessages = await db
+			.select({
+				id: messages.id,
+				role: messages.role,
+				createdAt: messages.createdAt,
+			})
+			.from(messages)
+			.where(eq(messages.sessionId, researchSessionId))
+			.orderBy(asc(messages.createdAt));
+
+		let contextContent = '';
+		for (const msg of researchMessages) {
+			if (msg.role === 'user' || msg.role === 'assistant') {
+				const parts = await db
+					.select({ type: messageParts.type, content: messageParts.content })
+					.from(messageParts)
+					.where(eq(messageParts.messageId, msg.id))
+					.orderBy(asc(messageParts.index));
+
+				for (const part of parts) {
+					if (part.type === 'text' && part.content) {
+						contextContent += `[${msg.role}]: ${part.content}\n\n`;
+					}
+				}
+			}
+		}
+
+		const injectedContext = `<research-context from="${researchSessionId}" label="${label}" injected-at="${new Date().toISOString()}">\n${contextContent}</research-context>`;
+
+		// Return the content to the client instead of creating a system message
+		// The client will store it in zustand and include it in the next user message
+		return c.json({
+			content: injectedContext,
+			label,
+			sessionId: researchSessionId,
+			parentSessionId: parentId,
+			tokenEstimate: Math.ceil(injectedContext.length / 4),
+		});
+	});
+
+	app.post('/v1/research/:researchId/export', async (c) => {
+		const researchId = c.req.param('researchId');
+		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 researchRows = await db
+			.select()
+			.from(sessions)
+			.where(eq(sessions.id, researchId))
+			.limit(1);
+
+		if (!researchRows.length || researchRows[0].sessionType !== 'research') {
+			return c.json({ error: 'Research session not found' }, 404);
+		}
+
+		const researchSession = researchRows[0];
+
+		if (researchSession.projectPath !== cfg.projectRoot) {
+			return c.json({ error: 'Research session not in this project' }, 404);
+		}
+
+		const providerCandidate =
+			typeof body.provider === 'string' ? body.provider : undefined;
+		const provider: ProviderId = (() => {
+			if (providerCandidate && isProviderId(providerCandidate))
+				return providerCandidate;
+			return cfg.defaults.provider;
+		})();
+
+		const modelCandidate =
+			typeof body.model === 'string' ? body.model.trim() : undefined;
+		const model = modelCandidate?.length ? modelCandidate : cfg.defaults.model;
+
+		const agentCandidate =
+			typeof body.agent === 'string' ? body.agent.trim() : undefined;
+		const agent = agentCandidate?.length ? agentCandidate : cfg.defaults.agent;
+
+		const researchMessages = await db
+			.select({
+				id: messages.id,
+				role: messages.role,
+				createdAt: messages.createdAt,
+			})
+			.from(messages)
+			.where(eq(messages.sessionId, researchId))
+			.orderBy(asc(messages.createdAt));
+
+		let contextContent = '';
+		for (const msg of researchMessages) {
+			if (msg.role === 'user' || msg.role === 'assistant') {
+				const parts = await db
+					.select({ type: messageParts.type, content: messageParts.content })
+					.from(messageParts)
+					.where(eq(messageParts.messageId, msg.id))
+					.orderBy(asc(messageParts.index));
+
+				for (const part of parts) {
+					if (part.type === 'text' && part.content) {
+						contextContent += `[${msg.role}]: ${part.content}\n\n`;
+					}
+				}
+			}
+		}
+
+		const injectedContext = `<research-context from="${researchId}" exported-at="${new Date().toISOString()}">\n${contextContent}</research-context>`;
+
+		const newSessionId = crypto.randomUUID();
+		const now = Date.now();
+
+		await db.insert(sessions).values({
+			id: newSessionId,
+			title: researchSession.title ? `From: ${researchSession.title}` : null,
+			agent,
+			provider,
+			model,
+			projectPath: cfg.projectRoot,
+			createdAt: now,
+			lastActiveAt: now,
+			parentSessionId: null,
+			sessionType: 'main',
+			totalInputTokens: null,
+			totalOutputTokens: null,
+			totalCachedTokens: null,
+			totalCacheCreationTokens: null,
+			totalReasoningTokens: null,
+			totalToolTimeMs: null,
+			toolCountsJson: null,
+		});
+
+		const msgId = crypto.randomUUID();
+		const partId = crypto.randomUUID();
+
+		await db.insert(messages).values({
+			id: msgId,
+			sessionId: newSessionId,
+			role: 'system',
+			status: 'complete',
+			agent,
+			provider,
+			model,
+			createdAt: now,
+			completedAt: now,
+		});
+
+		await db.insert(messageParts).values({
+			id: partId,
+			messageId: msgId,
+			index: 0,
+			type: 'text',
+			content: injectedContext,
+			agent,
+			provider,
+			model,
+		});
+
+		publish({
+			type: 'session.created',
+			sessionId: newSessionId,
+			payload: { id: newSessionId },
+		});
+
+		const newSession = await db
+			.select()
+			.from(sessions)
+			.where(eq(sessions.id, newSessionId))
+			.limit(1);
+
+		return c.json(
+			{
+				newSession: newSession[0],
+				injectedContext,
+			},
+			201,
+		);
+	});
+}

package/src/routes/root.ts

@@ -0,0 +1,5 @@
+import type { Hono } from 'hono';
+
+export function registerRootRoutes(app: Hono) {
+	app.get('/', (c) => c.text('otto server running'));
+}

package/src/routes/session-approval.ts

@@ -0,0 +1,63 @@
+import type { Hono } from 'hono';
+import {
+	resolveApproval,
+	getPendingApproval,
+	getPendingApprovalsForSession,
+} from '../runtime/tools/approval.ts';
+
+export function registerSessionApprovalRoute(app: Hono) {
+	app.post('/v1/sessions/:id/approval', async (c) => {
+		const sessionId = c.req.param('id');
+		const body = await c.req.json<{
+			callId: string;
+			approved: boolean;
+		}>();
+
+		if (!body.callId) {
+			return c.json({ ok: false, error: 'callId is required' }, 400);
+		}
+
+		if (typeof body.approved !== 'boolean') {
+			return c.json({ ok: false, error: 'approved must be a boolean' }, 400);
+		}
+
+		const pending = getPendingApproval(body.callId);
+		if (!pending) {
+			return c.json(
+				{ ok: false, error: 'No pending approval found for this callId' },
+				404,
+			);
+		}
+
+		if (pending.sessionId !== sessionId) {
+			return c.json(
+				{ ok: false, error: 'Approval does not belong to this session' },
+				403,
+			);
+		}
+
+		const result = resolveApproval(body.callId, body.approved);
+
+		if (!result.ok) {
+			return c.json(result, 404);
+		}
+
+		return c.json({ ok: true, callId: body.callId, approved: body.approved });
+	});
+
+	app.get('/v1/sessions/:id/approval/pending', async (c) => {
+		const sessionId = c.req.param('id');
+		const pending = getPendingApprovalsForSession(sessionId);
+
+		return c.json({
+			ok: true,
+			pending: pending.map((p) => ({
+				callId: p.callId,
+				toolName: p.toolName,
+				args: p.args,
+				messageId: p.messageId,
+				createdAt: p.createdAt,
+			})),
+		});
+	});
+}