@gguf/coder 0.3.0 → 0.3.1

package/source/usage/storage.ts

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

@@ -0,0 +1,456 @@
+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');
+});