@gguf/coder 0.3.1 → 0.3.2

package/source/tools/execute-bash.tsx

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

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

@@ -1,342 +0,0 @@
-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/);
-});