@wabot-dev/framework 0.9.9 → 0.9.10

package/dist/src/addon/chat-bot/in-memory/InMemoryChatMemory.js

@@ -1,13 +1,67 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Logger } from '../../../core/logger/Logger.js';
+
+const PERSIST_LIMIT = 32;
+const PERSIST_DIR = '.wabot/in-memory';
+const logger = new Logger('wabot:in-memory-chat-memory');
 class InMemoryChatMemory {
     memory = [];
+    filePath;
+    onActivity;
+    constructor(chatId, onActivity) {
+        this.filePath = chatId
+            ? path.resolve(process.cwd(), PERSIST_DIR, `${chatId}.json`)
+            : null;
+        this.onActivity = onActivity ?? null;
+        this.load();
+    }
     async findLastItems(count) {
         return this.memory.slice(-count);
     }
     async create(item) {
         this.memory.push(item);
+        if (this.memory.length > PERSIST_LIMIT) {
+            this.memory = this.memory.slice(-PERSIST_LIMIT);
+        }
+        this.persist();
+        this.onActivity?.();
     }
     async clearMemory() {
         this.memory = [];
+        if (this.filePath && fs.existsSync(this.filePath)) {
+            try {
+                fs.unlinkSync(this.filePath);
+            }
+            catch (err) {
+                logger.warn(`Failed to delete ${this.filePath}:`, err);
+            }
+        }
+    }
+    load() {
+        if (!this.filePath || !fs.existsSync(this.filePath))
+            return;
+        try {
+            const raw = fs.readFileSync(this.filePath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed)) {
+                this.memory = parsed.slice(-PERSIST_LIMIT);
+            }
+        }
+        catch (err) {
+            logger.warn(`Failed to load ${this.filePath}:`, err);
+        }
+    }
+    persist() {
+        if (!this.filePath)
+            return;
+        try {
+            fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+            fs.writeFileSync(this.filePath, JSON.stringify(this.memory, null, 2), 'utf-8');
+        }
+        catch (err) {
+            logger.warn(`Failed to persist ${this.filePath}:`, err);
+        }
     }
 }
 

package/dist/src/addon/chat-bot/in-memory/InMemoryChatRepository.js

@@ -1,7 +1,11 @@
-import { __decorate } from 'tslib';
+import { __decorate, __metadata } from 'tslib';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { v4 } from 'uuid';
 import { InMemoryChatMemory } from './InMemoryChatMemory.js';
 import { singleton } from '../../../core/injection/index.js';
+import { Logger } from '../../../core/logger/Logger.js';
+import { Chat } from '../../../feature/chat-bot/Chat.js';
 import '../../../feature/chat-bot/ChatAdapterRegistry.js';
 import '../../../feature/chat-bot/ChatBot.js';
 import { ChatOperator } from '../../../feature/chat-bot/ChatOperator.js';
@@ -10,14 +14,23 @@ import '../../../feature/chat-bot/metadata/ChatAdapterMetadataStore.js';
 import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 import '../../../core/error/setupErrorHandlers.js';
 
+const CHATS_FILE = '.wabot/in-memory/chats.json';
+const MEMORY_DIR = '.wabot/in-memory';
+const MAX_CHATS = 10;
+const logger = new Logger('wabot:in-memory-chat-repository');
 let InMemoryChatRepository = class InMemoryChatRepository {
+    // Ordered least-recently-active first, most-recent last.
     items = [];
     memories = [];
+    constructor() {
+        this.load();
+    }
     async update(chat) {
         if (!chat.wasCreated()) {
             throw new Error('Chat wat not created');
         }
         chat.validate();
+        this.persist();
     }
     async create(chat) {
         if (chat.wasCreated()) {
@@ -27,11 +40,12 @@ let InMemoryChatRepository = class InMemoryChatRepository {
         chat['data'].createdAt = new Date().getTime();
         chat.validate();
         this.items.push(chat);
-        const memory = {
-            memory: new InMemoryChatMemory(),
+        this.memories.push({
             chatId: chat.id,
-        };
-        this.memories.push(memory);
+            memory: new InMemoryChatMemory(chat.id, () => this.touch(chat.id)),
+        });
+        this.enforceLimit();
+        this.persist();
     }
     async findByConnection(query) {
         return this.items.find((item) => item.hasConnection(query)) ?? null;
@@ -55,9 +69,80 @@ let InMemoryChatRepository = class InMemoryChatRepository {
     getMemory(chatId) {
         return this.memories.find((r) => r.chatId === chatId) ?? null;
     }
+    touch(chatId) {
+        const idx = this.items.findIndex((c) => c.id === chatId);
+        if (idx === -1 || idx === this.items.length - 1) {
+            if (idx !== -1)
+                this.persist();
+            return;
+        }
+        const [chat] = this.items.splice(idx, 1);
+        this.items.push(chat);
+        this.persist();
+    }
+    enforceLimit() {
+        while (this.items.length > MAX_CHATS) {
+            const evicted = this.items.shift();
+            const memIdx = this.memories.findIndex((m) => m.chatId === evicted.id);
+            if (memIdx !== -1)
+                this.memories.splice(memIdx, 1);
+            this.deleteMemoryFile(evicted.id);
+        }
+    }
+    deleteMemoryFile(chatId) {
+        const file = path.resolve(process.cwd(), MEMORY_DIR, `${chatId}.json`);
+        if (!fs.existsSync(file))
+            return;
+        try {
+            fs.unlinkSync(file);
+        }
+        catch (err) {
+            logger.warn(`Failed to delete ${file}:`, err);
+        }
+    }
+    chatsFilePath() {
+        return path.resolve(process.cwd(), CHATS_FILE);
+    }
+    load() {
+        const file = this.chatsFilePath();
+        if (!fs.existsSync(file))
+            return;
+        try {
+            const raw = fs.readFileSync(file, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed))
+                return;
+            for (const data of parsed) {
+                if (!data?.id)
+                    continue;
+                const chat = new Chat(data);
+                this.items.push(chat);
+                this.memories.push({
+                    chatId: chat.id,
+                    memory: new InMemoryChatMemory(chat.id, () => this.touch(chat.id)),
+                });
+            }
+            this.enforceLimit();
+        }
+        catch (err) {
+            logger.warn(`Failed to load ${file}:`, err);
+        }
+    }
+    persist() {
+        const file = this.chatsFilePath();
+        try {
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            const data = this.items.map((c) => c['data']);
+            fs.writeFileSync(file, JSON.stringify(data, null, 2), 'utf-8');
+        }
+        catch (err) {
+            logger.warn(`Failed to persist ${file}:`, err);
+        }
+    }
 };
 InMemoryChatRepository = __decorate([
-    singleton()
+    singleton(),
+    __metadata("design:paramtypes", [])
 ], InMemoryChatRepository);
 
 export { InMemoryChatRepository };

package/dist/src/addon/chat-controller/cmd/CmdChannel.js

@@ -65,10 +65,10 @@ let CmdChannel = class CmdChannel {
         return this.config.route.replace(/[^a-zA-Z0-9._-]/g, '_');
     }
     chatIdPath() {
-        return path.join('.cmd-channel', this.routeSlug(), 'id.json');
+        return path.join('.wabot', 'cmd-channel', this.routeSlug(), 'id.json');
     }
     authInfoPath() {
-        return path.join('.cmd-channel', this.routeSlug(), 'auth-info.json');
+        return path.join('.wabot', 'cmd-channel', this.routeSlug(), 'auth-info.json');
     }
     ensureChatId() {
         if (this.chatId !== undefined)

package/dist/src/addon/chat-controller/cmd/cmdChannelSocketPath.js

@@ -10,7 +10,7 @@ function cmdChannelSocketPath() {
             .slice(0, 12);
         return `\\\\.\\pipe\\wabot-cmd-channel-${cwdHash}`;
     }
-    return path.resolve(process.cwd(), '.cmd-channel/socket');
+    return path.resolve(process.cwd(), '.wabot/cmd-channel/socket');
 }
 
 export { cmdChannelSocketPath };

package/dist/src/feature/project-runner/ProjectRunner.js

@@ -36,7 +36,7 @@ import { RepositoryAdapterRegistry } from '../repository/RepositoryAdapterRegist
 
 const logger = new Logger('wabot:project-runner');
 const TEST_FILE_PATTERNS = /\.(test|spec|unit|integration|e2e|multiprocess)\.(ts|js)$/;
-const DEFAULT_EXCLUDE = ['run.ts', 'cmd.ts'];
+const DEFAULT_EXCLUDE = ['_run_.ts', '_cmd_.ts'];
 const MODULE_EXT = import.meta.url.endsWith('.ts') ? '.ts' : '.js';
 const DEFAULT_CHAT_ADAPTERS = [
     {
@@ -279,21 +279,17 @@ class ProjectRunner {
     }
     async resolveDefaultChatAdapters() {
         const results = await Promise.all(DEFAULT_CHAT_ADAPTERS.map(async ({ path, name, apiKeyEnv }) => {
-            if (!process.env[apiKeyEnv]) {
-                logger.info(`Skipping ${name}: ${apiKeyEnv} is not set`);
+            if (!process.env[apiKeyEnv])
                 return null;
-            }
             try {
                 const mod = await import(path);
                 const adapter = mod[name];
-                if (!adapter) {
-                    logger.warn(`Skipping ${name}: module loaded but no '${name}' export found`);
+                if (!adapter)
                     return null;
-                }
+                logger.info(`Using ${name}`);
                 return adapter;
             }
             catch {
-                logger.warn(`Skipping ${name}: missing peer dependency`);
                 return null;
             }
         }));

package/dist/src/index.d.ts

@@ -1931,20 +1931,32 @@ declare class PgChatMemory extends PgCrudRepository<ChatItem> implements IChatMe
 
 declare class InMemoryChatMemory implements IChatMemory {
     private memory;
+    private readonly filePath;
+    private readonly onActivity;
+    constructor(chatId?: string, onActivity?: () => void);
     findLastItems(count: number): Promise<ChatItem[]>;
     create(item: ChatItem): Promise<void>;
     clearMemory(): Promise<void>;
+    private load;
+    private persist;
 }
 
 declare class InMemoryChatRepository implements IChatRepository {
     private items;
     private memories;
+    constructor();
     update(chat: Chat): Promise<void>;
     create(chat: Chat): Promise<void>;
     findByConnection(query: IChatConnection): Promise<Chat | null>;
     findMemory(chatId: string): Promise<IChatMemory | null>;
     findOperator(chatId: string): Promise<ChatOperator | null>;
     private getMemory;
+    private touch;
+    private enforceLimit;
+    private deleteMemoryFile;
+    private chatsFilePath;
+    private load;
+    private persist;
 }
 
 declare class WabotChatAdapter implements IChatAdapter {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/framework",
-  "version": "0.9.9",
+  "version": "0.9.10",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",