@agi-cli/server 0.1.66 → 0.1.68

package/src/routes/git.ts

@@ -1,10 +1,14 @@
 import type { Hono } from 'hono';
 import { execFile } from 'node:child_process';
-import { extname } from 'node:path';
+import { extname, join } from 'node:path';
+import { readFile } from 'node:fs/promises';
 import { promisify } from 'node:util';
 import { z } from 'zod';
-import { generateText, resolveModel, type ProviderId } from '@agi-cli/sdk';
-import { loadConfig } from '@agi-cli/sdk';
+import { generateText } from 'ai';
+import type { ProviderId } from '@agi-cli/sdk';
+import { loadConfig, getAuth } from '@agi-cli/sdk';
+import { resolveModel } from '../runtime/provider.ts';
+import { getProviderSpoofPrompt } from '../runtime/prompt.ts';
 
 const execFileAsync = promisify(execFile);
 
@@ -113,10 +117,13 @@ const gitPushSchema = z.object({
 // Types
 export interface GitFile {
 	path: string;
+	absPath: string; // NEW: Absolute filesystem path
 	status: 'modified' | 'added' | 'deleted' | 'renamed' | 'untracked';
 	staged: boolean;
 	insertions?: number;
 	deletions?: number;
+	oldPath?: string; // For renamed files
+	isNew: boolean; // NEW: True for untracked or newly added files
 }
 
 interface GitRoot {
@@ -149,7 +156,25 @@ async function validateAndGetGitRoot(
 	}
 }
 
-function parseGitStatus(statusOutput: string): {
+/**
+ * Check if a file is new/untracked (not in git index)
+ */
+async function checkIfNewFile(gitRoot: string, file: string): Promise<boolean> {
+	try {
+		// Check if file exists in git index or committed
+		await execFileAsync('git', ['ls-files', '--error-unmatch', file], {
+			cwd: gitRoot,
+		});
+		return false; // File exists in git
+	} catch {
+		return true; // File is new/untracked
+	}
+}
+
+function parseGitStatus(
+	statusOutput: string,
+	gitRoot: string,
+): {
 	staged: GitFile[];
 	unstaged: GitFile[];
 	untracked: GitFile[];
@@ -160,34 +185,50 @@ function parseGitStatus(statusOutput: string): {
 	const untracked: GitFile[] = [];
 
 	for (const line of lines) {
-		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,
-				status: getStatusFromCode(x),
-				staged: true,
-			});
-		}
-
-		// Check if file is unstaged (Y is not space)
-		if (y !== ' ' && y !== '?') {
-			unstaged.push({
-				path,
-				status: getStatusFromCode(y),
-				staged: false,
-			});
-		}
+		// Porcelain v2 format has different line types
+		if (line.startsWith('1 ') || line.startsWith('2 ')) {
+			// Regular changed entry: "1 XY sub <mH> <mI> <mW> <hH> <hI> <path>"
+			// XY is a 2-character field with staged (X) and unstaged (Y) status
+			const parts = line.split(' ');
+			if (parts.length < 9) continue;
+
+			const xy = parts[1]; // e.g., ".M", "M.", "MM", "A.", etc.
+			const x = xy[0]; // staged status
+			const y = xy[1]; // unstaged status
+			const path = parts.slice(8).join(' '); // Path can contain spaces
+			const absPath = join(gitRoot, path);
+
+			// Check if file is staged (X is not '.')
+			if (x !== '.') {
+				staged.push({
+					path,
+					absPath,
+					status: getStatusFromCodeV2(x),
+					staged: true,
+					isNew: x === 'A',
+				});
+			}
 
-		// Check if file is untracked
-		if (x === '?' && y === '?') {
+			// Check if file is unstaged (Y is not '.')
+			if (y !== '.') {
+				unstaged.push({
+					path,
+					absPath,
+					status: getStatusFromCodeV2(y),
+					staged: false,
+					isNew: false,
+				});
+			}
+		} else if (line.startsWith('? ')) {
+			// Untracked file: "? <path>"
+			const path = line.slice(2);
+			const absPath = join(gitRoot, path);
 			untracked.push({
 				path,
+				absPath,
 				status: 'untracked',
 				staged: false,
+				isNew: true,
 			});
 		}
 	}
@@ -195,7 +236,22 @@ function parseGitStatus(statusOutput: string): {
 	return { staged, unstaged, untracked };
 }
 
-function getStatusFromCode(code: string): GitFile['status'] {
+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';
+	}
+}
+
+function getStatusFromCodeV2(code: string): GitFile['status'] {
 	switch (code) {
 		case 'M':
 			return 'modified';
@@ -205,6 +261,8 @@ function getStatusFromCode(code: string): GitFile['status'] {
 			return 'deleted';
 		case 'R':
 			return 'renamed';
+		case 'C':
+			return 'modified'; // Copied - treat as modified
 		default:
 			return 'modified';
 	}
@@ -264,11 +322,14 @@ export function registerGitRoutes(app: Hono) {
 			// Get status
 			const { stdout: statusOutput } = await execFileAsync(
 				'git',
-				['status', '--porcelain=v1'],
+				['status', '--porcelain=v2'],
 				{ cwd: gitRoot },
 			);
 
-			const { staged, unstaged, untracked } = parseGitStatus(statusOutput);
+			const { staged, unstaged, untracked } = parseGitStatus(
+				statusOutput,
+				gitRoot,
+			);
 
 			// Get ahead/behind counts
 			const { ahead, behind } = await getAheadBehind(gitRoot);
@@ -286,6 +347,8 @@ export function registerGitRoutes(app: Hono) {
 					branch,
 					ahead,
 					behind,
+					gitRoot, // NEW: Expose git root path
+					workingDir: requestedPath, // NEW: Current working directory
 					staged,
 					unstaged,
 					untracked,
@@ -324,8 +387,46 @@ export function registerGitRoutes(app: Hono) {
 			}
 
 			const { gitRoot } = validation;
+			const absPath = join(gitRoot, query.file);
+
+			// Check if file is new/untracked
+			const isNewFile = await checkIfNewFile(gitRoot, query.file);
+
+			// For new files, read and return full content
+			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: '', // Empty diff for new files
+							content, // NEW: Full file content
+							isNewFile: true, // NEW: Flag indicating this is a new file
+							isBinary: false,
+							insertions: lineCount,
+							deletions: 0,
+							language,
+							staged: !!query.staged, // NEW: Whether showing staged or unstaged
+						},
+					});
+				} catch (error) {
+					return c.json(
+						{
+							status: 'error',
+							error:
+								error instanceof Error ? error.message : 'Failed to read file',
+						},
+						500,
+					);
+				}
+			}
 
-			// Get diff output and stats for the requested file
+			// For existing files, get diff output and stats
 			const diffArgs = query.staged
 				? ['diff', '--cached', '--', query.file]
 				: ['diff', '--', query.file];
@@ -370,11 +471,14 @@ export function registerGitRoutes(app: Hono) {
 				status: 'ok',
 				data: {
 					file: query.file,
+					absPath, // NEW: Absolute path
 					diff: diffText,
+					isNewFile: false, // NEW: Not a new file
+					isBinary: binary,
 					insertions,
 					deletions,
 					language,
-					binary,
+					staged: !!query.staged, // NEW: Whether showing staged or unstaged
 				},
 			});
 		} catch (error) {
@@ -568,25 +672,31 @@ export function registerGitRoutes(app: Hono) {
 			// Get file list for context
 			const { stdout: statusOutput } = await execFileAsync(
 				'git',
-				['status', '--porcelain=v1'],
+				['status', '--porcelain=v2'],
 				{ cwd: gitRoot },
 			);
-			const { staged } = parseGitStatus(statusOutput);
+			const { staged } = parseGitStatus(statusOutput, gitRoot);
 			const fileList = staged.map((f) => `${f.status}: ${f.path}`).join('\n');
 
 			// Load config to get provider settings
 			const config = await loadConfig();
 
-			// 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,
-			);
+			// Use the default provider and model for quick commit message generation
+			const provider = (config.defaults?.provider || 'anthropic') as ProviderId;
+			const modelId = config.defaults?.model || 'claude-3-5-sonnet-20241022';
+
+			// Check if we need OAuth spoof prompt (same as runner)
+			const auth = await getAuth(provider, config.projectRoot);
+			const needsSpoof = auth?.type === 'oauth';
+			const spoofPrompt = needsSpoof
+				? getProviderSpoofPrompt(provider)
+				: undefined;
+
+			// Resolve model with proper authentication (3-level fallback: OAuth, API key, env var)
+			const model = await resolveModel(provider, modelId, config);
 
 			// Generate commit message using AI
-			const prompt = `Generate a concise, conventional commit message for these git changes.
+			const userPrompt = `Generate a concise, conventional commit message for these git changes.
 
 Staged files:
 ${fileList}
@@ -604,12 +714,15 @@ Guidelines:
 
 Commit message:`;
 
+			// Use spoof prompt as system if OAuth, otherwise use normal system prompt
+			const systemPrompt = spoofPrompt
+				? spoofPrompt
+				: 'You are a helpful assistant that generates git commit messages.';
+
 			const { text } = await generateText({
-				provider: provider as ProviderId,
-				model: model.id,
-				systemPrompt:
-					'You are a helpful assistant that generates git commit messages.',
-				prompt,
+				model,
+				system: systemPrompt,
+				prompt: userPrompt,
 				maxTokens: 200,
 			});
 

package/src/routes/session-messages.ts

@@ -9,6 +9,8 @@ import {
 	ensureProviderEnv,
 } from '@agi-cli/sdk';
 import { dispatchAssistantMessage } from '../runtime/message-service.ts';
+import { logger } from '../runtime/logger.ts';
+import { serializeError } from '../runtime/api-error.ts';
 
 type MessagePartRow = typeof messageParts.$inferSelect;
 type SessionRow = typeof sessions.$inferSelect;
@@ -16,108 +18,125 @@ type SessionRow = typeof sessions.$inferSelect;
 export function registerSessionMessagesRoutes(app: Hono) {
 	// List messages for a session
 	app.get('/v1/sessions/:id/messages', async (c) => {
-		const projectRoot = c.req.query('project') || process.cwd();
-		const cfg = await loadConfig(projectRoot);
-		const db = await getDb(cfg.projectRoot);
-		const id = c.req.param('id');
-		const rows = await db
-			.select()
-			.from(messages)
-			.where(eq(messages.sessionId, id))
-			.orderBy(messages.createdAt);
-		const without = c.req.query('without');
-		if (without !== 'parts') {
-			const ids = rows.map((m) => m.id);
-			const parts = ids.length
-				? await db
-						.select()
-						.from(messageParts)
-						.where(inArray(messageParts.messageId, ids))
-				: [];
-			const partsByMsg = new Map<string, MessagePartRow[]>();
-			for (const p of parts) {
-				const existing = partsByMsg.get(p.messageId);
-				if (existing) existing.push(p);
-				else partsByMsg.set(p.messageId, [p]);
-			}
-			const wantParsed = (() => {
-				const q = (c.req.query('parsed') || '').toLowerCase();
-				return q === '1' || q === 'true' || q === 'yes';
-			})();
-			function parseContent(raw: string): Record<string, unknown> | string {
-				try {
-					const v = JSON.parse(String(raw ?? ''));
-					if (v && typeof v === 'object' && !Array.isArray(v))
-						return v as Record<string, unknown>;
-				} catch {}
-				return raw;
-			}
-			const enriched = rows.map((m) => {
-				const parts = (partsByMsg.get(m.id) ?? []).sort(
-					(a, b) => a.index - b.index,
-				);
-				const mapped = parts.map((p) => {
-					const parsed = parseContent(p.content);
-					return wantParsed
-						? { ...p, content: parsed }
-						: { ...p, contentJson: parsed };
+		try {
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+			const db = await getDb(cfg.projectRoot);
+			const id = c.req.param('id');
+			const rows = await db
+				.select()
+				.from(messages)
+				.where(eq(messages.sessionId, id))
+				.orderBy(messages.createdAt);
+			const without = c.req.query('without');
+			if (without !== 'parts') {
+				const ids = rows.map((m) => m.id);
+				const parts = ids.length
+					? await db
+							.select()
+							.from(messageParts)
+							.where(inArray(messageParts.messageId, ids))
+					: [];
+				const partsByMsg = new Map<string, MessagePartRow[]>();
+				for (const p of parts) {
+					const existing = partsByMsg.get(p.messageId);
+					if (existing) existing.push(p);
+					else partsByMsg.set(p.messageId, [p]);
+				}
+				const wantParsed = (() => {
+					const q = (c.req.query('parsed') || '').toLowerCase();
+					return q === '1' || q === 'true' || q === 'yes';
+				})();
+				function parseContent(raw: string): Record<string, unknown> | string {
+					try {
+						const v = JSON.parse(String(raw ?? ''));
+						if (v && typeof v === 'object' && !Array.isArray(v))
+							return v as Record<string, unknown>;
+					} catch {}
+					return raw;
+				}
+				const enriched = rows.map((m) => {
+					const parts = (partsByMsg.get(m.id) ?? []).sort(
+						(a, b) => a.index - b.index,
+					);
+					const mapped = parts.map((p) => {
+						const parsed = parseContent(p.content);
+						return wantParsed
+							? { ...p, content: parsed }
+							: { ...p, contentJson: parsed };
+					});
+					return { ...m, parts: mapped };
 				});
-				return { ...m, parts: mapped };
-			});
-			return c.json(enriched);
+				return c.json(enriched);
+			}
+			return c.json(rows);
+		} catch (error) {
+			logger.error('Failed to list session messages', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
 		}
-		return c.json(rows);
 	});
 
 	// Post a user message and get assistant reply (non-streaming for v0)
 	app.post('/v1/sessions/:id/messages', async (c) => {
-		const projectRoot = c.req.query('project') || process.cwd();
-		const cfg = await loadConfig(projectRoot);
-		const db = await getDb(cfg.projectRoot);
-		const sessionId = c.req.param('id');
-		const body = await c.req.json().catch(() => ({}));
-		// Load session to inherit its provider/model/agent by default
-		const sessionRows = await db
-			.select()
-			.from(sessions)
-			.where(eq(sessions.id, sessionId));
-		if (!sessionRows.length) return c.json({ error: 'Session not found' }, 404);
-		const sess: SessionRow = sessionRows[0];
-		const provider = body?.provider ?? sess.provider ?? cfg.defaults.provider;
-		const modelName = body?.model ?? sess.model ?? cfg.defaults.model;
-		const agent = body?.agent ?? sess.agent ?? cfg.defaults.agent;
-		const content = body?.content ?? '';
-
-		// Validate model capabilities if tools are allowed for this agent
-		const wantsToolCalls = true; // agent toolset may be non-empty
 		try {
-			validateProviderModel(provider, modelName, { wantsToolCalls });
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			return c.json({ error: message }, 400);
-		}
-		// Enforce provider auth: only allow providers/models the user authenticated for
-		const authorized = await isProviderAuthorized(cfg, provider);
-		if (!authorized) {
-			return c.json(
-				{
-					error: `Provider ${provider} is not configured. Run \`agi auth login\` to add credentials.`,
-				},
-				400,
-			);
-		}
-		await ensureProviderEnv(cfg, provider);
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+			const db = await getDb(cfg.projectRoot);
+			const sessionId = c.req.param('id');
+			const body = await c.req.json().catch(() => ({}));
+			// Load session to inherit its provider/model/agent by default
+			const sessionRows = await db
+				.select()
+				.from(sessions)
+				.where(eq(sessions.id, sessionId));
+			if (!sessionRows.length) {
+				logger.warn('Session not found', { sessionId });
+				return c.json({ error: 'Session not found' }, 404);
+			}
+			const sess: SessionRow = sessionRows[0];
+			const provider = body?.provider ?? sess.provider ?? cfg.defaults.provider;
+			const modelName = body?.model ?? sess.model ?? cfg.defaults.model;
+			const agent = body?.agent ?? sess.agent ?? cfg.defaults.agent;
+			const content = body?.content ?? '';
+
+			// Validate model capabilities if tools are allowed for this agent
+			const wantsToolCalls = true; // agent toolset may be non-empty
+			try {
+				validateProviderModel(provider, modelName, { wantsToolCalls });
+			} catch (err) {
+				logger.error('Model validation failed', err, { provider, modelName });
+				const message = err instanceof Error ? err.message : String(err);
+				return c.json({ error: message }, 400);
+			}
+			// Enforce provider auth: only allow providers/models the user authenticated for
+			const authorized = await isProviderAuthorized(cfg, provider);
+			if (!authorized) {
+				logger.warn('Provider not authorized', { provider });
+				return c.json(
+					{
+						error: `Provider ${provider} is not configured. Run \`agi auth login\` to add credentials.`,
+					},
+					400,
+				);
+			}
+			await ensureProviderEnv(cfg, provider);
 
-		const { assistantMessageId } = await dispatchAssistantMessage({
-			cfg,
-			db,
-			session: sess,
-			agent,
-			provider,
-			model: modelName,
-			content,
-			oneShot: Boolean(body?.oneShot),
-		});
-		return c.json({ messageId: assistantMessageId }, 202);
+			const { assistantMessageId } = await dispatchAssistantMessage({
+				cfg,
+				db,
+				session: sess,
+				agent,
+				provider,
+				model: modelName,
+				content,
+				oneShot: Boolean(body?.oneShot),
+			});
+			return c.json({ messageId: assistantMessageId }, 202);
+		} catch (error) {
+			logger.error('Failed to create session message', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
 	});
 }

package/src/routes/sessions.ts

@@ -7,6 +7,8 @@ import type { ProviderId } from '@agi-cli/sdk';
 import { isProviderId } from '@agi-cli/sdk';
 import { resolveAgentConfig } from '../runtime/agent-registry.ts';
 import { createSession as createSessionRow } from '../runtime/session-manager.ts';
+import { serializeError } from '../runtime/api-error.ts';
+import { logger } from '../runtime/logger.ts';
 
 export function registerSessionsRoutes(app: Hono) {
 	// List sessions
@@ -72,8 +74,9 @@ export function registerSessionsRoutes(app: Hono) {
 			});
 			return c.json(row, 201);
 		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			return c.json({ error: message }, 400);
+			logger.error('Failed to create session', err);
+			const errorResponse = serializeError(err);
+			return c.json(errorResponse, errorResponse.error.status || 400);
 		}
 	});