@hazeljs/ai 0.2.0-beta.1

package/dist/tracking/token.tracker.js

@@ -0,0 +1,222 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenTracker = void 0;
+const core_1 = require("@hazeljs/core");
+const core_2 = __importDefault(require("@hazeljs/core"));
+/**
+ * Token Usage Tracker
+ * Tracks and limits token usage per user/request
+ */
+let TokenTracker = class TokenTracker {
+    constructor(config) {
+        this.usageHistory = [];
+        this.userUsage = new Map();
+        // Token costs per 1K tokens (as of 2024)
+        this.TOKEN_COSTS = {
+            'gpt-4-turbo-preview': { prompt: 0.01, completion: 0.03 },
+            'gpt-4': { prompt: 0.03, completion: 0.06 },
+            'gpt-3.5-turbo': { prompt: 0.0005, completion: 0.0015 },
+            'claude-3-opus': { prompt: 0.015, completion: 0.075 },
+            'claude-3-sonnet': { prompt: 0.003, completion: 0.015 },
+            'claude-3-haiku': { prompt: 0.00025, completion: 0.00125 },
+        };
+        this.config = {
+            maxTokensPerRequest: config?.maxTokensPerRequest || 4096,
+            maxTokensPerDay: config?.maxTokensPerDay || 100000,
+            maxTokensPerMonth: config?.maxTokensPerMonth || 1000000,
+            costPerToken: config?.costPerToken,
+        };
+        core_2.default.info('Token Tracker initialized', this.config);
+    }
+    /**
+     * Track token usage
+     */
+    track(usage, model) {
+        // Calculate cost if not provided
+        if (!usage.cost && model) {
+            usage.cost = this.calculateCost(usage, model);
+        }
+        this.usageHistory.push(usage);
+        // Track per user if userId provided
+        if (usage.userId) {
+            const userHistory = this.userUsage.get(usage.userId) || [];
+            userHistory.push(usage);
+            this.userUsage.set(usage.userId, userHistory);
+        }
+        core_2.default.debug('Token usage tracked', {
+            userId: usage.userId,
+            totalTokens: usage.totalTokens,
+            cost: usage.cost,
+        });
+    }
+    /**
+     * Check if request is within limits
+     */
+    async checkLimits(userId, requestTokens) {
+        // Check request token limit
+        if (requestTokens && requestTokens > this.config.maxTokensPerRequest) {
+            return {
+                allowed: false,
+                reason: `Request exceeds token limit (${requestTokens} > ${this.config.maxTokensPerRequest})`,
+            };
+        }
+        if (!userId) {
+            return { allowed: true };
+        }
+        const now = Date.now();
+        const oneDayAgo = now - 24 * 60 * 60 * 1000;
+        const oneMonthAgo = now - 30 * 24 * 60 * 60 * 1000;
+        const userHistory = this.userUsage.get(userId) || [];
+        // Calculate daily usage
+        const dailyUsage = userHistory
+            .filter((u) => u.timestamp > oneDayAgo)
+            .reduce((sum, u) => sum + u.totalTokens, 0);
+        // Calculate monthly usage
+        const monthlyUsage = userHistory
+            .filter((u) => u.timestamp > oneMonthAgo)
+            .reduce((sum, u) => sum + u.totalTokens, 0);
+        const usage = {
+            today: dailyUsage,
+            month: monthlyUsage,
+            limit: {
+                daily: this.config.maxTokensPerDay,
+                monthly: this.config.maxTokensPerMonth,
+            },
+        };
+        // Check daily limit
+        if (dailyUsage >= this.config.maxTokensPerDay) {
+            return {
+                allowed: false,
+                reason: 'Daily token limit exceeded',
+                usage,
+            };
+        }
+        // Check monthly limit
+        if (monthlyUsage >= this.config.maxTokensPerMonth) {
+            return {
+                allowed: false,
+                reason: 'Monthly token limit exceeded',
+                usage,
+            };
+        }
+        return { allowed: true, usage };
+    }
+    /**
+     * Calculate cost for token usage
+     */
+    calculateCost(usage, model) {
+        const costs = this.TOKEN_COSTS[model];
+        if (!costs) {
+            core_2.default.warn(`Unknown model for cost calculation: ${model}`);
+            return 0;
+        }
+        const promptCost = (usage.promptTokens / 1000) * costs.prompt;
+        const completionCost = (usage.completionTokens / 1000) * costs.completion;
+        return promptCost + completionCost;
+    }
+    /**
+     * Get usage statistics for a user
+     */
+    getUserStats(userId, days = 30) {
+        const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+        const userHistory = (this.userUsage.get(userId) || []).filter((u) => u.timestamp > cutoff);
+        const totalTokens = userHistory.reduce((sum, u) => sum + u.totalTokens, 0);
+        const totalCost = userHistory.reduce((sum, u) => sum + (u.cost || 0), 0);
+        const requestCount = userHistory.length;
+        return {
+            totalTokens,
+            totalCost,
+            requestCount,
+            averageTokensPerRequest: requestCount > 0 ? Math.round(totalTokens / requestCount) : 0,
+            dailyAverage: Math.round(totalTokens / days),
+        };
+    }
+    /**
+     * Get global statistics
+     */
+    getGlobalStats(days = 30) {
+        const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+        const recentUsage = this.usageHistory.filter((u) => u.timestamp > cutoff);
+        const totalTokens = recentUsage.reduce((sum, u) => sum + u.totalTokens, 0);
+        const totalCost = recentUsage.reduce((sum, u) => sum + (u.cost || 0), 0);
+        const requestCount = recentUsage.length;
+        // Calculate per-user stats
+        const userStats = new Map();
+        recentUsage.forEach((u) => {
+            if (u.userId) {
+                const stats = userStats.get(u.userId) || { tokens: 0, cost: 0 };
+                stats.tokens += u.totalTokens;
+                stats.cost += u.cost || 0;
+                userStats.set(u.userId, stats);
+            }
+        });
+        // Get top users
+        const topUsers = Array.from(userStats.entries())
+            .map(([userId, stats]) => ({
+            userId,
+            tokens: stats.tokens,
+            cost: stats.cost,
+        }))
+            .sort((a, b) => b.tokens - a.tokens)
+            .slice(0, 10);
+        return {
+            totalTokens,
+            totalCost,
+            requestCount,
+            uniqueUsers: userStats.size,
+            topUsers,
+        };
+    }
+    /**
+     * Clear old usage data
+     */
+    cleanup(daysToKeep = 90) {
+        const cutoff = Date.now() - daysToKeep * 24 * 60 * 60 * 1000;
+        // Clean global history
+        this.usageHistory = this.usageHistory.filter((u) => u.timestamp > cutoff);
+        // Clean per-user history
+        for (const [userId, history] of this.userUsage.entries()) {
+            const filtered = history.filter((u) => u.timestamp > cutoff);
+            if (filtered.length === 0) {
+                this.userUsage.delete(userId);
+            }
+            else {
+                this.userUsage.set(userId, filtered);
+            }
+        }
+        core_2.default.info(`Cleaned up usage data older than ${daysToKeep} days`);
+    }
+    /**
+     * Export usage data
+     */
+    exportData(userId) {
+        if (userId) {
+            return this.userUsage.get(userId) || [];
+        }
+        return [...this.usageHistory];
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+        core_2.default.info('Token tracker configuration updated', this.config);
+    }
+};
+exports.TokenTracker = TokenTracker;
+exports.TokenTracker = TokenTracker = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [Object])
+], TokenTracker);

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.Injectable)()
+], VectorService);

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@hazeljs/ai",
+  "version": "0.2.0-beta.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/cache": "file:../cache",
+    "@hazeljs/core": "file:../core",
+    "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 <marslan@hazeljs.com>",
+  "license": "MIT"
+}