@gguf/coder 0.3.1 → 0.3.2

package/source/commands/checkpoint.tsx

@@ -1,366 +0,0 @@
-import {CheckpointListDisplay} from '@/components/checkpoint-display';
-import {
-	ErrorMessage,
-	InfoMessage,
-	SuccessMessage,
-	WarningMessage,
-} from '@/components/message-box';
-import {CheckpointManager} from '@/services/checkpoint-manager';
-import {Command, Message} from '@/types/index';
-import {addToMessageQueue} from '@/utils/message-queue';
-import React from 'react';
-
-// Default checkpoint manager instance (lazy-initialized)
-let defaultCheckpointManager: CheckpointManager | null = null;
-
-/**
- * Get or create the default checkpoint manager.
- * For testing, use createCheckpointCommand() with a custom manager.
- */
-function getDefaultCheckpointManager(): CheckpointManager {
-	if (!defaultCheckpointManager) {
-		defaultCheckpointManager = new CheckpointManager();
-	}
-	return defaultCheckpointManager;
-}
-
-/**
- * Show checkpoint command help
- */
-function CheckpointHelp() {
-	return (
-		<InfoMessage
-			message={`Checkpoint Commands:
-
-/checkpoint create [name] - Create a new checkpoint
-  • Creates a snapshot of current conversation and modified files
-  • Auto-generates timestamped name if not provided
-  • Example: /checkpoint create feature-auth-v1
-
-/checkpoint list - List all available checkpoints
-  • Shows checkpoint name, creation time, message count, and files changed
-
-/checkpoint load - Interactive checkpoint selection and restore
-  • Choose from available checkpoints
-  • Shows confirmation before restoring
-  • Optionally creates backup of current session
-
-/checkpoint delete <name> - Delete a specific checkpoint
-  • Permanently removes checkpoint and all its data
-  • Shows confirmation before deletion
-
-/checkpoint help - Show this help message
-
-Note: Checkpoints are stored in your coder config directory.`}
-			hideBox={false}
-		/>
-	);
-}
-
-/**
- * Create checkpoint subcommand
- */
-async function createCheckpoint(
-	args: string[],
-	messages: Message[],
-	metadata: {provider: string; model: string},
-): Promise<React.ReactElement> {
-	try {
-		const manager = getDefaultCheckpointManager();
-		const name = args.length > 0 ? args.join(' ') : undefined;
-
-		if (messages.length === 0) {
-			return React.createElement(WarningMessage, {
-				key: `warning-${Date.now()}`,
-				message: 'No messages to checkpoint. Start a conversation first.',
-				hideBox: true,
-			});
-		}
-
-		const checkpointMetadata = await manager.saveCheckpoint(
-			name,
-			messages,
-			metadata.provider,
-			metadata.model,
-		);
-
-		return React.createElement(SuccessMessage, {
-			key: `success-${Date.now()}`,
-			message: `Checkpoint '${checkpointMetadata.name}' created successfully
-  └─ ${checkpointMetadata.messageCount} messages saved
-  └─ ${
-		checkpointMetadata.filesChanged.length
-	} files captured: ${checkpointMetadata.filesChanged.slice(0, 3).join(', ')}${
-		checkpointMetadata.filesChanged.length > 3 ? '...' : ''
-	}
-  └─ Provider: ${checkpointMetadata.provider.name} (${
-		checkpointMetadata.provider.model
-	})`,
-			hideBox: true,
-		});
-	} catch (error) {
-		return React.createElement(ErrorMessage, {
-			key: `error-${Date.now()}`,
-			message: `Failed to create checkpoint: ${
-				error instanceof Error ? error.message : 'Unknown error'
-			}`,
-			hideBox: true,
-		});
-	}
-}
-
-/**
- * List checkpoints subcommand
- */
-async function listCheckpoints(): Promise<React.ReactElement> {
-	try {
-		const manager = getDefaultCheckpointManager();
-		const checkpoints = await manager.listCheckpoints();
-
-		return React.createElement(CheckpointListDisplay, {
-			key: `list-${Date.now()}`,
-			checkpoints,
-		});
-	} catch (error) {
-		return React.createElement(ErrorMessage, {
-			key: `error-${Date.now()}`,
-			message: `Failed to list checkpoints: ${
-				error instanceof Error ? error.message : 'Unknown error'
-			}`,
-			hideBox: true,
-		});
-	}
-}
-
-/**
- * Load checkpoint subcommand
- */
-async function loadCheckpoint(
-	args: string[],
-	messages: Message[],
-	metadata: {provider: string; model: string},
-): Promise<React.ReactElement> {
-	try {
-		const manager = getDefaultCheckpointManager();
-		const checkpointName = args.join(' ');
-
-		if (checkpointName) {
-			if (!manager.checkpointExists(checkpointName)) {
-				return React.createElement(ErrorMessage, {
-					key: `error-${Date.now()}`,
-					message: `Checkpoint '${checkpointName}' does not exist. Use /checkpoint list to see available checkpoints.`,
-					hideBox: true,
-				});
-			}
-
-			const checkpointData = await manager.loadCheckpoint(checkpointName, {
-				validateIntegrity: true,
-			});
-
-			await manager.restoreFiles(checkpointData);
-
-			return React.createElement(
-				React.Fragment,
-				{key: `load-success-${Date.now()}`},
-				React.createElement(SuccessMessage, {
-					key: 'success',
-					message: `✓ Checkpoint '${checkpointName}' files restored successfully`,
-					hideBox: true,
-				}),
-				React.createElement(InfoMessage, {
-					key: 'details',
-					message: `Restored checkpoint:
-  • ${checkpointData.fileSnapshots.size} file(s) restored to workspace
-  • Provider: ${checkpointData.metadata.provider.name} (${
-		checkpointData.metadata.provider.model
-	})
-  • Created: ${new Date(checkpointData.metadata.timestamp).toLocaleString()}`,
-					hideBox: true,
-				}),
-			);
-		}
-
-		const checkpoints = await manager.listCheckpoints();
-
-		if (checkpoints.length === 0) {
-			return React.createElement(InfoMessage, {
-				key: `info-${Date.now()}`,
-				message:
-					'No checkpoints available. Create one with /checkpoint create [name]',
-				hideBox: true,
-			});
-		}
-
-		const CheckpointSelector = (
-			await import('@/components/checkpoint-selector')
-		).default;
-
-		const handleError = (error: Error) => {
-			addToMessageQueue(
-				React.createElement(ErrorMessage, {
-					key: `restore-error-${Date.now()}`,
-					message: `Failed to restore checkpoint: ${error.message}`,
-					hideBox: true,
-				}),
-			);
-		};
-
-		return React.createElement(CheckpointSelector, {
-			key: `selector-${Date.now()}`,
-			checkpoints,
-			currentMessageCount: messages.length,
-			onSelect: (selectedName: string, createBackup: boolean) => {
-				void (async () => {
-					try {
-						if (createBackup) {
-							try {
-								await manager.saveCheckpoint(
-									`backup-${new Date().toISOString().replace(/[:.]/g, '-')}`,
-									messages,
-									metadata.provider,
-									metadata.model,
-								);
-							} catch (error) {
-								// Show backup error but continue with restore
-								addToMessageQueue(
-									React.createElement(WarningMessage, {
-										key: `backup-warning-${Date.now()}`,
-										message: `Warning: Failed to create backup: ${
-											error instanceof Error ? error.message : 'Unknown error'
-										}`,
-										hideBox: true,
-									}),
-								);
-							}
-						}
-
-						const checkpointData = await manager.loadCheckpoint(selectedName, {
-							validateIntegrity: true,
-						});
-
-						await manager.restoreFiles(checkpointData);
-
-						addToMessageQueue(
-							React.createElement(SuccessMessage, {
-								key: `restore-success-${Date.now()}`,
-								message: `✓ Checkpoint '${selectedName}' restored successfully`,
-								hideBox: true,
-							}),
-						);
-					} catch (error) {
-						handleError(
-							error instanceof Error ? error : new Error('Unknown error'),
-						);
-					}
-				})();
-			},
-			onCancel: () => {
-				// Nothing to do, component will unmount
-			},
-			onError: handleError,
-		});
-	} catch (error) {
-		return React.createElement(ErrorMessage, {
-			key: `error-${Date.now()}`,
-			message: `Failed to load checkpoint: ${
-				error instanceof Error ? error.message : 'Unknown error'
-			}`,
-			hideBox: true,
-		});
-	}
-}
-
-/**
- * Delete checkpoint subcommand
- */
-async function deleteCheckpoint(args: string[]): Promise<React.ReactElement> {
-	try {
-		if (args.length === 0) {
-			return React.createElement(ErrorMessage, {
-				key: `error-${Date.now()}`,
-				message:
-					'Please specify a checkpoint name to delete. Usage: /checkpoint delete <name>',
-				hideBox: true,
-			});
-		}
-
-		const manager = getDefaultCheckpointManager();
-		const checkpointName = args.join(' ');
-
-		if (!manager.checkpointExists(checkpointName)) {
-			return React.createElement(ErrorMessage, {
-				key: `error-${Date.now()}`,
-				message: `Checkpoint '${checkpointName}' does not exist. Use /checkpoint list to see available checkpoints.`,
-				hideBox: true,
-			});
-		}
-
-		// Actually delete the checkpoint
-		await manager.deleteCheckpoint(checkpointName);
-
-		// Show success with what was deleted
-		return React.createElement(SuccessMessage, {
-			key: `delete-success-${Date.now()}`,
-			message: `✓ Checkpoint '${checkpointName}' deleted successfully`,
-			hideBox: true,
-		});
-	} catch (error) {
-		return React.createElement(ErrorMessage, {
-			key: `error-${Date.now()}`,
-			message: `Failed to delete checkpoint: ${
-				error instanceof Error ? error.message : 'Unknown error'
-			}`,
-			hideBox: true,
-		});
-	}
-}
-
-/**
- * Main checkpoint command handler
- */
-export const checkpointCommand: Command = {
-	name: 'checkpoint',
-	description:
-		'Manage conversation checkpoints - save and restore session snapshots',
-	handler: async (args: string[], messages: Message[], metadata) => {
-		if (args.length === 0) {
-			return checkpointCommand.handler(['help'], messages, metadata);
-		}
-
-		const subcommand = args[0].toLowerCase();
-		const subArgs = args.slice(1);
-
-		switch (subcommand) {
-			case 'create':
-			case 'save':
-				return await createCheckpoint(subArgs, messages, metadata);
-
-			case 'list':
-			case 'ls':
-				return await listCheckpoints();
-
-			case 'load':
-			case 'restore':
-				return await loadCheckpoint(subArgs, messages, metadata);
-
-			case 'delete':
-			case 'remove':
-			case 'rm':
-				return await deleteCheckpoint(subArgs);
-
-			case 'help':
-			case '--help':
-			case '-h':
-				return React.createElement(CheckpointHelp, {
-					key: `help-${Date.now()}`,
-				});
-
-			default:
-				return React.createElement(ErrorMessage, {
-					key: `error-${Date.now()}`,
-					message: `Unknown checkpoint subcommand: ${subcommand}. Use /checkpoint help for available commands.`,
-					hideBox: true,
-				});
-		}
-	},
-};

package/source/commands/clear.tsx

@@ -1,22 +0,0 @@
-import {SuccessMessage} from '@/components/message-box';
-import {Command} from '@/types/index';
-import React from 'react';
-
-function Clear() {
-	return (
-		<SuccessMessage hideBox={true} message="Chat Cleared."></SuccessMessage>
-	);
-}
-
-export const clearCommand: Command = {
-	name: 'clear',
-	description: 'Clear the chat history and model context',
-	handler: (_args: string[]) => {
-		// Return info message saying chat was cleared
-		return Promise.resolve(
-			React.createElement(Clear, {
-				key: `clear-${Date.now()}`,
-			}),
-		);
-	},
-};

package/source/commands/custom-commands.tsx

@@ -1,121 +0,0 @@
-import {TitledBox} from '@/components/ui/titled-box';
-import {CustomCommandLoader} from '@/custom-commands/loader';
-import {useTheme} from '@/hooks/useTheme';
-import type {Command, CustomCommand} from '@/types/index';
-import {Box, Text} from 'ink';
-import React from 'react';
-
-interface CustomCommandsProps {
-	commands: CustomCommand[];
-}
-
-function formatCommand(cmd: CustomCommand): string {
-	const parts: string[] = [`/${cmd.fullName}`];
-
-	if (cmd.metadata.parameters && cmd.metadata.parameters.length > 0) {
-		parts.push(cmd.metadata.parameters.map((p: string) => `<${p}>`).join(' '));
-	}
-
-	if (cmd.metadata.description) {
-		parts.push(`- ${cmd.metadata.description}`);
-	}
-
-	if (cmd.metadata.aliases && cmd.metadata.aliases.length > 0) {
-		const aliasNames = cmd.metadata.aliases.map((a: string) =>
-			cmd.namespace ? `${cmd.namespace}:${a}` : a,
-		);
-		parts.push(`(aliases: ${aliasNames.join(', ')})`);
-	}
-
-	return parts.join(' ');
-}
-
-function CustomCommands({commands}: CustomCommandsProps) {
-	const {colors} = useTheme();
-	// Sort commands alphabetically by full name
-	const sortedCommands = [...commands].sort((a, b) =>
-		a.fullName.localeCompare(b.fullName),
-	);
-
-	return (
-		<TitledBox
-			title="Custom Commands"
-			width={75}
-			borderColor={colors.primary}
-			paddingX={2}
-			paddingY={1}
-			flexDirection="column"
-			marginBottom={1}
-		>
-			{commands.length === 0 ? (
-				<>
-					<Box marginBottom={1}>
-						<Text color={colors.white} bold>
-							No custom commands found
-						</Text>
-					</Box>
-
-					<Text color={colors.white}>To create custom commands:</Text>
-
-					<Text color={colors.secondary}>
-						1. Create a <Text color={colors.primary}>.coder/commands</Text>{' '}
-						directory in your project
-					</Text>
-
-					<Text color={colors.secondary}>
-						2. Add <Text color={colors.primary}>.md</Text> files with command
-						prompts
-					</Text>
-
-					<Text color={colors.secondary}>
-						3. Optionally add frontmatter for metadata:
-					</Text>
-
-					<Box marginTop={1} marginBottom={1}>
-						<Text color={colors.secondary}>
-							{`---\n`}
-							{`description: Generate unit tests\n`}
-							{`aliases: [test, unittest]\n`}
-							{`parameters: [filename]\n`}
-							{`---\n`}
-							{`Generate comprehensive unit tests for {{filename}}...`}
-						</Text>
-					</Box>
-				</>
-			) : (
-				<>
-					<Box marginBottom={1}>
-						<Text color={colors.white}>
-							Found {commands.length} custom command
-							{commands.length !== 1 ? 's' : ''}:
-						</Text>
-					</Box>
-
-					{sortedCommands.map((cmd, index) => (
-						<Text key={index} color={colors.white}>
-							• {formatCommand(cmd)}
-						</Text>
-					))}
-				</>
-			)}
-		</TitledBox>
-	);
-}
-
-export const commandsCommand: Command = {
-	name: 'custom-commands',
-	description: 'List all custom commands from .coder/commands',
-	handler: (_args: string[]) => {
-		// Create a custom command loader to get the commands
-		const loader = new CustomCommandLoader();
-		loader.loadCommands();
-		const commands = loader.getAllCommands() || [];
-
-		return Promise.resolve(
-			React.createElement(CustomCommands, {
-				key: `custom-commands-${Date.now()}`,
-				commands: commands,
-			}),
-		);
-	},
-};

package/source/commands/exit.ts

@@ -1,21 +0,0 @@
-import {InfoMessage} from '@/components/message-box';
-import {Command} from '@/types/index';
-import React from 'react';
-
-export const exitCommand: Command = {
-	name: 'exit',
-	description: 'Exit the application',
-	handler: (_args: string[], _messages, _metadata) => {
-		// Return InfoMessage component first, then exit after a short delay
-		setTimeout(() => {
-			process.exit(0);
-		}, 500); // 500ms delay to allow message to render
-
-		return Promise.resolve(
-			React.createElement(InfoMessage, {
-				message: 'Goodbye! 👋',
-				hideTitle: true,
-			}),
-		);
-	},
-};

package/source/commands/export.spec.tsx

@@ -1,131 +0,0 @@
-import test from 'ava';
-import type {Message} from '@/types/index';
-import {exportCommand} from './export';
-import {promises as fs} from 'fs';
-import React from 'react';
-
-// Mock fs module
-const originalWriteFile = fs.writeFile;
-let mockWriteFileCalls: Array<{path: string; content: string}> = [];
-
-test.beforeEach(() => {
-	mockWriteFileCalls = [];
-	fs.writeFile = async (filepath: string, content: string) => {
-		mockWriteFileCalls.push({path: filepath, content});
-		return Promise.resolve(void 0);
-	};
-});
-
-test.afterEach(() => {
-	fs.writeFile = originalWriteFile;
-});
-
-const testMessages: Message[] = [
-	{role: 'user', content: 'Hello'},
-	{role: 'assistant', content: 'Hi there', tool_calls: undefined},
-	{role: 'tool', name: 'test', content: 'Tool result'},
-	{role: 'system', content: 'System message'},
-];
-
-const testMetadata = {
-	provider: 'test-provider',
-	model: 'test-model',
-	tokens: 100,
-	getMessageTokens: (m: Message) => 0,
-};
-
-test('exportCommand has correct name and description', t => {
-	t.is(exportCommand.name, 'export');
-	t.is(exportCommand.description, 'Export the chat history to a markdown file');
-});
-
-test('exportCommand handler returns React element', async t => {
-	const result = await exportCommand.handler([], testMessages, testMetadata);
-	t.truthy(React.isValidElement(result));
-});
-
-test('exportCommand uses provided filename', async t => {
-	await exportCommand.handler(['custom-export.md'], testMessages, testMetadata);
-
-	t.is(mockWriteFileCalls.length, 1);
-	t.true(mockWriteFileCalls[0].path.includes('custom-export.md'));
-});
-
-test('exportCommand generates default filename when none provided', async t => {
-	await exportCommand.handler([], testMessages, testMetadata);
-
-	t.is(mockWriteFileCalls.length, 1);
-	t.true(mockWriteFileCalls[0].path.includes('coder-chat-'));
-	t.true(mockWriteFileCalls[0].path.endsWith('.md'));
-});
-
-test('exportCommand includes frontmatter in export', async t => {
-	await exportCommand.handler(['test.md'], testMessages, testMetadata);
-
-	const content = mockWriteFileCalls[0].content;
-	t.true(content.includes('session_date:'));
-	t.true(content.includes('provider: test-provider'));
-	t.true(content.includes('model: test-model'));
-	t.true(content.includes('total_tokens: 100'));
-});
-
-test('exportCommand formats user messages correctly', async t => {
-	const messages: Message[] = [{role: 'user', content: 'Hello world'}];
-	await exportCommand.handler(['test.md'], messages, testMetadata);
-
-	const content = mockWriteFileCalls[0].content;
-	t.true(content.includes('## User'));
-	t.true(content.includes('Hello world'));
-});
-
-test('exportCommand formats assistant messages correctly', async t => {
-	const messages: Message[] = [{role: 'assistant', content: 'Assistant response'}];
-	await exportCommand.handler(['test.md'], messages, testMetadata);
-
-	const content = mockWriteFileCalls[0].content;
-	t.true(content.includes('## Assistant'));
-	t.true(content.includes('Assistant response'));
-});
-
-test('exportCommand formats assistant messages with tool calls', async t => {
-	const messages: Message[] = [
-		{
-			role: 'assistant',
-			content: 'Using tools',
-			tool_calls: [
-				{function: {name: 'tool1', arguments: '{}'}, id: '1'},
-				{function: {name: 'tool2', arguments: '{}'}, id: '2'},
-			],
-		},
-	];
-	await exportCommand.handler(['test.md'], messages, testMetadata);
-
-	const content = mockWriteFileCalls[0].content;
-	t.true(content.includes('[tool_use: tool1, tool2]'));
-});
-
-test('exportCommand formats tool messages correctly', async t => {
-	const messages: Message[] = [{role: 'tool', name: 'my_tool', content: 'Tool output'}];
-	await exportCommand.handler(['test.md'], messages, testMetadata);
-
-	const content = mockWriteFileCalls[0].content;
-	t.true(content.includes('## Tool Output: my_tool'));
-	t.true(content.includes('```'));
-	t.true(content.includes('Tool output'));
-});
-
-test('exportCommand excludes system messages', async t => {
-	const messages: Message[] = [{role: 'system', content: 'System instruction'}];
-	await exportCommand.handler(['test.md'], messages, testMetadata);
-
-	const content = mockWriteFileCalls[0].content;
-	t.false(content.includes('System instruction'));
-});
-
-test('exportCommand handles unknown message role', async t => {
-	const messages: Message[] = [{role: 'unknown' as const, content: 'Unknown'}];
-	await exportCommand.handler(['test.md'], messages, testMetadata);
-
-	// Should not throw, just handle gracefully
-	t.is(mockWriteFileCalls.length, 1);
-});