@agi-cli/sdk 0.1.53 → 0.1.55

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

@@ -0,0 +1,102 @@
+import { tool, type Tool } from 'ai';
+import { z } from 'zod';
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import DESCRIPTION from './ripgrep.txt' with { type: 'text' };
+
+export function buildRipgrepTool(projectRoot: string): {
+	name: string;
+	tool: Tool;
+} {
+	const rg = tool({
+		description: DESCRIPTION,
+		inputSchema: z.object({
+			query: z.string().min(1).describe('Search pattern (regex by default)'),
+			path: z
+				.string()
+				.optional()
+				.default('.')
+				.describe('Relative path to search in'),
+			ignoreCase: z.boolean().optional().default(false),
+			glob: z
+				.array(z.string())
+				.optional()
+				.describe('One or more glob patterns to include'),
+			maxResults: z.number().int().min(1).max(5000).optional().default(500),
+		}),
+		async execute({
+			query,
+			path = '.',
+			ignoreCase,
+			glob,
+			maxResults = 500,
+		}: {
+			query: string;
+			path?: string;
+			ignoreCase?: boolean;
+			glob?: string[];
+			maxResults?: number;
+		}) {
+			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;
+			}
+			const p = expandTilde(String(path ?? '.')).trim();
+			const isAbs = p.startsWith('/') || /^[A-Za-z]:[\\/]/.test(p);
+			const target = p ? (isAbs ? p : join(projectRoot, p)) : projectRoot;
+			const args = ['--no-heading', '--line-number', '--color=never'];
+			if (ignoreCase) args.push('-i');
+			if (Array.isArray(glob)) for (const g of glob) args.push('-g', g);
+			args.push('--max-count', String(maxResults));
+			args.push(query);
+			args.push(target);
+
+			try {
+				return await new Promise((resolve) => {
+					const proc = spawn('rg', args, { cwd: projectRoot });
+					let stdout = '';
+					let stderr = '';
+
+					proc.stdout.on('data', (data) => {
+						stdout += data.toString();
+					});
+
+					proc.stderr.on('data', (data) => {
+						stderr += data.toString();
+					});
+
+					proc.on('close', (code) => {
+						if (code !== 0 && code !== 1) {
+							resolve({ count: 0, matches: [], error: stderr.trim() });
+							return;
+						}
+
+						const lines = stdout
+							.split('\n')
+							.filter(Boolean)
+							.slice(0, maxResults);
+						const matches = lines.map((l) => {
+							const parts = l.split(':');
+							if (parts.length < 3) return { file: '', line: 0, text: l };
+							const file = parts[0];
+							const line = Number.parseInt(parts[1], 10);
+							const text = parts.slice(2).join(':');
+							return { file, line, text };
+						});
+						resolve({ count: matches.length, matches });
+					});
+
+					proc.on('error', (err) => {
+						resolve({ count: 0, matches: [], error: String(err) });
+					});
+				});
+			} catch (err) {
+				return { count: 0, matches: [], error: String(err) };
+			}
+		},
+	});
+	return { name: 'ripgrep', tool: rg };
+}

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

@@ -0,0 +1,7 @@
+- Search files using ripgrep (rg) with regex patterns
+- Returns a flat list of matches with `file`, `line`, and `text`
+- Supports include globs and case-insensitive search
+
+Usage tips:
+- Use the Grep tool for a friendly summary grouped by file
+- Use the Glob tool first to limit the search set if needed

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

@@ -0,0 +1,219 @@
+import { tool, type Tool } from 'ai';
+import { z } from 'zod';
+import DESCRIPTION from './websearch.txt' with { type: 'text' };
+
+export function buildWebSearchTool(): {
+	name: string;
+	tool: Tool;
+} {
+	const websearch = tool({
+		description: DESCRIPTION,
+		inputSchema: z
+			.object({
+				url: z
+					.string()
+					.optional()
+					.describe(
+						'URL to fetch content from (mutually exclusive with query)',
+					),
+				query: z
+					.string()
+					.optional()
+					.describe(
+						'Search query to search the web (mutually exclusive with url)',
+					),
+				maxLength: z
+					.number()
+					.optional()
+					.default(50000)
+					.describe(
+						'Maximum content length to return (default: 50000 characters)',
+					),
+			})
+			.strict()
+			.refine((data) => (data.url ? !data.query : !!data.query), {
+				message: 'Must provide either url or query, but not both',
+			}),
+		async execute({
+			url,
+			query,
+			maxLength,
+		}: {
+			url?: string;
+			query?: string;
+			maxLength?: number;
+		}) {
+			const maxLen = maxLength ?? 50000;
+
+			if (url) {
+				// Fetch URL content
+				try {
+					const response = await fetch(url, {
+						headers: {
+							'User-Agent':
+								'Mozilla/5.0 (compatible; AGI-Bot/1.0; +https://github.com/anthropics/agi)',
+							Accept:
+								'text/html,application/xhtml+xml,application/xml;q=0.9,text/plain;q=0.8,*/*;q=0.7',
+						},
+						redirect: 'follow',
+						signal: AbortSignal.timeout(30000), // 30 second timeout
+					});
+
+					if (!response.ok) {
+						throw new Error(
+							`HTTP error! status: ${response.status} ${response.statusText}`,
+						);
+					}
+
+					const contentType = response.headers.get('content-type') || '';
+					let content = '';
+
+					if (
+						contentType.includes('text/') ||
+						contentType.includes('application/json') ||
+						contentType.includes('application/xml') ||
+						contentType.includes('application/xhtml')
+					) {
+						content = await response.text();
+					} else {
+						return {
+							error: `Unsupported content type: ${contentType}. Only text-based content can be fetched.`,
+						};
+					}
+
+					// Strip HTML tags for better readability (basic cleaning)
+					const cleanContent = content
+						.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+						.replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '')
+						.replace(/<[^>]+>/g, ' ')
+						.replace(/\s+/g, ' ')
+						.trim();
+
+					const truncated = cleanContent.slice(0, maxLen);
+					const wasTruncated = cleanContent.length > maxLen;
+
+					return {
+						url,
+						content: truncated,
+						contentLength: cleanContent.length,
+						truncated: wasTruncated,
+						contentType,
+					};
+				} catch (error) {
+					const errorMessage =
+						error instanceof Error ? error.message : String(error);
+					return {
+						error: `Failed to fetch URL: ${errorMessage}`,
+					};
+				}
+			}
+
+			if (query) {
+				// Web search functionality
+				// Use DuckDuckGo's HTML search (doesn't require API key)
+				try {
+					const searchUrl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+					const response = await fetch(searchUrl, {
+						headers: {
+							'User-Agent':
+								'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+							Accept: 'text/html',
+						},
+						redirect: 'follow',
+						signal: AbortSignal.timeout(30000),
+					});
+
+					if (!response.ok) {
+						throw new Error(`Search failed: ${response.status}`);
+					}
+
+					const html = await response.text();
+
+					// Parse DuckDuckGo results (basic parsing)
+					const results: Array<{
+						title: string;
+						url: string;
+						snippet: string;
+					}> = [];
+
+					// Match result blocks
+					const resultPattern =
+						/<a[^>]+class="result__a"[^>]+href="([^"]+)"[^>]*>([^<]+)<\/a>[\s\S]*?<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
+
+					let match: RegExpExecArray | null = null;
+					match = resultPattern.exec(html);
+					while (match !== null && results.length < 10) {
+						const url = match[1]?.trim();
+						const title = match[2]?.trim();
+						let snippet = match[3]?.trim();
+
+						if (url && title) {
+							// Clean snippet
+							snippet = snippet
+								?.replace(/<[^>]+>/g, '')
+								.replace(/\s+/g, ' ')
+								.trim();
+
+							results.push({
+								title,
+								url,
+								snippet: snippet || '',
+							});
+						}
+						match = resultPattern.exec(html);
+					}
+
+					// Fallback: simpler pattern if the above doesn't work
+					if (results.length === 0) {
+						const simplePattern =
+							/<a[^>]+rel="nofollow"[^>]+href="([^"]+)"[^>]*>([^<]+)<\/a>/gi;
+						match = simplePattern.exec(html);
+						while (match !== null && results.length < 10) {
+							const url = match[1]?.trim();
+							const title = match[2]?.trim();
+							if (url && title && url.startsWith('http')) {
+								results.push({
+									title,
+									url,
+									snippet: '',
+								});
+							}
+							match = simplePattern.exec(html);
+						}
+					}
+
+					if (results.length === 0) {
+						return {
+							error:
+								'No search results found. The search service may have changed its format or blocked the request.',
+							query,
+							suggestion:
+								'Try using the url parameter to fetch a specific webpage instead.',
+						};
+					}
+
+					return {
+						query,
+						results,
+						count: results.length,
+					};
+				} catch (error) {
+					const errorMessage =
+						error instanceof Error ? error.message : String(error);
+					return {
+						error: `Search failed: ${errorMessage}`,
+						query,
+						suggestion:
+							'Search services may be temporarily unavailable. Try using the url parameter to fetch a specific webpage instead.',
+					};
+				}
+			}
+
+			return {
+				error: 'Must provide either url or query parameter',
+			};
+		},
+	});
+
+	return { name: 'websearch', tool: websearch };
+}

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

@@ -0,0 +1,12 @@
+- Search the web or fetch content from URLs
+- Use `query` to search the web and get a list of results with titles, URLs, and snippets
+- Use `url` to fetch and read the content of a specific webpage
+- Returns cleaned, text-based content (HTML tags are stripped)
+- Cannot be used for both search and URL fetch in the same call
+
+Usage tips:
+- For research: use `query` to find relevant pages, then `url` to read specific ones
+- Search returns up to 10 results with titles, URLs, and snippets
+- URL fetching works for text-based content (HTML, JSON, XML, plain text)
+- Content is automatically truncated if it exceeds maxLength (default 50,000 chars)
+- Use this to gather current information, read documentation, or verify facts