@gguf/coder 0.3.0 → 0.3.1

package/source/tools/write-file.tsx

@@ -0,0 +1,228 @@
+import { constants, existsSync } from 'node:fs';
+import { access, readFile, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { highlight } from 'cli-highlight';
+import { Box, Text } from 'ink';
+import React from 'react';
+
+import ToolMessage from '@/components/tool-message';
+import { getCurrentMode } from '@/context/mode-context';
+import { ThemeContext } from '@/hooks/useTheme';
+import { jsonSchema, tool } from '@/types/core';
+import { getCachedFileContent, invalidateCache } from '@/utils/file-cache';
+import { normalizeIndentation } from '@/utils/indentation-normalizer';
+import { getLanguageFromExtension } from '@/utils/programming-language-helper';
+
+
+const executeWriteFile = async (args: {
+	path: string;
+	content: string;
+}): Promise<string> => {
+	const absPath = resolve(args.path);
+	const fileExists = existsSync(absPath);
+
+	await writeFile(absPath, args.content, 'utf-8');
+
+	// Invalidate cache after write
+	invalidateCache(absPath);
+
+	// Read back to verify and show actual content
+	const actualContent = await readFile(absPath, 'utf-8');
+	const lines = actualContent.split('\n');
+	const lineCount = lines.length;
+	const charCount = actualContent.length;
+	const estimatedTokens = Math.ceil(charCount / 4);
+
+	// Generate full file contents to show the model the current file state
+	let fileContext = '\n\nFile contents after write:\n';
+	for (let i = 0; i < lines.length; i++) {
+		const lineNumStr = String(i + 1).padStart(4, ' ');
+		const line = lines[i] || '';
+		fileContext += `${lineNumStr}: ${line}\n`;
+	}
+
+	const action = fileExists ? 'overwritten' : 'written';
+	return `File ${action} successfully (${lineCount} lines, ${charCount} characters, ~${estimatedTokens} tokens).${fileContext}`;
+};
+
+const writeFileCoreTool = tool({
+	description:
+		'Write content to a file (creates new file or overwrites existing file). Use this for complete file rewrites, generated code, or when most of the file needs to change. For small targeted edits, use string_replace instead.',
+	inputSchema: jsonSchema<{ path: string; content: string }>({
+		type: 'object',
+		properties: {
+			path: {
+				type: 'string',
+				description: 'The path to the file to write.',
+			},
+			content: {
+				type: 'string',
+				description: 'The complete content to write to the file.',
+			},
+		},
+		required: ['path', 'content'],
+	}),
+	// Medium risk: file write operation, requires approval except in auto-accept mode
+	needsApproval: () => {
+		const mode = getCurrentMode();
+		return mode !== 'auto-accept'; // true in normal/plan, false in auto-accept
+	},
+	execute: async (args, _options) => {
+		return await executeWriteFile(args);
+	},
+});
+
+interface WriteFileArgs {
+	path?: string;
+	file_path?: string;
+	content?: string;
+}
+
+// Create a component that will re-render when theme changes
+const WriteFileFormatter = React.memo(({ args }: { args: WriteFileArgs }) => {
+	const themeContext = React.useContext(ThemeContext);
+	if (!themeContext) {
+		throw new Error('ThemeContext is required');
+	}
+	const { colors } = themeContext;
+	const path = args.path || args.file_path || 'unknown';
+	const newContent = args.content || '';
+	const lineCount = newContent.split('\n').length;
+	const charCount = newContent.length;
+
+	// Estimate tokens (rough approximation: ~4 characters per token)
+	const estimatedTokens = Math.ceil(charCount / 4);
+
+	// Normalize indentation for display
+	const lines = newContent.split('\n');
+	const normalizedLines = normalizeIndentation(lines);
+
+	const messageContent = (
+		<Box flexDirection="column">
+			<Text color={colors.tool}>☕︎ write_file</Text>
+
+			<Box>
+				<Text color={colors.secondary}>Path: </Text>
+				<Text color={colors.white}>{path}</Text>
+			</Box>
+			<Box>
+				<Text color={colors.secondary}>Size: </Text>
+				<Text color={colors.white}>
+					{lineCount} lines, {charCount} characters (~{estimatedTokens} tokens)
+				</Text>
+			</Box>
+
+			{newContent.length > 0 ? (
+				<Box flexDirection="column" marginTop={1}>
+					<Text color={colors.white}>File content:</Text>
+					{normalizedLines.slice(0, 50).map((line: string, i: number) => {
+						const lineNumStr = String(i + 1).padStart(4, ' ');
+						const ext = path.split('.').pop()?.toLowerCase() ?? '';
+						const language = getLanguageFromExtension(ext);
+
+						try {
+							const highlighted = highlight(line, { language, theme: 'default' });
+							return (
+								<Box key={i}>
+									<Text color={colors.secondary}>{lineNumStr} </Text>
+									<Text wrap="wrap">{highlighted}</Text>
+								</Box>
+							);
+						} catch {
+							return (
+								<Box key={i}>
+									<Text color={colors.secondary}>{lineNumStr} </Text>
+									<Text wrap="wrap">{line}</Text>
+								</Box>
+							);
+						}
+					})}
+					{normalizedLines.length > 50 && (
+						<Box marginTop={0}>
+							<Text color={colors.secondary}>
+								... {normalizedLines.length - 50} more lines (truncated for display)
+							</Text>
+						</Box>
+					)}
+				</Box>
+			) : (
+				<Box marginTop={1}>
+					<Text color={colors.secondary}>File will be empty</Text>
+				</Box>
+			)}
+		</Box>
+	);
+
+	return <ToolMessage message={messageContent} hideBox={true} />;
+});
+
+
+
+const writeFileFormatter = async (
+	args: WriteFileArgs,
+	result?: string,
+): Promise<React.ReactElement> => {
+	const path = args.path || args.file_path || '';
+	const absPath = resolve(path);
+
+	// VS Code preview logic removed
+
+	return <WriteFileFormatter args={args} />;
+};
+
+const writeFileValidator = async (args: {
+	path: string;
+	content: string;
+}): Promise<{ valid: true } | { valid: false; error: string }> => {
+	const absPath = resolve(args.path);
+
+	// Check if parent directory exists
+	const parentDir = dirname(absPath);
+	try {
+		await access(parentDir, constants.F_OK);
+	} catch (error) {
+		if (error && typeof error === 'object' && 'code' in error) {
+			if (error.code === 'ENOENT') {
+				return {
+					valid: false,
+					error: `☕︎ Parent directory does not exist: "${parentDir}"`,
+				};
+			}
+		}
+		const errorMessage =
+			error instanceof Error ? error.message : 'Unknown error';
+		return {
+			valid: false,
+			error: `☕︎ Cannot access parent directory "${parentDir}": ${errorMessage}`,
+		};
+	}
+
+	// Check for invalid path characters or attempts to write to system directories
+	const invalidPatterns = [
+		/^\/etc\//i,
+		/^\/sys\//i,
+		/^\/proc\//i,
+		/^\/dev\//i,
+		/^\/boot\//i,
+		/^C:\\Windows\\/i,
+		/^C:\\Program Files\\/i,
+	];
+
+	for (const pattern of invalidPatterns) {
+		if (pattern.test(absPath)) {
+			return {
+				valid: false,
+				error: `☕︎ Cannot write files to system directory: "${args.path}"`,
+			};
+		}
+	}
+
+	return { valid: true };
+};
+
+export const writeFileTool = {
+	name: 'write_file' as const,
+	tool: writeFileCoreTool,
+	formatter: writeFileFormatter,
+	validator: writeFileValidator,
+};

package/source/types/app.ts

@@ -0,0 +1,37 @@
+import {CustomCommandExecutor} from '@/custom-commands/executor';
+import {CustomCommandLoader} from '@/custom-commands/loader';
+import React from 'react';
+import type {CheckpointListItem} from './checkpoint';
+import type {CustomCommand} from './commands';
+import type {Message} from './core';
+import type {UpdateInfo} from './utils';
+
+export interface MessageSubmissionOptions {
+	customCommandCache: Map<string, CustomCommand>;
+	customCommandLoader: CustomCommandLoader | null;
+	customCommandExecutor: CustomCommandExecutor | null;
+	onClearMessages: () => Promise<void>;
+	onEnterModelSelectionMode: () => void;
+	onEnterProviderSelectionMode: () => void;
+	onEnterThemeSelectionMode: () => void;
+	onEnterModelDatabaseMode: () => void;
+	onEnterConfigWizardMode: () => void;
+	onEnterCheckpointLoadMode: (
+		checkpoints: CheckpointListItem[],
+		currentMessageCount: number,
+	) => void;
+	onShowStatus: () => void;
+	onHandleChatMessage: (message: string) => Promise<void>;
+	onAddToChatQueue: (component: React.ReactNode) => void;
+	onCommandComplete?: () => void;
+	componentKeyCounter: number;
+	setMessages: (messages: Message[]) => void;
+	messages: Message[];
+	setIsBashExecuting: (executing: boolean) => void;
+	setCurrentBashCommand: (command: string) => void;
+	provider: string;
+	model: string;
+	theme: string;
+	updateInfo: UpdateInfo | null;
+	getMessageTokens: (message: Message) => number;
+}

package/source/types/checkpoint.ts

@@ -0,0 +1,48 @@
+import type {Message} from '@/types/core';
+
+export interface CheckpointMetadata {
+	name: string;
+	timestamp: string; // ISO 8601 format
+	messageCount: number;
+	filesChanged: string[]; // Relative file paths
+	provider: {
+		name: string;
+		model: string;
+	};
+	description?: string; // Optional: first message or custom
+	gitCommitHash?: string; // Optional: for future git integration
+}
+
+export interface CheckpointConversation {
+	messages: Message[];
+	toolExecutions?: Array<{
+		tool: string;
+		args: Record<string, unknown>;
+		result: unknown;
+		timestamp: string;
+	}>;
+}
+
+export interface CheckpointData {
+	metadata: CheckpointMetadata;
+	conversation: CheckpointConversation;
+	fileSnapshots: Map<string, string>;
+}
+
+export interface CheckpointListItem {
+	name: string;
+	metadata: CheckpointMetadata;
+	sizeBytes?: number;
+}
+
+export interface CheckpointValidationResult {
+	valid: boolean;
+	errors: string[];
+	warnings?: string[];
+}
+
+export interface CheckpointRestoreOptions {
+	createBackup?: boolean;
+	backupName?: string;
+	validateIntegrity?: boolean;
+}

package/source/types/commands.ts

@@ -0,0 +1,46 @@
+import {Message} from '@/types/core';
+
+export interface Command<T = React.ReactElement> {
+	name: string;
+	description: string;
+	handler: (
+		args: string[],
+		messages: Message[],
+		metadata: {
+			provider: string;
+			model: string;
+			tokens: number;
+			getMessageTokens: (message: Message) => number;
+		},
+	) => Promise<T>;
+}
+
+export interface ParsedCommand {
+	isCommand: boolean;
+	command?: string;
+	args?: string[];
+	fullCommand?: string;
+	// Bash command properties
+	isBashCommand?: boolean;
+	bashCommand?: string;
+}
+
+export interface CustomCommandMetadata {
+	description?: string;
+	aliases?: string[];
+	parameters?: string[];
+}
+
+export interface CustomCommand {
+	name: string;
+	path: string;
+	namespace?: string;
+	fullName: string; // e.g., "refactor:dry" or just "test"
+	metadata: CustomCommandMetadata;
+	content: string; // The markdown content without frontmatter
+}
+
+export interface ParsedCustomCommand {
+	metadata: CustomCommandMetadata;
+	content: string;
+}

package/source/types/components.ts

@@ -0,0 +1,27 @@
+import {ReactNode} from 'react';
+
+export interface AssistantMessageProps {
+	message: string;
+	model: string;
+}
+
+export interface BashExecutionIndicatorProps {
+	command: string;
+}
+
+export interface ChatQueueProps {
+	staticComponents?: ReactNode[];
+	queuedComponents?: ReactNode[];
+}
+
+export type Completion = {name: string; isCustom: boolean};
+
+export interface ToolExecutionIndicatorProps {
+	toolName: string;
+	currentIndex: number;
+	totalTools: number;
+}
+
+export interface UserMessageProps {
+	message: string;
+}

package/source/types/config.ts

@@ -0,0 +1,103 @@
+import type {ThemePreset} from '@/types/ui';
+
+// AI provider configurations (OpenAI-compatible)
+export interface AIProviderConfig {
+	name: string;
+	type: string;
+	models: string[];
+	requestTimeout?: number;
+	socketTimeout?: number;
+	maxRetries?: number; // Maximum number of retries for failed requests (default: 2)
+	connectionPool?: {
+		idleTimeout?: number;
+		cumulativeMaxIdleTimeout?: number;
+	};
+	config: {
+		baseURL?: string;
+		apiKey?: string;
+		[key: string]: unknown;
+	};
+}
+
+// Provider configuration type for wizard and config building
+export interface ProviderConfig {
+	name: string;
+	baseUrl?: string;
+	apiKey?: string;
+	models: string[];
+	requestTimeout?: number;
+	socketTimeout?: number;
+	maxRetries?: number; // Maximum number of retries for failed requests (default: 2)
+	organizationId?: string;
+	timeout?: number;
+	connectionPool?: {
+		idleTimeout?: number;
+		cumulativeMaxIdleTimeout?: number;
+	};
+	[key: string]: unknown; // Allow additional provider-specific config
+}
+
+export interface AppConfig {
+	// Providers array structure - all OpenAI compatible
+	providers?: {
+		name: string;
+		baseUrl?: string;
+		apiKey?: string;
+		models: string[];
+		requestTimeout?: number;
+		socketTimeout?: number;
+		maxRetries?: number; // Maximum number of retries for failed requests (default: 2)
+		connectionPool?: {
+			idleTimeout?: number;
+			cumulativeMaxIdleTimeout?: number;
+		};
+		[key: string]: unknown; // Allow additional provider-specific config
+	}[];
+
+	mcpServers?: {
+		name: string;
+		transport: 'stdio' | 'websocket' | 'http';
+		command?: string;
+		args?: string[];
+		env?: Record<string, string>;
+		url?: string;
+		headers?: Record<string, string>;
+		auth?: {
+			type: 'bearer' | 'basic' | 'api-key' | 'custom';
+			token?: string;
+			username?: string;
+			password?: string;
+			apiKey?: string;
+			customHeaders?: Record<string, string>;
+		};
+		timeout?: number;
+		reconnect?: {
+			enabled: boolean;
+			maxAttempts: number;
+			backoffMs: number;
+		};
+		description?: string;
+		tags?: string[];
+		enabled?: boolean;
+	}[];
+
+	// LSP server configurations (optional - auto-discovery enabled by default)
+	lspServers?: {
+		name: string;
+		command: string;
+		args?: string[];
+		languages: string[]; // File extensions this server handles
+		env?: Record<string, string>;
+	}[];
+}
+
+export interface UserPreferences {
+	lastProvider?: string;
+	lastModel?: string;
+	providerModels?: {
+		[key in string]?: string;
+	};
+	lastUpdateCheck?: number;
+	selectedTheme?: ThemePreset;
+	trustedDirectories?: string[];
+}

package/source/types/core-connection-status.spec.ts

@@ -0,0 +1,67 @@
+import type {
+	ConnectionStatus,
+	LSPConnectionStatus,
+	MCPConnectionStatus,
+} from '@/types/core';
+import test from 'ava';
+
+test('MCPConnectionStatus type structure', t => {
+	const status: MCPConnectionStatus = {
+		name: 'test-server',
+		status: 'connected',
+	};
+
+	t.is(status.name, 'test-server');
+	t.is(status.status, 'connected');
+	t.is(status.errorMessage, undefined);
+});
+
+test('MCPConnectionStatus with error', t => {
+	const status: MCPConnectionStatus = {
+		name: 'failed-server',
+		status: 'failed',
+		errorMessage: 'Connection timeout',
+	};
+
+	t.is(status.name, 'failed-server');
+	t.is(status.status, 'failed');
+	t.is(status.errorMessage, 'Connection timeout');
+});
+
+test('LSPConnectionStatus type structure', t => {
+	const status: LSPConnectionStatus = {
+		name: 'ts-language-server',
+		status: 'connected',
+	};
+
+	t.is(status.name, 'ts-language-server');
+	t.is(status.status, 'connected');
+	t.is(status.errorMessage, undefined);
+});
+
+test('ConnectionStatus union type', t => {
+	const validStatuses: ConnectionStatus[] = ['connected', 'failed', 'pending'];
+
+	validStatuses.forEach(status => {
+		t.true(['connected', 'failed', 'pending'].includes(status));
+	});
+});
+
+test('Connection status filtering', t => {
+	const mcpStatuses: MCPConnectionStatus[] = [
+		{name: 'server1', status: 'connected'},
+		{name: 'server2', status: 'failed', errorMessage: 'Timeout'},
+		{name: 'server3', status: 'pending'},
+	];
+
+	const connected = mcpStatuses.filter(s => s.status === 'connected');
+	const failed = mcpStatuses.filter(s => s.status === 'failed');
+	const pending = mcpStatuses.filter(s => s.status === 'pending');
+
+	t.is(connected.length, 1);
+	t.is(failed.length, 1);
+	t.is(pending.length, 1);
+	t.is(connected[0].name, 'server1');
+	t.is(failed[0].errorMessage, 'Timeout');
+	t.is(pending[0].name, 'server3');
+});