xiaozuoassistant 0.1.41

package/dist/server/core/brain.js

@@ -0,0 +1,131 @@
+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) {
+        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.';
+        // Convert history messages to the format expected by OpenAI
+        const messageHistory = history.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 },
+            ...messageHistory,
+            { role: 'user', content: newMessage }
+        ];
+        try {
+            if (process.env.DEBUG)
+                console.log('[Brain] Calling LLM...');
+            let response = await this.callLLM(messages);
+            // 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 = 10;
+            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 result = await skill.execute(functionArgs);
+                            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 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) + '...');
+            return finalContent;
+        }
+        catch (error) {
+            console.error('[Brain] Error in processing:', error);
+            return `Error: ${error.message}`;
+        }
+    }
+    async generateSummary(content) {
+        try {
+            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
+            });
+            return response.choices[0].message.content || '';
+        }
+        catch (e) {
+            console.error('Summary generation failed:', e);
+            return '';
+        }
+    }
+    async callLLM(messages) {
+        const tools = skillRegistry.getToolsDefinition();
+        // OpenAI SDK expects tools to be undefined if empty array, or valid tools array
+        const toolsParam = tools.length > 0 ? tools : undefined;
+        return await this.openai.chat.completions.create({
+            model: config.llm.model,
+            messages: messages,
+            tools: toolsParam,
+            temperature: config.llm.temperature
+        });
+    }
+}
+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];
+// Only add Console transport if NOT in production, or if explicitly requested
+// This prevents double logging to stdout.log in daemon mode.
+if (process.env.NODE_ENV !== 'production') {
+    transports.push(new winston.transports.Console({
+        format: winston.format.combine(winston.format.colorize(), winston.format.simple())
+    }));
+}
+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,115 @@
+import { ShortTermMemory } from './short-term.js';
+import { VectorMemory } from './vector.js';
+import { StructuredMemory } from './structured.js';
+import { brain } from '../brain.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() {
+        return this.shortTerm.createSession();
+    }
+    async getSession(id) {
+        return this.shortTerm.getSession(id);
+    }
+    async listSessions() {
+        return this.shortTerm.listSessions();
+    }
+    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
+            this.vector.addMemory(message.content, 'recent', { sessionId, role: message.role })
+                .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 getHistory(sessionId) {
+        const session = await this.shortTerm.getSession(sessionId);
+        return session ? session.messages : [];
+    }
+    // --- Retrieval ---
+    async getRelevantContext(query, sessionId) {
+        // 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, 3);
+        const vectorContext = vectorResults.map(r => `[Memory]: ${r.text}`).join('\n');
+        // 3. Get User Profile (Structured)
+        const profile = await this.structured.getUserProfile();
+        const profileContext = Object.entries(profile).map(([k, v]) => `[User Info] ${k}: ${v}`).join('\n');
+        return `
+=== User Profile ===
+${profileContext}
+
+=== Relevant Memories ===
+${vectorContext}
+
+=== Recent Conversation ===
+${recentMessages}
+`;
+    }
+    // --- Maintenance ---
+    // Managed by Scheduler
+    async runMaintenance(maxAgeDays = 15) {
+        console.log(`[MemoryManager] Running maintenance (Max Age: ${maxAgeDays} days)...`);
+        try {
+            // 1. Clean up old sessions
+            const deletedSessions = await this.shortTerm.cleanupOldSessions(maxAgeDays);
+            if (deletedSessions > 0) {
+                console.log(`[MemoryManager] Deleted ${deletedSessions} old sessions.`);
+            }
+            // 2. Summarize and Prune Vector Memories
+            const oldMemories = await this.vector.getMemoriesOlderThan(maxAgeDays);
+            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(maxAgeDays);
+            }
+            else {
+                // No old memories
+            }
+        }
+        catch (error) {
+            console.error('[MemoryManager] Maintenance failed:', error);
+        }
+    }
+}
+export const memoryManager = MemoryManager.getInstance();

package/dist/server/core/memories/short-term.js

@@ -0,0 +1,128 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+const SESSIONS_DIR = path.resolve(process.cwd(), 'sessions');
+export class ShortTermMemory {
+    constructor() {
+        this.sessionCache = new Map();
+        fs.ensureDirSync(SESSIONS_DIR);
+        this.ensureDefaultSession();
+    }
+    static getInstance() {
+        if (!ShortTermMemory.instance) {
+            ShortTermMemory.instance = new ShortTermMemory();
+        }
+        return ShortTermMemory.instance;
+    }
+    async ensureDefaultSession() {
+        const defaultSessionId = 'default-session';
+        const filePath = path.join(SESSIONS_DIR, `${defaultSessionId}.json`);
+        if (!await fs.pathExists(filePath)) {
+            const session = {
+                id: defaultSessionId,
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+                messages: []
+            };
+            await this.saveSession(session);
+        }
+    }
+    async createSession() {
+        const id = uuidv4();
+        const session = {
+            id,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            messages: []
+        };
+        await this.saveSession(session);
+        return session;
+    }
+    async getSession(id) {
+        if (this.sessionCache.has(id)) {
+            return this.sessionCache.get(id);
+        }
+        const filePath = path.join(SESSIONS_DIR, `${id}.json`);
+        if (await fs.pathExists(filePath)) {
+            const data = await fs.readJson(filePath);
+            this.sessionCache.set(id, data);
+            return data;
+        }
+        return null;
+    }
+    async saveSession(session) {
+        const filePath = path.join(SESSIONS_DIR, `${session.id}.json`);
+        session.updatedAt = Date.now();
+        this.sessionCache.set(session.id, session);
+        await fs.writeJson(filePath, session, { spaces: 2 });
+    }
+    async addMessage(sessionId, message) {
+        const session = await this.getSession(sessionId);
+        if (session) {
+            session.messages.push(message);
+            // Keep only last 50 messages in memory for "immediate" context if needed, 
+            // but here we keep full session history for simplicity as per current design.
+            // Layer 1 specific requirement: "Recent 20-50 turns". 
+            // We can implement truncation logic here if we want to save space, 
+            // but for now let's just save everything to JSON.
+            await this.saveSession(session);
+        }
+        else {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+    }
+    async deleteSession(id) {
+        if (id === 'default-session') {
+            throw new Error('Cannot delete default session');
+        }
+        const filePath = path.join(SESSIONS_DIR, `${id}.json`);
+        if (await fs.pathExists(filePath)) {
+            await fs.remove(filePath);
+            this.sessionCache.delete(id);
+        }
+    }
+    async listSessions() {
+        const files = await fs.readdir(SESSIONS_DIR);
+        const sessions = [];
+        for (const file of files) {
+            if (file.endsWith('.json')) {
+                try {
+                    const data = await fs.readJson(path.join(SESSIONS_DIR, file));
+                    sessions.push(data);
+                }
+                catch (e) {
+                    console.error(`Error reading session file ${file}:`, e);
+                }
+            }
+        }
+        return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+    async cleanupOldSessions(maxAgeDays) {
+        const files = await fs.readdir(SESSIONS_DIR);
+        let deletedCount = 0;
+        const now = Date.now();
+        const msPerDay = 24 * 60 * 60 * 1000;
+        for (const file of files) {
+            if (file.endsWith('.json')) {
+                const filePath = path.join(SESSIONS_DIR, file);
+                try {
+                    const session = await fs.readJson(filePath);
+                    // Skip default session
+                    if (session.id === 'default-session')
+                        continue;
+                    const ageDays = (now - session.updatedAt) / msPerDay;
+                    if (ageDays > maxAgeDays) {
+                        console.log(`[ShortTermMemory] Deleting old session: ${session.id} (Age: ${ageDays.toFixed(1)} days)`);
+                        await fs.remove(filePath);
+                        this.sessionCache.delete(session.id);
+                        deletedCount++;
+                    }
+                }
+                catch (error) {
+                    console.error(`[ShortTermMemory] Error processing file ${file} for cleanup:`, error);
+                }
+            }
+        }
+        return deletedCount;
+    }
+}

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

@@ -0,0 +1,109 @@
+import Database from 'better-sqlite3';
+import path from 'path';
+import fs from 'fs-extra';
+const DB_DIR = path.resolve(process.cwd(), 'data/sqlite');
+const DB_FILE = path.join(DB_DIR, 'memories.db');
+export class StructuredMemory {
+    constructor() {
+        fs.ensureDirSync(DB_DIR);
+        this.db = new Database(DB_FILE);
+        this.initTables();
+    }
+    static getInstance() {
+        if (!StructuredMemory.instance) {
+            StructuredMemory.instance = new StructuredMemory();
+        }
+        return StructuredMemory.instance;
+    }
+    initTables() {
+        // Facts table: key-value or simple structured data
+        this.db.prepare(`
+      CREATE TABLE IF NOT EXISTS facts (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        category TEXT NOT NULL,
+        key TEXT NOT NULL,
+        value TEXT NOT NULL,
+        confidence REAL DEFAULT 1.0,
+        source TEXT,
+        timestamp INTEGER
+      )
+    `).run();
+        // User Profile: specialized facts
+        this.db.prepare(`
+      CREATE TABLE IF NOT EXISTS user_profile (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        key TEXT UNIQUE NOT NULL,
+        value TEXT NOT NULL,
+        updated_at INTEGER
+      )
+    `).run();
+        // Graph nodes (Entities)
+        this.db.prepare(`
+      CREATE TABLE IF NOT EXISTS entities (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT UNIQUE NOT NULL,
+        type TEXT NOT NULL,
+        metadata TEXT
+      )
+    `).run();
+        // Graph edges (Relations)
+        this.db.prepare(`
+      CREATE TABLE IF NOT EXISTS relations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        source_id INTEGER,
+        target_id INTEGER,
+        relation TEXT NOT NULL,
+        weight REAL DEFAULT 1.0,
+        FOREIGN KEY(source_id) REFERENCES entities(id),
+        FOREIGN KEY(target_id) REFERENCES entities(id)
+      )
+    `).run();
+    }
+    addFact(category, key, value, source = 'user') {
+        const stmt = this.db.prepare(`
+      INSERT INTO facts (category, key, value, source, timestamp)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        stmt.run(category, key, value, source, Date.now());
+    }
+    getFacts(category) {
+        if (category) {
+            return this.db.prepare('SELECT * FROM facts WHERE category = ?').all(category);
+        }
+        return this.db.prepare('SELECT * FROM facts').all();
+    }
+    updateUserProfile(key, value) {
+        const stmt = this.db.prepare(`
+      INSERT INTO user_profile (key, value, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+    `);
+        stmt.run(key, value, Date.now());
+    }
+    getUserProfile() {
+        const rows = this.db.prepare('SELECT key, value FROM user_profile').all();
+        const profile = {};
+        rows.forEach((row) => {
+            profile[row.key] = row.value;
+        });
+        return profile;
+    }
+    // Simple Graph Operations
+    addEntity(name, type, metadata = {}) {
+        try {
+            this.db.prepare('INSERT INTO entities (name, type, metadata) VALUES (?, ?, ?)')
+                .run(name, type, JSON.stringify(metadata));
+        }
+        catch (e) {
+            // Ignore unique constraint violation, maybe update?
+        }
+    }
+    addRelation(sourceName, targetName, relation) {
+        const source = this.db.prepare('SELECT id FROM entities WHERE name = ?').get(sourceName);
+        const target = this.db.prepare('SELECT id FROM entities WHERE name = ?').get(targetName);
+        if (source && target) {
+            this.db.prepare('INSERT INTO relations (source_id, target_id, relation) VALUES (?, ?, ?)')
+                .run(source.id, target.id, relation);
+        }
+    }
+}