@crewx/memory 0.1.0

package/dist/src/engine.js

@@ -0,0 +1,942 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CATEGORIES = exports.MemoryEngine = void 0;
+exports.createMemoryEngine = createMemoryEngine;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+const nanoid_1 = require("nanoid");
+const parser_1 = require("./parser");
+const knowledge_core_1 = require("@crewx/knowledge-core");
+function parseCrewxResponse(raw) {
+    const responseMatch = raw.match(/📄 Response:\s*─+\s*([\s\S]*?)(?=📁 Working Directory|$)/);
+    if (responseMatch?.[1]) {
+        const captured = responseMatch[1].trim();
+        const capturedFirstLine = captured.split('\n')[0]?.trim() ?? '';
+        if (!capturedFirstLine.startsWith('{')) {
+            return captured;
+        }
+        return parseJsonlContent(captured);
+    }
+    return parseJsonlContent(raw);
+}
+function parseJsonlContent(raw) {
+    const lines = raw.split('\n').filter((l) => l.trim().startsWith('{'));
+    let assistantText = '';
+    let hasAssistantMessage = false;
+    for (const line of lines) {
+        try {
+            const obj = JSON.parse(line);
+            if (obj.type === 'message' && obj.role === 'assistant') {
+                hasAssistantMessage = true;
+                if (obj.content)
+                    assistantText += obj.content;
+            }
+        }
+        catch (_e) {
+        }
+    }
+    if (hasAssistantMessage)
+        return assistantText.trim() || null;
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        return null;
+    const firstLine = trimmed.split('\n')[0]?.trim() ?? '';
+    if (firstLine.startsWith('{'))
+        return null;
+    return trimmed;
+}
+class MemoryEngine {
+    constructor(config = {}) {
+        this.dataDir =
+            config.dataDir ??
+                process.env['MEMORY_DATA_DIR'] ??
+                path_1.default.resolve(process.cwd(), 'memory');
+        this.summaryDays =
+            config.summaryDays ??
+                (parseInt(process.env['MEMORY_SUMMARY_DAYS'] ?? '', 10) || 7);
+        this.recentDays =
+            config.recentDays ??
+                (parseInt(process.env['MEMORY_RECENT_DAYS'] ?? '', 10) || 30);
+        this.shortTermHours = config.shortTermHours ?? 24;
+    }
+    getAgentDir(agentId) {
+        return path_1.default.join(this.dataDir, agentId);
+    }
+    getEntriesDir(agentId) {
+        return path_1.default.join(this.getAgentDir(agentId), 'entries');
+    }
+    getSummaryPath(agentId) {
+        return path_1.default.join(this.getAgentDir(agentId), 'summary.md');
+    }
+    getDirtySummaryPath(agentId) {
+        return path_1.default.join(this.getAgentDir(agentId), '.dirty-summary');
+    }
+    ensureDir(dir) {
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+    }
+    generateId() {
+        return (0, nanoid_1.nanoid)(6);
+    }
+    getToday() {
+        return new Date().toISOString().slice(0, 10);
+    }
+    getLocalISO8601() {
+        const now = new Date();
+        const offset = -now.getTimezoneOffset();
+        const sign = offset >= 0 ? '+' : '-';
+        const offsetHours = String(Math.floor(Math.abs(offset) / 60)).padStart(2, '0');
+        const offsetMins = String(Math.abs(offset) % 60).padStart(2, '0');
+        const y = now.getFullYear();
+        const m = String(now.getMonth() + 1).padStart(2, '0');
+        const d = String(now.getDate()).padStart(2, '0');
+        const h = String(now.getHours()).padStart(2, '0');
+        const min = String(now.getMinutes()).padStart(2, '0');
+        const s = String(now.getSeconds()).padStart(2, '0');
+        return `${y}-${m}-${d}T${h}:${min}:${s}${sign}${offsetHours}:${offsetMins}`;
+    }
+    getPrimaryTag(entry) {
+        return (entry.tags?.[0]) ?? 'general';
+    }
+    toEntryTimestamp(entry) {
+        if (entry['created_at'])
+            return String(entry['created_at']);
+        const d = entry['date'];
+        const dateStr = d && typeof d === 'object' && typeof d.toISOString === 'function' ? d.toISOString().slice(0, 10) : String(d ?? '');
+        if (dateStr.includes('T'))
+            return dateStr;
+        return dateStr + 'T09:00:00+09:00';
+    }
+    markSummaryDirty(agentId) {
+        this.ensureDir(this.getAgentDir(agentId));
+        fs_1.default.writeFileSync(this.getDirtySummaryPath(agentId), String(Date.now()), 'utf-8');
+    }
+    loadAllEntries(agentId) {
+        const entriesDir = this.getEntriesDir(agentId);
+        if (!fs_1.default.existsSync(entriesDir))
+            return [];
+        const files = fs_1.default.readdirSync(entriesDir).filter((f) => f.endsWith('.md'));
+        const entries = [];
+        for (const file of files) {
+            const raw = fs_1.default.readFileSync(path_1.default.join(entriesDir, file), 'utf-8');
+            const { data, content } = (0, parser_1.parseFrontmatter)(raw);
+            const bodyText = content.replace(/^#[^\n]*\n*/m, '').trim();
+            const hasBody = Boolean(bodyText) && bodyText !== '(상세 내용을 여기에 추가)';
+            const entry = data;
+            entries.push({ ...entry, file, hasBody });
+        }
+        entries.sort((a, b) => this.toEntryTimestamp(b).localeCompare(this.toEntryTimestamp(a)));
+        return entries;
+    }
+    findEntryById(agentId, memoryId) {
+        const entriesDir = this.getEntriesDir(agentId);
+        if (!fs_1.default.existsSync(entriesDir))
+            return null;
+        const files = fs_1.default.readdirSync(entriesDir).filter((f) => f.endsWith('.md'));
+        for (const file of files) {
+            const filePath = path_1.default.join(entriesDir, file);
+            const raw = fs_1.default.readFileSync(filePath, 'utf-8');
+            const { data, content } = (0, parser_1.parseFrontmatter)(raw);
+            if (data.id === memoryId) {
+                return {
+                    file,
+                    filePath,
+                    data: data,
+                    content,
+                };
+            }
+        }
+        return null;
+    }
+    save(agentId, summary, category = 'general', options = {}) {
+        this.ensureDir(this.getEntriesDir(agentId));
+        const id = this.generateId();
+        const dateTime = this.getLocalISO8601();
+        const tags = Array.isArray(options.tags)
+            ? options.tags
+            : options.tags ? options.tags.split(',').map((t) => t.trim()) : [];
+        const frontmatter = (0, parser_1.stringifyFrontmatter)({
+            id,
+            type: 'memory',
+            date: dateTime,
+            category,
+            tags,
+            summary,
+            ...(options.important ? { important: true } : {}),
+        });
+        const filename = `${id}.md`;
+        const filepath = path_1.default.join(this.getEntriesDir(agentId), filename);
+        const body = options.body ?? '(상세 내용을 여기에 추가)';
+        const content = `${frontmatter}\n\n# ${summary}\n\n${body}\n`;
+        fs_1.default.writeFileSync(filepath, content, 'utf-8');
+        console.log(`✅ 저장 완료: data/${agentId}/entries/${filename}`);
+        console.log(`   ID: ${id}`);
+        console.log(`   Tags: ${tags.join(', ') || '(없음)'}`);
+        console.log(`   Category: ${category}`);
+        try {
+            this.markSummaryDirty(agentId);
+            console.log(`   📝 summary.md 갱신 예약됨`);
+        }
+        catch (_e) {
+        }
+        const saveCtx = {
+            commandId: 'memory.save',
+            params: { agentId, tags: tags.join(',') },
+            resultTags: tags.slice(0, 3),
+            resultCount: 1,
+        };
+        const saveActions = (0, knowledge_core_1.generateNextActions)(saveCtx);
+        const saveBlock = (0, knowledge_core_1.formatActions)(saveActions);
+        if (saveBlock)
+            console.log(saveBlock);
+    }
+    index(agentId, options = {}) {
+        const summaryPath = this.getSummaryPath(agentId);
+        const entries = this.loadAllEntries(agentId);
+        const topics = [...new Set(entries.map((e) => this.getPrimaryTag(e)))];
+        if (options.recent) {
+            const days = parseInt(String(options.recent), 10) || this.recentDays;
+            this.recent(agentId, days);
+            return;
+        }
+        const cutoff24h = new Date(Date.now() - this.shortTermHours * 60 * 60 * 1000).toISOString();
+        const shortTermEntries = entries.filter((e) => this.toEntryTimestamp(e) >= cutoff24h);
+        console.log(`# ${agentId} 기억 요약\n`);
+        const summaryLastUpdated = fs_1.default.existsSync(summaryPath)
+            ? (0, parser_1.parseFrontmatter)(fs_1.default.readFileSync(summaryPath, 'utf-8')).data.last_updated ?? '-'
+            : '-';
+        console.log(`> ${entries.length}건 | 토픽 ${topics.length}개 | 갱신: ${summaryLastUpdated}`);
+        if (options.full) {
+            const byCat = {};
+            for (const entry of entries) {
+                const cat = entry.category ?? 'general';
+                byCat[cat] = (byCat[cat] ?? 0) + 1;
+            }
+            const catSummary = Object.entries(byCat)
+                .sort((a, b) => b[1] - a[1])
+                .map(([cat, count]) => `${cat}:${count}`)
+                .join(' ');
+            console.log(`> 📊 ${catSummary}`);
+        }
+        console.log('');
+        if (shortTermEntries.length > 0) {
+            const sortedShortTerm = [...shortTermEntries].sort((a, b) => {
+                const aImp = a.important ? 1 : 0;
+                const bImp = b.important ? 1 : 0;
+                if (aImp !== bImp)
+                    return bImp - aImp;
+                return this.toEntryTimestamp(b).localeCompare(this.toEntryTimestamp(a));
+            });
+            console.log(`## 🔥 최근 작업 (24h)\n`);
+            for (const e of sortedShortTerm) {
+                const star = e.important ? '⭐ ' : '';
+                console.log(`- ${star}[${e.id}] ${e.summary} (${this.getPrimaryTag(e)})`);
+            }
+            console.log('');
+        }
+        if (options.full) {
+            if (fs_1.default.existsSync(summaryPath)) {
+                const raw = fs_1.default.readFileSync(summaryPath, 'utf-8');
+                const { content: summaryBody } = (0, parser_1.parseFrontmatter)(raw);
+                if (entries.length > 0) {
+                    const newestDate = entries[0]?.date;
+                    const oldestDate = entries[entries.length - 1]?.date;
+                    const newest = newestDate ? new Date(`${newestDate}T00:00:00Z`) : null;
+                    const oldest = oldestDate ? new Date(`${oldestDate}T00:00:00Z`) : null;
+                    if (newest &&
+                        oldest &&
+                        !Number.isNaN(newest.getTime()) &&
+                        !Number.isNaN(oldest.getTime())) {
+                        const msPerDay = 24 * 60 * 60 * 1000;
+                        const diffDays = Math.max(1, Math.floor((newest.getTime() - oldest.getTime()) / msPerDay) + 1);
+                        const toMD = (d) => `${String(d.getMonth() + 1).padStart(2, '0')}/${String(d.getDate()).padStart(2, '0')}`;
+                        console.log('---');
+                        console.log(`📋 토픽 요약 (${toMD(oldest)} ~ ${toMD(newest)}, ${diffDays}일간)\n`);
+                    }
+                }
+                console.log(summaryBody.trim());
+            }
+            else {
+                for (const tag of topics.sort()) {
+                    const count = entries.filter((e) => this.getPrimaryTag(e) === tag).length;
+                    console.log(`- **${tag}** (${count}건)`);
+                }
+            }
+        }
+        const commandId = options.full ? 'memory.index-full' : 'memory.index';
+        const ctx = {
+            commandId,
+            params: { agentId },
+            resultTags: topics.slice(0, 3),
+            resultIds: entries.slice(0, 3).map(e => e.id),
+            resultCount: entries.length,
+        };
+        const actions = (0, knowledge_core_1.generateNextActions)(ctx);
+        const block = (0, knowledge_core_1.formatActions)(actions);
+        if (block)
+            console.log(block);
+    }
+    generateIndexContent(agentId) {
+        const entries = this.loadAllEntries(agentId);
+        const today = this.getToday();
+        const cutoff = new Date(Date.now() - this.recentDays * 24 * 60 * 60 * 1000)
+            .toISOString()
+            .slice(0, 10);
+        const byCategory = {};
+        const recent = [];
+        for (const entry of entries) {
+            if (entry.date >= cutoff)
+                recent.push(entry);
+            const category = entry.category ?? 'general';
+            if (!byCategory[category])
+                byCategory[category] = [];
+            byCategory[category].push(entry);
+        }
+        let md = `# ${agentId} 메모리\n\n`;
+        md += `> Last Updated: ${today}\n`;
+        md += `> Total: ${entries.length} memories\n\n`;
+        md += `## 🔥 최근 ${this.recentDays}일\n\n`;
+        if (recent.length === 0) {
+            md += `(없음)\n\n`;
+        }
+        else {
+            md += `| ID | 날짜 | 카테고리 | 요약 | 상세 |\n`;
+            md += `|----|------|----------|------|------|\n`;
+            for (const entry of recent) {
+                const detailIcon = entry.hasBody ? '📄' : '-';
+                md += `| ${entry.id} | ${entry.date} | ${entry.category ?? '-'} | [${entry.summary}](entries/${entry.file}) | ${detailIcon} |\n`;
+            }
+            md += `\n`;
+        }
+        md += `## 🏷️ 카테고리별\n\n`;
+        for (const [category, items] of Object.entries(byCategory).sort()) {
+            md += `- **${category}**: ${items.length}건\n`;
+        }
+        const olderCount = entries.length - recent.length;
+        const oldestDate = entries[entries.length - 1]?.date ?? '-';
+        const newestDate = entries[0]?.date ?? '-';
+        md += `\n## 📊 통계\n\n`;
+        md += `- 전체: ${entries.length}건 (${oldestDate} ~ ${newestDate})\n`;
+        md += `- 최근 ${this.recentDays}일: ${recent.length}건\n`;
+        if (olderCount > 0)
+            md += `- ${this.recentDays}일 이전: ${olderCount}건\n`;
+        return md;
+    }
+    topic(agentId, topicName) {
+        const entries = this.loadAllEntries(agentId);
+        const filtered = entries.filter((e) => this.getPrimaryTag(e) === topicName);
+        if (filtered.length === 0) {
+            console.log(`토픽 '${topicName}'에 해당하는 기억이 없습니다.`);
+            return;
+        }
+        console.log(`## 📂 토픽: ${topicName} (${filtered.length}건)\n`);
+        for (const entry of filtered) {
+            console.log(`### [${entry.date}] ${entry.summary}`);
+            console.log(`- 파일: data/${agentId}/entries/${entry.file}`);
+            console.log(`- 카테고리: ${entry.category ?? '-'}`);
+            console.log(`- 태그: ${(entry.tags ?? []).join(', ') || '-'}`);
+            console.log('');
+        }
+    }
+    recent(agentId, days = 30) {
+        const entries = this.loadAllEntries(agentId);
+        const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000)
+            .toISOString()
+            .slice(0, 10);
+        const filtered = entries.filter((e) => e.date >= cutoff);
+        if (filtered.length === 0) {
+            console.log(`최근 ${days}일 내 기억이 없습니다.`);
+            return;
+        }
+        console.log(`## 🔥 최근 ${days}일 (${filtered.length}건)\n`);
+        for (const entry of filtered) {
+            const detailIcon = entry.hasBody ? ' 📄' : '';
+            const timestamp = String(entry.date).includes('T')
+                ? String(entry.date).slice(0, 16).replace('T', ' ')
+                : entry.date;
+            console.log(`[${entry.id}] [${timestamp}] [${entry.category ?? '-'}] ${entry.summary}${detailIcon}`);
+        }
+    }
+    find(agentId, keyword) {
+        const entriesDir = this.getEntriesDir(agentId);
+        if (!fs_1.default.existsSync(entriesDir)) {
+            console.log('기억이 없습니다.');
+            return;
+        }
+        const files = fs_1.default.readdirSync(entriesDir).filter((f) => f.endsWith('.md'));
+        const entries = [];
+        for (const file of files) {
+            const content = fs_1.default.readFileSync(path_1.default.join(entriesDir, file), 'utf-8');
+            const { data, content: body } = (0, parser_1.parseFrontmatter)(content);
+            const entry = data;
+            entries.push({ ...entry, file, body });
+        }
+        if (entries.length === 0) {
+            console.log('기억이 없습니다.');
+            return;
+        }
+        const kcEntries = entries;
+        const results = (0, knowledge_core_1.searchEntries)(kcEntries, keyword, { summary: 3, tags: 2, body: 1 });
+        if (results.length === 0) {
+            console.log(`'${keyword}' 관련 기억을 찾을 수 없습니다.`);
+            return;
+        }
+        console.log(`## 🔍 검색 결과: "${keyword}" (${results.length}건, BM25 점수순)\n`);
+        for (const entry of results) {
+            const score = entry._score != null ? ` [${entry._score}점]` : '';
+            console.log(`[${entry.id}] [${entry.date}] [${this.getPrimaryTag(entry)}]${score} ${entry.summary}`);
+        }
+        const resultTags = [...new Set(results.flatMap(e => e.tags ?? []))].slice(0, 3);
+        const resultIds = results.slice(0, 3).map(e => e.id);
+        const findCtx = {
+            commandId: 'memory.find',
+            params: { agentId, query: keyword },
+            resultTags,
+            resultIds,
+            resultCount: results.length,
+        };
+        const findActions = (0, knowledge_core_1.generateNextActions)(findCtx);
+        const findBlock = (0, knowledge_core_1.formatActions)(findActions);
+        if (findBlock)
+            console.log(findBlock);
+    }
+    list(agentId, options = {}) {
+        const entries = this.loadAllEntries(agentId);
+        let filtered = entries;
+        if (options.category) {
+            filtered = filtered.filter(e => e.category === options.category);
+        }
+        if (options.tag) {
+            const requiredTags = options.tag.split(',').map(t => t.trim());
+            filtered = filtered.filter(e => requiredTags.every(t => (e.tags ?? []).includes(t)));
+        }
+        if (filtered.length === 0) {
+            const filters = [];
+            if (options.category)
+                filters.push(`category=${options.category}`);
+            if (options.tag)
+                filters.push(`tag=${options.tag}`);
+            console.log(`조건에 맞는 기억이 없습니다. (${filters.join(', ') || '전체'})`);
+            return;
+        }
+        console.log(`## 📋 목록: ${agentId} (${filtered.length}건)\n`);
+        for (const entry of filtered) {
+            console.log(`[${entry.id}] [${entry.date}] [${this.getPrimaryTag(entry)}] ${entry.summary}`);
+        }
+        const resultTags = [...new Set(filtered.flatMap(e => e.tags ?? []))].slice(0, 3);
+        const resultIds = filtered.slice(0, 3).map(e => e.id);
+        const listCtx = {
+            commandId: 'memory.list',
+            params: { agentId, ...(options.category ? { category: options.category } : {}) },
+            resultTags,
+            resultIds,
+            resultCount: filtered.length,
+        };
+        const listActions = (0, knowledge_core_1.generateNextActions)(listCtx);
+        const listBlock = (0, knowledge_core_1.formatActions)(listActions);
+        if (listBlock)
+            console.log(listBlock);
+    }
+    stats(agentId) {
+        const entries = this.loadAllEntries(agentId);
+        if (entries.length === 0) {
+            console.log('기억이 없습니다.');
+            return;
+        }
+        const byCategory = {};
+        for (const entry of entries) {
+            const cat = entry.category ?? 'general';
+            byCategory[cat] = (byCategory[cat] ?? 0) + 1;
+        }
+        const byTag = {};
+        for (const entry of entries) {
+            for (const tag of entry.tags ?? []) {
+                byTag[tag] = (byTag[tag] ?? 0) + 1;
+            }
+        }
+        console.log(`# ${agentId} 통계 (${entries.length}건)\n`);
+        console.log(`## 카테고리별`);
+        for (const [cat, count] of Object.entries(byCategory).sort((a, b) => b[1] - a[1])) {
+            console.log(`  ${cat}: ${count}건`);
+        }
+        console.log(`\n## 태그 Top 20`);
+        const sortedTags = Object.entries(byTag).sort((a, b) => b[1] - a[1]).slice(0, 20);
+        for (const [tag, count] of sortedTags) {
+            console.log(`  ${tag}: ${count}건`);
+        }
+        const topCategories = Object.entries(byCategory).sort((a, b) => b[1] - a[1]).map(t => t[0]);
+        const statsCtx = {
+            commandId: 'memory.stats',
+            params: { agentId },
+            resultTags: topCategories.slice(0, 3),
+            resultCount: entries.length,
+        };
+        const statsActions = (0, knowledge_core_1.generateNextActions)(statsCtx);
+        const statsBlock = (0, knowledge_core_1.formatActions)(statsActions);
+        if (statsBlock)
+            console.log(statsBlock);
+    }
+    tags(agentId) {
+        const entries = this.loadAllEntries(agentId);
+        if (entries.length === 0) {
+            console.log('기억이 없습니다.');
+            return;
+        }
+        const byTag = {};
+        for (const entry of entries) {
+            for (const tag of entry.tags ?? []) {
+                byTag[tag] = (byTag[tag] ?? 0) + 1;
+            }
+        }
+        const sortedTags = Object.entries(byTag).sort((a, b) => b[1] - a[1]);
+        if (sortedTags.length === 0) {
+            console.log('태그가 없습니다.');
+            return;
+        }
+        console.log(`## 🏷️ 전체 태그 (${sortedTags.length}개)\n`);
+        for (const [tag, count] of sortedTags) {
+            console.log(`  ${tag}: ${count}건`);
+        }
+    }
+    get(agentId, memoryId) {
+        const entriesDir = this.getEntriesDir(agentId);
+        if (!fs_1.default.existsSync(entriesDir)) {
+            console.log('기억이 없습니다.');
+            return;
+        }
+        const files = fs_1.default.readdirSync(entriesDir).filter((f) => f.endsWith('.md'));
+        for (const file of files) {
+            const filePath = path_1.default.join(entriesDir, file);
+            const raw = fs_1.default.readFileSync(filePath, 'utf-8');
+            const { data, content } = (0, parser_1.parseFrontmatter)(raw);
+            if (data.id === memoryId) {
+                const d = data;
+                console.log(`## 📄 ${d.summary}\n`);
+                console.log(`- ID: ${d.id}`);
+                console.log(`- 날짜: ${d.date}`);
+                console.log(`- 카테고리: ${d.category ?? '-'}`);
+                console.log(`- 태그: ${(d.tags ?? []).join(', ') || '-'}`);
+                console.log(`- 파일: data/${agentId}/entries/${file}`);
+                console.log(`\n---\n`);
+                console.log(content.trim());
+                const graphPath = path_1.default.join(this.getAgentDir(agentId), 'graph.json');
+                if (fs_1.default.existsSync(graphPath)) {
+                    try {
+                        const graph = JSON.parse(fs_1.default.readFileSync(graphPath, 'utf-8'));
+                        const relatedEdges = graph.edges
+                            .filter((e) => e.from === memoryId || e.to === memoryId)
+                            .sort((a, b) => b.weight - a.weight)
+                            .slice(0, 5);
+                        if (relatedEdges.length > 0) {
+                            const nodeMap = {};
+                            graph.nodes.forEach((n) => {
+                                nodeMap[n.id] = n;
+                            });
+                            console.log(`\n---\n`);
+                            console.log(`## 🔗 연관 기억 (${relatedEdges.length}개)\n`);
+                            for (const edge of relatedEdges) {
+                                const otherId = edge.from === memoryId ? edge.to : edge.from;
+                                const other = nodeMap[otherId];
+                                if (other) {
+                                    console.log(`[${edge.weight}] [${otherId}] ${other.summary.slice(0, 50)}...`);
+                                }
+                            }
+                        }
+                    }
+                    catch (_e) {
+                    }
+                }
+                const getCtx = {
+                    commandId: 'memory.get',
+                    params: { agentId, id: memoryId },
+                    resultTags: (d.tags ?? []).slice(0, 3),
+                    resultIds: [memoryId],
+                    resultCount: 1,
+                };
+                const getActions = (0, knowledge_core_1.generateNextActions)(getCtx);
+                const getBlock = (0, knowledge_core_1.formatActions)(getActions);
+                if (getBlock)
+                    console.log(getBlock);
+                return;
+            }
+        }
+        console.log(`ID '${memoryId}'를 찾을 수 없습니다.`);
+    }
+    update(agentId, memoryId, options = {}) {
+        const entry = this.findEntryById(agentId, memoryId);
+        if (!entry) {
+            console.log(`❌ ID '${memoryId}'를 찾을 수 없습니다.`);
+            process.exit(1);
+        }
+        const { filePath, data, content } = entry;
+        const existingBody = content.replace(/^#[^\n]*\n*/m, '').trim();
+        const tags = Array.isArray(options.tags)
+            ? options.tags
+            : options.tags ? options.tags.split(',').map((t) => t.trim()) : (data.tags ?? []);
+        const newData = {
+            ...data,
+            summary: options.summary ?? data.summary,
+            category: options.category ?? data.category,
+            tags,
+            updated: this.getToday(),
+        };
+        if (options.important) {
+            newData['important'] = true;
+        }
+        else if (options['no-important']) {
+            delete newData['important'];
+        }
+        const newBody = options.body ?? existingBody ?? '(상세 내용을 여기에 추가)';
+        const newFrontmatter = (0, parser_1.stringifyFrontmatter)(newData);
+        const newContent = `${newFrontmatter}\n\n# ${String(newData['summary'])}\n\n${newBody}\n`;
+        fs_1.default.writeFileSync(filePath, newContent, 'utf-8');
+        console.log(`✅ 수정 완료: ${entry.file}`);
+        console.log(`   ID: ${memoryId}`);
+        if (options.summary)
+            console.log(`   Summary: ${String(newData['summary'])}`);
+        if (options.category)
+            console.log(`   Category: ${String(newData['category'])}`);
+        if (options.tags)
+            console.log(`   Tags: ${newData['tags'].join(', ')}`);
+        if (options.body)
+            console.log(`   Body: (업데이트됨)`);
+    }
+    delete(agentId, memoryId, options = {}) {
+        const entry = this.findEntryById(agentId, memoryId);
+        if (!entry) {
+            console.log(`❌ ID '${memoryId}'를 찾을 수 없습니다.`);
+            process.exit(1);
+        }
+        if (!options.force) {
+            console.log(`⚠️  삭제 대상: [${entry.data.id}] ${entry.data.summary}`);
+            console.log(`   파일: ${entry.file}`);
+            console.log(`\n--force 옵션을 추가하면 삭제됩니다.`);
+            console.log(`예: memory delete ${agentId} ${memoryId} --force`);
+            return;
+        }
+        fs_1.default.unlinkSync(entry.filePath);
+        console.log(`🗑️  삭제 완료: ${entry.file}`);
+        console.log(`   ID: ${memoryId}`);
+        console.log(`   Summary: ${entry.data.summary}`);
+        try {
+            this.markSummaryDirty(agentId);
+            console.log(`   📝 summary.md 갱신 예약됨`);
+        }
+        catch (_e) {
+        }
+    }
+    merge(agentId, memoryId1, memoryId2, options = {}) {
+        const entry1 = this.findEntryById(agentId, memoryId1);
+        const entry2 = this.findEntryById(agentId, memoryId2);
+        if (!entry1) {
+            console.log(`❌ ID '${memoryId1}'를 찾을 수 없습니다.`);
+            process.exit(1);
+        }
+        if (!entry2) {
+            console.log(`❌ ID '${memoryId2}'를 찾을 수 없습니다.`);
+            process.exit(1);
+        }
+        const body1 = entry1.content.replace(/^#[^\n]*\n*/m, '').trim();
+        const body2 = entry2.content.replace(/^#[^\n]*\n*/m, '').trim();
+        const mergedSummary = options.summary ?? `${entry1.data.summary} + ${entry2.data.summary}`;
+        const mergedBody = `## 병합된 기억 1 (${entry1.data.id}, ${entry1.data.date})
+${entry1.data.summary}
+
+${body1 !== '(상세 내용을 여기에 추가)' ? body1 : '(상세 없음)'}
+
+---
+
+## 병합된 기억 2 (${entry2.data.id}, ${entry2.data.date})
+${entry2.data.summary}
+
+${body2 !== '(상세 내용을 여기에 추가)' ? body2 : '(상세 없음)'}`;
+        const mergedTags = [
+            ...new Set([...(entry1.data.tags ?? []), ...(entry2.data.tags ?? [])]),
+        ];
+        const newerDate = entry1.data.date > entry2.data.date ? entry1.data.date : entry2.data.date;
+        const newId = this.generateId();
+        const newData = {
+            id: newId,
+            type: 'memory',
+            date: newerDate,
+            category: entry1.data.category,
+            tags: mergedTags,
+            summary: mergedSummary,
+            merged_from: [memoryId1, memoryId2],
+        };
+        const filename = `${newId}.md`;
+        const filepath = path_1.default.join(this.getEntriesDir(agentId), filename);
+        const newFrontmatter = (0, parser_1.stringifyFrontmatter)(newData);
+        const newContent = `${newFrontmatter}\n\n# ${mergedSummary}\n\n${mergedBody}\n`;
+        fs_1.default.writeFileSync(filepath, newContent, 'utf-8');
+        fs_1.default.unlinkSync(entry1.filePath);
+        fs_1.default.unlinkSync(entry2.filePath);
+        console.log(`🔀 병합 완료!`);
+        console.log(`   새 ID: ${newId}`);
+        console.log(`   새 파일: ${filename}`);
+        console.log(`   병합된 기억: [${memoryId1}] + [${memoryId2}]`);
+        console.log(`   Summary: ${mergedSummary}`);
+    }
+    buildFallbackSummary(entries) {
+        const byTag = {};
+        for (const entry of entries) {
+            const tag = this.getPrimaryTag(entry);
+            if (!byTag[tag])
+                byTag[tag] = [];
+            byTag[tag].push(entry);
+        }
+        const toMD = (dateStr) => {
+            if (!dateStr)
+                return '-';
+            const normalized = String(dateStr).includes('T') ? dateStr : `${dateStr}T00:00:00Z`;
+            const d = new Date(normalized);
+            if (Number.isNaN(d.getTime()))
+                return '-';
+            return `${String(d.getMonth() + 1).padStart(2, '0')}/${String(d.getDate()).padStart(2, '0')}`;
+        };
+        let body = '';
+        for (const [topic, items] of Object.entries(byTag).sort()) {
+            const dates = items.map((i) => i.date).filter(Boolean).sort();
+            const oldest = dates[0];
+            const newest = dates[dates.length - 1];
+            const rangeLabel = oldest && newest ? `, ${toMD(oldest)}~${toMD(newest)}` : '';
+            body += `## ${topic} (${items.length}건${rangeLabel})\n`;
+            for (const e of items)
+                body += `- [${e.date}] ${e.summary}\n`;
+            for (const e of items)
+                body += `→ [entries/${e.file}](entries/${e.file})\n`;
+            body += `\n`;
+        }
+        return body;
+    }
+    callSummarizer(prompt) {
+        const tmpFile = path_1.default.join(os_1.default.tmpdir(), `memory-summarizer-${Date.now()}.txt`);
+        try {
+            fs_1.default.writeFileSync(tmpFile, prompt, 'utf-8');
+            const result = (0, child_process_1.execSync)(`./crewx q "@memory_summarizer $(cat '${tmpFile}')"`, { encoding: 'utf-8', timeout: 60000, stdio: ['pipe', 'pipe', 'pipe'] });
+            return parseCrewxResponse(result);
+        }
+        catch (_e) {
+            return null;
+        }
+        finally {
+            try {
+                fs_1.default.unlinkSync(tmpFile);
+            }
+            catch (_e) {
+            }
+        }
+    }
+    generateSummary(agentId, options = {}) {
+        const allEntries = this.loadAllEntries(agentId);
+        if (allEntries.length === 0)
+            return { status: 'empty' };
+        const cutoff = new Date(Date.now() - this.summaryDays * 24 * 60 * 60 * 1000)
+            .toISOString()
+            .slice(0, 10);
+        const entries = options.force
+            ? allEntries
+            : allEntries.filter((e) => e.date >= cutoff);
+        if (entries.length === 0)
+            return { status: 'empty', entryCount: allEntries.length };
+        const summaryPath = this.getSummaryPath(agentId);
+        const existing = fs_1.default.existsSync(summaryPath)
+            ? (0, parser_1.parseFrontmatter)(fs_1.default.readFileSync(summaryPath, 'utf-8'))
+            : null;
+        const lastEntryId = existing?.data?.last_entry_id ?? null;
+        const existingBody = existing?.content.trim() ?? null;
+        const getNewSince = (arr, lastId) => {
+            if (!lastId)
+                return arr;
+            const idx = arr.findIndex((e) => e.id === lastId);
+            if (idx === -1)
+                return arr;
+            return arr.slice(0, idx);
+        };
+        const newEntries = getNewSince(entries, lastEntryId);
+        if (newEntries.length === 0 && !options.force) {
+            return { status: 'up-to-date', entryCount: allEntries.length };
+        }
+        const entriesToProcess = options.force ? entries : newEntries;
+        const enriched = [...entriesToProcess].reverse().map((e) => {
+            if (e.file) {
+                try {
+                    const raw = fs_1.default.readFileSync(path_1.default.join(this.getEntriesDir(agentId), e.file), 'utf-8');
+                    const { content } = (0, parser_1.parseFrontmatter)(raw);
+                    const body = content.replace(/^#[^\n]*\n*/m, '').trim();
+                    return { ...e, body };
+                }
+                catch (_e) {
+                }
+            }
+            return e;
+        });
+        const allTopics = [...new Set(entries.map((e) => this.getPrimaryTag(e)))].sort();
+        const buildPrompt = (existBody, newItems, topics) => {
+            let p = `You are a memory summarizer for an AI agent.\n\n`;
+            if (existBody) {
+                p += `## Existing summary:\n${existBody}\n\n## New entries to incorporate:\n`;
+            }
+            else {
+                p += `## All entries:\n`;
+            }
+            for (const entry of newItems) {
+                const importantTag = entry.important ? ' [important]' : '';
+                p += `- [${entry.id}] [${entry.date}] [${this.getPrimaryTag(entry)}]${importantTag} ${entry.summary}`;
+                if (entry.body && entry.body !== '(상세 내용을 여기에 추가)') {
+                    p += ` — ${entry.body.slice(0, 200)}`;
+                }
+                p += ` (file: entries/${entry.file})\n`;
+            }
+            p += `\n## Instructions:\n`;
+            p += `- Group by topic, each topic as ## heading with entry count and date range, e.g. "## mcp-http (4건, 01/28~02/14)"\n`;
+            p += `- Write concise Korean summary per topic (2-5 sentences)\n`;
+            p += `- After each topic summary, list relevant entry file links as "→ [entries/filename](entries/filename)"\n`;
+            p += `- Highlight key decisions, insights, and action items\n`;
+            p += `- If there's an existing summary, merge new information into it\n`;
+            p += `- Topics to cover: ${topics.join(', ')}\n`;
+            p += `- Output ONLY the markdown body (topic sections), no frontmatter or top-level heading\n`;
+            return p;
+        };
+        const prompt = buildPrompt(options.force ? null : existingBody, enriched, allTopics);
+        const summaryText = this.callSummarizer(prompt);
+        const newestEntryId = entries[0]?.id;
+        if (!summaryText) {
+            const allEnriched = entries.map((e) => {
+                if (e.file) {
+                    try {
+                        const raw = fs_1.default.readFileSync(path_1.default.join(this.getEntriesDir(agentId), e.file), 'utf-8');
+                        const { content } = (0, parser_1.parseFrontmatter)(raw);
+                        const body = content.replace(/^#[^\n]*\n*/m, '').trim();
+                        return { ...e, body };
+                    }
+                    catch (_e) {
+                    }
+                }
+                return e;
+            });
+            const fallbackBody = this.buildFallbackSummary(allEnriched);
+            const fm = (0, parser_1.stringifyFrontmatter)({
+                last_entry_id: newestEntryId,
+                last_updated: this.getToday(),
+                entry_count: allEntries.length,
+                summary_days: this.summaryDays,
+                summarizer: 'fallback',
+            });
+            fs_1.default.writeFileSync(summaryPath, `${fm}\n\n${fallbackBody}`, 'utf-8');
+            return { status: 'fallback', entryCount: allEntries.length, newEntries: entriesToProcess.length };
+        }
+        const fm = (0, parser_1.stringifyFrontmatter)({
+            last_entry_id: newestEntryId,
+            last_updated: this.getToday(),
+            entry_count: allEntries.length,
+            summary_days: this.summaryDays,
+            summarizer: 'memory_summarizer',
+        });
+        fs_1.default.writeFileSync(summaryPath, `${fm}\n\n${summaryText}\n`, 'utf-8');
+        return { status: 'updated', entryCount: allEntries.length, newEntries: entriesToProcess.length };
+    }
+    summarize(agentId, options = {}) {
+        const entries = this.loadAllEntries(agentId);
+        if (entries.length === 0) {
+            console.log('기억이 없습니다.');
+            return;
+        }
+        console.log(`📝 요약 생성 시작 (${entries.length}개 엔트리)\n`);
+        const result = this.generateSummary(agentId, { force: options.force });
+        if (result.status === 'up-to-date') {
+            console.log('✅ summary.md 최신 상태입니다.');
+        }
+        else if (result.status === 'fallback') {
+            console.log(`📋 폴백 요약 생성 완료 (AI 호출 실패)`);
+        }
+        else if (result.status === 'updated') {
+            console.log(`🤖 요약 완료 (${result.newEntries}건 반영)`);
+        }
+        console.log(`   파일: data/${agentId}/summary.md`);
+        console.log(`   엔트리: ${result.entryCount}개`);
+    }
+    summarizeDirty() {
+        if (!fs_1.default.existsSync(this.dataDir)) {
+            console.log(`💡 디바운스 cron 등록:`);
+            console.log(`npx cron add "*/1 * * * *" "npx memory summarize-dirty" --mode command --name "memory-debounce"`);
+            return;
+        }
+        const agentDirs = fs_1.default
+            .readdirSync(this.dataDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+        for (const agentId of agentDirs) {
+            const dirtyPath = this.getDirtySummaryPath(agentId);
+            if (!fs_1.default.existsSync(dirtyPath))
+                continue;
+            try {
+                const result = this.generateSummary(agentId);
+                if (result.status === 'updated') {
+                    console.log(`🤖 ${agentId} summary.md 갱신 (${result.newEntries}건 반영)`);
+                }
+                else if (result.status === 'fallback') {
+                    console.log(`📋 ${agentId} 폴백 요약 생성 완료 (AI 호출 실패)`);
+                }
+                else if (result.status === 'up-to-date') {
+                    console.log(`✅ ${agentId} summary.md 최신 상태입니다.`);
+                }
+                else if (result.status === 'empty') {
+                    console.log(`ℹ️  ${agentId} 요약할 기억이 없습니다.`);
+                }
+                fs_1.default.unlinkSync(dirtyPath);
+            }
+            catch (e) {
+                console.error(`❌ ${agentId} summary.md 갱신 실패: ${e.message}`);
+            }
+        }
+        console.log(`💡 디바운스 cron 등록:`);
+        console.log(`npx cron add "*/1 * * * *" "npx memory summarize-dirty" --mode command --name "memory-debounce"`);
+    }
+    search(agentId, query) {
+        const entries = this.loadAllEntries(agentId);
+        if (entries.length === 0) {
+            console.log('기억이 없습니다.');
+            return;
+        }
+        const memoryList = entries
+            .map((e) => `[${e.id}] [${e.date}] [${this.getPrimaryTag(e)}] ${e.summary}`)
+            .join('\n');
+        const task = `기억 목록:\n${memoryList}\n\n질문: "${query}"`;
+        try {
+            console.log(`🔍 "${query}" 검색 중... (@memory_searcher)\n`);
+            const result = (0, child_process_1.execSync)(`./crewx q "@memory_searcher ${task.replace(/"/g, '\\"').replace(/\n/g, ' ')}"`, { encoding: 'utf-8', timeout: 300000, stdio: ['pipe', 'pipe', 'pipe'] });
+            const parsed = parseCrewxResponse(result);
+            if (parsed) {
+                console.log(`## 🧠 시맨틱 검색 결과\n`);
+                console.log(parsed);
+            }
+            else {
+                console.log(result.trim());
+            }
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === 'ETIMEDOUT' || err.killed) {
+                console.log('검색 실패: 시간 초과 (최대 5분)');
+            }
+            else {
+                console.log('검색 실패:', err.message);
+            }
+            console.log('\n💡 Tip: find 명령으로 키워드 검색을 시도해보세요.');
+        }
+    }
+}
+exports.MemoryEngine = MemoryEngine;
+function createMemoryEngine(config) {
+    return new MemoryEngine(config);
+}
+var types_1 = require("./types");
+Object.defineProperty(exports, "CATEGORIES", { enumerable: true, get: function () { return types_1.CATEGORIES; } });
+//# sourceMappingURL=engine.js.map