@gguf/coder 0.2.9 → 0.3.1

package/source/utils/checkpoint-utils.ts

@@ -0,0 +1,92 @@
+/**
+ * Format timestamp to relative time string
+ */
+export function formatRelativeTime(timestamp: string): string {
+	const now = new Date();
+	const checkpointTime = new Date(timestamp);
+	const diffMs = now.getTime() - checkpointTime.getTime();
+	const diffMinutes = Math.floor(diffMs / 60000);
+	const diffHours = Math.floor(diffMinutes / 60);
+	const diffDays = Math.floor(diffHours / 24);
+
+	if (diffMinutes < 1) {
+		return 'Just now';
+	} else if (diffMinutes < 60) {
+		return `${diffMinutes} min${diffMinutes === 1 ? '' : 's'} ago`;
+	} else if (diffHours < 24) {
+		return `${diffHours} hr${diffHours === 1 ? '' : 's'} ago`;
+	} else if (diffDays < 7) {
+		return `${diffDays} day${diffDays === 1 ? '' : 's'} ago`;
+	} else {
+		return checkpointTime.toLocaleDateString();
+	}
+}
+
+/**
+ * Validate checkpoint name for invalid characters and length
+ */
+export function validateCheckpointName(name: string): {
+	valid: boolean;
+	error?: string;
+} {
+	if (!name || name.trim().length === 0) {
+		return {valid: false, error: 'Checkpoint name cannot be empty'};
+	}
+
+	if (name.length > 100) {
+		return {
+			valid: false,
+			error: 'Checkpoint name must be 100 characters or less',
+		};
+	}
+
+	// Check for invalid characters (filesystem-unsafe characters)
+	const invalidChars = /[<>:"/\\|?*]/;
+	if (invalidChars.test(name)) {
+		return {valid: false, error: 'Checkpoint name contains invalid characters'};
+	}
+
+	// Check for reserved names (Windows)
+	const reservedNames = [
+		'CON',
+		'PRN',
+		'AUX',
+		'NUL',
+		'COM1',
+		'COM2',
+		'COM3',
+		'COM4',
+		'COM5',
+		'COM6',
+		'COM7',
+		'COM8',
+		'COM9',
+		'LPT1',
+		'LPT2',
+		'LPT3',
+		'LPT4',
+		'LPT5',
+		'LPT6',
+		'LPT7',
+		'LPT8',
+		'LPT9',
+	];
+	if (reservedNames.includes(name.toUpperCase())) {
+		return {valid: false, error: 'Checkpoint name is reserved by the system'};
+	}
+
+	// Check if name starts or ends with dot or space
+	if (
+		name.startsWith('.') ||
+		name.endsWith('.') ||
+		name.startsWith(' ') ||
+		name.endsWith(' ')
+	) {
+		return {
+			valid: false,
+			error: 'Checkpoint name cannot start or end with a dot or space',
+		};
+	}
+
+	return {valid: true};
+}

package/source/utils/error-formatter.spec.ts

@@ -0,0 +1,169 @@
+import test from 'ava';
+import {formatError} from './error-formatter';
+
+console.log(`\nerror-formatter.spec.ts`);
+
+// Tests for Error instances
+test('formatError - formats standard Error instance', t => {
+	const error = new Error('Something went wrong');
+	const result = formatError(error);
+	t.is(result, 'Something went wrong');
+});
+
+test('formatError - formats Error with empty message', t => {
+	const error = new Error('');
+	const result = formatError(error);
+	t.is(result, '');
+});
+
+test('formatError - formats TypeError instance', t => {
+	const error = new TypeError('Invalid type');
+	const result = formatError(error);
+	t.is(result, 'Invalid type');
+});
+
+test('formatError - formats RangeError instance', t => {
+	const error = new RangeError('Out of range');
+	const result = formatError(error);
+	t.is(result, 'Out of range');
+});
+
+test('formatError - formats SyntaxError instance', t => {
+	const error = new SyntaxError('Unexpected token');
+	const result = formatError(error);
+	t.is(result, 'Unexpected token');
+});
+
+test('formatError - formats custom Error subclass', t => {
+	class CustomError extends Error {
+		constructor(message: string) {
+			super(message);
+			this.name = 'CustomError';
+		}
+	}
+	const error = new CustomError('Custom error message');
+	const result = formatError(error);
+	t.is(result, 'Custom error message');
+});
+
+// Tests for non-Error types
+test('formatError - formats string error', t => {
+	const error = 'Simple error string';
+	const result = formatError(error);
+	t.is(result, 'Simple error string');
+});
+
+test('formatError - formats number error', t => {
+	const error = 404;
+	const result = formatError(error);
+	t.is(result, '404');
+});
+
+test('formatError - formats boolean error', t => {
+	const error = false;
+	const result = formatError(error);
+	t.is(result, 'false');
+});
+
+test('formatError - formats null error', t => {
+	const error = null;
+	const result = formatError(error);
+	t.is(result, 'null');
+});
+
+test('formatError - formats undefined error', t => {
+	const error = undefined;
+	const result = formatError(error);
+	t.is(result, 'undefined');
+});
+
+test('formatError - formats object error', t => {
+	const error = {code: 'ERR_001', message: 'Custom error'};
+	const result = formatError(error);
+	t.is(result, '[object Object]');
+});
+
+test('formatError - formats array error', t => {
+	const error = ['error1', 'error2'];
+	const result = formatError(error);
+	t.is(result, 'error1,error2');
+});
+
+test('formatError - formats object with toString method', t => {
+	const error = {
+		toString() {
+			return 'Custom toString';
+		},
+	};
+	const result = formatError(error);
+	t.is(result, 'Custom toString');
+});
+
+// Edge cases
+test('formatError - formats Error with multiline message', t => {
+	const error = new Error('Line 1\nLine 2\nLine 3');
+	const result = formatError(error);
+	t.is(result, 'Line 1\nLine 2\nLine 3');
+});
+
+test('formatError - formats Error with special characters', t => {
+	const error = new Error('Error: "quoted" \'text\' with\ttabs');
+	const result = formatError(error);
+	t.is(result, 'Error: "quoted" \'text\' with\ttabs');
+});
+
+test('formatError - formats Error with unicode characters', t => {
+	const error = new Error('Error: 日本語 emoji 🚀');
+	const result = formatError(error);
+	t.is(result, 'Error: 日本語 emoji 🚀');
+});
+
+test('formatError - handles Error.cause if present', t => {
+	const error = new Error('Main error');
+	// Note: Error.cause is a modern feature, just test that formatError still works
+	const result = formatError(error);
+	t.is(result, 'Main error');
+});
+
+// Type consistency tests
+test('formatError - always returns string type for Error', t => {
+	const error = new Error('Test');
+	const result = formatError(error);
+	t.is(typeof result, 'string');
+});
+
+test('formatError - always returns string type for non-Error', t => {
+	const error = {custom: 'object'};
+	const result = formatError(error);
+	t.is(typeof result, 'string');
+});
+
+// Real-world scenario tests
+test('formatError - handles JSON parse error', t => {
+	let error: unknown;
+	try {
+		JSON.parse('{invalid}');
+	} catch (e) {
+		error = e;
+	}
+	const result = formatError(error);
+	t.true(result.includes('JSON') || result.includes('Unexpected'));
+});
+
+test('formatError - handles fetch-like error', t => {
+	const error = new Error('Failed to fetch: Network error');
+	const result = formatError(error);
+	t.is(result, 'Failed to fetch: Network error');
+});
+
+test('formatError - handles validation error object', t => {
+	const error = {
+		field: 'email',
+		message: 'Invalid email format',
+		toString() {
+			return `${this.field}: ${this.message}`;
+		},
+	};
+	const result = formatError(error);
+	t.is(result, 'email: Invalid email format');
+});

package/source/utils/error-formatter.ts

@@ -0,0 +1,194 @@
+/**
+ * Enhanced error formatting utilities with structured logging integration
+ * Handles Error instances and unknown error types consistently
+ *
+ * This utility provides comprehensive error analysis and formatting
+ * with integration to the structured logging system for better debugging.
+ */
+
+// Import logging utilities with dependency injection pattern
+import {generateCorrelationId} from '@/utils/logging';
+
+/**
+ * Enhanced error information with structured metadata
+ */
+export interface ErrorInfo {
+	message: string;
+	name?: string;
+	stack?: string;
+	code?: string | number;
+	type: 'Error' | 'String' | 'Object' | 'Unknown';
+	originalType: string;
+	hasStack: boolean;
+	isNetworkError: boolean;
+	isTimeoutError: boolean;
+	isValidationError: boolean;
+	timestamp: string;
+	correlationId?: string;
+	cause?: unknown;
+	context?: Record<string, unknown>;
+}
+
+/**
+ * Format error objects into string messages
+ * Handles Error instances and unknown error types consistently
+ *
+ * This utility eliminates the repeated pattern of:
+ * ```
+ * error instanceof Error ? error.message : String(error)
+ * ```
+ *
+ * @param error - Error of any type (Error instance, string, object, etc.)
+ * @returns Formatted error message string
+ *
+ * @example
+ * try {
+ *   await doSomething();
+ * } catch (error) {
+ *   const message = formatError(error);
+ *   console.error(message);
+ * }
+ */
+export function formatError(error: unknown): string {
+	if (error instanceof Error) {
+		return error.message;
+	}
+	return String(error);
+}
+
+/**
+ * Create comprehensive error information with logging
+ *
+ * @param error - Error of any type
+ * @param context - Additional context information
+ * @param correlationId - Optional correlation ID for tracking
+ * @returns Enhanced error information object
+ */
+export function createErrorInfo(
+	error: unknown,
+	context?: Record<string, unknown>,
+	correlationId?: string,
+): ErrorInfo {
+	const timestamp = new Date().toISOString();
+	const effectiveCorrelationId = correlationId || generateCorrelationId();
+
+	// Determine error type and extract information
+	if (error instanceof Error) {
+		const errorInfo: ErrorInfo = {
+			message: error.message,
+			name: error.name,
+			stack: error.stack,
+			type: 'Error',
+			originalType: error.constructor.name,
+			hasStack: !!error.stack,
+			isNetworkError: isNetworkError(error),
+			isTimeoutError: isTimeoutError(error),
+			isValidationError: isValidationError(error),
+			timestamp,
+			correlationId: effectiveCorrelationId,
+			context,
+		};
+
+		// Extract cause if available
+		if (error.cause) {
+			errorInfo.cause = error.cause;
+		}
+
+		// Extract error code if available
+		const errorCode = extractErrorCode(error);
+		if (errorCode) {
+			errorInfo.code = errorCode;
+		}
+
+		return errorInfo;
+	}
+
+	// Handle non-Error objects
+	const errorType = typeof error;
+	const message = String(error);
+
+	return {
+		message,
+		type:
+			errorType === 'string'
+				? 'String'
+				: errorType === 'object' && error !== null
+					? 'Object'
+					: 'Unknown',
+		originalType: errorType,
+		hasStack: false,
+		isNetworkError: false,
+		isTimeoutError: false,
+		isValidationError: false,
+		timestamp,
+		correlationId: effectiveCorrelationId,
+		context,
+	};
+}
+
+/**
+ * Check if error is a network-related error
+ */
+function isNetworkError(error: Error): boolean {
+	return (
+		error.name === 'NetworkError' ||
+		error.name === 'FetchError' ||
+		error.name === 'ECONNREFUSED' ||
+		error.name === 'ENOTFOUND' ||
+		error.name === 'ECONNRESET' ||
+		error.name === 'ETIMEDOUT' ||
+		error.message.includes('network') ||
+		error.message.includes('fetch') ||
+		error.message.includes('connection')
+	);
+}
+
+/**
+ * Check if error is a timeout error
+ */
+function isTimeoutError(error: Error): boolean {
+	return (
+		error.name === 'TimeoutError' ||
+		error.name === 'ETIMEDOUT' ||
+		error.message.includes('timeout') ||
+		error.message.includes('timed out')
+	);
+}
+
+/**
+ * Check if error is a validation error
+ */
+function isValidationError(error: Error): boolean {
+	return (
+		error.name === 'ValidationError' ||
+		error.name === 'ZodError' ||
+		error.message.includes('validation') ||
+		error.message.includes('invalid') ||
+		error.message.includes('required')
+	);
+}
+
+/**
+ * Extract error code from error object
+ */
+function extractErrorCode(error: Error): string | number | undefined {
+	// Try common properties for error codes
+	if ('status' in error) {
+		// biome-ignore lint/suspicious/noExplicitAny: Dynamic error type
+		return (error as any).status;
+	}
+	if ('statusCode' in error) {
+		// biome-ignore lint/suspicious/noExplicitAny: Dynamic error type
+		return (error as any).statusCode;
+	}
+	if ('code' in error) {
+		// biome-ignore lint/suspicious/noExplicitAny: Dynamic error type
+		return (error as any).code;
+	}
+	if ('errorCode' in error) {
+		// biome-ignore lint/suspicious/noExplicitAny: Dynamic error type
+		return (error as any).errorCode;
+	}
+
+	return undefined;
+}

package/source/utils/file-autocomplete.spec.ts

@@ -0,0 +1,173 @@
+import test from 'ava';
+import {
+	clearFileListCache,
+	getCurrentFileMention,
+} from './file-autocomplete.js';
+import {fuzzyScoreFilePath} from './fuzzy-matching.js';
+
+console.log(`\nfile-autocomplete.spec.ts`);
+
+// Test fuzzyScoreFilePath()
+test('fuzzy score: exact match gets highest score', t => {
+	const score = fuzzyScoreFilePath('app.tsx', 'app.tsx');
+	t.is(score, 1000);
+});
+
+test('fuzzy score: exact filename match', t => {
+	const score = fuzzyScoreFilePath('src/components/app.tsx', 'app.tsx');
+	t.is(score, 900);
+});
+
+test('fuzzy score: path ends with query', t => {
+	const score = fuzzyScoreFilePath('src/components/Button.tsx', 'Button.tsx');
+	// This matches exact filename, so it gets 900 not 850
+	t.is(score, 900);
+});
+
+test('fuzzy score: filename starts with query', t => {
+	const score = fuzzyScoreFilePath('src/components/Button.tsx', 'butt');
+	t.is(score, 800);
+});
+
+test('fuzzy score: path starts with query', t => {
+	const score = fuzzyScoreFilePath('src/components/Button.tsx', 'src/comp');
+	t.is(score, 750);
+});
+
+test('fuzzy score: filename contains query', t => {
+	const score = fuzzyScoreFilePath('src/components/Button.tsx', 'ton');
+	t.is(score, 700);
+});
+
+test('fuzzy score: path contains query', t => {
+	const score = fuzzyScoreFilePath('src/components/Button.tsx', 'compo');
+	// "compo" is a substring in path but doesn't start the path
+	t.is(score, 600);
+});
+
+test('fuzzy score: sequential character match', t => {
+	const score = fuzzyScoreFilePath('src/components/Button.tsx', 'btn');
+	t.true(score > 0 && score < 600);
+});
+
+test('fuzzy score: no match returns 0', t => {
+	const score = fuzzyScoreFilePath('app.tsx', 'xyz');
+	t.is(score, 0);
+});
+
+test('fuzzy score: empty query returns 0', t => {
+	const score = fuzzyScoreFilePath('app.tsx', '');
+	t.is(score, 0);
+});
+
+test('fuzzy score: case insensitive', t => {
+	const score1 = fuzzyScoreFilePath('App.tsx', 'app');
+	const score2 = fuzzyScoreFilePath('app.tsx', 'APP');
+	t.true(score1 > 0);
+	t.true(score2 > 0);
+});
+
+test('fuzzy score: prefers shorter paths', t => {
+	const shortPath = fuzzyScoreFilePath('app.tsx', 'app');
+	const longPath = fuzzyScoreFilePath('src/components/nested/app.tsx', 'app');
+	// Both match filename "app.tsx" starting with "app", so they get same score
+	// The scoring doesn't currently prefer shorter paths
+	t.is(shortPath, longPath);
+});
+
+test('fuzzy score: consecutive matches get bonus', t => {
+	// "but" matches consecutively in "Button"
+	const consecutive = fuzzyScoreFilePath('Button.tsx', 'but');
+	// "btn" requires skipping characters
+	const nonConsecutive = fuzzyScoreFilePath('Button.tsx', 'btn');
+	t.true(consecutive > nonConsecutive);
+});
+
+// Test getCurrentFileMention()
+test('extracts mention at end of string', t => {
+	const result = getCurrentFileMention('Fix @src/app');
+	t.truthy(result);
+	t.is(result!.mention, 'src/app');
+	t.is(result!.startIndex, 4);
+	t.is(result!.endIndex, 12);
+});
+
+test('extracts mention in middle of string', t => {
+	// Cursor at position 15 is right after "x" in ".tsx"
+	const result = getCurrentFileMention('Check @app.tsx please', 14);
+	t.truthy(result);
+	t.is(result!.mention, 'app.tsx');
+	t.is(result!.startIndex, 6);
+});
+
+test('extracts mention with cursor in middle', t => {
+	const result = getCurrentFileMention('Fix @src/ap', 11);
+	t.truthy(result);
+	t.is(result!.mention, 'src/ap');
+});
+
+test('returns null when no @ symbol', t => {
+	const result = getCurrentFileMention('Just regular text');
+	t.is(result, null);
+});
+
+test('returns null when @ is after cursor', t => {
+	const result = getCurrentFileMention('Text @file.txt', 3);
+	t.is(result, null);
+});
+
+test('returns null when @ is followed by space', t => {
+	const result = getCurrentFileMention('Fix @ file.txt');
+	t.is(result, null);
+});
+
+test('strips line range from mention', t => {
+	const result = getCurrentFileMention('Fix @app.tsx:10-20');
+	t.truthy(result);
+	t.is(result!.mention, 'app.tsx');
+});
+
+test('strips single line number from mention', t => {
+	const result = getCurrentFileMention('Fix @app.tsx:10');
+	t.truthy(result);
+	t.is(result!.mention, 'app.tsx');
+});
+
+test('handles multiple @ symbols', t => {
+	const result = getCurrentFileMention('Compare @a.ts and @b.ts', 24);
+	t.truthy(result);
+	t.is(result!.mention, 'b.ts');
+});
+
+test('handles @ at start of string', t => {
+	const result = getCurrentFileMention('@app.tsx');
+	t.truthy(result);
+	t.is(result!.mention, 'app.tsx');
+	t.is(result!.startIndex, 0);
+});
+
+test('handles path with slashes', t => {
+	const result = getCurrentFileMention('@src/components/Button.tsx');
+	t.truthy(result);
+	t.is(result!.mention, 'src/components/Button.tsx');
+});
+
+test('stops at whitespace', t => {
+	// When cursor is at end (after "here"), we look back and hit whitespace
+	// So we should use cursor position right after the file mention
+	const result = getCurrentFileMention('@app.tsx here', 8);
+	t.truthy(result);
+	t.is(result!.mention, 'app.tsx');
+	t.is(result!.endIndex, 8);
+});
+
+test('stops at next @ symbol', t => {
+	const result = getCurrentFileMention('@app.tsx@other', 8);
+	t.truthy(result);
+	t.is(result!.mention, 'app.tsx');
+});
+
+// Clear cache between tests (if needed)
+test.afterEach(() => {
+	clearFileListCache();
+});