memory-lucia 2.0.0

package/modules/priority.js

@@ -0,0 +1,174 @@
+/**
+ * Priority Module
+ * Automatic message priority classification and scoring
+ */
+
+class PriorityModule {
+    constructor(db) {
+        this.db = db;
+        this.keywords = {
+            critical: ['urgent', 'emergency', 'critical', 'asap', 'immediately', 'deadline', 'blocked'],
+            high: ['important', 'priority', 'required', 'needed', 'should', 'recommend'],
+            medium: ['consider', 'maybe', 'optional', 'suggestion', 'idea'],
+            low: ['nice to have', 'someday', 'eventually', 'wish', 'dream']
+        };
+    }
+
+    /**
+     * Analyze message and determine priority
+     * @param {string} message - Message content
+     * @param {object} context - Additional context
+     * @returns {object} Priority analysis result
+     */
+    async analyze(message, context = {}) {
+        const content = message.toLowerCase();
+        let priorityLevel = 4; // Default: Low
+        let importanceScore = 0;
+        const detectedKeywords = [];
+
+        // Check for critical keywords
+        for (const keyword of this.keywords.critical) {
+            if (content.includes(keyword)) {
+                priorityLevel = Math.min(priorityLevel, 1);
+                importanceScore += 25;
+                detectedKeywords.push({ word: keyword, level: 'critical' });
+            }
+        }
+
+        // Check for high priority keywords
+        for (const keyword of this.keywords.high) {
+            if (content.includes(keyword)) {
+                priorityLevel = Math.min(priorityLevel, 2);
+                importanceScore += 15;
+                detectedKeywords.push({ word: keyword, level: 'high' });
+            }
+        }
+
+        // Check for medium priority keywords
+        for (const keyword of this.keywords.medium) {
+            if (content.includes(keyword)) {
+                priorityLevel = Math.min(priorityLevel, 3);
+                importanceScore += 10;
+                detectedKeywords.push({ word: keyword, level: 'medium' });
+            }
+        }
+
+        // Context-based scoring
+        if (context.isMentioned) importanceScore += 10;
+        if (context.isReply) importanceScore += 5;
+        if (context.isDirectMessage) importanceScore += 10;
+
+        // Cap score at 100
+        importanceScore = Math.min(importanceScore, 100);
+
+        return {
+            priorityLevel,
+            importanceScore,
+            keywords: detectedKeywords,
+            contextSummary: this.generateSummary(message, detectedKeywords)
+        };
+    }
+
+    /**
+     * Store priority record
+     */
+    async store(messageId, conversationId, analysis) {
+        const sql = `
+            INSERT INTO memory_priorities 
+            (message_id, conversation_id, priority_level, importance_score, keywords, context_summary)
+            VALUES (?, ?, ?, ?, ?, ?)
+        `;
+        
+        await this.db.run(sql, [
+            messageId,
+            conversationId,
+            analysis.priorityLevel,
+            analysis.importanceScore,
+            JSON.stringify(analysis.keywords),
+            analysis.contextSummary
+        ]);
+
+        return { success: true, messageId, priority: analysis.priorityLevel };
+    }
+
+    /**
+     * Get messages by priority level
+     */
+    async getByPriority(level, limit = 50) {
+        const sql = `
+            SELECT * FROM memory_priorities 
+            WHERE priority_level = ? 
+            ORDER BY importance_score DESC, created_at DESC 
+            LIMIT ?
+        `;
+        return await this.db.all(sql, [level, limit]);
+    }
+
+    /**
+     * Get high priority messages
+     */
+    async getHighPriority(limit = 20) {
+        const sql = `
+            SELECT * FROM v_high_priority_messages 
+            LIMIT ?
+        `;
+        return await this.db.all(sql, [limit]);
+    }
+
+    /**
+     * Search by priority range
+     */
+    async searchByPriorityRange(minLevel = 1, maxLevel = 4) {
+        const sql = `
+            SELECT * FROM memory_priorities 
+            WHERE priority_level BETWEEN ? AND ? 
+            ORDER BY priority_level ASC, importance_score DESC
+        `;
+        return await this.db.all(sql, [minLevel, maxLevel]);
+    }
+
+    /**
+     * Auto-cleanup low priority old records
+     */
+    async cleanupOldLowPriority(days = 30) {
+        const sql = `
+            DELETE FROM memory_priorities 
+            WHERE priority_level = 4 
+            AND created_at < datetime('now', '-${days} days')
+        `;
+        const result = await this.db.run(sql);
+        return { deleted: result.changes };
+    }
+
+    /**
+     * Generate context summary
+     */
+    generateSummary(message, keywords) {
+        const sentences = message.split(/[.!?]+/).filter(s => s.trim().length > 0);
+        const firstSentence = sentences[0]?.trim() || message.substring(0, 100);
+        
+        return {
+            firstSentence,
+            keywordCount: keywords.length,
+            detectedWords: keywords.map(k => k.word)
+        };
+    }
+
+    /**
+     * Get priority statistics
+     */
+    async getStats() {
+        const sql = `
+            SELECT 
+                priority_level,
+                COUNT(*) as count,
+                AVG(importance_score) as avg_score
+            FROM memory_priorities 
+            GROUP BY priority_level
+            ORDER BY priority_level
+        `;
+        return await this.db.all(sql);
+    }
+}
+
+module.exports = PriorityModule;

package/modules/version.js

@@ -0,0 +1,286 @@
+/**
+ * Version Manager Module
+ * Handle database backups, migrations, and rollbacks
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+class VersionManager {
+    constructor(db, backupDir = './backups') {
+        this.db = db;
+        this.backupDir = backupDir;
+        
+        // Ensure backup directory exists
+        if (!fs.existsSync(backupDir)) {
+            fs.mkdirSync(backupDir, { recursive: true });
+        }
+    }
+
+    /**
+     * Create database backup
+     */
+    async createBackup(description = '', type = 'full') {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupName = `memory-v2-${type}-${timestamp}`;
+        const backupPath = path.join(this.backupDir, `${backupName}.db`);
+
+        // Copy database file
+        const dbPath = this.db.dbPath;
+        await this.copyFile(dbPath, backupPath);
+
+        // Calculate checksum
+        const checksum = await this.calculateChecksum(backupPath);
+        const stats = fs.statSync(backupPath);
+
+        // Record version
+        const result = await this.db.run(
+            `INSERT INTO memory_versions 
+             (version_name, version_type, description, backup_path, backup_size, checksum)
+             VALUES (?, ?, ?, ?, ?, ?)`,
+            [backupName, type, description, backupPath, stats.size, checksum]
+        );
+
+        // Record table statistics
+        await this.recordTableStats(result.id);
+
+        return {
+            success: true,
+            versionId: result.id,
+            backupPath,
+            size: stats.size,
+            checksum
+        };
+    }
+
+    /**
+     * Copy file (promise wrapper)
+     */
+    copyFile(src, dest) {
+        return new Promise((resolve, reject) => {
+            fs.copyFile(src, dest, (err) => {
+                if (err) reject(err);
+                else resolve();
+            });
+        });
+    }
+
+    /**
+     * Calculate file checksum
+     */
+    calculateChecksum(filePath) {
+        return new Promise((resolve, reject) => {
+            const hash = crypto.createHash('sha256');
+            const stream = fs.createReadStream(filePath);
+            
+            stream.on('data', data => hash.update(data));
+            stream.on('end', () => resolve(hash.digest('hex')));
+            stream.on('error', reject);
+        });
+    }
+
+    /**
+     * Record table statistics
+     */
+    async recordTableStats(versionId) {
+        const tables = [
+            'memory_priorities',
+            'memory_learning',
+            'memory_learning_milestones',
+            'memory_decisions',
+            'memory_evolution',
+            'memory_evolution_history',
+            'memory_versions',
+            'memory_version_stats'
+        ];
+
+        for (const table of tables) {
+            try {
+                const count = await this.db.get(
+                    `SELECT COUNT(*) as count FROM ${table}`
+                );
+                
+                await this.db.run(
+                    `INSERT INTO memory_version_stats (version_id, table_name, record_count)
+                     VALUES (?, ?, ?)`,
+                    [versionId, table, count.count]
+                );
+            } catch (err) {
+                console.warn(`Table ${table} not found or error:`, err.message);
+            }
+        }
+    }
+
+    /**
+     * List all versions
+     */
+    async listVersions() {
+        const sql = `
+            SELECT v.*, 
+                   GROUP_CONCAT(s.table_name || ': ' || s.record_count, ', ') as table_stats
+            FROM memory_versions v
+            LEFT JOIN memory_version_stats s ON v.id = s.version_id
+            GROUP BY v.id
+            ORDER BY v.created_at DESC
+        `;
+        return await this.db.all(sql);
+    }
+
+    /**
+     * Get active version
+     */
+    async getActiveVersion() {
+        return await this.db.get(
+            `SELECT * FROM memory_versions WHERE is_active = 1`
+        );
+    }
+
+    /**
+     * Activate version
+     */
+    async activateVersion(versionId) {
+        // Deactivate current active version
+        await this.db.run(
+            `UPDATE memory_versions SET is_active = 0 WHERE is_active = 1`
+        );
+
+        // Activate new version
+        await this.db.run(
+            `UPDATE memory_versions 
+             SET is_active = 1, activated_at = CURRENT_TIMESTAMP 
+             WHERE id = ?`,
+            [versionId]
+        );
+
+        return { success: true, versionId };
+    }
+
+    /**
+     * Rollback to version
+     */
+    async rollbackToVersion(versionId) {
+        const version = await this.db.get(
+            `SELECT * FROM memory_versions WHERE id = ?`,
+            [versionId]
+        );
+
+        if (!version) {
+            return { success: false, error: 'Version not found' };
+        }
+
+        if (!fs.existsSync(version.backup_path)) {
+            return { success: false, error: 'Backup file not found' };
+        }
+
+        // Create backup before rollback
+        await this.createBackup(`Pre-rollback to v${versionId}`, 'pre-rollback');
+
+        // Copy backup to active database
+        await this.copyFile(version.backup_path, this.db.dbPath);
+
+        // Activate version
+        await this.activateVersion(versionId);
+
+        return {
+            success: true,
+            rolledBackTo: version.version_name,
+            timestamp: version.created_at
+        };
+    }
+
+    /**
+     * Delete old backups
+     */
+    async cleanupOldBackups(days = 30, keepLastN = 5) {
+        // Get backups to delete
+        const oldBackups = await this.db.all(
+            `SELECT * FROM memory_versions 
+             WHERE version_type = 'full' 
+             AND created_at < datetime('now', '-${days} days')
+             ORDER BY created_at DESC`
+        );
+
+        // Keep last N backups
+        const toDelete = oldBackups.slice(keepLastN);
+        let deletedCount = 0;
+
+        for (const backup of toDelete) {
+            try {
+                if (fs.existsSync(backup.backup_path)) {
+                    fs.unlinkSync(backup.backup_path);
+                }
+                await this.db.run(
+                    `DELETE FROM memory_version_stats WHERE version_id = ?`,
+                    [backup.id]
+                );
+                await this.db.run(
+                    `DELETE FROM memory_versions WHERE id = ?`,
+                    [backup.id]
+                );
+                deletedCount++;
+            } catch (err) {
+                console.error(`Failed to delete backup ${backup.version_name}:`, err);
+            }
+        }
+
+        return { deleted: deletedCount };
+    }
+
+    /**
+     * Get backup statistics
+     */
+    async getBackupStats() {
+        const stats = await this.db.get(
+            `SELECT 
+                COUNT(*) as total_backups,
+                SUM(backup_size) as total_size,
+                AVG(backup_size) as avg_size,
+                MAX(created_at) as last_backup,
+                MIN(created_at) as first_backup
+             FROM memory_versions
+             WHERE version_type = 'full'`
+        );
+
+        return {
+            totalBackups: stats.total_backups || 0,
+            totalSize: stats.total_size || 0,
+            avgSize: stats.avg_size || 0,
+            lastBackup: stats.last_backup,
+            firstBackup: stats.first_backup
+        };
+    }
+
+    /**
+     * Verify backup integrity
+     */
+    async verifyBackup(versionId) {
+        const version = await this.db.get(
+            `SELECT * FROM memory_versions WHERE id = ?`,
+            [versionId]
+        );
+
+        if (!version) {
+            return { valid: false, error: 'Version not found' };
+        }
+
+        if (!fs.existsSync(version.backup_path)) {
+            return { valid: false, error: 'Backup file missing' };
+        }
+
+        const currentChecksum = await this.calculateChecksum(version.backup_path);
+        
+        if (currentChecksum !== version.checksum) {
+            return { 
+                valid: false, 
+                error: 'Checksum mismatch',
+                expected: version.checksum,
+                actual: currentChecksum
+            };
+        }
+
+        return { valid: true, checksum: currentChecksum };
+    }
+}
+
+module.exports = VersionManager;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "memory-lucia",
+  "version": "2.0.0",
+  "description": "Advanced memory system for OpenClaw agents with priority analysis, learning tracking, decision recording, and skill evolution",
+  "main": "api/index.js",
+  "scripts": {
+    "start": "node api/index.js",
+    "init": "node scripts/init-memory.js",
+    "test": "node tests/test.js",
+    "backup": "node scripts/backup.js"
+  },
+  "keywords": [
+    "openclaw",
+    "skill",
+    "memory",
+    "learning",
+    "decision",
+    "priority",
+    "evolution",
+    "sqlite"
+  ],
+  "author": "Chief of Staff",
+  "license": "MIT",
+  "dependencies": {
+    "sqlite3": "^5.1.6"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/YOUR_USERNAME/memory-lucia.git"
+  },
+  "bugs": {
+    "url": "https://github.com/YOUR_USERNAME/memory-lucia/issues"
+  },
+  "homepage": "https://github.com/YOUR_USERNAME/memory-lucia#readme"
+}

package/publish-with-otp.bat

@@ -0,0 +1,13 @@
+@echo off
+echo 🚀 Publishing memory-lucia to npm...
+echo.
+echo This package requires 2FA authentication.
+echo.
+echo Please enter your 6-digit 2FA code from your Authenticator app:
+set /p OTP="2FA Code: "
+echo.
+echo Publishing with OTP: %OTP%
+npm publish --access=public --otp=%OTP%
+echo.
+echo ✅ Done!
+pause

package/publish.bat

@@ -0,0 +1,17 @@
+@echo off
+echo 🚀 Publishing memory-lucia to npm...
+echo.
+
+echo Logging in to npm...
+npm login --auth-type=legacy
+
+echo.
+echo Publishing package...
+npm publish --access=public
+
+echo.
+echo ✅ Published!
+echo.
+echo Users can now install with:
+echo   npm install memory-lucia
+pause

package/publish.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+# Memory Lucia Publish Script
+
+echo "🚀 Publishing memory-lucia to npm..."
+echo ""
+
+# Login
+echo "Logging in to npm..."
+npm login --auth-type=legacy
+
+# Publish
+echo ""
+echo "Publishing package..."
+npm publish --access=public
+
+echo ""
+echo "✅ Published!"
+echo ""
+echo "Users can now install with:"
+echo "  npm install memory-lucia"

package/scripts/init-memory.js

@@ -0,0 +1,30 @@
+/**
+ * Initialize Memory V2 Database
+ * Usage: node scripts/init-memory.js [database-path]
+ */
+
+const MemoryAPI = require('../api');
+const path = require('path');
+
+const dbPath = process.argv[2] || './memory-v2.db';
+
+console.log('🚀 Initializing Memory V2 Database...\n');
+
+(async () => {
+    try {
+        const api = new MemoryAPI(dbPath);
+        await api.init();
+        
+        console.log('✅ Database initialized successfully!');
+        console.log(`📁 Location: ${path.resolve(dbPath)}`);
+        console.log('\nNext steps:');
+        console.log('  1. Use the API to track learning, decisions, etc.');
+        console.log('  2. Run tests: npm test');
+        console.log('  3. Create backups: npm run backup');
+        
+        await api.close();
+    } catch (err) {
+        console.error('❌ Initialization failed:', err.message);
+        process.exit(1);
+    }
+})();