@agi-cli/sdk 0.1.57 → 0.1.59

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/sdk",
-	"version": "0.1.57",
+	"version": "0.1.59",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "ntishxyz",
 	"license": "MIT",

package/src/core/src/tools/builtin/bash.ts

@@ -1,6 +1,6 @@
 import { tool, type Tool } from 'ai';
 import { z } from 'zod';
-import { exec } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import DESCRIPTION from './bash.txt' with { type: 'text' };
 
 function normalizePath(p: string) {
@@ -31,7 +31,7 @@ export function buildBashTool(projectRoot: string): {
 		description: DESCRIPTION,
 		inputSchema: z
 			.object({
-				cmd: z.string().describe('Shell command to run (bash -lc <cmd>)'),
+				cmd: z.string().describe('Shell command to run (bash -c <cmd>)'),
 				cwd: z
 					.string()
 					.default('.')
@@ -41,27 +41,45 @@ export function buildBashTool(projectRoot: string): {
 					.optional()
 					.default(false)
 					.describe('If true, do not throw on non-zero exit'),
+				timeout: z
+					.number()
+					.optional()
+					.default(300000)
+					.describe('Timeout in milliseconds (default: 300000 = 5 minutes)'),
 			})
 			.strict(),
 		async execute({
 			cmd,
 			cwd,
 			allowNonZeroExit,
+			timeout = 300000,
 		}: {
 			cmd: string;
 			cwd?: string;
 			allowNonZeroExit?: boolean;
+			timeout?: number;
 		}) {
 			const absCwd = resolveSafePath(projectRoot, cwd || '.');
 
 			return new Promise((resolve, reject) => {
-				const proc = exec(`bash -lc '${cmd.replace(/'/g, "'\\''")}'`, {
+				// Use spawn with shell: true for cross-platform compatibility
+				const proc = spawn(cmd, {
 					cwd: absCwd,
-					maxBuffer: 10 * 1024 * 1024,
+					shell: true,
+					stdio: ['ignore', 'pipe', 'pipe'],
 				});
 
 				let stdout = '';
 				let stderr = '';
+				let didTimeout = false;
+				let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+				if (timeout > 0) {
+					timeoutId = setTimeout(() => {
+						didTimeout = true;
+						proc.kill();
+					}, timeout);
+				}
 
 				proc.stdout?.on('data', (chunk) => {
 					stdout += chunk.toString();
@@ -72,8 +90,16 @@ export function buildBashTool(projectRoot: string): {
 				});
 
 				proc.on('close', (exitCode) => {
-					if (exitCode !== 0 && !allowNonZeroExit) {
-						const msg = (stderr || stdout || `Command failed: ${cmd}`).trim();
+					if (timeoutId) clearTimeout(timeoutId);
+
+					if (didTimeout) {
+						reject(new Error(`Command timed out after ${timeout}ms: ${cmd}`));
+					} else if (exitCode !== 0 && !allowNonZeroExit) {
+						const errorMsg =
+							stderr.trim() ||
+							stdout.trim() ||
+							`Command failed with exit code ${exitCode}`;
+						const msg = `${errorMsg}\n\nCommand: ${cmd}\nExit code: ${exitCode}`;
 						reject(new Error(msg));
 					} else {
 						resolve({ exitCode: exitCode ?? 0, stdout, stderr });
@@ -81,7 +107,12 @@ export function buildBashTool(projectRoot: string): {
 				});
 
 				proc.on('error', (err) => {
-					reject(err);
+					if (timeoutId) clearTimeout(timeoutId);
+					reject(
+						new Error(
+							`Command execution failed: ${err.message}\n\nCommand: ${cmd}`,
+						),
+					);
 				});
 			});
 		},

package/src/core/src/tools/builtin/glob.ts

@@ -0,0 +1,116 @@
+import { tool, type Tool } from 'ai';
+import { z } from 'zod';
+import fg from 'fast-glob';
+import { join } from 'node:path';
+import { stat } from 'node:fs/promises';
+import DESCRIPTION from './glob.txt' with { type: 'text' };
+import { defaultIgnoreGlobs } from './ignore.ts';
+
+function expandTilde(p: string) {
+	const home = process.env.HOME || process.env.USERPROFILE || '';
+	if (!home) return p;
+	if (p === '~') return home;
+	if (p.startsWith('~/')) return `${home}/${p.slice(2)}`;
+	return p;
+}
+
+export function buildGlobTool(projectRoot: string): {
+	name: string;
+	tool: Tool;
+} {
+	const globTool = tool({
+		description: DESCRIPTION,
+		inputSchema: z.object({
+			pattern: z
+				.string()
+				.min(1)
+				.describe(
+					'Glob pattern to match files (e.g., "*.ts", "**/*.tsx", "src/**/*.{js,ts}")',
+				),
+			path: z
+				.string()
+				.optional()
+				.describe('Directory to search in (default: project root)'),
+			ignore: z
+				.array(z.string())
+				.optional()
+				.describe('Additional glob patterns to exclude'),
+			limit: z
+				.number()
+				.int()
+				.min(1)
+				.max(1000)
+				.optional()
+				.default(100)
+				.describe('Maximum number of files to return'),
+		}),
+		async execute({
+			pattern,
+			path = '.',
+			ignore,
+			limit = 100,
+		}: {
+			pattern: string;
+			path?: string;
+			ignore?: string[];
+			limit?: number;
+		}) {
+			const p = expandTilde(String(path || '.')).trim();
+			const isAbs = p.startsWith('/') || /^[A-Za-z]:[\\/]/.test(p);
+			const searchPath = p ? (isAbs ? p : join(projectRoot, p)) : projectRoot;
+
+			// Build ignore patterns
+			const ignorePatterns = defaultIgnoreGlobs(ignore);
+
+			try {
+				// Use fast-glob to find matching files
+				const files = await fg(pattern, {
+					cwd: searchPath,
+					ignore: ignorePatterns,
+					onlyFiles: true,
+					absolute: false,
+					dot: false,
+				});
+
+				// Get file stats for sorting by modification time
+				const filesWithStats = await Promise.all(
+					files.map(async (file) => {
+						const fullPath = join(searchPath, file);
+						try {
+							const stats = await stat(fullPath);
+							return {
+								file,
+								mtime: stats.mtime.getTime(),
+							};
+						} catch {
+							return {
+								file,
+								mtime: 0,
+							};
+						}
+					}),
+				);
+
+				// Sort by modification time (most recent first) and limit
+				filesWithStats.sort((a, b) => b.mtime - a.mtime);
+				const limitedFiles = filesWithStats.slice(0, limit).map((f) => f.file);
+
+				return {
+					count: limitedFiles.length,
+					total: files.length,
+					files: limitedFiles,
+					truncated: files.length > limit,
+				};
+			} catch (error: unknown) {
+				const err = error as { message?: string };
+				return {
+					count: 0,
+					total: 0,
+					files: [],
+					error: `Glob search failed: ${err.message || String(error)}`,
+				};
+			}
+		},
+	});
+	return { name: 'glob', tool: globTool };
+}

package/src/core/src/tools/builtin/glob.txt

@@ -0,0 +1,10 @@
+- Find files matching glob patterns (e.g., "*.ts", "**/*.tsx", "src/**/*.{js,ts}")
+- Returns a list of matching file paths relative to the search directory
+- Supports standard glob syntax: * (any chars), ** (any dirs), {a,b} (alternatives), [abc] (character sets)
+- Automatically excludes common build/cache folders (node_modules, dist, .git, etc.)
+- Results sorted by modification time (most recent first)
+
+Usage tips:
+- Use this tool to find files by name or extension patterns
+- Use Grep or Ripgrep tools to search file contents
+- Combine with path parameter to search in specific directories only

package/src/core/src/tools/builtin/grep.ts

@@ -3,7 +3,6 @@ import { z } from 'zod';
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import { join } from 'node:path';
-import { stat } from 'node:fs/promises';
 import DESCRIPTION from './grep.txt' with { type: 'text' };
 import { defaultIgnoreGlobs } from './ignore.ts';
 
@@ -64,11 +63,7 @@ export function buildGrepTool(projectRoot: string): {
 			} catch (error: unknown) {
 				const err = error as { code?: number; stderr?: string };
 				if (err.code === 1) {
-					return {
-						title: pattern,
-						metadata: { matches: 0, truncated: false },
-						output: 'No files found',
-					};
+					return { count: 0, matches: [] };
 				}
 				const err2 = error as { stderr?: string; message?: string };
 				throw new Error(`ripgrep failed: ${err2.stderr || err2.message}`);
@@ -76,10 +71,9 @@ export function buildGrepTool(projectRoot: string): {
 
 			const lines = output.trim().split('\n');
 			const matches: Array<{
-				path: string;
-				modTime: number;
-				lineNum: number;
-				lineText: string;
+				file: string;
+				line: number;
+				text: string;
 			}> = [];
 
 			for (const line of lines) {
@@ -92,47 +86,16 @@ export function buildGrepTool(projectRoot: string): {
 				const lineText = line.slice(idx2 + 1);
 				const lineNum = parseInt(lineNumStr, 10);
 				if (!filePath || !Number.isFinite(lineNum)) continue;
-				const stats = await stat(filePath)
-					.then((s) => s.mtime.getTime())
-					.catch(() => 0);
-				matches.push({ path: filePath, modTime: stats, lineNum, lineText });
+				matches.push({ file: filePath, line: lineNum, text: lineText });
 			}
 
-			matches.sort((a, b) => b.modTime - a.modTime);
-
-			const limit = 100;
+			const limit = 500;
 			const truncated = matches.length > limit;
 			const finalMatches = truncated ? matches.slice(0, limit) : matches;
 
-			if (finalMatches.length === 0) {
-				return {
-					title: pattern,
-					metadata: { matches: 0, truncated: false },
-					output: 'No files found',
-				};
-			}
-
-			const outputLines = [`Found ${finalMatches.length} matches`];
-			let currentFile = '';
-			for (const match of finalMatches) {
-				if (currentFile !== match.path) {
-					if (currentFile !== '') outputLines.push('');
-					currentFile = match.path;
-					outputLines.push(`${match.path}:`);
-				}
-				outputLines.push(`  Line ${match.lineNum}: ${match.lineText}`);
-			}
-			if (truncated) {
-				outputLines.push('');
-				outputLines.push(
-					'(Results are truncated. Consider using a more specific path or pattern.)',
-				);
-			}
-
 			return {
-				title: pattern,
-				metadata: { matches: finalMatches.length, truncated },
-				output: outputLines.join('\n'),
+				count: finalMatches.length,
+				matches: finalMatches,
 			};
 		},
 	});

package/src/core/src/tools/builtin/patch.ts

@@ -70,16 +70,57 @@ async function applyEnvelopedPatch(projectRoot: string, patch: string) {
 				if (oldLines.length > 0) {
 					const oldText = oldLines.join('\n');
 					const newText = newLines.join('\n');
+
+					// Try exact match first
 					if (existingContent.includes(oldText)) {
 						newContent = existingContent.replace(oldText, newText);
 					} else {
-						// Can't find exact match, this is where enveloped format fails
-						// Provide more context about what couldn't be found
-						const preview = oldText.substring(0, 100);
-						return {
-							ok: false,
-							error: `Cannot find content to replace in ${currentFile}. Looking for: "${preview}${oldText.length > 100 ? '...' : ''}"`,
-						};
+						// Try normalizing whitespace for more flexible matching
+						const normalizeWhitespace = (s: string) =>
+							s.replace(/\s+/g, ' ').trim();
+						const normalizedOld = normalizeWhitespace(oldText);
+						const normalizedExisting = normalizeWhitespace(existingContent);
+
+						if (normalizedExisting.includes(normalizedOld)) {
+							// Find the actual text in the file by matching normalized version
+							const lines = existingContent.split('\n');
+							let found = false;
+
+							for (let i = 0; i < lines.length; i++) {
+								const candidate = lines
+									.slice(i, i + oldLines.length)
+									.join('\n');
+								if (normalizeWhitespace(candidate) === normalizedOld) {
+									// Replace this section
+									const before = lines.slice(0, i).join('\n');
+									const after = lines.slice(i + oldLines.length).join('\n');
+									newContent =
+										before +
+										(before ? '\n' : '') +
+										newText +
+										(after ? '\n' : '') +
+										after;
+									found = true;
+									break;
+								}
+							}
+
+							if (!found) {
+								const preview = oldText.substring(0, 100);
+								return {
+									ok: false,
+									error: `Cannot find exact location to replace in ${currentFile}. Looking for: "${preview}${oldText.length > 100 ? '...' : ''}"`,
+								};
+							}
+						} else {
+							// Can't find even with normalized whitespace
+							const preview = oldText.substring(0, 100);
+							const filePreview = existingContent.substring(0, 200);
+							return {
+								ok: false,
+								error: `Cannot find content to replace in ${currentFile}.\nLooking for: "${preview}${oldText.length > 100 ? '...' : ''}"\nFile contains: "${filePreview}${existingContent.length > 200 ? '...' : ''}"`,
+							};
+						}
 					}
 				} else if (newLines.length > 0) {
 					// Just appending new lines

package/src/core/src/tools/loader.ts

@@ -7,6 +7,7 @@ import { progressUpdateTool } from './builtin/progress.ts';
 import { buildBashTool } from './builtin/bash.ts';
 import { buildRipgrepTool } from './builtin/ripgrep.ts';
 import { buildGrepTool } from './builtin/grep.ts';
+import { buildGlobTool } from './builtin/glob.ts';
 import { buildApplyPatchTool } from './builtin/patch.ts';
 import { updatePlanTool } from './builtin/plan.ts';
 import { editTool } from './builtin/edit.ts';
@@ -107,6 +108,8 @@ export async function discoverProjectTools(
 	tools.set(rg.name, rg.tool);
 	const grep = buildGrepTool(projectRoot);
 	tools.set(grep.name, grep.tool);
+	const glob = buildGlobTool(projectRoot);
+	tools.set(glob.name, glob.tool);
 	// Patch/apply
 	const ap = buildApplyPatchTool(projectRoot);
 	tools.set(ap.name, ap.tool);