@agi-cli/server 0.1.79 → 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);
+		}
+	});
+}

package/src/runtime/history-builder.ts

@@ -109,6 +109,9 @@ export async function buildHistoryMessages(
 			}
 
 			for (const call of toolCalls) {
+				// Skip finish tool from history - it's internal loop control
+				if (call.name === 'finish') continue;
+
 				const toolType = `tool-${call.name}` as `tool-${string}`;
 				const result = toolResults.find((r) => r.callId === call.callId);
 

package/src/runtime/runner.ts

@@ -76,33 +76,6 @@ async function processQueue(sessionId: string) {
 	cleanupSession(sessionId);
 }
 
-/**
- * Ensures the finish tool is called if not already observed.
- */
-async function ensureFinishToolCalled(
-	finishObserved: boolean,
-	toolset: ReturnType<typeof adaptTools>,
-	sharedCtx: RunnerToolContext,
-	stepIndex: number,
-) {
-	if (finishObserved || !toolset?.finish?.execute) return;
-
-	const finishInput = {} as const;
-	const callOptions = { input: finishInput } as const;
-
-	sharedCtx.stepIndex = stepIndex;
-
-	try {
-		await toolset.finish.onInputStart?.(callOptions as never);
-	} catch {}
-
-	try {
-		await toolset.finish.onInputAvailable?.(callOptions as never);
-	} catch {}
-
-	await toolset.finish.execute(finishInput, {} as never);
-}
-
 /**
  * Main function to run the assistant for a given request.
  */
@@ -290,12 +263,7 @@ async function runAssistant(opts: RunOpts) {
 
 	const onAbort = createAbortHandler(opts, db, getStepIndex, sharedCtx);
 
-	const onFinish = createFinishHandler(
-		opts,
-		db,
-		() => ensureFinishToolCalled(finishObserved, toolset, sharedCtx, stepIndex),
-		completeAssistantMessage,
-	);
+	const onFinish = createFinishHandler(opts, db, completeAssistantMessage);
 
 	// Apply optimizations: deduplication, pruning, cache control, and truncation
 	const { addCacheControl, truncateHistory } = await import(

package/src/runtime/stream-handlers.ts

@@ -264,7 +264,6 @@ export function createAbortHandler(
 export function createFinishHandler(
 	opts: RunOpts,
 	db: Awaited<ReturnType<typeof getDb>>,
-	ensureFinishToolCalled: () => Promise<void>,
 	completeAssistantMessageFn: (
 		fin: FinishEvent,
 		opts: RunOpts,
@@ -272,10 +271,6 @@ export function createFinishHandler(
 	) => Promise<void>,
 ) {
 	return async (fin: FinishEvent) => {
-		try {
-			await ensureFinishToolCalled();
-		} catch {}
-
 		// Note: Token updates are handled incrementally in onStepFinish
 		// Do NOT add fin.usage here as it would cause double-counting
 

package/src/tools/adapter.ts

@@ -5,6 +5,7 @@ import { publish } from '../events/bus.ts';
 import type { DiscoveredTool } from '@agi-cli/sdk';
 import { getCwd, setCwd, joinRelative } from '../runtime/cwd.ts';
 import type { ToolAdapterContext } from '../runtime/tool-context.ts';
+import { isToolError } from '@agi-cli/sdk/tools/error';
 
 export type { ToolAdapterContext } from '../runtime/tool-context.ts';
 
@@ -403,7 +404,8 @@ export function adaptTools(
 					}
 					return result;
 				} catch (error) {
-					// Tool execution failed - save error to database as tool_result
+					// Tool execution failed
+					// Check if the error is already a structured tool error response
 					const resultPartId = crypto.randomUUID();
 					const callId = callIdFromQueue;
 					const startTs = startTsFromQueue;
@@ -411,15 +413,21 @@ export function adaptTools(
 					const dur =
 						typeof startTs === 'number' ? Math.max(0, endTs - startTs) : null;
 
-					const errorMessage =
-						error instanceof Error ? error.message : String(error);
-					const errorStack = error instanceof Error ? error.stack : undefined;
-
-					const errorResult = {
-						ok: false,
-						error: errorMessage,
-						stack: errorStack,
-					};
+					// If the tool returned a structured error response, use it directly
+					// Otherwise, wrap the thrown error in our standard format
+					let errorResult: unknown;
+					if (isToolError(error)) {
+						errorResult = error;
+					} else {
+						const errorMessage =
+							error instanceof Error ? error.message : String(error);
+						const errorStack = error instanceof Error ? error.stack : undefined;
+						errorResult = {
+							ok: false,
+							error: errorMessage,
+							stack: errorStack,
+						};
+					}
 
 					const contentObj = {
 						name,