@sowonai/crewx-cli 0.8.0-rc.1 → 0.8.0-rc.3

package/dist/services/memory.service.js

@@ -1,707 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var MemoryService_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryService = exports.MemoryType = void 0;
-const common_1 = require("@nestjs/common");
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs"));
-var MemoryType;
-(function (MemoryType) {
-    MemoryType["FACT"] = "fact";
-    MemoryType["PREFERENCE"] = "preference";
-    MemoryType["CONTEXT"] = "context";
-    MemoryType["SUMMARY"] = "summary";
-    MemoryType["TASK"] = "task";
-    MemoryType["CUSTOM"] = "custom";
-})(MemoryType || (exports.MemoryType = MemoryType = {}));
-let MemoryService = MemoryService_1 = class MemoryService {
-    constructor() {
-        this.logger = new common_1.Logger(MemoryService_1.name);
-        this.db = null;
-        this.initialized = false;
-        const homeDir = process.env.HOME || process.env.USERPROFILE || '.';
-        const crewxDir = path.join(homeDir, '.crewx');
-        this.dbPath = path.join(crewxDir, 'memory.db');
-    }
-    async ensureInitialized() {
-        if (this.initialized) {
-            return true;
-        }
-        try {
-            const Database = await this.loadBetterSqlite3();
-            if (!Database) {
-                this.logger.warn('better-sqlite3 not available, memory service disabled');
-                return false;
-            }
-            const dir = path.dirname(this.dbPath);
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
-            }
-            this.db = new Database(this.dbPath);
-            this.db.pragma('journal_mode = WAL');
-            this.db.pragma('synchronous = NORMAL');
-            this.db.pragma('cache_size = -64000');
-            this.db.pragma('temp_store = MEMORY');
-            this.createTables();
-            this.initialized = true;
-            this.logger.log(`Memory database initialized at ${this.dbPath}`);
-            return true;
-        }
-        catch (error) {
-            this.logger.warn(`Failed to initialize memory database: ${error instanceof Error ? error.message : String(error)}`);
-            return false;
-        }
-    }
-    async loadBetterSqlite3() {
-        try {
-            return require('better-sqlite3');
-        }
-        catch {
-            return null;
-        }
-    }
-    createTables() {
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS memories (
-        id TEXT PRIMARY KEY,
-        type TEXT NOT NULL,
-        agent_id TEXT,
-        session_id TEXT,
-        content TEXT NOT NULL,
-        embedding BLOB,
-        metadata TEXT,
-        tags TEXT,
-        importance REAL DEFAULT 0.5,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL,
-        expires_at INTEGER
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
-      CREATE INDEX IF NOT EXISTS idx_memories_agent_id ON memories(agent_id);
-      CREATE INDEX IF NOT EXISTS idx_memories_session_id ON memories(session_id);
-      CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance);
-      CREATE INDEX IF NOT EXISTS idx_memories_created_at ON memories(created_at);
-      CREATE INDEX IF NOT EXISTS idx_memories_expires_at ON memories(expires_at);
-    `);
-        this.db.exec(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-        id UNINDEXED,
-        content,
-        tags,
-        content='memories',
-        content_rowid='rowid',
-        tokenize='porter unicode61'
-      );
-    `);
-        this.db.exec(`
-      CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
-        INSERT INTO memories_fts(rowid, id, content, tags)
-        VALUES (new.rowid, new.id, new.content, new.tags);
-      END;
-
-      CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
-        INSERT INTO memories_fts(memories_fts, rowid, id, content, tags)
-        VALUES ('delete', old.rowid, old.id, old.content, old.tags);
-      END;
-
-      CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
-        INSERT INTO memories_fts(memories_fts, rowid, id, content, tags)
-        VALUES ('delete', old.rowid, old.id, old.content, old.tags);
-        INSERT INTO memories_fts(rowid, id, content, tags)
-        VALUES (new.rowid, new.id, new.content, new.tags);
-      END;
-    `);
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS memory_tags (
-        memory_id TEXT NOT NULL,
-        tag TEXT NOT NULL,
-        PRIMARY KEY (memory_id, tag),
-        FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_memory_tags_tag ON memory_tags(tag);
-    `);
-    }
-    generateId() {
-        const timestamp = Date.now().toString(36);
-        const randomPart = Math.random().toString(36).substring(2, 10);
-        return `mem_${timestamp}_${randomPart}`;
-    }
-    async create(input) {
-        if (!(await this.ensureInitialized())) {
-            return null;
-        }
-        const id = this.generateId();
-        const now = Date.now();
-        const tagsJson = input.tags ? JSON.stringify(input.tags) : null;
-        try {
-            const stmt = this.db.prepare(`
-        INSERT INTO memories (
-          id, type, agent_id, session_id, content, metadata, tags, importance, created_at, updated_at, expires_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `);
-            stmt.run(id, input.type, input.agentId || null, input.sessionId || null, input.content, input.metadata ? JSON.stringify(input.metadata) : null, tagsJson, input.importance ?? 0.5, now, now, input.expiresAt || null);
-            if (input.tags && input.tags.length > 0) {
-                const tagStmt = this.db.prepare('INSERT INTO memory_tags (memory_id, tag) VALUES (?, ?)');
-                for (const tag of input.tags) {
-                    tagStmt.run(id, tag);
-                }
-            }
-            this.logger.debug(`Created memory: ${id}`);
-            return {
-                id,
-                type: input.type,
-                agentId: input.agentId,
-                sessionId: input.sessionId,
-                content: input.content,
-                metadata: input.metadata,
-                tags: input.tags,
-                importance: input.importance ?? 0.5,
-                createdAt: now,
-                updatedAt: now,
-                expiresAt: input.expiresAt,
-            };
-        }
-        catch (error) {
-            this.logger.error(`Failed to create memory: ${error instanceof Error ? error.message : String(error)}`);
-            return null;
-        }
-    }
-    async get(id) {
-        if (!(await this.ensureInitialized())) {
-            return null;
-        }
-        try {
-            const stmt = this.db.prepare('SELECT * FROM memories WHERE id = ?');
-            const row = stmt.get(id);
-            if (!row) {
-                return null;
-            }
-            return this.rowToMemory(row);
-        }
-        catch (error) {
-            this.logger.error(`Failed to get memory: ${error instanceof Error ? error.message : String(error)}`);
-            return null;
-        }
-    }
-    async update(id, input) {
-        if (!(await this.ensureInitialized())) {
-            return null;
-        }
-        try {
-            const updates = [];
-            const params = [];
-            if (input.content !== undefined) {
-                updates.push('content = ?');
-                params.push(input.content);
-            }
-            if (input.metadata !== undefined) {
-                updates.push('metadata = ?');
-                params.push(JSON.stringify(input.metadata));
-            }
-            if (input.tags !== undefined) {
-                updates.push('tags = ?');
-                params.push(JSON.stringify(input.tags));
-            }
-            if (input.importance !== undefined) {
-                updates.push('importance = ?');
-                params.push(input.importance);
-            }
-            if (input.expiresAt !== undefined) {
-                updates.push('expires_at = ?');
-                params.push(input.expiresAt);
-            }
-            if (updates.length === 0) {
-                return this.get(id);
-            }
-            const now = Date.now();
-            updates.push('updated_at = ?');
-            params.push(now);
-            params.push(id);
-            const stmt = this.db.prepare(`
-        UPDATE memories SET ${updates.join(', ')} WHERE id = ?
-      `);
-            const result = stmt.run(...params);
-            if (result.changes === 0) {
-                return null;
-            }
-            if (input.tags !== undefined) {
-                this.db.prepare('DELETE FROM memory_tags WHERE memory_id = ?').run(id);
-                if (input.tags.length > 0) {
-                    const tagStmt = this.db.prepare('INSERT INTO memory_tags (memory_id, tag) VALUES (?, ?)');
-                    for (const tag of input.tags) {
-                        tagStmt.run(id, tag);
-                    }
-                }
-            }
-            this.logger.debug(`Updated memory: ${id}`);
-            return this.get(id);
-        }
-        catch (error) {
-            this.logger.error(`Failed to update memory: ${error instanceof Error ? error.message : String(error)}`);
-            return null;
-        }
-    }
-    async delete(id) {
-        if (!(await this.ensureInitialized())) {
-            return false;
-        }
-        try {
-            const stmt = this.db.prepare('DELETE FROM memories WHERE id = ?');
-            const result = stmt.run(id);
-            if (result.changes > 0) {
-                this.logger.debug(`Deleted memory: ${id}`);
-                return true;
-            }
-            return false;
-        }
-        catch (error) {
-            this.logger.error(`Failed to delete memory: ${error instanceof Error ? error.message : String(error)}`);
-            return false;
-        }
-    }
-    async query(options = {}) {
-        if (!(await this.ensureInitialized())) {
-            return [];
-        }
-        try {
-            const conditions = [];
-            const params = [];
-            if (options.type) {
-                conditions.push('type = ?');
-                params.push(options.type);
-            }
-            if (options.agentId) {
-                conditions.push('agent_id = ?');
-                params.push(options.agentId);
-            }
-            if (options.sessionId) {
-                conditions.push('session_id = ?');
-                params.push(options.sessionId);
-            }
-            if (options.createdAtFrom !== undefined) {
-                conditions.push('created_at >= ?');
-                params.push(options.createdAtFrom);
-            }
-            if (options.createdAtTo !== undefined) {
-                conditions.push('created_at <= ?');
-                params.push(options.createdAtTo);
-            }
-            if (options.minImportance !== undefined) {
-                conditions.push('importance >= ?');
-                params.push(options.minImportance);
-            }
-            conditions.push('(expires_at IS NULL OR expires_at > ?)');
-            params.push(Date.now());
-            if (options.tags && options.tags.length > 0) {
-                conditions.push(`
-          id IN (
-            SELECT memory_id FROM memory_tags
-            WHERE tag IN (${options.tags.map(() => '?').join(', ')})
-            GROUP BY memory_id
-            HAVING COUNT(DISTINCT tag) = ?
-          )
-        `);
-                params.push(...options.tags, options.tags.length);
-            }
-            const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-            const orderBy = options.orderBy || 'createdAt';
-            const orderDir = options.orderDir || 'desc';
-            const orderColumn = orderBy === 'createdAt' ? 'created_at'
-                : orderBy === 'updatedAt' ? 'updated_at'
-                    : 'importance';
-            const limit = options.limit || 100;
-            const offset = options.offset || 0;
-            const stmt = this.db.prepare(`
-        SELECT * FROM memories
-        ${whereClause}
-        ORDER BY ${orderColumn} ${orderDir.toUpperCase()}
-        LIMIT ? OFFSET ?
-      `);
-            params.push(limit, offset);
-            const rows = stmt.all(...params);
-            return rows.map((row) => this.rowToMemory(row));
-        }
-        catch (error) {
-            this.logger.error(`Failed to query memories: ${error instanceof Error ? error.message : String(error)}`);
-            return [];
-        }
-    }
-    async search(query, options = {}) {
-        if (!(await this.ensureInitialized())) {
-            return [];
-        }
-        if (!query.trim()) {
-            return [];
-        }
-        try {
-            const conditions = [];
-            const params = [];
-            if (options.type) {
-                conditions.push('m.type = ?');
-                params.push(options.type);
-            }
-            if (options.agentId) {
-                conditions.push('m.agent_id = ?');
-                params.push(options.agentId);
-            }
-            if (options.sessionId) {
-                conditions.push('m.session_id = ?');
-                params.push(options.sessionId);
-            }
-            if (options.createdAtFrom !== undefined) {
-                conditions.push('m.created_at >= ?');
-                params.push(options.createdAtFrom);
-            }
-            if (options.createdAtTo !== undefined) {
-                conditions.push('m.created_at <= ?');
-                params.push(options.createdAtTo);
-            }
-            if (options.minImportance !== undefined) {
-                conditions.push('m.importance >= ?');
-                params.push(options.minImportance);
-            }
-            conditions.push('(m.expires_at IS NULL OR m.expires_at > ?)');
-            params.push(Date.now());
-            const additionalWhere = conditions.length > 0 ? `AND ${conditions.join(' AND ')}` : '';
-            const limit = options.limit || 50;
-            const offset = options.offset || 0;
-            const stmt = this.db.prepare(`
-        SELECT m.*, fts.rank as score,
-               snippet(memories_fts, 1, '<mark>', '</mark>', '...', 32) as highlight
-        FROM memories_fts fts
-        JOIN memories m ON fts.id = m.id
-        WHERE memories_fts MATCH ?
-        ${additionalWhere}
-        ORDER BY fts.rank
-        LIMIT ? OFFSET ?
-      `);
-            const searchParams = [query, ...params, limit, offset];
-            const rows = stmt.all(...searchParams);
-            return rows.map((row) => ({
-                ...this.rowToMemory(row),
-                score: Math.abs(row.score),
-                highlights: row.highlight ? [row.highlight] : undefined,
-            }));
-        }
-        catch (error) {
-            this.logger.error(`Failed to search memories: ${error instanceof Error ? error.message : String(error)}`);
-            return [];
-        }
-    }
-    async getByTags(tags, options = {}) {
-        if (!(await this.ensureInitialized())) {
-            return [];
-        }
-        if (!tags || tags.length === 0) {
-            return [];
-        }
-        try {
-            const placeholders = tags.map(() => '?').join(', ');
-            const matchAll = options.matchAll ?? true;
-            let sql;
-            if (matchAll) {
-                sql = `
-          SELECT m.* FROM memories m
-          JOIN memory_tags mt ON m.id = mt.memory_id
-          WHERE mt.tag IN (${placeholders})
-          AND (m.expires_at IS NULL OR m.expires_at > ?)
-          GROUP BY m.id
-          HAVING COUNT(DISTINCT mt.tag) = ?
-          ORDER BY m.importance DESC, m.created_at DESC
-        `;
-            }
-            else {
-                sql = `
-          SELECT DISTINCT m.* FROM memories m
-          JOIN memory_tags mt ON m.id = mt.memory_id
-          WHERE mt.tag IN (${placeholders})
-          AND (m.expires_at IS NULL OR m.expires_at > ?)
-          ORDER BY m.importance DESC, m.created_at DESC
-        `;
-            }
-            const stmt = this.db.prepare(sql);
-            const params = matchAll
-                ? [...tags, Date.now(), tags.length]
-                : [...tags, Date.now()];
-            const rows = stmt.all(...params);
-            return rows.map((row) => this.rowToMemory(row));
-        }
-        catch (error) {
-            this.logger.error(`Failed to get memories by tags: ${error instanceof Error ? error.message : String(error)}`);
-            return [];
-        }
-    }
-    async getAllTags() {
-        if (!(await this.ensureInitialized())) {
-            return [];
-        }
-        try {
-            const stmt = this.db.prepare('SELECT DISTINCT tag FROM memory_tags ORDER BY tag');
-            const rows = stmt.all();
-            return rows.map((row) => row.tag);
-        }
-        catch (error) {
-            this.logger.error(`Failed to get all tags: ${error instanceof Error ? error.message : String(error)}`);
-            return [];
-        }
-    }
-    async deleteExpired() {
-        if (!(await this.ensureInitialized())) {
-            return 0;
-        }
-        try {
-            const now = Date.now();
-            const stmt = this.db.prepare('DELETE FROM memories WHERE expires_at IS NOT NULL AND expires_at <= ?');
-            const result = stmt.run(now);
-            if (result.changes > 0) {
-                this.logger.log(`Deleted ${result.changes} expired memories`);
-            }
-            return result.changes;
-        }
-        catch (error) {
-            this.logger.error(`Failed to delete expired memories: ${error instanceof Error ? error.message : String(error)}`);
-            return 0;
-        }
-    }
-    async getStats(options = {}) {
-        if (!(await this.ensureInitialized())) {
-            return { total: 0, byType: {}, tagCount: 0, avgImportance: 0 };
-        }
-        try {
-            const agentCondition = options.agentId ? 'WHERE agent_id = ?' : '';
-            const params = options.agentId ? [options.agentId] : [];
-            const totalStmt = this.db.prepare(`SELECT COUNT(*) as count FROM memories ${agentCondition}`);
-            const total = totalStmt.get(...params).count;
-            const typeStmt = this.db.prepare(`
-        SELECT type, COUNT(*) as count
-        FROM memories ${agentCondition}
-        GROUP BY type
-      `);
-            const typeRows = typeStmt.all(...params);
-            const byType = typeRows.reduce((acc, row) => {
-                acc[row.type] = row.count;
-                return acc;
-            }, {});
-            const tagStmt = this.db.prepare('SELECT COUNT(DISTINCT tag) as count FROM memory_tags');
-            const tagCount = tagStmt.get().count;
-            const avgStmt = this.db.prepare(`SELECT AVG(importance) as avg FROM memories ${agentCondition}`);
-            const avgImportance = avgStmt.get(...params)?.avg || 0;
-            return { total, byType, tagCount, avgImportance };
-        }
-        catch (error) {
-            this.logger.error(`Failed to get stats: ${error instanceof Error ? error.message : String(error)}`);
-            return { total: 0, byType: {}, tagCount: 0, avgImportance: 0 };
-        }
-    }
-    async consolidate(options) {
-        if (!(await this.ensureInitialized())) {
-            return { months: 0, summarized: 0, deleted: 0, summaryIds: [] };
-        }
-        const windowDays = options.windowDays ?? 180;
-        const maxEntriesPerMonth = options.maxEntriesPerMonth ?? 20;
-        const cutoff = Date.now() - windowDays * 24 * 60 * 60 * 1000;
-        const rows = this.db.prepare(`
-      SELECT * FROM memories
-      WHERE agent_id = ?
-        AND type != ?
-        AND created_at < ?
-        AND (expires_at IS NULL OR expires_at > ?)
-      ORDER BY created_at ASC
-    `).all(options.agentId, MemoryType.SUMMARY, cutoff, Date.now());
-        if (!rows || rows.length === 0) {
-            return { months: 0, summarized: 0, deleted: 0, summaryIds: [] };
-        }
-        const byMonth = new Map();
-        for (const row of rows) {
-            const monthKey = new Date(row.created_at).toISOString().slice(0, 7);
-            const bucket = byMonth.get(monthKey) ?? [];
-            bucket.push(row);
-            byMonth.set(monthKey, bucket);
-        }
-        const insertStmt = this.db.prepare(`
-      INSERT INTO memories (
-        id, type, agent_id, session_id, content, metadata, tags, importance, created_at, updated_at, expires_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-        const insertTagStmt = this.db.prepare('INSERT INTO memory_tags (memory_id, tag) VALUES (?, ?)');
-        const deleteStmt = this.db.prepare('DELETE FROM memories WHERE id = ?');
-        const summaryIds = [];
-        let deleted = 0;
-        const now = Date.now();
-        const consolidateTransaction = this.db.transaction(() => {
-            for (const [month, monthRows] of byMonth.entries()) {
-                const total = monthRows.length;
-                const samples = monthRows.slice(0, maxEntriesPerMonth).map((r) => {
-                    const content = String(r.content ?? '').replace(/\s+/g, ' ').trim();
-                    const preview = content.length > 160 ? `${content.slice(0, 157)}...` : content;
-                    return `- [${r.type}] ${preview}`;
-                });
-                const content = [
-                    `Monthly memory summary for ${month}`,
-                    `Entries: ${total}`,
-                    '',
-                    ...samples,
-                ].join('\n');
-                const id = this.generateId();
-                const tags = ['consolidated', `month:${month}`];
-                const metadata = {
-                    consolidated: {
-                        month,
-                        windowDays,
-                        sourceCount: total,
-                        sourceIds: monthRows.map((r) => r.id),
-                    },
-                };
-                insertStmt.run(id, MemoryType.SUMMARY, options.agentId, null, content, JSON.stringify(metadata), JSON.stringify(tags), 0.5, now, now, null);
-                for (const tag of tags) {
-                    insertTagStmt.run(id, tag);
-                }
-                summaryIds.push(id);
-                for (const row of monthRows) {
-                    const result = deleteStmt.run(row.id);
-                    deleted += result.changes ?? 0;
-                }
-            }
-        });
-        try {
-            consolidateTransaction();
-            return {
-                months: byMonth.size,
-                summarized: rows.length,
-                deleted,
-                summaryIds,
-            };
-        }
-        catch (error) {
-            this.logger.error(`Failed to consolidate memories: ${error instanceof Error ? error.message : String(error)}`);
-            return { months: 0, summarized: 0, deleted: 0, summaryIds: [] };
-        }
-    }
-    async bulkCreate(inputs) {
-        if (!(await this.ensureInitialized())) {
-            return [];
-        }
-        const results = [];
-        try {
-            const transaction = this.db.transaction(() => {
-                for (const input of inputs) {
-                    const id = this.generateId();
-                    const now = Date.now();
-                    const tagsJson = input.tags ? JSON.stringify(input.tags) : null;
-                    const stmt = this.db.prepare(`
-            INSERT INTO memories (
-              id, type, agent_id, session_id, content, metadata, tags, importance, created_at, updated_at, expires_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-          `);
-                    stmt.run(id, input.type, input.agentId || null, input.sessionId || null, input.content, input.metadata ? JSON.stringify(input.metadata) : null, tagsJson, input.importance ?? 0.5, now, now, input.expiresAt || null);
-                    if (input.tags && input.tags.length > 0) {
-                        const tagStmt = this.db.prepare('INSERT INTO memory_tags (memory_id, tag) VALUES (?, ?)');
-                        for (const tag of input.tags) {
-                            tagStmt.run(id, tag);
-                        }
-                    }
-                    results.push({
-                        id,
-                        type: input.type,
-                        agentId: input.agentId,
-                        sessionId: input.sessionId,
-                        content: input.content,
-                        metadata: input.metadata,
-                        tags: input.tags,
-                        importance: input.importance ?? 0.5,
-                        createdAt: now,
-                        updatedAt: now,
-                        expiresAt: input.expiresAt,
-                    });
-                }
-            });
-            transaction();
-            this.logger.debug(`Bulk created ${results.length} memories`);
-            return results;
-        }
-        catch (error) {
-            this.logger.error(`Failed to bulk create memories: ${error instanceof Error ? error.message : String(error)}`);
-            return [];
-        }
-    }
-    rowToMemory(row) {
-        return {
-            id: row.id,
-            type: row.type,
-            agentId: row.agent_id || undefined,
-            sessionId: row.session_id || undefined,
-            content: row.content,
-            embedding: row.embedding ? Array.from(row.embedding) : undefined,
-            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
-            tags: row.tags ? JSON.parse(row.tags) : undefined,
-            importance: row.importance,
-            createdAt: row.created_at,
-            updatedAt: row.updated_at,
-            expiresAt: row.expires_at || undefined,
-        };
-    }
-    async isAvailable() {
-        return this.ensureInitialized();
-    }
-    onModuleDestroy() {
-        if (this.db) {
-            try {
-                this.db.close();
-                this.logger.log('Memory database connection closed');
-            }
-            catch (error) {
-                this.logger.warn(`Error closing database: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-    }
-};
-exports.MemoryService = MemoryService;
-exports.MemoryService = MemoryService = MemoryService_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [])
-], MemoryService);
-//# sourceMappingURL=memory.service.js.map