@gguf/coder 0.3.1 → 0.3.2

package/source/usage/storage.ts

@@ -1,238 +0,0 @@
-/**
- * Usage data storage
- * Persists usage statistics to the app data directory
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import {getAppDataPath, getConfigPath} from '@/config/paths';
-import {MAX_DAILY_AGGREGATES, MAX_USAGE_SESSIONS} from '@/constants';
-import {logInfo, logWarning} from '@/utils/message-queue';
-import type {DailyAggregate, SessionUsage, UsageData} from '../types/usage';
-
-const USAGE_FILE_NAME = 'usage.json';
-
-function getLegacyUsageFilePath(): string {
-	// Legacy location: config directory (pre-app-data change)
-	try {
-		const configDir = getConfigPath();
-		return path.join(configDir, USAGE_FILE_NAME);
-	} catch {
-		return '';
-	}
-}
-
-function getUsageFilePath(): string {
-	const appDataDir = getAppDataPath();
-	const newPath = path.join(appDataDir, USAGE_FILE_NAME);
-
-	// If new path already exists, use it
-	if (fs.existsSync(newPath)) {
-		return newPath;
-	}
-
-	// Attempt one-time lazy migration from legacy location
-	const legacyPath = getLegacyUsageFilePath();
-	if (legacyPath && fs.existsSync(legacyPath)) {
-		try {
-			if (!fs.existsSync(appDataDir)) {
-				fs.mkdirSync(appDataDir, {recursive: true});
-			}
-
-			try {
-				fs.renameSync(legacyPath, newPath);
-				logInfo(`Migrated usage data to new location: ${newPath}`);
-			} catch (renameError) {
-				// Fallback if rename/move fails: copy then best-effort delete
-				logWarning(
-					`Could not move usage file (${
-						renameError instanceof Error ? renameError.message : 'unknown error'
-					}), copying instead...`,
-				);
-				fs.copyFileSync(legacyPath, newPath);
-				try {
-					fs.unlinkSync(legacyPath);
-					logInfo(`Successfully migrated usage data to: ${newPath}`);
-				} catch {
-					logWarning(
-						`Migrated usage data to new location, but could not remove old file at ${legacyPath}. You may want to manually delete it.`,
-					);
-				}
-			}
-
-			return newPath;
-		} catch (error) {
-			// On any failure, fall through to using newPath without migration
-			logWarning(
-				`Failed to migrate usage data from ${legacyPath}: ${
-					error instanceof Error ? error.message : 'unknown error'
-				}. Old data remains at legacy location.`,
-			);
-		}
-	}
-
-	return newPath;
-}
-
-function ensureAppDataDir(): void {
-	const appDataDir = getAppDataPath();
-	if (!fs.existsSync(appDataDir)) {
-		fs.mkdirSync(appDataDir, {recursive: true});
-	}
-}
-
-function createEmptyUsageData(): UsageData {
-	return {
-		sessions: [],
-		dailyAggregates: [],
-		totalLifetime: 0,
-		lastUpdated: Date.now(),
-	};
-}
-
-export function readUsageData(): UsageData {
-	try {
-		const filePath = getUsageFilePath();
-
-		if (!fs.existsSync(filePath)) {
-			return createEmptyUsageData();
-		}
-
-		const content = fs.readFileSync(filePath, 'utf-8');
-		const data = JSON.parse(content) as UsageData;
-
-		return data;
-	} catch (error) {
-		logWarning('Failed to read usage data:', true, {
-			context: {error},
-		});
-		return createEmptyUsageData();
-	}
-}
-
-export function writeUsageData(data: UsageData): void {
-	try {
-		ensureAppDataDir();
-
-		data.lastUpdated = Date.now();
-
-		const filePath = getUsageFilePath();
-		fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
-	} catch (error) {
-		logWarning('Failed to write usage data:', true, {
-			context: {error},
-		});
-	}
-}
-
-export function addSession(session: SessionUsage): void {
-	const data = readUsageData();
-
-	// Add session to the beginning (most recent first)
-	data.sessions.unshift(session);
-
-	// Keep only last MAX_USAGE_SESSIONS
-	if (data.sessions.length > MAX_USAGE_SESSIONS) {
-		data.sessions = data.sessions.slice(0, MAX_USAGE_SESSIONS);
-	}
-
-	// Update lifetime total
-	data.totalLifetime += session.tokens.total;
-
-	// Update daily aggregate
-	updateDailyAggregate(data, session);
-
-	writeUsageData(data);
-}
-
-function updateDailyAggregate(data: UsageData, session: SessionUsage): void {
-	const dateParts = new Date(session.timestamp).toISOString().split('T');
-	const dateStr = dateParts[0] || new Date().toISOString().split('T')[0] || '';
-
-	// Find or create daily aggregate
-	let dailyAggregate = data.dailyAggregates.find(agg => agg.date === dateStr);
-
-	if (!dailyAggregate) {
-		dailyAggregate = {
-			date: dateStr,
-			sessions: 0,
-			totalTokens: 0,
-			providers: {},
-			models: {},
-		};
-		data.dailyAggregates.push(dailyAggregate);
-	}
-
-	// Update aggregate
-	dailyAggregate.sessions += 1;
-	dailyAggregate.totalTokens += session.tokens.total;
-
-	// Update provider stats
-	dailyAggregate.providers[session.provider] =
-		(dailyAggregate.providers[session.provider] || 0) + session.tokens.total;
-
-	// Update model stats
-	dailyAggregate.models[session.model] =
-		(dailyAggregate.models[session.model] || 0) + session.tokens.total;
-
-	// Sort by date (newest first) and keep only last MAX_DAILY_AGGREGATES
-	data.dailyAggregates.sort((a, b) => b.date.localeCompare(a.date));
-	if (data.dailyAggregates.length > MAX_DAILY_AGGREGATES) {
-		data.dailyAggregates = data.dailyAggregates.slice(0, MAX_DAILY_AGGREGATES);
-	}
-}
-
-export function getTodayAggregate(): DailyAggregate | null {
-	const data = readUsageData();
-	const todayParts = new Date().toISOString().split('T');
-	const today = todayParts[0] || '';
-
-	return data.dailyAggregates.find(agg => agg.date === today) || null;
-}
-
-export function getLastNDaysAggregate(days: number): {
-	totalTokens: number;
-	totalSessions: number;
-	avgTokensPerDay: number;
-} {
-	const data = readUsageData();
-	const cutoffDate = new Date();
-	cutoffDate.setDate(cutoffDate.getDate() - days);
-	const cutoffParts = cutoffDate.toISOString().split('T');
-	const cutoffStr = cutoffParts[0] || '';
-
-	const relevantAggregates = data.dailyAggregates.filter(
-		agg => agg.date >= cutoffStr,
-	);
-
-	const totalTokens = relevantAggregates.reduce(
-		(sum, agg) => sum + agg.totalTokens,
-		0,
-	);
-	const totalSessions = relevantAggregates.reduce(
-		(sum, agg) => sum + agg.sessions,
-		0,
-	);
-
-	return {
-		totalTokens,
-		totalSessions,
-		avgTokensPerDay: Math.round(totalTokens / (days || 1)),
-	};
-}
-
-/**
- * Clear all usage data
- */
-export function clearUsageData(): void {
-	try {
-		const filePath = getUsageFilePath();
-		if (fs.existsSync(filePath)) {
-			fs.unlinkSync(filePath);
-		}
-	} catch (error) {
-		logWarning('Failed to clear usage data:', true, {
-			context: {error},
-		});
-	}
-}

package/source/usage/tracker.spec.ts

@@ -1,456 +0,0 @@
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import type {Message} from '@/types/core.js';
-import type {Tokenizer} from '@/types/tokenization.js';
-import test from 'ava';
-import {clearUsageData, readUsageData} from './storage.js';
-import {
-	SessionTracker,
-	clearCurrentSession,
-	getCurrentSession,
-	initializeSession,
-} from './tracker.js';
-
-console.log('\ntracker.spec.ts');
-
-// ============================================================================
-// Mock Tokenizer
-// ============================================================================
-
-class MockTokenizer implements Tokenizer {
-	getName(): string {
-		return 'mock-tokenizer';
-	}
-
-	countTokens(message: Message): number {
-		// Simple mock: 1 token per 4 characters
-		return Math.ceil(message.content.length / 4);
-	}
-
-	encode(text: string): number {
-		// Return token count (1 token per 4 characters)
-		return Math.ceil(text.length / 4);
-	}
-}
-
-// ============================================================================
-// Test Setup
-// ============================================================================
-
-function createTestDir(): string {
-	const testDir = path.join(
-		os.tmpdir(),
-		`coder-test-${Date.now()}-${Math.random().toString(36).substring(7)}`,
-	);
-	fs.mkdirSync(testDir, {recursive: true});
-	return testDir;
-}
-
-let originalEnv: NodeJS.ProcessEnv;
-
-test.before(() => {
-	originalEnv = {...process.env};
-});
-
-test.beforeEach(() => {
-	const testDir = createTestDir();
-	process.env.XDG_CONFIG_HOME = testDir;
-	clearCurrentSession(); // Clear any lingering session from previous tests
-});
-
-test.afterEach(() => {
-	clearCurrentSession();
-	clearUsageData();
-	try {
-		if (process.env.XDG_CONFIG_HOME) {
-			fs.rmSync(process.env.XDG_CONFIG_HOME, {recursive: true, force: true});
-		}
-	} catch (error) {
-		// Ignore cleanup errors
-	}
-});
-
-test.after(() => {
-	process.env = originalEnv;
-});
-
-// Helper to create messages
-function createMockMessages(): Message[] {
-	return [
-		{role: 'system', content: 'You are a helpful assistant.'},
-		{role: 'user', content: 'Hello'},
-		{role: 'assistant', content: 'Hi there!'},
-	];
-}
-
-// ============================================================================
-// SessionTracker Constructor Tests
-// ============================================================================
-
-test('SessionTracker initializes with provider and model', t => {
-	const tracker = new SessionTracker('openai', 'gpt-4');
-	const info = tracker.getSessionInfo();
-
-	t.is(info.provider, 'openai');
-	t.is(info.model, 'gpt-4');
-	t.truthy(info.id);
-	t.truthy(info.startTime);
-});
-
-test('SessionTracker generates unique session IDs', t => {
-	const tracker1 = new SessionTracker('openai', 'gpt-4');
-	const tracker2 = new SessionTracker('anthropic', 'claude');
-
-	const info1 = tracker1.getSessionInfo();
-	const info2 = tracker2.getSessionInfo();
-
-	t.not(info1.id, info2.id);
-});
-
-test('SessionTracker records start time', t => {
-	const before = Date.now();
-	const tracker = new SessionTracker('openai', 'gpt-4');
-	const after = Date.now();
-
-	const info = tracker.getSessionInfo();
-
-	t.true(info.startTime >= before);
-	t.true(info.startTime <= after);
-});
-
-// ============================================================================
-// getCurrentStats Tests
-// ============================================================================
-
-test('getCurrentStats returns stats for empty messages', async t => {
-	const tracker = new SessionTracker('openai', 'gpt-4');
-	const tokenizer = new MockTokenizer();
-	const messages: Message[] = [];
-
-	const stats = await tracker.getCurrentStats(messages, tokenizer);
-
-	t.is(stats.provider, 'openai');
-	t.is(stats.model, 'gpt-4');
-	t.is(stats.messageCount, 0);
-	t.is(stats.tokens.total, 0);
-	t.truthy(stats.startTime);
-});
-
-test('getCurrentStats calculates token breakdown', async t => {
-	const tracker = new SessionTracker('openai', 'gpt-4');
-	const tokenizer = new MockTokenizer();
-	const messages = createMockMessages();
-
-	const stats = await tracker.getCurrentStats(messages, tokenizer);
-
-	t.is(stats.messageCount, 3);
-	t.true(stats.tokens.total > 0);
-	t.true(stats.tokens.system > 0);
-	t.true(stats.tokens.userMessages > 0);
-	t.true(stats.tokens.assistantMessages > 0);
-});
-
-test('getCurrentStats includes context limit and percent used', async t => {
-	const tracker = new SessionTracker('openai', 'gpt-4');
-	const tokenizer = new MockTokenizer();
-	const messages = createMockMessages();
-
-	const stats = await tracker.getCurrentStats(messages, tokenizer);
-
-	// Context limit may be null if model not found
-	if (stats.contextLimit) {
-		t.true(stats.contextLimit > 0);
-		t.true(stats.percentUsed >= 0);
-		t.true(stats.percentUsed <= 100 || stats.percentUsed > 100); // Allow over 100%
-	} else {
-		t.is(stats.percentUsed, 0);
-	}
-});
-
-test('getCurrentStats calculates percent used correctly', async t => {
-	const tracker = new SessionTracker('openai', 'gpt-4');
-	const tokenizer = new MockTokenizer();
-	// Create a message with known token count
-	const messages: Message[] = [
-		{role: 'user', content: 'a'.repeat(400)}, // 400 chars / 4 = 100 tokens
-	];
-
-	const stats = await tracker.getCurrentStats(messages, tokenizer);
-
-	t.is(stats.tokens.total, 100);
-
-	if (stats.contextLimit) {
-		const expectedPercent = (100 / stats.contextLimit) * 100;
-		t.is(stats.percentUsed, expectedPercent);
-	}
-});
-
-// ============================================================================
-// saveSession Tests
-// ============================================================================
-
-test('saveSession persists session to storage', t => {
-	const tracker = new SessionTracker('openai', 'gpt-4');
-	const tokenizer = new MockTokenizer();
-	const messages = createMockMessages();
-
-	tracker.saveSession(messages, tokenizer);
-
-	const data = readUsageData();
-	t.is(data.sessions.length, 1);
-
-	const session = data.sessions[0]!;
-	t.is(session.provider, 'openai');
-	t.is(session.model, 'gpt-4');
-	t.is(session.messageCount, 3);
-	t.true(session.tokens.total > 0);
-	t.true(session.duration !== undefined);
-	t.true(session.duration! >= 0);
-});
-
-test('saveSession includes duration', t => {
-	const tracker = new SessionTracker('openai', 'gpt-4');
-	const tokenizer = new MockTokenizer();
-	const messages = createMockMessages();
-
-	// Wait a bit to ensure duration > 0
-	const start = Date.now();
-	while (Date.now() - start < 10) {
-		// Small delay
-	}
-
-	tracker.saveSession(messages, tokenizer);
-
-	const data = readUsageData();
-	const session = data.sessions[0]!;
-
-	t.true(session.duration! >= 10);
-});
-
-test('saveSession saves correct token breakdown', t => {
-	const tracker = new SessionTracker('openai', 'gpt-4');
-	const tokenizer = new MockTokenizer();
-	const messages: Message[] = [
-		{role: 'system', content: 'abcd'}, // 4 chars = 1 token
-		{role: 'user', content: 'abcdefgh'}, // 8 chars = 2 tokens
-		{role: 'assistant', content: 'abcdefghijkl'}, // 12 chars = 3 tokens
-	];
-
-	tracker.saveSession(messages, tokenizer);
-
-	const data = readUsageData();
-	const session = data.sessions[0]!;
-
-	t.is(session.tokens.system, 1);
-	t.is(session.tokens.userMessages, 2);
-	t.is(session.tokens.assistantMessages, 3);
-	t.is(session.tokens.total, 6);
-});
-
-// ============================================================================
-// updateProviderModel Tests
-// ============================================================================
-
-test('updateProviderModel changes provider and model', t => {
-	const tracker = new SessionTracker('openai', 'gpt-4');
-
-	tracker.updateProviderModel('anthropic', 'claude-3');
-
-	const info = tracker.getSessionInfo();
-	t.is(info.provider, 'anthropic');
-	t.is(info.model, 'claude-3');
-});
-
-test('updateProviderModel preserves session ID and start time', t => {
-	const tracker = new SessionTracker('openai', 'gpt-4');
-	const infoBefore = tracker.getSessionInfo();
-
-	tracker.updateProviderModel('anthropic', 'claude');
-	const infoAfter = tracker.getSessionInfo();
-
-	t.is(infoAfter.id, infoBefore.id);
-	t.is(infoAfter.startTime, infoBefore.startTime);
-});
-
-test('updateProviderModel affects saved session', t => {
-	const tracker = new SessionTracker('openai', 'gpt-4');
-	const tokenizer = new MockTokenizer();
-	const messages = createMockMessages();
-
-	tracker.updateProviderModel('anthropic', 'claude-3-opus');
-	tracker.saveSession(messages, tokenizer);
-
-	const data = readUsageData();
-	const session = data.sessions[0]!;
-
-	t.is(session.provider, 'anthropic');
-	t.is(session.model, 'claude-3-opus');
-});
-
-// ============================================================================
-// getSessionInfo Tests
-// ============================================================================
-
-test('getSessionInfo returns current session details', t => {
-	const tracker = new SessionTracker('openai', 'gpt-4');
-	const info = tracker.getSessionInfo();
-
-	t.truthy(info.id);
-	t.is(info.provider, 'openai');
-	t.is(info.model, 'gpt-4');
-	t.truthy(info.startTime);
-});
-
-// ============================================================================
-// Module-level Functions Tests
-// ============================================================================
-
-test('initializeSession creates new session tracker', t => {
-	initializeSession('openai', 'gpt-4');
-
-	const session = getCurrentSession();
-	t.truthy(session);
-
-	const info = session!.getSessionInfo();
-	t.is(info.provider, 'openai');
-	t.is(info.model, 'gpt-4');
-});
-
-test('getCurrentSession returns null initially', t => {
-	const session = getCurrentSession();
-	t.is(session, null);
-});
-
-test('getCurrentSession returns initialized session', t => {
-	initializeSession('openai', 'gpt-4');
-
-	const session = getCurrentSession();
-	t.truthy(session);
-	t.true(session instanceof SessionTracker);
-});
-
-test('clearCurrentSession removes current session', t => {
-	initializeSession('openai', 'gpt-4');
-
-	let session = getCurrentSession();
-	t.truthy(session);
-
-	clearCurrentSession();
-
-	session = getCurrentSession();
-	t.is(session, null);
-});
-
-test('clearCurrentSession is idempotent', t => {
-	clearCurrentSession();
-	clearCurrentSession();
-
-	const session = getCurrentSession();
-	t.is(session, null);
-});
-
-test('initializeSession replaces existing session', t => {
-	initializeSession('openai', 'gpt-4');
-	const session1 = getCurrentSession();
-	const info1 = session1!.getSessionInfo();
-
-	initializeSession('anthropic', 'claude-3-opus');
-	const session2 = getCurrentSession();
-	const info2 = session2!.getSessionInfo();
-
-	t.not(info1.id, info2.id);
-	t.is(info2.provider, 'anthropic');
-	t.is(info2.model, 'claude-3-opus');
-});
-
-// ============================================================================
-// Integration Tests
-// ============================================================================
-
-test('complete session tracking flow', async t => {
-	// Initialize session
-	initializeSession('openai', 'gpt-4');
-
-	const tracker = getCurrentSession();
-	t.truthy(tracker);
-
-	// Get current stats
-	const tokenizer = new MockTokenizer();
-	const messages = createMockMessages();
-	const stats = await tracker!.getCurrentStats(messages, tokenizer);
-
-	t.is(stats.provider, 'openai');
-	t.is(stats.model, 'gpt-4');
-	t.is(stats.messageCount, 3);
-	t.true(stats.tokens.total > 0);
-
-	// Save session
-	tracker!.saveSession(messages, tokenizer);
-
-	// Verify session was saved
-	const data = readUsageData();
-	t.is(data.sessions.length, 1);
-
-	const savedSession = data.sessions[0]!;
-	t.is(savedSession.provider, 'openai');
-	t.is(savedSession.model, 'gpt-4');
-	t.is(savedSession.messageCount, 3);
-
-	// Clear session
-	clearCurrentSession();
-	t.is(getCurrentSession(), null);
-});
-
-test('session tracking across provider/model changes', async t => {
-	// Initialize with first provider/model
-	initializeSession('openai', 'gpt-4');
-	const tracker = getCurrentSession()!;
-
-	// Change provider/model
-	tracker.updateProviderModel('anthropic', 'claude-3-opus');
-
-	// Get stats
-	const tokenizer = new MockTokenizer();
-	const messages = createMockMessages();
-	const stats = await tracker.getCurrentStats(messages, tokenizer);
-
-	t.is(stats.provider, 'anthropic');
-	t.is(stats.model, 'claude-3-opus');
-
-	// Save session
-	tracker.saveSession(messages, tokenizer);
-
-	// Verify correct provider/model was saved
-	const data = readUsageData();
-	const session = data.sessions[0]!;
-
-	t.is(session.provider, 'anthropic');
-	t.is(session.model, 'claude-3-opus');
-});
-
-test('multiple sessions tracked correctly', t => {
-	const tokenizer = new MockTokenizer();
-	const messages = createMockMessages();
-
-	// Session 1
-	initializeSession('openai', 'gpt-4');
-	getCurrentSession()!.saveSession(messages, tokenizer);
-
-	// Session 2
-	initializeSession('anthropic', 'claude');
-	getCurrentSession()!.saveSession(messages, tokenizer);
-
-	// Session 3
-	initializeSession('openai', 'gpt-3.5');
-	getCurrentSession()!.saveSession(messages, tokenizer);
-
-	// Verify all sessions saved
-	const data = readUsageData();
-	t.is(data.sessions.length, 3);
-
-	// Verify they're in reverse order (most recent first)
-	t.is(data.sessions[0]!.model, 'gpt-3.5');
-	t.is(data.sessions[1]!.model, 'claude');
-	t.is(data.sessions[2]!.model, 'gpt-4');
-});