xiaozuoassistant 0.1.95 → 0.1.97

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

@@ -1,24 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,238 +0,0 @@
-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();