@agi-cli/sdk 0.1.42 → 0.1.43

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/sdk",
-	"version": "0.1.42",
+	"version": "0.1.43",
 	"description": "AI agent SDK for building intelligent assistants",
 	"author": "ntishxyz",
 	"license": "MIT",

package/src/tools/builtin/git.ts

@@ -8,6 +8,19 @@ 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()
@@ -21,7 +34,8 @@ export function buildGitTools(
 		inputSchema: z.object({}).optional(),
 		async execute() {
 			if (!(await inRepo())) throw new Error('Not a git repository');
-			const out = await $`git -C ${projectRoot} status --porcelain=v1`.text();
+			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;
@@ -47,11 +61,12 @@ export function buildGitTools(
 		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 ${projectRoot} ${args}`.text();
+			const out = await $`git -C ${gitRoot} ${args}`.text();
 			const limited = out.split('\n').slice(0, 5000).join('\n');
 			return { all: !!all, patch: limited };
 		},
@@ -74,10 +89,11 @@ export function buildGitTools(
 			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 ${projectRoot} ${args}`
+			const res = await $`git -C ${gitRoot} ${args}`
 				.quiet()
 				.text()
 				.catch(async (e) => {

package/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/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

package/src/tools/loader.ts

@@ -11,6 +11,7 @@ import { buildGlobTool } from './builtin/glob.ts';
 import { buildApplyPatchTool } from './builtin/patch.ts';
 import { updatePlanTool } from './builtin/plan.ts';
 import { editTool } from './builtin/edit.ts';
+import { buildWebSearchTool } from './builtin/websearch.ts';
 import { Glob } from 'bun';
 import { dirname, isAbsolute, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -115,6 +116,9 @@ export async function discoverProjectTools(
 	tools.set('update_plan', updatePlanTool);
 	// Edit
 	tools.set('edit', editTool);
+	// Web search
+	const ws = buildWebSearchTool();
+	tools.set(ws.name, ws.tool);
 
 	async function loadFromBase(base: string | null | undefined) {
 		if (!base) return;