@gguf/coder 0.3.0 → 0.3.1

package/source/usage/tracker.ts

@@ -0,0 +1,102 @@
+/**
+ * Usage tracker
+ * Tracks current session usage
+ */
+
+import {randomBytes} from 'node:crypto';
+
+import {getModelContextLimit} from '@/models/index';
+import type {Message} from '@/types/core';
+import type {Tokenizer} from '@/types/tokenization';
+import type {CurrentSessionStats, SessionUsage} from '../types/usage';
+import {calculateTokenBreakdown} from './calculator';
+import {addSession} from './storage';
+
+export class SessionTracker {
+	private sessionId: string;
+	private startTime: number;
+	private provider: string;
+	private model: string;
+
+	constructor(provider: string, model: string) {
+		this.sessionId = this.generateSessionId();
+		this.startTime = Date.now();
+		this.provider = provider;
+		this.model = model;
+	}
+
+	private generateSessionId(): string {
+		return `${Date.now()}-${randomBytes(8).toString('hex')}`;
+	}
+
+	async getCurrentStats(
+		messages: Message[],
+		tokenizer: Tokenizer,
+	): Promise<CurrentSessionStats> {
+		const breakdown = calculateTokenBreakdown(messages, tokenizer);
+		const contextLimit = await getModelContextLimit(this.model);
+		const percentUsed = contextLimit
+			? (breakdown.total / contextLimit) * 100
+			: 0;
+
+		return {
+			tokens: breakdown,
+			messageCount: messages.length,
+			startTime: this.startTime,
+			provider: this.provider,
+			model: this.model,
+			contextLimit,
+			percentUsed,
+		};
+	}
+
+	saveSession(messages: Message[], tokenizer: Tokenizer): void {
+		const breakdown = calculateTokenBreakdown(messages, tokenizer);
+		const duration = Date.now() - this.startTime;
+
+		const session: SessionUsage = {
+			id: this.sessionId,
+			timestamp: this.startTime,
+			provider: this.provider,
+			model: this.model,
+			tokens: breakdown,
+			messageCount: messages.length,
+			duration,
+		};
+
+		addSession(session);
+	}
+
+	updateProviderModel(provider: string, model: string): void {
+		this.provider = provider;
+		this.model = model;
+	}
+
+	getSessionInfo(): {
+		id: string;
+		startTime: number;
+		provider: string;
+		model: string;
+	} {
+		return {
+			id: this.sessionId,
+			startTime: this.startTime,
+			provider: this.provider,
+			model: this.model,
+		};
+	}
+}
+
+let currentSessionTracker: SessionTracker | null = null;
+
+export function initializeSession(provider: string, model: string): void {
+	currentSessionTracker = new SessionTracker(provider, model);
+}
+
+export function getCurrentSession(): SessionTracker | null {
+	return currentSessionTracker;
+}
+
+export function clearCurrentSession(): void {
+	currentSessionTracker = null;
+}

package/source/utils/atomic-deletion.spec.ts

@@ -0,0 +1,194 @@
+import test from 'ava';
+import type {InputState, PastePlaceholderContent} from '../types/hooks';
+import {PlaceholderType} from '../types/hooks';
+import {
+	findPlaceholderAtPosition,
+	handleAtomicDeletion,
+	wouldPartiallyDeletePlaceholder,
+} from './atomic-deletion';
+
+console.log(`\natomic-deletion.spec.ts`);
+
+// Tests for atomic placeholder deletion
+test('handleAtomicDeletion removes placeholder when backspaced', t => {
+	const previousState: InputState = {
+		displayValue: 'Analyze this: [Paste #123: 500 chars] code',
+		placeholderContent: {
+			'123': {
+				type: PlaceholderType.PASTE,
+				displayText: '[Paste #123: 500 chars]',
+				content: 'console.log("hello world");',
+				originalSize: 500,
+			} as PastePlaceholderContent,
+		},
+	};
+
+	// Simulate backspacing from the end of the placeholder
+	const newText = 'Analyze this: [Paste #123: 500 char code';
+
+	const result = handleAtomicDeletion(previousState, newText);
+
+	t.truthy(result);
+	t.is(result!.displayValue, 'Analyze this:  code');
+	t.deepEqual(result!.placeholderContent, {});
+});
+
+test('handleAtomicDeletion removes placeholder when deleted from middle', t => {
+	const previousState: InputState = {
+		displayValue: 'Before [Paste #456: 200 chars] after',
+		placeholderContent: {
+			'456': {
+				type: PlaceholderType.PASTE,
+				displayText: '[Paste #456: 200 chars]',
+				content: 'function test() { return true; }',
+				originalSize: 200,
+			} as PastePlaceholderContent,
+		},
+	};
+
+	// Simulate deleting part of the placeholder
+	const newText = 'Before [Paste #456: 200 ch after';
+
+	const result = handleAtomicDeletion(previousState, newText);
+
+	t.truthy(result);
+	t.is(result!.displayValue, 'Before  after');
+	t.deepEqual(result!.placeholderContent, {});
+});
+
+test('handleAtomicDeletion preserves other placeholders', t => {
+	const previousState: InputState = {
+		displayValue:
+			'First [Paste #111: 100 chars] second [Paste #222: 200 chars]',
+		placeholderContent: {
+			'111': {
+				type: PlaceholderType.PASTE,
+				displayText: '[Paste #111: 100 chars]',
+				content: 'first content',
+				originalSize: 100,
+			} as PastePlaceholderContent,
+			'222': {
+				type: PlaceholderType.PASTE,
+				displayText: '[Paste #222: 200 chars]',
+				content: 'second content',
+				originalSize: 200,
+			} as PastePlaceholderContent,
+		},
+	};
+
+	// Delete part of first placeholder
+	const newText = 'First [Paste #111: 100 ch second [Paste #222: 200 chars]';
+
+	const result = handleAtomicDeletion(previousState, newText);
+
+	t.truthy(result);
+	t.is(result!.displayValue, 'First  second [Paste #222: 200 chars]');
+	t.deepEqual(result!.placeholderContent, {
+		'222': {
+			type: PlaceholderType.PASTE,
+			displayText: '[Paste #222: 200 chars]',
+			content: 'second content',
+			originalSize: 200,
+		} as PastePlaceholderContent,
+	});
+});
+
+test('handleAtomicDeletion returns null for normal deletions', t => {
+	const previousState: InputState = {
+		displayValue: 'Normal text here',
+		placeholderContent: {},
+	};
+
+	const newText = 'Normal text her';
+
+	const result = handleAtomicDeletion(previousState, newText);
+
+	t.is(result, null);
+});
+
+test('handleAtomicDeletion returns null for additions', t => {
+	const previousState: InputState = {
+		displayValue: 'Short text',
+		placeholderContent: {},
+	};
+
+	const newText = 'Short text with more';
+
+	const result = handleAtomicDeletion(previousState, newText);
+
+	t.is(result, null);
+});
+
+test('findPlaceholderAtPosition finds placeholder ID', t => {
+	const text = 'Before [Paste #789: 300 chars] after';
+
+	// Position inside the placeholder
+	const result1 = findPlaceholderAtPosition(text, 10); // Inside "[Paste #789: 300 chars]"
+	t.is(result1, '789');
+
+	// Position outside the placeholder
+	const result2 = findPlaceholderAtPosition(text, 0); // In "Before"
+	t.is(result2, null);
+
+	// Position after placeholder
+	const result3 = findPlaceholderAtPosition(text, 35); // In "after"
+	t.is(result3, null);
+});
+
+test('wouldPartiallyDeletePlaceholder detects partial deletion', t => {
+	const text = 'Text [Paste #123: 100 chars] more';
+	//       01234567890123456789012345678901234
+	//       0         1         2         3
+	// Placeholder is at position 5-28 (length 23)
+
+	// Partial deletion from middle of placeholder
+	const result1 = wouldPartiallyDeletePlaceholder(text, 8, 5); // Delete "Paste"
+	t.true(result1);
+
+	// Complete deletion of placeholder - delete from position 5, length 23
+	const result2 = wouldPartiallyDeletePlaceholder(text, 5, 23); // Delete entire "[Paste #123: 100 chars]"
+	t.false(result2);
+
+	// Deletion outside placeholder
+	const result3 = wouldPartiallyDeletePlaceholder(text, 0, 4); // Delete "Text"
+	t.false(result3);
+});
+
+// Integration test showing complete flow
+test('atomic deletion works with multiple placeholders', t => {
+	const previousState: InputState = {
+		displayValue:
+			'Compare [Paste #111: 50 chars] with [Paste #222: 100 chars] output',
+		placeholderContent: {
+			'111': {
+				type: PlaceholderType.PASTE,
+				displayText: '[Paste #111: 50 chars]',
+				content: 'first code block',
+				originalSize: 50,
+			} as PastePlaceholderContent,
+			'222': {
+				type: PlaceholderType.PASTE,
+				displayText: '[Paste #222: 100 chars]',
+				content: 'second code block with more content',
+				originalSize: 100,
+			} as PastePlaceholderContent,
+		},
+	};
+
+	// Delete part of second placeholder
+	const newText =
+		'Compare [Paste #111: 50 chars] with [Paste #222: 100 ch output';
+
+	const result = handleAtomicDeletion(previousState, newText);
+
+	t.truthy(result);
+	t.is(result!.displayValue, 'Compare [Paste #111: 50 chars] with  output');
+	t.deepEqual(result!.placeholderContent, {
+		'111': {
+			type: PlaceholderType.PASTE,
+			displayText: '[Paste #111: 50 chars]',
+			content: 'first code block',
+			originalSize: 50,
+		} as PastePlaceholderContent,
+	});
+});

package/source/utils/atomic-deletion.ts

@@ -0,0 +1,127 @@
+import type {InputState} from '../types/hooks';
+
+/**
+ * Detect if a text change represents a deletion that should be atomic
+ * Returns the modified InputState if atomic deletion occurred, null otherwise
+ */
+export 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;
+}
+
+/**
+ * Find placeholder at cursor position
+ * Returns placeholder ID if cursor is within a placeholder, null otherwise
+ */
+export function findPlaceholderAtPosition(
+	text: string,
+	position: number,
+): string | null {
+	const placeholderRegex = /\[Paste #(\d+): \d+ chars\]/g;
+	let match;
+
+	while ((match = placeholderRegex.exec(text)) !== null) {
+		const placeholderStart = match.index;
+		const placeholderEnd = placeholderStart + match[0].length;
+
+		if (position >= placeholderStart && position <= placeholderEnd) {
+			return match[1]; // Return the placeholder ID
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Check if a deletion would partially affect a placeholder
+ * Used to prevent partial placeholder deletions
+ */
+export function wouldPartiallyDeletePlaceholder(
+	text: string,
+	deletionStart: number,
+	deletionLength: number,
+): boolean {
+	const placeholderRegex = /\[Paste #(\d+): \d+ chars\]/g;
+	let match;
+
+	while ((match = placeholderRegex.exec(text)) !== null) {
+		const placeholderStart = match.index;
+		const placeholderEnd = placeholderStart + match[0].length;
+		const deletionEnd = deletionStart + deletionLength;
+
+		// Check for overlap
+		const overlapsStart =
+			deletionStart >= placeholderStart && deletionStart < placeholderEnd;
+		const overlapsEnd =
+			deletionEnd > placeholderStart && deletionEnd <= placeholderEnd;
+		const spansPast =
+			deletionStart < placeholderStart && deletionEnd > placeholderStart;
+		const spansOver =
+			deletionStart < placeholderEnd && deletionEnd > placeholderEnd;
+
+		const hasOverlap = overlapsStart || overlapsEnd || spansPast || spansOver;
+		const completeOverlap =
+			deletionStart <= placeholderStart && deletionEnd >= placeholderEnd;
+
+		if (hasOverlap && !completeOverlap) {
+			return true;
+		}
+	}
+
+	return false;
+}