@gguf/coder 0.3.0 → 0.3.1

package/source/tools/tool-registry.ts

@@ -0,0 +1,228 @@
+import type {
+	AISDKCoreTool,
+	ToolEntry,
+	ToolFormatter,
+	ToolHandler,
+	ToolValidator,
+} from '@/types/index';
+
+/**
+ * Helper class to encapsulate tool registry management
+ *
+ * This class provides structured access to tool metadata and eliminates
+ * the need to manage multiple separate registries manually.
+ *
+ * Benefits:
+ * - Single source of truth for all tool metadata
+ * - Type-safe access to tool components
+ * - Cleaner API for tool registration and lookup
+ * - Easier to extend with future metadata
+ */
+export class ToolRegistry {
+	private tools: Map<string, ToolEntry> = new Map();
+
+	/**
+	 * Register a complete tool entry
+	 * @param entry - The ToolEntry containing all tool metadata
+	 */
+	register(entry: ToolEntry): void {
+		this.tools.set(entry.name, entry);
+	}
+
+	/**
+	 * Register multiple tool entries at once
+	 * @param entries - Array of ToolEntry objects
+	 */
+	registerMany(entries: ToolEntry[]): void {
+		for (const entry of entries) {
+			this.register(entry);
+		}
+	}
+
+	/**
+	 * Unregister a tool by name
+	 * @param name - The tool name
+	 */
+	unregister(name: string): void {
+		this.tools.delete(name);
+	}
+
+	/**
+	 * Unregister multiple tools by name
+	 * @param names - Array of tool names
+	 */
+	unregisterMany(names: string[]): void {
+		for (const name of names) {
+			this.unregister(name);
+		}
+	}
+
+	/**
+	 * Get a complete tool entry by name
+	 * @param name - The tool name
+	 * @returns The ToolEntry or undefined if not found
+	 */
+	getEntry(name: string): ToolEntry | undefined {
+		return this.tools.get(name);
+	}
+
+	/**
+	 * Get a tool handler by name
+	 * @param name - The tool name
+	 * @returns The ToolHandler or undefined if not found
+	 */
+	getHandler(name: string): ToolHandler | undefined {
+		return this.tools.get(name)?.handler;
+	}
+
+	/**
+	 * Get a tool formatter by name
+	 * @param name - The tool name
+	 * @returns The ToolFormatter or undefined if not found
+	 */
+	getFormatter(name: string): ToolFormatter | undefined {
+		return this.tools.get(name)?.formatter;
+	}
+
+	/**
+	 * Get a tool validator by name
+	 * @param name - The tool name
+	 * @returns The ToolValidator or undefined if not found
+	 */
+	getValidator(name: string): ToolValidator | undefined {
+		return this.tools.get(name)?.validator;
+	}
+
+	/**
+	 * Get the native AI SDK tool by name
+	 * @param name - The tool name
+	 * @returns The AISDKCoreTool or undefined if not found
+	 */
+	getTool(name: string): AISDKCoreTool | undefined {
+		return this.tools.get(name)?.tool;
+	}
+
+	/**
+	 * Get all handler entries as a record (compatible with old API)
+	 * @returns Record mapping tool names to handlers
+	 */
+	getHandlers(): Record<string, ToolHandler> {
+		const handlers: Record<string, ToolHandler> = {};
+		for (const [name, entry] of this.tools) {
+			handlers[name] = entry.handler;
+		}
+		return handlers;
+	}
+
+	/**
+	 * Get all formatter entries as a record (compatible with old API)
+	 * @returns Record mapping tool names to formatters
+	 */
+	getFormatters(): Record<string, ToolFormatter> {
+		const formatters: Record<string, ToolFormatter> = {};
+		for (const [name, entry] of this.tools) {
+			if (entry.formatter) {
+				formatters[name] = entry.formatter;
+			}
+		}
+		return formatters;
+	}
+
+	/**
+	 * Get all validator entries as a record (compatible with old API)
+	 * @returns Record mapping tool names to validators
+	 */
+	getValidators(): Record<string, ToolValidator> {
+		const validators: Record<string, ToolValidator> = {};
+		for (const [name, entry] of this.tools) {
+			if (entry.validator) {
+				validators[name] = entry.validator;
+			}
+		}
+		return validators;
+	}
+
+	/**
+	 * Get all native AI SDK tools as a record (compatible with old API)
+	 * @returns Record mapping tool names to AISDKCoreTool objects
+	 */
+	getNativeTools(): Record<string, AISDKCoreTool> {
+		const nativeTools: Record<string, AISDKCoreTool> = {};
+		for (const [name, entry] of this.tools) {
+			nativeTools[name] = entry.tool;
+		}
+		return nativeTools;
+	}
+
+	/**
+	 * Get all tool entries
+	 * @returns Array of all ToolEntry objects
+	 */
+	getAllEntries(): ToolEntry[] {
+		return Array.from(this.tools.values());
+	}
+
+	/**
+	 * Get all tool names
+	 * @returns Array of all registered tool names
+	 */
+	getToolNames(): string[] {
+		return Array.from(this.tools.keys());
+	}
+
+	/**
+	 * Check if a tool is registered
+	 * @param name - The tool name
+	 * @returns True if the tool exists, false otherwise
+	 */
+	hasTool(name: string): boolean {
+		return this.tools.has(name);
+	}
+
+	/**
+	 * Get the number of registered tools
+	 * @returns The count of registered tools
+	 */
+	getToolCount(): number {
+		return this.tools.size;
+	}
+
+	/**
+	 * Clear all registered tools
+	 */
+	clear(): void {
+		this.tools.clear();
+	}
+
+	/**
+	 * Create a new registry from static registries (backward compatibility helper)
+	 * @param handlers - Record of tool handlers
+	 * @param tools - Record of native AI SDK tools
+	 * @param formatters - Optional record of tool formatters
+	 * @param validators - Optional record of tool validators
+	 * @returns New ToolRegistry instance
+	 */
+	static fromRegistries(
+		handlers: Record<string, ToolHandler>,
+		tools: Record<string, AISDKCoreTool>,
+		formatters?: Record<string, ToolFormatter>,
+		validators?: Record<string, ToolValidator>,
+	): ToolRegistry {
+		const registry = new ToolRegistry();
+
+		for (const [name, handler] of Object.entries(handlers)) {
+			const tool = tools[name];
+			if (tool) {
+				registry.register({
+					name,
+					handler,
+					tool,
+					formatter: formatters?.[name],
+					validator: validators?.[name],
+				});
+			}
+		}
+
+		return registry;
+	}
+}

package/source/tools/web-search.tsx

@@ -0,0 +1,223 @@
+import * as cheerio from 'cheerio';
+import { Box, Text } from 'ink';
+import React from 'react';
+import { fetch } from 'undici';
+
+import ToolMessage from '@/components/tool-message';
+import {
+	DEFAULT_WEB_SEARCH_RESULTS,
+	MAX_WEB_SEARCH_QUERY_LENGTH,
+	TIMEOUT_WEB_SEARCH_MS,
+	WEB_SEARCH_DISPLAY_RESULTS,
+} from '@/constants';
+import { ThemeContext } from '@/hooks/useTheme';
+import { jsonSchema, tool } from '@/types/core';
+import type { CoderToolExport } from '@/types/core';
+
+interface SearchArgs {
+	query: string;
+	max_results?: number;
+}
+
+interface SearchResult {
+	title: string;
+	url: string;
+	snippet: string;
+}
+
+const executeWebSearch = async (args: SearchArgs): Promise<string> => {
+	const maxResults = args.max_results ?? DEFAULT_WEB_SEARCH_RESULTS;
+	const encodedQuery = encodeURIComponent(args.query);
+
+	try {
+		// Use Brave Search - scraper-friendly, no CAPTCHA
+		const searchUrl = `https://search.brave.com/search?q=${encodedQuery}`;
+
+		const response = await fetch(searchUrl, {
+			headers: {
+				'User-Agent':
+					'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
+				Accept: 'text/html',
+			},
+			signal: AbortSignal.timeout(TIMEOUT_WEB_SEARCH_MS),
+		});
+
+		if (!response.ok) {
+			throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+		}
+
+		const html = await response.text();
+		const $ = cheerio.load(html);
+
+		const results: SearchResult[] = [];
+
+		// Brave Search uses specific result containers
+		$('[data-type="web"]').each((_i, elem) => {
+			if (results.length >= maxResults) return;
+
+			const $elem = $(elem);
+
+			// Extract title and URL
+			const titleLink = $elem.find('a[href^="http"]').first();
+			const url = titleLink.attr('href');
+			const title = titleLink.text().trim();
+
+			// Extract snippet
+			const snippet = $elem.find('.snippet-description').text().trim();
+
+			if (url && title) {
+				results.push({
+					title: title || 'No title',
+					url,
+					snippet: snippet || '',
+				});
+			}
+		});
+
+		if (results.length === 0) {
+			return `No results found for query: "${args.query}"`;
+		}
+
+		// Format results as markdown for easier LLM reading
+		let formattedResults = `# Web Search Results: "${args.query}"\n\n`;
+
+		for (let i = 0; i < results.length; i++) {
+			const result = results[i];
+			formattedResults += `## ${i + 1}. ${result.title}\n\n`;
+			formattedResults += `**URL:** ${result.url}\n\n`;
+			if (result.snippet) {
+				formattedResults += `${result.snippet}\n\n`;
+			}
+			formattedResults += '---\n\n';
+		}
+
+		return formattedResults;
+	} catch (error: unknown) {
+		if (error instanceof Error && error.name === 'AbortError') {
+			throw new Error('Search request timeout');
+		}
+
+		const errorMessage =
+			error instanceof Error ? error.message : 'Unknown error';
+		throw new Error(`Web search failed: ${errorMessage}`);
+	}
+};
+
+const webSearchCoreTool = tool({
+	description:
+		'Search the web for information (scrapes Brave Search, returns markdown)',
+	inputSchema: jsonSchema<SearchArgs>({
+		type: 'object',
+		properties: {
+			query: {
+				type: 'string',
+				description: 'The search query.',
+			},
+			max_results: {
+				type: 'number',
+				description:
+					'Maximum number of search results to return (default: 10).',
+			},
+		},
+		required: ['query'],
+	}),
+	// Low risk: read-only operation, never requires approval
+	needsApproval: false,
+	execute: async (args, _options) => {
+		return await executeWebSearch(args);
+	},
+});
+
+// Create a component that will re-render when theme changes
+const WebSearchFormatter = React.memo(
+	({ args, result }: { args: SearchArgs; result?: string }) => {
+		const themeContext = React.useContext(ThemeContext);
+		if (!themeContext) {
+			throw new Error('ThemeContext not found');
+		}
+		const { colors } = themeContext;
+		const query = args.query || 'unknown';
+		const maxResults = args.max_results ?? WEB_SEARCH_DISPLAY_RESULTS;
+
+		// Parse result to count actual results
+		let resultCount = 0;
+		let estimatedTokens = 0;
+		if (result) {
+			const matches = result.match(/^## \d+\./gm);
+			resultCount = matches ? matches.length : 0;
+			estimatedTokens = Math.ceil(result.length / 4);
+		}
+
+		const messageContent = (
+			<Box flexDirection="column">
+				<Text color={colors.tool}>☕︎ web_search</Text>
+
+				<Box>
+					<Text color={colors.secondary}>Query: </Text>
+					<Text color={colors.white}>{query}</Text>
+				</Box>
+
+				<Box>
+					<Text color={colors.secondary}>Engine: </Text>
+					<Text color={colors.white}>Brave Search</Text>
+				</Box>
+
+				{result && (
+					<>
+						<Box>
+							<Text color={colors.secondary}>Results: </Text>
+							<Text color={colors.white}>
+								{resultCount} / {maxResults} results
+							</Text>
+						</Box>
+
+						<Box>
+							<Text color={colors.secondary}>Output: </Text>
+							<Text color={colors.white}>~{estimatedTokens} tokens</Text>
+						</Box>
+					</>
+				)}
+			</Box>
+		);
+
+		return <ToolMessage message={messageContent} hideBox={true} />;
+	},
+);
+
+const webSearchFormatter = (
+	args: SearchArgs,
+	result?: string,
+): React.ReactElement => {
+	return <WebSearchFormatter args={args} result={result} />;
+};
+
+const webSearchValidator = (
+	args: SearchArgs,
+): Promise<{ valid: true } | { valid: false; error: string }> => {
+	const query = args.query?.trim();
+
+	// Check if query is empty
+	if (!query) {
+		return Promise.resolve({
+			valid: false,
+			error: '☕︎ Search query cannot be empty',
+		});
+	}
+
+	// Check query length (reasonable limit)
+	if (query.length > MAX_WEB_SEARCH_QUERY_LENGTH) {
+		return Promise.resolve({
+			valid: false,
+			error: `☕︎ Search query is too long (${query.length} characters). Maximum length is ${MAX_WEB_SEARCH_QUERY_LENGTH} characters.`,
+		});
+	}
+
+	return Promise.resolve({ valid: true });
+};
+
+export const webSearchTool: CoderToolExport = {
+	name: 'web_search' as const,
+	tool: webSearchCoreTool,
+	formatter: webSearchFormatter,
+	validator: webSearchValidator,
+};