xiaozuoassistant 0.2.7 → 0.2.9

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

@@ -0,0 +1,357 @@
+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() {
+        try {
+            // 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 (multi-user)
+            // V3: Simplified profile (name, email only)
+            this.db.prepare(`
+        CREATE TABLE IF NOT EXISTS user_profile_v3 (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          user_id TEXT NOT NULL,
+          name TEXT,
+          email TEXT,
+          updated_at INTEGER,
+          UNIQUE(user_id)
+        )
+      `).run();
+            this.migrateUserProfileV3();
+            // 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();
+            // Projects
+            this.db.prepare(`
+      CREATE TABLE IF NOT EXISTS projects (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT,
+        departments TEXT,
+        members TEXT,
+        directory TEXT,
+        created_at INTEGER,
+        updated_at INTEGER
+      )
+    `).run();
+            // Notebooks
+            this.db.prepare(`
+      CREATE TABLE IF NOT EXISTS notebooks (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT,
+        keywords TEXT,
+        created_at INTEGER,
+        updated_at INTEGER
+      )
+    `).run();
+            // Notes
+            this.db.prepare(`
+      CREATE TABLE IF NOT EXISTS notes (
+        id TEXT PRIMARY KEY,
+        notebook_id TEXT NOT NULL,
+        title TEXT NOT NULL,
+        content TEXT,
+        is_todo INTEGER DEFAULT 0,
+        done INTEGER DEFAULT 0,
+        created_at INTEGER,
+        updated_at INTEGER,
+        FOREIGN KEY(notebook_id) REFERENCES notebooks(id) ON DELETE CASCADE
+      )
+    `).run();
+        }
+        catch (error) {
+            console.error('[StructuredMemory] initTables failed:', error);
+            throw error; // Rethrow to stop startup if DB is critical
+        }
+    }
+    migrateUserProfileV3() {
+        try {
+            const columns = this.db.prepare('PRAGMA table_info(user_profile)').all();
+            // If old table doesn't exist, we are good (new install will use v3)
+            // But wait, we created v3 table above.
+            // We need to check if we need to migrate from v1/v2 to v3.
+            // Strategy: 
+            // 1. Check if 'user_profile' table exists.
+            // 2. If it does, read data, transform, insert into v3, drop old table.
+            const tableExists = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='user_profile'").get();
+            if (!tableExists)
+                return;
+            console.log('[StructuredMemory] Migrating user profile to V3...');
+            const rows = this.db.prepare('SELECT * FROM user_profile').all();
+            // Group by user_id
+            const users = {};
+            for (const row of rows) {
+                const uid = row.user_id || 'default';
+                if (!users[uid])
+                    users[uid] = {};
+                if (row.key === 'name')
+                    users[uid].name = row.value;
+                if (row.key === 'email')
+                    users[uid].email = row.value;
+            }
+            const ins = this.db.prepare('INSERT OR REPLACE INTO user_profile_v3 (user_id, name, email, updated_at) VALUES (?, ?, ?, ?)');
+            const tx = this.db.transaction(() => {
+                for (const [uid, data] of Object.entries(users)) {
+                    ins.run(uid, data.name || null, data.email || null, Date.now());
+                }
+            });
+            tx();
+            this.db.prepare('DROP TABLE user_profile').run();
+            this.db.prepare('DROP TABLE IF EXISTS user_profile_v2').run(); // Clean up intermediate v2 if any
+        }
+        catch (e) {
+            console.error('[StructuredMemory] Migration to V3 failed:', e);
+        }
+    }
+    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(userId, key, value) {
+        const uid = userId || 'default';
+        const now = Date.now();
+        // V3: Column based
+        if (key !== 'name' && key !== 'email') {
+            console.warn(`[StructuredMemory] Unknown profile key: ${key}`);
+            return;
+        }
+        // Use dynamic SQL for specific column update
+        this.db.prepare(`
+        INSERT INTO user_profile_v3 (user_id, ${key}, updated_at)
+        VALUES (?, ?, ?)
+        ON CONFLICT(user_id) DO UPDATE SET ${key} = excluded.${key}, updated_at = excluded.updated_at
+    `).run(uid, value, now);
+    }
+    getUserProfile(userId) {
+        const row = this.db.prepare('SELECT * FROM user_profile_v3 WHERE user_id = ?').get(userId || 'default');
+        if (!row)
+            return {};
+        // Map back to object for compatibility
+        return {
+            name: row.name || '',
+            email: row.email || ''
+        };
+    }
+    // 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);
+        }
+    }
+    // --- Projects ---
+    createProject(id, name, description, departments, members, directory) {
+        const now = Date.now();
+        this.db.prepare(`
+      INSERT INTO projects (id, name, description, departments, members, directory, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, name, description || null, departments || null, members || null, directory || null, now, now);
+    }
+    getProject(id) {
+        const row = this.db.prepare('SELECT * FROM projects WHERE id = ?').get(id);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            name: row.name,
+            description: row.description,
+            departments: row.departments,
+            members: row.members,
+            directory: row.directory,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at
+        };
+    }
+    updateProject(id, patch) {
+        const current = this.getProject(id);
+        if (!current)
+            throw new Error('Project not found');
+        const next = { ...current, ...patch };
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE projects SET name = ?, description = ?, departments = ?, members = ?, directory = ?, updated_at = ?
+      WHERE id = ?
+    `).run(next.name, next.description || null, next.departments || null, next.members || null, next.directory || null, now, id);
+    }
+    deleteProject(id) {
+        this.db.prepare('DELETE FROM projects WHERE id = ?').run(id);
+    }
+    listProjects() {
+        const rows = this.db.prepare('SELECT * FROM projects ORDER BY updated_at DESC').all();
+        return rows.map(row => ({
+            id: row.id,
+            name: row.name,
+            description: row.description,
+            departments: row.departments,
+            members: row.members,
+            directory: row.directory,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at
+        }));
+    }
+    // --- Notebooks ---
+    createNotebook(id, name, description, keywords) {
+        const now = Date.now();
+        this.db.prepare(`
+      INSERT INTO notebooks (id, name, description, keywords, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(id, name, description || null, keywords || null, now, now);
+    }
+    getNotebook(id) {
+        const row = this.db.prepare('SELECT * FROM notebooks WHERE id = ?').get(id);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            name: row.name,
+            description: row.description,
+            keywords: row.keywords,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at
+        };
+    }
+    updateNotebook(id, patch) {
+        const current = this.getNotebook(id);
+        if (!current)
+            throw new Error('Notebook not found');
+        const next = { ...current, ...patch };
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE notebooks SET name = ?, description = ?, keywords = ?, updated_at = ?
+      WHERE id = ?
+    `).run(next.name, next.description || null, next.keywords || null, now, id);
+    }
+    deleteNotebook(id) {
+        this.db.prepare('DELETE FROM notebooks WHERE id = ?').run(id);
+    }
+    listNotebooks() {
+        const rows = this.db.prepare('SELECT * FROM notebooks ORDER BY updated_at DESC').all();
+        return rows.map(row => ({
+            id: row.id,
+            name: row.name,
+            description: row.description,
+            keywords: row.keywords,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at
+        }));
+    }
+    // --- Notes ---
+    createNote(id, notebookId, title, content, isTodo = false, done = false) {
+        const now = Date.now();
+        this.db.prepare(`
+      INSERT INTO notes (id, notebook_id, title, content, is_todo, done, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, notebookId, title, content || null, isTodo ? 1 : 0, done ? 1 : 0, now, now);
+    }
+    getNote(id) {
+        const row = this.db.prepare('SELECT * FROM notes WHERE id = ?').get(id);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            notebookId: row.notebook_id,
+            title: row.title,
+            content: row.content,
+            isTodo: !!row.is_todo,
+            done: !!row.done,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at
+        };
+    }
+    updateNote(id, patch) {
+        const current = this.getNote(id);
+        if (!current)
+            throw new Error('Note not found');
+        const next = { ...current, ...patch };
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE notes SET title = ?, content = ?, is_todo = ?, done = ?, updated_at = ?
+      WHERE id = ?
+    `).run(next.title, next.content || null, next.isTodo ? 1 : 0, next.done ? 1 : 0, now, id);
+    }
+    deleteNote(id) {
+        this.db.prepare('DELETE FROM notes WHERE id = ?').run(id);
+    }
+    listNotes(notebookId) {
+        let rows;
+        if (notebookId) {
+            rows = this.db.prepare('SELECT * FROM notes WHERE notebook_id = ? ORDER BY created_at DESC').all(notebookId);
+        }
+        else {
+            rows = this.db.prepare('SELECT * FROM notes ORDER BY created_at DESC').all();
+        }
+        return rows.map(row => ({
+            id: row.id,
+            notebookId: row.notebook_id,
+            title: row.title,
+            content: row.content,
+            isTodo: !!row.is_todo,
+            done: !!row.done,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at
+        }));
+    }
+}

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

@@ -0,0 +1,137 @@
+import * as lancedb from '@lancedb/lancedb';
+import path from 'path';
+import fs from 'fs-extra';
+import { config } from '../../config/loader.js';
+import { createOpenAIClient } from '../../llm/openai.js';
+const VECTOR_DB_DIR = path.resolve(process.cwd(), 'data/lancedb');
+export class VectorMemory {
+    constructor() {
+        this.openai = null;
+        this.isInitialized = false;
+        fs.ensureDirSync(VECTOR_DB_DIR);
+        this.updateClient();
+        this.initDB();
+    }
+    updateClient() {
+        this.openai = config.llm.apiKey ? createOpenAIClient(config.llm) : null;
+    }
+    static getInstance() {
+        if (!VectorMemory.instance) {
+            VectorMemory.instance = new VectorMemory();
+        }
+        return VectorMemory.instance;
+    }
+    async initDB() {
+        try {
+            this.db = await lancedb.connect(VECTOR_DB_DIR);
+            // Ensure table exists
+            const tableNames = await this.db.tableNames();
+            if (!tableNames.includes('memories')) {
+                // Create table with dummy data to define schema, then delete it
+                // LanceDB schema inference is based on data
+                const dummyData = [{
+                        id: 'init',
+                        text: 'init',
+                        vector: Array(1536).fill(0), // OpenAI embedding dimension
+                        metadata: { type: 'recent', timestamp: Date.now(), sessionId: 'init', tags: '' }
+                    }];
+                this.table = await this.db.createTable('memories', dummyData);
+                // await this.table.delete('id = "init"'); // Older lancedb syntax might differ
+            }
+            else {
+                this.table = await this.db.openTable('memories');
+            }
+            this.isInitialized = true;
+        }
+        catch (error) {
+            console.error('Failed to init LanceDB:', error);
+        }
+    }
+    async getEmbedding(text) {
+        if (!this.openai) {
+            console.warn('OpenAI client not initialized (missing API Key), skipping embedding.');
+            return Array(1536).fill(0);
+        }
+        try {
+            // Use OpenAI compatible embedding endpoint
+            // Note: Some compatible providers might use different models/dimensions.
+            // Default to text-embedding-ada-002 or similar standard.
+            const model = config.llm.embeddingModel || 'text-embedding-ada-002';
+            const response = await this.openai.embeddings.create({
+                model: model,
+                input: text,
+            });
+            return response.data[0].embedding;
+        }
+        catch (error) {
+            console.error('Embedding failed:', error);
+            // Fallback: return zero vector or throw? 
+            // For MVP robustness, return zeros if embedding fails (search won't work but app won't crash)
+            return Array(1536).fill(0);
+        }
+    }
+    async addMemory(text, type, metadata = {}) {
+        if (!this.isInitialized)
+            await this.initDB();
+        if (!this.table)
+            return; // DB failed to init
+        const vector = await this.getEmbedding(text);
+        const memory = {
+            id: Math.random().toString(36).substring(7),
+            text,
+            vector,
+            metadata: {
+                type: type,
+                timestamp: Date.now(),
+                ...metadata
+            }
+        };
+        try {
+            await this.table.add([memory]);
+        }
+        catch (e) {
+            console.error('Failed to add memory to vector db:', e);
+        }
+    }
+    async search(query, type, limit = 5) {
+        if (!this.isInitialized)
+            await this.initDB();
+        if (!this.table)
+            return [];
+        const vector = await this.getEmbedding(query);
+        // Check if table supports search
+        if (this.table.search) {
+            let search = this.table.search(vector).limit(limit);
+            if (type) {
+                try {
+                    // Using simpler filter to avoid Dictionary type issues
+                    // search = search.where(`metadata.type = '${type}'`);
+                    // Skip filtering for now to avoid lancedb issues
+                }
+                catch (e) {
+                    console.warn('Filter not supported in this LanceDB version/mode, filtering manually');
+                }
+            }
+            try {
+                const results = await search.execute();
+                return results.map((r) => ({
+                    id: r.id,
+                    text: r.text,
+                    vector: r.vector,
+                    metadata: r.metadata
+                }));
+            }
+            catch (e) {
+                console.error('Vector search failed:', e);
+                return [];
+            }
+        }
+        return [];
+    }
+    async getMemoriesOlderThan(maxAgeDays) {
+        return []; // Disable for now to avoid build errors with older lancedb types
+    }
+    async pruneOldMemories(maxAgeDays) {
+        return 0; // Disable for now
+    }
+}

package/dist/server/core/memory.js

@@ -0,0 +1,2 @@
+import { memoryManager } from './memories/manager.js';
+export const memory = memoryManager;

package/dist/server/core/plugin-manager.js

@@ -0,0 +1,128 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { skillRegistry } from '../skills/registry.js';
+export class PluginManager {
+    constructor(pluginDir) {
+        this.plugins = new Map();
+        this.channels = [];
+        this.pluginDir = pluginDir;
+    }
+    getChannels() {
+        return this.channels;
+    }
+    createContext(pluginName) {
+        return {
+            registerSkill: (skill) => {
+                console.log(`[PluginManager] Plugin '${pluginName}' registered skill: ${skill.name}`);
+                // Inject plugin name into skill for tracking if needed
+                skill.pluginName = pluginName;
+                skillRegistry.register(skill);
+            },
+            registerChannel: (channel) => {
+                console.log(`[PluginManager] Plugin '${pluginName}' registered channel: ${channel.name}`);
+                this.channels.push(channel);
+                // Note: Channels registered after app start might need manual starting if the app is already running.
+                // For simplicity in this MVP, we assume plugins are loaded at startup.
+            },
+            logger: {
+                info: (msg) => console.log(`[Plugin:${pluginName}] ${msg}`),
+                warn: (msg) => console.warn(`[Plugin:${pluginName}] ${msg}`),
+                error: (msg) => console.error(`[Plugin:${pluginName}] ${msg}`),
+            }
+        };
+    }
+    async loadPlugins() {
+        try {
+            // 1. Load built-in plugins (migrated skills) from local src/plugins
+            const internalPluginDir = path.resolve(__dirname, '../plugins');
+            await this.scanAndLoad(internalPluginDir);
+            // 2. Load user plugins from configured plugin directory
+            // Only if it's different from internal directory to avoid duplicates
+            if (path.resolve(this.pluginDir) !== internalPluginDir) {
+                await this.scanAndLoad(this.pluginDir);
+            }
+        }
+        catch (error) {
+            console.error('[PluginManager] Error loading plugins:', error);
+        }
+    }
+    async scanAndLoad(dir) {
+        try {
+            await fs.access(dir);
+        }
+        catch {
+            return; // Directory doesn't exist, skip
+        }
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                await this.loadPluginFromDir(path.join(dir, entry.name));
+            }
+        }
+    }
+    getPlugins() {
+        return Array.from(this.plugins.values()).map(p => ({
+            name: p.metadata.name,
+            version: p.metadata.version,
+            description: p.metadata.description,
+            author: p.metadata.author,
+            enabled: true // Todo: Implement enable/disable persistence
+        }));
+    }
+    async loadPluginFromDir(dirPath) {
+        try {
+            // Check for package.json or index.js/ts
+            const pkgPath = path.join(dirPath, 'package.json');
+            const indexPath = path.join(dirPath, 'index.js'); // Assuming compiled JS for now, or ts-node handling
+            let entryPoint = indexPath;
+            // Try to read package.json main field
+            try {
+                const pkgContent = await fs.readFile(pkgPath, 'utf-8');
+                const pkg = JSON.parse(pkgContent);
+                if (pkg.main) {
+                    entryPoint = path.join(dirPath, pkg.main);
+                }
+            }
+            catch (e) {
+                // No package.json, assume index.js
+            }
+            // Dynamic import
+            // Note: In a real-world scenario, we might need to handle CJS/ESM compatibility carefully.
+            // Here we assume the plugin exports a default object implementing the Plugin interface.
+            // Ensure we are importing a file that exists
+            try {
+                await fs.access(entryPoint);
+            }
+            catch {
+                // Try .ts if .js doesn't exist (for dev mode with tsx/ts-node)
+                if (entryPoint.endsWith('.js')) {
+                    const tsEntryPoint = entryPoint.replace(/\.js$/, '.ts');
+                    try {
+                        await fs.access(tsEntryPoint);
+                        entryPoint = tsEntryPoint;
+                    }
+                    catch {
+                        // console.warn(`[PluginManager] Could not find entry point for plugin at ${dirPath}`);
+                        return;
+                    }
+                }
+                else {
+                    return;
+                }
+            }
+            const pluginModule = await import(entryPoint);
+            const plugin = pluginModule.default || pluginModule;
+            if (!plugin.metadata || !plugin.onLoad) {
+                console.warn(`[PluginManager] Invalid plugin structure in ${dirPath}`);
+                return;
+            }
+            console.log(`[PluginManager] Loading plugin: ${plugin.metadata.name} (${plugin.metadata.version})`);
+            const context = this.createContext(plugin.metadata.name);
+            await plugin.onLoad(context);
+            this.plugins.set(plugin.metadata.name, plugin);
+        }
+        catch (error) {
+            console.error(`[PluginManager] Failed to load plugin from ${dirPath}:`, error);
+        }
+    }
+}

package/dist/server/core/plugin.js

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