memory-lucia 2.5.1 → 2.5.3

package/README.md

@@ -104,7 +104,7 @@ SQLite backend with tables:
 
 ## 📋 Version
 
-Current: 2.5.1
+Current: 2.5.3
 
 ## 📄 License
 

package/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: memory-lucia
-version: 2.5.1
+version: 2.5.3
 description: |
   Memory Lucia V2.5 - Advanced memory system with hybrid query, enhanced learning tracking,
   autonomous decision recording, and skill evolution monitoring.

package/database/schema.sql

@@ -1,29 +1,37 @@
--- Memory V2.0 Database Schema
--- SQLite database schema for OpenClaw Memory System
+-- Memory V2.5 Database Schema
+-- SQLite database schema for Memory Lucia V2.5
 
 -- Priority Analysis Table
 CREATE TABLE IF NOT EXISTS memory_priorities (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
-    msg_id TEXT NOT NULL,
-    conv_id TEXT,
-    priority_level TEXT CHECK(priority_level IN ('critical', 'high', 'medium', 'low')),
-    reasoning TEXT,
-    category TEXT,
-    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    message_id TEXT NOT NULL,
+    conversation_id INTEGER,
+    priority_level INTEGER CHECK(priority_level BETWEEN 1 AND 4),
+    importance_score REAL DEFAULT 0,
+    keywords TEXT,
+    context_summary TEXT,
+    auto_detected BOOLEAN DEFAULT 0,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
 );
 
 -- Learning Tracking Table
 CREATE TABLE IF NOT EXISTS memory_learning (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
-    msg_id TEXT NOT NULL,
-    conv_id TEXT,
-    topic TEXT,
-    description TEXT,
-    status TEXT CHECK(status IN ('active', 'paused', 'completed', 'abandoned')) DEFAULT 'active',
-    progress INTEGER DEFAULT 0 CHECK(progress >= 0 AND progress <= 100),
-    started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-    completed_at DATETIME
+    message_id TEXT NOT NULL,
+    conversation_id INTEGER,
+    learning_topic TEXT NOT NULL,
+    topic_category TEXT,
+    progress_status TEXT CHECK(progress_status IN ('not_started', 'started', 'in_progress', 'completed', 'on_hold')),
+    progress_percentage INTEGER DEFAULT 0 CHECK(progress_percentage BETWEEN 0 AND 100),
+    estimated_completion_date DATETIME,
+    actual_completion_date DATETIME,
+    milestone_count INTEGER DEFAULT 0,
+    completed_milestones INTEGER DEFAULT 0,
+    resources TEXT,
+    notes TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
 );
 
 -- Learning Milestones Table
@@ -32,54 +40,101 @@ CREATE TABLE IF NOT EXISTS memory_learning_milestones (
     learning_id INTEGER NOT NULL,
     title TEXT NOT NULL,
     description TEXT,
-    achieved_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    status TEXT DEFAULT 'pending',
+    target_date DATETIME,
+    completed_at DATETIME,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
     FOREIGN KEY (learning_id) REFERENCES memory_learning(id) ON DELETE CASCADE
 );
 
 -- Decision Records Table
 CREATE TABLE IF NOT EXISTS memory_decisions (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
-    msg_id TEXT NOT NULL,
-    conv_id TEXT,
-    summary TEXT NOT NULL,
-    context TEXT,
+    message_id TEXT NOT NULL,
+    conversation_id INTEGER,
+    decision_type TEXT,
+    decision_question TEXT NOT NULL,
+    decision_context TEXT,
+    options_considered TEXT,
+    chosen_option TEXT,
+    rationale TEXT,
+    confidence_level INTEGER CHECK(confidence_level BETWEEN 1 AND 5),
     expected_outcome TEXT,
     actual_outcome TEXT,
-    status TEXT CHECK(status IN ('pending', 'implemented', 'validated', 'rejected')) DEFAULT 'pending',
-    review_scheduled_at DATETIME,
+    outcome_status TEXT CHECK(outcome_status IN ('pending', 'implemented', 'validated', 'rejected')),
+    review_date DATETIME,
     reviewed_at DATETIME,
-    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    review_notes TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
 );
 
 -- Skill Evolution Table
 CREATE TABLE IF NOT EXISTS memory_evolution (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     skill_name TEXT NOT NULL,
-    category TEXT,
+    skill_category TEXT,
+    proficiency_level INTEGER DEFAULT 1 CHECK(proficiency_level BETWEEN 1 AND 10),
+    experience_points INTEGER DEFAULT 0,
     usage_count INTEGER DEFAULT 0,
     success_count INTEGER DEFAULT 0,
+    failure_count INTEGER DEFAULT 0,
     last_used_at DATETIME,
-    first_used_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    first_used_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    performance_metrics TEXT,
+    improvement_areas TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
 );
 
--- Database Version Tracking
-CREATE TABLE IF NOT EXISTS memory_schema_version (
-    version TEXT PRIMARY KEY,
-    applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+-- Skill Evolution History Table
+CREATE TABLE IF NOT EXISTS memory_evolution_history (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    skill_id INTEGER NOT NULL,
+    event_type TEXT NOT NULL,
+    event_data TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (skill_id) REFERENCES memory_evolution(id) ON DELETE CASCADE
 );
 
--- Insert initial version
-INSERT OR IGNORE INTO memory_schema_version (version) VALUES ('2.0.0');
+-- Version Management Table
+CREATE TABLE IF NOT EXISTS memory_versions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    version_name TEXT NOT NULL,
+    version_type TEXT,
+    description TEXT,
+    backup_path TEXT,
+    backup_size INTEGER,
+    checksum TEXT,
+    is_active BOOLEAN DEFAULT 0,
+    migration_script TEXT,
+    rollback_script TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    activated_at DATETIME
+);
+
+-- Version Statistics Table
+CREATE TABLE IF NOT EXISTS memory_version_stats (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    version_id INTEGER,
+    stat_name TEXT,
+    stat_value INTEGER,
+    recorded_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
 
 -- Create indexes for performance
 CREATE INDEX IF NOT EXISTS idx_priorities_level ON memory_priorities(priority_level);
 CREATE INDEX IF NOT EXISTS idx_priorities_created ON memory_priorities(created_at);
-CREATE INDEX IF NOT EXISTS idx_learning_status ON memory_learning(status);
-CREATE INDEX IF NOT EXISTS idx_learning_topic ON memory_learning(topic);
-CREATE INDEX IF NOT EXISTS idx_decisions_status ON memory_decisions(status);
-CREATE INDEX IF NOT EXISTS idx_decisions_review ON memory_decisions(review_scheduled_at);
+CREATE INDEX IF NOT EXISTS idx_learning_status ON memory_learning(progress_status);
+CREATE INDEX IF NOT EXISTS idx_learning_topic ON memory_learning(learning_topic);
+CREATE INDEX IF NOT EXISTS idx_decisions_status ON memory_decisions(outcome_status);
+CREATE INDEX IF NOT EXISTS idx_decisions_review ON memory_decisions(review_date);
 CREATE INDEX IF NOT EXISTS idx_evolution_skill ON memory_evolution(skill_name);
-CREATE INDEX IF NOT EXISTS idx_evolution_category ON memory_evolution(category);
+CREATE INDEX IF NOT EXISTS idx_evolution_category ON memory_evolution(skill_category);
+
+-- Insert initial version
+INSERT OR IGNORE INTO memory_versions (version_name, version_type, description, is_active) 
+VALUES ('2.5.0', 'initial', 'Memory V2.5 Initial Version', 1);
 
 -- Views for common queries
 
@@ -88,65 +143,91 @@ CREATE VIEW IF NOT EXISTS v_pending_decisions AS
 SELECT 
     d.*,
     CASE 
-        WHEN review_scheduled_at < CURRENT_TIMESTAMP THEN 'overdue'
-        WHEN review_scheduled_at <= datetime('now', '+7 days') THEN 'due_soon'
+        WHEN review_date < datetime('now') THEN 'overdue'
+        WHEN review_date <= datetime('now', '+7 days') THEN 'due_soon'
         ELSE 'scheduled'
     END as review_status
 FROM memory_decisions d
-WHERE status IN ('pending', 'implemented')
-    AND (review_scheduled_at IS NULL OR review_scheduled_at <= datetime('now', '+7 days'))
-ORDER BY review_scheduled_at ASC;
+WHERE outcome_status IN ('pending', 'implemented')
+    AND (review_date IS NULL OR review_date <= datetime('now', '+7 days'))
+ORDER BY review_date ASC;
 
 -- View: Skill Summary
 CREATE VIEW IF NOT EXISTS v_skill_summary AS
 SELECT 
     skill_name,
-    category,
+    skill_category,
     usage_count,
     success_count,
     CASE 
         WHEN usage_count > 0 THEN ROUND(100.0 * success_count / usage_count, 2)
         ELSE 0
     END as success_rate,
+    proficiency_level,
+    experience_points,
     last_used_at,
     first_used_at
 FROM memory_evolution
 ORDER BY usage_count DESC;
 
+-- View: Active Learning
+CREATE VIEW IF NOT EXISTS v_active_learning AS
+SELECT 
+    l.*,
+    CASE 
+        WHEN progress_percentage = 0 THEN 'not_started'
+        WHEN progress_percentage < 50 THEN 'early_stage'
+        WHEN progress_percentage < 100 THEN 'in_progress'
+        ELSE 'completed'
+    END as stage
+FROM memory_learning l
+WHERE progress_status IN ('started', 'in_progress')
+ORDER BY updated_at DESC;
+
 -- View: Weekly Learning Report
 CREATE VIEW IF NOT EXISTS v_weekly_learning_report AS
 SELECT 
-    topic,
-    COUNT(*) as session_count,
-    AVG(progress) as avg_progress,
-    MAX(updated_at) as last_activity,
-    SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed_count
+    learning_topic,
+    topic_category,
+    progress_status,
+    progress_percentage,
+    milestone_count,
+    completed_milestones,
+    updated_at,
+    CASE 
+        WHEN progress_percentage = 100 THEN 'completed'
+        WHEN progress_percentage > 0 THEN 'in_progress'
+        ELSE 'not_started'
+    END as status_label
 FROM memory_learning
 WHERE updated_at >= datetime('now', '-7 days')
-GROUP BY topic
-ORDER BY last_activity DESC;
+ORDER BY updated_at DESC;
 
 -- View: High Priority Items
-CREATE VIEW IF NOT EXISTS v_high_priority AS
+CREATE VIEW IF NOT EXISTS v_high_priority_messages AS
 SELECT 
     'priority' as type,
     id,
-    msg_id,
+    message_id,
     priority_level as level,
-    category,
-    reasoning as details,
+    importance_score,
+    context_summary as details,
     created_at
 FROM memory_priorities
-WHERE priority_level IN ('critical', 'high')
+WHERE priority_level <= 2
 UNION ALL
 SELECT 
     'decision' as type,
     id,
-    msg_id,
-    status as level,
-    'decision' as category,
-    summary as details,
+    message_id,
+    CASE outcome_status 
+        WHEN 'pending' THEN 1
+        WHEN 'implemented' THEN 2
+        ELSE 3
+    END as level,
+    confidence_level as importance_score,
+    decision_question as details,
     created_at
 FROM memory_decisions
-WHERE status = 'pending' AND review_scheduled_at <= CURRENT_TIMESTAMP
+WHERE outcome_status = 'pending' AND review_date <= datetime('now', '+7 days')
 ORDER BY created_at DESC;

package/migrations/README.md

@@ -0,0 +1 @@
+V2.5 uses a new schema. No migration from V1/V2 is supported. Use init-demo.js for fresh setup.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memory-lucia",
-  "version": "2.5.1",
+  "version": "2.5.3",
   "description": "Advanced memory system for OpenClaw agents with priority analysis, learning tracking, decision recording, and skill evolution",
   "main": "api/index.js",
   "scripts": {

package/check-db.js

@@ -1,13 +0,0 @@
-const sqlite3 = require('sqlite3').verbose();
-const db = new sqlite3.Database('../memory-v2/memory-v2.5.db');
-
-// Check memory_decisions table structure
-db.all("PRAGMA table_info(memory_decisions)", (err, rows) => {
-  if (err) {
-    console.error('Error:', err);
-  } else {
-    console.log('memory_decisions columns:');
-    rows.forEach(r => console.log('- ' + r.name + ' (' + r.type + ')'));
-  }
-  db.close();
-});

package/migrations/v1-to-v2.js

@@ -1,213 +0,0 @@
-#!/usr/bin/env node
-/**
- * Memory V1 to V2 Migration Script
- * Migrates data from old memory format to V2 schema
- */
-
-const sqlite3 = require('sqlite3').verbose();
-const fs = require('fs');
-const path = require('path');
-
-class MemoryMigration {
-    constructor(sourceDbPath, targetDbPath = './memory-v2.db') {
-        this.sourceDbPath = sourceDbPath;
-        this.targetDbPath = targetDbPath;
-        this.sourceDb = null;
-        this.targetDb = null;
-    }
-
-    async init() {
-        // Check if source exists
-        if (!fs.existsSync(this.sourceDbPath)) {
-            throw new Error(`Source database not found: ${this.sourceDbPath}`);
-        }
-
-        // Open source database
-        this.sourceDb = new sqlite3.Database(this.sourceDbPath, sqlite3.OPEN_READONLY);
-        
-        // Open/create target database
-        this.targetDb = new sqlite3.Database(this.targetDbPath);
-        
-        console.log('✅ Connected to source and target databases');
-    }
-
-    async runSchema() {
-        const schemaPath = path.join(__dirname, '..', 'database', 'schema.sql');
-        
-        if (!fs.existsSync(schemaPath)) {
-            throw new Error(`Schema file not found: ${schemaPath}`);
-        }
-
-        const schema = fs.readFileSync(schemaPath, 'utf8');
-        const statements = schema
-            .split(';')
-            .map(s => s.trim())
-            .filter(s => s.length > 0);
-
-        for (const statement of statements) {
-            await this.runTarget(statement);
-        }
-        
-        console.log('✅ Target database schema initialized');
-    }
-
-    async migratePriorities() {
-        console.log('🔄 Migrating priorities...');
-        
-        try {
-            const rows = await this.allSource(
-                "SELECT * FROM memory_priorities WHERE created_at >= datetime('now', '-90 days')"
-            );
-
-            for (const row of rows) {
-                await this.runTarget(
-                    `INSERT INTO memory_priorities 
-                     (msg_id, conv_id, priority_level, reasoning, category, created_at)
-                     VALUES (?, ?, ?, ?, ?, ?)`,
-                    [row.msg_id, row.conv_id, row.priority_level, row.reasoning, row.category, row.created_at]
-                );
-            }
-
-            console.log(`✅ Migrated ${rows.length} priority records`);
-        } catch (err) {
-            console.log('ℹ️ No priorities to migrate or table does not exist');
-        }
-    }
-
-    async migrateLearning() {
-        console.log('🔄 Migrating learning records...');
-        
-        try {
-            const rows = await this.allSource(
-                "SELECT * FROM memory_learning WHERE status != 'abandoned'"
-            );
-
-            for (const row of rows) {
-                await this.runTarget(
-                    `INSERT INTO memory_learning 
-                     (msg_id, conv_id, topic, description, status, progress, started_at, updated_at, completed_at)
-                     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-                    [row.msg_id, row.conv_id, row.topic, row.description, row.status, 
-                     row.progress, row.started_at, row.updated_at, row.completed_at]
-                );
-            }
-
-            console.log(`✅ Migrated ${rows.length} learning records`);
-        } catch (err) {
-            console.log('ℹ️ No learning records to migrate or table does not exist');
-        }
-    }
-
-    async migrateDecisions() {
-        console.log('🔄 Migrating decisions...');
-        
-        try {
-            const rows = await this.allSource(
-                "SELECT * FROM memory_decisions WHERE status IN ('pending', 'implemented')"
-            );
-
-            for (const row of rows) {
-                await this.runTarget(
-                    `INSERT INTO memory_decisions 
-                     (msg_id, conv_id, summary, context, expected_outcome, actual_outcome, 
-                      status, review_scheduled_at, reviewed_at, created_at)
-                     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-                    [row.msg_id, row.conv_id, row.summary, row.context, row.expected_outcome,
-                     row.actual_outcome, row.status, row.review_scheduled_at, row.reviewed_at, row.created_at]
-                );
-            }
-
-            console.log(`✅ Migrated ${rows.length} decision records`);
-        } catch (err) {
-            console.log('ℹ️ No decisions to migrate or table does not exist');
-        }
-    }
-
-    async migrateEvolution() {
-        console.log('🔄 Migrating skill evolution...');
-        
-        try {
-            const rows = await this.allSource(
-                "SELECT * FROM memory_evolution WHERE usage_count > 0"
-            );
-
-            for (const row of rows) {
-                await this.runTarget(
-                    `INSERT INTO memory_evolution 
-                     (skill_name, category, usage_count, success_count, last_used_at, first_used_at)
-                     VALUES (?, ?, ?, ?, ?, ?)`,
-                    [row.skill_name, row.category, row.usage_count, row.success_count, 
-                     row.last_used_at, row.first_used_at]
-                );
-            }
-
-            console.log(`✅ Migrated ${rows.length} skill evolution records`);
-        } catch (err) {
-            console.log('ℹ️ No evolution records to migrate or table does not exist');
-        }
-    }
-
-    async runTarget(sql, params = []) {
-        return new Promise((resolve, reject) => {
-            this.targetDb.run(sql, params, function(err) {
-                if (err) reject(err);
-                else resolve({ id: this.lastID, changes: this.changes });
-            });
-        });
-    }
-
-    async allSource(sql, params = []) {
-        return new Promise((resolve, reject) => {
-            this.sourceDb.all(sql, params, (err, rows) => {
-                if (err) reject(err);
-                else resolve(rows);
-            });
-        });
-    }
-
-    async close() {
-        if (this.sourceDb) {
-            await new Promise((resolve) => this.sourceDb.close(resolve));
-        }
-        if (this.targetDb) {
-            await new Promise((resolve) => this.targetDb.close(resolve));
-        }
-        console.log('✅ Database connections closed');
-    }
-
-    async migrate() {
-        try {
-            await this.init();
-            await this.runSchema();
-            await this.migratePriorities();
-            await this.migrateLearning();
-            await this.migrateDecisions();
-            await this.migrateEvolution();
-            
-            console.log('\n🎉 Migration completed successfully!');
-            console.log(`📁 New database: ${path.resolve(this.targetDbPath)}`);
-        } catch (err) {
-            console.error('\n❌ Migration failed:', err.message);
-            process.exit(1);
-        } finally {
-            await this.close();
-        }
-    }
-}
-
-// CLI usage
-if (require.main === module) {
-    const sourceDb = process.argv[2];
-    const targetDb = process.argv[3] || './memory-v2.db';
-
-    if (!sourceDb) {
-        console.log('Usage: node migrations/v1-to-v2.js <source-v1.db> [target-v2.db]');
-        console.log('Example: node migrations/v1-to-v2.js ./memory-v1.db ./memory-v2.db');
-        process.exit(1);
-    }
-
-    const migration = new MemoryMigration(sourceDb, targetDb);
-    migration.migrate();
-}
-
-module.exports = MemoryMigration;