@agi-cli/server 0.1.80 → 0.1.82

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

@@ -0,0 +1,218 @@
+import type { Hono } from 'hono';
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { serializeError } from '../runtime/api-error.ts';
+import { logger } from '../runtime/logger.ts';
+
+const execAsync = promisify(exec);
+
+const EXCLUDED_PATTERNS = [
+	'node_modules',
+	'.git',
+	'dist',
+	'build',
+	'.next',
+	'.nuxt',
+	'.turbo',
+	'coverage',
+	'.cache',
+	'.DS_Store',
+	'bun.lockb',
+	'.env',
+	'.env.local',
+	'.env.production',
+	'.env.development',
+];
+
+function shouldExclude(name: string): boolean {
+	for (const pattern of EXCLUDED_PATTERNS) {
+		if (pattern.includes('*')) {
+			const regex = new RegExp(`^${pattern.replace(/\*/g, '.*')}$`);
+			if (regex.test(name)) return true;
+		} else if (name === pattern || name.endsWith(pattern)) {
+			return true;
+		}
+	}
+	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,
+	maxDepth: number,
+	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 };
+	}
+
+	try {
+		const entries = await readdir(dir, { withFileTypes: true });
+
+		for (const entry of entries) {
+			if (collected.length >= limit) {
+				return { files: collected, truncated: true };
+			}
+
+			if (shouldExclude(entry.name)) {
+				continue;
+			}
+
+			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,
+					projectRoot,
+					maxDepth,
+					currentDepth + 1,
+					limit,
+					collected,
+					gitignorePatterns,
+				);
+				if (result.truncated) {
+					return result;
+				}
+			} else if (entry.isFile()) {
+				collected.push(relativePath);
+			}
+		}
+	} catch (err) {
+		logger.warn(`Failed to read directory ${dir}:`, err);
+	}
+
+	return { files: collected, truncated: false };
+}
+
+async function getChangedFiles(
+	projectRoot: string,
+): Promise<Map<string, string>> {
+	try {
+		const { stdout } = await execAsync('git status --porcelain', {
+			cwd: projectRoot,
+		});
+		const changedFiles = new Map<string, string>();
+		for (const line of stdout.split('\n')) {
+			if (line.length > 3) {
+				const statusCode = line.substring(0, 2).trim();
+				const filePath = line.substring(3).trim();
+
+				let status = 'modified';
+				if (statusCode.includes('A')) status = 'added';
+				else if (statusCode.includes('M')) status = 'modified';
+				else if (statusCode.includes('D')) status = 'deleted';
+				else if (statusCode.includes('R')) status = 'renamed';
+				else if (statusCode.includes('?')) status = 'untracked';
+
+				changedFiles.set(filePath, status);
+			}
+		}
+		return changedFiles;
+	} catch (_err) {
+		return new Set();
+	}
+}
+
+export function registerFilesRoutes(app: Hono) {
+	app.get('/v1/files', async (c) => {
+		try {
+			const projectRoot = c.req.query('project') || process.cwd();
+			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);
+
+			result.files.sort((a, b) => {
+				const aChanged = changedFiles.has(a);
+				const bChanged = changedFiles.has(b);
+				if (aChanged && !bChanged) return -1;
+				if (!aChanged && bChanged) return 1;
+				return a.localeCompare(b);
+			});
+
+			return c.json({
+				files: result.files,
+				changedFiles: Array.from(changedFiles.entries()).map(
+					([path, status]) => ({
+						path,
+						status,
+					}),
+				),
+				truncated: result.truncated,
+			});
+		} catch (err) {
+			logger.error('Files route error:', err);
+			return c.json({ error: serializeError(err) }, 500);
+		}
+	});
+}

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,
+			);
+		}
+	});
+}