genai-lite 0.1.0 → 0.1.3

package/dist/llm/config.test.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("./config");
+describe('LLM Config', () => {
+    describe('isProviderSupported', () => {
+        it('should correctly identify supported providers', () => {
+            expect((0, config_1.isProviderSupported)('openai')).toBe(true);
+            expect((0, config_1.isProviderSupported)('anthropic')).toBe(true);
+            expect((0, config_1.isProviderSupported)('gemini')).toBe(true);
+        });
+        it('should return false for unsupported providers', () => {
+            expect((0, config_1.isProviderSupported)('unsupported-provider')).toBe(false);
+            expect((0, config_1.isProviderSupported)('')).toBe(false);
+        });
+    });
+    describe('getProviderById', () => {
+        it('should return provider info for valid providers', () => {
+            const openaiProvider = (0, config_1.getProviderById)('openai');
+            expect(openaiProvider).toBeDefined();
+            expect(openaiProvider?.id).toBe('openai');
+            expect(openaiProvider?.name).toBe('OpenAI');
+        });
+        it('should return undefined for invalid providers', () => {
+            expect((0, config_1.getProviderById)('unsupported-provider')).toBeUndefined();
+            expect((0, config_1.getProviderById)('')).toBeUndefined();
+        });
+    });
+    describe('getModelById', () => {
+        it('should return model info for valid model and provider combination', () => {
+            const model = (0, config_1.getModelById)('gpt-4.1', 'openai');
+            expect(model).toBeDefined();
+            expect(model?.id).toBe('gpt-4.1');
+            expect(model?.providerId).toBe('openai');
+        });
+        it('should return undefined for invalid model or provider', () => {
+            expect((0, config_1.getModelById)('invalid-model', 'openai')).toBeUndefined();
+            expect((0, config_1.getModelById)('gpt-4.1', 'anthropic')).toBeUndefined();
+            expect((0, config_1.getModelById)('gpt-4.1', 'invalid-provider')).toBeUndefined();
+        });
+    });
+    describe('getModelsByProvider', () => {
+        it('should return models for valid providers', () => {
+            const openaiModels = (0, config_1.getModelsByProvider)('openai');
+            expect(openaiModels.length).toBeGreaterThan(0);
+            expect(openaiModels.every(model => model.providerId === 'openai')).toBe(true);
+        });
+        it('should return empty array for invalid providers', () => {
+            expect((0, config_1.getModelsByProvider)('invalid-provider')).toEqual([]);
+            expect((0, config_1.getModelsByProvider)('')).toEqual([]);
+        });
+    });
+    describe('isModelSupported', () => {
+        it('should correctly identify supported model/provider combinations', () => {
+            expect((0, config_1.isModelSupported)('gpt-4.1', 'openai')).toBe(true);
+            expect((0, config_1.isModelSupported)('claude-sonnet-4-20250514', 'anthropic')).toBe(true);
+            expect((0, config_1.isModelSupported)('gemini-2.5-pro', 'gemini')).toBe(true);
+        });
+        it('should return false for unsupported combinations', () => {
+            expect((0, config_1.isModelSupported)('gpt-4.1', 'anthropic')).toBe(false);
+            expect((0, config_1.isModelSupported)('claude-sonnet-4-20250514', 'openai')).toBe(false);
+            expect((0, config_1.isModelSupported)('invalid-model', 'openai')).toBe(false);
+        });
+    });
+    describe('getDefaultSettingsForModel', () => {
+        it('should return default settings for valid models', () => {
+            const settings = (0, config_1.getDefaultSettingsForModel)('gpt-4.1', 'openai');
+            expect(settings).toBeDefined();
+            expect(settings.temperature).toBeDefined();
+            expect(settings.maxTokens).toBeDefined();
+            expect(settings.topP).toBeDefined();
+        });
+        it('should apply model-specific overrides', () => {
+            const gpt4Settings = (0, config_1.getDefaultSettingsForModel)('gpt-4.1', 'openai');
+            const gpt4MiniSettings = (0, config_1.getDefaultSettingsForModel)('gpt-4.1-mini', 'openai');
+            // These might have different maxTokens based on model capabilities
+            expect(gpt4Settings.maxTokens).toBeDefined();
+            expect(gpt4MiniSettings.maxTokens).toBeDefined();
+        });
+    });
+    describe('validateLLMSettings', () => {
+        it('should return empty array for valid settings', () => {
+            const validSettings = {
+                temperature: 0.7,
+                maxTokens: 1000,
+                topP: 0.9,
+                frequencyPenalty: 0.5,
+                presencePenalty: -0.5,
+                stopSequences: ['\\n', 'END'],
+                user: 'test-user'
+            };
+            expect((0, config_1.validateLLMSettings)(validSettings)).toEqual([]);
+        });
+        it('should validate temperature bounds', () => {
+            expect((0, config_1.validateLLMSettings)({ temperature: -0.1 })).toContain('temperature must be a number between 0 and 2');
+            expect((0, config_1.validateLLMSettings)({ temperature: 2.1 })).toContain('temperature must be a number between 0 and 2');
+            expect((0, config_1.validateLLMSettings)({ temperature: 'invalid' })).toContain('temperature must be a number between 0 and 2');
+        });
+        it('should validate maxTokens', () => {
+            expect((0, config_1.validateLLMSettings)({ maxTokens: 0 })).toContain('maxTokens must be an integer between 1 and 100000');
+            expect((0, config_1.validateLLMSettings)({ maxTokens: 100001 })).toContain('maxTokens must be an integer between 1 and 100000');
+            expect((0, config_1.validateLLMSettings)({ maxTokens: 1.5 })).toContain('maxTokens must be an integer between 1 and 100000');
+        });
+        it('should validate topP bounds', () => {
+            expect((0, config_1.validateLLMSettings)({ topP: -0.1 })).toContain('topP must be a number between 0 and 1');
+            expect((0, config_1.validateLLMSettings)({ topP: 1.1 })).toContain('topP must be a number between 0 and 1');
+        });
+        it('should validate frequencyPenalty bounds', () => {
+            expect((0, config_1.validateLLMSettings)({ frequencyPenalty: -2.1 })).toContain('frequencyPenalty must be a number between -2 and 2');
+            expect((0, config_1.validateLLMSettings)({ frequencyPenalty: 2.1 })).toContain('frequencyPenalty must be a number between -2 and 2');
+        });
+        it('should validate presencePenalty bounds', () => {
+            expect((0, config_1.validateLLMSettings)({ presencePenalty: -2.1 })).toContain('presencePenalty must be a number between -2 and 2');
+            expect((0, config_1.validateLLMSettings)({ presencePenalty: 2.1 })).toContain('presencePenalty must be a number between -2 and 2');
+        });
+        it('should validate stopSequences', () => {
+            expect((0, config_1.validateLLMSettings)({ stopSequences: 'invalid' })).toContain('stopSequences must be an array');
+            expect((0, config_1.validateLLMSettings)({ stopSequences: ['1', '2', '3', '4', '5'] })).toContain('stopSequences can contain at most 4 sequences');
+            expect((0, config_1.validateLLMSettings)({ stopSequences: ['valid', ''] })).toContain('stopSequences must contain only non-empty strings');
+            expect((0, config_1.validateLLMSettings)({ stopSequences: ['valid', 123] })).toContain('stopSequences must contain only non-empty strings');
+        });
+        it('should validate user field', () => {
+            expect((0, config_1.validateLLMSettings)({ user: 123 })).toContain('user must be a string');
+        });
+        it('should validate geminiSafetySettings', () => {
+            const invalidSettings = { geminiSafetySettings: 'invalid' };
+            expect((0, config_1.validateLLMSettings)(invalidSettings)).toContain('geminiSafetySettings must be an array');
+            const invalidCategory = {
+                geminiSafetySettings: [
+                    { category: 'INVALID_CATEGORY', threshold: 'BLOCK_NONE' }
+                ]
+            };
+            expect((0, config_1.validateLLMSettings)(invalidCategory)).toContain('geminiSafetySettings[0].category must be a valid Gemini harm category');
+            const invalidThreshold = {
+                geminiSafetySettings: [
+                    { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'INVALID_THRESHOLD' }
+                ]
+            };
+            expect((0, config_1.validateLLMSettings)(invalidThreshold)).toContain('geminiSafetySettings[0].threshold must be a valid Gemini harm block threshold');
+            const validGeminiSettings = {
+                geminiSafetySettings: [
+                    { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_NONE' }
+                ]
+            };
+            expect((0, config_1.validateLLMSettings)(validGeminiSettings)).toEqual([]);
+        });
+        it('should return multiple errors for multiple invalid fields', () => {
+            const invalidSettings = {
+                temperature: -1,
+                maxTokens: 0,
+                topP: 2
+            };
+            const errors = (0, config_1.validateLLMSettings)(invalidSettings);
+            expect(errors).toHaveLength(3);
+            expect(errors).toContain('temperature must be a number between 0 and 2');
+            expect(errors).toContain('maxTokens must be an integer between 1 and 100000');
+            expect(errors).toContain('topP must be a number between 0 and 1');
+        });
+    });
+});

package/dist/providers/fromEnvironment.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/providers/fromEnvironment.test.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fromEnvironment_1 = require("./fromEnvironment");
+describe('fromEnvironment', () => {
+    const OLD_ENV = process.env;
+    beforeEach(() => {
+        jest.resetModules(); // Clear cache
+        process.env = { ...OLD_ENV }; // Make a copy
+    });
+    afterAll(() => {
+        process.env = OLD_ENV; // Restore old environment
+    });
+    it('should retrieve an existing environment variable', async () => {
+        process.env.OPENAI_API_KEY = 'test-openai-key';
+        const key = await (0, fromEnvironment_1.fromEnvironment)('openai');
+        expect(key).toBe('test-openai-key');
+    });
+    it('should convert provider ID to uppercase', async () => {
+        process.env.ANTHROPIC_API_KEY = 'test-anthropic-key';
+        const key = await (0, fromEnvironment_1.fromEnvironment)('anthropic');
+        expect(key).toBe('test-anthropic-key');
+    });
+    it('should handle mixed case provider IDs', async () => {
+        process.env.GEMINI_API_KEY = 'test-gemini-key';
+        const key = await (0, fromEnvironment_1.fromEnvironment)('GeMiNi');
+        expect(key).toBe('test-gemini-key');
+    });
+    it('should return null for a non-existent environment variable', async () => {
+        const key = await (0, fromEnvironment_1.fromEnvironment)('nonexistent');
+        expect(key).toBeNull();
+    });
+    it('should return null for empty provider ID', async () => {
+        const key = await (0, fromEnvironment_1.fromEnvironment)('');
+        expect(key).toBeNull();
+    });
+    it('should handle special characters in provider ID', async () => {
+        process.env['PROVIDER-123_API_KEY'] = 'test-special-key';
+        const key = await (0, fromEnvironment_1.fromEnvironment)('provider-123');
+        expect(key).toBe('test-special-key');
+    });
+    it('should return null when environment variable exists but is empty', async () => {
+        process.env.EMPTY_API_KEY = '';
+        const key = await (0, fromEnvironment_1.fromEnvironment)('empty');
+        expect(key).toBeNull(); // Empty string is falsy, so || null returns null
+    });
+});

package/dist/types/presets.d.ts

@@ -0,0 +1,19 @@
+import type { ApiProviderId, LLMSettings } from '../llm/types';
+/**
+ * Represents a model preset with pre-configured LLM settings
+ * optimized for common use cases.
+ */
+export interface ModelPreset {
+    /** Unique preset identifier, e.g., "gemini-pro-creative-writing" */
+    id: string;
+    /** User-friendly display name, e.g., "Google Gemini - gemini-1.5-pro-002 (Creative)" */
+    displayName: string;
+    /** Optional description of the preset's intended use case */
+    description?: string;
+    /** Provider ID that matches an entry in SUPPORTED_PROVIDERS */
+    providerId: ApiProviderId;
+    /** Model ID that matches a supported model for the given providerId */
+    modelId: string;
+    /** Preset-specific LLM settings, can include provider-specific configurations */
+    settings: Partial<LLMSettings>;
+}

package/dist/types/presets.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './prompt';

package/dist/utils/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./prompt"), exports);

package/dist/utils/prompt.d.ts

@@ -0,0 +1,6 @@
+import { TiktokenModel } from 'js-tiktoken';
+export declare function countTokens(text: string, model?: TiktokenModel): number;
+export declare function getSmartPreview(content: string, config: {
+    minLines: number;
+    maxLines: number;
+}): string;

package/dist/utils/prompt.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countTokens = countTokens;
+exports.getSmartPreview = getSmartPreview;
+const js_tiktoken_1 = require("js-tiktoken");
+const tokenizerCache = new Map();
+function getTokenizer(model) {
+    if (tokenizerCache.has(model)) {
+        return tokenizerCache.get(model);
+    }
+    try {
+        const tokenizer = (0, js_tiktoken_1.encodingForModel)(model);
+        tokenizerCache.set(model, tokenizer);
+        return tokenizer;
+    }
+    catch (error) {
+        console.error(`Failed to initialize tokenizer for model ${model}:`, error);
+        throw error;
+    }
+}
+function countTokens(text, model = 'gpt-4') {
+    if (!text)
+        return 0;
+    try {
+        const tokenizer = getTokenizer(model);
+        return tokenizer.encode(text).length;
+    }
+    catch (error) {
+        // Fallback to a rough estimate if tokenizer fails for any reason
+        return Math.ceil(text.length / 4);
+    }
+}
+function getSmartPreview(content, config) {
+    const lines = content.split('\n');
+    // If the file is not longer than maxLines, return it in full
+    if (lines.length <= config.maxLines) {
+        return content;
+    }
+    // Always show at least minLines
+    let endLine = config.minLines;
+    let emptyLinesCount = lines
+        .slice(0, config.minLines)
+        .filter((line) => line.trim() === '').length;
+    // If we haven't found at least two empty lines, keep looking up to maxLines
+    if (emptyLinesCount < 2 && lines.length > config.minLines) {
+        for (let i = config.minLines; i < Math.min(lines.length, config.maxLines); i++) {
+            if (lines[i].trim() === '') {
+                endLine = i + 1; // Include the empty line
+                break;
+            }
+            endLine = i + 1;
+        }
+    }
+    return lines.slice(0, endLine).join('\n') + '\n... (content truncated)';
+}

package/dist/utils/prompt.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/prompt.test.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompt_1 = require("./prompt");
+describe('Prompt Utilities', () => {
+    describe('countTokens', () => {
+        it('should return 0 for empty string', () => {
+            expect((0, prompt_1.countTokens)('')).toBe(0);
+        });
+        it('should count tokens for simple text', () => {
+            const text = 'Hello, world!';
+            const count = (0, prompt_1.countTokens)(text);
+            expect(count).toBeGreaterThan(0);
+            expect(count).toBeLessThan(text.length); // Tokens are typically fewer than characters
+        });
+        it('should count tokens with default gpt-4 model', () => {
+            const text = 'The quick brown fox jumps over the lazy dog';
+            const count = (0, prompt_1.countTokens)(text);
+            expect(count).toBeGreaterThan(0);
+        });
+        it('should count tokens with different models', () => {
+            const text = 'Testing different models';
+            const gpt4Count = (0, prompt_1.countTokens)(text, 'gpt-4');
+            const gpt35Count = (0, prompt_1.countTokens)(text, 'gpt-3.5-turbo');
+            expect(gpt4Count).toBeGreaterThan(0);
+            expect(gpt35Count).toBeGreaterThan(0);
+        });
+        it('should handle special characters and emojis', () => {
+            const text = '🚀 Special chars: @#$% and \n\t newlines';
+            const count = (0, prompt_1.countTokens)(text);
+            expect(count).toBeGreaterThan(0);
+        });
+        it('should fallback to estimate for invalid model', () => {
+            const text = 'Test fallback behavior';
+            const count = (0, prompt_1.countTokens)(text, 'invalid-model');
+            // Should fallback to length/4 estimate
+            expect(count).toBe(Math.ceil(text.length / 4));
+        });
+        it('should handle very long text', () => {
+            const longText = 'a'.repeat(10000);
+            const count = (0, prompt_1.countTokens)(longText);
+            expect(count).toBeGreaterThan(0);
+            expect(count).toBeLessThan(longText.length);
+        });
+    });
+    describe('getSmartPreview', () => {
+        const config = { minLines: 5, maxLines: 10 };
+        it('should return full content if shorter than maxLines', () => {
+            const content = 'Line 1\nLine 2\nLine 3';
+            const preview = (0, prompt_1.getSmartPreview)(content, config);
+            expect(preview).toBe(content);
+        });
+        it('should truncate at maxLines if no empty lines found', () => {
+            const lines = Array.from({ length: 20 }, (_, i) => `Line ${i + 1}`);
+            const content = lines.join('\n');
+            const preview = (0, prompt_1.getSmartPreview)(content, config);
+            const previewLines = preview.split('\n');
+            // Should extend up to maxLines when no empty lines are found
+            expect(previewLines.length).toBe(config.maxLines + 1); // +1 for truncation message
+            expect(preview).toContain('... (content truncated)');
+        });
+        it('should extend to next empty line within maxLines', () => {
+            const content = `Line 1
+Line 2
+Line 3
+Line 4
+Line 5
+Line 6
+
+Line 8
+Line 9
+Line 10
+Line 11`;
+            const preview = (0, prompt_1.getSmartPreview)(content, config);
+            const previewLines = preview.split('\n');
+            // Should include up to line 7 (the empty line)
+            expect(previewLines[6]).toBe('');
+            expect(preview).toContain('... (content truncated)');
+        });
+        it('should handle content exactly at maxLines', () => {
+            const lines = Array.from({ length: config.maxLines }, (_, i) => `Line ${i + 1}`);
+            const content = lines.join('\n');
+            const preview = (0, prompt_1.getSmartPreview)(content, config);
+            expect(preview).toBe(content);
+        });
+        it('should handle empty content', () => {
+            const preview = (0, prompt_1.getSmartPreview)('', config);
+            expect(preview).toBe('');
+        });
+        it('should handle content with multiple consecutive empty lines', () => {
+            const content = `Line 1
+Line 2
+
+
+Line 5
+Line 6
+
+Line 8
+Line 9
+Line 10
+Line 11`;
+            const preview = (0, prompt_1.getSmartPreview)(content, config);
+            const previewLines = preview.split('\n');
+            // Should stop at first empty line after minLines
+            expect(previewLines.length).toBeLessThanOrEqual(config.maxLines + 1);
+            expect(preview).toContain('... (content truncated)');
+        });
+        it('should respect maxLines limit even with empty lines', () => {
+            const lines = Array.from({ length: 15 }, (_, i) => i % 3 === 0 ? '' : `Line ${i + 1}`);
+            const content = lines.join('\n');
+            const preview = (0, prompt_1.getSmartPreview)(content, config);
+            const previewLines = preview.split('\n');
+            expect(previewLines.length).toBeLessThanOrEqual(config.maxLines + 1);
+        });
+    });
+});

package/package.json

@@ -1,9 +1,21 @@
 {
   "name": "genai-lite",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "A lightweight, portable toolkit for interacting with various Generative AI APIs.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./utils": {
+      "import": "./dist/utils/index.js",
+      "require": "./dist/utils/index.js",
+      "types": "./dist/utils/index.d.ts"
+    }
+  },
   "author": "Luigi Acerbi <luigi.acerbi@gmail.com>",
   "license": "MIT",
   "funding": {
@@ -18,15 +30,21 @@
     "url": "https://github.com/lacerbi/genai-lite/issues"
   },
   "homepage": "https://github.com/lacerbi/genai-lite#readme",
+  "files": [
+    "dist",
+    "src/config/presets.json"
+  ],
   "scripts": {
     "build": "tsc",
     "test": "jest --coverage",
-    "test:watch": "jest --watch"
+    "test:watch": "jest --watch",
+    "test:e2e": "npm run build && jest --config jest.e2e.config.js"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.52.0",
+    "@anthropic-ai/sdk": "^0.56.0",
     "@google/genai": "^1.0.1",
-    "openai": "^4.103.0"
+    "js-tiktoken": "^1.0.20",
+    "openai": "^5.8.2"
   },
   "devDependencies": {
     "@types/jest": ">=30.0.0",