@agi-cli/server 0.1.81 → 0.1.82

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,159 @@
+import type { Hono } from 'hono';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { generateText } from 'ai';
+import type { ProviderId } from '@agi-cli/sdk';
+import { loadConfig, getAuth } from '@agi-cli/sdk';
+import { gitCommitSchema, gitGenerateCommitMessageSchema } from './schemas.ts';
+import { validateAndGetGitRoot, parseGitStatus } from './utils.ts';
+import { resolveModel } from '../../runtime/provider.ts';
+import { getProviderSpoofPrompt } from '../../runtime/prompt.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 } = 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();
+
+			const provider = (config.defaults?.provider || 'anthropic') as ProviderId;
+			const modelId = config.defaults?.model || 'claude-3-5-sonnet-20241022';
+
+			const auth = await getAuth(provider, config.projectRoot);
+			const needsSpoof = auth?.type === 'oauth';
+			const spoofPrompt = needsSpoof
+				? getProviderSpoofPrompt(provider)
+				: undefined;
+
+			const model = await resolveModel(provider, modelId, config);
+
+			const userPrompt = `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 systemPrompt = spoofPrompt
+				? spoofPrompt
+				: 'You are a helpful assistant that generates git commit messages.';
+
+			const { text } = await generateText({
+				model,
+				system: systemPrompt,
+				prompt: userPrompt,
+				maxTokens: 200,
+			});
+
+			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);
+}

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,47 @@
+import { z } from 'zod';
+
+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(),
+});
+
+export const gitPushSchema = z.object({
+	project: z.string().optional(),
+});