@gguf/coder 0.3.0 → 0.3.1

package/source/command-parser.spec.ts

@@ -0,0 +1,127 @@
+import test from 'ava';
+import { parseInput } from './command-parser';
+
+test('parseInput - parses bash commands with ! prefix', t => {
+	const result = parseInput('!ls -la');
+
+	t.false(result.isCommand);
+	t.true(result.isBashCommand);
+	t.is(result.bashCommand, 'ls -la');
+});
+
+test('parseInput - handles empty bash command', t => {
+	const result = parseInput('!');
+
+	t.false(result.isCommand);
+	t.true(result.isBashCommand);
+	t.is(result.bashCommand, '');
+});
+
+test('parseInput - handles bash command with spaces', t => {
+	const result = parseInput('!   echo "hello world"   ');
+
+	t.false(result.isCommand);
+	t.true(result.isBashCommand);
+	t.is(result.bashCommand, '   echo "hello world"');
+});
+
+test('parseInput - returns non-command for text without prefix', t => {
+	const result = parseInput('Hello world');
+
+	t.false(result.isCommand);
+	t.is(result.isBashCommand, undefined);
+});
+
+test('parseInput - parses regular commands with / prefix', t => {
+	const result = parseInput('/command arg1 arg2');
+
+	t.true(result.isCommand);
+	t.is(result.isBashCommand, undefined);
+	t.is(result.command, 'command');
+	t.deepEqual(result.args, ['arg1', 'arg2']);
+	t.is(result.fullCommand, 'command arg1 arg2');
+});
+
+test('parseInput - handles empty command', t => {
+	const result = parseInput('/');
+
+	t.true(result.isCommand);
+	t.is(result.isBashCommand, undefined);
+	t.is(result.command, '');
+	t.deepEqual(result.args, []);
+	t.is(result.fullCommand, '');
+});
+
+test('parseInput - handles command without arguments', t => {
+	const result = parseInput('/help');
+
+	t.true(result.isCommand);
+	t.is(result.isBashCommand, undefined);
+	t.is(result.command, 'help');
+	t.deepEqual(result.args, []);
+	t.is(result.fullCommand, 'help');
+});
+
+test('parseInput - handles command with single argument', t => {
+	const result = parseInput('/init my-project');
+
+	t.true(result.isCommand);
+	t.is(result.isBashCommand, undefined);
+	t.is(result.command, 'init');
+	t.deepEqual(result.args, ['my-project']);
+	t.is(result.fullCommand, 'init my-project');
+});
+
+test('parseInput - handles multiple whitespace between arguments', t => {
+	const result = parseInput('/test    arg1     arg2');
+
+	t.true(result.isCommand);
+	t.is(result.isBashCommand, undefined);
+	t.is(result.command, 'test');
+	t.deepEqual(result.args, ['arg1', 'arg2']);
+	t.is(result.fullCommand, 'test    arg1     arg2');
+});
+
+test('parseInput - trims whitespace from input', t => {
+	const result = parseInput('   /command arg1   ');
+
+	t.true(result.isCommand);
+	t.is(result.isBashCommand, undefined);
+	t.is(result.command, 'command');
+	t.deepEqual(result.args, ['arg1']);
+	t.is(result.fullCommand, 'command arg1');
+});
+
+test('parseInput - handles empty string input', t => {
+	const result = parseInput('');
+
+	t.false(result.isCommand);
+	t.is(result.isBashCommand, undefined);
+});
+
+test('parseInput - handles whitespace-only input', t => {
+	const result = parseInput('   ');
+
+	t.false(result.isCommand);
+	t.is(result.isBashCommand, undefined);
+});
+
+test('parseInput - handles / followed by whitespace', t => {
+	const result = parseInput('/   ');
+
+	t.true(result.isCommand);
+	t.is(result.isBashCommand, undefined);
+	t.is(result.command, '');
+	t.deepEqual(result.args, []);
+	t.is(result.fullCommand, '');
+});
+
+test('parseInput - preserves argument case and special characters', t => {
+	const result = parseInput('/echo "Hello World" --flag=value');
+
+	t.true(result.isCommand);
+	t.is(result.isBashCommand, undefined);
+	t.is(result.command, 'echo');
+	t.deepEqual(result.args, ['"Hello', 'World"', '--flag=value']);
+	t.is(result.fullCommand, 'echo "Hello World" --flag=value');
+});

package/source/command-parser.ts

@@ -0,0 +1,36 @@
+import type {ParsedCommand} from '@/types/index';
+
+export function parseInput(input: string): ParsedCommand {
+	const trimmed = input.trim();
+
+	// Check for bash command (prefixed with !)
+	if (trimmed.startsWith('!')) {
+		const bashCommand = trimmed.slice(1);
+		return {
+			isCommand: false, // Not a regular command
+			isBashCommand: true,
+			bashCommand: bashCommand,
+		};
+	}
+
+	// Check for regular command (prefixed with /)
+	if (!trimmed.startsWith('/')) {
+		return {isCommand: false};
+	}
+
+	const commandText = trimmed.slice(1);
+	if (!commandText) {
+		return {isCommand: true, command: '', args: [], fullCommand: ''};
+	}
+
+	const parts = commandText.split(/\s+/);
+	const command = parts[0];
+	const args = parts.slice(1);
+
+	return {
+		isCommand: true,
+		command,
+		args,
+		fullCommand: commandText,
+	};
+}

package/source/commands/checkpoint.spec.tsx

@@ -0,0 +1,277 @@
+import {renderWithTheme} from '@/test-utils/render-with-theme';
+import type {Message} from '@/types/core';
+import test from 'ava';
+import React from 'react';
+import {checkpointCommand} from './checkpoint';
+
+// Helper to create mock messages
+function createMockMessages(count: number): Message[] {
+	const messages: Message[] = [];
+	for (let i = 0; i < count; i++) {
+		messages.push({
+			role: i % 2 === 0 ? 'user' : 'assistant',
+			content: `Message ${i + 1}`,
+		});
+	}
+	return messages;
+}
+
+const mockMetadata = {
+	provider: 'TestProvider',
+	model: 'test-model',
+};
+
+// Command metadata tests
+test('checkpointCommand has correct name', t => {
+	t.is(checkpointCommand.name, 'checkpoint');
+});
+
+test('checkpointCommand has description', t => {
+	t.truthy(checkpointCommand.description);
+	t.true(checkpointCommand.description.length > 0);
+});
+
+test('checkpointCommand has handler function', t => {
+	t.is(typeof checkpointCommand.handler, 'function');
+});
+
+// Help command tests
+test('checkpointCommand shows help with no arguments', async t => {
+	const result = await checkpointCommand.handler([], [], mockMetadata);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	t.true(output.includes('Checkpoint Commands'));
+});
+
+test('checkpointCommand shows help with help argument', async t => {
+	const result = await checkpointCommand.handler(['help'], [], mockMetadata);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	t.true(output.includes('Checkpoint Commands'));
+	t.true(output.includes('/checkpoint create'));
+	t.true(output.includes('/checkpoint list'));
+	t.true(output.includes('/checkpoint load'));
+	t.true(output.includes('/checkpoint delete'));
+});
+
+test('checkpointCommand shows help with --help flag', async t => {
+	const result = await checkpointCommand.handler(['--help'], [], mockMetadata);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	t.true(output.includes('Checkpoint Commands'));
+});
+
+test('checkpointCommand shows help with -h flag', async t => {
+	const result = await checkpointCommand.handler(['-h'], [], mockMetadata);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	t.true(output.includes('Checkpoint Commands'));
+});
+
+// Create subcommand tests
+test('checkpointCommand create warns when no messages', async t => {
+	const result = await checkpointCommand.handler(['create'], [], mockMetadata);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	t.true(output.includes('No messages to checkpoint'));
+});
+
+test('checkpointCommand create alias "save" works', async t => {
+	const result = await checkpointCommand.handler(['save'], [], mockMetadata);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	t.true(output.includes('No messages to checkpoint'));
+});
+
+// List subcommand tests
+test('checkpointCommand list shows checkpoints', async t => {
+	const result = await checkpointCommand.handler(['list'], [], mockMetadata);
+	// Just verify it returns something (actual checkpoints depend on state)
+	t.truthy(result);
+});
+
+test('checkpointCommand list alias "ls" works', async t => {
+	const result = await checkpointCommand.handler(['ls'], [], mockMetadata);
+	t.truthy(result);
+});
+
+// Load subcommand tests
+test('checkpointCommand load with non-existent checkpoint shows error', async t => {
+	const messages = createMockMessages(2);
+	const result = await checkpointCommand.handler(
+		['load', 'non-existent-checkpoint-xyz'],
+		messages,
+		mockMetadata,
+	);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	t.true(output.includes('does not exist'));
+});
+
+test('checkpointCommand load alias "restore" works', async t => {
+	const messages = createMockMessages(2);
+	const result = await checkpointCommand.handler(
+		['restore', 'non-existent'],
+		messages,
+		mockMetadata,
+	);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	t.true(output.includes('does not exist'));
+});
+
+// Delete subcommand tests
+test('checkpointCommand delete requires name', async t => {
+	const result = await checkpointCommand.handler(['delete'], [], mockMetadata);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	t.true(output.includes('specify a checkpoint name'));
+});
+
+test('checkpointCommand delete with non-existent checkpoint shows error', async t => {
+	const result = await checkpointCommand.handler(
+		['delete', 'non-existent-checkpoint-xyz'],
+		[],
+		mockMetadata,
+	);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	t.true(output.includes('does not exist'));
+});
+
+test('checkpointCommand delete alias "remove" works', async t => {
+	const result = await checkpointCommand.handler(
+		['remove', 'non-existent'],
+		[],
+		mockMetadata,
+	);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	t.true(output.includes('does not exist'));
+});
+
+test('checkpointCommand delete alias "rm" works', async t => {
+	const result = await checkpointCommand.handler(
+		['rm', 'non-existent'],
+		[],
+		mockMetadata,
+	);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	t.true(output.includes('does not exist'));
+});
+
+// Unknown subcommand tests
+test('checkpointCommand shows error for unknown subcommand', async t => {
+	const result = await checkpointCommand.handler(['unknown'], [], mockMetadata);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	t.true(output.includes('Unknown checkpoint subcommand'));
+	t.true(output.includes('unknown'));
+	t.true(output.includes('/checkpoint help'));
+});
+
+test('checkpointCommand handles subcommand case-insensitively', async t => {
+	const result1 = await checkpointCommand.handler(['HELP'], [], mockMetadata);
+	const result2 = await checkpointCommand.handler(['Help'], [], mockMetadata);
+	const result3 = await checkpointCommand.handler(['LIST'], [], mockMetadata);
+
+	const {lastFrame: frame1} = renderWithTheme(result1 as React.ReactElement);
+	const {lastFrame: frame2} = renderWithTheme(result2 as React.ReactElement);
+
+	t.true((frame1() || '').includes('Checkpoint Commands'));
+	t.true((frame2() || '').includes('Checkpoint Commands'));
+	t.truthy(result3); // Just verify it doesn't throw
+});
+
+// Multiple word checkpoint name tests
+test('checkpointCommand delete handles multi-word names', async t => {
+	const result = await checkpointCommand.handler(
+		['delete', 'my', 'checkpoint', 'name'],
+		[],
+		mockMetadata,
+	);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	// Should join the words and look for "my checkpoint name"
+	t.true(output.includes('my checkpoint name'));
+});
+
+test('checkpointCommand load handles multi-word names', async t => {
+	const result = await checkpointCommand.handler(
+		['load', 'my', 'checkpoint', 'name'],
+		[],
+		mockMetadata,
+	);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	t.true(output.includes('my checkpoint name'));
+});
+
+// Handler returns React elements
+test('checkpointCommand handler returns React element', async t => {
+	const result = await checkpointCommand.handler(['help'], [], mockMetadata);
+	t.true(React.isValidElement(result));
+});
+
+test('checkpointCommand create handler returns React element', async t => {
+	const result = await checkpointCommand.handler(['create'], [], mockMetadata);
+	t.true(React.isValidElement(result));
+});
+
+test('checkpointCommand list handler returns React element', async t => {
+	const result = await checkpointCommand.handler(['list'], [], mockMetadata);
+	t.true(React.isValidElement(result));
+});
+
+test('checkpointCommand delete handler returns React element', async t => {
+	const result = await checkpointCommand.handler(['delete'], [], mockMetadata);
+	t.true(React.isValidElement(result));
+});
+
+// Verify help content is comprehensive
+test('checkpointCommand help includes all subcommands', async t => {
+	const result = await checkpointCommand.handler(['help'], [], mockMetadata);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	// Check for create subcommand
+	t.true(output.includes('create'));
+	t.true(output.includes('snapshot'));
+
+	// Check for list subcommand
+	t.true(output.includes('list'));
+
+	// Check for load subcommand
+	t.true(output.includes('load'));
+	t.true(output.includes('restore') || output.includes('Interactive'));
+
+	// Check for delete subcommand
+	t.true(output.includes('delete'));
+
+	// Check for help subcommand
+	t.true(output.includes('help'));
+});
+
+test('checkpointCommand help includes examples', async t => {
+	const result = await checkpointCommand.handler(['help'], [], mockMetadata);
+	const {lastFrame} = renderWithTheme(result as React.ReactElement);
+	const output = lastFrame() || '';
+
+	t.true(output.includes('Example'));
+});