@crewx/memory 0.1.0

package/dist/src/mindmap.js

@@ -0,0 +1,838 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MindmapEngine = void 0;
+exports.loadAllEntries = loadAllEntries;
+exports.buildGraph = buildGraph;
+exports.saveGraph = saveGraph;
+exports.loadGraph = loadGraph;
+exports.generateHtml = generateHtml;
+exports.filterGraphByPeriod = filterGraphByPeriod;
+exports.renderMermaid = renderMermaid;
+exports.renderText = renderText;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const parser_1 = require("./parser");
+const knowledge_core_1 = require("@crewx/knowledge-core");
+const MEMORY_SHORT_TERM_HOURS = 24;
+const MEMORY_SUMMARY_DAYS = 7;
+const MEMORY_RECENT_DAYS = 30;
+const PERIOD_CONFIG = {
+    stm: {
+        label: `STM ${MEMORY_SHORT_TERM_HOURS}h`,
+        ms: MEMORY_SHORT_TERM_HOURS * 60 * 60 * 1000,
+    },
+    mtm: {
+        label: `MTM ${MEMORY_SUMMARY_DAYS}d`,
+        ms: MEMORY_SUMMARY_DAYS * 24 * 60 * 60 * 1000,
+    },
+    ltm: {
+        label: `LTM ${MEMORY_RECENT_DAYS}d`,
+        ms: MEMORY_RECENT_DAYS * 24 * 60 * 60 * 1000,
+    },
+};
+const DEFAULT_COLORS = [
+    '#6366f1', '#8b5cf6', '#ec4899', '#f43f5e', '#f97316',
+    '#eab308', '#22c55e', '#14b8a6', '#06b6d4', '#3b82f6',
+];
+function loadAllEntries(entriesDir) {
+    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);
+        entries.push({ file, content, ...data });
+    }
+    return entries;
+}
+function buildGraph(entriesDir, options = {}) {
+    const { edgeThreshold = 0.3, includeSameDay = false, } = options;
+    const entries = loadAllEntries(entriesDir);
+    if (entries.length === 0) {
+        return null;
+    }
+    const kcEntries = entries.map(e => ({
+        id: e.id,
+        type: e['type'] || 'memory',
+        category: e.category || 'general',
+        tags: e.tags || [],
+        date: e.date || '',
+        summary: e.summary || '',
+        body: e.content || '',
+    }));
+    const coreGraph = (0, knowledge_core_1.buildGraph)(kcEntries, { edgeThreshold, includeSameDay });
+    return {
+        nodes: coreGraph.nodes.map(n => ({
+            ...n,
+            important: entries.find(e => e.id === n.id)?.important,
+        })),
+        edges: coreGraph.edges,
+        stats: coreGraph.stats,
+        updated: new Date().toISOString(),
+    };
+}
+function saveGraph(outputPath, graph) {
+    graph.updated = new Date().toISOString();
+    fs_1.default.writeFileSync(outputPath, JSON.stringify(graph, null, 2), 'utf-8');
+}
+function loadGraph(inputPath) {
+    if (!fs_1.default.existsSync(inputPath)) {
+        return { nodes: [], edges: [], stats: { nodeCount: 0, edgeCount: 0 }, updated: null };
+    }
+    return JSON.parse(fs_1.default.readFileSync(inputPath, 'utf-8'));
+}
+function generateHtml(graphs, options = {}) {
+    const { colors = DEFAULT_COLORS, title = 'Memory Graph' } = options;
+    if (Object.keys(graphs).length === 0) {
+        return null;
+    }
+    const agentData = {};
+    for (const [agentId, graph] of Object.entries(graphs)) {
+        if (!graph || !graph.nodes || graph.nodes.length === 0) {
+            continue;
+        }
+        const topics = [...new Set(graph.nodes.map(n => (n.tags?.[0]) || 'general'))];
+        const topicColors = {};
+        topics.forEach((topic, i) => {
+            topicColors[topic] = colors[i % colors.length];
+        });
+        const nodes = graph.nodes.map(n => {
+            const summary = n.summary ? String(n.summary) : (n.id ? String(n.id) : 'Unknown');
+            const primaryTag = (n.tags?.[0]) || 'general';
+            return {
+                id: n.id || 'unknown',
+                label: summary.slice(0, 40),
+                fullLabel: summary,
+                topic: primaryTag,
+                date: n.date || '-',
+                color: topicColors[primaryTag],
+            };
+        });
+        const links = graph.edges.map(e => ({
+            source: e.from,
+            target: e.to,
+            weight: e.weight,
+            type: e.type,
+        }));
+        agentData[agentId] = { nodes, links, topics, topicColors, updated: graph.updated };
+    }
+    const agentOptions = Object.keys(agentData)
+        .map(agentId => `<option value="${agentId}">${agentId}</option>`)
+        .join('');
+    return `<!DOCTYPE html>
+<html lang="ko">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title}</title>
+  <script src="https://d3js.org/d3.v7.min.js"></script>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: #1a1a2e;
+      overflow: hidden;
+    }
+    #graph { width: 100vw; height: 100vh; }
+    .node circle {
+      cursor: pointer;
+      stroke: #fff;
+      stroke-width: 1.5px;
+      transition: all 0.2s;
+    }
+    .node circle:hover {
+      stroke-width: 3px;
+      filter: brightness(1.2);
+    }
+    .node text {
+      font-size: 10px;
+      fill: #e0e0e0;
+      pointer-events: none;
+      text-shadow: 0 0 3px #1a1a2e;
+    }
+    .link {
+      stroke: #4a4a6a;
+      stroke-opacity: 0.6;
+    }
+    .tooltip {
+      position: absolute;
+      background: #2d2d44;
+      border: 1px solid #4a4a6a;
+      border-radius: 8px;
+      padding: 12px;
+      color: #fff;
+      font-size: 13px;
+      max-width: 300px;
+      pointer-events: none;
+      box-shadow: 0 4px 20px rgba(0,0,0,0.5);
+      z-index: 10;
+    }
+    .tooltip .title { font-weight: bold; margin-bottom: 8px; color: #a5b4fc; }
+    .tooltip .meta { color: #9ca3af; font-size: 11px; }
+    .controls {
+      position: absolute;
+      top: 20px;
+      left: 20px;
+      background: #2d2d44;
+      border-radius: 8px;
+      padding: 15px;
+      color: #fff;
+      font-size: 13px;
+      min-width: 200px;
+      z-index: 5;
+    }
+    .controls h3 { margin-bottom: 10px; color: #a5b4fc; }
+    .controls select {
+      width: 100%;
+      padding: 8px;
+      background: #1a1a2e;
+      color: #fff;
+      border: 1px solid #4a4a6a;
+      border-radius: 4px;
+      font-size: 13px;
+      cursor: pointer;
+    }
+    .controls select + select {
+      margin-top: 6px;
+    }
+    .controls select:hover {
+      border-color: #6366f1;
+    }
+    .legend {
+      position: absolute;
+      top: 100px;
+      left: 20px;
+      background: #2d2d44;
+      border-radius: 8px;
+      padding: 15px;
+      color: #fff;
+      font-size: 12px;
+      max-height: calc(100vh - 200px);
+      overflow-y: auto;
+      z-index: 5;
+    }
+    .legend h4 { margin-bottom: 8px; color: #a5b4fc; font-size: 11px; }
+    .legend-item { display: flex; align-items: center; margin: 4px 0; }
+    .legend-color { width: 12px; height: 12px; border-radius: 50%; margin-right: 8px; flex-shrink: 0; }
+    .stats {
+      position: absolute;
+      bottom: 20px;
+      left: 20px;
+      background: #2d2d44;
+      border-radius: 8px;
+      padding: 10px 15px;
+      color: #9ca3af;
+      font-size: 11px;
+      z-index: 5;
+    }
+  </style>
+</head>
+<body>
+  <div id="graph"></div>
+
+  <div class="controls">
+    <h3>📊 ${title}</h3>
+    <select id="agentSelect">${agentOptions}</select>
+    <select id="periodSelect">
+      <option value="all">All</option>
+      <option value="stm">STM (24h)</option>
+      <option value="mtm">MTM (7d)</option>
+      <option value="ltm">LTM (30d)</option>
+    </select>
+  </div>
+
+  <div class="legend" id="legend"></div>
+
+  <div class="stats" id="stats"></div>
+
+  <div class="tooltip" style="display:none"></div>
+
+  <script>
+    const agentData = ${JSON.stringify(agentData)};
+
+    const urlParams = new URLSearchParams(window.location.search);
+    const agentFromUrl = urlParams.get('agent');
+    let currentAgent = (agentFromUrl && agentData[agentFromUrl]) ? agentFromUrl : Object.keys(agentData)[0];
+    let currentPeriod = urlParams.get('period') || 'all';
+
+    let simulation = null;
+    let svg = null;
+    let g = null;
+
+    const width = window.innerWidth;
+    const height = window.innerHeight;
+
+    function initSVG() {
+      svg = d3.select('#graph')
+        .append('svg')
+        .attr('width', width)
+        .attr('height', height);
+
+      g = svg.append('g');
+
+      svg.call(d3.zoom()
+        .extent([[0, 0], [width, height]])
+        .scaleExtent([0.1, 4])
+        .on('zoom', (event) => g.attr('transform', event.transform)));
+    }
+
+    function parseDateForFilter(dateStr) {
+      if (!dateStr || dateStr === '-') return null;
+      const raw = String(dateStr);
+      const date = raw.includes('T') ? new Date(raw) : new Date(raw + 'T00:00:00Z');
+      return Number.isNaN(date.getTime()) ? null : date;
+    }
+
+    function filterDataByPeriod(data, period) {
+      if (!period || period === 'all') return data;
+      const periodMap = {
+        stm: 24 * 60 * 60 * 1000,
+        mtm: 7 * 24 * 60 * 60 * 1000,
+        ltm: 30 * 24 * 60 * 60 * 1000
+      };
+      const windowMs = periodMap[period];
+      if (!windowMs) return data;
+      const cutoff = Date.now() - windowMs;
+      const nodes = data.nodes.filter(n => {
+        const date = parseDateForFilter(n.date);
+        return date && date.getTime() >= cutoff;
+      });
+      const nodeIds = new Set(nodes.map(n => n.id));
+      const links = data.links.filter(l => nodeIds.has(l.source) && nodeIds.has(l.target));
+      return { ...data, nodes, links };
+    }
+
+    function getFilteredData() {
+      return filterDataByPeriod(agentData[currentAgent], currentPeriod);
+    }
+
+    function updateLegend(data) {
+      const topics = [...new Set(data.nodes.map(n => n.topic))];
+      const colors = agentData[currentAgent].topicColors || {};
+      const items = topics.map(t =>
+        '<div class="legend-item"><div class="legend-color" style="background:' + (colors[t] || '#666') + '"></div><span>' + t + '</span></div>'
+      ).join('');
+      document.getElementById('legend').innerHTML = '<h4>토픽</h4>' + items;
+    }
+
+    function updateStats(data) {
+      const periodLabels = {
+        all: 'All',
+        stm: 'STM (24h)',
+        mtm: 'MTM (7d)',
+        ltm: 'LTM (30d)'
+      };
+      const periodLabel = periodLabels[currentPeriod] || 'All';
+      const periodText = currentPeriod === 'all' ? '' : (' | 기간: ' + periodLabel);
+      document.getElementById('stats').innerHTML =
+        '에이전트: ' + currentAgent + ' | ' +
+        '노드: ' + data.nodes.length + ' | ' +
+        '엣지: ' + data.links.length + ' | ' +
+        '업데이트: ' + (data.updated ? data.updated.slice(0, 10) : '-') +
+        periodText;
+    }
+
+    function renderGraph() {
+      const data = getFilteredData();
+
+      if (simulation) {
+        simulation.stop();
+      }
+
+      g.selectAll('*').remove();
+
+      const nodes = JSON.parse(JSON.stringify(data.nodes));
+      const links = JSON.parse(JSON.stringify(data.links));
+
+      simulation = d3.forceSimulation(nodes)
+        .force('link', d3.forceLink(links).id(d => d.id).distance(80))
+        .force('charge', d3.forceManyBody().strength(-200))
+        .force('center', d3.forceCenter(width / 2, height / 2))
+        .force('collision', d3.forceCollide().radius(30));
+
+      const link = g.append('g')
+        .selectAll('line')
+        .data(links)
+        .join('line')
+        .attr('class', 'link')
+        .attr('stroke-width', d => Math.sqrt(d.weight) * 2);
+
+      const node = g.append('g')
+        .selectAll('g')
+        .data(nodes)
+        .join('g')
+        .attr('class', 'node')
+        .call(d3.drag()
+          .on('start', dragstarted)
+          .on('drag', dragged)
+          .on('end', dragended));
+
+      node.append('circle')
+        .attr('r', d => {
+          const connections = links.filter(l => l.source.id === d.id || l.target.id === d.id).length;
+          return Math.max(6, Math.min(20, 6 + connections));
+        })
+        .attr('fill', d => d.color);
+
+      node.append('text')
+        .attr('dx', 15)
+        .attr('dy', 4)
+        .text(d => d.label);
+
+      const tooltip = d3.select('.tooltip');
+
+      node.on('mouseover', (event, d) => {
+        tooltip.style('display', 'block')
+          .style('left', (event.pageX + 15) + 'px')
+          .style('top', (event.pageY - 10) + 'px')
+          .html('<div class="title">' + d.fullLabel + '</div><div class="meta">ID: ' + d.id + '<br>토픽: ' + d.topic + '<br>날짜: ' + d.date + '</div>');
+      }).on('mouseout', () => {
+        tooltip.style('display', 'none');
+      });
+
+      simulation.on('tick', () => {
+        link
+          .attr('x1', d => d.source.x)
+          .attr('y1', d => d.source.y)
+          .attr('x2', d => d.target.x)
+          .attr('y2', d => d.target.y);
+        node.attr('transform', d => 'translate(' + d.x + ',' + d.y + ')');
+      });
+
+      function dragstarted(event) {
+        if (!event.active) simulation.alphaTarget(0.3).restart();
+        event.subject.fx = event.subject.x;
+        event.subject.fy = event.subject.y;
+      }
+
+      function dragged(event) {
+        event.subject.fx = event.x;
+        event.subject.fy = event.y;
+      }
+
+      function dragended(event) {
+        if (!event.active) simulation.alphaTarget(0);
+        event.subject.fx = null;
+        event.subject.fy = null;
+      }
+
+      updateLegend(data);
+      updateStats(data);
+    }
+
+    document.addEventListener('DOMContentLoaded', () => {
+      document.getElementById('agentSelect').value = currentAgent;
+      document.getElementById('periodSelect').value = currentPeriod;
+
+      document.getElementById('agentSelect').addEventListener('change', (e) => {
+        currentAgent = e.target.value;
+        const url = new URL(window.location);
+        url.searchParams.set('agent', currentAgent);
+        url.searchParams.set('period', currentPeriod);
+        history.replaceState({}, '', url);
+        renderGraph();
+      });
+      document.getElementById('periodSelect').addEventListener('change', (e) => {
+        currentPeriod = e.target.value;
+        const url = new URL(window.location);
+        url.searchParams.set('agent', currentAgent);
+        url.searchParams.set('period', currentPeriod);
+        history.replaceState({}, '', url);
+        renderGraph();
+      });
+
+      initSVG();
+      renderGraph();
+    });
+  </script>
+</body>
+</html>`;
+}
+function parseDateForFilter(dateStr) {
+    if (!dateStr)
+        return null;
+    const raw = String(dateStr);
+    const date = raw.includes('T') ? new Date(raw) : new Date(`${raw}T00:00:00Z`);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+function filterGraphByPeriod(graph, period) {
+    if (!period || period === true || period === 'all') {
+        return { graph, label: null, invalid: false };
+    }
+    const key = String(period).toLowerCase();
+    const config = PERIOD_CONFIG[key];
+    if (!config) {
+        return { graph, label: null, invalid: true };
+    }
+    const cutoff = Date.now() - config.ms;
+    const nodes = (graph.nodes || []).filter(node => {
+        const date = parseDateForFilter(node.date);
+        return date && date.getTime() >= cutoff;
+    });
+    const nodeIds = new Set(nodes.map(n => n.id));
+    const edges = (graph.edges || []).filter(e => nodeIds.has(e.from) && nodeIds.has(e.to));
+    return {
+        graph: {
+            ...graph,
+            nodes,
+            edges,
+            stats: { nodeCount: nodes.length, edgeCount: edges.length },
+        },
+        label: config.label,
+        invalid: false,
+    };
+}
+function truncateLabel(value, limit = 30) {
+    const text = value ? String(value) : '';
+    if (text.length <= limit)
+        return text;
+    return text.slice(0, limit);
+}
+function escapeMermaidLabel(value) {
+    return String(value)
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\r?\n/g, ' ');
+}
+function sanitizeMermaidId(value) {
+    return String(value || '').replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+function mergeImportantFlags(graph, entries) {
+    if (!entries || entries.length === 0)
+        return graph;
+    const importantMap = new Map();
+    for (const entry of entries) {
+        if (entry && entry.id) {
+            importantMap.set(entry.id, Boolean(entry.important));
+        }
+    }
+    if (importantMap.size === 0)
+        return graph;
+    const nodes = (graph.nodes || []).map(node => {
+        if (importantMap.has(node.id)) {
+            return { ...node, important: importantMap.get(node.id) };
+        }
+        return node;
+    });
+    return { ...graph, nodes };
+}
+function renderMermaid(viewGraph) {
+    const lines = [];
+    lines.push('```mermaid');
+    lines.push('graph LR');
+    const byTag = {};
+    for (const node of viewGraph.nodes || []) {
+        const tag = (node.tags?.[0]) || 'general';
+        if (!byTag[tag])
+            byTag[tag] = [];
+        byTag[tag].push(node);
+    }
+    const tagKeys = Object.keys(byTag).sort((a, b) => a.localeCompare(b));
+    for (const topic of tagKeys) {
+        const topicId = sanitizeMermaidId(topic || 'general');
+        lines.push(`  subgraph ${topicId}`);
+        const nodes = byTag[topic].slice().sort((a, b) => {
+            const aId = String(a.id || '');
+            const bId = String(b.id || '');
+            return aId.localeCompare(bId);
+        });
+        for (const node of nodes) {
+            const baseLabel = truncateLabel(node.summary || node.id || 'Unknown', 30);
+            const label = node.important ? `⭐ ${baseLabel}` : baseLabel;
+            const safeLabel = escapeMermaidLabel(label);
+            const nodeId = sanitizeMermaidId(node.id);
+            lines.push(`    ${nodeId}["${safeLabel}"]`);
+        }
+        lines.push('  end');
+    }
+    const edges = (viewGraph.edges || []).filter(edge => Number(edge.weight) >= 0.5);
+    for (const edge of edges) {
+        const fromId = sanitizeMermaidId(edge.from);
+        const toId = sanitizeMermaidId(edge.to);
+        const weight = Number.isFinite(edge.weight) ? edge.weight : Number(edge.weight);
+        const weightLabel = Number.isFinite(weight) ? weight : edge.weight;
+        lines.push(`  ${fromId} -->|${weightLabel}| ${toId}`);
+    }
+    lines.push('```');
+    return lines.join('\n');
+}
+function renderText(viewGraph, agentId, filtered) {
+    console.log(`# ${agentId} 연결 그래프\n`);
+    if (filtered.label && !filtered.invalid) {
+        console.log(`> (기간 필터: ${filtered.label})`);
+    }
+    console.log(`> 최종 업데이트: ${viewGraph.updated || '-'}`);
+    console.log(`> 노드: ${viewGraph.nodes.length}개 | 엣지: ${viewGraph.edges.length}개\n`);
+    if (viewGraph.nodes.length === 0) {
+        console.log('해당 기간에 해당하는 노드가 없습니다.');
+        return;
+    }
+    const byTag = {};
+    for (const node of viewGraph.nodes) {
+        const tag = (node.tags?.[0]) || 'general';
+        if (!byTag[tag])
+            byTag[tag] = [];
+        byTag[tag].push(node);
+    }
+    console.log(`## 태그별 클러스터\n`);
+    for (const [topic, nodes] of Object.entries(byTag).sort((a, b) => b[1].length - a[1].length)) {
+        console.log(`### ${topic} (${nodes.length}개)`);
+        for (const node of nodes.slice(0, 5)) {
+            const connectionCount = viewGraph.edges.filter(e => e.from === node.id || e.to === node.id).length;
+            console.log(`- [${node.id}] ${node.summary} (연결: ${connectionCount})`);
+        }
+        if (nodes.length > 5) {
+            console.log(`- ... 외 ${nodes.length - 5}개`);
+        }
+        console.log('');
+    }
+    const connectionCounts = {};
+    for (const edge of viewGraph.edges) {
+        connectionCounts[edge.from] = (connectionCounts[edge.from] || 0) + 1;
+        connectionCounts[edge.to] = (connectionCounts[edge.to] || 0) + 1;
+    }
+    const hubs = Object.entries(connectionCounts)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5);
+    if (hubs.length > 0) {
+        console.log(`## 허브 노드 (연결 많은 기억)\n`);
+        const nodeMap = {};
+        viewGraph.nodes.forEach(n => (nodeMap[n.id] = n));
+        for (const [id, count] of hubs) {
+            const node = nodeMap[id];
+            if (node) {
+                console.log(`- [${id}] ${node.summary} - ${count}개 연결`);
+            }
+        }
+    }
+}
+class MindmapEngine {
+    constructor(dataDir) {
+        this.dataDir = dataDir;
+    }
+    getAgentDir(agentId) {
+        return path_1.default.join(this.dataDir, agentId);
+    }
+    getEntriesDir(agentId) {
+        return path_1.default.join(this.getAgentDir(agentId), 'entries');
+    }
+    getGraphPath(agentId) {
+        return path_1.default.join(this.getAgentDir(agentId), 'graph.json');
+    }
+    getHtmlPath() {
+        return path_1.default.join(this.dataDir, 'mindmap.html');
+    }
+    build(agentId, options = {}) {
+        console.log(`🔨 ${agentId} 그래프 빌드 중...\n`);
+        const entriesDir = this.getEntriesDir(agentId);
+        const graph = buildGraph(entriesDir, { edgeThreshold: 0.3, ...options });
+        if (!graph) {
+            console.log('기억이 없습니다.');
+            return;
+        }
+        saveGraph(this.getGraphPath(agentId), graph);
+        console.log(`✅ 그래프 빌드 완료!`);
+        console.log(`   노드: ${graph.stats.nodeCount}개`);
+        console.log(`   엣지: ${graph.stats.edgeCount}개`);
+        console.log(`   파일: ${agentId}/graph.json`);
+        if (graph.edges.length > 0) {
+            console.log(`\n📊 주요 연결 (weight 상위 10개):`);
+            const topEdges = graph.edges.sort((a, b) => b.weight - a.weight).slice(0, 10);
+            const nodeMap = {};
+            graph.nodes.forEach(n => (nodeMap[n.id] = n.summary));
+            for (const edge of topEdges) {
+                const fromSummary = (nodeMap[edge.from] || edge.from).slice(0, 25);
+                const toSummary = (nodeMap[edge.to] || edge.to).slice(0, 25);
+                console.log(`   [${edge.weight}] ${fromSummary}... ↔ ${toSummary}...`);
+            }
+        }
+    }
+    show(agentId, options = {}) {
+        const graph = loadGraph(this.getGraphPath(agentId));
+        if (!graph.nodes || graph.nodes.length === 0) {
+            console.log('그래프가 없습니다. 먼저 build 명령을 실행하세요.');
+            return;
+        }
+        const filtered = filterGraphByPeriod(graph, options.period);
+        if (filtered.invalid) {
+            console.log(`⚠️  알 수 없는 period: ${options.period} (stm|mtm|ltm)`);
+        }
+        let viewGraph = filtered.invalid ? graph : filtered.graph;
+        const entries = loadAllEntries(this.getEntriesDir(agentId));
+        viewGraph = mergeImportantFlags(viewGraph, entries);
+        const format = normalizeFormatOption(options.format);
+        if (format === 'text') {
+            renderText(viewGraph, agentId, filtered);
+            return;
+        }
+        if (!viewGraph.nodes || viewGraph.nodes.length === 0) {
+            console.log('해당 기간에 해당하는 노드가 없습니다.');
+            return;
+        }
+        if (filtered.label && !filtered.invalid) {
+            console.log(`(기간 필터: ${filtered.label})`);
+        }
+        console.log(renderMermaid(viewGraph));
+    }
+    related(agentId, memoryId) {
+        const graph = loadGraph(this.getGraphPath(agentId));
+        if (!graph.nodes || graph.nodes.length === 0) {
+            console.log('그래프가 없습니다. 먼저 build 명령을 실행하세요.');
+            return;
+        }
+        const node = graph.nodes.find(n => n.id === memoryId);
+        if (!node) {
+            console.log(`ID '${memoryId}'를 찾을 수 없습니다.`);
+            return;
+        }
+        console.log(`## 🔗 [${memoryId}] ${node.summary}\n`);
+        console.log(`- 날짜: ${node.date || '-'}`);
+        console.log(`- 태그: ${(node.tags || []).join(', ') || '-'}\n`);
+        const connectedEdges = graph.edges.filter(e => e.from === memoryId || e.to === memoryId);
+        if (connectedEdges.length === 0) {
+            console.log('연결된 기억이 없습니다.');
+            return;
+        }
+        console.log(`### 연결된 기억 (${connectedEdges.length}개)\n`);
+        const nodeMap = {};
+        graph.nodes.forEach(n => (nodeMap[n.id] = n));
+        connectedEdges.sort((a, b) => b.weight - a.weight);
+        for (const edge of connectedEdges) {
+            const otherId = edge.from === memoryId ? edge.to : edge.from;
+            const otherNode = nodeMap[otherId];
+            if (otherNode) {
+                const reasons = edge.reasons.join(', ');
+                console.log(`[${edge.weight}] [${otherId}] ${otherNode.summary}`);
+                console.log(`    └─ 연결 이유: ${reasons}`);
+            }
+        }
+    }
+    add(agentId, fromId, toId, type = 'manual') {
+        const graph = loadGraph(this.getGraphPath(agentId));
+        if (!graph.nodes || graph.nodes.length === 0) {
+            console.log('그래프가 없습니다. 먼저 build 명령을 실행하세요.');
+            return;
+        }
+        const fromNode = graph.nodes.find(n => n.id === fromId);
+        const toNode = graph.nodes.find(n => n.id === toId);
+        if (!fromNode) {
+            console.log(`ID '${fromId}'를 찾을 수 없습니다.`);
+            return;
+        }
+        if (!toNode) {
+            console.log(`ID '${toId}'를 찾을 수 없습니다.`);
+            return;
+        }
+        const existingEdge = graph.edges.find(e => (e.from === fromId && e.to === toId) || (e.from === toId && e.to === fromId));
+        if (existingEdge) {
+            console.log(`이미 연결되어 있습니다: weight ${existingEdge.weight}`);
+            return;
+        }
+        graph.edges.push({
+            from: fromId,
+            to: toId,
+            type,
+            weight: 1.0,
+            reasons: [type],
+            manual: true,
+        });
+        saveGraph(this.getGraphPath(agentId), graph);
+        console.log(`✅ 연결 추가 완료!`);
+        console.log(`   ${(fromNode.summary || '').slice(0, 30)}...`);
+        console.log(`   ↔`);
+        console.log(`   ${(toNode.summary || '').slice(0, 30)}...`);
+    }
+    remove(agentId, fromId, toId) {
+        const graph = loadGraph(this.getGraphPath(agentId));
+        if (!graph.edges || graph.edges.length === 0) {
+            console.log('연결이 없습니다.');
+            return;
+        }
+        const edgeIndex = graph.edges.findIndex(e => (e.from === fromId && e.to === toId) || (e.from === toId && e.to === fromId));
+        if (edgeIndex === -1) {
+            console.log('해당 연결을 찾을 수 없습니다.');
+            return;
+        }
+        graph.edges.splice(edgeIndex, 1);
+        saveGraph(this.getGraphPath(agentId), graph);
+        console.log(`🗑️ 연결 제거 완료: ${fromId} ↔ ${toId}`);
+    }
+    html() {
+        if (!fs_1.default.existsSync(this.dataDir)) {
+            console.log('data 디렉토리가 없습니다.');
+            return;
+        }
+        const agentDirs = fs_1.default.readdirSync(this.dataDir).filter(name => {
+            const dirPath = path_1.default.join(this.dataDir, name);
+            try {
+                return fs_1.default.statSync(dirPath).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+        const agentGraphs = {};
+        let totalNodes = 0;
+        let totalEdges = 0;
+        for (const agentId of agentDirs) {
+            const graph = loadGraph(this.getGraphPath(agentId));
+            if (graph.nodes && graph.nodes.length > 0) {
+                agentGraphs[agentId] = graph;
+                totalNodes += graph.nodes.length;
+                totalEdges += graph.edges.length;
+            }
+        }
+        if (Object.keys(agentGraphs).length === 0) {
+            console.log('그래프가 없습니다. 먼저 build 명령을 실행하세요.');
+            return;
+        }
+        const htmlContent = generateHtml(agentGraphs, {
+            title: 'Memory Graph - All Agents',
+        });
+        if (!htmlContent) {
+            console.log('HTML 생성 실패');
+            return;
+        }
+        const htmlPath = this.getHtmlPath();
+        fs_1.default.writeFileSync(htmlPath, htmlContent, 'utf-8');
+        console.log(`✅ 공용 그래프 시각화 생성 완료!`);
+        console.log(`   파일: ${htmlPath}`);
+        console.log(`   에이전트: ${Object.keys(agentGraphs).length}개`);
+        console.log(`   전체 노드: ${totalNodes}개 | 전체 엣지: ${totalEdges}개`);
+        console.log(`\n브라우저에서 열기: open ${htmlPath}`);
+    }
+    open(agentId) {
+        const htmlPath = this.getHtmlPath();
+        if (!fs_1.default.existsSync(htmlPath)) {
+            console.log('mindmap.html이 없습니다. 먼저 html 명령을 실행하세요.');
+            return;
+        }
+        const url = `file://${htmlPath}${agentId ? '?agent=' + agentId : ''}`;
+        try {
+            (0, child_process_1.execSync)(`osascript -e 'tell application "Google Chrome" to open location "${url}"'`);
+            console.log(`✅ Chrome에서 그래프 열기: ${agentId || '전체'}`);
+        }
+        catch {
+            try {
+                (0, child_process_1.execSync)(`osascript -e 'tell application "Safari" to open location "${url}"'`);
+                console.log(`✅ Safari에서 그래프 열기: ${agentId || '전체'}`);
+            }
+            catch {
+                (0, child_process_1.execSync)(`open "${url}"`);
+                console.log(`✅ 기본 브라우저에서 그래프 열기: ${agentId || '전체'}`);
+            }
+        }
+    }
+}
+exports.MindmapEngine = MindmapEngine;
+function normalizeFormatOption(format) {
+    if (!format || format === true)
+        return 'mermaid';
+    return String(format).toLowerCase();
+}
+//# sourceMappingURL=mindmap.js.map