xiaozuoassistant 0.2.7 → 0.2.8

package/dist/server/core/brain.js

@@ -0,0 +1,255 @@
+import { config } from '../config/loader.js';
+import { skillRegistry } from '../skills/registry.js';
+import { SYSTEM_PROMPT } from '../config/prompts.js';
+import { createOpenAIClient } from '../llm/openai.js';
+export class Brain {
+    constructor() {
+        this.openai = createOpenAIClient(config.llm);
+        this.updateClient();
+    }
+    static getInstance() {
+        if (!Brain.instance) {
+            Brain.instance = new Brain();
+        }
+        return Brain.instance;
+    }
+    updateClient() {
+        this.openai = createOpenAIClient(config.llm);
+    }
+    async processMessage(history, newMessage, systemPrompt, context) {
+        if (process.env.DEBUG)
+            console.log('[Brain] Processing message:', newMessage);
+        const defaultSystemPrompt = systemPrompt || config.systemPrompt || SYSTEM_PROMPT || 'You are xiaozuoAssistant, a helpful AI assistant. You can use tools to help users.';
+        // Check if API key is configured
+        if (!config.llm.apiKey) {
+            console.warn('API key not configured, cannot process message');
+            return 'Error: API key not configured. Please set up your API key in the configuration.';
+        }
+        // Check for long inactivity (Session Wake-up)
+        const sessionLastActive = context?.session?.lastActiveAt || 0;
+        const now = Date.now();
+        const hoursSinceActive = (now - sessionLastActive) / (1000 * 60 * 60);
+        const WAKEUP_THRESHOLD = config.llm.sessionWakeupHours ?? 24;
+        let wakeupContext = '';
+        if (sessionLastActive > 0 && hoursSinceActive > WAKEUP_THRESHOLD) {
+            if (process.env.DEBUG)
+                console.log(`[Brain] Session wake-up detected (${hoursSinceActive.toFixed(1)}h > ${WAKEUP_THRESHOLD}h). Generating recap...`);
+            // Use recent history for quick summary, or could query Vector DB for deeper context
+            // For now, simple summary of recent messages to refresh context
+            const recentText = history.slice(-50).map(m => `${m.role}: ${m.content}`).join('\n');
+            if (recentText.length > 100) {
+                const summary = await this.generateSummary(recentText);
+                if (summary) {
+                    wakeupContext = `\n\n[System Notice]: The user has returned after ${Math.floor(hoursSinceActive)} hours. Here is a brief recap of the previous conversation context to help you catch up:\n${summary}`;
+                }
+            }
+        }
+        // Convert history messages to the format expected by OpenAI
+        // Strategy: Keep last N messages to avoid context window overflow
+        // TODO: A better strategy would be token-based truncation.
+        const MAX_HISTORY_MESSAGES = config.llm.maxHistoryMessages ?? 20;
+        const recentHistory = history.slice(-MAX_HISTORY_MESSAGES);
+        const messageHistory = recentHistory.map(m => {
+            const msg = { role: m.role, content: m.content };
+            if (m.name)
+                msg.name = m.name;
+            if (m.tool_call_id)
+                msg.tool_call_id = m.tool_call_id;
+            if (m.tool_calls)
+                msg.tool_calls = m.tool_calls;
+            return msg;
+        });
+        const messages = [
+            { role: 'system', content: defaultSystemPrompt + wakeupContext },
+            ...messageHistory,
+            { role: 'user', content: newMessage }
+        ];
+        try {
+            if (process.env.DEBUG)
+                console.log('[Brain] Calling LLM...');
+            let response = await this.callLLM(messages, newMessage);
+            // Log only the content snippet to avoid flooding logs with full JSON
+            const contentSnippet = response.choices[0].message.content ? response.choices[0].message.content.substring(0, 100) + '...' : 'No content';
+            if (process.env.DEBUG)
+                console.log('[Brain] LLM Response (snippet):', contentSnippet);
+            let iterations = 0;
+            const MAX_ITERATIONS = config.llm.maxToolIterations ?? 15; // Reduced default from 200 to 15 for safety
+            while (response.choices[0].message.tool_calls && iterations < MAX_ITERATIONS) {
+                iterations++;
+                const toolCalls = response.choices[0].message.tool_calls;
+                const assistantMsg = response.choices[0].message;
+                messages.push(assistantMsg); // Add assistant message with tool calls
+                for (const toolCall of toolCalls) {
+                    if (toolCall.type !== 'function')
+                        continue;
+                    const functionName = toolCall.function.name;
+                    const functionArgs = JSON.parse(toolCall.function.arguments);
+                    if (process.env.DEBUG)
+                        console.log(`[Brain] Executing tool: ${functionName}`);
+                    const skill = skillRegistry.getSkill(functionName);
+                    let toolResult = '';
+                    if (skill) {
+                        try {
+                            const ctxForTool = context
+                                ? { ...context, metadata: { ...(context.metadata || {}), toolCall: { id: toolCall.id, name: functionName } } }
+                                : undefined;
+                            const result = await skill.execute(functionArgs, ctxForTool);
+                            toolResult = JSON.stringify(result);
+                        }
+                        catch (error) {
+                            toolResult = JSON.stringify({ error: error.message });
+                        }
+                    }
+                    else {
+                        toolResult = JSON.stringify({ error: 'Tool not found' });
+                    }
+                    // Log tool result snippet
+                    if (process.env.DEBUG)
+                        console.log(`[Brain] Tool Result (snippet):`, toolResult.substring(0, 100) + '...');
+                    messages.push({
+                        role: 'tool',
+                        tool_call_id: toolCall.id,
+                        content: toolResult
+                    });
+                }
+                // Call LLM again with tool results
+                if (process.env.DEBUG)
+                    console.log('[Brain] Calling LLM with tool results...');
+                response = await this.callLLM(messages);
+                const nextContentSnippet = response.choices[0].message.content ? response.choices[0].message.content.substring(0, 100) + '...' : 'No content';
+                if (process.env.DEBUG)
+                    console.log('[Brain] LLM Response (after tool, snippet):', nextContentSnippet);
+            }
+            const hitLimit = Boolean(response.choices[0].message.tool_calls) && iterations >= MAX_ITERATIONS;
+            const finalContent = response.choices[0].message.content || 'I could not generate a response.';
+            if (process.env.DEBUG)
+                console.log('[Brain] Final Response (snippet):', finalContent.substring(0, 100) + '...');
+            if (!hitLimit)
+                return finalContent;
+            return `${finalContent}\n\n（已到达回合上限，建议回复“继续”以接着执行；可在 config.json 设置 llm.maxToolIterations，当前=${MAX_ITERATIONS}）`;
+        }
+        catch (error) {
+            console.error('[Brain] Error in processing:', error);
+            return `Error: ${error.message}`;
+        }
+    }
+    async generateSummary(content) {
+        try {
+            // Check if API key is configured
+            if (!config.llm.apiKey) {
+                console.warn('API key not configured, skipping summary generation');
+                return '';
+            }
+            const response = await this.openai.chat.completions.create({
+                model: config.llm.model,
+                messages: [
+                    { role: 'system', content: 'You are a helpful assistant. Please summarize the following content concisely.' },
+                    { role: 'user', content: content }
+                ],
+                temperature: 0.5
+            }, { timeout: config.llm.requestTimeoutMs ?? 600000 });
+            return response.choices[0].message.content || '';
+        }
+        catch (e) {
+            console.error('Summary generation failed:', e);
+            return '';
+        }
+    }
+    async extractKeyInformation(content, contextType) {
+        try {
+            // Check if API key is configured
+            if (!config.llm.apiKey) {
+                console.warn('API key not configured, skipping key information extraction');
+                return '';
+            }
+            const prompt = contextType === 'project'
+                ? 'Extract key project-related information, decisions, and tasks from the following conversation. Return a concise summary.'
+                : 'Extract key information, insights, and valuable knowledge from the following conversation. Return a concise summary suitable for long-term memory.';
+            const response = await this.openai.chat.completions.create({
+                model: config.llm.model,
+                messages: [
+                    { role: 'system', content: prompt },
+                    { role: 'user', content: content }
+                ],
+                temperature: 0.3
+            }, { timeout: config.llm.requestTimeoutMs ?? 600000 });
+            return response.choices[0].message.content || '';
+        }
+        catch (e) {
+            console.error('Key information extraction failed:', e);
+            return '';
+        }
+    }
+    async extractNotebookNotes(content, keywords) {
+        try {
+            // Check if API key is configured
+            if (!config.llm.apiKey) {
+                console.warn('API key not configured, skipping notebook note extraction');
+                return [];
+            }
+            const prompt = keywords
+                ? `You are a note-taker. Extract notes relevant to the following keywords: "${keywords}".`
+                : `You are a note-taker. Extract important notes, knowledge points, code snippets, or actionable items from the conversation.`;
+            const response = await this.openai.chat.completions.create({
+                model: config.llm.model,
+                messages: [
+                    { role: 'system', content: `${prompt}
+Return a JSON array of objects with "title" and "content" fields. If no relevant info, return empty array [].
+Format: [{"title": "...", "content": "..."}]` },
+                    { role: 'user', content: content }
+                ],
+                temperature: 0.3,
+                response_format: { type: 'json_object' }
+            }, { timeout: config.llm.requestTimeoutMs ?? 600000 });
+            const jsonStr = response.choices[0].message.content || '{"notes": []}';
+            try {
+                const parsed = JSON.parse(jsonStr);
+                if (Array.isArray(parsed))
+                    return parsed;
+                if (parsed.notes && Array.isArray(parsed.notes))
+                    return parsed.notes;
+                return [];
+            }
+            catch {
+                return [];
+            }
+        }
+        catch (e) {
+            console.error('Notebook note extraction failed:', e);
+            return [];
+        }
+    }
+    async callLLM(messages, userQuery) {
+        // 根据用户当前输入，获取过滤后的 Tools
+        const tools = skillRegistry.getToolsDefinition(userQuery);
+        // OpenAI SDK expects tools to be undefined if empty array, or valid tools array
+        const toolsParam = tools.length > 0 ? tools : undefined;
+        const maxRetries = config.llm.maxRetries ?? 2;
+        const timeout = config.llm.requestTimeoutMs ?? 600000;
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return await this.openai.chat.completions.create({
+                    model: config.llm.model,
+                    messages: messages,
+                    tools: toolsParam,
+                    temperature: config.llm.temperature
+                }, { timeout });
+            }
+            catch (e) {
+                lastError = e;
+                const msg = String(e?.message || '').toLowerCase();
+                const code = String(e?.code || '').toLowerCase();
+                const isTimeout = msg.includes('timeout') || code.includes('etimedout');
+                const isConn = msg.includes('econnreset') || msg.includes('network') || code.includes('econnreset');
+                const retryable = isTimeout || isConn;
+                if (!retryable || attempt === maxRetries)
+                    break;
+                const backoffMs = Math.min(2000 * (attempt + 1), 8000);
+                await new Promise(r => setTimeout(r, backoffMs));
+            }
+        }
+        throw lastError;
+    }
+}
+export const brain = Brain.getInstance();

package/dist/server/core/event-bus.js

@@ -0,0 +1,24 @@
+import { EventEmitter } from 'events';
+class EventBus extends EventEmitter {
+    constructor() {
+        super();
+    }
+    static getInstance() {
+        if (!EventBus.instance) {
+            EventBus.instance = new EventBus();
+        }
+        return EventBus.instance;
+    }
+    emitEvent(event) {
+        this.emit(event.type, event);
+        // 同时也触发一个通用的 '*' 事件，方便日志记录
+        this.emit('*', event);
+    }
+    onEvent(eventType, handler) {
+        this.on(eventType, handler);
+    }
+    offEvent(eventType, handler) {
+        this.off(eventType, handler);
+    }
+}
+export const eventBus = EventBus.getInstance();

package/dist/server/core/logger.js

@@ -0,0 +1,71 @@
+import winston from 'winston';
+import 'winston-daily-rotate-file';
+import path from 'path';
+import fs from 'fs';
+// Determine log directory
+// In production, logs should be in the directory where the user runs the app (process.cwd()/logs)
+// In development, it might be the project root.
+const logDir = path.join(process.cwd(), 'logs');
+// Ensure log directory exists
+if (!fs.existsSync(logDir)) {
+    try {
+        fs.mkdirSync(logDir, { recursive: true });
+    }
+    catch (e) {
+        console.error('Failed to create log directory:', e);
+    }
+}
+// Define the custom format
+const logFormat = winston.format.combine(winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston.format.errors({ stack: true }), // Print stack trace for errors
+winston.format.splat(), winston.format.printf(({ timestamp, level, message, stack }) => {
+    return `[${timestamp}] ${level.toUpperCase()}: ${message} ${stack || ''}`;
+}));
+// Create the rotating file transport
+const fileTransport = new winston.transports.DailyRotateFile({
+    filename: path.join(logDir, 'app-%DATE%.log'),
+    datePattern: 'YYYY-MM-DD',
+    zippedArchive: true, // Archive old logs (gzip)
+    maxSize: '20m', // Rotate if size exceeds 20MB (optional safety)
+    maxFiles: '30d', // Keep logs for 30 days
+    createSymlink: true, // Create a symlink 'app.log' pointing to current log
+    symlinkName: 'app.log',
+    level: 'info'
+});
+const transports = [
+    fileTransport,
+    new winston.transports.Console({
+        format: winston.format.combine(winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston.format.colorize(), winston.format.printf(({ timestamp, level, message, stack }) => {
+            return `[${timestamp}] ${level}: ${message} ${stack || ''}`;
+        }))
+    })
+];
+export const logger = winston.createLogger({
+    level: 'info',
+    format: logFormat,
+    transports: transports,
+    exceptionHandlers: [
+        new winston.transports.File({ filename: path.join(logDir, 'exceptions.log') })
+    ],
+    rejectionHandlers: [
+        new winston.transports.File({ filename: path.join(logDir, 'rejections.log') })
+    ]
+});
+// Helper to integrate with existing console.log usage
+export const overrideConsole = () => {
+    const originalLog = console.log;
+    const originalError = console.error;
+    const originalWarn = console.warn;
+    const originalInfo = console.info;
+    console.log = (...args) => {
+        logger.info(args.map(arg => typeof arg === 'object' ? JSON.stringify(arg, null, 2) : arg).join(' '));
+    };
+    console.error = (...args) => {
+        logger.error(args.map(arg => typeof arg === 'object' ? JSON.stringify(arg, null, 2) : arg).join(' '));
+    };
+    console.warn = (...args) => {
+        logger.warn(args.map(arg => typeof arg === 'object' ? JSON.stringify(arg, null, 2) : arg).join(' '));
+    };
+    console.info = (...args) => {
+        logger.info(args.map(arg => typeof arg === 'object' ? JSON.stringify(arg, null, 2) : arg).join(' '));
+    };
+};

package/dist/server/core/memories/manager.js

@@ -0,0 +1,238 @@
+import { ShortTermMemory } from './short-term.js';
+import { VectorMemory } from './vector.js';
+import { StructuredMemory } from './structured.js';
+import { brain } from '../brain.js';
+import { config } from '../../config/loader.js';
+export class MemoryManager {
+    constructor() {
+        this.shortTerm = ShortTermMemory.getInstance();
+        this.vector = VectorMemory.getInstance();
+        this.structured = StructuredMemory.getInstance();
+    }
+    static getInstance() {
+        if (!MemoryManager.instance) {
+            MemoryManager.instance = new MemoryManager();
+        }
+        return MemoryManager.instance;
+    }
+    // --- Layer 1: Short-term (Session) ---
+    async createSession(input) {
+        return this.shortTerm.createSession(input);
+    }
+    async getSession(id) {
+        return this.shortTerm.getSession(id);
+    }
+    async listSessions() {
+        return this.shortTerm.listSessions();
+    }
+    async updateSessionMeta(id, patch) {
+        return this.shortTerm.updateSessionMeta(id, patch);
+    }
+    async persistSession(id) {
+        return this.shortTerm.persistSession(id);
+    }
+    async deleteSession(id) {
+        return this.shortTerm.deleteSession(id);
+    }
+    async addMessage(sessionId, message) {
+        // 1. Add to Short-term
+        await this.shortTerm.addMessage(sessionId, message);
+        // 2. Add to Recent/Long-term (Vector) - Async/Background
+        // For now, we only embed user messages or significant assistant responses
+        // to avoid cluttering.
+        if (message.content.length > 10) { // Simple filter
+            const userId = config.userId || 'default';
+            this.vector.addMemory(message.content, 'recent', { sessionId, role: message.role, userId })
+                .catch(err => console.error('Background vector add failed:', err));
+        }
+        // 3. Extract Facts (Structured) - This usually requires an LLM call to extract
+        // structured info from the message. For MVP, we skip automatic extraction here
+        // but provide the API for the Brain to call explicitly.
+    }
+    async clearSessionMessages(sessionId) {
+        await this.shortTerm.clearMessages(sessionId);
+    }
+    updateClients() {
+        this.vector.updateClient();
+    }
+    async createRun(sessionId, userContent, runId) {
+        return this.shortTerm.createRun(sessionId, userContent, runId);
+    }
+    async updateRun(sessionId, runId, patch) {
+        return this.shortTerm.updateRun(sessionId, runId, patch);
+    }
+    async listRuns(sessionId) {
+        return this.shortTerm.listRuns(sessionId);
+    }
+    async getHistory(sessionId) {
+        return this.shortTerm.getMessages(sessionId);
+    }
+    // --- Retrieval ---
+    async getRelevantContext(query, sessionId, userId) {
+        const uid = userId || config.userId || 'default';
+        // 1. Get Short-term context (recent messages)
+        const history = await this.getHistory(sessionId);
+        const recentMessages = history.slice(-10).map(m => `${m.role}: ${m.content}`).join('\n');
+        // 2. Search Vector Memory (Recent & Long-term)
+        const vectorResults = await this.vector.search(query, undefined, 10);
+        const vectorFiltered = vectorResults.filter(r => (r.metadata?.userId || 'default') === uid).slice(0, 3);
+        const vectorContext = vectorFiltered.map(r => `[Memory]: ${r.text}`).join('\n');
+        // 3. Get User Profile (Structured)
+        const profile = await this.structured.getUserProfile(uid);
+        const profileContext = Object.entries(profile).map(([k, v]) => `[User Info] ${k}: ${v}`).join('\n');
+        return `
+=== User Identity (userId: ${uid}) ===
+${profileContext}
+
+=== Relevant Memories ===
+${vectorContext}
+
+=== Recent Conversation ===
+${recentMessages}
+`;
+    }
+    getUserProfile(userId) {
+        const uid = userId || config.userId || 'default';
+        return this.structured.getUserProfile(uid);
+    }
+    updateUserProfile(userId, patch) {
+        const uid = userId || config.userId || 'default';
+        for (const [k, v] of Object.entries(patch || {})) {
+            const key = String(k).trim();
+            if (!key)
+                continue;
+            const value = v === null || v === undefined ? '' : String(v);
+            this.structured.updateUserProfile(uid, key, value);
+        }
+    }
+    async runSessionArchiving() {
+        console.log('[MemoryManager] Running session archiving...');
+        const sessions = await this.listSessions();
+        const now = Date.now();
+        for (const session of sessions) {
+            try {
+                // Check if session has new activity since last archive
+                const lastArchived = session.lastArchivedAt || 0;
+                const lastActive = session.lastActiveAt || session.updatedAt || 0;
+                // If no new activity, skip
+                if (lastActive <= lastArchived)
+                    continue;
+                // If less than 3 minutes since last archive, skip (though scheduler runs every 3 mins, so this check is redundant but safe)
+                // Actually, we want to archive if there is new content.
+                console.log(`[MemoryManager] Archiving session ${session.id} (Alias: ${session.alias || 'N/A'})...`);
+                const messages = await this.getHistory(session.id);
+                // Filter messages after lastArchived
+                const newMessages = messages.filter(m => (m.timestamp || 0) > lastArchived);
+                if (newMessages.length === 0) {
+                    // Update lastArchivedAt to now to avoid re-checking empty interval
+                    await this.updateSessionMeta(session.id, { lastArchivedAt: now });
+                    continue;
+                }
+                // Process in chunks to avoid context overflow
+                const CHUNK_SIZE = 50; // Process 50 messages at a time
+                for (let i = 0; i < newMessages.length; i += CHUNK_SIZE) {
+                    const chunk = newMessages.slice(i, i + CHUNK_SIZE);
+                    const content = chunk.map(m => `${m.role}: ${m.content}`).join('\n');
+                    // 1. Memory Archiving (Project or General)
+                    const projectIds = session.projectIds || (session.projectId ? [session.projectId] : []);
+                    if (projectIds.length > 0) {
+                        // Project Context
+                        const projectInfo = await brain.extractKeyInformation(content, 'project');
+                        if (projectInfo) {
+                            for (const pid of projectIds) {
+                                await this.vector.addMemory(projectInfo, 'project_archive', {
+                                    sessionId: session.id,
+                                    projectId: pid,
+                                    archivedAt: now
+                                });
+                                console.log(`[MemoryManager] Archived project info for Project ${pid} (Chunk ${i / CHUNK_SIZE + 1})`);
+                            }
+                        }
+                    }
+                    else {
+                        // General Context (No Project)
+                        const generalInfo = await brain.extractKeyInformation(content, 'general');
+                        if (generalInfo) {
+                            await this.vector.addMemory(generalInfo, 'long_term', {
+                                sessionId: session.id,
+                                archivedAt: now,
+                                source: 'auto_archive'
+                            });
+                            console.log(`[MemoryManager] Archived general info for Session ${session.id} (Chunk ${i / CHUNK_SIZE + 1})`);
+                        }
+                    }
+                    // 2. Notebook Memory Archiving
+                    if (session.notebookId) {
+                        const notebook = this.structured.getNotebook(session.notebookId);
+                        if (notebook) {
+                            // Extract notes regardless of keywords (Brain handles fallback)
+                            const notes = await brain.extractNotebookNotes(content, notebook.keywords);
+                            if (notes && notes.length > 0) {
+                                for (const note of notes) {
+                                    if (!note.title || !note.content)
+                                        continue;
+                                    this.structured.createNote(require('uuid').v4(), session.notebookId, note.title, note.content);
+                                    console.log(`[MemoryManager] Created note "${note.title}" in Notebook ${notebook.name} (Chunk ${i / CHUNK_SIZE + 1})`);
+                                }
+                            }
+                        }
+                    }
+                }
+                // Update lastArchivedAt
+                await this.updateSessionMeta(session.id, { lastArchivedAt: now });
+            }
+            catch (e) {
+                console.error(`[MemoryManager] Failed to archive session ${session.id}:`, e);
+            }
+        }
+    }
+    // --- Maintenance ---
+    // Managed by Scheduler
+    async runMaintenance(input) {
+        const sessionMaxAgeDays = input?.sessionMaxAgeDays ?? 5;
+        const vectorMaxAgeDays = input?.vectorMaxAgeDays ?? 15;
+        console.log(`[MemoryManager] Running maintenance (Sessions: ${sessionMaxAgeDays} days, Vector: ${vectorMaxAgeDays} days)...`);
+        try {
+            // 0. Auto-archive active sessions
+            await this.runSessionArchiving();
+            // 1. Clean up old sessions
+            const deletedSessions = await this.shortTerm.cleanupOldSessions(sessionMaxAgeDays);
+            if (deletedSessions > 0) {
+                console.log(`[MemoryManager] Deleted ${deletedSessions} old sessions.`);
+            }
+            // 2. Summarize and Prune Vector Memories
+            const oldMemories = await this.vector.getMemoriesOlderThan(vectorMaxAgeDays);
+            if (oldMemories.length > 0) {
+                console.log(`[MemoryManager] Found ${oldMemories.length} old memories to summarize.`);
+                // Batch process
+                const BATCH_SIZE = 10;
+                for (let i = 0; i < oldMemories.length; i += BATCH_SIZE) {
+                    const batch = oldMemories.slice(i, i + BATCH_SIZE);
+                    const batchText = batch.map(m => `[${new Date(m.metadata.timestamp).toISOString()}] ${m.text}`).join('\n');
+                    try {
+                        const summary = await brain.generateSummary(batchText);
+                        if (summary) {
+                            await this.vector.addMemory(summary, 'long_term', {
+                                original_count: batch.length,
+                                summary_date: Date.now(),
+                                source: 'maintenance_summary'
+                            });
+                        }
+                    }
+                    catch (e) {
+                        console.error('Failed to summarize batch:', e);
+                    }
+                }
+                // Prune after summarization
+                await this.vector.pruneOldMemories(vectorMaxAgeDays);
+            }
+            else {
+                // No old memories
+            }
+        }
+        catch (error) {
+            console.error('[MemoryManager] Maintenance failed:', error);
+        }
+    }
+}
+export const memoryManager = MemoryManager.getInstance();