@ottocode/server 0.1.173

package/src/routes/files.ts

@@ -0,0 +1,218 @@
+import type { Hono } from 'hono';
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { serializeError } from '../runtime/errors/api-error.ts';
+import { logger } from '@ottocode/sdk';
+
+const execAsync = promisify(exec);
+
+const EXCLUDED_PATTERNS = [
+	'node_modules',
+	'.git',
+	'dist',
+	'build',
+	'.next',
+	'.nuxt',
+	'.turbo',
+	'coverage',
+	'.cache',
+	'.DS_Store',
+	'bun.lockb',
+	'.env',
+	'.env.local',
+	'.env.production',
+	'.env.development',
+];
+
+function shouldExclude(name: string): boolean {
+	for (const pattern of EXCLUDED_PATTERNS) {
+		if (pattern.includes('*')) {
+			const regex = new RegExp(`^${pattern.replace(/\*/g, '.*')}$`);
+			if (regex.test(name)) return true;
+		} else if (name === pattern || name.endsWith(pattern)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+async function parseGitignore(projectRoot: string): Promise<Set<string>> {
+	const patterns = new Set<string>();
+	try {
+		const gitignorePath = join(projectRoot, '.gitignore');
+		const content = await readFile(gitignorePath, 'utf-8');
+		for (const line of content.split('\n')) {
+			const trimmed = line.trim();
+			if (trimmed && !trimmed.startsWith('#')) {
+				patterns.add(trimmed);
+			}
+		}
+	} catch (_err) {}
+	return patterns;
+}
+
+function matchesGitignorePattern(
+	relativePath: string,
+	patterns: Set<string>,
+): boolean {
+	for (const pattern of patterns) {
+		const cleanPattern = pattern.replace(/^\//, '').replace(/\/$/, '');
+		const pathParts = relativePath.split('/');
+
+		if (pattern.endsWith('/')) {
+			if (pathParts[0] === cleanPattern) return true;
+			if (relativePath.startsWith(`${cleanPattern}/`)) return true;
+		}
+
+		if (pattern.includes('*')) {
+			const regex = new RegExp(
+				`^${cleanPattern.replace(/\*/g, '.*').replace(/\?/g, '.')}$`,
+			);
+			if (regex.test(relativePath)) return true;
+			for (const part of pathParts) {
+				if (regex.test(part)) return true;
+			}
+		} else {
+			if (relativePath === cleanPattern) return true;
+			if (pathParts.includes(cleanPattern)) return true;
+			if (relativePath.startsWith(`${cleanPattern}/`)) return true;
+		}
+	}
+	return false;
+}
+
+async function traverseDirectory(
+	dir: string,
+	projectRoot: string,
+	maxDepth: number,
+	currentDepth = 0,
+	limit: number,
+	collected: string[] = [],
+	gitignorePatterns?: Set<string>,
+): Promise<{ files: string[]; truncated: boolean }> {
+	if (currentDepth >= maxDepth || collected.length >= limit) {
+		return { files: collected, truncated: collected.length >= limit };
+	}
+
+	try {
+		const entries = await readdir(dir, { withFileTypes: true });
+
+		for (const entry of entries) {
+			if (collected.length >= limit) {
+				return { files: collected, truncated: true };
+			}
+
+			if (shouldExclude(entry.name)) {
+				continue;
+			}
+
+			const fullPath = join(dir, entry.name);
+			const relativePath = relative(projectRoot, fullPath);
+
+			if (
+				gitignorePatterns &&
+				matchesGitignorePattern(relativePath, gitignorePatterns)
+			) {
+				continue;
+			}
+
+			if (entry.isDirectory()) {
+				const result = await traverseDirectory(
+					fullPath,
+					projectRoot,
+					maxDepth,
+					currentDepth + 1,
+					limit,
+					collected,
+					gitignorePatterns,
+				);
+				if (result.truncated) {
+					return result;
+				}
+			} else if (entry.isFile()) {
+				collected.push(relativePath);
+			}
+		}
+	} catch (err) {
+		logger.warn(`Failed to read directory ${dir}:`, err);
+	}
+
+	return { files: collected, truncated: false };
+}
+
+async function getChangedFiles(
+	projectRoot: string,
+): Promise<Map<string, string>> {
+	try {
+		const { stdout } = await execAsync('git status --porcelain', {
+			cwd: projectRoot,
+		});
+		const changedFiles = new Map<string, string>();
+		for (const line of stdout.split('\n')) {
+			if (line.length > 3) {
+				const statusCode = line.substring(0, 2).trim();
+				const filePath = line.substring(3).trim();
+
+				let status = 'modified';
+				if (statusCode.includes('A')) status = 'added';
+				else if (statusCode.includes('M')) status = 'modified';
+				else if (statusCode.includes('D')) status = 'deleted';
+				else if (statusCode.includes('R')) status = 'renamed';
+				else if (statusCode.includes('?')) status = 'untracked';
+
+				changedFiles.set(filePath, status);
+			}
+		}
+		return changedFiles;
+	} catch (_err) {
+		return new Set();
+	}
+}
+
+export function registerFilesRoutes(app: Hono) {
+	app.get('/v1/files', async (c) => {
+		try {
+			const projectRoot = c.req.query('project') || process.cwd();
+			const maxDepth = Number.parseInt(c.req.query('maxDepth') || '10', 10);
+			const limit = Number.parseInt(c.req.query('limit') || '1000', 10);
+
+			const gitignorePatterns = await parseGitignore(projectRoot);
+
+			const result = await traverseDirectory(
+				projectRoot,
+				projectRoot,
+				maxDepth,
+				0,
+				limit,
+				[],
+				gitignorePatterns,
+			);
+
+			const changedFiles = await getChangedFiles(projectRoot);
+
+			result.files.sort((a, b) => {
+				const aChanged = changedFiles.has(a);
+				const bChanged = changedFiles.has(b);
+				if (aChanged && !bChanged) return -1;
+				if (!aChanged && bChanged) return 1;
+				return a.localeCompare(b);
+			});
+
+			return c.json({
+				files: result.files,
+				changedFiles: Array.from(changedFiles.entries()).map(
+					([path, status]) => ({
+						path,
+						status,
+					}),
+				),
+				truncated: result.truncated,
+			});
+		} catch (err) {
+			logger.error('Files route error:', err);
+			return c.json({ error: serializeError(err) }, 500);
+		}
+	});
+}

package/src/routes/git/branch.ts

@@ -0,0 +1,75 @@
+import type { Hono } from 'hono';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { gitStatusSchema } from './schemas.ts';
+import {
+	validateAndGetGitRoot,
+	getAheadBehind,
+	getCurrentBranch,
+} from './utils.ts';
+
+const execFileAsync = promisify(execFile);
+
+export function registerBranchRoute(app: Hono) {
+	app.get('/v1/git/branch', async (c) => {
+		try {
+			const query = gitStatusSchema.parse({
+				project: c.req.query('project'),
+			});
+
+			const requestedPath = query.project || process.cwd();
+
+			const validation = await validateAndGetGitRoot(requestedPath);
+			if ('error' in validation) {
+				return c.json(
+					{ status: 'error', error: validation.error, code: validation.code },
+					400,
+				);
+			}
+
+			const { gitRoot } = validation;
+
+			const branch = await getCurrentBranch(gitRoot);
+
+			const { ahead, behind } = await getAheadBehind(gitRoot);
+
+			try {
+				const { stdout: remotes } = await execFileAsync('git', ['remote'], {
+					cwd: gitRoot,
+				});
+				const remoteList = remotes.trim().split('\n').filter(Boolean);
+
+				return c.json({
+					status: 'ok',
+					data: {
+						branch,
+						ahead,
+						behind,
+						remotes: remoteList,
+					},
+				});
+			} catch {
+				return c.json({
+					status: 'ok',
+					data: {
+						branch,
+						ahead,
+						behind,
+						remotes: [],
+					},
+				});
+			}
+		} catch (error) {
+			return c.json(
+				{
+					status: 'error',
+					error:
+						error instanceof Error
+							? error.message
+							: 'Failed to get branch info',
+				},
+				500,
+			);
+		}
+	});
+}

package/src/routes/git/commit.ts

@@ -0,0 +1,209 @@
+import type { Hono } from 'hono';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { generateText, streamText } from 'ai';
+import { eq } from 'drizzle-orm';
+import type { ProviderId } from '@ottocode/sdk';
+import { loadConfig, getAuth, getFastModelForAuth } from '@ottocode/sdk';
+import { getDb } from '@ottocode/database';
+import { sessions } from '@ottocode/database/schema';
+import { gitCommitSchema, gitGenerateCommitMessageSchema } from './schemas.ts';
+import { validateAndGetGitRoot, parseGitStatus } from './utils.ts';
+import { resolveModel } from '../../runtime/provider/index.ts';
+import { debugLog } from '../../runtime/debug/index.ts';
+import {
+	detectOAuth,
+	adaptSimpleCall,
+} from '../../runtime/provider/oauth-adapter.ts';
+
+const execFileAsync = promisify(execFile);
+
+export function registerCommitRoutes(app: Hono) {
+	app.post('/v1/git/commit', async (c) => {
+		try {
+			const body = await c.req.json();
+			const { message, project } = gitCommitSchema.parse(body);
+
+			const requestedPath = project || process.cwd();
+
+			const validation = await validateAndGetGitRoot(requestedPath);
+			if ('error' in validation) {
+				return c.json(
+					{ status: 'error', error: validation.error, code: validation.code },
+					400,
+				);
+			}
+
+			const { gitRoot } = validation;
+
+			const { stdout } = await execFileAsync('git', ['commit', '-m', message], {
+				cwd: gitRoot,
+			});
+
+			return c.json({
+				status: 'ok',
+				data: {
+					message: stdout.trim(),
+				},
+			});
+		} catch (error) {
+			return c.json(
+				{
+					status: 'error',
+					error: error instanceof Error ? error.message : 'Failed to commit',
+				},
+				500,
+			);
+		}
+	});
+
+	app.post('/v1/git/generate-commit-message', async (c) => {
+		try {
+			const body = await c.req.json();
+			const { project, sessionId } = gitGenerateCommitMessageSchema.parse(body);
+
+			const requestedPath = project || process.cwd();
+
+			const validation = await validateAndGetGitRoot(requestedPath);
+			if ('error' in validation) {
+				return c.json(
+					{ status: 'error', error: validation.error, code: validation.code },
+					400,
+				);
+			}
+
+			const { gitRoot } = validation;
+
+			const { stdout: diff } = await execFileAsync(
+				'git',
+				['diff', '--cached'],
+				{
+					cwd: gitRoot,
+				},
+			);
+
+			if (!diff.trim()) {
+				return c.json(
+					{
+						status: 'error',
+						error: 'No staged changes to generate message from',
+					},
+					400,
+				);
+			}
+
+			const { stdout: statusOutput } = await execFileAsync(
+				'git',
+				['status', '--porcelain=v2'],
+				{ cwd: gitRoot },
+			);
+			const { staged } = parseGitStatus(statusOutput, gitRoot);
+			const fileList = staged.map((f) => `${f.status}: ${f.path}`).join('\n');
+
+			const config = await loadConfig();
+
+			let provider = (config.defaults?.provider || 'anthropic') as ProviderId;
+
+			if (sessionId) {
+				const db = await getDb();
+				const [session] = await db
+					.select({ provider: sessions.provider })
+					.from(sessions)
+					.where(eq(sessions.id, sessionId));
+				if (session?.provider) {
+					provider = session.provider as ProviderId;
+				}
+			}
+
+			const auth = await getAuth(provider, config.projectRoot);
+			const oauth = detectOAuth(provider, auth);
+
+			const modelId =
+				getFastModelForAuth(provider, auth?.type) ??
+				config.defaults?.model ??
+				'claude-3-5-sonnet-20241022';
+			const model = await resolveModel(provider, modelId, config);
+
+			const userPrompt = `Generate a commit message for these git changes.
+
+Staged files:
+${fileList}
+
+Diff (first 4000 chars):
+${diff.slice(0, 4000)}
+
+Guidelines:
+- CAREFULLY READ the diff above - describe what ACTUALLY changed
+- Use conventional commits format: type(scope): description
+- First line under 72 characters
+- Add a blank line, then 2-4 short bullet points
+- Each bullet describes ONE specific change you see in the diff
+- Be ACCURATE - don't invent changes that aren't in the diff
+- Keep bullets short (under 80 chars each)
+- Do not include markdown code blocks or backticks
+- Return ONLY the commit message text, nothing else
+
+Example (for a diff that adds boolean returns to functions):
+refactor(auth): return success status from login functions
+
+- Add boolean return type to auth functions
+- Return false on user cancellation or failure
+- Check return value before proceeding with auth flow
+
+Commit message:`;
+
+			const commitInstructions =
+				'You are a helpful assistant that generates accurate git commit messages based on the actual diff content.';
+
+			const adapted = adaptSimpleCall(oauth, {
+				instructions: commitInstructions,
+				userContent: userPrompt,
+				maxOutputTokens: 500,
+			});
+
+			if (adapted.forceStream) {
+				debugLog('[COMMIT] Using streamText for OpenAI OAuth');
+				const result = streamText({
+					model,
+					system: adapted.system,
+					messages: adapted.messages,
+					providerOptions: adapted.providerOptions,
+				});
+				let text = '';
+				for await (const chunk of result.textStream) {
+					text += chunk;
+				}
+				const message = text.trim();
+				debugLog(`[COMMIT] OAuth result: "${message.slice(0, 80)}..."`);
+				return c.json({ status: 'ok', data: { message } });
+			}
+
+			const { text } = await generateText({
+				model,
+				system: adapted.system,
+				messages: adapted.messages,
+				maxOutputTokens: adapted.maxOutputTokens,
+			});
+
+			const message = text.trim();
+
+			return c.json({
+				status: 'ok',
+				data: {
+					message,
+				},
+			});
+		} catch (error) {
+			return c.json(
+				{
+					status: 'error',
+					error:
+						error instanceof Error
+							? error.message
+							: 'Failed to generate commit message',
+				},
+				500,
+			);
+		}
+	});
+}

package/src/routes/git/diff.ts

@@ -0,0 +1,137 @@
+import type { Hono } from 'hono';
+import { execFile } from 'node:child_process';
+import { join } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { promisify } from 'node:util';
+import { gitDiffSchema } from './schemas.ts';
+import {
+	validateAndGetGitRoot,
+	checkIfNewFile,
+	inferLanguage,
+	summarizeDiff,
+} from './utils.ts';
+
+const execFileAsync = promisify(execFile);
+
+export function registerDiffRoute(app: Hono) {
+	app.get('/v1/git/diff', async (c) => {
+		try {
+			const query = gitDiffSchema.parse({
+				project: c.req.query('project'),
+				file: c.req.query('file'),
+				staged: c.req.query('staged'),
+			});
+
+			const requestedPath = query.project || process.cwd();
+
+			const validation = await validateAndGetGitRoot(requestedPath);
+			if ('error' in validation) {
+				return c.json(
+					{ status: 'error', error: validation.error, code: validation.code },
+					400,
+				);
+			}
+
+			const { gitRoot } = validation;
+			const absPath = join(gitRoot, query.file);
+
+			const isNewFile = await checkIfNewFile(gitRoot, query.file);
+
+			if (isNewFile) {
+				try {
+					const content = await readFile(absPath, 'utf-8');
+					const lineCount = content.split('\n').length;
+					const language = inferLanguage(query.file);
+
+					return c.json({
+						status: 'ok',
+						data: {
+							file: query.file,
+							absPath,
+							diff: '',
+							content,
+							isNewFile: true,
+							isBinary: false,
+							insertions: lineCount,
+							deletions: 0,
+							language,
+							staged: !!query.staged,
+						},
+					});
+				} catch (error) {
+					return c.json(
+						{
+							status: 'error',
+							error:
+								error instanceof Error ? error.message : 'Failed to read file',
+						},
+						500,
+					);
+				}
+			}
+
+			const diffArgs = query.staged
+				? ['diff', '--cached', '--', query.file]
+				: ['diff', '--', query.file];
+			const numstatArgs = query.staged
+				? ['diff', '--cached', '--numstat', '--', query.file]
+				: ['diff', '--numstat', '--', query.file];
+
+			const [{ stdout: diffOutput }, { stdout: numstatOutput }] =
+				await Promise.all([
+					execFileAsync('git', diffArgs, { cwd: gitRoot }),
+					execFileAsync('git', numstatArgs, { cwd: gitRoot }),
+				]);
+
+			let insertions = 0;
+			let deletions = 0;
+			let binary = false;
+
+			const numstatLine = numstatOutput.trim().split('\n').find(Boolean);
+			if (numstatLine) {
+				const [rawInsertions, rawDeletions] = numstatLine.split('\t');
+				if (rawInsertions === '-' || rawDeletions === '-') {
+					binary = true;
+				} else {
+					insertions = Number.parseInt(rawInsertions, 10) || 0;
+					deletions = Number.parseInt(rawDeletions, 10) || 0;
+				}
+			}
+
+			const diffText = diffOutput ?? '';
+			if (!binary) {
+				const summary = summarizeDiff(diffText);
+				binary = summary.binary;
+				if (insertions === 0 && deletions === 0) {
+					insertions = summary.insertions;
+					deletions = summary.deletions;
+				}
+			}
+
+			const language = inferLanguage(query.file);
+
+			return c.json({
+				status: 'ok',
+				data: {
+					file: query.file,
+					absPath,
+					diff: diffText,
+					isNewFile: false,
+					isBinary: binary,
+					insertions,
+					deletions,
+					language,
+					staged: !!query.staged,
+				},
+			});
+		} catch (error) {
+			return c.json(
+				{
+					status: 'error',
+					error: error instanceof Error ? error.message : 'Failed to get diff',
+				},
+				500,
+			);
+		}
+	});
+}

package/src/routes/git/index.ts

@@ -0,0 +1,18 @@
+import type { Hono } from 'hono';
+import { registerStatusRoute } from './status.ts';
+import { registerBranchRoute } from './branch.ts';
+import { registerDiffRoute } from './diff.ts';
+import { registerStagingRoutes } from './staging.ts';
+import { registerCommitRoutes } from './commit.ts';
+import { registerPushRoute } from './push.ts';
+
+export type { GitFile } from './types.ts';
+
+export function registerGitRoutes(app: Hono) {
+	registerStatusRoute(app);
+	registerBranchRoute(app);
+	registerDiffRoute(app);
+	registerStagingRoutes(app);
+	registerCommitRoutes(app);
+	registerPushRoute(app);
+}