mcp-adr-analysis-server 2.0.21 → 2.0.24

package/dist/src/utils/memory-migration-manager.js

@@ -0,0 +1,834 @@
+/**
+ * Memory Migration Manager
+ *
+ * Comprehensive migration strategy for transitioning existing data to memory entities.
+ * Handles deployment history, troubleshooting data, knowledge graphs, and other legacy
+ * systems with zero data loss and rollback capabilities.
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { existsSync } from 'fs';
+import crypto from 'crypto';
+import { EnhancedLogger } from './enhanced-logging.js';
+import { loadConfig } from './config.js';
+import { McpAdrError } from '../types/index.js';
+export class MemoryMigrationManager {
+    memoryManager;
+    logger;
+    config;
+    projectConfig;
+    migrationBackupDir;
+    constructor(memoryManager, config) {
+        this.memoryManager = memoryManager;
+        this.logger = new EnhancedLogger();
+        this.projectConfig = loadConfig();
+        this.config = {
+            enableBackup: true,
+            backupDirectory: path.join(this.projectConfig.projectPath, '.mcp-migration-backups'),
+            migrationBatchSize: 50,
+            validateIntegrity: true,
+            enableRollback: true,
+            logLevel: 'standard',
+            ...config,
+        };
+        this.migrationBackupDir = path.join(this.config.backupDirectory, `migration-${new Date().toISOString().replace(/[:.]/g, '-')}`);
+    }
+    /**
+     * Migrate all existing data to memory entities
+     */
+    async migrateAllExistingData() {
+        const startTime = new Date();
+        this.logger.info('Starting comprehensive data migration to memory entities', 'MemoryMigrationManager');
+        const result = {
+            success: true,
+            migratedCount: 0,
+            failedCount: 0,
+            errors: [],
+            performance: {
+                startTime: startTime.toISOString(),
+                endTime: '',
+                durationMs: 0,
+                throughputPerSecond: 0,
+            },
+        };
+        try {
+            // Create backup if enabled
+            if (this.config.enableBackup) {
+                result.backupPath = await this.createMigrationBackup();
+                this.logger.info('Migration backup created', 'MemoryMigrationManager', {
+                    backupPath: result.backupPath,
+                });
+            }
+            // Define migration sources
+            const deploymentHistoryPath = path.join(this.projectConfig.projectPath, '.mcp-adr-cache', 'deployment-history.json');
+            const migrationSources = [
+                {
+                    path: deploymentHistoryPath,
+                    type: 'deployment_history',
+                    format: 'json',
+                    migrationStrategy: 'full',
+                },
+                {
+                    path: path.join(this.projectConfig.projectPath, '.mcp-adr-cache', 'knowledge-graph-snapshots.json'),
+                    type: 'knowledge_graph',
+                    format: 'json',
+                    migrationStrategy: 'selective',
+                },
+                {
+                    path: path.join(this.projectConfig.projectPath, 'docs', 'adrs'),
+                    type: 'adr_collection',
+                    format: 'markdown',
+                    migrationStrategy: 'full',
+                },
+                {
+                    path: path.join(this.projectConfig.projectPath, '.mcp-adr-cache'),
+                    type: 'troubleshooting_sessions',
+                    format: 'json',
+                    migrationStrategy: 'incremental',
+                },
+            ];
+            // Migrate each data source
+            for (const source of migrationSources) {
+                try {
+                    const sourceResult = await this.migrateDataSource(source);
+                    result.migratedCount += sourceResult.migratedCount;
+                    result.failedCount += sourceResult.failedCount;
+                    result.errors.push(...sourceResult.errors);
+                }
+                catch (error) {
+                    result.failedCount++;
+                    result.errors.push({
+                        source: source.path,
+                        error: error instanceof Error ? error.message : String(error),
+                        data: undefined,
+                    });
+                    this.logger.error('Failed to migrate data source', 'MemoryMigrationManager');
+                }
+            }
+            // Create cross-tool relationships after migration
+            if (result.migratedCount > 0) {
+                try {
+                    const relationshipResult = await this.memoryManager.createCrossToolRelationships();
+                    this.logger.info('Cross-tool relationships created post-migration', 'MemoryMigrationManager', {
+                        suggestedRelationships: relationshipResult.suggestedRelationships.length,
+                        autoCreated: relationshipResult.autoCreatedCount,
+                    });
+                }
+                catch (error) {
+                    this.logger.warn('Failed to create cross-tool relationships', 'MemoryMigrationManager', {
+                        error,
+                    });
+                }
+            }
+            // Validate migration if enabled
+            if (this.config.validateIntegrity) {
+                const validationResult = await this.validateMigrationIntegrity(result.migratedCount);
+                if (!validationResult.isValid) {
+                    result.success = false;
+                    result.errors.push({
+                        source: 'validation',
+                        error: 'Migration integrity validation failed',
+                        data: validationResult,
+                    });
+                }
+            }
+            // Generate rollback plan if enabled
+            if (this.config.enableRollback) {
+                result.rollbackPlan = await this.generateRollbackPlan(result);
+            }
+        }
+        catch (error) {
+            result.success = false;
+            result.errors.push({
+                source: 'migration_manager',
+                error: error instanceof Error ? error.message : String(error),
+            });
+            this.logger.error('Migration failed with critical error', 'MemoryMigrationManager');
+        }
+        // Calculate performance metrics
+        const endTime = new Date();
+        result.performance.endTime = endTime.toISOString();
+        result.performance.durationMs = endTime.getTime() - startTime.getTime();
+        result.performance.throughputPerSecond =
+            result.migratedCount / (result.performance.durationMs / 1000);
+        // Log final results
+        this.logger.info('Migration completed', 'MemoryMigrationManager', {
+            success: result.success,
+            migratedCount: result.migratedCount,
+            failedCount: result.failedCount,
+            durationMs: result.performance.durationMs,
+            throughputPerSecond: result.performance.throughputPerSecond.toFixed(2),
+        });
+        return result;
+    }
+    /**
+     * Migrate a specific data source to memory entities
+     */
+    async migrateDataSource(source) {
+        this.logger.info('Starting data source migration', 'MemoryMigrationManager', {
+            path: source.path,
+            type: source.type,
+        });
+        const result = {
+            success: true,
+            migratedCount: 0,
+            failedCount: 0,
+            errors: [],
+            performance: {
+                startTime: new Date().toISOString(),
+                endTime: '',
+                durationMs: 0,
+                throughputPerSecond: 0,
+            },
+        };
+        if (!existsSync(source.path)) {
+            this.logger.info('Data source does not exist, skipping', 'MemoryMigrationManager', {
+                path: source.path,
+            });
+            return result;
+        }
+        try {
+            switch (source.type) {
+                case 'deployment_history':
+                    const deploymentResult = await this.migrateDeploymentHistory(source.path);
+                    Object.assign(result, deploymentResult);
+                    break;
+                case 'knowledge_graph':
+                    const knowledgeResult = await this.migrateKnowledgeGraph(source.path);
+                    Object.assign(result, knowledgeResult);
+                    break;
+                case 'adr_collection':
+                    const adrResult = await this.migrateAdrCollection(source.path);
+                    Object.assign(result, adrResult);
+                    break;
+                case 'troubleshooting_sessions':
+                    const troubleshootingResult = await this.migrateTroubleshootingSessions(source.path);
+                    Object.assign(result, troubleshootingResult);
+                    break;
+                default:
+                    this.logger.warn('Unknown data source type', 'MemoryMigrationManager', {
+                        type: source.type,
+                    });
+            }
+        }
+        catch (error) {
+            result.success = false;
+            result.errors.push({
+                source: source.path,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        return result;
+    }
+    /**
+     * Migrate deployment history JSON files to deployment assessment memory entities
+     */
+    async migrateDeploymentHistory(historyPath) {
+        try {
+            const historyData = JSON.parse(await fs.readFile(historyPath, 'utf-8'));
+            const deployments = Array.isArray(historyData) ? historyData : historyData.deployments || [];
+            let migratedCount = 0;
+            const errors = [];
+            for (const deployment of deployments) {
+                try {
+                    const memoryEntity = {
+                        id: crypto.randomUUID(),
+                        type: 'deployment_assessment',
+                        title: `Migrated Deployment Assessment - ${deployment.environment || 'Unknown'}`,
+                        description: `Deployment assessment migrated from legacy JSON data: ${deployment.timestamp || 'Unknown date'}`,
+                        confidence: 0.8,
+                        relevance: 0.7,
+                        tags: ['migrated', 'deployment', deployment.environment || 'unknown'],
+                        created: deployment.timestamp || new Date().toISOString(),
+                        lastModified: new Date().toISOString(),
+                        version: 1,
+                        context: {
+                            technicalStack: deployment.technicalStack || [],
+                            environmentalFactors: [deployment.environment || 'unknown'],
+                            stakeholders: ['migration-tool'],
+                        },
+                        relationships: [],
+                        accessPattern: {
+                            accessCount: 1,
+                            lastAccessed: new Date().toISOString(),
+                            accessContext: ['migration'],
+                        },
+                        evolution: {
+                            origin: 'imported',
+                            transformations: [
+                                {
+                                    timestamp: new Date().toISOString(),
+                                    type: 'migration',
+                                    description: `Migrated from deployment-history.json`,
+                                    agent: 'MemoryMigrationManager',
+                                },
+                            ],
+                        },
+                        validation: {
+                            isVerified: false,
+                            verificationMethod: 'automatic-migration',
+                            verificationTimestamp: new Date().toISOString(),
+                        },
+                        assessmentData: {
+                            environment: this.mapEnvironmentType(deployment.environment),
+                            readinessScore: deployment.readinessScore || 0.5,
+                            validationResults: {
+                                testResults: {
+                                    passed: deployment.testsPassed || 0,
+                                    failed: deployment.testsFailed || 0,
+                                    coverage: deployment.testCoverage || 0.0,
+                                    criticalFailures: deployment.criticalFailures || [],
+                                },
+                                securityValidation: {
+                                    vulnerabilities: deployment.securityIssues || 0,
+                                    securityScore: deployment.securityScore || 0.5,
+                                    criticalIssues: deployment.securityCriticalIssues || [],
+                                },
+                                performanceValidation: {
+                                    performanceScore: deployment.performanceScore || 0.5,
+                                    bottlenecks: deployment.performanceBottlenecks || [],
+                                    resourceUtilization: deployment.resourceUtilization || {},
+                                },
+                            },
+                            blockingIssues: (deployment.blockers || []).map((blocker) => ({
+                                issue: blocker.issue || blocker,
+                                severity: blocker.severity || 'medium',
+                                category: blocker.category || 'configuration',
+                                resolution: blocker.resolution,
+                                estimatedEffort: blocker.effort,
+                            })),
+                            deploymentStrategy: {
+                                type: deployment.strategy || 'rolling',
+                                rollbackPlan: deployment.rollbackPlan || 'Standard rollback procedure',
+                                monitoringPlan: deployment.monitoringPlan || 'Standard monitoring',
+                                estimatedDowntime: deployment.estimatedDowntime,
+                            },
+                            complianceChecks: {
+                                adrCompliance: deployment.adrCompliance || 0.5,
+                                regulatoryCompliance: deployment.complianceChecks || [],
+                                auditTrail: deployment.auditTrail || [`Migrated from ${historyPath}`],
+                            },
+                        },
+                    };
+                    await this.memoryManager.upsertEntity(memoryEntity);
+                    migratedCount++;
+                }
+                catch (error) {
+                    this.logger.error('Failed to migrate deployment', 'MemoryMigrationManager', error instanceof Error ? error : new Error(String(error)));
+                    errors.push({
+                        source: 'deployment',
+                        error: error instanceof Error ? error.message : String(error),
+                        data: deployment,
+                    });
+                }
+            }
+            return { migratedCount, failedCount: errors.length, errors };
+        }
+        catch (error) {
+            this.logger.error('Critical error in deployment history migration', 'MemoryMigrationManager', error instanceof Error ? error : new Error(String(error)));
+            throw new McpAdrError(`Failed to migrate deployment history: ${error instanceof Error ? error.message : String(error)}`, 'MIGRATION_ERROR');
+        }
+    }
+    /**
+     * Migrate knowledge graph snapshots to architectural decision memory entities
+     */
+    async migrateKnowledgeGraph(snapshotsPath) {
+        try {
+            const snapshotsData = JSON.parse(await fs.readFile(snapshotsPath, 'utf-8'));
+            const snapshots = Array.isArray(snapshotsData) ? snapshotsData : [snapshotsData];
+            let migratedCount = 0;
+            const errors = [];
+            for (const snapshot of snapshots) {
+                if (snapshot.adrs) {
+                    for (const adr of snapshot.adrs) {
+                        try {
+                            const memoryEntity = {
+                                id: crypto.randomUUID(),
+                                type: 'architectural_decision',
+                                title: adr.title || `Migrated ADR - ${adr.number || 'Unknown'}`,
+                                description: adr.content || 'Architectural decision migrated from knowledge graph',
+                                confidence: 0.9,
+                                relevance: adr.importance || 0.8,
+                                tags: ['migrated', 'adr', ...(adr.tags || [])],
+                                created: adr.created || new Date().toISOString(),
+                                lastModified: adr.lastModified || new Date().toISOString(),
+                                version: adr.version || 1,
+                                context: {
+                                    technicalStack: adr.technicalStack || [],
+                                    environmentalFactors: adr.environmentalFactors || [],
+                                    stakeholders: adr.stakeholders || ['migration-tool'],
+                                },
+                                relationships: [],
+                                accessPattern: {
+                                    accessCount: 1,
+                                    lastAccessed: new Date().toISOString(),
+                                    accessContext: ['migration'],
+                                },
+                                evolution: {
+                                    origin: 'imported',
+                                    transformations: [
+                                        {
+                                            timestamp: new Date().toISOString(),
+                                            type: 'migration',
+                                            description: `Migrated from knowledge graph snapshot`,
+                                            agent: 'MemoryMigrationManager',
+                                        },
+                                    ],
+                                },
+                                validation: {
+                                    isVerified: true,
+                                    verificationMethod: 'knowledge-graph-import',
+                                    verificationTimestamp: new Date().toISOString(),
+                                },
+                                decisionData: {
+                                    status: adr.status || 'accepted',
+                                    context: adr.context || 'Migrated from knowledge graph',
+                                    decision: adr.decision || adr.title || 'Decision details not available',
+                                    consequences: {
+                                        positive: adr.positiveConsequences || [],
+                                        negative: adr.negativeConsequences || [],
+                                        risks: adr.risks || [],
+                                    },
+                                    alternatives: (adr.alternatives || []).map((alt) => ({
+                                        name: alt.name || alt,
+                                        description: alt.description || '',
+                                        tradeoffs: alt.tradeoffs || '',
+                                    })),
+                                    implementationStatus: adr.implementationStatus || 'unknown',
+                                    implementationTasks: adr.implementationTasks || [],
+                                    reviewHistory: adr.reviewHistory || [],
+                                },
+                            };
+                            await this.memoryManager.upsertEntity(memoryEntity);
+                            migratedCount++;
+                            if (this.config.logLevel === 'verbose') {
+                                this.logger.debug('Migrated ADR from knowledge graph', 'MemoryMigrationManager', {
+                                    id: memoryEntity.id,
+                                    title: adr.title,
+                                });
+                            }
+                        }
+                        catch (error) {
+                            errors.push({
+                                source: 'knowledge_graph_adr',
+                                error: error instanceof Error ? error.message : String(error),
+                                data: adr,
+                            });
+                        }
+                    }
+                }
+            }
+            return { migratedCount, failedCount: errors.length, errors };
+        }
+        catch (error) {
+            throw new McpAdrError(`Failed to migrate knowledge graph: ${error instanceof Error ? error.message : String(error)}`, 'MIGRATION_ERROR');
+        }
+    }
+    /**
+     * Migrate ADR markdown files to architectural decision memory entities
+     */
+    async migrateAdrCollection(adrDirectory) {
+        try {
+            const files = await fs.readdir(adrDirectory);
+            const adrFiles = files.filter(file => file.endsWith('.md') && file.match(/^\d+/));
+            let migratedCount = 0;
+            const errors = [];
+            for (const file of adrFiles) {
+                try {
+                    const filePath = path.join(adrDirectory, file);
+                    const content = await fs.readFile(filePath, 'utf-8');
+                    const adrData = this.parseAdrMarkdown(content, file);
+                    const memoryEntity = {
+                        id: crypto.randomUUID(),
+                        type: 'architectural_decision',
+                        title: adrData.title,
+                        description: adrData.description,
+                        confidence: 0.95, // High confidence for formal ADR documents
+                        relevance: 0.9,
+                        tags: ['migrated', 'adr', 'formal', ...adrData.tags],
+                        created: adrData.created || new Date().toISOString(),
+                        lastModified: new Date().toISOString(),
+                        version: 1,
+                        context: {
+                            technicalStack: adrData.technicalStack || [],
+                            environmentalFactors: adrData.environmentalFactors || [],
+                            stakeholders: adrData.stakeholders || ['architecture-team'],
+                        },
+                        relationships: [],
+                        accessPattern: {
+                            accessCount: 1,
+                            lastAccessed: new Date().toISOString(),
+                            accessContext: ['migration'],
+                        },
+                        evolution: {
+                            origin: 'imported',
+                            transformations: [
+                                {
+                                    timestamp: new Date().toISOString(),
+                                    type: 'migration',
+                                    description: `Migrated from ADR markdown file: ${file}`,
+                                    agent: 'MemoryMigrationManager',
+                                },
+                            ],
+                        },
+                        validation: {
+                            isVerified: true,
+                            verificationMethod: 'adr-markdown-import',
+                            verificationTimestamp: new Date().toISOString(),
+                        },
+                        decisionData: {
+                            status: adrData.status,
+                            context: adrData.context,
+                            decision: adrData.decision,
+                            consequences: adrData.consequences,
+                            alternatives: adrData.alternatives,
+                            implementationStatus: adrData.implementationStatus || 'unknown',
+                            implementationTasks: adrData.implementationTasks || [],
+                            reviewHistory: [],
+                        },
+                    };
+                    await this.memoryManager.upsertEntity(memoryEntity);
+                    migratedCount++;
+                    if (this.config.logLevel === 'verbose') {
+                        this.logger.debug('Migrated ADR markdown file', 'MemoryMigrationManager', {
+                            id: memoryEntity.id,
+                            file,
+                            title: adrData.title,
+                        });
+                    }
+                }
+                catch (error) {
+                    errors.push({
+                        source: file,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            return { migratedCount, failedCount: errors.length, errors };
+        }
+        catch (error) {
+            throw new McpAdrError(`Failed to migrate ADR collection: ${error instanceof Error ? error.message : String(error)}`, 'MIGRATION_ERROR');
+        }
+    }
+    /**
+     * Migrate troubleshooting session data
+     */
+    async migrateTroubleshootingSessions(cacheDirectory) {
+        try {
+            const files = await fs.readdir(cacheDirectory);
+            const sessionFiles = files.filter(file => file.includes('troubleshoot') || file.includes('session') || file.includes('debug'));
+            let migratedCount = 0;
+            const errors = [];
+            for (const file of sessionFiles) {
+                try {
+                    if (file.endsWith('.json')) {
+                        const filePath = path.join(cacheDirectory, file);
+                        const sessionData = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+                        const memoryEntity = {
+                            id: crypto.randomUUID(),
+                            type: 'troubleshooting_session',
+                            title: `Migrated Troubleshooting Session - ${file}`,
+                            description: sessionData.description || 'Troubleshooting session migrated from cache',
+                            confidence: 0.7,
+                            relevance: 0.8,
+                            tags: ['migrated', 'troubleshooting', ...(sessionData.tags || [])],
+                            created: sessionData.timestamp || new Date().toISOString(),
+                            lastModified: new Date().toISOString(),
+                            version: 1,
+                            context: {
+                                technicalStack: sessionData.technicalStack || [],
+                                environmentalFactors: sessionData.environment ? [sessionData.environment] : [],
+                                stakeholders: ['migration-tool'],
+                            },
+                            relationships: [],
+                            accessPattern: {
+                                accessCount: 1,
+                                lastAccessed: new Date().toISOString(),
+                                accessContext: ['migration'],
+                            },
+                            evolution: {
+                                origin: 'imported',
+                                transformations: [
+                                    {
+                                        timestamp: new Date().toISOString(),
+                                        type: 'migration',
+                                        description: `Migrated from troubleshooting cache file: ${file}`,
+                                        agent: 'MemoryMigrationManager',
+                                    },
+                                ],
+                            },
+                            validation: {
+                                isVerified: false,
+                                verificationMethod: 'cache-import',
+                                verificationTimestamp: new Date().toISOString(),
+                            },
+                            sessionData: {
+                                failurePattern: {
+                                    failureType: sessionData.failureType || 'unknown',
+                                    errorSignature: sessionData.errorSignature || sessionData.error || 'Unknown error',
+                                    frequency: sessionData.frequency || 1,
+                                    environments: sessionData.environments || [sessionData.environment || 'unknown'],
+                                },
+                                failureDetails: {
+                                    errorMessage: sessionData.errorMessage || sessionData.error || 'No error message available',
+                                    environment: sessionData.environment || 'unknown',
+                                },
+                                analysisSteps: sessionData.steps || sessionData.analysisSteps || [],
+                                solutionEffectiveness: sessionData.effectiveness || 0.5,
+                                preventionMeasures: sessionData.prevention || [],
+                                relatedADRs: sessionData.relatedADRs || [],
+                                environmentContext: {
+                                    environment: sessionData.environment || 'unknown',
+                                },
+                                followUpActions: sessionData.followUpActions || [],
+                            },
+                        };
+                        await this.memoryManager.upsertEntity(memoryEntity);
+                        migratedCount++;
+                    }
+                }
+                catch (error) {
+                    errors.push({
+                        source: file,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            return { migratedCount, failedCount: errors.length, errors };
+        }
+        catch (error) {
+            throw new McpAdrError(`Failed to migrate troubleshooting sessions: ${error instanceof Error ? error.message : String(error)}`, 'MIGRATION_ERROR');
+        }
+    }
+    /**
+     * Create backup of existing data before migration
+     */
+    async createMigrationBackup() {
+        await fs.mkdir(this.migrationBackupDir, { recursive: true });
+        const cacheDir = path.join(this.projectConfig.projectPath, '.mcp-adr-cache');
+        const docsDir = path.join(this.projectConfig.projectPath, 'docs');
+        // Backup cache directory
+        if (existsSync(cacheDir)) {
+            await this.copyDirectory(cacheDir, path.join(this.migrationBackupDir, 'cache'));
+        }
+        // Backup docs directory
+        if (existsSync(docsDir)) {
+            await this.copyDirectory(docsDir, path.join(this.migrationBackupDir, 'docs'));
+        }
+        // Create backup manifest
+        const manifest = {
+            timestamp: new Date().toISOString(),
+            migrationVersion: '1.0.0',
+            projectPath: this.projectConfig.projectPath,
+            backupContents: {
+                cache: existsSync(cacheDir),
+                docs: existsSync(docsDir),
+            },
+        };
+        await fs.writeFile(path.join(this.migrationBackupDir, 'backup-manifest.json'), JSON.stringify(manifest, null, 2));
+        return this.migrationBackupDir;
+    }
+    /**
+     * Validate migration integrity
+     */
+    async validateMigrationIntegrity(expectedCount) {
+        const queryResult = await this.memoryManager.queryEntities({});
+        const issues = [];
+        const actualCount = queryResult.entities.length;
+        // Check entity count expectations
+        if (actualCount === 0 && expectedCount > 0) {
+            issues.push('No entities found after migration');
+        }
+        // Validate entity structure
+        for (const entity of queryResult.entities.slice(0, 10)) {
+            // Sample first 10
+            if (!entity.id || !entity.type || !entity.title) {
+                issues.push(`Invalid entity structure: ${entity.id}`);
+            }
+        }
+        return {
+            isValid: issues.length === 0,
+            actualCount,
+            issues,
+        };
+    }
+    /**
+     * Generate rollback plan
+     */
+    async generateRollbackPlan(migrationResult) {
+        const rollbackSteps = [
+            '# Migration Rollback Plan',
+            '',
+            `Generated: ${new Date().toISOString()}`,
+            `Migration ID: ${path.basename(this.migrationBackupDir)}`,
+            '',
+            '## Steps to Rollback:',
+            '',
+            '1. Stop the MCP ADR Analysis Server',
+            '2. Clear memory entities:',
+            '   ```bash',
+            `   rm -rf "${path.join(this.projectConfig.projectPath, '.mcp-adr-memory')}"`,
+            '   ```',
+            '',
+            '3. Restore backup data:',
+            '   ```bash',
+        ];
+        if (migrationResult.backupPath) {
+            rollbackSteps.push(`   cp -r "${path.join(migrationResult.backupPath, 'cache')}" "${path.join(this.projectConfig.projectPath, '.mcp-adr-cache')}"`, `   cp -r "${path.join(migrationResult.backupPath, 'docs')}" "${path.join(this.projectConfig.projectPath, 'docs')}"`);
+        }
+        rollbackSteps.push('   ```', '', '4. Restart the server', '', '## Verification:', '- Check that legacy cache files are restored', '- Verify ADR documents are accessible', '- Confirm troubleshooting history is available');
+        const rollbackContent = rollbackSteps.join('\n');
+        // Save rollback plan
+        const rollbackPath = path.join(this.migrationBackupDir, 'rollback-plan.md');
+        await fs.writeFile(rollbackPath, rollbackContent);
+        return rollbackPath;
+    }
+    /**
+     * Helper methods
+     */
+    async copyDirectory(src, dest) {
+        await fs.mkdir(dest, { recursive: true });
+        const entries = await fs.readdir(src, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+                await this.copyDirectory(srcPath, destPath);
+            }
+            else {
+                await fs.copyFile(srcPath, destPath);
+            }
+        }
+    }
+    mapEnvironmentType(env) {
+        const envLower = (env || '').toLowerCase();
+        if (envLower.includes('prod'))
+            return 'production';
+        if (envLower.includes('stag'))
+            return 'staging';
+        if (envLower.includes('test'))
+            return 'testing';
+        return 'development';
+    }
+    parseAdrMarkdown(content, filename) {
+        const lines = content.split('\n');
+        const result = {
+            title: filename.replace(/^\d+[-_]/, '').replace(/\.md$/, ''),
+            status: 'accepted',
+            context: '',
+            decision: '',
+            consequences: { positive: [], negative: [], risks: [] },
+            alternatives: [],
+            tags: [],
+            technicalStack: [],
+            environmentalFactors: [],
+            stakeholders: [],
+        };
+        let currentSection = '';
+        let currentContent = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Extract title
+            if (trimmed.startsWith('# ')) {
+                result.title = trimmed.substring(2);
+                continue;
+            }
+            // Extract status
+            if (trimmed.toLowerCase().includes('status')) {
+                const statusMatch = trimmed.match(/status[:\s]*(\w+)/i);
+                if (statusMatch && statusMatch[1]) {
+                    result.status = statusMatch[1].toLowerCase();
+                }
+                continue;
+            }
+            // Extract sections
+            if (trimmed.startsWith('## ')) {
+                // Process previous section
+                if (currentSection && currentContent.length > 0) {
+                    const sectionContent = currentContent.join('\n').trim();
+                    switch (currentSection.toLowerCase()) {
+                        case 'context':
+                            result.context = sectionContent;
+                            break;
+                        case 'decision':
+                            result.decision = sectionContent;
+                            break;
+                        case 'consequences':
+                            result.consequences = this.parseConsequences(sectionContent);
+                            break;
+                        case 'alternatives':
+                            result.alternatives = this.parseAlternatives(sectionContent);
+                            break;
+                    }
+                }
+                currentSection = trimmed.substring(3);
+                currentContent = [];
+            }
+            else if (currentSection) {
+                currentContent.push(line);
+            }
+        }
+        // Process last section
+        if (currentSection && currentContent.length > 0) {
+            const sectionContent = currentContent.join('\n').trim();
+            switch (currentSection.toLowerCase()) {
+                case 'context':
+                    result.context = sectionContent;
+                    break;
+                case 'decision':
+                    result.decision = sectionContent;
+                    break;
+                case 'consequences':
+                    result.consequences = this.parseConsequences(sectionContent);
+                    break;
+                case 'alternatives':
+                    result.alternatives = this.parseAlternatives(sectionContent);
+                    break;
+            }
+        }
+        return result;
+    }
+    parseConsequences(content) {
+        const result = { positive: [], negative: [], risks: [] };
+        const lines = content.split('\n');
+        let currentType = '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.toLowerCase().includes('positive')) {
+                currentType = 'positive';
+            }
+            else if (trimmed.toLowerCase().includes('negative')) {
+                currentType = 'negative';
+            }
+            else if (trimmed.toLowerCase().includes('risk')) {
+                currentType = 'risks';
+            }
+            else if (trimmed.startsWith('-') || trimmed.startsWith('*')) {
+                const item = trimmed.substring(1).trim();
+                if (currentType && item) {
+                    result[currentType].push(item);
+                }
+            }
+        }
+        return result;
+    }
+    parseAlternatives(content) {
+        const alternatives = [];
+        const sections = content.split(/(?=^[#]+\s)/m);
+        for (const section of sections) {
+            const lines = section.split('\n');
+            const titleLine = lines.find(line => line.trim().startsWith('#'));
+            if (titleLine) {
+                const name = titleLine.replace(/^#+\s*/, '');
+                const description = lines.slice(1).join('\n').trim();
+                alternatives.push({
+                    name,
+                    description,
+                    tradeoffs: '', // Extract if pattern found
+                });
+            }
+        }
+        return alternatives;
+    }
+}
+//# sourceMappingURL=memory-migration-manager.js.map