@agi-cli/server 0.1.81 → 0.1.83

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,76 @@
+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 } = 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;
+
+			return c.json({
+				status: 'ok',
+				data: {
+					branch,
+					ahead,
+					behind,
+					gitRoot,
+					workingDir: requestedPath,
+					staged,
+					unstaged,
+					untracked,
+					hasChanges,
+				},
+			});
+		} 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,19 @@
+export interface GitFile {
+	path: string;
+	absPath: string;
+	status: 'modified' | 'added' | 'deleted' | 'renamed' | 'untracked';
+	staged: boolean;
+	insertions?: number;
+	deletions?: number;
+	oldPath?: string;
+	isNew: boolean;
+}
+
+export interface GitRoot {
+	gitRoot: string;
+}
+
+export interface GitError {
+	error: string;
+	code?: string;
+}

package/src/routes/git/utils.ts

@@ -0,0 +1,212 @@
+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';
+	}
+}
+
+export function parseGitStatus(
+	statusOutput: string,
+	gitRoot: string,
+): {
+	staged: GitFile[];
+	unstaged: GitFile[];
+	untracked: GitFile[];
+} {
+	const lines = statusOutput.trim().split('\n').filter(Boolean);
+	const staged: GitFile[] = [];
+	const unstaged: GitFile[] = [];
+	const untracked: 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,
+			});
+		}
+	}
+
+	return { staged, unstaged, untracked };
+}
+
+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/runtime/runner.ts

@@ -22,10 +22,7 @@ import {
 	dequeueJob,
 	cleanupSession,
 } from './session-queue.ts';
-import {
-	setupToolContext,
-	type RunnerToolContext,
-} from './tool-context-setup.ts';
+import { setupToolContext } from './tool-context-setup.ts';
 import {
 	updateSessionTokensIncremental,
 	updateMessageTokensIncremental,
@@ -218,12 +215,12 @@ async function runAssistant(opts: RunOpts) {
 	let accumulated = '';
 	let stepIndex = 0;
 
-	let finishObserved = false;
+	let _finishObserved = false;
 	const unsubscribeFinish = subscribe(opts.sessionId, (evt) => {
 		if (evt.type !== 'tool.result') return;
 		try {
 			const name = (evt.payload as { name?: string } | undefined)?.name;
-			if (name === 'finish') finishObserved = true;
+			if (name === 'finish') _finishObserved = true;
 		} catch {}
 	});
 

package/src/runtime/session-manager.ts

@@ -47,7 +47,7 @@ export async function createSession({
 		model,
 		projectPath: cfg.projectRoot,
 		createdAt: now,
-		lastActiveAt: null,
+		lastActiveAt: now,
 		totalInputTokens: null,
 		totalOutputTokens: null,
 		totalCachedTokens: null,