@andrebuzeli/advanced-memory-markdown-mcp
Version:
Advanced Memory Bank MCP v3.1.5 - Sistema avançado de gerenciamento de memória com isolamento de projetos por IDE, sincronização sob demanda, backup a cada 30min, apenas arquivos .md principais sincronizados, pasta reasoning temporária com limpeza automát
215 lines • 9.31 kB
JavaScript
/**
* Visualize Manager - Sistema de visualização e gráficos das memórias
* Gera visualizações de relacionamentos entre tópicos, planos e memórias
*/
export class VisualizeManager {
topicManager;
planningManager;
constructor(topicManager, planningManager) {
this.topicManager = topicManager;
this.planningManager = planningManager;
}
async executeVisualizeAction(action, projectName, params = {}) {
switch (action) {
case 'graph':
return this.generateGraph(projectName, params);
case 'timeline':
return this.generateTimeline(projectName, params);
case 'connections':
return this.generateConnections(projectName, params);
default:
throw new Error(`Ação de visualização desconhecida: ${action}`);
}
}
async generateGraph(projectName, params = {}) {
const { includeTopics = true, includePlans = true, minImportance = 1, maxNodes = 100 } = params;
const nodes = [];
const edges = [];
const nodeIds = new Set();
if (includeTopics) {
const memories = await this.topicManager.listAllTopicMemories(projectName);
for (const [topicName, memory] of Object.entries(memories)) {
if (memory.importance >= minImportance && nodes.length < maxNodes) {
const nodeId = `topic_${topicName}`;
if (!nodeIds.has(nodeId)) {
nodes.push({
id: nodeId,
title: topicName,
type: 'topic',
importance: memory.importance,
connections: this.extractConnections(memory.content, memory.tags),
metadata: {
created: memory.timestamp,
modified: memory.lastModified,
tags: memory.tags,
project: projectName
}
});
nodeIds.add(nodeId);
}
}
}
}
if (includePlans) {
const tasks = await this.planningManager.listTasks(projectName);
for (const task of tasks) {
const importance = task.priority === 'High' ? 8 : task.priority === 'Medium' ? 5 : 2;
if (importance >= minImportance && nodes.length < maxNodes) {
const nodeId = `task_${task.id}`;
if (!nodeIds.has(nodeId)) {
nodes.push({
id: nodeId,
title: task.description,
type: 'plan',
importance: importance,
connections: [],
metadata: {
created: task.created,
modified: task.modified,
tags: [], // Tags para tarefas podem ser implementadas depois
project: projectName
}
});
nodeIds.add(nodeId);
}
}
}
}
this.generateEdges(nodes, edges);
return {
nodes: nodes.slice(0, maxNodes),
edges
};
}
async generateTimeline(projectName, params = {}) {
const { startDate = 0, endDate = Date.now(), includeMemories = true, includePlans = true } = params;
const events = [];
if (includeMemories) {
const memories = await this.topicManager.listAllTopicMemories(projectName);
for (const [topicName, memory] of Object.entries(memories)) {
if (memory.timestamp >= startDate && memory.timestamp <= endDate) {
events.push({
id: `memory_${topicName}`,
title: `Memória: ${topicName}`,
type: 'memory',
date: memory.timestamp,
importance: memory.importance,
description: memory.content.substring(0, 100) + '...',
tags: memory.tags
});
}
if (memory.lastModified !== memory.timestamp && memory.lastModified >= startDate && memory.lastModified <= endDate) {
events.push({
id: `memory_mod_${topicName}`,
title: `Atualização: ${topicName}`,
type: 'memory',
date: memory.lastModified,
importance: memory.importance,
description: 'Memória atualizada',
tags: [...memory.tags, 'update']
});
}
}
}
if (includePlans) {
const tasks = await this.planningManager.listTasks(projectName);
for (const task of tasks) {
if (task.created >= startDate && task.created <= endDate) {
events.push({
id: `task_${task.id}`,
title: `Tarefa: ${task.description}`,
type: 'plan',
date: task.created,
importance: task.priority === 'High' ? 8 : task.priority === 'Medium' ? 5 : 2,
description: task.description,
tags: []
});
}
if (task.modified !== task.created && task.modified >= startDate && task.modified <= endDate) {
events.push({
id: `task_mod_${task.id}`,
title: `Atualização da Tarefa: ${task.description}`,
type: 'task',
date: task.modified,
importance: task.priority === 'High' ? 8 : task.priority === 'Medium' ? 5 : 2,
description: 'Tarefa atualizada',
tags: ['update']
});
}
}
}
events.sort((a, b) => a.date - b.date);
const timespan = endDate - startDate;
return {
events,
summary: {
totalEvents: events.length,
timespan,
}
};
}
async generateConnections(projectName, params = {}) {
const graph = await this.generateGraph(projectName, { maxNodes: 200 });
const connections = [];
for (const edge of graph.edges) {
connections.push({
from: edge.from,
to: edge.to,
type: edge.type,
strength: edge.weight,
path: [edge.from, edge.to]
});
}
return {
connections,
clusters: [], // Análise de cluster pode ser implementada depois
stats: {
totalConnections: connections.length,
strongestConnection: Math.max(...connections.map(c => c.strength), 0),
averageConnections: connections.length / Math.max(graph.nodes.length, 1),
isolatedElements: graph.nodes.length - new Set(connections.flatMap(c => [c.from, c.to])).size
}
};
}
extractConnections(content, tags) {
const connections = [];
const contentLower = content.toLowerCase();
const fixedTopics = ['summary', 'libraries', 'change-history', 'architecture', 'todo', 'bugs', 'features', 'documentation', 'testing', 'deployment'];
for (const topic of fixedTopics) {
if (contentLower.includes(topic)) {
connections.push(topic);
}
}
connections.push(...tags);
return [...new Set(connections)];
}
generateEdges(nodes, edges) {
for (let i = 0; i < nodes.length; i++) {
for (let j = i + 1; j < nodes.length; j++) {
const nodeA = nodes[i];
const nodeB = nodes[j];
if (!nodeA || !nodeB)
continue;
const commonTags = (nodeA.metadata.tags || []).filter(tag => (nodeB.metadata.tags || []).includes(tag));
if (commonTags.length > 0) {
edges.push({
from: nodeA.id,
to: nodeB.id,
weight: commonTags.length,
type: 'related'
});
}
if ((nodeA.connections || []).some(conn => nodeB.id.includes(conn)) ||
(nodeB.connections || []).some(conn => nodeA.id.includes(conn))) {
edges.push({
from: nodeA.id,
to: nodeB.id,
weight: 2,
type: 'reference'
});
}
}
}
}
}
//# sourceMappingURL=visualize-manager.js.map