xiaozuoassistant 0.2.19 → 0.2.21

package/dist/server/core/scheduler.js

@@ -0,0 +1,85 @@
+import cron from 'node-cron';
+import { memoryManager } from './memories/manager.js';
+import { config } from '../config/loader.js';
+let cronTask = null;
+let archiveTask = null;
+let isMaintenanceRunning = false;
+let isArchiveRunning = false;
+export const initScheduler = () => {
+    // Stop existing task if any
+    if (cronTask) {
+        cronTask.stop();
+        cronTask = null;
+    }
+    if (archiveTask) {
+        archiveTask.stop();
+        archiveTask = null;
+    }
+    // Default: Every day at midnight
+    const cronSchedule = config.scheduler?.memoryMaintenanceCron || '0 0 * * *';
+    console.log(`[Scheduler] Initializing memory maintenance job with schedule: "${cronSchedule}"`);
+    cronTask = cron.schedule(cronSchedule, () => {
+        runMaintenanceNow();
+    });
+    // Archive session memories every 3 minutes
+    archiveTask = cron.schedule('*/3 * * * *', () => {
+        runSessionArchivingNow();
+    });
+};
+export const getSchedulerStatus = () => {
+    return {
+        maintenance: {
+            status: cronTask ? 'running' : 'stopped',
+            schedule: config.scheduler?.memoryMaintenanceCron || '0 0 * * *',
+            isRunningNow: isMaintenanceRunning
+        },
+        archiving: {
+            status: archiveTask ? 'running' : 'stopped',
+            schedule: '*/3 * * * *',
+            isRunningNow: isArchiveRunning
+        }
+    };
+};
+export const startScheduler = () => {
+    initScheduler();
+};
+export const stopScheduler = () => {
+    if (cronTask) {
+        cronTask.stop();
+        cronTask = null;
+    }
+    if (archiveTask) {
+        archiveTask.stop();
+        archiveTask = null;
+    }
+    console.log('[Scheduler] All scheduled tasks stopped.');
+};
+export const runMaintenanceNow = async () => {
+    if (isMaintenanceRunning) {
+        console.log('[Scheduler] Maintenance is already running, skipping.');
+        return;
+    }
+    isMaintenanceRunning = true;
+    try {
+        console.log('[Scheduler] Manually triggering maintenance...');
+        const sessionMaxAgeDays = config.scheduler?.sessionRetentionDays ?? 5;
+        await memoryManager.runMaintenance({ sessionMaxAgeDays, vectorMaxAgeDays: 15 });
+    }
+    finally {
+        isMaintenanceRunning = false;
+    }
+};
+export const runSessionArchivingNow = async () => {
+    if (isArchiveRunning) {
+        console.log('[Scheduler] Archiving is already running, skipping.');
+        return;
+    }
+    isArchiveRunning = true;
+    try {
+        console.log('[Scheduler] Manually triggering session archiving...');
+        await memoryManager.runSessionArchiving();
+    }
+    finally {
+        isArchiveRunning = false;
+    }
+};

package/dist/server/core/task-queue.js

@@ -0,0 +1,104 @@
+import { memory } from './memory.js';
+import { brain } from './brain.js';
+import { eventBus } from './event-bus.js';
+export class TaskQueue {
+    constructor() {
+        this.chains = new Map();
+    }
+    enqueue(task) {
+        const key = task.run.sessionId;
+        const prev = this.chains.get(key) || Promise.resolve();
+        const next = prev
+            .catch(() => { })
+            .then(() => this.process(task))
+            .finally(() => {
+            if (this.chains.get(key) === next)
+                this.chains.delete(key);
+        });
+        this.chains.set(key, next);
+    }
+    async process(task) {
+        const { run, channel } = task;
+        try {
+            const session = await memory.getSession(run.sessionId);
+            if (!session) {
+                await memory.updateRun(run.sessionId, run.id, { status: 'failed', error: 'Session not found', completedAt: Date.now() });
+                eventBus.emitEvent({
+                    type: 'run_status',
+                    payload: { runId: run.id, status: 'failed', error: 'Session not found' },
+                    channel,
+                    sessionId: run.sessionId,
+                    timestamp: Date.now()
+                });
+                return;
+            }
+            await memory.updateRun(run.sessionId, run.id, { status: 'running', updatedAt: Date.now() });
+            eventBus.emitEvent({
+                type: 'run_status',
+                payload: { runId: run.id, status: 'running' },
+                channel,
+                sessionId: run.sessionId,
+                timestamp: Date.now()
+            });
+            const context = await memory.getRelevantContext(run.userContent, run.sessionId);
+            const sessionAlias = session.meta.alias ? `Session Alias: ${session.meta.alias}` : '';
+            const workspaceLine = session.meta.workspace ? `Current Workspace: ${session.meta.workspace}` : '';
+            const enhancedSystemPrompt = `You are xiaozuoAssistant, a helpful AI assistant.
+${sessionAlias}
+${workspaceLine}
+Here is some relevant context from your memory:
+${context}`;
+            const ctx = {
+                sessionId: run.sessionId,
+                history: session.messages,
+                channel,
+                session: session.meta,
+                metadata: {
+                    workspace: session.meta.workspace,
+                    alias: session.meta.alias,
+                    runId: run.id
+                }
+            };
+            const responseContent = await brain.processMessage(session.messages, run.userContent, enhancedSystemPrompt, ctx);
+            await memory.addMessage(run.sessionId, { role: 'assistant', content: responseContent, timestamp: Date.now() });
+            await memory.updateRun(run.sessionId, run.id, { status: 'completed', completedAt: Date.now() });
+            eventBus.emitEvent({
+                type: 'run_status',
+                payload: { runId: run.id, status: 'completed' },
+                channel,
+                sessionId: run.sessionId,
+                timestamp: Date.now()
+            });
+            eventBus.emitEvent({
+                type: 'response',
+                payload: { content: responseContent, runId: run.id },
+                channel,
+                sessionId: run.sessionId,
+                timestamp: Date.now()
+            });
+        }
+        catch (e) {
+            const msg = String(e?.message || e);
+            try {
+                await memory.updateRun(run.sessionId, run.id, { status: 'failed', error: msg, completedAt: Date.now() });
+            }
+            catch {
+                // ignore
+            }
+            try {
+                await memory.addMessage(run.sessionId, { role: 'assistant', content: `Error: ${msg}`, timestamp: Date.now() });
+            }
+            catch {
+                // ignore
+            }
+            eventBus.emitEvent({
+                type: 'run_status',
+                payload: { runId: run.id, status: 'failed', error: msg },
+                channel,
+                sessionId: run.sessionId,
+                timestamp: Date.now()
+            });
+        }
+    }
+}
+export const taskQueue = new TaskQueue();

package/dist/server/core/types.js

@@ -0,0 +1 @@
+export {};