@ottocode/sdk 0.1.265 → 0.1.266

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

@@ -0,0 +1,197 @@
+import { createToolError, type ToolResponse } from '../error.ts';
+
+export type WebFetchResult = {
+	url: string;
+	content: string;
+	contentLength: number;
+	truncated: boolean;
+	contentType: string;
+};
+
+export type WebSearchResult = {
+	query: string;
+	results: Array<{ title: string; url: string; snippet: string }>;
+	count: number;
+};
+
+const FETCH_HEADERS = {
+	'User-Agent':
+		'Mozilla/5.0 (compatible; otto-bot/1.0; +https://github.com/anthropics/otto)',
+	Accept:
+		'text/html,application/xhtml+xml,application/xml;q=0.9,text/plain;q=0.8,*/*;q=0.7',
+};
+
+const SEARCH_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',
+};
+
+export async function fetchUrlContent(
+	url: string,
+	maxLength: number,
+): Promise<ToolResponse<WebFetchResult>> {
+	try {
+		const response = await fetch(url, {
+			headers: FETCH_HEADERS,
+			redirect: 'follow',
+			signal: AbortSignal.timeout(30000),
+		});
+
+		if (!response.ok) {
+			throw new Error(
+				`HTTP error! status: ${response.status} ${response.statusText}`,
+			);
+		}
+
+		const contentType = response.headers.get('content-type') || '';
+		if (!isTextContentType(contentType)) {
+			return createToolError(
+				`Unsupported content type: ${contentType}. Only text-based content can be fetched.`,
+				'unsupported',
+				{ contentType },
+			);
+		}
+
+		const content = await response.text();
+		const cleanContent = cleanHtmlContent(content);
+		const truncated = cleanContent.slice(0, maxLength);
+		const wasTruncated = cleanContent.length > maxLength;
+
+		return {
+			ok: true,
+			url,
+			content: truncated,
+			contentLength: cleanContent.length,
+			truncated: wasTruncated,
+			contentType,
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		return createToolError(
+			`Failed to fetch URL: ${errorMessage}`,
+			'execution',
+			{
+				url,
+			},
+		);
+	}
+}
+
+export async function searchDuckDuckGo(
+	query: string,
+): Promise<ToolResponse<WebSearchResult>> {
+	try {
+		const searchUrl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+		const response = await fetch(searchUrl, {
+			headers: SEARCH_HEADERS,
+			redirect: 'follow',
+			signal: AbortSignal.timeout(30000),
+		});
+
+		if (!response.ok) {
+			throw new Error(`Search failed: ${response.status}`);
+		}
+
+		const html = await response.text();
+		const results = parseDuckDuckGoResults(html);
+		if (results.length === 0) {
+			return createToolError(
+				'No search results found. The search service may have changed its format or blocked the request.',
+				'execution',
+				{
+					query,
+					suggestion:
+						'Try using the url parameter to fetch a specific webpage instead.',
+				},
+			);
+		}
+
+		return {
+			ok: true,
+			query,
+			results,
+			count: results.length,
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		return createToolError(`Search failed: ${errorMessage}`, 'execution', {
+			query,
+			suggestion:
+				'Search services may be temporarily unavailable. Try using the url parameter to fetch a specific webpage instead.',
+		});
+	}
+}
+
+function isTextContentType(contentType: string): boolean {
+	return (
+		contentType.includes('text/') ||
+		contentType.includes('application/json') ||
+		contentType.includes('application/xml') ||
+		contentType.includes('application/xhtml')
+	);
+}
+
+function cleanHtmlContent(content: string): string {
+	return content
+		.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+		.replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '')
+		.replace(/<[^>]+>/g, ' ')
+		.replace(/\s+/g, ' ')
+		.trim();
+}
+
+function parseDuckDuckGoResults(
+	html: string,
+): Array<{ title: string; url: string; snippet: string }> {
+	const parsed = parseDuckDuckGoResultBlocks(html);
+	return parsed.length > 0 ? parsed : parseDuckDuckGoSimpleLinks(html);
+}
+
+function parseDuckDuckGoResultBlocks(
+	html: string,
+): Array<{ title: string; url: string; snippet: string }> {
+	const results: Array<{ title: string; url: string; snippet: string }> = [];
+	const resultPattern =
+		/<a[^>]+class="result__a"[^>]+href="([^"]+)"[^>]*>([^<]+)<\/a>[\s\S]*?<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
+
+	let match: RegExpExecArray | null = resultPattern.exec(html);
+	while (match !== null && results.length < 10) {
+		const url = match[1]?.trim();
+		const title = match[2]?.trim();
+		const snippet = cleanSearchSnippet(match[3]);
+
+		if (url && title) {
+			results.push({ title, url, snippet });
+		}
+		match = resultPattern.exec(html);
+	}
+	return results;
+}
+
+function parseDuckDuckGoSimpleLinks(
+	html: string,
+): Array<{ title: string; url: string; snippet: string }> {
+	const results: Array<{ title: string; url: string; snippet: string }> = [];
+	const simplePattern =
+		/<a[^>]+rel="nofollow"[^>]+href="([^"]+)"[^>]*>([^<]+)<\/a>/gi;
+	let match: RegExpExecArray | null = 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);
+	}
+	return results;
+}
+
+function cleanSearchSnippet(snippet: string | undefined): string {
+	return (
+		snippet
+			?.replace(/<[^>]+>/g, '')
+			.replace(/\s+/g, ' ')
+			.trim() || ''
+	);
+}

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

@@ -2,6 +2,12 @@ import { tool, type Tool } from 'ai';
 import { z } from 'zod/v3';
 import DESCRIPTION from './websearch.txt' with { type: 'text' };
 import { createToolError, type ToolResponse } from '../error.ts';
+import {
+	fetchUrlContent,
+	searchDuckDuckGo,
+	type WebFetchResult,
+	type WebSearchResult,
+} from './websearch-strategies.ts';
 
 export function buildWebSearchTool(): {
 	name: string;
@@ -43,197 +49,13 @@ export function buildWebSearchTool(): {
 			url?: string;
 			query?: string;
 			maxLength?: number;
-		}): Promise<
-			ToolResponse<
-				| {
-						url: string;
-						content: string;
-						contentLength: number;
-						truncated: boolean;
-						contentType: string;
-				  }
-				| {
-						query: string;
-						results: Array<{ title: string; url: string; snippet: string }>;
-						count: number;
-				  }
-			>
-		> {
-			const maxLen = maxLength ?? 50000;
-
+		}): Promise<ToolResponse<WebFetchResult | WebSearchResult>> {
 			if (url) {
-				// Fetch URL content
-				try {
-					const response = await fetch(url, {
-						headers: {
-							'User-Agent':
-								'Mozilla/5.0 (compatible; otto-bot/1.0; +https://github.com/anthropics/otto)',
-							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 createToolError(
-							`Unsupported content type: ${contentType}. Only text-based content can be fetched.`,
-							'unsupported',
-							{ contentType },
-						);
-					}
-
-					// 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 {
-						ok: true,
-						url,
-						content: truncated,
-						contentLength: cleanContent.length,
-						truncated: wasTruncated,
-						contentType,
-					};
-				} catch (error) {
-					const errorMessage =
-						error instanceof Error ? error.message : String(error);
-					return createToolError(
-						`Failed to fetch URL: ${errorMessage}`,
-						'execution',
-						{ url },
-					);
-				}
+				return fetchUrlContent(url, maxLength ?? 50000);
 			}
 
 			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 createToolError(
-							'No search results found. The search service may have changed its format or blocked the request.',
-							'execution',
-							{
-								query,
-								suggestion:
-									'Try using the url parameter to fetch a specific webpage instead.',
-							},
-						);
-					}
-
-					return {
-						ok: true,
-						query,
-						results,
-						count: results.length,
-					};
-				} catch (error) {
-					const errorMessage =
-						error instanceof Error ? error.message : String(error);
-					return createToolError(
-						`Search failed: ${errorMessage}`,
-						'execution',
-						{
-							query,
-							suggestion:
-								'Search services may be temporarily unavailable. Try using the url parameter to fetch a specific webpage instead.',
-						},
-					);
-				}
+				return searchDuckDuckGo(query);
 			}
 
 			return createToolError(

package/src/core/src/tools/loader.ts

@@ -24,11 +24,11 @@ import {
 	getMCPToolsRecord,
 	type MCPToolBrief,
 } from '../mcp/lazy-tools.ts';
-import fg from 'fast-glob';
 import { dirname, isAbsolute, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { promises as fs } from 'node:fs';
 import { spawn as nodeSpawn } from 'node:child_process';
+import { discoverPluginFiles } from './plugin-discovery.ts';
 
 export type DiscoveredTool = { name: string; tool: Tool };
 
@@ -105,8 +105,6 @@ type FsHelpers = {
 	exists: (path: string) => Promise<boolean>;
 };
 
-const pluginPatterns = ['tools/*/tool.js', 'tools/*/tool.mjs'];
-
 let globalTerminalManager: TerminalManager | null = null;
 const staticToolDiscoveryCache = new Map<string, Promise<DiscoveredTool[]>>();
 
@@ -168,53 +166,12 @@ async function discoverStaticProjectTools(
 		tools.set(skillTool.name, skillTool.tool);
 
 		async function loadFromBase(base: string | null | undefined) {
-			if (!base) return;
-			try {
-				await fs.readdir(base);
-			} catch {
-				return;
+			for (const { absPath, folder } of await discoverPluginFiles(base)) {
+				try {
+					const plugin = await loadPlugin(absPath, folder, projectRoot);
+					if (plugin) tools.set(plugin.name, plugin.tool);
+				} catch {}
 			}
-			for (const pattern of pluginPatterns) {
-				const files = await fg(pattern, { cwd: base, absolute: false });
-				for (const rel of files) {
-					const match = rel.match(/^tools\/([^/]+)\/tool\.(m?js)$/);
-					if (!match || !match[1]) continue;
-					const folder = match[1];
-					const absPath = join(base, rel).replace(/\\/g, '/');
-					try {
-						const plugin = await loadPlugin(absPath, folder, projectRoot);
-						if (plugin) tools.set(plugin.name, plugin.tool);
-					} catch {}
-				}
-			}
-			// Fallback: manual directory scan
-			try {
-				const toolsDir = join(base, 'tools');
-				const entries = await fs.readdir(toolsDir).catch(() => [] as string[]);
-				for (const folder of entries) {
-					const js = join(toolsDir, folder, 'tool.js');
-					const mjs = join(toolsDir, folder, 'tool.mjs');
-					const candidate = await fs
-						.stat(js)
-						.then(() => js)
-						.catch(
-							async () =>
-								await fs
-									.stat(mjs)
-									.then(() => mjs)
-									.catch(() => null),
-						);
-					if (!candidate) continue;
-					try {
-						const plugin = await loadPlugin(
-							candidate.replace(/\\/g, '/'),
-							folder,
-							projectRoot,
-						);
-						if (plugin) tools.set(plugin.name, plugin.tool);
-					} catch {}
-				}
-			} catch {}
 		}
 
 		await loadFromBase(globalConfigDir);

package/src/core/src/tools/plugin-discovery.ts

@@ -0,0 +1,86 @@
+import fg from 'fast-glob';
+import { join } from 'node:path';
+import { promises as fs } from 'node:fs';
+
+const pluginPatterns = ['tools/*/tool.js', 'tools/*/tool.mjs'];
+
+export type PluginFileCandidate = {
+	folder: string;
+	absPath: string;
+};
+
+export async function discoverPluginFiles(
+	base: string | null | undefined,
+): Promise<PluginFileCandidate[]> {
+	if (!base) return [];
+	try {
+		await fs.readdir(base);
+	} catch {
+		return [];
+	}
+
+	const candidates = new Map<string, PluginFileCandidate>();
+	for (const candidate of await discoverPluginFilesWithGlob(base)) {
+		candidates.set(`${candidate.folder}:${candidate.absPath}`, candidate);
+	}
+	for (const candidate of await discoverPluginFilesByDirectoryScan(base)) {
+		candidates.set(`${candidate.folder}:${candidate.absPath}`, candidate);
+	}
+	return Array.from(candidates.values());
+}
+
+async function discoverPluginFilesWithGlob(
+	base: string,
+): Promise<PluginFileCandidate[]> {
+	const candidates: PluginFileCandidate[] = [];
+	for (const pattern of pluginPatterns) {
+		const files = await fg(pattern, { cwd: base, absolute: false });
+		for (const rel of files) {
+			const match = rel.match(/^tools\/([^/]+)\/tool\.(m?js)$/);
+			if (!match || !match[1]) continue;
+			candidates.push({
+				folder: match[1],
+				absPath: join(base, rel).replace(/\\/g, '/'),
+			});
+		}
+	}
+	return candidates;
+}
+
+async function discoverPluginFilesByDirectoryScan(
+	base: string,
+): Promise<PluginFileCandidate[]> {
+	try {
+		const toolsDir = join(base, 'tools');
+		const entries = await fs.readdir(toolsDir).catch(() => [] as string[]);
+		const candidates: PluginFileCandidate[] = [];
+		for (const folder of entries) {
+			const candidate = await findToolFile(toolsDir, folder);
+			if (!candidate) continue;
+			candidates.push({
+				folder,
+				absPath: candidate.replace(/\\/g, '/'),
+			});
+		}
+		return candidates;
+	} catch {
+		return [];
+	}
+}
+
+async function findToolFile(
+	toolsDir: string,
+	folder: string,
+): Promise<string | null> {
+	const js = join(toolsDir, folder, 'tool.js');
+	const mjs = join(toolsDir, folder, 'tool.mjs');
+	return fs
+		.stat(js)
+		.then(() => js)
+		.catch(async () =>
+			fs
+				.stat(mjs)
+				.then(() => mjs)
+				.catch(() => null),
+		);
+}

package/src/core/src/utils/logger/format.ts

@@ -0,0 +1,50 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+const ANSI_RESET = '\x1b[0m';
+const ANSI_DIM = '\x1b[2m';
+const ANSI_CYAN = '\x1b[36m';
+const ANSI_BLUE = '\x1b[34m';
+const ANSI_GREEN = '\x1b[32m';
+const ANSI_YELLOW = '\x1b[33m';
+const ANSI_RED = '\x1b[31m';
+
+export function safeHasMeta(
+	meta?: Record<string, unknown>,
+): meta is Record<string, unknown> {
+	return Boolean(meta && Object.keys(meta).length);
+}
+
+export function serializeLogMeta(meta?: Record<string, unknown>): string {
+	if (!safeHasMeta(meta)) return '';
+	try {
+		const sanitized = { ...meta };
+		delete sanitized.debugDetail;
+		return Object.keys(sanitized).length ? ` ${JSON.stringify(sanitized)}` : '';
+	} catch {
+		return ' [unserializable-meta]';
+	}
+}
+
+export function colorizeLine(line: string, level: LogLevel): string {
+	const levelColor =
+		level === 'debug'
+			? ANSI_CYAN
+			: level === 'info'
+				? ANSI_BLUE
+				: level === 'warn'
+					? ANSI_YELLOW
+					: ANSI_RED;
+	const scopeMatch = line.match(
+		/\[(debug|info|warn|error|timing)\]\s+\[([^\]]+)\]/i,
+	);
+	if (!scopeMatch) {
+		return `${levelColor}${line}${ANSI_RESET}`;
+	}
+	const rest = line.slice(24);
+	return `${ANSI_DIM}${line.slice(0, 24)}${ANSI_RESET}${rest
+		.replace(scopeMatch[1], `${levelColor}${scopeMatch[1]}${ANSI_RESET}`)
+		.replace(
+			`[${scopeMatch[2]}]`,
+			`${ANSI_GREEN}[${scopeMatch[2]}]${ANSI_RESET}`,
+		)}`;
+}

package/src/core/src/utils/logger/sinks.ts

@@ -0,0 +1,61 @@
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import {
+	getGlobalDebugLogPath,
+	getSessionDebugDetailsLogPath,
+	getSessionDebugLogPath,
+} from '../../../../config/src/paths.ts';
+import { isDebugEnabled } from '../debug.ts';
+import { serializeLogMeta } from './format.ts';
+
+function getDebugLogFilePath(): string | undefined {
+	if (!isDebugEnabled()) return undefined;
+	return getGlobalDebugLogPath();
+}
+
+function getSessionLogFilePath(
+	meta?: Record<string, unknown>,
+): string | undefined {
+	if (!isDebugEnabled()) return undefined;
+	if (meta?.debugDetail === true) return undefined;
+	const sessionId = meta?.sessionId;
+	if (typeof sessionId !== 'string' || !sessionId.trim()) return undefined;
+	return getSessionDebugLogPath(sessionId);
+}
+
+function getSessionDetailsLogFilePath(
+	meta?: Record<string, unknown>,
+): string | undefined {
+	if (!isDebugEnabled()) return undefined;
+	const sessionId = meta?.sessionId;
+	if (typeof sessionId !== 'string' || !sessionId.trim()) return undefined;
+	return getSessionDebugDetailsLogPath(sessionId);
+}
+
+function appendLogFile(filePath: string, fullLine: string): void {
+	try {
+		mkdirSync(dirname(filePath), { recursive: true });
+		appendFileSync(filePath, `${fullLine}\n`, 'utf-8');
+	} catch {
+		// ignore file logging errors
+	}
+}
+
+export function writeLogLine(
+	line: string,
+	meta?: Record<string, unknown>,
+): string {
+	const suffix = serializeLogMeta(meta);
+	const fullLine = `${new Date().toISOString()} ${line}${suffix}`;
+	const logFile = getDebugLogFilePath();
+
+	if (logFile) appendLogFile(logFile, fullLine);
+
+	const sessionLogFile = getSessionLogFilePath(meta);
+	if (sessionLogFile) appendLogFile(sessionLogFile, fullLine);
+
+	const sessionDetailsLogFile = getSessionDetailsLogFilePath(meta);
+	if (sessionDetailsLogFile) appendLogFile(sessionDetailsLogFile, fullLine);
+
+	return fullLine;
+}