@gguf/coder 0.3.1 → 0.3.2

package/source/tools/tool-registry.ts

@@ -1,228 +0,0 @@
-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

@@ -1,223 +0,0 @@
-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,
-};