@gguf/coder 0.3.1 → 0.3.2

package/source/usage/tracker.ts

@@ -1,102 +0,0 @@
-/**
- * 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

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

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