@ottocode/server 0.1.173

package/src/routes/git/push.ts

@@ -0,0 +1,160 @@
+import type { Hono } from 'hono';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { gitPushSchema } from './schemas.ts';
+import { validateAndGetGitRoot, getCurrentBranch } from './utils.ts';
+
+const execFileAsync = promisify(execFile);
+
+export function registerPushRoute(app: Hono) {
+	app.post('/v1/git/push', async (c) => {
+		try {
+			let body = {};
+			try {
+				body = await c.req.json();
+			} catch (jsonError) {
+				console.warn(
+					'Failed to parse JSON body for git push, using empty object:',
+					jsonError,
+				);
+			}
+
+			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;
+
+			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 {
+				return c.json(
+					{ status: 'error', error: 'No remote repository configured' },
+					400,
+				);
+			}
+
+			const branch = await getCurrentBranch(gitRoot);
+			let hasUpstream = false;
+			try {
+				await execFileAsync(
+					'git',
+					['rev-parse', '--abbrev-ref', '@{upstream}'],
+					{
+						cwd: gitRoot,
+					},
+				);
+				hasUpstream = true;
+			} catch {}
+
+			try {
+				let pushOutput: string;
+				let pushError: string;
+
+				if (hasUpstream) {
+					const result = await execFileAsync('git', ['push'], { cwd: gitRoot });
+					pushOutput = result.stdout;
+					pushError = result.stderr;
+				} else {
+					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) {
+				const error = pushErr as {
+					message?: string;
+					stderr?: string;
+					code?: number;
+				};
+				const errorMessage = error.stderr || error.message || 'Failed to push';
+
+				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,
+					);
+				}
+
+				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 push',
+				},
+				500,
+			);
+		}
+	});
+}

package/src/routes/git/schemas.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod/v3';
+
+export const gitStatusSchema = z.object({
+	project: z.string().optional(),
+});
+
+export const gitDiffSchema = z.object({
+	project: z.string().optional(),
+	file: z.string(),
+	staged: z
+		.string()
+		.optional()
+		.transform((val) => val === 'true'),
+});
+
+export const gitStageSchema = z.object({
+	project: z.string().optional(),
+	files: z.array(z.string()),
+});
+
+export const gitUnstageSchema = z.object({
+	project: z.string().optional(),
+	files: z.array(z.string()),
+});
+
+export const gitRestoreSchema = z.object({
+	project: z.string().optional(),
+	files: z.array(z.string()),
+});
+
+export const gitDeleteSchema = z.object({
+	project: z.string().optional(),
+	files: z.array(z.string()),
+});
+
+export const gitCommitSchema = z.object({
+	project: z.string().optional(),
+	message: z.string().min(1),
+});
+
+export const gitGenerateCommitMessageSchema = z.object({
+	project: z.string().optional(),
+	sessionId: z.string().optional(),
+});
+
+export const gitPushSchema = z.object({
+	project: z.string().optional(),
+});

package/src/routes/git/staging.ts

@@ -0,0 +1,208 @@
+import type { Hono } from 'hono';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import {
+	gitStageSchema,
+	gitUnstageSchema,
+	gitRestoreSchema,
+	gitDeleteSchema,
+} from './schemas.ts';
+import { validateAndGetGitRoot } from './utils.ts';
+
+const execFileAsync = promisify(execFile);
+
+export function registerStagingRoutes(app: Hono) {
+	app.post('/v1/git/stage', async (c) => {
+		try {
+			const body = await c.req.json();
+			const { files, project } = gitStageSchema.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;
+
+			if (files.length === 0) {
+				return c.json(
+					{
+						status: 'error',
+						error: 'No files specified',
+					},
+					400,
+				);
+			}
+
+			await execFileAsync('git', ['add', ...files], { cwd: gitRoot });
+
+			return c.json({
+				status: 'ok',
+				data: {
+					staged: files,
+				},
+			});
+		} catch (error) {
+			return c.json(
+				{
+					status: 'error',
+					error:
+						error instanceof Error ? error.message : 'Failed to stage files',
+				},
+				500,
+			);
+		}
+	});
+
+	app.post('/v1/git/unstage', async (c) => {
+		try {
+			const body = await c.req.json();
+			const { files, project } = gitUnstageSchema.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;
+
+			if (files.length === 0) {
+				return c.json(
+					{
+						status: 'error',
+						error: 'No files specified',
+					},
+					400,
+				);
+			}
+
+			await execFileAsync('git', ['reset', 'HEAD', '--', ...files], {
+				cwd: gitRoot,
+			});
+
+			return c.json({
+				status: 'ok',
+				data: {
+					unstaged: files,
+				},
+			});
+		} catch (error) {
+			return c.json(
+				{
+					status: 'error',
+					error:
+						error instanceof Error ? error.message : 'Failed to unstage files',
+				},
+				500,
+			);
+		}
+	});
+
+	app.post('/v1/git/restore', async (c) => {
+		try {
+			const body = await c.req.json();
+			const { files, project } = gitRestoreSchema.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;
+
+			if (files.length === 0) {
+				return c.json(
+					{
+						status: 'error',
+						error: 'No files specified',
+					},
+					400,
+				);
+			}
+
+			await execFileAsync('git', ['restore', '--', ...files], {
+				cwd: gitRoot,
+			});
+
+			return c.json({
+				status: 'ok',
+				data: {
+					restored: files,
+				},
+			});
+		} catch (error) {
+			return c.json(
+				{
+					status: 'error',
+					error:
+						error instanceof Error ? error.message : 'Failed to restore files',
+				},
+				500,
+			);
+		}
+	});
+
+	app.post('/v1/git/delete', async (c) => {
+		try {
+			const body = await c.req.json();
+			const { files, project } = gitDeleteSchema.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;
+
+			if (files.length === 0) {
+				return c.json(
+					{
+						status: 'error',
+						error: 'No files specified',
+					},
+					400,
+				);
+			}
+
+			await execFileAsync('git', ['clean', '-f', '--', ...files], {
+				cwd: gitRoot,
+			});
+
+			return c.json({
+				status: 'ok',
+				data: {
+					deleted: files,
+				},
+			});
+		} catch (error) {
+			return c.json(
+				{
+					status: 'error',
+					error:
+						error instanceof Error ? error.message : 'Failed to delete files',
+				},
+				500,
+			);
+		}
+	});
+}

package/src/routes/git/status.ts

@@ -0,0 +1,83 @@
+import type { Hono } from 'hono';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { gitStatusSchema } from './schemas.ts';
+import {
+	validateAndGetGitRoot,
+	parseGitStatus,
+	getAheadBehind,
+	getCurrentBranch,
+} from './utils.ts';
+
+const execFileAsync = promisify(execFile);
+
+export function registerStatusRoute(app: Hono) {
+	app.get('/v1/git/status', 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 { stdout: statusOutput } = await execFileAsync(
+				'git',
+				['status', '--porcelain=v2'],
+				{ cwd: gitRoot },
+			);
+
+			const { staged, unstaged, untracked, conflicted } = parseGitStatus(
+				statusOutput,
+				gitRoot,
+			);
+
+			const { ahead, behind } = await getAheadBehind(gitRoot);
+
+			const branch = await getCurrentBranch(gitRoot);
+
+			const hasChanges =
+				staged.length > 0 ||
+				unstaged.length > 0 ||
+				untracked.length > 0 ||
+				conflicted.length > 0;
+
+			const hasConflicts = conflicted.length > 0;
+
+			return c.json({
+				status: 'ok',
+				data: {
+					branch,
+					ahead,
+					behind,
+					gitRoot,
+					workingDir: requestedPath,
+					staged,
+					unstaged,
+					untracked,
+					conflicted,
+					hasChanges,
+					hasConflicts,
+				},
+			});
+		} catch (error) {
+			return c.json(
+				{
+					status: 'error',
+					error:
+						error instanceof Error ? error.message : 'Failed to get status',
+				},
+				500,
+			);
+		}
+	});
+}

package/src/routes/git/types.ts

@@ -0,0 +1,31 @@
+export interface GitFile {
+	path: string;
+	absPath: string;
+	status:
+		| 'modified'
+		| 'added'
+		| 'deleted'
+		| 'renamed'
+		| 'untracked'
+		| 'conflicted';
+	staged: boolean;
+	insertions?: number;
+	deletions?: number;
+	oldPath?: string;
+	isNew: boolean;
+	conflictType?:
+		| 'both-modified'
+		| 'deleted-by-us'
+		| 'deleted-by-them'
+		| 'both-added'
+		| 'both-deleted';
+}
+
+export interface GitRoot {
+	gitRoot: string;
+}
+
+export interface GitError {
+	error: string;
+	code?: string;
+}