@agi-cli/sdk 0.1.156 → 0.1.158

package/package.json

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

package/src/core/src/terminals/manager.ts

@@ -3,6 +3,7 @@ import type { PtyOptions } from './bun-pty.ts';
 import { spawn as spawnPty } from './bun-pty.ts';
 import { Terminal } from './terminal.ts';
 import { logger } from '../utils/logger.ts';
+import { getAugmentedPath } from '../tools/bin-manager.ts';
 
 const MAX_TERMINALS = 10;
 const CLEANUP_DELAY_MS = 5 * 60 * 1000;
@@ -41,7 +42,10 @@ export class TerminalManager {
 				cols: 80,
 				rows: 30,
 				cwd: options.cwd,
-				env: process.env as Record<string, string>,
+				env: { ...process.env, PATH: getAugmentedPath() } as Record<
+					string,
+					string
+				>,
 			};
 
 			const pty = spawnPty(options.command, options.args || [], ptyOptions);

package/src/core/src/tools/bin-manager.ts

@@ -0,0 +1,197 @@
+import { join } from 'node:path';
+import { promises as fs } from 'node:fs';
+import { spawn } from 'node:child_process';
+
+const AGI_BIN_DIR_NAME = 'bin';
+
+let cachedBinDir: string | null = null;
+const resolvedPaths = new Map<string, string>();
+
+function getConfigHome(): string {
+	const cfgHome = process.env.XDG_CONFIG_HOME;
+	if (cfgHome?.trim()) return cfgHome.replace(/\\/g, '/');
+	const home = process.env.HOME || process.env.USERPROFILE || '';
+	return join(home, '.config');
+}
+
+export function getAgiBinDir(): string {
+	if (cachedBinDir) return cachedBinDir;
+	cachedBinDir = join(getConfigHome(), 'agi', AGI_BIN_DIR_NAME);
+	return cachedBinDir;
+}
+
+function getPlatformKey(): string {
+	const platform = process.platform;
+	const arch = process.arch;
+	const os =
+		platform === 'darwin'
+			? 'darwin'
+			: platform === 'win32'
+				? 'windows'
+				: 'linux';
+	const cpu = arch === 'arm64' ? 'arm64' : 'x64';
+	return `${os}-${cpu}`;
+}
+
+function getBinaryFileName(name: string): string {
+	if (process.platform === 'win32') return `${name}.exe`;
+	return name;
+}
+
+async function ensureDir(dir: string): Promise<void> {
+	await fs.mkdir(dir, { recursive: true });
+}
+
+async function fileExists(p: string): Promise<boolean> {
+	try {
+		await fs.access(p);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function isExecutable(p: string): Promise<boolean> {
+	try {
+		await fs.access(p, 0o1);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function makeExecutable(p: string): Promise<void> {
+	if (process.platform === 'win32') return;
+	try {
+		await fs.chmod(p, 0o755);
+	} catch {}
+}
+
+async function whichBinary(name: string): Promise<string | null> {
+	const cmd = process.platform === 'win32' ? 'where' : 'which';
+	return new Promise((resolve) => {
+		const proc = spawn(cmd, [name], { stdio: ['ignore', 'pipe', 'ignore'] });
+		let stdout = '';
+		proc.stdout.on('data', (d) => {
+			stdout += d.toString();
+		});
+		proc.on('close', (code) => {
+			if (code === 0 && stdout.trim()) resolve(stdout.trim().split('\n')[0]);
+			else resolve(null);
+		});
+		proc.on('error', () => resolve(null));
+	});
+}
+
+function getVendorSearchPaths(binaryName: string): string[] {
+	const platformKey = getPlatformKey();
+	const paths: string[] = [];
+
+	const tauriResource = process.env.TAURI_RESOURCE_DIR;
+	if (tauriResource) {
+		paths.push(join(tauriResource, 'vendor', 'bin', platformKey, binaryName));
+		paths.push(join(tauriResource, 'vendor', 'bin', binaryName));
+	}
+
+	try {
+		const exePath = process.execPath;
+		if (exePath) {
+			const exeDir = join(exePath, '..');
+			paths.push(join(exeDir, 'vendor', 'bin', platformKey, binaryName));
+			paths.push(
+				join(
+					exeDir,
+					'..',
+					'Resources',
+					'vendor',
+					'bin',
+					platformKey,
+					binaryName,
+				),
+			);
+		}
+	} catch {}
+
+	if (process.env.CARGO_MANIFEST_DIR) {
+		paths.push(
+			join(
+				process.env.CARGO_MANIFEST_DIR,
+				'resources',
+				'vendor',
+				'bin',
+				platformKey,
+				binaryName,
+			),
+		);
+	}
+
+	const cwd = process.cwd();
+	paths.push(join(cwd, 'vendor', 'bin', platformKey, binaryName));
+
+	return paths;
+}
+
+async function extractFromVendor(name: string): Promise<string | null> {
+	const binaryName = getBinaryFileName(name);
+	const binDir = getAgiBinDir();
+	const targetPath = join(binDir, binaryName);
+
+	if ((await fileExists(targetPath)) && (await isExecutable(targetPath))) {
+		return targetPath;
+	}
+
+	const searchPaths = getVendorSearchPaths(binaryName);
+
+	for (const src of searchPaths) {
+		if (await fileExists(src)) {
+			await ensureDir(binDir);
+			await fs.copyFile(src, targetPath);
+			await makeExecutable(targetPath);
+			return targetPath;
+		}
+	}
+
+	return null;
+}
+
+export async function resolveBinary(name: string): Promise<string> {
+	const cached = resolvedPaths.get(name);
+	if (cached) return cached;
+
+	const binaryName = getBinaryFileName(name);
+	const binDir = getAgiBinDir();
+	const installedPath = join(binDir, binaryName);
+	if (
+		(await fileExists(installedPath)) &&
+		(await isExecutable(installedPath))
+	) {
+		resolvedPaths.set(name, installedPath);
+		return installedPath;
+	}
+
+	const vendorPath = await extractFromVendor(name);
+	if (vendorPath) {
+		resolvedPaths.set(name, vendorPath);
+		return vendorPath;
+	}
+
+	const systemPath = await whichBinary(binaryName);
+	if (systemPath) {
+		resolvedPaths.set(name, systemPath);
+		return systemPath;
+	}
+
+	return binaryName;
+}
+
+export function clearBinaryCache(): void {
+	resolvedPaths.clear();
+}
+
+export function getAugmentedPath(): string {
+	const binDir = getAgiBinDir();
+	const current = process.env.PATH || '';
+	const commonPaths = ['/opt/homebrew/bin', '/usr/local/bin'];
+	const parts = [binDir, ...commonPaths, current];
+	return parts.join(process.platform === 'win32' ? ';' : ':');
+}

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

@@ -3,6 +3,7 @@ import { z } from 'zod/v3';
 import { spawn } from 'node:child_process';
 import DESCRIPTION from './bash.txt' with { type: 'text' };
 import { createToolError, type ToolResponse } from '../error.ts';
+import { getAugmentedPath } from '../bin-manager.ts';
 
 function normalizePath(p: string) {
 	const parts = p.replace(/\\/g, '/').split('/');
@@ -73,6 +74,7 @@ export function buildBashTool(projectRoot: string): {
 					cwd: absCwd,
 					shell: true,
 					stdio: ['ignore', 'pipe', 'pipe'],
+					env: { ...process.env, PATH: getAugmentedPath() },
 				});
 
 				let stdout = '';

package/src/core/src/tools/builtin/fs/ls.ts

@@ -1,16 +1,11 @@
 import { tool, type Tool } from 'ai';
 import { z } from 'zod/v3';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
+import { promises as fs } from 'node:fs';
 import { expandTilde, isAbsoluteLike, resolveSafePath } from './util.ts';
 import DESCRIPTION from './ls.txt' with { type: 'text' };
 import { toIgnoredBasenames } from '../ignore.ts';
 import { createToolError, type ToolResponse } from '../../error.ts';
 
-const execAsync = promisify(exec);
-
-// description imported above
-
 export function buildLsTool(projectRoot: string): { name: string; tool: Tool } {
 	const ls = tool({
 		description: DESCRIPTION,
@@ -45,32 +40,29 @@ export function buildLsTool(projectRoot: string): { name: string; tool: Tool } {
 			const ignored = toIgnoredBasenames(ignore);
 
 			try {
-				const { stdout } = await execAsync('ls -1p', {
-					cwd: abs,
-					maxBuffer: 10 * 1024 * 1024,
-				});
-				const entries = stdout
-					.split('\n')
-					.map((line) => line.trim())
-					.filter((line) => line.length > 0 && !line.startsWith('.'))
-					.map((line) => ({
-						name: line.replace(/\/$/, ''),
-						type: line.endsWith('/') ? 'dir' : 'file',
+				const dirents = await fs.readdir(abs, { withFileTypes: true });
+				const entries = dirents
+					.filter((d) => !String(d.name).startsWith('.'))
+					.map((d) => ({
+						name: String(d.name),
+						type: d.isDirectory() ? 'dir' : 'file',
 					}))
-					.filter(
-						(entry) => !(entry.type === 'dir' && ignored.has(entry.name)),
-					);
+					.filter((entry) => !(entry.type === 'dir' && ignored.has(entry.name)))
+					.sort((a, b) => a.name.localeCompare(b.name));
 				return { ok: true, path: req, entries };
 			} catch (error: unknown) {
-				const err = error as { stderr?: string; stdout?: string };
-				const message = (err.stderr || err.stdout || 'ls failed').trim();
+				const err = error as { code?: string; message?: string };
+				const message = err.message || 'ls failed';
 				return createToolError(
 					`ls failed for ${req}: ${message}`,
-					'execution',
+					err.code === 'ENOENT' ? 'not_found' : 'execution',
 					{
 						parameter: 'path',
 						value: req,
-						suggestion: 'Check if the directory exists and is accessible',
+						suggestion:
+							err.code === 'ENOENT'
+								? 'Check if the directory exists'
+								: 'Check if the directory exists and is accessible',
 					},
 				);
 			}

package/src/core/src/tools/builtin/fs/tree.ts

@@ -1,15 +1,72 @@
 import { tool, type Tool } from 'ai';
 import { z } from 'zod/v3';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
 import { expandTilde, isAbsoluteLike, resolveSafePath } from './util.ts';
 import DESCRIPTION from './tree.txt' with { type: 'text' };
 import { toIgnoredBasenames } from '../ignore.ts';
 import { createToolError, type ToolResponse } from '../../error.ts';
 
-const execAsync = promisify(exec);
+async function walkTree(
+	dir: string,
+	ignored: Set<string>,
+	maxDepth: number | null,
+	currentDepth: number,
+	prefix: string,
+): Promise<{ lines: string[]; dirs: number; files: number }> {
+	let dirs = 0;
+	let files = 0;
+	const lines: string[] = [];
 
-// description imported above
+	if (maxDepth !== null && currentDepth >= maxDepth)
+		return { lines, dirs, files };
+
+	try {
+		const rawEntries = await fs.readdir(dir, { withFileTypes: true });
+		const entries = rawEntries.map((e) => ({
+			name: String(e.name),
+			isDir: e.isDirectory(),
+		}));
+
+		const filtered = entries
+			.filter((e) => !e.name.startsWith('.'))
+			.filter((e) => !(e.isDir && ignored.has(e.name)))
+			.sort((a, b) => {
+				if (a.isDir && !b.isDir) return -1;
+				if (!a.isDir && b.isDir) return 1;
+				return a.name.localeCompare(b.name);
+			});
+
+		for (let i = 0; i < filtered.length; i++) {
+			const entry = filtered[i];
+			const isLast = i === filtered.length - 1;
+			const connector = isLast ? '└── ' : '├── ';
+			const childPrefix = isLast ? '    ' : '│   ';
+
+			if (entry.isDir) {
+				dirs++;
+				lines.push(`${prefix}${connector}${entry.name}`);
+				const sub = await walkTree(
+					join(dir, entry.name),
+					ignored,
+					maxDepth,
+					currentDepth + 1,
+					`${prefix}${childPrefix}`,
+				);
+				lines.push(...sub.lines);
+				dirs += sub.dirs;
+				files += sub.files;
+			} else {
+				files++;
+				lines.push(`${prefix}${connector}${entry.name}`);
+			}
+		}
+	} catch {
+		return { lines, dirs, files };
+	}
+
+	return { lines, dirs, files };
+}
 
 export function buildTreeTool(projectRoot: string): {
 	name: string;
@@ -48,32 +105,35 @@ export function buildTreeTool(projectRoot: string): {
 				: resolveSafePath(projectRoot, req || '.');
 			const ignored = toIgnoredBasenames(ignore);
 
-			let cmd = 'tree';
-			if (typeof depth === 'number') cmd += ` -L ${depth}`;
-			if (ignored.size) {
-				const pattern = Array.from(ignored).join('|');
-				cmd += ` -I '${pattern.replace(/'/g, "'\\''")}'`;
+			try {
+				await fs.access(start);
+			} catch {
+				return createToolError(
+					`tree failed for ${req}: directory not found`,
+					'not_found',
+					{
+						parameter: 'path',
+						value: req,
+						suggestion: 'Check if the directory exists',
+					},
+				);
 			}
-			cmd += ' .';
 
 			try {
-				const { stdout } = await execAsync(cmd, {
-					cwd: start,
-					maxBuffer: 10 * 1024 * 1024,
-				});
-				const output = stdout.trimEnd();
+				const result = await walkTree(start, ignored, depth ?? null, 0, '');
+				const header = '.';
+				const summary = `\n${result.dirs} director${result.dirs === 1 ? 'y' : 'ies'}, ${result.files} file${result.files === 1 ? '' : 's'}`;
+				const output = [header, ...result.lines, summary].join('\n');
 				return { ok: true, path: req, depth: depth ?? null, tree: output };
 			} catch (error: unknown) {
-				const err = error as { stderr?: string; stdout?: string };
-				const message = (err.stderr || err.stdout || 'tree failed').trim();
+				const err = error as { message?: string };
 				return createToolError(
-					`tree failed for ${req}: ${message}`,
+					`tree failed for ${req}: ${err.message || 'unknown error'}`,
 					'execution',
 					{
 						parameter: 'path',
 						value: req,
-						suggestion:
-							'Check if the directory exists and tree command is installed',
+						suggestion: 'Check if the directory exists and is accessible',
 					},
 				);
 			}

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

@@ -1,13 +1,11 @@
 import { tool, type Tool } from 'ai';
 import { z } from 'zod/v3';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
+import { spawn } from 'node:child_process';
 import { join } from 'node:path';
 import DESCRIPTION from './grep.txt' with { type: 'text' };
 import { defaultIgnoreGlobs } from './ignore.ts';
 import { createToolError, type ToolResponse } from '../error.ts';
-
-const execAsync = promisify(exec);
+import { resolveBinary } from '../bin-manager.ts';
 
 function expandTilde(p: string) {
 	const home = process.env.HOME || process.env.USERPROFILE || '';
@@ -63,35 +61,44 @@ export function buildGrepTool(projectRoot: string): {
 			const isAbs = p.startsWith('/') || /^[A-Za-z]:[\\/]/.test(p);
 			const searchPath = p ? (isAbs ? p : join(projectRoot, p)) : projectRoot;
 
-			let cmd = `rg -n --color never`;
+			const rgBin = await resolveBinary('rg');
+			const args: string[] = ['-n', '--color', 'never'];
 			for (const g of defaultIgnoreGlobs(params.ignore)) {
-				cmd += ` --glob "${g.replace(/"/g, '\\"')}"`;
+				args.push('--glob', g);
 			}
 			if (params.include) {
-				cmd += ` --glob "${params.include.replace(/"/g, '\\"')}"`;
+				args.push('--glob', params.include);
 			}
-			cmd += ` "${pattern.replace(/"/g, '\\"')}" "${searchPath}"`;
+			args.push(pattern, searchPath);
 
 			let output = '';
 			try {
-				const result = await execAsync(cmd, { maxBuffer: 10 * 1024 * 1024 });
-				output = result.stdout;
+				output = await new Promise<string>((resolve, reject) => {
+					const proc = spawn(rgBin, args, { cwd: projectRoot });
+					let stdout = '';
+					let stderr = '';
+					proc.stdout.on('data', (d) => {
+						stdout += d.toString();
+					});
+					proc.stderr.on('data', (d) => {
+						stderr += d.toString();
+					});
+					proc.on('close', (code) => {
+						if (code === 1) resolve('');
+						else if (code !== 0)
+							reject(new Error(stderr.trim() || 'ripgrep failed'));
+						else resolve(stdout);
+					});
+					proc.on('error', reject);
+				});
 			} catch (error: unknown) {
-				const err = error as { code?: number; stderr?: string };
-				if (err.code === 1) {
-					return { ok: true, count: 0, matches: [] };
-				}
-				const err2 = error as { stderr?: string; message?: string };
-				return createToolError(
-					`ripgrep failed: ${err2.stderr || err2.message}`,
-					'execution',
-					{
-						parameter: 'pattern',
-						value: pattern,
-						suggestion:
-							'Check if ripgrep (rg) is installed and the pattern is valid',
-					},
-				);
+				const err2 = error as { message?: string };
+				return createToolError(`ripgrep failed: ${err2.message}`, 'execution', {
+					parameter: 'pattern',
+					value: pattern,
+					suggestion:
+						'Check if ripgrep (rg) is installed and the pattern is valid',
+				});
 			}
 
 			const lines = output.trim().split('\n');

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

@@ -4,6 +4,7 @@ import { spawn } from 'node:child_process';
 import { join } from 'node:path';
 import DESCRIPTION from './ripgrep.txt' with { type: 'text' };
 import { createToolError, type ToolResponse } from '../error.ts';
+import { resolveBinary } from '../bin-manager.ts';
 
 export function buildRipgrepTool(projectRoot: string): {
 	name: string;
@@ -61,8 +62,9 @@ export function buildRipgrepTool(projectRoot: string): {
 			args.push(target);
 
 			try {
+				const rgBin = await resolveBinary('rg');
 				return await new Promise((resolve) => {
-					const proc = spawn('rg', args, { cwd: projectRoot });
+					const proc = spawn(rgBin, args, { cwd: projectRoot });
 					let stdout = '';
 					let stderr = '';
 

package/src/prompts/src/providers/anthropic.txt

@@ -3,8 +3,8 @@ You are an interactive CLI tool that helps users with software engineering tasks
 IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files.
 
 If the user asks for help or wants to give feedback inform them of the following:
-- /help: Get help with using opencode
-- To give feedback, users should report the issue at https://github.com/sst/opencode/issues
+- /help: Get help with using agi
+- To give feedback, users should report the issue at https://github.com/nitishxyz/agi/issues
 
 # Tone and style
 You should be concise, direct, and to the point.