memory-lucia 2.5.2 → 2.5.4

package/README.md

@@ -4,7 +4,7 @@
 [![GitHub](https://img.shields.io/badge/github-memory--lucia-blue.svg)](https://github.com/wen521/memory-lucia-)
 [![License](https://img.shields.io/npm/l/memory-lucia.svg)](LICENSE)
 
-Advanced memory system for OpenClaw agents with priority analysis, learning tracking, decision recording, and skill evolution.
+Local SQLite-based memory system for OpenClaw agents. All data stored locally with no external dependencies.
 
 ## 📦 Installation
 
@@ -104,7 +104,7 @@ SQLite backend with tables:
 
 ## 📋 Version
 
-Current: 2.5.2
+Current: 2.5.4
 
 ## 📄 License
 

package/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: memory-lucia
-version: 2.5.2
+version: 2.5.4
 description: |
-  Memory Lucia V2.5 - Advanced memory system with hybrid query, enhanced learning tracking,
-  autonomous decision recording, and skill evolution monitoring.
-  Use when: (1) Tracking learning progress with milestones, (2) Recording decisions with review scheduling,
-  (3) Analyzing message priorities, (4) Monitoring skill evolution with proficiency levels,
-  (5) Hybrid query with local-first + API fallback.
+  Memory Lucia - Local SQLite-based memory system for OpenClaw agents.
+  Features: (1) Priority analysis and tracking, (2) Learning progress with milestones,
+  (3) Decision recording with review scheduling, (4) Skill evolution monitoring,
+  (5) Local text search across all memory tables, (6) Automatic database backups.
+  All data stored locally in SQLite database. No external API calls.
 ---
 
 # Memory V2 Skill

package/database/schema.sql

@@ -184,8 +184,27 @@ 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 
+    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')
+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,

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/modules/query.js

@@ -1,15 +1,13 @@
 /**
- * Memory V2.5 - Hybrid Query Module
+ * Memory Query Module
  * 
  * Features:
- * - Local-first query (SQLite)
- * - Semantic search (Qdrant)
- * - API fallback (LLM)
- * - Smart caching
- * - Cost tracking
+ * - Local SQLite query with text search
+ * - Multi-table search
+ * - Result ranking
  * 
  * @module QueryModule
- * @version 2.5.0
+ * @version 2.5.3
  */
 
 const sqlite3 = require('sqlite3').verbose();
@@ -18,123 +16,166 @@ class QueryModule {
   constructor(options = {}) {
     this.dbPath = options.dbPath || './memory-v2.5.db';
     this.db = null;
-    this.cache = new Map();
-    this.cacheEnabled = options.cacheEnabled !== false;
-    this.useAPIFallback = options.useAPIFallback !== false;
-    
-    this.costStats = {
-      localQueries: 0,
-      apiFallbacks: 0,
-      totalTokens: 0
+    this.stats = {
+      totalQueries: 0,
+      resultsFound: 0
     };
   }
 
   async init() {
     this.db = new sqlite3.Database(this.dbPath);
-    console.log('✅ Query Module V2.5 initialized');
+    console.log('✅ Query Module initialized');
     return this;
   }
 
-  async query(queryText, options = {}) {
+  /**
+   * Search across all memory tables
+   * @param {string} queryText - Search text
+   * @param {Object} options - Search options
+   * @returns {Object} Search results
+   */
+  async search(queryText, options = {}) {
     const startTime = Date.now();
     
-    console.log(`\n🔍 Query: "${queryText}"`);
-    
-    // Try local first
-    const localResults = await this.localQuery(queryText, options);
-    if (localResults.length > 0) {
-      this.costStats.localQueries++;
-      return {
-        source: 'local',
-        results: localResults,
-        time: Date.now() - startTime,
-        cost: 0
-      };
-    }
-    
-    // Fallback to API if enabled
-    if (this.useAPIFallback) {
-      this.costStats.apiFallbacks++;
-      // API call placeholder
-      return {
-        source: 'api',
-        results: [],
-        time: Date.now() - startTime,
-        cost: 'tokens'
-      };
-    }
+    console.log(`\n🔍 Search: "${queryText}"`);
     
-    return {
-      source: 'none',
-      results: [],
-      time: Date.now() - startTime,
-      cost: 0
-    };
-  }
-
-  async localQuery(queryText, options) {
-    const pattern = `%${queryText}%`;
     const results = [];
     
-    // Query learning table (handle missing table gracefully)
+    // Search learning table
     try {
-      const learning = await this.queryTable('memory_learning', ['learning_topic', 'notes'], pattern);
-      results.push(...learning.map(r => ({ ...r, _source: 'learning' })));
+      const learning = await this.searchLearning(queryText);
+      results.push(...learning.map(r => ({ ...r, _source: 'learning', _score: this.calculateScore(r, queryText) })));
     } catch (err) {
-      // Table might not exist yet, skip
+      // Table might not exist
     }
     
-    // Query priorities table
+    // Search priorities table
     try {
-      const priorities = await this.queryTable('memory_priorities', ['message_text', 'reasoning'], pattern);
-      results.push(...priorities.map(r => ({ ...r, _source: 'priority' })));
+      const priorities = await this.searchPriorities(queryText);
+      results.push(...priorities.map(r => ({ ...r, _source: 'priority', _score: this.calculateScore(r, queryText) })));
     } catch (err) {
-      // Table might not exist yet, skip
+      // Table might not exist
     }
     
-    // Query decisions table
+    // Search decisions table
     try {
-      const decisions = await this.queryTable('memory_decisions', ['decision_summary', 'context'], pattern);
-      results.push(...decisions.map(r => ({ ...r, _source: 'decision' })));
+      const decisions = await this.searchDecisions(queryText);
+      results.push(...decisions.map(r => ({ ...r, _source: 'decision', _score: this.calculateScore(r, queryText) })));
     } catch (err) {
-      // Table might not exist yet, skip
+      // Table might not exist
     }
     
-    // Query evolution table
+    // Search evolution table
     try {
-      const evolution = await this.queryTable('memory_evolution', ['skill_name'], pattern);
-      results.push(...evolution.map(r => ({ ...r, _source: 'evolution' })));
+      const evolution = await this.searchEvolution(queryText);
+      results.push(...evolution.map(r => ({ ...r, _source: 'evolution', _score: this.calculateScore(r, queryText) })));
     } catch (err) {
-      // Table might not exist yet, skip
+      // Table might not exist
     }
     
-    return results.slice(0, options.limit || 10);
+    // Sort by score and limit
+    results.sort((a, b) => b._score - a._score);
+    const limited = results.slice(0, options.limit || 10);
+    
+    this.stats.totalQueries++;
+    this.stats.resultsFound += limited.length;
+    
+    return {
+      query: queryText,
+      results: limited,
+      total: results.length,
+      time: Date.now() - startTime
+    };
   }
 
-  async queryTable(table, fields, pattern) {
+  /**
+   * Search learning table
+   */
+  async searchLearning(queryText) {
+    const pattern = `%${queryText}%`;
     return new Promise((resolve, reject) => {
-      // Build OR query for multiple fields
-      const whereClause = fields.map(f => `${f} LIKE ?`).join(' OR ');
-      const params = fields.map(() => pattern);
-      const sql = `SELECT * FROM ${table} WHERE ${whereClause} LIMIT 10`;
-      
-      this.db.all(sql, params, (err, rows) => {
-        if (err) {
-          // Return empty array for missing tables
-          if (err.message.includes('no such table')) {
-            resolve([]);
-          } else {
-            reject(err);
-          }
-        } else {
-          resolve(rows || []);
-        }
+      const sql = `SELECT * FROM memory_learning 
+                   WHERE learning_topic LIKE ? OR notes LIKE ? 
+                   LIMIT 10`;
+      this.db.all(sql, [pattern, pattern], (err, rows) => {
+        if (err) reject(err);
+        else resolve(rows || []);
+      });
+    });
+  }
+
+  /**
+   * Search priorities table
+   */
+  async searchPriorities(queryText) {
+    const pattern = `%${queryText}%`;
+    return new Promise((resolve, reject) => {
+      const sql = `SELECT * FROM memory_priorities 
+                   WHERE context_summary LIKE ? OR keywords LIKE ? 
+                   LIMIT 10`;
+      this.db.all(sql, [pattern, pattern], (err, rows) => {
+        if (err) reject(err);
+        else resolve(rows || []);
+      });
+    });
+  }
+
+  /**
+   * Search decisions table
+   */
+  async searchDecisions(queryText) {
+    const pattern = `%${queryText}%`;
+    return new Promise((resolve, reject) => {
+      const sql = `SELECT * FROM memory_decisions 
+                   WHERE decision_question LIKE ? OR decision_context LIKE ? OR rationale LIKE ? 
+                   LIMIT 10`;
+      this.db.all(sql, [pattern, pattern, pattern], (err, rows) => {
+        if (err) reject(err);
+        else resolve(rows || []);
+      });
+    });
+  }
+
+  /**
+   * Search evolution table
+   */
+  async searchEvolution(queryText) {
+    const pattern = `%${queryText}%`;
+    return new Promise((resolve, reject) => {
+      const sql = `SELECT * FROM memory_evolution 
+                   WHERE skill_name LIKE ? OR skill_category LIKE ? 
+                   LIMIT 10`;
+      this.db.all(sql, [pattern, pattern], (err, rows) => {
+        if (err) reject(err);
+        else resolve(rows || []);
       });
     });
   }
 
+  /**
+   * Calculate relevance score
+   */
+  calculateScore(row, queryText) {
+    const query = queryText.toLowerCase();
+    let score = 0;
+    
+    // Check all text fields
+    for (const key of Object.keys(row)) {
+      if (typeof row[key] === 'string') {
+        const value = row[key].toLowerCase();
+        if (value.includes(query)) {
+          score += 1;
+          // Bonus for exact match
+          if (value === query) score += 2;
+        }
+      }
+    }
+    
+    return score;
+  }
+
   getStats() {
-    return this.costStats;
+    return this.stats;
   }
 
   close() {
@@ -142,4 +183,4 @@ class QueryModule {
   }
 }
 
-module.exports = QueryModule;
+module.exports = QueryModule;

package/package.json

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

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;