@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
286 lines • 10.6 kB
JavaScript
/**
* Sync Integration - Integração completa do sistema de sincronização
* Coordena FileWatcher, BidirectionalSync e BackupScheduler
*/
import { createBidirectionalSync } from './bidirectional-sync.js';
import { createBackupScheduler } from './backup-scheduler.js';
import { errorHandler } from './error-handler.js';
import * as path from 'path';
import * as os from 'os';
export class SyncIntegration {
config;
syncManager = null;
backupScheduler = null;
isInitialized = false;
constructor(config) {
this.config = {
...config,
memoryBankRoot: config.memoryBankRoot || this.getDefaultMemoryBankRoot(),
memoryBankBackupRoot: config.memoryBankBackupRoot || this.getDefaultBackupRoot()
};
}
/**
* Inicializa todo o sistema de sincronização
*/
async initialize() {
if (this.isInitialized) {
// console.log('[SyncIntegration] Já inicializado');
return;
}
try {
// console.log('[SyncIntegration] Inicializando sistema de sincronização...');
// console.log(`[SyncIntegration] Projeto: ${this.config.projectName}`);
// console.log(`[SyncIntegration] Local: ${this.config.projectPath}`);
// console.log(`[SyncIntegration] Memory Bank Root: ${this.config.memoryBankRoot}`);
// console.log(`[SyncIntegration] Backup Root: ${this.config.memoryBankBackupRoot}`);
// Inicializa sincronização bidirecional
if (this.config.enableAutoSync) {
await this.initializeSyncManager();
}
// Inicializa backup automático
if (this.config.enableAutoBackup) {
await this.initializeBackupScheduler();
}
this.isInitialized = true;
// console.log('[SyncIntegration] Sistema inicializado com sucesso');
}
catch (error) {
const handledError = errorHandler.handleError(error, {
operation: 'sync-integration-initialize',
projectName: this.config.projectName,
timestamp: Date.now()
});
throw handledError;
}
}
/**
* Para todo o sistema
*/
async shutdown() {
if (!this.isInitialized) {
return;
}
// console.log('[SyncIntegration] Parando sistema de sincronização...');
// Para sincronização
if (this.syncManager) {
await this.syncManager.stop();
this.syncManager = null;
}
// Para backup
if (this.backupScheduler) {
this.backupScheduler.stop();
this.backupScheduler = null;
}
this.isInitialized = false;
// console.log('[SyncIntegration] Sistema parado');
}
/**
* Força sincronização manual
*/
async forceSync() {
if (!this.syncManager) {
throw new Error('Sincronização não está inicializada');
}
await this.syncManager.forceSync();
}
/**
* Sincronização sob demanda - executa uma vez quando chamada
*/
async syncOnDemand() {
if (!this.syncManager) {
// Inicializa temporariamente o sync manager se não existir
await this.initializeSyncManager();
}
if (this.syncManager) {
await this.syncManager.forceSync();
}
}
/**
* Força backup manual
*/
async forceBackup() {
if (!this.backupScheduler) {
throw new Error('Backup não está inicializado');
}
return await this.backupScheduler.forceBackup();
}
/**
* Inicializa o gerenciador de sincronização (sob demanda)
*/
async initializeSyncManager() {
const syncConfig = {
projectName: this.config.projectName,
projectPath: this.config.projectPath,
memoryBankRoot: this.config.memoryBankRoot,
enableAutoSync: false, // Desativado: sincronização sob demanda
conflictResolution: this.config.conflictResolution
};
this.syncManager = createBidirectionalSync(syncConfig);
await this.syncManager.initialize();
// console.log('[SyncIntegration] Sincronização sob demanda ativada');
}
/**
* Inicializa o agendador de backup
*/
async initializeBackupScheduler() {
const backupConfig = {
projectName: this.config.projectName,
projectPath: this.config.projectPath,
memoryBankRoot: this.config.memoryBankRoot,
backupRoot: this.config.memoryBankBackupRoot,
intervalMinutes: this.config.backupIntervalMinutes,
maxBackupsPerMonth: this.config.maxBackupsPerMonth,
enableAutoCleanup: true
};
this.backupScheduler = createBackupScheduler(backupConfig);
this.backupScheduler.start();
// console.log(`[SyncIntegration] Backup automático ativado (${this.config.backupIntervalMinutes} min)`);
}
/**
* Obtém diretório padrão do Memory Bank Root
*/
getDefaultMemoryBankRoot() {
const homeDir = os.homedir();
return path.join(homeDir, '.advanced-memory-bank');
}
/**
* Obtém diretório padrão do Backup Root
*/
getDefaultBackupRoot() {
const homeDir = os.homedir();
return path.join(homeDir, '.advanced-memory-bank-backups');
}
/**
* Obtém estatísticas completas do sistema
*/
getSystemStats() {
return {
isInitialized: this.isInitialized,
sync: this.syncManager ? this.syncManager.getStats() : null,
backup: this.backupScheduler ? this.backupScheduler.getStats() : null,
config: this.config
};
}
/**
* Verifica se o sistema está funcionando corretamente
*/
async healthCheck() {
const issues = [];
let syncStatus = 'disabled';
let backupStatus = 'disabled';
// Verifica sincronização
if (this.config.enableAutoSync) {
if (this.syncManager) {
const syncStats = this.syncManager.getStats();
if (syncStats.isInitialized) {
syncStatus = 'healthy';
if (syncStats.queueSize > 10) {
syncStatus = 'warning';
issues.push(`Fila de sincronização grande: ${syncStats.queueSize} itens`);
}
if (syncStats.conflictCount > 0) {
syncStatus = 'warning';
issues.push(`${syncStats.conflictCount} conflitos detectados`);
}
}
else {
syncStatus = 'error';
issues.push('Sincronização não inicializada');
}
}
else {
syncStatus = 'error';
issues.push('SyncManager não criado');
}
}
// Verifica backup
if (this.config.enableAutoBackup) {
if (this.backupScheduler) {
const backupStats = this.backupScheduler.getStats();
if (backupStats.isRunning) {
backupStatus = 'healthy';
if (backupStats.failedBackups > 0) {
backupStatus = 'warning';
issues.push(`${backupStats.failedBackups} backups falharam`);
}
// Verifica se último backup foi há muito tempo
if (backupStats.lastBackup) {
const timeSinceLastBackup = Date.now() - backupStats.lastBackup.timestamp;
const maxInterval = this.config.backupIntervalMinutes * 60 * 1000 * 2; // 2x o intervalo
if (timeSinceLastBackup > maxInterval) {
backupStatus = 'warning';
issues.push('Último backup foi há muito tempo');
}
}
}
else {
backupStatus = 'error';
issues.push('Backup scheduler não está rodando');
}
}
else {
backupStatus = 'error';
issues.push('BackupScheduler não criado');
}
}
// Determina status geral
let overall = 'healthy';
if (syncStatus === 'error' || backupStatus === 'error') {
overall = 'error';
}
else if (syncStatus === 'warning' || backupStatus === 'warning') {
overall = 'warning';
}
return {
overall,
sync: syncStatus,
backup: backupStatus,
issues
};
}
/**
* Obtém configuração atual
*/
getConfig() {
return { ...this.config };
}
/**
* Atualiza configuração (requer reinicialização)
*/
updateConfig(newConfig) {
this.config = { ...this.config, ...newConfig };
console.log('[SyncIntegration] Configuração atualizada - reinicialização necessária');
}
}
// Factory function com configuração padrão
export function createSyncIntegration(projectName, projectPath, options = {}) {
const defaultConfig = {
projectName,
projectPath,
enableAutoSync: true,
enableAutoBackup: true,
backupIntervalMinutes: 30, // 30 minutos conforme especificado
maxBackupsPerMonth: 50, // Máximo de 50 backups por mês
conflictResolution: 'newest-wins', // Regra 3: mais recente ganha
...options
};
return new SyncIntegration(defaultConfig);
}
// Função para integrar com as ferramentas MCP existentes
export function integrateSyncWithMCPTools(projectName, projectPath, memoryBankRoot, memoryBankBackupRoot) {
const config = {
enableAutoSync: false, // Desativado: sincronização sob demanda
enableAutoBackup: true,
backupIntervalMinutes: 30,
maxBackupsPerMonth: 100,
conflictResolution: 'newest-wins'
};
if (memoryBankRoot) {
config.memoryBankRoot = memoryBankRoot;
}
if (memoryBankBackupRoot) {
config.memoryBankBackupRoot = memoryBankBackupRoot;
}
return createSyncIntegration(projectName, projectPath, config);
}
//# sourceMappingURL=sync-integration.js.map