memory-lucia 2.0.0

package/api/index.js

@@ -0,0 +1,255 @@
+/**
+ * Memory V2.0 Unified API
+ * Single entry point for all memory operations
+ */
+
+const PriorityModule = require('../modules/priority');
+const LearningModule = require('../modules/learning');
+const DecisionModule = require('../modules/decision');
+const EvolutionModule = require('../modules/evolution');
+const VersionManager = require('../modules/version');
+const MemoryDatabase = require('../database/init');
+
+class MemoryAPI {
+    constructor(dbPath = './memory-v2.db') {
+        this.dbPath = dbPath;
+        this.db = new MemoryDatabase(dbPath);
+        this.modules = {};
+    }
+
+    /**
+     * Initialize API and all modules
+     */
+    async init() {
+        await this.db.init();
+        await this.db.runSchema();
+
+        // Initialize modules
+        this.modules = {
+            priority: new PriorityModule(this.db),
+            learning: new LearningModule(this.db),
+            decision: new DecisionModule(this.db),
+            evolution: new EvolutionModule(this.db),
+            version: new VersionManager(this.db)
+        };
+
+        console.log('✅ Memory V2.0 API initialized');
+        return this;
+    }
+
+    // =========================================
+    // PRIORITY API
+    // =========================================
+
+    async analyzePriority(message, context = {}) {
+        return await this.modules.priority.analyze(message, context);
+    }
+
+    async storePriority(messageId, conversationId, analysis) {
+        return await this.modules.priority.store(messageId, conversationId, analysis);
+    }
+
+    async getHighPriority(limit = 20) {
+        return await this.modules.priority.getHighPriority(limit);
+    }
+
+    // =========================================
+    // LEARNING API
+    // =========================================
+
+    async detectLearningIntent(message) {
+        return await this.modules.learning.detectIntent(message);
+    }
+
+    async startLearning(messageId, conversationId, message) {
+        const intent = await this.detectLearningIntent(message);
+        if (!intent.isLearning) {
+            return { success: false, error: 'No learning intent detected' };
+        }
+        return await this.modules.learning.createLearning(messageId, conversationId, intent, message);
+    }
+
+    async updateLearningProgress(learningId, progressData) {
+        return await this.modules.learning.updateProgress(learningId, progressData);
+    }
+
+    async addMilestone(learningId, milestone) {
+        return await this.modules.learning.addMilestone(learningId, milestone);
+    }
+
+    async getActiveLearning(limit = 20) {
+        return await this.modules.learning.getActiveLearning(limit);
+    }
+
+    async getWeeklyLearningReport() {
+        return await this.modules.learning.generateWeeklyReport();
+    }
+
+    // =========================================
+    // DECISION API
+    // =========================================
+
+    async recordDecision(messageId, conversationId, decisionData) {
+        return await this.modules.decision.createDecision(messageId, conversationId, decisionData);
+    }
+
+    async updateDecisionOutcome(decisionId, outcomeData) {
+        return await this.modules.decision.updateOutcome(decisionId, outcomeData);
+    }
+
+    async getPendingDecisions(limit = 20) {
+        return await this.modules.decision.getPendingDecisions(limit);
+    }
+
+    async getDueReviews(days = 7) {
+        return await this.modules.decision.getDueReviews(days);
+    }
+
+    async getDecisionStats() {
+        return await this.modules.decision.getStats();
+    }
+
+    async analyzeDecisionPatterns() {
+        return await this.modules.decision.analyzePatterns();
+    }
+
+    // =========================================
+    // EVOLUTION API
+    // =========================================
+
+    async recordSkillUsage(skillName, category, result = 'success', metrics = {}) {
+        return await this.modules.evolution.recordUsage(skillName, category, result, metrics);
+    }
+
+    async getSkill(skillName) {
+        return await this.modules.evolution.getSkill(skillName);
+    }
+
+    async getTopSkills(limit = 10) {
+        return await this.modules.evolution.getTopSkills(limit);
+    }
+
+    async getSkillGrowthReport(days = 30) {
+        return await this.modules.evolution.generateGrowthReport(days);
+    }
+
+    async suggestSkillsToPractice() {
+        return await this.modules.evolution.suggestPractice();
+    }
+
+    // =========================================
+    // VERSION API
+    // =========================================
+
+    async createBackup(description = '') {
+        return await this.modules.version.createBackup(description, 'full');
+    }
+
+    async listVersions() {
+        return await this.modules.version.listVersions();
+    }
+
+    async rollbackToVersion(versionId) {
+        return await this.modules.version.rollbackToVersion(versionId);
+    }
+
+    async getBackupStats() {
+        return await this.modules.version.getBackupStats();
+    }
+
+    // =========================================
+    // UNIFIED QUERY API
+    // =========================================
+
+    /**
+     * Search across all memory modules
+     */
+    async search(query, options = {}) {
+        const results = {
+            query,
+            timestamp: new Date().toISOString(),
+            modules: {}
+        };
+
+        // Search priorities
+        if (options.modules?.includes('priority') || !options.modules) {
+            results.modules.priority = await this.modules.priority.searchByPriorityRange();
+        }
+
+        // Search learning
+        if (options.modules?.includes('learning') || !options.modules) {
+            results.modules.learning = await this.modules.learning.getByTopic(query);
+        }
+
+        // Search decisions
+        if (options.modules?.includes('decision') || !options.modules) {
+            results.modules.decisions = await this.modules.decision.getSimilarDecisions(query);
+        }
+
+        return results;
+    }
+
+    /**
+     * Get comprehensive dashboard data
+     */
+    async getDashboard() {
+        return {
+            priority: {
+                high: await this.modules.priority.getHighPriority(5),
+                stats: await this.modules.priority.getStats()
+            },
+            learning: {
+                active: await this.modules.learning.getActiveLearning(5),
+                weekly: await this.modules.learning.generateWeeklyReport()
+            },
+            decisions: {
+                pending: await this.modules.decision.getPendingDecisions(5),
+                dueReviews: await this.modules.decision.getDueReviews(7)
+            },
+            evolution: {
+                top: await this.modules.evolution.getTopSkills(5),
+                needsPractice: await this.modules.evolution.suggestPractice()
+            },
+            version: {
+                stats: await this.modules.version.getBackupStats()
+            }
+        };
+    }
+
+    /**
+     * Health check
+     */
+    async health() {
+        return await this.db.healthCheck();
+    }
+
+    /**
+     * Close database connection
+     */
+    async close() {
+        await this.db.close();
+    }
+}
+
+// CLI usage
+if (require.main === module) {
+    const api = new MemoryAPI();
+    
+    (async () => {
+        try {
+            await api.init();
+            
+            // Example usage
+            console.log('\n📊 Dashboard:');
+            const dashboard = await api.getDashboard();
+            console.log(JSON.stringify(dashboard, null, 2));
+            
+            await api.close();
+        } catch (err) {
+            console.error('❌ Error:', err);
+            process.exit(1);
+        }
+    })();
+}
+
+module.exports = MemoryAPI;

package/database/init.js

@@ -0,0 +1,137 @@
+/**
+ * Memory V2.0 Database Initialization
+ * Extends Lossless Claw with personal modules
+ */
+
+const sqlite3 = require('sqlite3').verbose();
+const fs = require('fs');
+const path = require('path');
+
+class MemoryDatabase {
+    constructor(dbPath = './memory-v2.db') {
+        this.dbPath = dbPath;
+        this.db = null;
+    }
+
+    async init() {
+        return new Promise((resolve, reject) => {
+            this.db = new sqlite3.Database(this.dbPath, (err) => {
+                if (err) {
+                    console.error('Error opening database:', err);
+                    reject(err);
+                } else {
+                    console.log('✅ Connected to Memory V2.0 database');
+                    resolve();
+                }
+            });
+        });
+    }
+
+    async runSchema() {
+        const schemaPath = path.join(__dirname, 'schema.sql');
+        const schema = fs.readFileSync(schemaPath, 'utf8');
+        
+        // Split schema into individual statements
+        const statements = schema
+            .split(';')
+            .map(s => s.trim())
+            .filter(s => s.length > 0);
+
+        for (const statement of statements) {
+            await this.run(statement);
+        }
+        
+        console.log('✅ Database schema initialized');
+    }
+
+    async run(sql, params = []) {
+        return new Promise((resolve, reject) => {
+            this.db.run(sql, params, function(err) {
+                if (err) {
+                    console.error('SQL Error:', err);
+                    reject(err);
+                } else {
+                    resolve({ id: this.lastID, changes: this.changes });
+                }
+            });
+        });
+    }
+
+    async get(sql, params = []) {
+        return new Promise((resolve, reject) => {
+            this.db.get(sql, params, (err, row) => {
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve(row);
+                }
+            });
+        });
+    }
+
+    async all(sql, params = []) {
+        return new Promise((resolve, reject) => {
+            this.db.all(sql, params, (err, rows) => {
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve(rows);
+                }
+            });
+        });
+    }
+
+    async close() {
+        return new Promise((resolve, reject) => {
+            this.db.close((err) => {
+                if (err) {
+                    reject(err);
+                } else {
+                    console.log('✅ Database connection closed');
+                    resolve();
+                }
+            });
+        });
+    }
+
+    // Health check
+    async healthCheck() {
+        try {
+            const tables = await this.all(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'memory_%'"
+            );
+            return {
+                status: 'healthy',
+                tables: tables.map(t => t.name),
+                timestamp: new Date().toISOString()
+            };
+        } catch (err) {
+            return {
+                status: 'unhealthy',
+                error: err.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+}
+
+// CLI usage
+if (require.main === module) {
+    const db = new MemoryDatabase();
+    
+    (async () => {
+        try {
+            await db.init();
+            await db.runSchema();
+            const health = await db.healthCheck();
+            console.log('\n📊 Database Health:', health);
+            await db.close();
+            console.log('\n🎉 Memory V2.0 database initialized successfully!');
+        } catch (err) {
+            console.error('❌ Initialization failed:', err);
+            process.exit(1);
+        }
+    })();
+}
+
+module.exports = MemoryDatabase;

package/modules/decision.js

@@ -0,0 +1,267 @@
+/**
+ * Decision Module
+ * Track decisions, outcomes, and reviews
+ */
+
+class DecisionModule {
+    constructor(db) {
+        this.db = db;
+        this.decisionTypes = ['framework', 'vendor', 'migration', 'publish', 'spend', 'other'];
+        
+        // Keywords for automatic decision type detection
+        this.typeKeywords = {
+            framework: ['framework', 'library', 'architecture', 'stack', 'technology'],
+            vendor: ['vendor', 'provider', 'service', 'platform', 'tool'],
+            migration: ['migrate', 'upgrade', 'update', 'move', 'transfer', 'switch'],
+            publish: ['publish', 'release', 'deploy', 'launch', 'ship'],
+            spend: ['budget', 'cost', 'price', 'purchase', 'buy', 'invest', 'spend'],
+            other: ['decide', 'choice', 'option', 'select', 'pick']
+        };
+    }
+
+    /**
+     * Detect decision type from message
+     */
+    detectType(message) {
+        const content = message.toLowerCase();
+        const scores = {};
+
+        for (const [type, keywords] of Object.entries(this.typeKeywords)) {
+            scores[type] = 0;
+            for (const keyword of keywords) {
+                if (content.includes(keyword)) {
+                    scores[type] += 1;
+                }
+            }
+        }
+
+        // Find highest score
+        let detectedType = 'other';
+        let maxScore = 0;
+
+        for (const [type, score] of Object.entries(scores)) {
+            if (score > maxScore) {
+                maxScore = score;
+                detectedType = type;
+            }
+        }
+
+        return {
+            type: detectedType,
+            confidence: maxScore > 0 ? Math.min(maxScore / 3, 1) : 0,
+            scores
+        };
+    }
+
+    /**
+     * Extract decision question
+     */
+    extractQuestion(message) {
+        // Look for question patterns
+        const patterns = [
+            /(?:should|need to|want to|decide|choose)\s+(.+?)(?:\?|\.|$)/i,
+            /which\s+(.+?)(?:\?|\.|$)/i,
+            /what\s+(.+?)(?:\?|\.|$)/i,
+            /how\s+(.+?)(?:\?|\.|$)/i
+        ];
+
+        for (const pattern of patterns) {
+            const match = message.match(pattern);
+            if (match) {
+                return match[1].trim();
+            }
+        }
+
+        // Fallback: first sentence
+        const sentences = message.split(/[.!?]+/);
+        return sentences[0]?.trim() || message.substring(0, 100);
+    }
+
+    /**
+     * Create new decision record
+     */
+    async createDecision(messageId, conversationId, decisionData) {
+        const sql = `
+            INSERT INTO memory_decisions 
+            (message_id, conversation_id, decision_type, decision_question, 
+             decision_context, options_considered, chosen_option, rationale, 
+             confidence_level, expected_outcome, review_date)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `;
+
+        // Auto-detect type if not provided
+        const typeDetection = decisionData.type 
+            ? { type: decisionData.type, confidence: 1 } 
+            : this.detectType(decisionData.question || decisionData.context);
+
+        // Calculate review date (default: 30 days)
+        const reviewDate = new Date();
+        reviewDate.setDate(reviewDate.getDate() + (decisionData.reviewDays || 30));
+
+        const result = await this.db.run(sql, [
+            messageId,
+            conversationId,
+            typeDetection.type,
+            decisionData.question || this.extractQuestion(decisionData.context),
+            decisionData.context,
+            JSON.stringify(decisionData.options || []),
+            decisionData.chosenOption,
+            decisionData.rationale,
+            decisionData.confidence || 3,
+            decisionData.expectedOutcome,
+            reviewDate.toISOString()
+        ]);
+
+        return {
+            success: true,
+            decisionId: result.id,
+            type: typeDetection.type,
+            reviewDate: reviewDate.toISOString()
+        };
+    }
+
+    /**
+     * Update decision outcome
+     */
+    async updateOutcome(decisionId, outcomeData) {
+        const sql = `
+            UPDATE memory_decisions 
+            SET outcome_status = ?, actual_outcome = ?, updated_at = CURRENT_TIMESTAMP
+            WHERE id = ?
+        `;
+
+        await this.db.run(sql, [
+            outcomeData.status,
+            outcomeData.description,
+            decisionId
+        ]);
+
+        return { success: true, decisionId };
+    }
+
+    /**
+     * Schedule review
+     */
+    async scheduleReview(decisionId, reviewDate) {
+        const sql = `
+            UPDATE memory_decisions 
+            SET review_date = ?, updated_at = CURRENT_TIMESTAMP
+            WHERE id = ?
+        `;
+
+        await this.db.run(sql, [reviewDate, decisionId]);
+        return { success: true };
+    }
+
+    /**
+     * Complete review
+     */
+    async completeReview(decisionId, reviewData) {
+        const sql = `
+            UPDATE memory_decisions 
+            SET reviewed_at = CURRENT_TIMESTAMP, review_notes = ?, updated_at = CURRENT_TIMESTAMP
+            WHERE id = ?
+        `;
+
+        await this.db.run(sql, [reviewData.notes, decisionId]);
+        return { success: true };
+    }
+
+    /**
+     * Get pending decisions
+     */
+    async getPendingDecisions(limit = 20) {
+        const sql = `SELECT * FROM v_pending_decisions LIMIT ?`;
+        return await this.db.all(sql, [limit]);
+    }
+
+    /**
+     * Get decisions by type
+     */
+    async getByType(type, limit = 20) {
+        const sql = `
+            SELECT * FROM memory_decisions 
+            WHERE decision_type = ? 
+            ORDER BY created_at DESC 
+            LIMIT ?
+        `;
+        return await this.db.all(sql, [type, limit]);
+    }
+
+    /**
+     * Get decisions needing review
+     */
+    async getDueReviews(days = 7) {
+        const sql = `
+            SELECT * FROM memory_decisions 
+            WHERE outcome_status = 'pending'
+            AND review_date <= datetime('now', '+${days} days')
+            AND reviewed_at IS NULL
+            ORDER BY review_date ASC
+        `;
+        return await this.db.all(sql);
+    }
+
+    /**
+     * Get decision statistics
+     */
+    async getStats() {
+        const sql = `
+            SELECT 
+                decision_type,
+                outcome_status,
+                COUNT(*) as count
+            FROM memory_decisions 
+            GROUP BY decision_type, outcome_status
+        `;
+        return await this.db.all(sql);
+    }
+
+    /**
+     * Analyze decision patterns
+     */
+    async analyzePatterns() {
+        const sql = `
+            SELECT 
+                decision_type,
+                AVG(confidence_level) as avg_confidence,
+                COUNT(CASE WHEN outcome_status = 'successful' THEN 1 END) as success_count,
+                COUNT(CASE WHEN outcome_status = 'failed' THEN 1 END) as failure_count,
+                COUNT(*) as total
+            FROM memory_decisions 
+            WHERE outcome_status != 'pending'
+            GROUP BY decision_type
+        `;
+        
+        const patterns = await this.db.all(sql);
+        
+        return patterns.map(p => ({
+            ...p,
+            success_rate: p.total > 0 ? (p.success_count / p.total * 100).toFixed(2) : 0
+        }));
+    }
+
+    /**
+     * Get similar past decisions
+     */
+    async getSimilarDecisions(question, limit = 5) {
+        const keywords = question.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+        
+        if (keywords.length === 0) return [];
+
+        const conditions = keywords.map(() => 'decision_question LIKE ?').join(' OR ');
+        const sql = `
+            SELECT * FROM memory_decisions 
+            WHERE ${conditions}
+            ORDER BY created_at DESC 
+            LIMIT ?
+        `;
+
+        const params = keywords.map(k => `%${k}%`);
+        params.push(limit);
+
+        return await this.db.all(sql, params);
+    }
+}
+
+module.exports = DecisionModule;