@agi-cli/sdk 0.1.49 → 0.1.51

package/src/tools/builtin/git.ts

@@ -1,112 +0,0 @@
-import { tool, type Tool } from 'ai';
-import { z } from 'zod';
-import { $ } from 'bun';
-import GIT_STATUS_DESCRIPTION from './git.status.txt' with { type: 'text' };
-import GIT_DIFF_DESCRIPTION from './git.diff.txt' with { type: 'text' };
-import GIT_COMMIT_DESCRIPTION from './git.commit.txt' with { type: 'text' };
-
-export function buildGitTools(
-	projectRoot: string,
-): Array<{ name: string; tool: Tool }> {
-	// Helper to find git root directory
-	async function findGitRoot(): Promise<string> {
-		try {
-			const res = await $`git -C ${projectRoot} rev-parse --show-toplevel`
-				.quiet()
-				.text()
-				.catch(() => '');
-			return res.trim() || projectRoot;
-		} catch {
-			return projectRoot;
-		}
-	}
-
-	async function inRepo(): Promise<boolean> {
-		const res = await $`git -C ${projectRoot} rev-parse --is-inside-work-tree`
-			.quiet()
-			.text()
-			.catch(() => '');
-		return res.trim() === 'true';
-	}
-
-	const git_status = tool({
-		description: GIT_STATUS_DESCRIPTION,
-		inputSchema: z.object({}).optional(),
-		async execute() {
-			if (!(await inRepo())) throw new Error('Not a git repository');
-			const gitRoot = await findGitRoot();
-			const out = await $`git -C ${gitRoot} status --porcelain=v1`.text();
-			const lines = out.split('\n').filter(Boolean);
-			let staged = 0;
-			let unstaged = 0;
-			for (const line of lines) {
-				const x = line[0];
-				const y = line[1];
-				if (!x || !y) continue;
-				if (x === '!' && y === '!') continue; // ignored files
-				const isUntracked = x === '?' && y === '?';
-				if (x !== ' ' && !isUntracked) staged += 1;
-				if (isUntracked || y !== ' ') unstaged += 1;
-			}
-			return {
-				staged,
-				unstaged,
-				raw: lines.slice(0, 200),
-			};
-		},
-	});
-
-	const git_diff = tool({
-		description: GIT_DIFF_DESCRIPTION,
-		inputSchema: z.object({ all: z.boolean().optional().default(false) }),
-		async execute({ all }: { all?: boolean }) {
-			if (!(await inRepo())) throw new Error('Not a git repository');
-			const gitRoot = await findGitRoot();
-			// When all=true, show full working tree diff relative to HEAD
-			// so both staged and unstaged changes are included. Otherwise,
-			// show only the staged diff (index vs HEAD).
-			const args = all ? ['diff', 'HEAD'] : ['diff', '--staged'];
-			const out = await $`git -C ${gitRoot} ${args}`.text();
-			const limited = out.split('\n').slice(0, 5000).join('\n');
-			return { all: !!all, patch: limited };
-		},
-	});
-
-	const git_commit = tool({
-		description: GIT_COMMIT_DESCRIPTION,
-		inputSchema: z.object({
-			message: z.string().min(5),
-			amend: z.boolean().optional().default(false),
-			signoff: z.boolean().optional().default(false),
-		}),
-		async execute({
-			message,
-			amend,
-			signoff,
-		}: {
-			message: string;
-			amend?: boolean;
-			signoff?: boolean;
-		}) {
-			if (!(await inRepo())) throw new Error('Not a git repository');
-			const gitRoot = await findGitRoot();
-			const args = ['commit', '-m', message];
-			if (amend) args.push('--amend');
-			if (signoff) args.push('--signoff');
-			const res = await $`git -C ${gitRoot} ${args}`
-				.quiet()
-				.text()
-				.catch(async (e) => {
-					const txt = typeof e?.stderr === 'string' ? e.stderr : String(e);
-					throw new Error(txt || 'git commit failed');
-				});
-			return { result: res.trim() };
-		},
-	});
-
-	return [
-		{ name: 'git_status', tool: git_status },
-		{ name: 'git_diff', tool: git_diff },
-		{ name: 'git_commit', tool: git_commit },
-	];
-}

package/src/tools/builtin/glob.ts

@@ -1,82 +0,0 @@
-import { tool, type Tool } from 'ai';
-import { z } from 'zod';
-import { $ } from 'bun';
-import { join, isAbsolute, resolve } from 'node:path';
-import DESCRIPTION from './glob.txt' with { type: 'text' };
-import { defaultIgnoreGlobs } from './ignore.ts';
-
-// description imported above
-
-export function buildGlobTool(projectRoot: string): {
-	name: string;
-	tool: Tool;
-} {
-	const glob = tool({
-		description: DESCRIPTION,
-		inputSchema: z.object({
-			pattern: z
-				.string()
-				.describe('Glob pattern to match files (e.g., "**/*.ts")'),
-			path: z
-				.string()
-				.optional()
-				.describe('Directory to search in. Defaults to the project root.'),
-			ignore: z
-				.array(z.string())
-				.optional()
-				.describe('Glob patterns to exclude from results'),
-		}),
-		async execute(params) {
-			const limit = 100;
-			const search = params.path
-				? isAbsolute(params.path)
-					? params.path
-					: join(projectRoot, params.path)
-				: projectRoot;
-			const args = ['--files', '--color', 'never', '-g', params.pattern];
-			for (const g of defaultIgnoreGlobs(params.ignore)) {
-				args.push('-g', g);
-			}
-			const { exitCode, stdout, stderr } = await $`rg ${args}`
-				.cwd(search)
-				.nothrow();
-			if (exitCode !== 0) {
-				const msg = (stderr || stdout || 'rg failed').toString().trim();
-				throw new Error(`glob failed: ${msg}`);
-			}
-			const lines = stdout.split('\n').filter(Boolean);
-			const items: Array<{ path: string; mtime: number }> = [];
-			let truncated = false;
-			for (const rel of lines) {
-				if (items.length >= limit) {
-					truncated = true;
-					break;
-				}
-				const full = resolve(search, rel);
-				const mtime = await Bun.file(full)
-					.stat()
-					.then((s) => s.mtime.getTime())
-					.catch(() => 0);
-				items.push({ path: full, mtime });
-			}
-			items.sort((a, b) => b.mtime - a.mtime);
-			const output: string[] = [];
-			if (items.length === 0) output.push('No files found');
-			else {
-				output.push(...items.map((i) => i.path));
-				if (truncated) {
-					output.push('');
-					output.push(
-						'(Results are truncated. Consider using a more specific path or pattern.)',
-					);
-				}
-			}
-			return {
-				title: isAbsolute(search) ? search : join(projectRoot, search),
-				metadata: { count: items.length, truncated },
-				output: output.join('\n'),
-			};
-		},
-	});
-	return { name: 'glob', tool: glob };
-}

package/src/tools/builtin/glob.txt

@@ -1,8 +0,0 @@
-- Fast file pattern matching powered by ripgrep (rg)
-- Supports glob patterns like "**/*.js" or "src/**/*.ts"
-- Returns absolute file paths sorted by modification time
-- Skips common build and cache folders by default; add 'ignore' patterns to refine
-
-Usage tips:
-- Use the Grep tool for content searches
-- Omit 'path' to search from the project root; set a subdirectory to narrow results

package/src/tools/builtin/grep.ts

@@ -1,138 +0,0 @@
-import { tool, type Tool } from 'ai';
-import { z } from 'zod';
-import { join } from 'node:path';
-import DESCRIPTION from './grep.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 buildGrepTool(projectRoot: string): {
-	name: string;
-	tool: Tool;
-} {
-	const grep = tool({
-		description: DESCRIPTION,
-		inputSchema: z.object({
-			pattern: z
-				.string()
-				.describe('Regex pattern to search for in file contents'),
-			path: z
-				.string()
-				.optional()
-				.describe('Directory to search in (default: project root).'),
-			include: z
-				.string()
-				.optional()
-				.describe('File glob to include (e.g., "*.js", "*.{ts,tsx}")'),
-			ignore: z
-				.array(z.string())
-				.optional()
-				.describe('Glob patterns to exclude from search'),
-		}),
-		async execute(params) {
-			const pattern = String(params.pattern || '');
-			if (!pattern) throw new Error('pattern is required');
-
-			const p = expandTilde(String(params.path || '')).trim();
-			const isAbs = p.startsWith('/') || /^[A-Za-z]:[\\/]/.test(p);
-			const searchPath = p ? (isAbs ? p : join(projectRoot, p)) : projectRoot;
-
-			const rgPath = 'rg';
-			const args: string[] = ['-n', '--color', 'never'];
-			for (const g of defaultIgnoreGlobs(params.ignore)) args.push('--glob', g);
-			if (params.include) {
-				args.push('--glob', params.include);
-			}
-			args.push(pattern, searchPath);
-
-			const proc = Bun.spawn([rgPath, ...args], {
-				stdout: 'pipe',
-				stderr: 'pipe',
-			});
-
-			const output = await new Response(proc.stdout).text();
-			const errorOutput = await new Response(proc.stderr).text();
-			const exitCode = await proc.exited;
-
-			if (exitCode === 1) {
-				return {
-					title: pattern,
-					metadata: { matches: 0, truncated: false },
-					output: 'No files found',
-				};
-			}
-			if (exitCode !== 0) {
-				throw new Error(`ripgrep failed: ${errorOutput}`);
-			}
-
-			const lines = output.trim().split('\n');
-			const matches: Array<{
-				path: string;
-				modTime: number;
-				lineNum: number;
-				lineText: string;
-			}> = [];
-
-			for (const line of lines) {
-				if (!line) continue;
-				const idx1 = line.indexOf(':');
-				const idx2 = idx1 === -1 ? -1 : line.indexOf(':', idx1 + 1);
-				if (idx1 === -1 || idx2 === -1) continue;
-				const filePath = line.slice(0, idx1);
-				const lineNumStr = line.slice(idx1 + 1, idx2);
-				const lineText = line.slice(idx2 + 1);
-				const lineNum = parseInt(lineNumStr, 10);
-				if (!filePath || !Number.isFinite(lineNum)) continue;
-				const stats = await Bun.file(filePath)
-					.stat()
-					.then((s) => s.mtime.getTime())
-					.catch(() => 0);
-				matches.push({ path: filePath, modTime: stats, lineNum, lineText });
-			}
-
-			matches.sort((a, b) => b.modTime - a.modTime);
-
-			const limit = 100;
-			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'),
-			};
-		},
-	});
-	return { name: 'grep', tool: grep };
-}

package/src/tools/builtin/grep.txt

@@ -1,9 +0,0 @@
-- Fast content search tool powered by ripgrep (rg)
-- Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
-- Optional include glob to filter files (e.g., "*.js", "*.{ts,tsx}")
-- Returns files with at least one match and line previews, sorted by modification time
-- Skips common build and cache folders by default; add 'ignore' patterns to refine
-
-Usage tips:
-- For counting matches, use the Bash tool with rg directly (do not use grep)
-- Batch multiple searches when exploring a codebase broadly

package/src/tools/builtin/ignore.ts

@@ -1,45 +0,0 @@
-export const IGNORE_PATTERNS: string[] = [
-	'node_modules/',
-	'__pycache__/',
-	'.git/',
-	'dist/',
-	'build/',
-	'target/',
-	'vendor/',
-	'bin/',
-	'obj/',
-	'.idea/',
-	'.vscode/',
-	'.zig-cache/',
-	'zig-out',
-	'.coverage',
-	'coverage/',
-	'vendor/',
-	'tmp/',
-	'temp/',
-	'.cache/',
-	'cache/',
-	'logs/',
-	'.venv/',
-	'venv/',
-	'env/',
-];
-
-export function defaultIgnoreGlobs(extra?: string[]): string[] {
-	const base = IGNORE_PATTERNS.map((p) => `!${p}*`);
-	if (Array.isArray(extra) && extra.length) return base.concat(extra);
-	return base;
-}
-
-export function toIgnoredBasenames(extra?: string[]): Set<string> {
-	const names = new Set<string>();
-	for (const p of IGNORE_PATTERNS) {
-		const n = p.replace(/\/$/, '');
-		if (n) names.add(n);
-	}
-	for (const p of extra ?? []) {
-		const n = String(p).replace(/^!/, '').replace(/\/$/, '');
-		if (n) names.add(n);
-	}
-	return names;
-}

package/src/tools/builtin/patch.ts

@@ -1,273 +0,0 @@
-import { tool, type Tool } from 'ai';
-import { z } from 'zod';
-import { $ } from 'bun';
-import DESCRIPTION from './patch.txt' with { type: 'text' };
-
-/**
- * Apply enveloped patch by directly modifying files
- */
-async function applyEnvelopedPatch(projectRoot: string, patch: string) {
-	const lines = patch.split('\n');
-	let currentFile: string | null = null;
-	let operation: 'add' | 'update' | 'delete' | null = null;
-	let fileContent: string[] = [];
-
-	async function applyCurrentFile() {
-		if (!currentFile || !operation) return { ok: true };
-
-		const fullPath = `${projectRoot}/${currentFile}`;
-
-		if (operation === 'delete') {
-			try {
-				await Bun.write(fullPath, '');
-			} catch (e) {
-				return {
-					ok: false,
-					error: `Failed to delete ${currentFile}: ${e instanceof Error ? e.message : String(e)}`,
-				};
-			}
-		} else if (operation === 'add') {
-			// For add, only use lines starting with +
-			const newContent = fileContent
-				.filter((l) => l.startsWith('+'))
-				.map((l) => l.substring(1))
-				.join('\n');
-			try {
-				await Bun.write(fullPath, newContent);
-			} catch (e) {
-				return {
-					ok: false,
-					error: `Failed to create ${currentFile}: ${e instanceof Error ? e.message : String(e)}`,
-				};
-			}
-		} else if (operation === 'update') {
-			try {
-				// Read existing file
-				let existingContent = '';
-				try {
-					const file = Bun.file(fullPath);
-					existingContent = await file.text();
-				} catch {
-					// File doesn't exist yet
-				}
-
-				// Get the old content (lines starting with -)
-				const oldLines = fileContent
-					.filter((l) => l.startsWith('-'))
-					.map((l) => l.substring(1));
-
-				// Get the new content (lines starting with +)
-				const newLines = fileContent
-					.filter((l) => l.startsWith('+'))
-					.map((l) => l.substring(1));
-
-				// Simple replacement: if old content is empty, append
-				// Otherwise try to replace old with new
-				let newContent = existingContent;
-				if (oldLines.length > 0) {
-					const oldText = oldLines.join('\n');
-					const newText = newLines.join('\n');
-					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 ? '...' : ''}"`,
-						};
-					}
-				} else if (newLines.length > 0) {
-					// Just appending new lines
-					newContent =
-						existingContent +
-						(existingContent.endsWith('\n') ? '' : '\n') +
-						newLines.join('\n');
-				}
-
-				await Bun.write(fullPath, newContent);
-			} catch (e) {
-				return {
-					ok: false,
-					error: `Failed to update ${currentFile}: ${e instanceof Error ? e.message : String(e)}`,
-				};
-			}
-		}
-		return { ok: true };
-	}
-
-	for (const line of lines) {
-		if (line === '*** Begin Patch' || line === '*** End Patch') {
-			continue;
-		}
-
-		if (
-			line.startsWith('*** Add File:') ||
-			line.startsWith('*** Update File:') ||
-			line.startsWith('*** Delete File:')
-		) {
-			// Apply previous file if any
-			const result = await applyCurrentFile();
-			if (!result.ok) return result;
-
-			// Start new file
-			if (line.startsWith('*** Add File:')) {
-				currentFile = line.replace('*** Add File:', '').trim();
-				operation = 'add';
-			} else if (line.startsWith('*** Update File:')) {
-				currentFile = line.replace('*** Update File:', '').trim();
-				operation = 'update';
-			} else if (line.startsWith('*** Delete File:')) {
-				currentFile = line.replace('*** Delete File:', '').trim();
-				operation = 'delete';
-			}
-			fileContent = [];
-		} else if (
-			currentFile &&
-			(line.startsWith('+') || line.startsWith('-') || line.startsWith(' '))
-		) {
-			// Collect patch content lines
-			fileContent.push(line);
-		}
-	}
-
-	// Apply the last file
-	const result = await applyCurrentFile();
-	return result;
-}
-
-export function buildApplyPatchTool(projectRoot: string): {
-	name: string;
-	tool: Tool;
-} {
-	const applyPatch = tool({
-		description: DESCRIPTION,
-		inputSchema: z.object({
-			patch: z.string().min(1).describe('Unified diff patch content'),
-			allowRejects: z
-				.boolean()
-				.optional()
-				.default(false)
-				.describe(
-					'Allow hunks to be rejected without failing the whole operation',
-				),
-		}),
-		async execute({
-			patch,
-			allowRejects,
-		}: {
-			patch: string;
-			allowRejects?: boolean;
-		}) {
-			// Check if this is an enveloped patch format
-			const isEnveloped =
-				patch.includes('*** Begin Patch') ||
-				patch.includes('*** Add File:') ||
-				patch.includes('*** Update File:');
-
-			if (isEnveloped) {
-				// Handle enveloped patches directly
-				const result = await applyEnvelopedPatch(projectRoot, patch);
-				const summary = summarizePatch(patch);
-				if (result.ok) {
-					return {
-						ok: true,
-						output: 'Applied enveloped patch',
-						artifact: { kind: 'file_diff', patch, summary },
-					} as const;
-				} else {
-					return {
-						ok: false,
-						error: result.error || 'Failed to apply enveloped patch',
-						artifact: { kind: 'file_diff', patch, summary },
-					} as const;
-				}
-			}
-
-			// For unified diffs, use git apply as before
-			const dir = `${projectRoot}/.agi/tmp`;
-			try {
-				await $`mkdir -p ${dir}`;
-			} catch {}
-			const file = `${dir}/patch-${Date.now()}.diff`;
-			await Bun.write(file, patch);
-			const summary = summarizePatch(patch);
-			// Try -p1 first for canonical git-style patches (a/ b/ prefixes), then fall back to -p0.
-			const baseArgs = ['apply', '--whitespace=nowarn'];
-			const rejectArg = allowRejects ? ['--reject'] : [];
-			const tries: Array<string[]> = [
-				[...baseArgs, ...rejectArg, '-p1'],
-				[...baseArgs, ...rejectArg, '-p0'],
-			];
-			let lastError = '';
-			for (const args of tries) {
-				const cmd = ['git', '-C', projectRoot, ...args, file];
-				const proc = await $`${cmd}`.quiet().nothrow();
-				const out = await proc.text();
-				// Capture error output for later use
-				if (proc.exitCode !== 0) {
-					lastError = out || `git apply failed with exit code ${proc.exitCode}`;
-				}
-
-				// Check if the patch was actually applied by looking at git status
-				// Sometimes git apply returns non-zero but the patch is applied
-				if (proc.exitCode === 0 || proc.exitCode === 1) {
-					// Check if any files were actually modified
-					const statusProc = await $`git -C ${projectRoot} status --porcelain`
-						.quiet()
-						.nothrow();
-					const statusOut = await statusProc.text();
-					if (statusOut && statusOut.trim().length > 0) {
-						// Files were changed, so patch was likely applied
-						return {
-							ok: true,
-							output: out?.trim() ?? '',
-							artifact: { kind: 'file_diff', patch, summary },
-						} as const;
-					}
-				}
-				// Only continue trying if patch wasn't applied
-			}
-			// If both attempts fail with exit code, check if files were modified anyway
-			// Sometimes git apply exits with warnings but the patch is applied
-			const statusProc = await $`git -C ${projectRoot} status --porcelain`
-				.quiet()
-				.nothrow();
-			const statusOut = await statusProc.text();
-			if (statusOut && statusOut.trim().length > 0) {
-				// Files were changed, so patch was likely applied despite the exit code
-				return {
-					ok: true,
-					output: 'Patch applied with warnings',
-					artifact: { kind: 'file_diff', patch, summary },
-				} as const;
-			}
-
-			// If both attempts fail and no files changed, return error with more context
-			const errorDetails = lastError.includes('patch does not apply')
-				? 'The patch cannot be applied because the target content has changed or does not match. The file may have been modified since the patch was created.'
-				: lastError ||
-					'git apply failed (tried -p1 and -p0) — ensure paths match project root';
-			return {
-				ok: false,
-				error: errorDetails,
-				artifact: { kind: 'file_diff', patch, summary },
-			} as const;
-		},
-	});
-	return { name: 'apply_patch', tool: applyPatch };
-}
-
-function summarizePatch(patch: string) {
-	const lines = String(patch || '').split('\n');
-	let files = 0;
-	let additions = 0;
-	let deletions = 0;
-	for (const l of lines) {
-		if (/^\*\*\*\s+(Add|Update|Delete) File:/.test(l)) files += 1;
-		else if (l.startsWith('+') && !l.startsWith('+++')) additions += 1;
-		else if (l.startsWith('-') && !l.startsWith('---')) deletions += 1;
-	}
-	return { files, additions, deletions };
-}

package/src/tools/builtin/patch.txt

@@ -1,7 +0,0 @@
-- Apply a unified diff patch (`*** Begin Patch`/`*** Update File`/`---`/`+++`/`@@`)
-- Uses `git apply` under the hood; tries `-p1` then `-p0`
-- Returns an artifact summary and any output from `git apply`
-
-Usage tips:
-- Ensure paths in the patch match the project root (prefer `a/` and `b/` prefixes)
-- For small edits, consider the Edit or Write tools instead