@hazeljs/ai 0.2.0-alpha.1

package/dist/tracking/token.tracker.test.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('@hazeljs/core', () => ({
+    __esModule: true,
+    Service: () => () => undefined,
+    default: { info: jest.fn(), debug: jest.fn(), warn: jest.fn(), error: jest.fn() },
+}));
+const token_tracker_1 = require("./token.tracker");
+const NOW = Date.now();
+function makeUsage(overrides = {}) {
+    return {
+        promptTokens: 100,
+        completionTokens: 50,
+        totalTokens: 150,
+        timestamp: NOW,
+        ...overrides,
+    };
+}
+describe('TokenTracker', () => {
+    let tracker;
+    beforeEach(() => {
+        tracker = new token_tracker_1.TokenTracker();
+    });
+    describe('constructor', () => {
+        it('creates with defaults', () => {
+            expect(tracker).toBeDefined();
+        });
+        it('accepts custom config', () => {
+            const t = new token_tracker_1.TokenTracker({
+                maxTokensPerRequest: 1000,
+                maxTokensPerDay: 5000,
+                maxTokensPerMonth: 50000,
+            });
+            expect(t).toBeDefined();
+        });
+        it('uses partial config with defaults for missing fields', () => {
+            const t = new token_tracker_1.TokenTracker({ maxTokensPerRequest: 500 });
+            expect(t).toBeDefined();
+        });
+    });
+    describe('track()', () => {
+        it('tracks global usage', () => {
+            tracker.track(makeUsage());
+            const exported = tracker.exportData();
+            expect(exported).toHaveLength(1);
+            expect(exported[0].totalTokens).toBe(150);
+        });
+        it('tracks per-user usage when userId provided', () => {
+            tracker.track(makeUsage({ userId: 'user1' }));
+            const userData = tracker.exportData('user1');
+            expect(userData).toHaveLength(1);
+        });
+        it('appends to existing user history', () => {
+            tracker.track(makeUsage({ userId: 'user1' }));
+            tracker.track(makeUsage({ totalTokens: 200, userId: 'user1' }));
+            expect(tracker.exportData('user1')).toHaveLength(2);
+        });
+        it('calculates cost when model is provided and cost is missing', () => {
+            tracker.track({ promptTokens: 1000, completionTokens: 500, totalTokens: 1500, timestamp: NOW }, 'gpt-4-turbo-preview');
+            const exported = tracker.exportData();
+            expect(exported[0].cost).toBeGreaterThan(0);
+        });
+        it('does not recalculate if cost is already set', () => {
+            tracker.track(makeUsage({ cost: 0.999 }), 'gpt-4');
+            expect(tracker.exportData()[0].cost).toBe(0.999);
+        });
+        it('does not set cost when no model provided and cost is missing', () => {
+            tracker.track(makeUsage());
+            expect(tracker.exportData()[0].cost).toBeUndefined();
+        });
+    });
+    describe('checkLimits()', () => {
+        it('allows request within all limits', async () => {
+            const result = await tracker.checkLimits('user1', 100);
+            expect(result.allowed).toBe(true);
+        });
+        it('blocks request exceeding per-request limit', async () => {
+            const t = new token_tracker_1.TokenTracker({ maxTokensPerRequest: 10 });
+            const result = await t.checkLimits(undefined, 100);
+            expect(result.allowed).toBe(false);
+            expect(result.reason).toContain('Request exceeds token limit');
+        });
+        it('returns allowed when no userId and requestTokens within limit', async () => {
+            const result = await tracker.checkLimits(undefined, 50);
+            expect(result.allowed).toBe(true);
+        });
+        it('returns allowed with no arguments', async () => {
+            const result = await tracker.checkLimits();
+            expect(result.allowed).toBe(true);
+        });
+        it('blocks when daily limit exceeded', async () => {
+            const t = new token_tracker_1.TokenTracker({ maxTokensPerDay: 100, maxTokensPerMonth: 1000000 });
+            t.track({
+                promptTokens: 60,
+                completionTokens: 50,
+                totalTokens: 110,
+                timestamp: NOW,
+                userId: 'user1',
+            });
+            const result = await t.checkLimits('user1');
+            expect(result.allowed).toBe(false);
+            expect(result.reason).toBe('Daily token limit exceeded');
+        });
+        it('blocks when monthly limit exceeded', async () => {
+            const t = new token_tracker_1.TokenTracker({ maxTokensPerDay: 1000000, maxTokensPerMonth: 100 });
+            t.track({
+                promptTokens: 60,
+                completionTokens: 50,
+                totalTokens: 110,
+                timestamp: NOW,
+                userId: 'user1',
+            });
+            const result = await t.checkLimits('user1');
+            expect(result.allowed).toBe(false);
+            expect(result.reason).toBe('Monthly token limit exceeded');
+        });
+        it('returns usage info in response for user with history', async () => {
+            tracker.track(makeUsage({ userId: 'user1', totalTokens: 15 }));
+            const result = await tracker.checkLimits('user1');
+            expect(result.usage).toBeDefined();
+            expect(result.usage?.today).toBe(15);
+            expect(result.usage?.limit.daily).toBeDefined();
+        });
+        it('returns allowed true for user with no history', async () => {
+            const result = await tracker.checkLimits('newUser');
+            expect(result.allowed).toBe(true);
+        });
+    });
+    describe('calculateCost()', () => {
+        it('calculates cost for gpt-4', () => {
+            const cost = tracker.calculateCost(makeUsage({ promptTokens: 1000, completionTokens: 500 }), 'gpt-4');
+            expect(cost).toBeGreaterThan(0);
+        });
+        it('calculates cost for gpt-4-turbo-preview', () => {
+            const cost = tracker.calculateCost(makeUsage({ promptTokens: 1000, completionTokens: 500 }), 'gpt-4-turbo-preview');
+            expect(cost).toBeGreaterThan(0);
+        });
+        it('calculates cost for gpt-3.5-turbo', () => {
+            const cost = tracker.calculateCost(makeUsage({ promptTokens: 1000, completionTokens: 500 }), 'gpt-3.5-turbo');
+            expect(cost).toBeGreaterThan(0);
+        });
+        it('calculates cost for claude models', () => {
+            const models = ['claude-3-opus', 'claude-3-sonnet', 'claude-3-haiku'];
+            models.forEach((model) => {
+                const cost = tracker.calculateCost(makeUsage({ promptTokens: 1000, completionTokens: 500 }), model);
+                expect(cost).toBeGreaterThan(0);
+            });
+        });
+        it('returns 0 for unknown model', () => {
+            const cost = tracker.calculateCost(makeUsage(), 'unknown-model-xyz');
+            expect(cost).toBe(0);
+        });
+    });
+    describe('getUserStats()', () => {
+        it('returns zero stats for unknown user', () => {
+            const stats = tracker.getUserStats('nobody');
+            expect(stats.totalTokens).toBe(0);
+            expect(stats.requestCount).toBe(0);
+            expect(stats.averageTokensPerRequest).toBe(0);
+        });
+        it('returns correct stats for user with history', () => {
+            tracker.track(makeUsage({ totalTokens: 150, cost: 0.01, userId: 'user1' }));
+            tracker.track(makeUsage({ totalTokens: 300, cost: 0.02, userId: 'user1' }));
+            const stats = tracker.getUserStats('user1');
+            expect(stats.totalTokens).toBe(450);
+            expect(stats.requestCount).toBe(2);
+            expect(stats.totalCost).toBeCloseTo(0.03);
+            expect(stats.averageTokensPerRequest).toBe(225);
+        });
+        it('calculates dailyAverage', () => {
+            tracker.track(makeUsage({ totalTokens: 300, userId: 'user1' }));
+            const stats = tracker.getUserStats('user1', 30);
+            expect(stats.dailyAverage).toBe(10); // 300/30
+        });
+        it('excludes usage outside the time window', () => {
+            const old = NOW - 40 * 24 * 60 * 60 * 1000;
+            tracker.track(makeUsage({ totalTokens: 999, timestamp: old, userId: 'user1' }));
+            tracker.track(makeUsage({ totalTokens: 10, userId: 'user1' }));
+            const stats = tracker.getUserStats('user1', 30);
+            expect(stats.totalTokens).toBe(10);
+        });
+    });
+    describe('getGlobalStats()', () => {
+        it('returns zero stats when empty', () => {
+            const stats = tracker.getGlobalStats();
+            expect(stats.totalTokens).toBe(0);
+            expect(stats.requestCount).toBe(0);
+            expect(stats.uniqueUsers).toBe(0);
+            expect(stats.topUsers).toHaveLength(0);
+        });
+        it('returns correct stats with multiple users', () => {
+            tracker.track(makeUsage({ totalTokens: 150, userId: 'u1' }));
+            tracker.track(makeUsage({ totalTokens: 300, userId: 'u2' }));
+            tracker.track(makeUsage({ totalTokens: 75 })); // no userId
+            const stats = tracker.getGlobalStats();
+            expect(stats.totalTokens).toBe(525);
+            expect(stats.requestCount).toBe(3);
+            expect(stats.uniqueUsers).toBe(2);
+        });
+        it('returns top users sorted by token usage', () => {
+            tracker.track(makeUsage({ totalTokens: 100, userId: 'small' }));
+            tracker.track(makeUsage({ totalTokens: 500, userId: 'big' }));
+            const stats = tracker.getGlobalStats();
+            expect(stats.topUsers[0].userId).toBe('big');
+        });
+        it('limits top users to 10', () => {
+            for (let i = 0; i < 15; i++) {
+                tracker.track(makeUsage({ totalTokens: i * 10, userId: `user${i}` }));
+            }
+            const stats = tracker.getGlobalStats();
+            expect(stats.topUsers.length).toBeLessThanOrEqual(10);
+        });
+    });
+    describe('cleanup()', () => {
+        it('removes old global usage data', () => {
+            const old = NOW - 91 * 24 * 60 * 60 * 1000;
+            tracker.track(makeUsage({ totalTokens: 999, timestamp: old }));
+            tracker.track(makeUsage({ totalTokens: 15 }));
+            tracker.cleanup(90);
+            const exported = tracker.exportData();
+            expect(exported).toHaveLength(1);
+            expect(exported[0].totalTokens).toBe(15);
+        });
+        it('removes empty user entries after cleanup', () => {
+            const old = NOW - 100 * 24 * 60 * 60 * 1000;
+            tracker.track(makeUsage({ timestamp: old, userId: 'oldUser' }));
+            tracker.cleanup(90);
+            expect(tracker.exportData('oldUser')).toHaveLength(0);
+        });
+        it('keeps recent user entries after cleanup', () => {
+            const old = NOW - 100 * 24 * 60 * 60 * 1000;
+            tracker.track(makeUsage({ timestamp: old, userId: 'user1' }));
+            tracker.track(makeUsage({ userId: 'user1' }));
+            tracker.cleanup(90);
+            expect(tracker.exportData('user1')).toHaveLength(1);
+        });
+        it('uses default 90 days when no argument', () => {
+            const old = NOW - 95 * 24 * 60 * 60 * 1000;
+            tracker.track(makeUsage({ timestamp: old }));
+            tracker.cleanup();
+            expect(tracker.exportData()).toHaveLength(0);
+        });
+    });
+    describe('exportData()', () => {
+        it('exports all global data when no userId', () => {
+            tracker.track(makeUsage({ userId: 'u1' }));
+            tracker.track(makeUsage());
+            const data = tracker.exportData();
+            expect(data).toHaveLength(2);
+        });
+        it('returns empty array for unknown user', () => {
+            expect(tracker.exportData('nobody')).toEqual([]);
+        });
+        it('returns copy of global history', () => {
+            tracker.track(makeUsage());
+            const data = tracker.exportData();
+            expect(data).toHaveLength(1);
+        });
+    });
+    describe('updateConfig()', () => {
+        it('updates maxTokensPerRequest', async () => {
+            tracker.updateConfig({ maxTokensPerRequest: 2000 });
+            const result = await tracker.checkLimits(undefined, 1500);
+            expect(result.allowed).toBe(true);
+        });
+        it('merges config without overwriting unspecified fields', async () => {
+            tracker.updateConfig({ maxTokensPerRequest: 50 });
+            const result = await tracker.checkLimits(undefined, 100);
+            expect(result.allowed).toBe(false);
+        });
+    });
+});

package/dist/vector/vector.service.d.ts

@@ -0,0 +1,50 @@
+import { VectorStoreConfig, VectorDocument, VectorSearchRequest, VectorSearchResult, VectorDatabase } from '../ai-enhanced.types';
+/**
+ * Vector database service
+ *
+ * Note: This is a mock implementation. In production, you would use actual vector database clients:
+ * - Pinecone: npm install @pinecone-database/pinecone
+ * - Weaviate: npm install weaviate-ts-client
+ * - Qdrant: npm install @qdrant/js-client-rest
+ * - Chroma: npm install chromadb
+ */
+export declare class VectorService {
+    private config?;
+    private documents;
+    /**
+     * Initialize vector store
+     */
+    initialize(config: VectorStoreConfig): Promise<void>;
+    /**
+     * Upsert documents
+     */
+    upsert(documents: VectorDocument[]): Promise<void>;
+    /**
+     * Search for similar documents
+     */
+    search(request: VectorSearchRequest): Promise<VectorSearchResult[]>;
+    /**
+     * Delete documents
+     */
+    delete(ids: string[]): Promise<void>;
+    /**
+     * Get document by ID
+     */
+    get(id: string): Promise<VectorDocument | null>;
+    /**
+     * Clear all documents
+     */
+    clear(): Promise<void>;
+    /**
+     * Get statistics
+     */
+    getStats(): Promise<{
+        count: number;
+        database: VectorDatabase;
+    }>;
+    /**
+     * Calculate cosine similarity between two vectors
+     */
+    private cosineSimilarity;
+}
+//# sourceMappingURL=vector.service.d.ts.map

package/dist/vector/vector.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector.service.d.ts","sourceRoot":"","sources":["../../src/vector/vector.service.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAClB,cAAc,EACf,MAAM,sBAAsB,CAAC;AAI9B;;;;;;;;GAQG;AACH,qBACa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,CAAoB;IACnC,OAAO,CAAC,SAAS,CAA0C;IAE3D;;OAEG;IACG,UAAU,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB1D;;OAEG;IACG,MAAM,CAAC,SAAS,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBxD;;OAEG;IACG,MAAM,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAoCzE;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAa1C;;OAEG;IACG,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAQrD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,cAAc,CAAA;KAAE,CAAC;IAWtE;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAiBzB"}

package/dist/vector/vector.service.js

@@ -0,0 +1,163 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VectorService = void 0;
+const core_1 = require("@hazeljs/core");
+const core_2 = __importDefault(require("@hazeljs/core"));
+/**
+ * Vector database service
+ *
+ * Note: This is a mock implementation. In production, you would use actual vector database clients:
+ * - Pinecone: npm install @pinecone-database/pinecone
+ * - Weaviate: npm install weaviate-ts-client
+ * - Qdrant: npm install @qdrant/js-client-rest
+ * - Chroma: npm install chromadb
+ */
+let VectorService = class VectorService {
+    constructor() {
+        this.documents = new Map();
+    }
+    /**
+     * Initialize vector store
+     */
+    async initialize(config) {
+        this.config = config;
+        core_2.default.info(`Vector store initialized: ${config.database}`);
+        // In production, initialize the actual vector database client
+        // switch (config.database) {
+        //   case 'pinecone':
+        //     this.client = new PineconeClient();
+        //     await this.client.init({ apiKey: config.apiKey });
+        //     break;
+        //   case 'weaviate':
+        //     this.client = weaviate.client({ scheme: 'https', host: config.endpoint });
+        //     break;
+        //   // ... other databases
+        // }
+    }
+    /**
+     * Upsert documents
+     */
+    async upsert(documents) {
+        core_2.default.debug(`Upserting ${documents.length} documents`);
+        for (const doc of documents) {
+            // Generate mock embedding if not provided
+            if (!doc.embedding) {
+                doc.embedding = Array.from({ length: 1536 }, () => Math.random() * 2 - 1);
+            }
+            this.documents.set(doc.id, doc);
+        }
+        // In production:
+        // await this.client.upsert({
+        //   vectors: documents.map(doc => ({
+        //     id: doc.id,
+        //     values: doc.embedding,
+        //     metadata: { content: doc.content, ...doc.metadata },
+        //   })),
+        // });
+        core_2.default.info(`Upserted ${documents.length} documents`);
+    }
+    /**
+     * Search for similar documents
+     */
+    async search(request) {
+        core_2.default.debug(`Searching for: ${request.query}`);
+        // Mock implementation - generate random query embedding
+        const queryEmbedding = Array.from({ length: 1536 }, () => Math.random() * 2 - 1);
+        // Calculate cosine similarity for all documents
+        const results = [];
+        for (const [id, doc] of this.documents) {
+            if (doc.embedding) {
+                const score = this.cosineSimilarity(queryEmbedding, doc.embedding);
+                results.push({
+                    id,
+                    content: doc.content,
+                    score,
+                    metadata: doc.metadata,
+                });
+            }
+        }
+        // Sort by score and return top K
+        results.sort((a, b) => b.score - a.score);
+        const topK = request.topK || 10;
+        // In production:
+        // const response = await this.client.query({
+        //   vector: queryEmbedding,
+        //   topK: request.topK || 10,
+        //   filter: request.filter,
+        // });
+        core_2.default.info(`Found ${results.length} results`);
+        return results.slice(0, topK);
+    }
+    /**
+     * Delete documents
+     */
+    async delete(ids) {
+        core_2.default.debug(`Deleting ${ids.length} documents`);
+        for (const id of ids) {
+            this.documents.delete(id);
+        }
+        // In production:
+        // await this.client.delete({ ids });
+        core_2.default.info(`Deleted ${ids.length} documents`);
+    }
+    /**
+     * Get document by ID
+     */
+    async get(id) {
+        return this.documents.get(id) || null;
+        // In production:
+        // const response = await this.client.fetch({ ids: [id] });
+        // return response.vectors[id];
+    }
+    /**
+     * Clear all documents
+     */
+    async clear() {
+        this.documents.clear();
+        core_2.default.info('All documents cleared');
+        // In production:
+        // await this.client.deleteAll();
+    }
+    /**
+     * Get statistics
+     */
+    async getStats() {
+        return {
+            count: this.documents.size,
+            database: this.config?.database || 'pinecone',
+        };
+        // In production:
+        // const stats = await this.client.describeIndexStats();
+        // return { count: stats.totalVectorCount, database: this.config.database };
+    }
+    /**
+     * Calculate cosine similarity between two vectors
+     */
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length) {
+            throw new Error('Vectors must have the same length');
+        }
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+};
+exports.VectorService = VectorService;
+exports.VectorService = VectorService = __decorate([
+    (0, core_1.Service)()
+], VectorService);

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@hazeljs/ai",
+  "version": "0.2.0-alpha.1",
+  "description": "AI integration module for HazelJS framework",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc --skipLibCheck",
+    "test": "jest --coverage --maxWorkers=1",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.71.2",
+    "@google/generative-ai": "^0.24.1",
+    "@hazeljs/prompts": "^0.2.0-alpha.1",
+    "cohere-ai": "^7.14.0",
+    "openai": "^6.15.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.50",
+    "@typescript-eslint/eslint-plugin": "^8.18.2",
+    "@typescript-eslint/parser": "^8.18.2",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hazel-js/hazeljs.git",
+    "directory": "packages/ai"
+  },
+  "keywords": [
+    "hazeljs",
+    "ai",
+    "openai",
+    "anthropic",
+    "gemini",
+    "llm"
+  ],
+  "author": "Muhammad Arslan <muhammad.arslan@hazeljs.com>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/hazeljs/hazel-js/issues"
+  },
+  "homepage": "https://hazeljs.com",
+  "peerDependencies": {
+    "@hazeljs/cache": ">=0.2.0-beta.0",
+    "@hazeljs/core": ">=0.2.0-beta.0"
+  },
+  "gitHead": "cbc5ee2c12ced28fd0576faf13c5f078c1e8421e"
+}