@agi-cli/server 0.1.80 → 0.1.81

package/src/routes/files.ts

@@ -0,0 +1,160 @@
+import type { Hono } from 'hono';
+import { readdir } 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 traverseDirectory(
+	dir: string,
+	projectRoot: string,
+	maxDepth: number,
+	currentDepth = 0,
+	limit: number,
+	collected: 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 (entry.isDirectory()) {
+				const result = await traverseDirectory(
+					fullPath,
+					projectRoot,
+					maxDepth,
+					currentDepth + 1,
+					limit,
+					collected,
+				);
+				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 result = await traverseDirectory(
+				projectRoot,
+				projectRoot,
+				maxDepth,
+				0,
+				limit,
+			);
+
+			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);
+		}
+	});
+}