xiaozuoassistant 0.2.1 → 0.2.3

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

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

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

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

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

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

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