salmon-loop 0.2.3

package/dist/core/context/token/adaptive-budget.js

@@ -0,0 +1,364 @@
+/**
+ * Adaptive Context Budget Module.
+ *
+ * Implements priority-layered budget resolution:
+ * 1. Memory cache (transparent acceleration layer)
+ * 2. User configuration (highest authority)
+ * 3. API query (real-time authority) - placeholder for future
+ * 4. Static config library (MODEL_CONTEXT_CONFIG)
+ * 5. Conservative default values
+ *
+ * Design Principles:
+ * - SSOT: Single source of truth for budget configuration
+ * - Extensibility: Easy to add new models/providers
+ * - Performance: Memory cache for hot path
+ * - User override: User config takes precedence
+ */
+/**
+ * Static model context configuration library.
+ * Contains known model configurations.
+ *
+ * Add new models here when they become available.
+ * Budget values are conservative estimates based on:
+ * - Context window size
+ * - Output buffer requirements
+ * - Safety margins
+ */
+export const MODEL_CONTEXT_CONFIG = {
+    // OpenAI GPT-4 family
+    'openai-gpt4': {
+        modelFamily: 'openai-gpt4',
+        maxContextWindow: 128000,
+        recommendedBudget: 30000,
+        minBudget: 5000,
+        maxPrimaryTokens: 12000,
+        outputBuffer: 4096,
+        supportsCaching: true,
+        provider: 'openai',
+    },
+    'openai-gpt4-turbo': {
+        modelFamily: 'openai-gpt4',
+        maxContextWindow: 128000,
+        recommendedBudget: 30000,
+        minBudget: 5000,
+        maxPrimaryTokens: 12000,
+        outputBuffer: 4096,
+        supportsCaching: true,
+        provider: 'openai',
+    },
+    'openai-gpt4o': {
+        modelFamily: 'openai-gpt4o',
+        maxContextWindow: 128000,
+        recommendedBudget: 30000,
+        minBudget: 5000,
+        maxPrimaryTokens: 12000,
+        outputBuffer: 4096,
+        supportsCaching: true,
+        provider: 'openai',
+    },
+    'openai-gpt4o-mini': {
+        modelFamily: 'openai-gpt4o',
+        maxContextWindow: 128000,
+        recommendedBudget: 25000,
+        minBudget: 4000,
+        maxPrimaryTokens: 10000,
+        outputBuffer: 4096,
+        supportsCaching: true,
+        provider: 'openai',
+    },
+    'openai-gpt35-turbo': {
+        modelFamily: 'openai-gpt35',
+        maxContextWindow: 16385,
+        recommendedBudget: 12000,
+        minBudget: 3000,
+        maxPrimaryTokens: 6000,
+        outputBuffer: 4096,
+        provider: 'openai',
+    },
+    // Anthropic Claude family
+    'anthropic-claude': {
+        modelFamily: 'anthropic-claude',
+        maxContextWindow: 200000,
+        recommendedBudget: 50000,
+        minBudget: 8000,
+        maxPrimaryTokens: 20000,
+        outputBuffer: 8192,
+        supportsCaching: true,
+        provider: 'anthropic',
+    },
+    'anthropic-claude-sonnet': {
+        modelFamily: 'anthropic-claude',
+        maxContextWindow: 200000,
+        recommendedBudget: 40000,
+        minBudget: 6000,
+        maxPrimaryTokens: 15000,
+        outputBuffer: 8192,
+        supportsCaching: true,
+        provider: 'anthropic',
+    },
+    'anthropic-claude-haiku': {
+        modelFamily: 'anthropic-claude',
+        maxContextWindow: 200000,
+        recommendedBudget: 30000,
+        minBudget: 5000,
+        maxPrimaryTokens: 12000,
+        outputBuffer: 8192,
+        supportsCaching: true,
+        provider: 'anthropic',
+    },
+    // Generic/fallback configurations
+    'default-small': {
+        modelFamily: 'default',
+        maxContextWindow: 8000,
+        recommendedBudget: 4000,
+        minBudget: 1500,
+        maxPrimaryTokens: 3000,
+        outputBuffer: 2048,
+        provider: 'generic',
+    },
+    'default-medium': {
+        modelFamily: 'default',
+        maxContextWindow: 32000,
+        recommendedBudget: 15000,
+        minBudget: 4000,
+        maxPrimaryTokens: 8000,
+        outputBuffer: 4096,
+        provider: 'generic',
+    },
+    'default-large': {
+        modelFamily: 'default',
+        maxContextWindow: 128000,
+        recommendedBudget: 30000,
+        minBudget: 5000,
+        maxPrimaryTokens: 12000,
+        outputBuffer: 4096,
+        provider: 'generic',
+    },
+};
+/**
+ * Model alias map for flexible model name matching.
+ * Maps various model identifiers to canonical names.
+ */
+const MODEL_ALIASES = {
+    // OpenAI aliases
+    'gpt-4': 'openai-gpt4',
+    'gpt-4-turbo': 'openai-gpt4-turbo',
+    'gpt-4-turbo-preview': 'openai-gpt4-turbo',
+    'gpt-4o': 'openai-gpt4o',
+    'gpt-4o-mini': 'openai-gpt4o-mini',
+    'gpt-3.5-turbo': 'openai-gpt35-turbo',
+    'gpt-3.5': 'openai-gpt35-turbo',
+    // Anthropic aliases
+    claude: 'anthropic-claude',
+    'claude-3': 'anthropic-claude',
+    'claude-3-opus': 'anthropic-claude',
+    'claude-3-sonnet': 'anthropic-claude-sonnet',
+    'claude-3-haiku': 'anthropic-claude-haiku',
+    'claude-3.5-sonnet': 'anthropic-claude-sonnet',
+    'claude-3.5-haiku': 'anthropic-claude-haiku',
+    // Default aliases
+    default: 'default-medium',
+    unknown: 'default-medium',
+};
+/**
+ * Adaptive budget calculator with priority-layered resolution.
+ *
+ * Resolution priority:
+ * 1. Memory cache (transparent acceleration)
+ * 2. User configuration (highest authority)
+ * 3. API query (real-time authority) - future extension
+ * 4. Static config library (MODEL_CONTEXT_CONFIG)
+ * 5. Conservative default values
+ */
+export class AdaptiveBudgetCalculator {
+    memoryCache = new Map();
+    userConfig = null;
+    cacheTTL = 60000; // 1 minute TTL for memory cache
+    /**
+     * Set user configuration override.
+     * User config has highest authority.
+     */
+    setUserConfig(config) {
+        this.userConfig = config;
+        // Clear cache when user config changes
+        this.memoryCache.clear();
+    }
+    /**
+     * Get user configuration.
+     */
+    getUserConfig() {
+        return this.userConfig;
+    }
+    /**
+     * Resolve model context configuration.
+     *
+     * @param modelId - Model identifier (e.g., 'gpt-4o', 'claude-3-sonnet')
+     * @returns Resolved configuration with user overrides applied
+     */
+    resolveConfig(modelId) {
+        const normalizedId = this.normalizeModelId(modelId);
+        // 1. Check memory cache
+        const cached = this.getFromCache(normalizedId);
+        if (cached) {
+            return this.applyUserOverride(cached);
+        }
+        // 2. Check user config for model-specific override (future: per-model user config)
+        // 3. API query placeholder (future extension point)
+        // const apiConfig = await this.fetchFromAPI(normalizedId);
+        // 4. Static config library
+        const staticConfig = MODEL_CONTEXT_CONFIG[normalizedId];
+        if (staticConfig) {
+            this.setCache(normalizedId, staticConfig);
+            return this.applyUserOverride(staticConfig);
+        }
+        // 5. Conservative default
+        const defaultConfig = this.getDefaultConfig(modelId);
+        this.setCache(normalizedId, defaultConfig);
+        return this.applyUserOverride(defaultConfig);
+    }
+    /**
+     * Get recommended budget for model.
+     */
+    getRecommendedBudget(modelId) {
+        const config = this.resolveConfig(modelId);
+        return config.recommendedBudget;
+    }
+    /**
+     * Get minimum budget for model.
+     */
+    getMinBudget(modelId) {
+        const config = this.resolveConfig(modelId);
+        return config.minBudget;
+    }
+    /**
+     * Get maximum primary tokens for model.
+     */
+    getMaxPrimaryTokens(modelId) {
+        const config = this.resolveConfig(modelId);
+        return config.maxPrimaryTokens;
+    }
+    /**
+     * Clear memory cache.
+     */
+    clearCache() {
+        this.memoryCache.clear();
+    }
+    /**
+     * Normalize model ID to canonical form.
+     */
+    normalizeModelId(modelId) {
+        const lowercased = modelId.toLowerCase().trim();
+        // Check alias map
+        if (MODEL_ALIASES[lowercased]) {
+            return MODEL_ALIASES[lowercased];
+        }
+        // Check if it exists in static config
+        if (MODEL_CONTEXT_CONFIG[lowercased]) {
+            return lowercased;
+        }
+        // Try partial matching for flexibility
+        for (const [alias, canonical] of Object.entries(MODEL_ALIASES)) {
+            if (lowercased.includes(alias) || alias.includes(lowercased)) {
+                return canonical;
+            }
+        }
+        // Return as-is, will fall back to default
+        return lowercased;
+    }
+    /**
+     * Get from memory cache.
+     */
+    getFromCache(modelId) {
+        const entry = this.memoryCache.get(modelId);
+        if (!entry)
+            return null;
+        // Check TTL
+        if (Date.now() - entry.timestamp > this.cacheTTL) {
+            this.memoryCache.delete(modelId);
+            return null;
+        }
+        return entry.config;
+    }
+    /**
+     * Set memory cache.
+     */
+    setCache(modelId, config) {
+        this.memoryCache.set(modelId, {
+            config,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Apply user override to config.
+     */
+    applyUserOverride(config) {
+        if (!this.userConfig)
+            return config;
+        return {
+            ...config,
+            recommendedBudget: this.userConfig.recommendedBudget ?? config.recommendedBudget,
+            minBudget: this.userConfig.minBudget ?? config.minBudget,
+            maxPrimaryTokens: this.userConfig.maxPrimaryTokens ?? config.maxPrimaryTokens,
+            outputBuffer: this.userConfig.outputBuffer ?? config.outputBuffer,
+        };
+    }
+    /**
+     * Get default config for unknown models.
+     * Uses conservative values from LIMITS.
+     */
+    getDefaultConfig(modelId) {
+        // Determine default tier based on model name hints
+        const lowercased = modelId.toLowerCase();
+        if (lowercased.includes('mini') ||
+            lowercased.includes('small') ||
+            lowercased.includes('haiku')) {
+            return MODEL_CONTEXT_CONFIG['default-small'];
+        }
+        if (lowercased.includes('large') ||
+            lowercased.includes('opus') ||
+            lowercased.includes('claude')) {
+            return MODEL_CONTEXT_CONFIG['default-large'];
+        }
+        // Default to medium
+        return MODEL_CONTEXT_CONFIG['default-medium'];
+    }
+}
+/**
+ * Global adaptive budget calculator instance.
+ * Singleton for consistent budget resolution across the application.
+ */
+let globalInstance = null;
+/**
+ * Get the global adaptive budget calculator instance.
+ */
+export function getAdaptiveBudgetCalculator() {
+    if (!globalInstance) {
+        globalInstance = new AdaptiveBudgetCalculator();
+    }
+    return globalInstance;
+}
+/**
+ * Reset the global instance (for testing).
+ */
+export function resetAdaptiveBudgetCalculator() {
+    globalInstance = null;
+}
+/**
+ * Convenience function to get recommended budget.
+ */
+export function getModelRecommendedBudget(modelId) {
+    return getAdaptiveBudgetCalculator().getRecommendedBudget(modelId);
+}
+/**
+ * Convenience function to get minimum budget.
+ */
+export function getModelMinBudget(modelId) {
+    return getAdaptiveBudgetCalculator().getMinBudget(modelId);
+}
+/**
+ * Convenience function to get max primary tokens.
+ */
+export function getModelMaxPrimaryTokens(modelId) {
+    return getAdaptiveBudgetCalculator().getMaxPrimaryTokens(modelId);
+}
+//# sourceMappingURL=adaptive-budget.js.map

package/dist/core/context/token/cache.js

@@ -0,0 +1,163 @@
+/**
+ * Token cache with two-level caching strategy.
+ *
+ * Level 1: Memory LRU cache (content hash → token count)
+ * Level 2: File-level cache (file path + mtime → token count)
+ */
+import { createHash } from 'crypto';
+import { FileAdapter } from '../../adapters/fs/file-adapter.js';
+/**
+ * Two-level token cache for performance optimization.
+ *
+ * Features:
+ * - LRU eviction policy
+ * - File modification time validation
+ * - Statistics for monitoring
+ */
+export class TokenCache {
+    memoryCache;
+    fileCache;
+    maxSize;
+    fileAdapter = new FileAdapter();
+    hits = 0;
+    misses = 0;
+    constructor(maxSize = 1000) {
+        this.memoryCache = new Map();
+        this.fileCache = new Map();
+        this.maxSize = maxSize;
+    }
+    // ==================== Memory Cache ====================
+    /**
+     * Get from memory cache by content.
+     */
+    getFromMemory(content) {
+        const hash = this.hashContent(content);
+        const entry = this.memoryCache.get(hash);
+        if (entry) {
+            this.hits++;
+            // Move to end for LRU
+            this.memoryCache.delete(hash);
+            this.memoryCache.set(hash, entry);
+            return entry.tokens;
+        }
+        this.misses++;
+        return null;
+    }
+    /**
+     * Set to memory cache.
+     */
+    setToMemory(content, tokens) {
+        const hash = this.hashContent(content);
+        // LRU eviction: remove oldest entry
+        if (this.memoryCache.size >= this.maxSize) {
+            const firstKey = this.memoryCache.keys().next().value;
+            if (firstKey) {
+                this.memoryCache.delete(firstKey);
+            }
+        }
+        this.memoryCache.set(hash, { contentHash: hash, tokens });
+    }
+    // ==================== File Cache ====================
+    /**
+     * Get from file cache (validates mtime).
+     */
+    async getFromFile(filePath) {
+        try {
+            const entry = this.fileCache.get(filePath);
+            if (!entry) {
+                this.misses++;
+                return null;
+            }
+            // Validate modification time
+            const stats = await this.fileAdapter.stat(filePath);
+            if (stats.mtimeMs !== entry.mtime) {
+                // File changed, invalidate
+                this.fileCache.delete(filePath);
+                this.misses++;
+                return null;
+            }
+            this.hits++;
+            // Move to end for LRU
+            this.fileCache.delete(filePath);
+            this.fileCache.set(filePath, entry);
+            return entry;
+        }
+        catch {
+            // File doesn't exist or can't be accessed
+            this.fileCache.delete(filePath);
+            this.misses++;
+            return null;
+        }
+    }
+    /**
+     * Set file cache entry.
+     */
+    async setForFile(filePath, content, tokens) {
+        try {
+            const stats = await this.fileAdapter.stat(filePath);
+            // LRU eviction
+            if (this.fileCache.size >= this.maxSize) {
+                const firstKey = this.fileCache.keys().next().value;
+                if (firstKey) {
+                    this.fileCache.delete(firstKey);
+                }
+            }
+            this.fileCache.set(filePath, {
+                tokens,
+                mtime: stats.mtimeMs,
+                contentHash: this.hashContent(content),
+            });
+        }
+        catch {
+            // Ignore if file can't be accessed
+        }
+    }
+    // ==================== Invalidation ====================
+    /**
+     * Invalidate specific file.
+     */
+    invalidateFile(filePath) {
+        this.fileCache.delete(filePath);
+    }
+    /**
+     * Invalidate by content hash prefix.
+     */
+    invalidateByHash(hashPrefix) {
+        for (const [key, entry] of this.memoryCache) {
+            if (entry.contentHash.startsWith(hashPrefix)) {
+                this.memoryCache.delete(key);
+            }
+        }
+    }
+    /**
+     * Clear all caches.
+     */
+    clear() {
+        this.memoryCache.clear();
+        this.fileCache.clear();
+        this.hits = 0;
+        this.misses = 0;
+    }
+    // ==================== Statistics ====================
+    /**
+     * Get cache statistics.
+     */
+    getStats() {
+        const total = this.hits + this.misses;
+        return {
+            hits: this.hits,
+            misses: this.misses,
+            size: this.memoryCache.size + this.fileCache.size,
+            maxSize: this.maxSize * 2,
+            hitRate: total === 0 ? 0 : this.hits / total,
+        };
+    }
+    // ==================== Private ====================
+    /**
+     * Hash content for cache key.
+     */
+    hashContent(content) {
+        return createHash('sha256').update(content, 'utf-8').digest('hex').slice(0, 16);
+    }
+}
+//# sourceMappingURL=cache.js.map

package/dist/core/context/token/counter.js

@@ -0,0 +1,190 @@
+/**
+ * TokenCounter - Facade for token counting operations.
+ *
+ * Provides a simple API for token counting while hiding the complexity
+ * of encoding selection, caching, and file operations.
+ */
+import { FileAdapter } from '../../adapters/fs/file-adapter.js';
+import { TokenCache } from './cache.js';
+import { EncodingRegistry } from './encoding-registry.js';
+/**
+ * Default configuration for TokenCounter.
+ */
+const DEFAULT_CONFIG = {
+    defaultEncoding: 'cl100k_base',
+    cacheMaxSize: 1000,
+    enableCache: true,
+};
+/**
+ * TokenCounter provides unified token counting with caching.
+ *
+ * Features:
+ * - Automatic encoding selection by model
+ * - Two-level caching (memory + file)
+ * - Batch operations
+ * - Statistics monitoring
+ *
+ * @example
+ * ```typescript
+ * const counter = new TokenCounter();
+ * await counter.initialize();
+ *
+ * // Simple counting
+ * const tokens = counter.count('Hello, world!');
+ *
+ * // Count for a model
+ * const tokens = counter.countByModel('Hello', 'openai-gpt4');
+ *
+ * // Count file with caching
+ * const result = await counter.countFile('/path/to/file.ts');
+ * ```
+ */
+export class TokenCounter {
+    registry;
+    cache;
+    config;
+    fileAdapter = new FileAdapter();
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.registry = new EncodingRegistry();
+        this.cache = new TokenCache(this.config.cacheMaxSize);
+    }
+    // ==================== Lifecycle ====================
+    /**
+     * Initialize encodings. Call once at application startup.
+     */
+    async initialize() {
+        await this.registry.initializeAll();
+    }
+    /**
+     * Dispose resources. Call at application shutdown.
+     */
+    dispose() {
+        this.registry.disposeAll();
+        this.cache.clear();
+    }
+    /**
+     * Check if initialized.
+     */
+    isInitialized() {
+        return this.registry.isInitialized();
+    }
+    // ==================== Core Counting ====================
+    /**
+     * Count tokens in text.
+     */
+    count(text, encoding) {
+        const enc = encoding ?? this.config.defaultEncoding;
+        return this.registry.get(enc).count(text);
+    }
+    /**
+     * Count tokens with cache metadata.
+     */
+    countWithMeta(text, encoding) {
+        const enc = encoding ?? this.config.defaultEncoding;
+        // Check cache first
+        if (this.config.enableCache) {
+            const cached = this.cache.getFromMemory(text);
+            if (cached !== null) {
+                return { tokens: cached, cached: true, encoding: enc };
+            }
+        }
+        const tokens = this.registry.get(enc).count(text);
+        // Update cache
+        if (this.config.enableCache) {
+            this.cache.setToMemory(text, tokens);
+        }
+        return { tokens, cached: false, encoding: enc };
+    }
+    /**
+     * Count tokens for a specific model family.
+     */
+    countByModel(text, model) {
+        return this.registry.getByModel(model).count(text);
+    }
+    /**
+     * Count tokens with model and cache metadata.
+     */
+    countByModelWithMeta(text, model) {
+        const encoding = this.registry.getEncodingTypeForModel(model);
+        return this.countWithMeta(text, encoding);
+    }
+    // ==================== File Operations ====================
+    /**
+     * Count tokens in a file with caching.
+     */
+    async countFile(filePath, content, encoding) {
+        const enc = encoding ?? this.config.defaultEncoding;
+        // Check file cache
+        if (this.config.enableCache) {
+            const cached = await this.cache.getFromFile(filePath);
+            if (cached !== null) {
+                return { tokens: cached.tokens, cached: true, encoding: enc };
+            }
+        }
+        // Read content if not provided
+        const fileContent = content ?? (await this.readFileContent(filePath));
+        const tokens = this.count(fileContent, enc);
+        // Update cache
+        if (this.config.enableCache) {
+            await this.cache.setForFile(filePath, fileContent, tokens);
+        }
+        return { tokens, cached: false, encoding: enc };
+    }
+    // ==================== Batch Operations ====================
+    /**
+     * Count tokens for multiple texts.
+     */
+    countBatch(texts, encoding) {
+        return texts.map((text) => this.count(text, encoding));
+    }
+    /**
+     * Count total tokens for multiple texts.
+     */
+    countTotal(texts, encoding) {
+        return this.countBatch(texts, encoding).reduce((sum, n) => sum + n, 0);
+    }
+    // ==================== Cache Management ====================
+    /**
+     * Invalidate cache for a specific file.
+     */
+    invalidateFile(path) {
+        this.cache.invalidateFile(path);
+    }
+    /**
+     * Clear all caches.
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Get cache statistics.
+     */
+    getCacheStats() {
+        return this.cache.getStats();
+    }
+    // ==================== Registry Access ====================
+    /**
+     * Get all registered encodings.
+     */
+    getRegisteredEncodings() {
+        return this.registry.listEncodings();
+    }
+    /**
+     * Get all registered models.
+     */
+    getRegisteredModels() {
+        return this.registry.listModels();
+    }
+    /**
+     * Get encoding for a model.
+     */
+    getEncodingForModel(model) {
+        return this.registry.getEncodingTypeForModel(model);
+    }
+    // ==================== Private ====================
+    async readFileContent(path) {
+        return this.fileAdapter.readFile(path, 'utf-8');
+    }
+}
+//# sourceMappingURL=counter.js.map