praisonai 1.2.2 → 1.2.3

package/dist/memory/file-memory.js

@@ -0,0 +1,287 @@
+"use strict";
+/**
+ * File-based Memory Storage
+ * Persistent memory using JSONL files with lockfile support for concurrent access
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileMemory = void 0;
+exports.createFileMemory = createFileMemory;
+/**
+ * FileMemory - Append-only JSONL storage with compaction
+ */
+class FileMemory {
+    constructor(config) {
+        this.entries = new Map();
+        this.initialized = false;
+        this.writeQueue = Promise.resolve();
+        this.filePath = config.filePath;
+        this.maxEntries = config.maxEntries ?? 10000;
+        this.embeddingProvider = config.embeddingProvider;
+        this.compactionThreshold = config.compactionThreshold ?? 1000;
+        this.autoCompact = config.autoCompact ?? true;
+    }
+    /**
+     * Initialize and load existing entries
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        try {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            const content = await fs.readFile(this.filePath, 'utf-8').catch(() => '');
+            if (content) {
+                const lines = content.trim().split('\n').filter(Boolean);
+                let deletedCount = 0;
+                for (const line of lines) {
+                    try {
+                        const entry = JSON.parse(line);
+                        if (entry.deleted) {
+                            this.entries.delete(entry.id);
+                            deletedCount++;
+                        }
+                        else {
+                            this.entries.set(entry.id, entry);
+                        }
+                    }
+                    catch {
+                        // Skip malformed lines
+                    }
+                }
+                // Auto-compact if too many deleted entries
+                if (this.autoCompact && deletedCount > this.compactionThreshold) {
+                    await this.compact();
+                }
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+        this.initialized = true;
+    }
+    /**
+     * Add a memory entry
+     */
+    async add(content, role, metadata) {
+        await this.initialize();
+        const id = this.generateId();
+        const entry = {
+            id,
+            content,
+            role,
+            timestamp: Date.now(),
+            metadata
+        };
+        if (this.embeddingProvider) {
+            entry.embedding = await this.embeddingProvider.embed(content);
+        }
+        this.entries.set(id, entry);
+        await this.appendEntry(entry);
+        this.enforceLimit();
+        return entry;
+    }
+    /**
+     * Get a memory entry by ID
+     */
+    async get(id) {
+        await this.initialize();
+        const entry = this.entries.get(id);
+        return entry && !entry.deleted ? entry : undefined;
+    }
+    /**
+     * Get all entries
+     */
+    async getAll() {
+        await this.initialize();
+        return Array.from(this.entries.values())
+            .filter(e => !e.deleted)
+            .sort((a, b) => a.timestamp - b.timestamp);
+    }
+    /**
+     * Get recent entries
+     */
+    async getRecent(count) {
+        const all = await this.getAll();
+        return all.slice(-count);
+    }
+    /**
+     * Search memory by text similarity
+     */
+    async search(query, limit = 5) {
+        await this.initialize();
+        if (!this.embeddingProvider) {
+            return this.textSearch(query, limit);
+        }
+        const queryEmbedding = await this.embeddingProvider.embed(query);
+        const results = [];
+        for (const entry of this.entries.values()) {
+            if (entry.deleted)
+                continue;
+            if (entry.embedding) {
+                const score = this.cosineSimilarity(queryEmbedding, entry.embedding);
+                results.push({ entry, score });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    /**
+     * Delete a memory entry (soft delete)
+     */
+    async delete(id) {
+        await this.initialize();
+        const entry = this.entries.get(id);
+        if (!entry || entry.deleted)
+            return false;
+        entry.deleted = true;
+        await this.appendEntry({ id, deleted: true });
+        return true;
+    }
+    /**
+     * Clear all memory
+     */
+    async clear() {
+        await this.initialize();
+        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        await fs.writeFile(this.filePath, '');
+        this.entries.clear();
+    }
+    /**
+     * Compact the file by removing deleted entries
+     */
+    async compact() {
+        await this.initialize();
+        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        const activeEntries = Array.from(this.entries.values()).filter(e => !e.deleted);
+        const content = activeEntries
+            .map(e => JSON.stringify(e))
+            .join('\n') + (activeEntries.length ? '\n' : '');
+        // Write to temp file first, then rename (atomic)
+        const tempPath = `${this.filePath}.tmp`;
+        await fs.writeFile(tempPath, content);
+        await fs.rename(tempPath, this.filePath);
+    }
+    /**
+     * Get memory size
+     */
+    get size() {
+        return Array.from(this.entries.values()).filter(e => !e.deleted).length;
+    }
+    /**
+     * Export memory to JSON
+     */
+    async toJSON() {
+        return this.getAll();
+    }
+    /**
+     * Import memory from JSON
+     */
+    async fromJSON(entries) {
+        await this.clear();
+        for (const entry of entries) {
+            this.entries.set(entry.id, entry);
+        }
+        await this.compact();
+    }
+    /**
+     * Build context string from recent memory
+     */
+    async buildContext(count) {
+        const entries = count ? await this.getRecent(count) : await this.getAll();
+        return entries
+            .map(e => `${e.role}: ${e.content}`)
+            .join('\n');
+    }
+    async appendEntry(entry) {
+        // Queue writes to ensure order
+        this.writeQueue = this.writeQueue.then(async () => {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            await fs.appendFile(this.filePath, JSON.stringify(entry) + '\n');
+        });
+        await this.writeQueue;
+    }
+    textSearch(query, limit) {
+        const queryLower = query.toLowerCase();
+        const results = [];
+        for (const entry of this.entries.values()) {
+            if (entry.deleted)
+                continue;
+            const contentLower = entry.content.toLowerCase();
+            if (contentLower.includes(queryLower)) {
+                const score = queryLower.length / contentLower.length;
+                results.push({ entry, score: Math.min(score * 10, 1) });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        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];
+        }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator === 0 ? 0 : dotProduct / denominator;
+    }
+    generateId() {
+        return `fmem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    enforceLimit() {
+        const active = Array.from(this.entries.values()).filter(e => !e.deleted);
+        while (active.length > this.maxEntries) {
+            const oldest = active.shift();
+            if (oldest) {
+                oldest.deleted = true;
+            }
+        }
+    }
+}
+exports.FileMemory = FileMemory;
+/**
+ * Create a file-based memory instance
+ */
+function createFileMemory(config) {
+    return new FileMemory(config);
+}

package/dist/memory/index.d.ts

@@ -22,3 +22,5 @@ export declare class BaseMemoryStore implements MemoryStore {
     delete(id: string): boolean;
     clear(): void;
 }
+export { FileMemory, createFileMemory, type FileMemoryConfig, type FileMemoryEntry } from './file-memory';
+export { AutoMemory, createAutoMemory, createLLMSummarizer, DEFAULT_POLICIES, type AutoMemoryConfig, type AutoMemoryPolicy, type AutoMemoryContext, type VectorStoreAdapter, type KnowledgeBaseAdapter } from './auto-memory';

package/dist/memory/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseMemoryStore = void 0;
+exports.DEFAULT_POLICIES = exports.createLLMSummarizer = exports.createAutoMemory = exports.AutoMemory = exports.createFileMemory = exports.FileMemory = exports.BaseMemoryStore = void 0;
 class BaseMemoryStore {
     constructor() {
         this.memories = new Map();
@@ -29,3 +29,13 @@ class BaseMemoryStore {
     }
 }
 exports.BaseMemoryStore = BaseMemoryStore;
+// Export FileMemory
+var file_memory_1 = require("./file-memory");
+Object.defineProperty(exports, "FileMemory", { enumerable: true, get: function () { return file_memory_1.FileMemory; } });
+Object.defineProperty(exports, "createFileMemory", { enumerable: true, get: function () { return file_memory_1.createFileMemory; } });
+// Export AutoMemory
+var auto_memory_1 = require("./auto-memory");
+Object.defineProperty(exports, "AutoMemory", { enumerable: true, get: function () { return auto_memory_1.AutoMemory; } });
+Object.defineProperty(exports, "createAutoMemory", { enumerable: true, get: function () { return auto_memory_1.createAutoMemory; } });
+Object.defineProperty(exports, "createLLMSummarizer", { enumerable: true, get: function () { return auto_memory_1.createLLMSummarizer; } });
+Object.defineProperty(exports, "DEFAULT_POLICIES", { enumerable: true, get: function () { return auto_memory_1.DEFAULT_POLICIES; } });

package/dist/workflows/loop.js

@@ -0,0 +1 @@
+"use strict";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praisonai",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "PraisonAI TypeScript AI Agents Framework - Node.js, npm, and Javascript AI Agents Framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",