@gguf/coder 0.2.9 → 0.3.1

package/source/tools/find-files.tsx

@@ -0,0 +1,293 @@
+import { execFile } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import ignore from 'ignore';
+import { Box, Text } from 'ink';
+import React from 'react';
+
+import ToolMessage from '@/components/tool-message';
+import {
+	BUFFER_FIND_FILES_BYTES,
+	DEFAULT_FIND_FILES_RESULTS,
+	MAX_FIND_FILES_RESULTS,
+} from '@/constants';
+import { ThemeContext } from '@/hooks/useTheme';
+import { jsonSchema, tool } from '@/types/core';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Load and parse .gitignore file, returns an ignore instance
+ */
+function loadGitignore(cwd: string): ReturnType<typeof ignore> {
+	const ig = ignore();
+	const gitignorePath = join(cwd, '.gitignore');
+
+	// Always ignore common directories
+	ig.add([
+		'node_modules',
+		'.git',
+		'dist',
+		'build',
+		'coverage',
+		'.next',
+		'.nuxt',
+		'out',
+		'.cache',
+	]);
+
+	// Load .gitignore if it exists
+	if (existsSync(gitignorePath)) {
+		try {
+			const gitignoreContent = readFileSync(gitignorePath, 'utf-8');
+			ig.add(gitignoreContent);
+		} catch {
+			// Silently fail if we can't read .gitignore
+			// The hardcoded ignores above will still apply
+		}
+	}
+
+	return ig;
+}
+
+/**
+ * Find files matching a glob pattern using find command
+ */
+async function findFilesByPattern(
+	pattern: string,
+	cwd: string,
+	maxResults: number,
+): Promise<{ files: string[]; truncated: boolean }> {
+	try {
+		const ig = loadGitignore(cwd);
+
+		// Build find arguments array to prevent command injection
+		const findArgs: string[] = ['.'];
+
+		if (pattern.includes('{') && pattern.includes('}')) {
+			// Handle brace expansion like *.{ts,tsx}
+			const braceMatch = pattern.match(/\{([^}]+)\}/);
+			if (braceMatch) {
+				const extensions = braceMatch[1].split(',');
+				// Build: ( -name "*.ext1" -o -name "*.ext2" )
+				findArgs.push('(');
+				for (let i = 0; i < extensions.length; i++) {
+					if (i > 0) {
+						findArgs.push('-o');
+					}
+					findArgs.push('-name', `*.${extensions[i].trim()}`);
+				}
+				findArgs.push(')');
+			}
+		} else if (pattern.startsWith('**/')) {
+			// Pattern like **/*.ts - search everywhere
+			const namePattern = pattern.replace('**/', '');
+			findArgs.push('-name', namePattern);
+		} else if (pattern.includes('/**')) {
+			// Pattern like scripts/** or scripts/**/*.ts - search within a directory
+			const parts = pattern.split('/**');
+			const pathPrefix = `./${parts[0]}`;
+			const namePattern = parts[1] ? parts[1].replace(/^\//, '') : '*';
+
+			// Replace the starting '.' with pathPrefix
+			findArgs[0] = pathPrefix;
+
+			if (namePattern !== '*' && namePattern !== '') {
+				findArgs.push('-name', namePattern);
+			}
+		} else if (pattern.includes('/') && pattern.includes('*')) {
+			// Pattern like source/tools/*.ts - has both path and wildcard
+			// Split into directory path and filename pattern
+			const lastSlashIndex = pattern.lastIndexOf('/');
+			const dirPath = pattern.substring(0, lastSlashIndex);
+			const filePattern = pattern.substring(lastSlashIndex + 1);
+
+			// Start search from the directory
+			findArgs[0] = `./${dirPath}`;
+			// Only descend one level (maxdepth 1) to match the specific directory
+			findArgs.push('-maxdepth', '1', '-name', filePattern);
+		} else if (pattern.includes('*')) {
+			// Simple pattern like *.ts
+			findArgs.push('-name', pattern);
+		} else {
+			// Exact path or directory name
+			findArgs.push('-name', pattern);
+		}
+
+		// Add exclusions
+		const exclusions = [
+			'*/node_modules/*',
+			'*/.git/*',
+			'*/dist/*',
+			'*/build/*',
+			'*/coverage/*',
+			'*/.next/*',
+			'*/.nuxt/*',
+			'*/out/*',
+			'*/.cache/*',
+		];
+
+		for (const exclusion of exclusions) {
+			findArgs.push('-not', '-path', exclusion);
+		}
+
+		// Execute find command with array-based arguments
+		const { stdout } = await execFileAsync('find', findArgs, {
+			cwd,
+			maxBuffer: BUFFER_FIND_FILES_BYTES,
+		});
+
+		const allPaths = stdout
+			.trim()
+			.split('\n')
+			.filter(Boolean)
+			.map(line => line.replace(/^\.\//, ''))
+			.filter(path => path && path !== '.');
+
+		// Filter using gitignore and limit results
+		const paths: string[] = [];
+		for (const path of allPaths) {
+			if (!ig.ignores(path)) {
+				paths.push(path);
+
+				if (paths.length >= maxResults) {
+					break;
+				}
+			}
+		}
+
+		return {
+			files: paths,
+			truncated: allPaths.length >= maxResults || paths.length >= maxResults,
+		};
+	} catch (error: unknown) {
+		if (error instanceof Error && 'code' in error && error.code === 1) {
+			return { files: [], truncated: false };
+		}
+		throw error;
+	}
+}
+
+interface FindFilesArgs {
+	pattern: string;
+	maxResults?: number;
+}
+
+const executeFindFiles = async (args: FindFilesArgs): Promise<string> => {
+	const cwd = process.cwd();
+	const maxResults = Math.min(
+		args.maxResults || DEFAULT_FIND_FILES_RESULTS,
+		MAX_FIND_FILES_RESULTS,
+	);
+
+	try {
+		const { files, truncated } = await findFilesByPattern(
+			args.pattern,
+			cwd,
+			maxResults,
+		);
+
+		if (files.length === 0) {
+			return `No files or directories found matching pattern "${args.pattern}"`;
+		}
+
+		let output = `Found ${files.length} match${files.length === 1 ? '' : 'es'}${truncated ? ` (showing first ${maxResults})` : ''
+			}:\n\n`;
+		output += files.join('\n');
+
+		return output;
+	} catch (error: unknown) {
+		const errorMessage =
+			error instanceof Error ? error.message : 'Unknown error';
+		throw new Error(`File search failed: ${errorMessage}`);
+	}
+};
+
+const findFilesCoreTool = tool({
+	description:
+		'Find files and directories by path pattern or name. Use glob patterns like "*.tsx", "**/*.ts", "src/**/*.js", or "*.{ts,tsx}". Returns a list of matching file and directory paths. Does NOT search file contents - use search_file_contents for that.',
+	inputSchema: jsonSchema<FindFilesArgs>({
+		type: 'object',
+		properties: {
+			pattern: {
+				type: 'string',
+				description:
+					'Glob pattern to match file and directory paths. Examples: "*.tsx" (all .tsx files), "src/**/*.ts" (all .ts in src/), "components/**" (all files/dirs in components/), "*.{ts,tsx}" (multiple extensions)',
+			},
+			maxResults: {
+				type: 'number',
+				description:
+					'Maximum number of results to return (default: 50, max: 100)',
+			},
+		},
+		required: ['pattern'],
+	}),
+	// Low risk: read-only operation, never requires approval
+	needsApproval: false,
+	execute: async (args, _options) => {
+		return await executeFindFiles(args);
+	},
+});
+
+interface FindFilesFormatterProps {
+	args: {
+		pattern: string;
+		maxResults?: number;
+	};
+	result?: string;
+}
+
+const FindFilesFormatter = React.memo(
+	({ args, result }: FindFilesFormatterProps) => {
+		const themeContext = React.useContext(ThemeContext);
+		if (!themeContext) {
+			throw new Error('ThemeContext not found');
+		}
+		const { colors } = themeContext;
+
+		// Parse result to get file count
+		let fileCount = 0;
+		if (result && !result.startsWith('Error:')) {
+			const firstLine = result.split('\n')[0];
+			const matchFound = firstLine.match(/Found (\d+)/);
+			if (matchFound) {
+				fileCount = parseInt(matchFound[1], 10);
+			}
+		}
+
+		const messageContent = (
+			<Box flexDirection="column">
+				<Text color={colors.tool}>☕︎ find_files</Text>
+
+				<Box>
+					<Text color={colors.secondary}>Pattern: </Text>
+					<Text color={colors.white}>{args.pattern}</Text>
+				</Box>
+
+				<Box>
+					<Text color={colors.secondary}>Results: </Text>
+					<Text color={colors.white}>{fileCount}</Text>
+				</Box>
+			</Box>
+		);
+
+		return <ToolMessage message={messageContent} hideBox={true} />;
+	},
+);
+
+const findFilesFormatter = (
+	args: FindFilesFormatterProps['args'],
+	result?: string,
+): React.ReactElement => {
+	if (result && result.startsWith('Error:')) {
+		return <></>;
+	}
+	return <FindFilesFormatter args={args} result={result} />;
+};
+
+export const findFilesTool = {
+	name: 'find_files' as const,
+	tool: findFilesCoreTool,
+	formatter: findFilesFormatter,
+};

package/source/tools/index.ts

@@ -0,0 +1,102 @@
+import {executeBashTool} from '@/tools/execute-bash';
+import {fetchUrlTool} from '@/tools/fetch-url';
+import {findFilesTool} from '@/tools/find-files';
+import {getDiagnosticsTool} from '@/tools/lsp-get-diagnostics';
+import {readFileTool} from '@/tools/read-file';
+import {searchFileContentsTool} from '@/tools/search-file-contents';
+import {stringReplaceTool} from '@/tools/string-replace';
+import {webSearchTool} from '@/tools/web-search';
+import {writeFileTool} from '@/tools/write-file';
+import type {
+	AISDKCoreTool,
+	CoderToolExport,
+	ToolHandler,
+} from '@/types/index';
+import React from 'react';
+
+// Array of all tool exports from individual tool files
+// Each tool exports: { name, tool, formatter?, validator? }
+const allTools: CoderToolExport[] = [
+	readFileTool,
+	writeFileTool,
+	stringReplaceTool,
+	executeBashTool,
+	webSearchTool,
+	fetchUrlTool,
+	findFilesTool,
+	searchFileContentsTool,
+	getDiagnosticsTool,
+];
+
+// Export native AI SDK tools registry (for passing directly to AI SDK)
+export const nativeToolsRegistry: Record<string, AISDKCoreTool> =
+	Object.fromEntries(allTools.map(t => [t.name, t.tool]));
+
+// Export handlers for manual execution (human-in-the-loop)
+// These are extracted from the AI SDK tools' execute functions
+export const toolRegistry: Record<string, ToolHandler> = Object.fromEntries(
+	allTools.map(t => [
+		t.name,
+		// Extract the execute function from the AI SDK tool
+		// biome-ignore lint/suspicious/noExplicitAny: Dynamic typing required
+		async (args: any) => {
+			// Call the tool's execute function with a dummy options object
+			// The actual options will be provided by AI SDK during automatic execution
+			// biome-ignore lint/suspicious/noExplicitAny: Dynamic typing required
+			return await (t.tool as any).execute(args, {
+				toolCallId: 'manual',
+				messages: [],
+			});
+		},
+	]),
+);
+
+// Export formatter registry for the UI
+export const toolFormatters: Record<
+	string,
+	(
+		// biome-ignore lint/suspicious/noExplicitAny: Dynamic typing required
+		args: any,
+	) =>
+		| string
+		| Promise<string>
+		| React.ReactElement
+		| Promise<React.ReactElement>
+> = allTools.reduce(
+	(acc, t) => {
+		if ('formatter' in t && t.formatter) {
+			acc[t.name] = t.formatter;
+		}
+		return acc;
+	},
+	{} as Record<
+		string,
+		(
+			// biome-ignore lint/suspicious/noExplicitAny: Dynamic typing required
+			args: any,
+		) =>
+			| string
+			| Promise<string>
+			| React.ReactElement
+			| Promise<React.ReactElement>
+	>,
+);
+
+// Export validator registry
+export const toolValidators: Record<
+	string,
+	// biome-ignore lint/suspicious/noExplicitAny: Dynamic typing required
+	(args: any) => Promise<{valid: true} | {valid: false; error: string}>
+> = allTools.reduce(
+	(acc, t) => {
+		if ('validator' in t && t.validator) {
+			acc[t.name] = t.validator;
+		}
+		return acc;
+	},
+	{} as Record<
+		string,
+		// biome-ignore lint/suspicious/noExplicitAny: Dynamic typing required
+		(args: any) => Promise<{valid: true} | {valid: false; error: string}>
+	>,
+);

package/source/tools/lsp-get-diagnostics.tsx

@@ -0,0 +1,192 @@
+import { resolve as resolvePath } from 'node:path';
+import { Box, Text } from 'ink';
+import React from 'react';
+
+import ToolMessage from '@/components/tool-message';
+import { TIMEOUT_LSP_DIAGNOSTICS_MS } from '@/constants';
+import { ThemeContext } from '@/hooks/useTheme';
+import { DiagnosticSeverity, getLSPManager } from '@/lsp/index';
+import { jsonSchema, tool } from '@/types/core';
+
+interface GetDiagnosticsArgs {
+	path?: string;
+}
+
+// Request diagnostics from VS Code with timeout
+
+
+// Handler function
+const executeGetDiagnostics = async (
+	args: GetDiagnosticsArgs,
+): Promise<string> => {
+
+
+	// Fall back to local LSP
+	const lspManager = getLSPManager();
+
+	if (!lspManager.isInitialized()) {
+		return 'No diagnostics source available. Please install a language server.';
+	}
+
+	// If path is provided, get diagnostics for that file
+	if (args.path) {
+		// Check if we have LSP support for this file type
+		if (!lspManager.hasLanguageSupport(args.path)) {
+			return `No language server available for file type: ${args.path}.`;
+		}
+
+		// Open the document if not already open
+		await lspManager.openDocument(args.path);
+
+		// Get diagnostics
+		const diagnostics = await lspManager.getDiagnostics(args.path);
+
+		if (diagnostics.length === 0) {
+			return `No diagnostics found for ${args.path}`;
+		}
+
+		// Format diagnostics
+		const lines: string[] = [`Diagnostics for ${args.path}:`, ''];
+
+		for (const diag of diagnostics) {
+			const severity =
+				diag.severity === DiagnosticSeverity.Error
+					? 'ERROR'
+					: diag.severity === DiagnosticSeverity.Warning
+						? 'WARNING'
+						: diag.severity === DiagnosticSeverity.Information
+							? 'INFO'
+							: 'HINT';
+
+			const line = diag.range.start.line + 1;
+			const char = diag.range.start.character + 1;
+			const source = diag.source ? `[${diag.source}] ` : '';
+
+			lines.push(
+				`${severity} at line ${line}:${char}: ${source}${diag.message}`,
+			);
+		}
+
+		return lines.join('\n');
+	}
+
+	// Get all diagnostics from all open documents
+	const allDiagnostics = lspManager.getAllDiagnostics();
+
+	if (allDiagnostics.length === 0) {
+		return 'No diagnostics found in any open documents.';
+	}
+
+	const lines: string[] = ['Diagnostics from all open documents:', ''];
+
+	for (const { uri, diagnostics } of allDiagnostics) {
+		// Convert URI to path
+		const path = uri.startsWith('file://') ? uri.slice(7) : uri;
+		lines.push(`\n${path}:`);
+
+		for (const diag of diagnostics) {
+			const severity =
+				diag.severity === DiagnosticSeverity.Error
+					? 'ERROR'
+					: diag.severity === DiagnosticSeverity.Warning
+						? 'WARNING'
+						: diag.severity === DiagnosticSeverity.Information
+							? 'INFO'
+							: 'HINT';
+
+			const line = diag.range.start.line + 1;
+			const char = diag.range.start.character + 1;
+			const source = diag.source ? `[${diag.source}] ` : '';
+
+			lines.push(
+				`  ${severity} at line ${line}:${char}: ${source}${diag.message}`,
+			);
+		}
+	}
+
+	return lines.join('\n');
+};
+
+const getDiagnosticsCoreTool = tool({
+	description:
+		'Get errors and warnings for a file or project from the language server. Returns type errors, linting issues, and other diagnostics. Use this to check for problems before or after making code changes.',
+	inputSchema: jsonSchema<GetDiagnosticsArgs>({
+		type: 'object',
+		properties: {
+			path: {
+				type: 'string',
+				description:
+					'Optional path to a specific file. If omitted, returns diagnostics for all open documents.',
+			},
+		},
+		required: [],
+	}),
+	// Low risk: read-only operation, never requires approval
+	needsApproval: false,
+	execute: async (args, _options) => {
+		return await executeGetDiagnostics(args);
+	},
+});
+
+// Formatter component
+const GetDiagnosticsFormatter = React.memo(
+	({ args, result }: { args: GetDiagnosticsArgs; result?: string }) => {
+		const themeContext = React.useContext(ThemeContext);
+		if (!themeContext) {
+			throw new Error(
+				'GetDiagnosticsFormatter must be used within a ThemeProvider',
+			);
+		}
+		const { colors } = themeContext;
+
+		// Count diagnostics from result
+		const errorCount = (result?.match(/ERROR/g) || []).length;
+		const warningCount = (result?.match(/WARNING/g) || []).length;
+
+		const messageContent = (
+			<Box flexDirection="column">
+				<Text color={colors.tool}>☕︎ get_diagnostics</Text>
+
+				{args.path ? (
+					<Box>
+						<Text color={colors.secondary}>Path: </Text>
+						<Text color={colors.white}>{args.path}</Text>
+					</Box>
+				) : (
+					<Box>
+						<Text color={colors.secondary}>Scope: </Text>
+						<Text color={colors.white}>All open documents</Text>
+					</Box>
+				)}
+
+				{result && (
+					<Box>
+						<Text color={colors.secondary}>Found: </Text>
+						<Text color={errorCount > 0 ? colors.error : colors.white}>
+							{errorCount} errors
+						</Text>
+						<Text color={colors.secondary}>, </Text>
+						<Text color={warningCount > 0 ? colors.warning : colors.white}>
+							{warningCount} warnings
+						</Text>
+					</Box>
+				)}
+			</Box>
+		);
+
+		return <ToolMessage message={messageContent} hideBox={true} />;
+	},
+);
+
+const getDiagnosticsFormatter = (
+	args: GetDiagnosticsArgs,
+	result?: string,
+): React.ReactElement => {
+	return <GetDiagnosticsFormatter args={args} result={result} />;
+};
+
+export const getDiagnosticsTool = {
+	name: 'lsp_get_diagnostics' as const,
+	tool: getDiagnosticsCoreTool,
+	formatter: getDiagnosticsFormatter,
+};