@gguf/coder 0.3.1 → 0.3.2

package/source/utils/paste-detection.ts

@@ -1,124 +0,0 @@
-// CLI Paste Detection Utilities
-// Since CLI applications don't receive direct paste events, we use heuristics
-
-interface PasteDetectionOptions {
-	// Time threshold for rapid input (milliseconds)
-	timeThreshold: number;
-	// Character count threshold for single input change
-	charThreshold: number;
-	// Line count threshold for multi-line detection
-	lineThreshold: number;
-}
-
-const DEFAULT_PASTE_OPTIONS: PasteDetectionOptions = {
-	timeThreshold: 50, // Increased to 50ms to be more forgiving of fast typing
-	charThreshold: 5, // Lower threshold - detect pastes of 5+ chars (size method needs 10+ chars)
-	lineThreshold: 2, // Multiple lines added instantly
-};
-
-export class PasteDetector {
-	private lastInputTime = 0;
-	private lastInputLength = 0;
-
-	/**
-	 * Detect if a text change is likely a paste operation
-	 * @param newText The new text content
-	 * @param options Detection thresholds
-	 * @returns Object with detection result and details
-	 */
-	detectPaste(
-		newText: string,
-		options: PasteDetectionOptions = DEFAULT_PASTE_OPTIONS,
-	): {
-		isPaste: boolean;
-		method: 'rate' | 'size' | 'lines' | 'none';
-		addedText: string;
-		details: {
-			timeElapsed: number;
-			charsAdded: number;
-			linesAdded: number;
-		};
-	} {
-		const currentTime = Date.now();
-		const timeElapsed = currentTime - this.lastInputTime;
-		const charsAdded = newText.length - this.lastInputLength;
-
-		// Calculate lines added in THIS change, not total lines in text
-		const previousLineCount =
-			this.lastInputLength > 0
-				? newText.slice(0, this.lastInputLength).split('\n').length
-				: 1;
-		const currentLineCount = newText.split('\n').length;
-		const linesAdded = currentLineCount - previousLineCount;
-
-		// Get the added text (assuming it's at the end)
-		const addedText = newText.slice(this.lastInputLength);
-
-		// Update tracking
-		this.lastInputTime = currentTime;
-		this.lastInputLength = newText.length;
-
-		const details = {
-			timeElapsed,
-			charsAdded,
-			linesAdded,
-		};
-
-		// Method 1: Rate-based detection (fast input)
-		if (
-			timeElapsed < options.timeThreshold &&
-			charsAdded > options.charThreshold
-		) {
-			return {
-				isPaste: true,
-				method: 'rate',
-				addedText,
-				details,
-			};
-		}
-
-		// Method 2: Size-based detection (large single input)
-		if (charsAdded > options.charThreshold * 2) {
-			return {
-				isPaste: true,
-				method: 'size',
-				addedText,
-				details,
-			};
-		}
-
-		// Method 3: Multi-line detection
-		if (linesAdded >= options.lineThreshold) {
-			return {
-				isPaste: true,
-				method: 'lines',
-				addedText,
-				details,
-			};
-		}
-
-		return {
-			isPaste: false,
-			method: 'none',
-			addedText,
-			details,
-		};
-	}
-
-	/**
-	 * Reset the detector state (call when input is cleared or submitted)
-	 */
-	reset(): void {
-		this.lastInputTime = 0;
-		this.lastInputLength = 0;
-	}
-
-	/**
-	 * Update detector state without triggering detection
-	 * Useful for manual input changes that shouldn't be considered pastes
-	 */
-	updateState(text: string): void {
-		this.lastInputTime = Date.now();
-		this.lastInputLength = text.length;
-	}
-}

package/source/utils/paste-roundtrip.spec.ts

@@ -1,442 +0,0 @@
-import test from 'ava';
-import type {
-	InputState,
-	PastePlaceholderContent,
-	PlaceholderContent,
-} from '../types/hooks';
-import {PlaceholderType} from '../types/hooks';
-
-console.log(`\npaste-roundtrip.spec.ts`);
-
-// Self-contained implementations for integration testing
-class PasteDetector {
-	private lastInput = '';
-	private lastTimestamp = 0;
-
-	detectPaste(newInput: string): {
-		isPaste: boolean;
-		addedText: string;
-		method?: string;
-	} {
-		const now = Date.now();
-		const deltaTime = now - this.lastTimestamp;
-		const addedText = newInput.slice(this.lastInput.length);
-
-		// Update state for next call
-		const result = {
-			isPaste: false,
-			addedText,
-			method: undefined as string | undefined,
-		};
-
-		// Rate-based detection: >50 chars in <16ms
-		if (addedText.length > 50 && deltaTime < 16) {
-			result.isPaste = true;
-			result.method = 'rate';
-		}
-		// Size-based detection: >100 chars at once
-		else if (addedText.length > 100) {
-			result.isPaste = true;
-			result.method = 'size';
-		}
-		// Multi-line detection: >=2 lines
-		else if (addedText.split(/\r\n|\r|\n/).length >= 2) {
-			result.isPaste = true;
-			result.method = 'multiline';
-		}
-
-		this.lastInput = newInput;
-		this.lastTimestamp = now;
-
-		return result;
-	}
-
-	reset() {
-		this.lastInput = '';
-		this.lastTimestamp = 0;
-	}
-
-	updateState(newInput: string) {
-		this.lastInput = newInput;
-		this.lastTimestamp = Date.now();
-	}
-}
-
-function handlePaste(
-	pastedText: string,
-	currentDisplayValue: string,
-	currentPlaceholderContent: Record<string, PlaceholderContent>,
-): InputState | null {
-	// Only create placeholder for large pastes (>80 chars)
-	if (pastedText.length <= 80) {
-		return null; // Small paste, insert as normal text
-	}
-
-	// Generate simple incrementing ID based on existing paste placeholders
-	const existingPasteCount = Object.values(currentPlaceholderContent).filter(
-		content => content.type === PlaceholderType.PASTE,
-	).length;
-	const pasteId = (existingPasteCount + 1).toString();
-	const placeholder = `[Paste #${pasteId}: ${pastedText.length} chars]`;
-
-	const pasteContent: PastePlaceholderContent = {
-		type: PlaceholderType.PASTE,
-		displayText: placeholder,
-		content: pastedText,
-		originalSize: pastedText.length,
-		timestamp: Date.now(),
-	};
-
-	const newPlaceholderContent = {
-		...currentPlaceholderContent,
-		[pasteId]: pasteContent,
-	};
-
-	// For CLI paste detection, we need to replace the pasted text in the display value
-	// If the pasted text is at the end, replace it. Otherwise append the placeholder.
-	const newDisplayValue = currentDisplayValue.includes(pastedText)
-		? currentDisplayValue.replace(pastedText, placeholder)
-		: currentDisplayValue + placeholder;
-
-	return {
-		displayValue: newDisplayValue,
-		placeholderContent: newPlaceholderContent,
-	};
-}
-
-function assemblePrompt(inputState: InputState): string {
-	let assembledPrompt = inputState.displayValue;
-
-	Object.entries(inputState.placeholderContent).forEach(
-		([pasteId, placeholderContent]) => {
-			if (placeholderContent.type === 'paste') {
-				const pasteContent = placeholderContent as PastePlaceholderContent;
-				assembledPrompt = assembledPrompt.replace(
-					pasteContent.displayText,
-					pasteContent.content,
-				);
-			}
-		},
-	);
-
-	return assembledPrompt;
-}
-
-function handleAtomicDeletion(
-	previousState: InputState,
-	newText: string,
-): InputState | null {
-	const previousText = previousState.displayValue;
-
-	// Only handle deletions (text getting shorter)
-	if (newText.length >= previousText.length) {
-		return null;
-	}
-
-	// Find what was deleted
-	const deletedChars = previousText.length - newText.length;
-
-	// Find where the deletion occurred
-	let deletionStart = -1;
-	for (let i = 0; i < Math.min(previousText.length, newText.length); i++) {
-		if (previousText[i] !== newText[i]) {
-			deletionStart = i;
-			break;
-		}
-	}
-
-	// If no difference found in common part, deletion was at the end
-	if (deletionStart === -1) {
-		deletionStart = newText.length;
-	}
-
-	// Check if any placeholder was affected by this deletion
-	const placeholderRegex = /\[Paste #(\d+): \d+ chars\]/g;
-	let match;
-
-	while ((match = placeholderRegex.exec(previousText)) !== null) {
-		const placeholderStart = match.index;
-		const placeholderEnd = placeholderStart + match[0].length;
-		const placeholderId = match[1];
-
-		// Check if deletion overlaps with this placeholder
-		const deletionEnd = deletionStart + deletedChars;
-
-		if (
-			(deletionStart >= placeholderStart && deletionStart < placeholderEnd) ||
-			(deletionEnd > placeholderStart && deletionEnd <= placeholderEnd) ||
-			(deletionStart <= placeholderStart && deletionEnd >= placeholderEnd)
-		) {
-			// Deletion affects this placeholder - remove it atomically
-			const newDisplayValue = previousText.replace(match[0], '');
-			const newPlaceholderContent = {...previousState.placeholderContent};
-			delete newPlaceholderContent[placeholderId];
-
-			return {
-				displayValue: newDisplayValue,
-				placeholderContent: newPlaceholderContent,
-			};
-		}
-	}
-
-	return null;
-}
-
-// Full round-trip integration test for paste handling system
-test('complete paste handling round-trip workflow', t => {
-	// Step 1: Simulate user typing some text
-	let currentState: InputState = {
-		displayValue: 'Analyze this code: ',
-		placeholderContent: {},
-	};
-
-	// Step 2: Simulate a large paste being detected
-	const detector = new PasteDetector();
-	// Initialize detector with current state
-	detector.updateState(currentState.displayValue);
-
-	const largeCodeSnippet = `function fibonacci(n) {
-	if (n <= 1) return n;
-	return fibonacci(n - 1) + fibonacci(n - 2);
-}
-
-const result = fibonacci(10);
-console.log('Fibonacci result:', result);
-
-// Additional complex logic
-class Calculator {
-	constructor() {
-		this.history = [];
-		this.operations = ['add', 'subtract', 'multiply', 'divide'];
-		this.precision = 2;
-	}
-	
-	add(a, b) {
-		const result = a + b;
-		this.history.push(\`\${a} + \${b} = \${result}\`);
-		return result;
-	}
-	
-	subtract(a, b) {
-		const result = a - b;
-		this.history.push(\`\${a} - \${b} = \${result}\`);
-		return result;
-	}
-	
-	multiply(a, b) {
-		const result = a * b;
-		this.history.push(\`\${a} * \${b} = \${result}\`);
-		return result;
-	}
-	
-	divide(a, b) {
-		if (b === 0) throw new Error('Division by zero');
-		const result = a / b;
-		this.history.push(\`\${a} / \${b} = \${result}\`);
-		return result;
-	}
-	
-	getHistory() {
-		return this.history.slice();
-	}
-	
-	clearHistory() {
-		this.history = [];
-	}
-}`;
-
-	// Simulate paste detection
-	const newInputWithPaste = currentState.displayValue + largeCodeSnippet;
-	const detection = detector.detectPaste(newInputWithPaste);
-
-	// Verify paste was detected
-	t.true(detection.isPaste);
-	// Method could be 'rate' or 'size' depending on timing - both are valid for large pastes
-
-	// Step 3: Handle the paste by creating placeholder
-	const pasteResult = handlePaste(
-		detection.addedText,
-		currentState.displayValue,
-		currentState.placeholderContent,
-	);
-
-	t.truthy(pasteResult);
-	currentState = pasteResult!;
-
-	// Verify placeholder was created correctly
-	t.true(currentState.displayValue.includes('[Paste #'));
-	t.true(currentState.displayValue.includes('chars]'));
-
-	// Debug: Check actual vs expected length
-	const pasteId = Object.keys(currentState.placeholderContent)[0];
-	const pasteContent = currentState.placeholderContent[
-		pasteId
-	] as PastePlaceholderContent;
-	const actualLength = pasteContent.content.length;
-
-	// Use the actual length from the stored content
-	t.is(
-		currentState.displayValue,
-		`Analyze this code: [Paste #${pasteId}: ${actualLength} chars]`,
-	);
-
-	// Verify full content is preserved
-	t.is(pasteContent.content, largeCodeSnippet);
-
-	// Step 4: Simulate adding more text after the paste
-	currentState = {
-		displayValue: currentState.displayValue + ' and explain the algorithm',
-		placeholderContent: currentState.placeholderContent,
-	};
-
-	// Step 5: Simulate a second paste in the same command
-	const secondSnippet = 'const testData = [1, 2, 3, 4, 5];';
-	const secondPasteResult = handlePaste(
-		secondSnippet,
-		currentState.displayValue,
-		currentState.placeholderContent,
-	);
-
-	// Second paste is small, should return null (inserted as plain text)
-	t.is(secondPasteResult, null);
-
-	// Add the small paste manually (simulating normal insertion)
-	currentState = {
-		displayValue: currentState.displayValue + ' Compare with: ' + secondSnippet,
-		placeholderContent: currentState.placeholderContent,
-	};
-
-	// Step 6: Test atomic deletion - simulate user deleting part of the first placeholder
-	// Create a text where we delete from inside the placeholder (simulating backspace)
-	const fullPlaceholder = `[Paste #${pasteId}: ${actualLength} chars]`;
-	const placeholderIndex = currentState.displayValue.indexOf(fullPlaceholder);
-	// Delete 2 characters from the middle of the placeholder (remove "te" from "Paste")
-	const partiallyDeletedText =
-		currentState.displayValue.slice(0, placeholderIndex + 4) + // "[Pas"
-		currentState.displayValue.slice(placeholderIndex + 6); // skip "te", continue from " #..."
-	const atomicDeletionResult = handleAtomicDeletion(
-		currentState,
-		partiallyDeletedText,
-	);
-
-	t.truthy(atomicDeletionResult);
-
-	// After atomic deletion, placeholder and content should be gone
-	t.false(atomicDeletionResult!.displayValue.includes('[Paste #'));
-	t.deepEqual(atomicDeletionResult!.placeholderContent, {});
-
-	// Step 7: Restore state and test prompt assembly for submission
-	// (Simulate the state before deletion for final assembly test)
-	const finalState: InputState = {
-		displayValue: `Analyze this code: [Paste #${pasteId}: ${actualLength} chars] and explain the algorithm Compare with: ${secondSnippet}`,
-		placeholderContent: {
-			[pasteId]: {
-				type: PlaceholderType.PASTE,
-				displayText: `[Paste #${pasteId}: ${actualLength} chars]`,
-				content: largeCodeSnippet,
-				originalSize: actualLength,
-			} as PastePlaceholderContent,
-		},
-	};
-
-	// Step 8: Test prompt assembly (what gets sent to AI)
-	const assembledPrompt = assemblePrompt(finalState);
-
-	// Verify placeholders are replaced with full content
-	t.false(assembledPrompt.includes('[Paste #'));
-	t.true(assembledPrompt.includes('function fibonacci(n)'));
-	t.true(assembledPrompt.includes('class Calculator'));
-	t.true(assembledPrompt.includes('and explain the algorithm'));
-	t.true(assembledPrompt.includes('Compare with: const testData'));
-
-	// Verify complete reconstruction
-	const expectedFinalPrompt = `Analyze this code: ${largeCodeSnippet} and explain the algorithm Compare with: ${secondSnippet}`;
-	t.is(assembledPrompt, expectedFinalPrompt);
-
-	// Step 9: Test history preservation (what gets saved)
-	// Verify that the InputState can be serialized and deserialized
-	const serialized = JSON.stringify(finalState);
-	const deserialized: InputState = JSON.parse(serialized);
-
-	t.deepEqual(deserialized, finalState);
-	t.is(assemblePrompt(deserialized), expectedFinalPrompt);
-});
-
-// Test multiple placeholders in single command
-test('multiple placeholders in single command workflow', t => {
-	const detector = new PasteDetector();
-	let currentState: InputState = {
-		displayValue: 'Compare ',
-		placeholderContent: {},
-	};
-
-	// First large paste - simulate by creating full input
-	const firstCode = 'x'.repeat(600); // Large enough to trigger placeholder
-	const firstFullInput = currentState.displayValue + firstCode;
-	const firstDetection = detector.detectPaste(firstFullInput);
-	t.true(firstDetection.isPaste);
-
-	const firstPasteResult = handlePaste(
-		firstCode, // Pass the actual pasted code, not the added text which includes existing text
-		currentState.displayValue,
-		currentState.placeholderContent,
-	);
-	t.truthy(firstPasteResult);
-	currentState = firstPasteResult!;
-
-	// Add text between pastes
-	currentState = {
-		displayValue: currentState.displayValue + ' with ',
-		placeholderContent: currentState.placeholderContent,
-	};
-
-	// Update detector state to current state
-	detector.updateState(currentState.displayValue);
-
-	// Second large paste - simulate by creating new full input
-	const secondCode = 'y'.repeat(700);
-	const secondFullInput = currentState.displayValue + secondCode;
-	const secondDetection = detector.detectPaste(secondFullInput);
-	t.true(secondDetection.isPaste);
-
-	const secondPasteResult = handlePaste(
-		secondCode, // Pass the actual pasted code, not the added text
-		currentState.displayValue,
-		currentState.placeholderContent,
-	);
-	t.truthy(secondPasteResult);
-	currentState = secondPasteResult!;
-
-	// Verify two placeholders exist
-	const placeholderMatches = currentState.displayValue.match(
-		/\[Paste #\d+: \d+ chars\]/g,
-	);
-	t.is(placeholderMatches?.length, 2);
-
-	// Verify both pieces of content are preserved
-	t.is(Object.keys(currentState.placeholderContent).length, 2);
-
-	// Test assembly replaces both placeholders
-	const assembled = assemblePrompt(currentState);
-	t.false(assembled.includes('[Paste #'));
-	t.true(assembled.includes(firstCode));
-	t.true(assembled.includes(secondCode));
-	t.is(assembled, `Compare ${firstCode} with ${secondCode}`);
-});
-
-// Test edge cases and error conditions
-test('paste handling edge cases', t => {
-	// Test with empty state
-	const emptyState: InputState = {displayValue: '', placeholderContent: {}};
-	const assembled = assemblePrompt(emptyState);
-	t.is(assembled, '');
-
-	// Test with placeholder but missing content (error recovery)
-	const corruptState: InputState = {
-		displayValue: 'Test [Paste #123: 100 chars] here',
-		placeholderContent: {}, // Missing content for placeholder
-	};
-	const assembledCorrupt = assemblePrompt(corruptState);
-	// Should leave placeholder intact if content is missing
-	t.true(assembledCorrupt.includes('[Paste #123: 100 chars]'));
-});

package/source/utils/paste-utils.spec.ts

@@ -1,128 +0,0 @@
-import type {PastePlaceholderContent, PlaceholderContent} from '@/types/hooks';
-import {PlaceholderType} from '@/types/hooks';
-import test from 'ava';
-import {handlePaste} from './paste-utils';
-
-// Tests for handlePaste utility function
-// Validates paste handling logic and placeholder creation
-
-console.log(`\npaste-utils.spec.ts`);
-
-test('handlePaste returns null for empty pastes', t => {
-	const pastedText = '';
-	const currentDisplayValue = 'existing content';
-	const currentPlaceholderContent: Record<string, PlaceholderContent> = {};
-
-	const result = handlePaste(
-		pastedText,
-		currentDisplayValue,
-		currentPlaceholderContent,
-	);
-
-	t.is(result, null);
-});
-
-test('handlePaste creates placeholder for small pastes', t => {
-	const pastedText = 'small text';
-	const currentDisplayValue = 'existing content';
-	const currentPlaceholderContent: Record<string, PlaceholderContent> = {};
-
-	const result = handlePaste(
-		pastedText,
-		currentDisplayValue,
-		currentPlaceholderContent,
-	);
-
-	t.truthy(result);
-	t.is(typeof result!.displayValue, 'string');
-	t.true(result!.displayValue.includes('[Paste #'));
-	t.true(result!.displayValue.includes('10 chars]'));
-
-	// Should contain the pasted content in the map
-	const pasteIds = Object.keys(result!.placeholderContent);
-	t.is(pasteIds.length, 1);
-	const pasteContent = result!.placeholderContent[
-		pasteIds[0]
-	] as PastePlaceholderContent;
-	t.is(pasteContent.content, pastedText);
-	t.is(pasteContent.type, PlaceholderType.PASTE);
-});
-
-test('handlePaste creates placeholder for large pastes', t => {
-	const pastedText = 'a'.repeat(600);
-	const currentDisplayValue = 'existing content';
-	const currentPlaceholderContent: Record<string, PlaceholderContent> = {};
-
-	const result = handlePaste(
-		pastedText,
-		currentDisplayValue,
-		currentPlaceholderContent,
-	);
-
-	t.truthy(result);
-	t.is(typeof result!.displayValue, 'string');
-	t.true(result!.displayValue.includes('[Paste #'));
-	t.true(result!.displayValue.includes('600 chars]'));
-
-	// Should contain the pasted content in the map
-	const pasteIds = Object.keys(result!.placeholderContent);
-	t.is(pasteIds.length, 1);
-	const pasteContent = result!.placeholderContent[
-		pasteIds[0]
-	] as PastePlaceholderContent;
-	t.is(pasteContent.content, pastedText);
-	t.is(pasteContent.type, PlaceholderType.PASTE);
-});
-
-test('handlePaste replaces pasted text with placeholder in display value', t => {
-	const pastedText = 'x'.repeat(700);
-	const currentDisplayValue = `prefix ${pastedText} suffix`;
-	const currentPlaceholderContent: Record<string, PlaceholderContent> = {};
-
-	const result = handlePaste(
-		pastedText,
-		currentDisplayValue,
-		currentPlaceholderContent,
-	);
-
-	t.truthy(result);
-	t.true(result!.displayValue.startsWith('prefix [Paste #'));
-	t.true(result!.displayValue.endsWith('700 chars] suffix'));
-	t.false(result!.displayValue.includes('x'.repeat(10))); // Original text should be gone
-});
-
-test('handlePaste preserves existing pasted content', t => {
-	const existingPlaceholderContent: Record<string, PlaceholderContent> = {
-		'123': {
-			type: PlaceholderType.PASTE,
-			displayText: '[Paste #123: 24 chars]',
-			content: 'previous paste content',
-			originalSize: 24,
-		} as PastePlaceholderContent,
-	};
-	const pastedText = 'b'.repeat(800);
-	const currentDisplayValue = 'some text';
-
-	const result = handlePaste(
-		pastedText,
-		currentDisplayValue,
-		existingPlaceholderContent,
-	);
-
-	t.truthy(result);
-	t.is(Object.keys(result!.placeholderContent).length, 2);
-	const existingContent = result!.placeholderContent[
-		'123'
-	] as PastePlaceholderContent;
-	t.is(existingContent.content, 'previous paste content');
-
-	// Find the new paste ID
-	const newPasteId = Object.keys(result!.placeholderContent).find(
-		id => id !== '123',
-	);
-	t.truthy(newPasteId);
-	const newContent = result!.placeholderContent[
-		newPasteId!
-	] as PastePlaceholderContent;
-	t.is(newContent.content, pastedText);
-});