@agi-cli/server 0.1.61 → 0.1.63

package/src/routes/git.ts

@@ -1,9 +1,9 @@
 import type { Hono } from 'hono';
 import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
 import { extname } from 'node:path';
+import { promisify } from 'node:util';
 import { z } from 'zod';
-import { generateText, resolveModel } from '@agi-cli/sdk';
+import { generateText, resolveModel, type ProviderId } from '@agi-cli/sdk';
 import { loadConfig } from '@agi-cli/sdk';
 
 const execFileAsync = promisify(execFile);
@@ -22,6 +22,71 @@ const gitDiffSchema = z.object({
 		.transform((val) => val === 'true'),
 });
 
+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',
+};
+
+function inferLanguage(filePath: string): string {
+	const extension = extname(filePath).toLowerCase().replace('.', '');
+	if (!extension) {
+		return 'plaintext';
+	}
+	return LANGUAGE_MAP[extension] ?? 'plaintext';
+}
+
+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 };
+}
+
 const gitStageSchema = z.object({
 	project: z.string().optional(),
 	files: z.array(z.string()),
@@ -41,6 +106,10 @@ const gitGenerateCommitMessageSchema = z.object({
 	project: z.string().optional(),
 });
 
+const gitPushSchema = z.object({
+	project: z.string().optional(),
+});
+
 // Types
 export interface GitFile {
 	path: string;
@@ -48,144 +117,75 @@ export interface GitFile {
 	staged: boolean;
 	insertions?: number;
 	deletions?: number;
-	oldPath?: string;
-}
-
-export interface GitStatus {
-	branch: string;
-	ahead: number;
-	behind: number;
-	staged: GitFile[];
-	unstaged: GitFile[];
-	untracked: GitFile[];
-	hasChanges: boolean;
 }
 
-// File extension to language mapping
-const languageMap: Record<string, string> = {
-	'.ts': 'typescript',
-	'.tsx': 'typescript',
-	'.js': 'javascript',
-	'.jsx': 'javascript',
-	'.py': 'python',
-	'.java': 'java',
-	'.c': 'c',
-	'.cpp': 'cpp',
-	'.go': 'go',
-	'.rs': 'rust',
-	'.rb': 'ruby',
-	'.php': 'php',
-	'.css': 'css',
-	'.html': 'html',
-	'.json': 'json',
-	'.xml': 'xml',
-	'.yaml': 'yaml',
-	'.yml': 'yaml',
-	'.md': 'markdown',
-	'.sh': 'bash',
-};
-
-function detectLanguage(filePath: string): string {
-	const ext = extname(filePath).toLowerCase();
-	return languageMap[ext] || 'plaintext';
+interface GitRoot {
+	gitRoot: string;
 }
 
-// Helper function to check if path is in a git repository
-async function isGitRepository(path: string): Promise<boolean> {
-	try {
-		await execFileAsync('git', ['rev-parse', '--git-dir'], { cwd: path });
-		return true;
-	} catch {
-		return false;
-	}
+interface GitError {
+	error: string;
+	code?: string;
 }
 
-// Helper function to find git root directory
-async function findGitRoot(startPath: string): Promise<string | null> {
+// Helper functions
+async function validateAndGetGitRoot(
+	requestedPath: string,
+): Promise<GitRoot | GitError> {
 	try {
-		const { stdout } = await execFileAsync(
+		const { stdout: gitRoot } = await execFileAsync(
 			'git',
 			['rev-parse', '--show-toplevel'],
-			{ cwd: startPath },
+			{
+				cwd: requestedPath,
+			},
 		);
-		return stdout.trim();
+		return { gitRoot: gitRoot.trim() };
 	} catch {
-		return null;
-	}
-}
-
-// Helper to validate git repo and get root
-async function validateAndGetGitRoot(
-	path: string,
-): Promise<{ gitRoot: string } | { error: string; code: string }> {
-	if (!(await isGitRepository(path))) {
-		return { error: 'Not a git repository', code: 'NOT_A_GIT_REPO' };
-	}
-
-	const gitRoot = await findGitRoot(path);
-	if (!gitRoot) {
 		return {
-			error: 'Could not find git repository root',
-			code: 'GIT_ROOT_NOT_FOUND',
+			error: 'Not a git repository',
+			code: 'NOT_A_GIT_REPO',
 		};
 	}
-
-	return { gitRoot };
 }
 
-// Git status parsing
-function parseGitStatus(porcelainOutput: string): {
+function parseGitStatus(statusOutput: string): {
 	staged: GitFile[];
 	unstaged: GitFile[];
 	untracked: GitFile[];
 } {
+	const lines = statusOutput.trim().split('\n').filter(Boolean);
 	const staged: GitFile[] = [];
 	const unstaged: GitFile[] = [];
 	const untracked: GitFile[] = [];
 
-	const lines = porcelainOutput.split('\n').filter((line) => line.trim());
-
 	for (const line of lines) {
-		if (line.length < 4) continue;
-
-		const stagedStatus = line[0];
-		const unstagedStatus = line[1];
-		const filePath = line.slice(3);
-
-		// Parse staged files
-		if (stagedStatus !== ' ' && stagedStatus !== '?') {
-			let status: GitFile['status'] = 'modified';
-			if (stagedStatus === 'A') status = 'added';
-			else if (stagedStatus === 'D') status = 'deleted';
-			else if (stagedStatus === 'R') status = 'renamed';
-			else if (stagedStatus === 'M') status = 'modified';
+		const x = line[0]; // staged status
+		const y = line[1]; // unstaged status
+		const path = line.slice(3).trim();
 
+		// Check if file is staged (X is not space or ?)
+		if (x !== ' ' && x !== '?') {
 			staged.push({
-				path: filePath,
-				status,
+				path,
+				status: getStatusFromCode(x),
 				staged: true,
 			});
 		}
 
-		// Parse unstaged files
-		// NOTE: A file can appear in both staged and unstaged if it has staged changes
-		// and additional working directory changes
-		if (unstagedStatus !== ' ' && unstagedStatus !== '?') {
-			let status: GitFile['status'] = 'modified';
-			if (unstagedStatus === 'M') status = 'modified';
-			else if (unstagedStatus === 'D') status = 'deleted';
-
+		// Check if file is unstaged (Y is not space)
+		if (y !== ' ' && y !== '?') {
 			unstaged.push({
-				path: filePath,
-				status,
+				path,
+				status: getStatusFromCode(y),
 				staged: false,
 			});
 		}
 
-		// Parse untracked files
-		if (stagedStatus === '?' && unstagedStatus === '?') {
+		// Check if file is untracked
+		if (x === '?' && y === '?') {
 			untracked.push({
-				path: filePath,
+				path,
 				status: 'untracked',
 				staged: false,
 			});
@@ -195,63 +195,54 @@ function parseGitStatus(porcelainOutput: string): {
 	return { staged, unstaged, untracked };
 }
 
-async function parseNumstat(
-	numstatOutput: string,
-	files: GitFile[],
-): Promise<void> {
-	const lines = numstatOutput.split('\n').filter((line) => line.trim());
-
-	for (const line of lines) {
-		const parts = line.split('\t');
-		if (parts.length < 3) continue;
-
-		const insertions = Number.parseInt(parts[0], 10);
-		const deletions = Number.parseInt(parts[1], 10);
-		const filePath = parts[2];
-
-		const file = files.find((f) => f.path === filePath);
-		if (file) {
-			file.insertions = Number.isNaN(insertions) ? 0 : insertions;
-			file.deletions = Number.isNaN(deletions) ? 0 : deletions;
-		}
+function getStatusFromCode(code: string): GitFile['status'] {
+	switch (code) {
+		case 'M':
+			return 'modified';
+		case 'A':
+			return 'added';
+		case 'D':
+			return 'deleted';
+		case 'R':
+			return 'renamed';
+		default:
+			return 'modified';
 	}
 }
 
-async function getCurrentBranch(cwd: string): Promise<string> {
+async function getAheadBehind(
+	gitRoot: string,
+): Promise<{ ahead: number; behind: number }> {
 	try {
 		const { stdout } = await execFileAsync(
 			'git',
-			['branch', '--show-current'],
-			{ cwd },
+			['rev-list', '--left-right', '--count', 'HEAD...@{upstream}'],
+			{ cwd: gitRoot },
 		);
-		return stdout.trim() || 'HEAD';
+		const [ahead, behind] = stdout.trim().split(/\s+/).map(Number);
+		return { ahead: ahead || 0, behind: behind || 0 };
 	} catch {
-		return 'HEAD';
+		return { ahead: 0, behind: 0 };
 	}
 }
 
-async function getAheadBehind(
-	cwd: string,
-): Promise<{ ahead: number; behind: number }> {
+async function getCurrentBranch(gitRoot: string): Promise<string> {
 	try {
 		const { stdout } = await execFileAsync(
 			'git',
-			['rev-list', '--left-right', '--count', 'HEAD...@{u}'],
-			{ cwd },
+			['branch', '--show-current'],
+			{
+				cwd: gitRoot,
+			},
 		);
-		const parts = stdout.trim().split('\t');
-		return {
-			ahead: Number.parseInt(parts[0], 10) || 0,
-			behind: Number.parseInt(parts[1], 10) || 0,
-		};
+		return stdout.trim();
 	} catch {
-		return { ahead: 0, behind: 0 };
+		return 'unknown';
 	}
 }
 
-// Route handlers
 export function registerGitRoutes(app: Hono) {
-	// GET /v1/git/status - Get current git status
+	// GET /v1/git/status - Get git status
 	app.get('/v1/git/status', async (c) => {
 		try {
 			const query = gitStatusSchema.parse({
@@ -270,7 +261,7 @@ export function registerGitRoutes(app: Hono) {
 
 			const { gitRoot } = validation;
 
-			// Get git status
+			// Get status
 			const { stdout: statusOutput } = await execFileAsync(
 				'git',
 				['status', '--porcelain=v1'],
@@ -279,67 +270,41 @@ export function registerGitRoutes(app: Hono) {
 
 			const { staged, unstaged, untracked } = parseGitStatus(statusOutput);
 
-			// Get stats for staged files
-			if (staged.length > 0) {
-				try {
-					const { stdout: stagedNumstat } = await execFileAsync(
-						'git',
-						['diff', '--cached', '--numstat'],
-						{ cwd: gitRoot },
-					);
-					await parseNumstat(stagedNumstat, staged);
-				} catch {
-					// Ignore numstat errors
-				}
-			}
-
-			// Get stats for unstaged files
-			if (unstaged.length > 0) {
-				try {
-					const { stdout: unstagedNumstat } = await execFileAsync(
-						'git',
-						['diff', '--numstat'],
-						{ cwd: gitRoot },
-					);
-					await parseNumstat(unstagedNumstat, unstaged);
-				} catch {
-					// Ignore numstat errors
-				}
-			}
+			// Get ahead/behind counts
+			const { ahead, behind } = await getAheadBehind(gitRoot);
 
-			// Get branch info
+			// Get current branch
 			const branch = await getCurrentBranch(gitRoot);
-			const { ahead, behind } = await getAheadBehind(gitRoot);
 
-			const status: GitStatus = {
-				branch,
-				ahead,
-				behind,
-				staged,
-				unstaged,
-				untracked,
-				hasChanges:
-					staged.length > 0 || unstaged.length > 0 || untracked.length > 0,
-			};
+			// Calculate hasChanges
+			const hasChanges =
+				staged.length > 0 || unstaged.length > 0 || untracked.length > 0;
 
 			return c.json({
 				status: 'ok',
-				data: status,
+				data: {
+					branch,
+					ahead,
+					behind,
+					staged,
+					unstaged,
+					untracked,
+					hasChanges,
+				},
 			});
 		} catch (error) {
-			const errorMessage =
-				error instanceof Error ? error.message : 'Failed to get git status';
 			return c.json(
 				{
 					status: 'error',
-					error: errorMessage,
+					error:
+						error instanceof Error ? error.message : 'Failed to get status',
 				},
 				500,
 			);
 		}
 	});
 
-	// GET /v1/git/diff - Get diff for a specific file
+	// GET /v1/git/diff - Get file diff
 	app.get('/v1/git/diff', async (c) => {
 		try {
 			const query = gitDiffSchema.parse({
@@ -359,187 +324,105 @@ export function registerGitRoutes(app: Hono) {
 			}
 
 			const { gitRoot } = validation;
-			const file = query.file;
-			const staged = query.staged;
 
-			// Check if file is untracked (new file)
-			const { stdout: statusOutput } = await execFileAsync(
-				'git',
-				['status', '--porcelain=v1', file],
-				{ cwd: gitRoot },
-			);
+			// Get diff output and stats for the requested file
+			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 isUntracked = statusOutput.trim().startsWith('??');
+			const [{ stdout: diffOutput }, { stdout: numstatOutput }] =
+				await Promise.all([
+					execFileAsync('git', diffArgs, { cwd: gitRoot }),
+					execFileAsync('git', numstatArgs, { cwd: gitRoot }),
+				]);
 
-			let diffOutput = '';
 			let insertions = 0;
 			let deletions = 0;
-
-			if (isUntracked) {
-				// For untracked files, show the entire file content as additions
-				try {
-					const { readFile } = await import('node:fs/promises');
-					const { join } = await import('node:path');
-					const filePath = join(gitRoot, file);
-					const content = await readFile(filePath, 'utf-8');
-					const lines = content.split('\n');
-
-					// Create a diff-like output showing all lines as additions
-					diffOutput = `diff --git a/${file} b/${file}\n`;
-					diffOutput += `new file mode 100644\n`;
-					diffOutput += `--- /dev/null\n`;
-					diffOutput += `+++ b/${file}\n`;
-					diffOutput += `@@ -0,0 +1,${lines.length} @@\n`;
-					diffOutput += lines.map((line) => `+${line}`).join('\n');
-
-					insertions = lines.length;
-					deletions = 0;
-				} catch (err) {
-					diffOutput = `Error reading file: ${err instanceof Error ? err.message : 'Unknown error'}`;
-				}
-			} else {
-				// For tracked files, use git diff
-				const args = ['diff'];
-				if (staged) {
-					args.push('--cached');
-				}
-				args.push('--', file);
-
-				const { stdout: gitDiff } = await execFileAsync('git', args, {
-					cwd: gitRoot,
-				});
-				diffOutput = gitDiff;
-
-				// Get stats
-				const numstatArgs = ['diff', '--numstat'];
-				if (staged) {
-					numstatArgs.push('--cached');
+			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;
 				}
-				numstatArgs.push('--', file);
+			}
 
-				try {
-					const { stdout: numstatOutput } = await execFileAsync(
-						'git',
-						numstatArgs,
-						{ cwd: gitRoot },
-					);
-					const parts = numstatOutput.trim().split('\t');
-					if (parts.length >= 2) {
-						insertions = Number.parseInt(parts[0], 10) || 0;
-						deletions = Number.parseInt(parts[1], 10) || 0;
-					}
-				} catch {
-					// Ignore numstat errors
+			const diffText = diffOutput ?? '';
+			if (!binary) {
+				const summary = summarizeDiff(diffText);
+				binary = summary.binary;
+				if (insertions === 0 && deletions === 0) {
+					insertions = summary.insertions;
+					deletions = summary.deletions;
 				}
 			}
 
-			// Check if binary
-			const isBinary = diffOutput.includes('Binary files');
+			const language = inferLanguage(query.file);
 
 			return c.json({
 				status: 'ok',
 				data: {
-					file,
-					diff: diffOutput,
+					file: query.file,
+					diff: diffText,
 					insertions,
 					deletions,
-					language: detectLanguage(file),
-					binary: isBinary,
+					language,
+					binary,
 				},
 			});
 		} catch (error) {
-			const errorMessage =
-				error instanceof Error ? error.message : 'Failed to get git diff';
-			return c.json({ status: 'error', error: errorMessage }, 500);
+			return c.json(
+				{
+					status: 'error',
+					error: error instanceof Error ? error.message : 'Failed to get diff',
+				},
+				500,
+			);
 		}
 	});
 
-	// POST /v1/git/generate-commit-message - Generate AI commit message
-	app.post('/v1/git/generate-commit-message', async (c) => {
+	// POST /v1/git/stage - Stage files
+	app.post('/v1/git/stage', async (c) => {
 		try {
 			const body = await c.req.json();
-			const { project } = gitGenerateCommitMessageSchema.parse(body);
+			const { files, project } = gitStageSchema.parse(body);
+
 			const requestedPath = project || process.cwd();
-			const gitRoot = await findGitRoot(requestedPath);
 
-			// Check if there are staged changes
-			const { stdout: statusOutput } = await execFileAsync(
-				'git',
-				['diff', '--cached', '--name-only'],
-				{ cwd: gitRoot },
-			);
+			const validation = await validateAndGetGitRoot(requestedPath);
+			if ('error' in validation) {
+				return c.json(
+					{ status: 'error', error: validation.error, code: validation.code },
+					400,
+				);
+			}
+
+			const { gitRoot } = validation;
 
-			if (!statusOutput.trim()) {
+			if (files.length === 0) {
 				return c.json(
 					{
 						status: 'error',
-						error: 'No staged changes to generate commit message for',
+						error: 'No files specified',
 					},
 					400,
 				);
 			}
 
-			// Get the full staged diff
-			const { stdout: stagedDiff } = await execFileAsync(
-				'git',
-				['diff', '--cached'],
-				{ cwd: gitRoot },
-			);
-
-			// Limit diff size to avoid token limits (keep first 8000 chars)
-			const limitedDiff =
-				stagedDiff.length > 8000
-					? `${stagedDiff.slice(0, 8000)}\n\n... (diff truncated due to size)`
-					: stagedDiff;
-
-			// Generate commit message using AI
-			const prompt = `Based on the following git diff of staged changes, generate a clear and concise commit message following these guidelines:
-
-1. Use conventional commit format: <type>(<scope>): <subject>
-2. Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore
-3. Keep the subject line under 72 characters
-4. Use imperative mood ("add" not "added" or "adds")
-5. Don't end the subject line with a period
-6. If there are multiple significant changes, focus on the most important one
-7. Be specific about what changed
-
-Git diff of staged changes:
-\`\`\`diff
-${limitedDiff}
-\`\`\`
-
-Generate only the commit message, nothing else.`;
-
-			// Load config to get default provider/model
-			const cfg = await loadConfig(gitRoot);
-
-			// Resolve the model using SDK - this doesn't create any session
-			const model = await resolveModel(
-				cfg.defaults.provider,
-				cfg.defaults.model,
-			);
-
-			// Generate text directly - no session involved
-			const result = await generateText({
-				model: model as Parameters<typeof generateText>[0]['model'],
-				prompt,
-			});
-
-			// Extract and clean up the message
-			let message = result.text || '';
-
-			// Clean up the message (remove markdown code blocks if present)
-			if (typeof message === 'string') {
-				message = message
-					.replace(/^```(?:text|commit)?\n?/gm, '')
-					.replace(/```$/gm, '')
-					.trim();
-			}
+			// Stage files
+			await execFileAsync('git', ['add', ...files], { cwd: gitRoot });
 
 			return c.json({
 				status: 'ok',
 				data: {
-					message,
+					staged: files,
 				},
 			});
 		} catch (error) {
@@ -547,32 +430,50 @@ Generate only the commit message, nothing else.`;
 				{
 					status: 'error',
 					error:
-						error instanceof Error
-							? error.message
-							: 'Failed to generate commit message',
+						error instanceof Error ? error.message : 'Failed to stage files',
 				},
 				500,
 			);
 		}
 	});
 
-	// POST /v1/git/stage - Stage files
-	app.post('/v1/git/stage', async (c) => {
+	// POST /v1/git/unstage - Unstage files
+	app.post('/v1/git/unstage', async (c) => {
 		try {
 			const body = await c.req.json();
-			const { project, files } = gitStageSchema.parse(body);
+			const { files, project } = gitUnstageSchema.parse(body);
 
 			const requestedPath = project || process.cwd();
-			const gitRoot = await findGitRoot(requestedPath);
 
-			// Stage files - git add handles paths relative to git root
-			await execFileAsync('git', ['add', ...files], { cwd: gitRoot });
+			const validation = await validateAndGetGitRoot(requestedPath);
+			if ('error' in validation) {
+				return c.json(
+					{ status: 'error', error: validation.error, code: validation.code },
+					400,
+				);
+			}
+
+			const { gitRoot } = validation;
+
+			if (files.length === 0) {
+				return c.json(
+					{
+						status: 'error',
+						error: 'No files specified',
+					},
+					400,
+				);
+			}
+
+			// Unstage files
+			await execFileAsync('git', ['reset', 'HEAD', '--', ...files], {
+				cwd: gitRoot,
+			});
 
 			return c.json({
 				status: 'ok',
 				data: {
-					staged: files,
-					failed: [],
+					unstaged: files,
 				},
 			});
 		} catch (error) {
@@ -580,129 +481,161 @@ Generate only the commit message, nothing else.`;
 				{
 					status: 'error',
 					error:
-						error instanceof Error ? error.message : 'Failed to stage files',
+						error instanceof Error ? error.message : 'Failed to unstage files',
 				},
 				500,
 			);
 		}
 	});
 
-	// POST /v1/git/unstage - Unstage files
-	app.post('/v1/git/unstage', async (c) => {
+	// POST /v1/git/commit - Commit staged changes
+	app.post('/v1/git/commit', async (c) => {
 		try {
 			const body = await c.req.json();
-			const { project, files } = gitUnstageSchema.parse(body);
+			const { message, project } = gitCommitSchema.parse(body);
 
 			const requestedPath = project || process.cwd();
-			const gitRoot = await findGitRoot(requestedPath);
 
-			// Try modern git restore first, fallback to reset
-			try {
-				await execFileAsync('git', ['restore', '--staged', ...files], {
-					cwd: gitRoot,
-				});
-			} catch {
-				// Fallback to older git reset HEAD
-				await execFileAsync('git', ['reset', 'HEAD', ...files], {
-					cwd: gitRoot,
-				});
+			const validation = await validateAndGetGitRoot(requestedPath);
+			if ('error' in validation) {
+				return c.json(
+					{ status: 'error', error: validation.error, code: validation.code },
+					400,
+				);
 			}
 
+			const { gitRoot } = validation;
+
+			// Commit changes
+			const { stdout } = await execFileAsync('git', ['commit', '-m', message], {
+				cwd: gitRoot,
+			});
+
 			return c.json({
 				status: 'ok',
 				data: {
-					unstaged: files,
-					failed: [],
+					message: stdout.trim(),
 				},
 			});
 		} catch (error) {
 			return c.json(
 				{
 					status: 'error',
-					error:
-						error instanceof Error ? error.message : 'Failed to unstage files',
+					error: error instanceof Error ? error.message : 'Failed to commit',
 				},
 				500,
 			);
 		}
 	});
 
-	// POST /v1/git/commit - Commit staged changes
-	app.post('/v1/git/commit', async (c) => {
+	// POST /v1/git/generate-commit-message - Generate commit message from staged changes
+	app.post('/v1/git/generate-commit-message', async (c) => {
 		try {
 			const body = await c.req.json();
-			const { project, message } = gitCommitSchema.parse(body);
+			const { project } = gitGenerateCommitMessageSchema.parse(body);
 
 			const requestedPath = project || process.cwd();
-			const gitRoot = await findGitRoot(requestedPath);
 
-			// Check if there are staged changes
-			const { stdout: statusOutput } = await execFileAsync(
+			const validation = await validateAndGetGitRoot(requestedPath);
+			if ('error' in validation) {
+				return c.json(
+					{ status: 'error', error: validation.error, code: validation.code },
+					400,
+				);
+			}
+
+			const { gitRoot } = validation;
+
+			// Get staged diff
+			const { stdout: diff } = await execFileAsync(
 				'git',
-				['diff', '--cached', '--name-only'],
-				{ cwd: gitRoot },
+				['diff', '--cached'],
+				{
+					cwd: gitRoot,
+				},
 			);
 
-			if (!statusOutput.trim()) {
+			if (!diff.trim()) {
 				return c.json(
 					{
 						status: 'error',
-						error: 'No staged changes to commit',
+						error: 'No staged changes to generate message from',
 					},
 					400,
 				);
 			}
 
-			// Commit
-			const { stdout: commitOutput } = await execFileAsync(
+			// Get file list for context
+			const { stdout: statusOutput } = await execFileAsync(
 				'git',
-				['commit', '-m', message],
+				['status', '--porcelain=v1'],
 				{ cwd: gitRoot },
 			);
+			const { staged } = parseGitStatus(statusOutput);
+			const fileList = staged.map((f) => `${f.status}: ${f.path}`).join('\n');
 
-			// Parse commit output for hash
-			const hashMatch = commitOutput.match(/[\w/]+ ([a-f0-9]+)\]/);
-			const hash = hashMatch ? hashMatch[1] : '';
+			// Load config to get provider settings
+			const config = await loadConfig();
 
-			// Get commit stats
-			const { stdout: statOutput } = await execFileAsync(
-				'git',
-				['show', '--stat', '--format=', 'HEAD'],
-				{ cwd: gitRoot },
+			// Use a simple model for quick commit message generation
+			const provider = config.defaults?.provider || 'anthropic';
+			const model = await resolveModel(
+				provider as ProviderId,
+				config.defaults?.model,
+				undefined,
 			);
 
-			const filesChangedMatch = statOutput.match(/(\d+) files? changed/);
-			const insertionsMatch = statOutput.match(/(\d+) insertions?/);
-			const deletionsMatch = statOutput.match(/(\d+) deletions?/);
+			// Generate commit message using AI
+			const prompt = `Generate a concise, conventional commit message for these git changes.
+
+Staged files:
+${fileList}
+
+Diff (first 2000 chars):
+${diff.slice(0, 2000)}
+
+Guidelines:
+- Use conventional commits format (feat:, fix:, docs:, etc.)
+- Keep the first line under 72 characters
+- Be specific but concise
+- Focus on what changed and why, not how
+- Do not include any markdown formatting or code blocks
+- Return ONLY the commit message text, nothing else
+
+Commit message:`;
+
+			const { text } = await generateText({
+				provider: provider as ProviderId,
+				model: model.id,
+				systemPrompt:
+					'You are a helpful assistant that generates git commit messages.',
+				prompt,
+				maxTokens: 200,
+			});
+
+			const message = text.trim();
 
 			return c.json({
 				status: 'ok',
 				data: {
-					hash,
-					message: message.split('\n')[0],
-					filesChanged: filesChangedMatch
-						? Number.parseInt(filesChangedMatch[1], 10)
-						: 0,
-					insertions: insertionsMatch
-						? Number.parseInt(insertionsMatch[1], 10)
-						: 0,
-					deletions: deletionsMatch
-						? Number.parseInt(deletionsMatch[1], 10)
-						: 0,
+					message,
 				},
 			});
 		} catch (error) {
 			return c.json(
 				{
 					status: 'error',
-					error: error instanceof Error ? error.message : 'Failed to commit',
+					error:
+						error instanceof Error
+							? error.message
+							: 'Failed to generate commit message',
 				},
 				500,
 			);
 		}
 	});
 
-	// GET /v1/git/branch - Get branch information
+	// GET /v1/git/branch - Get branch info
 	app.get('/v1/git/branch', async (c) => {
 		try {
 			const query = gitStatusSchema.parse({
@@ -721,56 +654,211 @@ Generate only the commit message, nothing else.`;
 
 			const { gitRoot } = validation;
 
+			// Get current branch
 			const branch = await getCurrentBranch(gitRoot);
+
+			// Get ahead/behind counts
 			const { ahead, behind } = await getAheadBehind(gitRoot);
 
-			// Get all branches
-			let allBranches: string[] = [];
+			// Get remote info
 			try {
-				const { stdout: branchesOutput } = await execFileAsync(
-					'git',
-					['branch', '--list'],
-					{ cwd: gitRoot },
+				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,
+			);
+		}
+	});
+
+	// POST /v1/git/push - Push commits to remote
+	app.post('/v1/git/push', async (c) => {
+		try {
+			// Parse JSON body, defaulting to empty object if parsing fails
+			let body = {};
+			try {
+				body = await c.req.json();
+			} catch (jsonError) {
+				// If JSON parsing fails (e.g., empty body), use empty object
+				console.warn(
+					'Failed to parse JSON body for git push, using empty object:',
+					jsonError,
 				);
-				allBranches = branchesOutput
-					.split('\n')
-					.map((line) => line.replace(/^\*?\s*/, '').trim())
-					.filter(Boolean);
+			}
+
+			const { project } = gitPushSchema.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;
+
+			// Check if there's a remote configured
+			try {
+				const { stdout: remotes } = await execFileAsync('git', ['remote'], {
+					cwd: gitRoot,
+				});
+				if (!remotes.trim()) {
+					return c.json(
+						{ status: 'error', error: 'No remote repository configured' },
+						400,
+					);
+				}
 			} catch {
-				allBranches = [branch];
+				return c.json(
+					{ status: 'error', error: 'No remote repository configured' },
+					400,
+				);
 			}
 
-			// Get upstream branch
-			let upstream = '';
+			// Get current branch and check for upstream
+			const branch = await getCurrentBranch(gitRoot);
+			let hasUpstream = false;
 			try {
-				const { stdout: upstreamOutput } = await execFileAsync(
+				await execFileAsync(
 					'git',
-					['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'],
-					{ cwd: gitRoot },
+					['rev-parse', '--abbrev-ref', '@{upstream}'],
+					{
+						cwd: gitRoot,
+					},
 				);
-				upstream = upstreamOutput.trim();
+				hasUpstream = true;
 			} catch {
-				// No upstream configured
+				// No upstream set
 			}
 
-			return c.json({
-				status: 'ok',
-				data: {
-					current: branch,
-					upstream,
-					ahead,
-					behind,
-					all: allBranches,
-				},
-			});
+			// Push to remote - with proper error handling
+			try {
+				let pushOutput: string;
+				let pushError: string;
+
+				if (hasUpstream) {
+					// Push to existing upstream
+					const result = await execFileAsync('git', ['push'], { cwd: gitRoot });
+					pushOutput = result.stdout;
+					pushError = result.stderr;
+				} else {
+					// Set upstream and push
+					const result = await execFileAsync(
+						'git',
+						['push', '--set-upstream', 'origin', branch],
+						{ cwd: gitRoot },
+					);
+					pushOutput = result.stdout;
+					pushError = result.stderr;
+				}
+
+				return c.json({
+					status: 'ok',
+					data: {
+						output: pushOutput.trim() || pushError.trim(),
+					},
+				});
+			} catch (pushErr: unknown) {
+				// Handle specific git push errors
+				const error = pushErr as {
+					message?: string;
+					stderr?: string;
+					code?: number;
+				};
+				const errorMessage = error.stderr || error.message || 'Failed to push';
+
+				// Check for common error patterns
+				if (
+					errorMessage.includes('failed to push') ||
+					errorMessage.includes('rejected')
+				) {
+					return c.json(
+						{
+							status: 'error',
+							error: 'Push rejected. Try pulling changes first with: git pull',
+							details: errorMessage,
+						},
+						400,
+					);
+				}
+
+				if (
+					errorMessage.includes('Permission denied') ||
+					errorMessage.includes('authentication') ||
+					errorMessage.includes('could not read')
+				) {
+					return c.json(
+						{
+							status: 'error',
+							error: 'Authentication failed. Check your git credentials',
+							details: errorMessage,
+						},
+						401,
+					);
+				}
+
+				if (
+					errorMessage.includes('Could not resolve host') ||
+					errorMessage.includes('network')
+				) {
+					return c.json(
+						{
+							status: 'error',
+							error: 'Network error. Check your internet connection',
+							details: errorMessage,
+						},
+						503,
+					);
+				}
+
+				// Generic push error
+				return c.json(
+					{
+						status: 'error',
+						error: 'Failed to push commits',
+						details: errorMessage,
+					},
+					500,
+				);
+			}
 		} catch (error) {
 			return c.json(
 				{
 					status: 'error',
-					error:
-						error instanceof Error
-							? error.message
-							: 'Failed to get branch info',
+					error: error instanceof Error ? error.message : 'Failed to push',
 				},
 				500,
 			);