@gguf/coder 0.3.0 → 0.3.1

package/source/commands/checkpoint.tsx

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

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

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

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

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