@agi-cli/server 0.1.65 → 0.1.67

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/server",
-	"version": "0.1.65",
+	"version": "0.1.67",
 	"description": "HTTP API server for AGI CLI",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -29,10 +29,11 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@agi-cli/sdk": "0.1.65",
-		"@agi-cli/database": "0.1.65",
+		"@agi-cli/sdk": "0.1.67",
+		"@agi-cli/database": "0.1.67",
 		"drizzle-orm": "^0.44.5",
-		"hono": "^4.9.9"
+		"hono": "^4.9.9",
+		"zod": "^4.1.8"
 	},
 	"devDependencies": {
 		"@types/bun": "latest",

package/src/routes/config.ts

@@ -4,6 +4,63 @@ import { catalog, type ProviderId, isProviderAuthorized } from '@agi-cli/sdk';
 import { readdir } from 'node:fs/promises';
 import { join, basename } from 'node:path';
 import type { EmbeddedAppConfig } from '../index.ts';
+import type { AGIConfig } from '@agi-cli/sdk';
+
+/**
+ * Check if a provider is authorized in either embedded config or file-based config
+ */
+async function isProviderAuthorizedHybrid(
+	embeddedConfig: EmbeddedAppConfig | undefined,
+	fileConfig: AGIConfig,
+	provider: ProviderId,
+): Promise<boolean> {
+	// Check embedded auth first
+	const hasEmbeddedAuth =
+		embeddedConfig?.provider === provider ||
+		(embeddedConfig?.auth && provider in embeddedConfig.auth);
+
+	if (hasEmbeddedAuth) {
+		return true;
+	}
+
+	// Fallback to file-based auth
+	return await isProviderAuthorized(fileConfig, provider);
+}
+
+/**
+ * Get all authorized providers from both embedded and file-based config
+ */
+async function getAuthorizedProviders(
+	embeddedConfig: EmbeddedAppConfig | undefined,
+	fileConfig: AGIConfig,
+): Promise<ProviderId[]> {
+	const allProviders = Object.keys(catalog) as ProviderId[];
+	const authorizedProviders: ProviderId[] = [];
+
+	for (const provider of allProviders) {
+		const authorized = await isProviderAuthorizedHybrid(
+			embeddedConfig,
+			fileConfig,
+			provider,
+		);
+		if (authorized) {
+			authorizedProviders.push(provider);
+		}
+	}
+
+	return authorizedProviders;
+}
+
+/**
+ * Get default value with embedded config taking priority over file config
+ */
+function getDefault<T>(
+	embeddedValue: T | undefined,
+	embeddedDefaultValue: T | undefined,
+	fileValue: T,
+): T {
+	return embeddedValue ?? embeddedDefaultValue ?? fileValue;
+}
 
 export function registerConfigRoutes(app: Hono) {
 	// Get working directory info
@@ -46,37 +103,28 @@ export function registerConfigRoutes(app: Hono) {
 		const allAgents = Array.from(new Set([...embeddedAgents, ...fileAgents]));
 
 		// Providers: Check both embedded and file-based auth
-		const allProviders = Object.keys(catalog) as ProviderId[];
-		const authorizedProviders: ProviderId[] = [];
-
-		for (const provider of allProviders) {
-			// Check embedded auth first
-			const hasEmbeddedAuth =
-				embeddedConfig?.provider === provider ||
-				(embeddedConfig?.auth && provider in embeddedConfig.auth);
-
-			// Fallback to file-based auth
-			const hasFileAuth = await isProviderAuthorized(cfg, provider);
-
-			if (hasEmbeddedAuth || hasFileAuth) {
-				authorizedProviders.push(provider);
-			}
-		}
+		const authorizedProviders = await getAuthorizedProviders(
+			embeddedConfig,
+			cfg,
+		);
 
 		// Defaults: Embedded overrides file config
 		const defaults = {
-			agent:
-				embeddedConfig?.defaults?.agent ||
-				embeddedConfig?.agent ||
+			agent: getDefault(
+				embeddedConfig?.agent,
+				embeddedConfig?.defaults?.agent,
 				cfg.defaults.agent,
-			provider:
-				embeddedConfig?.defaults?.provider ||
-				embeddedConfig?.provider ||
+			),
+			provider: getDefault(
+				embeddedConfig?.provider,
+				embeddedConfig?.defaults?.provider,
 				cfg.defaults.provider,
-			model:
-				embeddedConfig?.defaults?.model ||
-				embeddedConfig?.model ||
+			),
+			model: getDefault(
+				embeddedConfig?.model,
+				embeddedConfig?.defaults?.model,
 				cfg.defaults.model,
+			),
 		};
 
 		return c.json({
@@ -98,8 +146,11 @@ export function registerConfigRoutes(app: Hono) {
 				: ['general', 'build', 'plan'];
 			return c.json({
 				agents,
-				default:
-					embeddedConfig.agent || embeddedConfig.defaults?.agent || 'general',
+				default: getDefault(
+					embeddedConfig.agent,
+					embeddedConfig.defaults?.agent,
+					'general',
+				),
 			});
 		}
 
@@ -140,22 +191,18 @@ export function registerConfigRoutes(app: Hono) {
 
 			return c.json({
 				providers,
-				default: embeddedConfig.defaults?.provider || embeddedConfig.provider,
+				default: getDefault(
+					embeddedConfig.provider,
+					embeddedConfig.defaults?.provider,
+					undefined,
+				),
 			});
 		}
 
 		const projectRoot = c.req.query('project') || process.cwd();
 		const cfg = await loadConfig(projectRoot);
 
-		const allProviders = Object.keys(catalog) as ProviderId[];
-		const authorizedProviders: ProviderId[] = [];
-
-		for (const provider of allProviders) {
-			const authorized = await isProviderAuthorized(cfg, provider);
-			if (authorized) {
-				authorizedProviders.push(provider);
-			}
-		}
+		const authorizedProviders = await getAuthorizedProviders(undefined, cfg);
 
 		return c.json({
 			providers: authorizedProviders,
@@ -170,36 +217,17 @@ export function registerConfigRoutes(app: Hono) {
 			| undefined;
 		const provider = c.req.param('provider') as ProviderId;
 
-		if (embeddedConfig) {
-			// Check if provider is authorized in embedded mode
-			const hasAuth =
-				embeddedConfig.provider === provider ||
-				(embeddedConfig.auth && provider in embeddedConfig.auth);
-
-			if (!hasAuth) {
-				return c.json({ error: 'Provider not authorized' }, 403);
-			}
-
-			const providerCatalog = catalog[provider];
-			if (!providerCatalog) {
-				return c.json({ error: 'Provider not found' }, 404);
-			}
-
-			return c.json({
-				models: providerCatalog.models.map((m) => ({
-					id: m.id,
-					label: m.label || m.id,
-					toolCall: m.toolCall,
-					reasoning: m.reasoning,
-				})),
-				default: embeddedConfig.model || embeddedConfig.defaults?.model,
-			});
-		}
-
+		// Always load file config for fallback auth check
 		const projectRoot = c.req.query('project') || process.cwd();
 		const cfg = await loadConfig(projectRoot);
 
-		const authorized = await isProviderAuthorized(cfg, provider);
+		// Check if provider is authorized (hybrid: embedded OR file-based)
+		const authorized = await isProviderAuthorizedHybrid(
+			embeddedConfig,
+			cfg,
+			provider,
+		);
+
 		if (!authorized) {
 			return c.json({ error: 'Provider not authorized' }, 403);
 		}
@@ -216,7 +244,11 @@ export function registerConfigRoutes(app: Hono) {
 				toolCall: m.toolCall,
 				reasoning: m.reasoning,
 			})),
-			default: cfg.defaults.model,
+			default: getDefault(
+				embeddedConfig?.model,
+				embeddedConfig?.defaults?.model,
+				cfg.defaults.model,
+			),
 		});
 	});
 }

package/src/routes/git.ts

@@ -1,6 +1,7 @@
 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';
@@ -113,10 +114,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 +153,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 +182,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,
 			});
 		}
 	}
@@ -210,6 +248,23 @@ function getStatusFromCode(code: string): GitFile['status'] {
 	}
 }
 
+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'; // Copied - treat as modified
+		default:
+			return 'modified';
+	}
+}
+
 async function getAheadBehind(
 	gitRoot: string,
 ): Promise<{ ahead: number; behind: number }> {
@@ -264,11 +319,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 +344,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 +384,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 +468,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,10 +669,10 @@ 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