@gguf/coder 0.2.9 → 0.3.1

package/source/tools/execute-bash.tsx

@@ -0,0 +1,219 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { platform } from 'node:os';
+import { highlight } from 'cli-highlight';
+import { Box, Text } from 'ink';
+import React from 'react';
+
+import ToolMessage from '@/components/tool-message';
+import { TRUNCATION_OUTPUT_LIMIT } from '@/constants';
+import { ThemeContext } from '@/hooks/useTheme';
+import { jsonSchema, tool } from '@/types/core';
+import type { CoderToolExport } from '@/types/core';
+
+const runShellCommand = (
+	shell: string,
+	shellArgs: string[],
+	script: string,
+): Promise<string> => {
+	return new Promise((resolve, reject) => {
+		const proc = spawn(shell, [...shellArgs, script]);
+		let stdout = '';
+		let stderr = '';
+
+		proc.stdout.on('data', (data: Buffer) => {
+			stdout += data.toString();
+		});
+
+		proc.stderr.on('data', (data: Buffer) => {
+			stderr += data.toString();
+		});
+
+		proc.on('close', (code: number | null) => {
+			let fullOutput = '';
+
+			// Include exit code information
+			const exitCodeInfo = code !== null ? `EXIT_CODE: ${code}\n` : '';
+
+			if (stderr) {
+				fullOutput = `${exitCodeInfo}STDERR:
+${stderr}
+STDOUT:
+${stdout}`;
+			} else {
+				fullOutput = `${exitCodeInfo}${stdout}`;
+			}
+
+			// Limit the context for LLM to first TRUNCATION_OUTPUT_LIMIT characters to prevent overwhelming the model
+			const llmContext =
+				fullOutput.length > TRUNCATION_OUTPUT_LIMIT
+					? fullOutput.substring(0, TRUNCATION_OUTPUT_LIMIT) +
+					'\n... [Output truncated. Use more specific commands to see full output]'
+					: fullOutput;
+
+			// Return ONLY the llmContext to avoid sending massive outputs to the model
+			// The formatter will need to be updated to handle plain strings
+			resolve(llmContext);
+		});
+
+		proc.on('error', error => {
+			reject(error);
+		});
+	});
+};
+
+const executeExecuteBash = async (args: { command: string }): Promise<string> => {
+	try {
+		return await runShellCommand('sh', ['-c'], args.command);
+	} catch (error: any) {
+		if (error.code === 'ENOENT' && platform() === 'win32') {
+			// Try to find Git Bash in common locations
+			const gitBashPaths = [
+				'C:\\Program Files\\Git\\bin\\bash.exe',
+				'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
+				`C:\\Users\\${process.env['USERNAME'] || 'User'
+				}\\AppData\\Local\\Programs\\Git\\bin\\bash.exe`,
+			];
+
+			for (const bashPath of gitBashPaths) {
+				if (existsSync(bashPath)) {
+					try {
+						return await runShellCommand(bashPath, ['-c'], args.command);
+					} catch {
+						// Continue to next fallback
+					}
+				}
+			}
+
+			// Fallback to PowerShell
+			try {
+				return await runShellCommand('powershell', ['-Command'], args.command);
+			} catch {
+				// If PowerShell also fails, throw the original error
+				throw new Error(`Error executing command: ${error.message}`);
+			}
+		}
+
+		throw new Error(`Error executing command: ${error.message}`);
+	}
+};
+
+const executeBashCoreTool = tool({
+	description:
+		'Execute a bash command and return the output (use for running commands)',
+	inputSchema: jsonSchema<{ command: string }>({
+		type: 'object',
+		properties: {
+			command: {
+				type: 'string',
+				description: 'The bash command to execute.',
+			},
+		},
+		required: ['command'],
+	}),
+	// High risk: bash commands always require approval in all modes
+	needsApproval: true,
+	execute: async (args, _options) => {
+		return await executeExecuteBash(args);
+	},
+});
+
+// Create a component that will re-render when theme changes
+const ExecuteBashFormatter = React.memo(
+	({ args, result }: { args: { command: string }; result?: string }) => {
+		const themeContext = React.useContext(ThemeContext);
+		if (!themeContext) {
+			throw new Error('ThemeContext is required');
+		}
+		const { colors } = themeContext;
+		const command = args.command || 'unknown';
+
+		try {
+			highlight(command, {
+				language: 'bash',
+				theme: 'default',
+			});
+		} catch {
+			// Syntax highlighting failed, will use plain command
+		}
+
+		// Result is now a plain string (truncated output)
+		let outputSize = 0;
+		let estimatedTokens = 0;
+		if (result) {
+			outputSize = result.length;
+			estimatedTokens = Math.ceil(outputSize / 4); // ~4 characters per token
+		}
+
+		const messageContent = (
+			<Box flexDirection="column">
+				<Text color={colors.tool}>☕︎ execute_bash</Text>
+
+				<Box>
+					<Text color={colors.secondary}>Command: </Text>
+					<Text color={colors.primary}>{command}</Text>
+				</Box>
+
+				{result && (
+					<Box>
+						<Text color={colors.secondary}>Output: </Text>
+						<Text color={colors.white}>
+							{outputSize} characters (~{estimatedTokens} tokens sent to LLM)
+						</Text>
+					</Box>
+				)}
+			</Box>
+		);
+
+		return <ToolMessage message={messageContent} hideBox={true} />;
+	},
+);
+
+const executeBashFormatter = (
+	args: { command: string },
+	result?: string,
+): React.ReactElement => {
+	return <ExecuteBashFormatter args={args} result={result} />;
+};
+
+const executeBashValidator = (args: {
+	command: string;
+}): Promise<{ valid: true } | { valid: false; error: string }> => {
+	const command = args.command?.trim();
+
+	// Check if command is empty
+	if (!command) {
+		return Promise.resolve({
+			valid: false,
+			error: '☕︎ Command cannot be empty',
+		});
+	}
+
+	// Check for extremely dangerous commands
+	const dangerousPatterns = [
+		/rm\s+-rf\s+\/(?!\w)/i, // rm -rf / (but allow /path)
+		/mkfs/i, // Format filesystem
+		/dd\s+if=/i, // Direct disk write
+		/:(){:|:&};:/i, // Fork bomb
+		/>\s*\/dev\/sd[a-z]/i, // Writing to raw disk devices
+		/chmod\s+-R\s+000/i, // Remove all permissions recursively
+	];
+
+	for (const pattern of dangerousPatterns) {
+		if (pattern.test(command)) {
+			return Promise.resolve({
+				valid: false,
+				error: `☕︎ Command contains potentially destructive operation: "${command}". This command is blocked for safety.`,
+			});
+		}
+	}
+
+	return Promise.resolve({ valid: true });
+};
+
+export const executeBashTool: CoderToolExport = {
+	name: 'execute_bash' as const,
+	tool: executeBashCoreTool,
+	formatter: executeBashFormatter,
+	validator: executeBashValidator,
+};

package/source/tools/execute-function.spec.ts

@@ -0,0 +1,130 @@
+import {tmpdir} from 'os';
+import {resolve} from 'path';
+import test from 'ava';
+import {unlink, writeFile} from 'fs/promises';
+import {executeBashTool} from './execute-bash.js';
+import {readFileTool} from './read-file.js';
+
+// ============================================================================
+// Tests for AI SDK v6 Native Tools
+// ============================================================================
+// These tests validate that the native AI SDK tools work correctly with their
+// execute functions. Since tools now only export the native AI SDK tool,
+// there's no separate handler to compare against.
+
+// ============================================================================
+// Bash Execute Function
+// ============================================================================
+
+test('execute_bash tool works correctly', async t => {
+	const result = (await executeBashTool.tool.execute!(
+		{command: 'echo "test"'},
+		{
+			toolCallId: 'test-1',
+			messages: [],
+		},
+	)) as string;
+
+	t.truthy(result);
+	t.regex(result, /test/);
+});
+
+test('execute_bash includes exit code', async t => {
+	const result = (await executeBashTool.tool.execute!(
+		{command: 'echo "success"'},
+		{
+			toolCallId: 'test-2',
+			messages: [],
+		},
+	)) as string;
+
+	t.truthy(result);
+	t.regex(result, /EXIT_CODE: 0/);
+});
+
+test('execute_bash captures stderr', async t => {
+	const result = (await executeBashTool.tool.execute!(
+		{command: 'echo "error" >&2'},
+		{
+			toolCallId: 'test-3',
+			messages: [],
+		},
+	)) as string;
+
+	t.truthy(result);
+	t.regex(result, /STDERR:/);
+	t.regex(result, /error/);
+});
+
+test('execute_bash tool name constant is correct', t => {
+	t.is(executeBashTool.name, 'execute_bash');
+});
+
+// ============================================================================
+// Read File Execute Function
+// ============================================================================
+
+test('read_file reads existing file', async t => {
+	const testFile = resolve(tmpdir(), `coder-test-${Date.now()}.txt`);
+	await writeFile(testFile, 'test content', 'utf-8');
+
+	try {
+		const result = (await readFileTool.tool.execute!(
+			{path: testFile},
+			{
+				toolCallId: 'test-4',
+				messages: [],
+			},
+		)) as string;
+
+		t.truthy(result);
+		t.regex(result, /test content/);
+	} finally {
+		await unlink(testFile).catch(() => {});
+	}
+});
+
+test('read_file handles non-existent file', async t => {
+	const nonExistentFile = resolve(tmpdir(), 'non-existent-file.txt');
+
+	await t.throwsAsync(
+		async () => {
+			await readFileTool.tool.execute!(
+				{path: nonExistentFile},
+				{
+					toolCallId: 'test-5',
+					messages: [],
+				},
+			);
+		},
+		{message: /does not exist|no such file or directory|ENOENT/i},
+	);
+});
+
+test('read_file reads with line ranges', async t => {
+	const testFile = resolve(tmpdir(), `coder-test-${Date.now()}.txt`);
+	await writeFile(testFile, 'line1\nline2\nline3\nline4\nline5', 'utf-8');
+
+	try {
+		const result = (await readFileTool.tool.execute!(
+			{path: testFile, start_line: 2, end_line: 4},
+			{
+				toolCallId: 'test-6',
+				messages: [],
+			},
+		)) as string;
+
+		t.truthy(result);
+		t.regex(result, /line2/);
+		t.regex(result, /line3/);
+		t.regex(result, /line4/);
+		t.notRegex(result, /line1/);
+		t.notRegex(result, /line5/);
+	} finally {
+		await unlink(testFile).catch(() => {});
+	}
+});
+
+test('read_file tool name constant is correct', t => {
+	t.is(readFileTool.name, 'read_file');
+});

package/source/tools/fetch-url.spec.tsx

@@ -0,0 +1,342 @@
+import test from 'ava';
+import {render} from 'ink-testing-library';
+import React from 'react';
+import {themes} from '../config/themes';
+import {ThemeContext} from '../hooks/useTheme';
+
+console.log(`\nfetch-url.spec.tsx – ${React.version}`);
+
+// Polyfill File for undici in Node.js test environment
+if (typeof File === 'undefined') {
+	(global as any).File = class File {
+		constructor(
+			public parts: any[],
+			public name: string,
+			public options?: any,
+		) {}
+	};
+}
+
+// Dynamically import to avoid loading undici in test environment
+let fetchUrlTool: any;
+
+test.before(async () => {
+	// Only import when we need it, and handle the case where undici might not work
+	try {
+		const module = await import('./fetch-url.js');
+		fetchUrlTool = module.fetchUrlTool;
+	} catch (error) {
+		// If undici fails to load (e.g., in CI), we'll skip handler tests
+		console.warn('Failed to load fetch-url module:', error);
+	}
+});
+
+// Mock ThemeProvider for testing
+const MockThemeProvider = ({children}: {children: React.ReactNode}) => {
+	const mockTheme = {
+		currentTheme: 'default' as const,
+		colors: themes['tokyo-night'].colors, // Use tokyo-night theme colors
+		setCurrentTheme: () => {},
+	};
+
+	return (
+		<ThemeContext.Provider value={mockTheme}>{children}</ThemeContext.Provider>
+	);
+};
+
+// Note: These tests validate the tool configuration and validator logic.
+// Handler tests that make actual network requests are skipped to avoid flakiness.
+// For handler testing, consider using integration tests with known stable URLs
+// or mocking the convertToMarkdown function at the module level.
+
+test('handler validates URL format', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+
+	await t.throwsAsync(
+		async () => {
+			await fetchUrlTool.tool.execute!(
+				{url: 'not-a-valid-url'},
+				{toolCallId: 'test', messages: []},
+			);
+		},
+		{message: /Invalid URL/},
+	);
+});
+
+test('validator accepts valid HTTP URLs', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	const result = await fetchUrlTool.validator!({url: 'https://example.com'});
+
+	t.true(result.valid);
+});
+
+test('validator accepts valid HTTPS URLs', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	const result = await fetchUrlTool.validator!({url: 'http://example.com'});
+
+	t.true(result.valid);
+});
+
+test('validator rejects invalid URL formats', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	const result = await fetchUrlTool.validator!({url: 'not a url'});
+
+	t.false(result.valid);
+	if (!result.valid) {
+		t.true(result.error.includes('Invalid URL format'));
+	}
+});
+
+test('validator rejects non-HTTP/HTTPS protocols', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	const result = await fetchUrlTool.validator!({url: 'ftp://example.com'});
+
+	t.false(result.valid);
+	if (!result.valid) {
+		t.true(result.error.includes('Invalid URL protocol'));
+		t.true(result.error.includes('ftp:'));
+	}
+});
+
+test('validator rejects localhost URLs', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	const result = await fetchUrlTool.validator!({url: 'http://localhost:3000'});
+
+	t.false(result.valid);
+	if (!result.valid) {
+		t.true(result.error.includes('internal/private network'));
+	}
+});
+
+test('validator rejects 127.0.0.1 URLs', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	const result = await fetchUrlTool.validator!({
+		url: 'http://127.0.0.1:8080',
+	});
+
+	t.false(result.valid);
+	if (!result.valid) {
+		t.true(result.error.includes('internal/private network'));
+	}
+});
+
+test('validator rejects 192.168.x.x URLs', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	const result = await fetchUrlTool.validator!({
+		url: 'http://192.168.1.1',
+	});
+
+	t.false(result.valid);
+	if (!result.valid) {
+		t.true(result.error.includes('internal/private network'));
+	}
+});
+
+test('validator rejects 10.x.x.x URLs', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	const result = await fetchUrlTool.validator!({url: 'http://10.0.0.1'});
+
+	t.false(result.valid);
+	if (!result.valid) {
+		t.true(result.error.includes('internal/private network'));
+	}
+});
+
+test('validator rejects 172.16-31.x.x URLs', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	const result = await fetchUrlTool.validator!({url: 'http://172.16.0.1'});
+
+	t.false(result.valid);
+	if (!result.valid) {
+		t.true(result.error.includes('internal/private network'));
+	}
+});
+
+test('validator accepts external IP addresses', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	const result = await fetchUrlTool.validator!({url: 'http://8.8.8.8'});
+
+	t.true(result.valid);
+});
+
+test('tool has correct name', t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	t.is(fetchUrlTool.name, 'fetch_url');
+});
+
+test('tool does not require confirmation', t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	t.false(fetchUrlTool.tool.needsApproval);
+});
+
+test('formatter is a function', t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	t.is(typeof fetchUrlTool.formatter, 'function');
+});
+
+test('formatter returns a Promise', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	const result = fetchUrlTool.formatter!({url: 'https://example.com'});
+
+	t.true(result instanceof Promise);
+});
+
+// ============================================================================
+// Component Rendering Tests
+// ============================================================================
+
+test('formatter renders component with URL', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	const component = await fetchUrlTool.formatter!({
+		url: 'https://example.com',
+	});
+
+	const {lastFrame} = render(
+		<MockThemeProvider>{component}</MockThemeProvider>,
+	);
+
+	const output = lastFrame();
+	t.truthy(output);
+	t.regex(output!, /fetch_url/);
+	t.regex(output!, /https:\/\/example\.com/);
+});
+
+test('formatter renders component with result stats', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	const mockResult = 'Test content with some markdown';
+
+	const component = await fetchUrlTool.formatter!(
+		{url: 'https://example.com'},
+		mockResult,
+	);
+
+	const {lastFrame} = render(
+		<MockThemeProvider>{component}</MockThemeProvider>,
+	);
+
+	const output = lastFrame();
+	t.truthy(output);
+	t.regex(output!, /fetch_url/);
+	t.regex(output!, /https:\/\/example\.com/);
+	t.regex(output!, /Content:/);
+	t.regex(output!, /characters/);
+	t.regex(output!, /tokens/);
+});
+
+test('formatter shows truncation warning when content is truncated', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	const truncatedResult =
+		'x'.repeat(100000) +
+		'\n\n[Content truncated - original size was 150000 characters]';
+
+	const component = await fetchUrlTool.formatter!(
+		{url: 'https://large-content.com'},
+		truncatedResult,
+	);
+
+	const {lastFrame} = render(
+		<MockThemeProvider>{component}</MockThemeProvider>,
+	);
+
+	const output = lastFrame();
+	t.truthy(output);
+	t.regex(output!, /Content was truncated to 100KB/);
+});
+
+test('formatter renders without result (before execution)', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	const component = await fetchUrlTool.formatter!({
+		url: 'https://example.com',
+	});
+
+	const {lastFrame} = render(
+		<MockThemeProvider>{component}</MockThemeProvider>,
+	);
+
+	const output = lastFrame();
+	t.truthy(output);
+	t.regex(output!, /fetch_url/);
+	t.regex(output!, /https:\/\/example\.com/);
+	// Should not show content stats before execution
+	t.notRegex(output!, /Content:/);
+});
+
+test('formatter calculates token estimate correctly', async t => {
+	if (!fetchUrlTool) {
+		t.pass('Skipping test - fetch-url module not available');
+		return;
+	}
+	// 100 characters should estimate ~25 tokens (divide by 4)
+	const mockResult = 'a'.repeat(100);
+
+	const component = await fetchUrlTool.formatter!(
+		{url: 'https://example.com'},
+		mockResult,
+	);
+
+	const {lastFrame} = render(
+		<MockThemeProvider>{component}</MockThemeProvider>,
+	);
+
+	const output = lastFrame();
+	t.truthy(output);
+	t.regex(output!, /100.*characters/);
+	t.regex(output!, /25.*tokens/);
+});