@agi-cli/server 0.1.81 → 0.1.83

package/package.json

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

package/src/index.ts

@@ -7,9 +7,9 @@ import { registerSessionsRoutes } from './routes/sessions.ts';
 import { registerSessionMessagesRoutes } from './routes/session-messages.ts';
 import { registerSessionStreamRoute } from './routes/session-stream.ts';
 import { registerAskRoutes } from './routes/ask.ts';
-import { registerConfigRoutes } from './routes/config.ts';
+import { registerConfigRoutes } from './routes/config/index.ts';
 import { registerFilesRoutes } from './routes/files.ts';
-import { registerGitRoutes } from './routes/git.ts';
+import { registerGitRoutes } from './routes/git/index.ts';
 import type { AgentConfigEntry } from './runtime/agent-registry.ts';
 
 function initApp() {

package/src/openapi/paths/git.ts

@@ -346,4 +346,108 @@ export const gitPaths = {
 			},
 		},
 	},
+	'/v1/git/restore': {
+		post: {
+			tags: ['git'],
+			operationId: 'restoreFiles',
+			summary: 'Restore files to HEAD',
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								project: { type: 'string' },
+								files: {
+									type: 'array',
+									items: { type: 'string' },
+								},
+							},
+							required: ['files'],
+						},
+					},
+				},
+			},
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									status: { type: 'string', enum: ['ok'] },
+									data: {
+										type: 'object',
+										properties: {
+											restored: {
+												type: 'array',
+												items: { type: 'string' },
+											},
+										},
+										required: ['restored'],
+									},
+								},
+								required: ['status', 'data'],
+							},
+						},
+					},
+				},
+				500: gitErrorResponse(),
+			},
+		},
+	},
+	'/v1/git/delete': {
+		post: {
+			tags: ['git'],
+			operationId: 'deleteFiles',
+			summary: 'Delete untracked files',
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								project: { type: 'string' },
+								files: {
+									type: 'array',
+									items: { type: 'string' },
+								},
+							},
+							required: ['files'],
+						},
+					},
+				},
+			},
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									status: { type: 'string', enum: ['ok'] },
+									data: {
+										type: 'object',
+										properties: {
+											deleted: {
+												type: 'array',
+												items: { type: 'string' },
+											},
+										},
+										required: ['deleted'],
+									},
+								},
+								required: ['status', 'data'],
+							},
+						},
+					},
+				},
+				500: gitErrorResponse(),
+			},
+		},
+	},
 } as const;

package/src/routes/config/agents.ts

@@ -0,0 +1,44 @@
+import type { Hono } from 'hono';
+import { loadConfig } from '@agi-cli/sdk';
+import type { EmbeddedAppConfig } from '../../index.ts';
+import { logger } from '../../runtime/logger.ts';
+import { serializeError } from '../../runtime/api-error.ts';
+import { discoverAllAgents, getDefault } from './utils.ts';
+
+export function registerAgentsRoute(app: Hono) {
+	app.get('/v1/config/agents', async (c) => {
+		try {
+			const embeddedConfig = c.get('embeddedConfig') as
+				| EmbeddedAppConfig
+				| undefined;
+
+			if (embeddedConfig) {
+				const agents = embeddedConfig.agents
+					? Object.keys(embeddedConfig.agents)
+					: ['general', 'build', 'plan'];
+				return c.json({
+					agents,
+					default: getDefault(
+						embeddedConfig.agent,
+						embeddedConfig.defaults?.agent,
+						'general',
+					),
+				});
+			}
+
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+
+			const allAgents = await discoverAllAgents(cfg.projectRoot);
+
+			return c.json({
+				agents: allAgents,
+				default: cfg.defaults.agent,
+			});
+		} catch (error) {
+			logger.error('Failed to get agents', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}

package/src/routes/config/cwd.ts

@@ -0,0 +1,21 @@
+import type { Hono } from 'hono';
+import { basename } from 'node:path';
+import { logger } from '../../runtime/logger.ts';
+import { serializeError } from '../../runtime/api-error.ts';
+
+export function registerCwdRoute(app: Hono) {
+	app.get('/v1/config/cwd', (c) => {
+		try {
+			const cwd = process.cwd();
+			const dirName = basename(cwd);
+			return c.json({
+				cwd,
+				dirName,
+			});
+		} catch (error) {
+			logger.error('Failed to get current working directory', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}

package/src/routes/config/index.ts

@@ -0,0 +1,14 @@
+import type { Hono } from 'hono';
+import { registerCwdRoute } from './cwd.ts';
+import { registerMainConfigRoute } from './main.ts';
+import { registerAgentsRoute } from './agents.ts';
+import { registerProvidersRoute } from './providers.ts';
+import { registerModelsRoutes } from './models.ts';
+
+export function registerConfigRoutes(app: Hono) {
+	registerCwdRoute(app);
+	registerMainConfigRoute(app);
+	registerAgentsRoute(app);
+	registerProvidersRoute(app);
+	registerModelsRoutes(app);
+}

package/src/routes/config/main.ts

@@ -0,0 +1,68 @@
+import type { Hono } from 'hono';
+import { loadConfig } from '@agi-cli/sdk';
+import type { EmbeddedAppConfig } from '../../index.ts';
+import { logger } from '../../runtime/logger.ts';
+import { serializeError } from '../../runtime/api-error.ts';
+import {
+	discoverAllAgents,
+	getAuthorizedProviders,
+	getDefault,
+} from './utils.ts';
+
+export function registerMainConfigRoute(app: Hono) {
+	app.get('/v1/config', async (c) => {
+		try {
+			const projectRoot = c.req.query('project') || process.cwd();
+			const embeddedConfig = c.get('embeddedConfig') as
+				| EmbeddedAppConfig
+				| undefined;
+
+			const cfg = await loadConfig(projectRoot);
+
+			let allAgents: string[];
+
+			if (embeddedConfig?.agents) {
+				const embeddedAgents = Object.keys(embeddedConfig.agents);
+				const fileAgents = await discoverAllAgents(cfg.projectRoot);
+				allAgents = Array.from(
+					new Set([...embeddedAgents, ...fileAgents]),
+				).sort();
+			} else {
+				allAgents = await discoverAllAgents(cfg.projectRoot);
+			}
+
+			const authorizedProviders = await getAuthorizedProviders(
+				embeddedConfig,
+				cfg,
+			);
+
+			const defaults = {
+				agent: getDefault(
+					embeddedConfig?.agent,
+					embeddedConfig?.defaults?.agent,
+					cfg.defaults.agent,
+				),
+				provider: getDefault(
+					embeddedConfig?.provider,
+					embeddedConfig?.defaults?.provider,
+					cfg.defaults.provider,
+				),
+				model: getDefault(
+					embeddedConfig?.model,
+					embeddedConfig?.defaults?.model,
+					cfg.defaults.model,
+				),
+			};
+
+			return c.json({
+				agents: allAgents,
+				providers: authorizedProviders,
+				defaults,
+			});
+		} catch (error) {
+			logger.error('Failed to load config', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}

package/src/routes/config/models.ts

@@ -0,0 +1,109 @@
+import type { Hono } from 'hono';
+import { loadConfig, catalog, type ProviderId } from '@agi-cli/sdk';
+import type { EmbeddedAppConfig } from '../../index.ts';
+import { logger } from '../../runtime/logger.ts';
+import { serializeError } from '../../runtime/api-error.ts';
+import {
+	isProviderAuthorizedHybrid,
+	getAuthorizedProviders,
+	getDefault,
+} from './utils.ts';
+
+export function registerModelsRoutes(app: Hono) {
+	app.get('/v1/config/providers/:provider/models', async (c) => {
+		try {
+			const embeddedConfig = c.get('embeddedConfig') as
+				| EmbeddedAppConfig
+				| undefined;
+			const provider = c.req.param('provider') as ProviderId;
+
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+
+			const authorized = await isProviderAuthorizedHybrid(
+				embeddedConfig,
+				cfg,
+				provider,
+			);
+
+			if (!authorized) {
+				logger.warn('Provider not authorized', { provider });
+				return c.json({ error: 'Provider not authorized' }, 403);
+			}
+
+			const providerCatalog = catalog[provider];
+			if (!providerCatalog) {
+				logger.warn('Provider not found in catalog', { provider });
+				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: getDefault(
+					embeddedConfig?.model,
+					embeddedConfig?.defaults?.model,
+					cfg.defaults.model,
+				),
+			});
+		} catch (error) {
+			logger.error('Failed to get provider models', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.get('/v1/config/models', async (c) => {
+		try {
+			const embeddedConfig = c.get('embeddedConfig') as
+				| EmbeddedAppConfig
+				| undefined;
+
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+
+			const authorizedProviders = await getAuthorizedProviders(
+				embeddedConfig,
+				cfg,
+			);
+
+			const modelsMap: Record<
+				string,
+				{
+					label: string;
+					models: Array<{
+						id: string;
+						label: string;
+						toolCall?: boolean;
+						reasoning?: boolean;
+					}>;
+				}
+			> = {};
+
+			for (const provider of authorizedProviders) {
+				const providerCatalog = catalog[provider];
+				if (providerCatalog) {
+					modelsMap[provider] = {
+						label: providerCatalog.label || provider,
+						models: providerCatalog.models.map((m) => ({
+							id: m.id,
+							label: m.label || m.id,
+							toolCall: m.toolCall,
+							reasoning: m.reasoning,
+						})),
+					};
+				}
+			}
+
+			return c.json(modelsMap);
+		} catch (error) {
+			logger.error('Failed to get all models', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}

package/src/routes/config/providers.ts

@@ -0,0 +1,46 @@
+import type { Hono } from 'hono';
+import { loadConfig } from '@agi-cli/sdk';
+import type { ProviderId } from '@agi-cli/sdk';
+import type { EmbeddedAppConfig } from '../../index.ts';
+import { logger } from '../../runtime/logger.ts';
+import { serializeError } from '../../runtime/api-error.ts';
+import { getAuthorizedProviders, getDefault } from './utils.ts';
+
+export function registerProvidersRoute(app: Hono) {
+	app.get('/v1/config/providers', async (c) => {
+		try {
+			const embeddedConfig = c.get('embeddedConfig') as
+				| EmbeddedAppConfig
+				| undefined;
+
+			if (embeddedConfig) {
+				const providers = embeddedConfig.auth
+					? (Object.keys(embeddedConfig.auth) as ProviderId[])
+					: [embeddedConfig.provider];
+
+				return c.json({
+					providers,
+					default: getDefault(
+						embeddedConfig.provider,
+						embeddedConfig.defaults?.provider,
+						undefined,
+					),
+				});
+			}
+
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+
+			const authorizedProviders = await getAuthorizedProviders(undefined, cfg);
+
+			return c.json({
+				providers: authorizedProviders,
+				default: cfg.defaults.provider,
+			});
+		} catch (error) {
+			logger.error('Failed to get providers', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}

package/src/routes/config/utils.ts

@@ -0,0 +1,107 @@
+import {
+	catalog,
+	type ProviderId,
+	isProviderAuthorized,
+	getGlobalAgentsDir,
+} from '@agi-cli/sdk';
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { EmbeddedAppConfig } from '../../index.ts';
+import type { AGIConfig } from '@agi-cli/sdk';
+import { logger } from '../../runtime/logger.ts';
+import { loadAgentsConfig } from '../../runtime/agent-registry.ts';
+
+export async function isProviderAuthorizedHybrid(
+	embeddedConfig: EmbeddedAppConfig | undefined,
+	fileConfig: AGIConfig,
+	provider: ProviderId,
+): Promise<boolean> {
+	const hasEmbeddedAuth =
+		embeddedConfig?.provider === provider ||
+		(embeddedConfig?.auth && provider in embeddedConfig.auth);
+
+	if (hasEmbeddedAuth) {
+		return true;
+	}
+
+	return await isProviderAuthorized(fileConfig, provider);
+}
+
+export 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;
+}
+
+export function getDefault<T>(
+	embeddedValue: T | undefined,
+	embeddedDefaultValue: T | undefined,
+	fileValue: T,
+): T {
+	return embeddedValue ?? embeddedDefaultValue ?? fileValue;
+}
+
+export async function discoverAllAgents(
+	projectRoot: string,
+): Promise<string[]> {
+	const builtInAgents = ['general', 'build', 'plan'];
+	const agentSet = new Set<string>(builtInAgents);
+
+	try {
+		const agentsJson = await loadAgentsConfig(projectRoot);
+		for (const agentName of Object.keys(agentsJson)) {
+			if (agentName.trim()) {
+				agentSet.add(agentName);
+			}
+		}
+	} catch (err) {
+		logger.debug('Failed to load agents.json', err);
+	}
+
+	try {
+		const localAgentsPath = join(projectRoot, '.agi', 'agents');
+		const localFiles = await readdir(localAgentsPath).catch(() => []);
+		for (const file of localFiles) {
+			if (file.endsWith('.txt') || file.endsWith('.md')) {
+				const agentName = file.replace(/\.(txt|md)$/, '');
+				if (agentName.trim()) {
+					agentSet.add(agentName);
+				}
+			}
+		}
+	} catch (err) {
+		logger.debug('Failed to read local agents directory', err);
+	}
+
+	try {
+		const globalAgentsPath = getGlobalAgentsDir();
+		const globalFiles = await readdir(globalAgentsPath).catch(() => []);
+		for (const file of globalFiles) {
+			if (file.endsWith('.txt') || file.endsWith('.md')) {
+				const agentName = file.replace(/\.(txt|md)$/, '');
+				if (agentName.trim()) {
+					agentSet.add(agentName);
+				}
+			}
+		}
+	} catch (err) {
+		logger.debug('Failed to read global agents directory', err);
+	}
+
+	return Array.from(agentSet).sort();
+}

package/src/routes/files.ts

@@ -1,5 +1,5 @@
 import type { Hono } from 'hono';
-import { readdir } from 'node:fs/promises';
+import { readdir, readFile } from 'node:fs/promises';
 import { join, relative } from 'node:path';
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -38,6 +38,51 @@ function shouldExclude(name: string): boolean {
 	return false;
 }
 
+async function parseGitignore(projectRoot: string): Promise<Set<string>> {
+	const patterns = new Set<string>();
+	try {
+		const gitignorePath = join(projectRoot, '.gitignore');
+		const content = await readFile(gitignorePath, 'utf-8');
+		for (const line of content.split('\n')) {
+			const trimmed = line.trim();
+			if (trimmed && !trimmed.startsWith('#')) {
+				patterns.add(trimmed);
+			}
+		}
+	} catch (_err) {}
+	return patterns;
+}
+
+function matchesGitignorePattern(
+	relativePath: string,
+	patterns: Set<string>,
+): boolean {
+	for (const pattern of patterns) {
+		const cleanPattern = pattern.replace(/^\//, '').replace(/\/$/, '');
+		const pathParts = relativePath.split('/');
+
+		if (pattern.endsWith('/')) {
+			if (pathParts[0] === cleanPattern) return true;
+			if (relativePath.startsWith(`${cleanPattern}/`)) return true;
+		}
+
+		if (pattern.includes('*')) {
+			const regex = new RegExp(
+				`^${cleanPattern.replace(/\*/g, '.*').replace(/\?/g, '.')}$`,
+			);
+			if (regex.test(relativePath)) return true;
+			for (const part of pathParts) {
+				if (regex.test(part)) return true;
+			}
+		} else {
+			if (relativePath === cleanPattern) return true;
+			if (pathParts.includes(cleanPattern)) return true;
+			if (relativePath.startsWith(`${cleanPattern}/`)) return true;
+		}
+	}
+	return false;
+}
+
 async function traverseDirectory(
 	dir: string,
 	projectRoot: string,
@@ -45,6 +90,7 @@ async function traverseDirectory(
 	currentDepth = 0,
 	limit: number,
 	collected: string[] = [],
+	gitignorePatterns?: Set<string>,
 ): Promise<{ files: string[]; truncated: boolean }> {
 	if (currentDepth >= maxDepth || collected.length >= limit) {
 		return { files: collected, truncated: collected.length >= limit };
@@ -65,6 +111,13 @@ async function traverseDirectory(
 			const fullPath = join(dir, entry.name);
 			const relativePath = relative(projectRoot, fullPath);
 
+			if (
+				gitignorePatterns &&
+				matchesGitignorePattern(relativePath, gitignorePatterns)
+			) {
+				continue;
+			}
+
 			if (entry.isDirectory()) {
 				const result = await traverseDirectory(
 					fullPath,
@@ -73,6 +126,7 @@ async function traverseDirectory(
 					currentDepth + 1,
 					limit,
 					collected,
+					gitignorePatterns,
 				);
 				if (result.truncated) {
 					return result;
@@ -112,7 +166,7 @@ async function getChangedFiles(
 			}
 		}
 		return changedFiles;
-	} catch (err) {
+	} catch (_err) {
 		return new Set();
 	}
 }
@@ -124,12 +178,16 @@ export function registerFilesRoutes(app: Hono) {
 			const maxDepth = Number.parseInt(c.req.query('maxDepth') || '10', 10);
 			const limit = Number.parseInt(c.req.query('limit') || '1000', 10);
 
+			const gitignorePatterns = await parseGitignore(projectRoot);
+
 			const result = await traverseDirectory(
 				projectRoot,
 				projectRoot,
 				maxDepth,
 				0,
 				limit,
+				[],
+				gitignorePatterns,
 			);
 
 			const changedFiles = await getChangedFiles(projectRoot);