const fs = require('fs').promises;
const path = require('path');
/**
* SyncEngine - Comprehensive synchronization and analysis for Matrix Pattern System
* Provides horizontal evolution tracking and vertical completeness reporting
*/
class SyncEngine {
constructor(matrixFileSystem) {
this.mfs = matrixFileSystem;
this.syncReportsDir = 'sync-reports';
this.horizontalReportsDir = path.join(this.syncReportsDir, 'horizontal');
this.verticalReportsDir = path.join(this.syncReportsDir, 'vertical');
}
/**
* Initialize sync reports directories
*/
async initialize() {
await fs.mkdir(this.horizontalReportsDir, { recursive: true });
await fs.mkdir(this.verticalReportsDir, { recursive: true });
}
/**
* Generate comprehensive horizontal evolution report
* Tracks how a horizontal concept evolves across all verticals
*/
async syncHorizontal(horizontal) {
await this.initialize();
const verticals = await this.mfs.getVerticals();
const report = {
horizontal,
timestamp: new Date().toISOString(),
summary: {
totalVerticals: verticals.length,
implementedVerticals: 0,
emptyVerticals: 0,
missingVerticals: 0
},
evolutionPattern: [],
verticalDetails: [],
consolidatedState: null
};
// Analyze each vertical for this horizontal
for (const vertical of verticals) {
const cellExists = await this.mfs.cellExists(horizontal, vertical);
let cellData = null;
let status = 'missing';
let content = '';
let preview = '';
if (cellExists) {
cellData = await this.mfs.getCell(horizontal, vertical);
content = cellData.content || '';
if (content.trim().length === 0) {
status = 'empty';
report.summary.emptyVerticals++;
} else {
status = 'implemented';
report.summary.implementedVerticals++;
preview = content.substring(0, 200);
if (content.length > 200) preview += '...';
}
} else {
report.summary.missingVerticals++;
}
const verticalDetail = {
vertical,
status,
exists: cellExists,
contentLength: content.length,
preview,
lastModified: cellData?.metadata?.lastModified || null,
evolution: this.analyzeEvolution(content, vertical)
};
report.verticalDetails.push(verticalDetail);
}
// Generate evolution pattern analysis
report.evolutionPattern = this.generateEvolutionPattern(report.verticalDetails);
// Extract consolidated state from the most complete implementation
report.consolidatedState = this.extractConsolidatedState(report.verticalDetails);
// Generate and save report
const reportContent = this.generateHorizontalReportMarkdown(report);
const reportPath = path.join(this.horizontalReportsDir, `${horizontal}-sync.md`);
await fs.writeFile(reportPath, reportContent, 'utf8');
return {
success: true,
report,
reportPath,
summary: `Generated horizontal sync report for '${horizontal}' - ${report.summary.implementedVerticals} implemented, ${report.summary.emptyVerticals} empty, ${report.summary.missingVerticals} missing`
};
}
/**
* Generate comprehensive vertical completeness report
* Analyzes implementation status across all horizontals for a specific vertical
*/
async syncVertical(vertical) {
await this.initialize();
const horizontals = await this.mfs.getHorizontals();
const report = {
vertical,
timestamp: new Date().toISOString(),
summary: {
totalHorizontals: horizontals.length,
implementedHorizontals: 0,
emptyHorizontals: 0,
missingHorizontals: 0,
completenessPercentage: 0
},
horizontalDetails: [],
completenessAssessment: null
};
// Analyze each horizontal for this vertical
for (const horizontal of horizontals) {
const cellExists = await this.mfs.cellExists(horizontal, vertical);
let cellData = null;
let status = 'missing';
let statusIcon = '❌';
let content = '';
let preview = '';
if (cellExists) {
cellData = await this.mfs.getCell(horizontal, vertical);
content = cellData.content || '';
if (content.trim().length === 0) {
status = 'empty';
statusIcon = '⬜';
report.summary.emptyHorizontals++;
} else {
status = 'implemented';
statusIcon = '✅';
report.summary.implementedHorizontals++;
preview = content.substring(0, 200);
if (content.length > 200) preview += '...';
}
} else {
report.summary.missingHorizontals++;
}
const horizontalDetail = {
horizontal,
status,
statusIcon,
exists: cellExists,
contentLength: content.length,
preview,
lastModified: cellData?.metadata?.lastModified || null,
implementation: this.analyzeImplementation(content, horizontal)
};
report.horizontalDetails.push(horizontalDetail);
}
// Calculate completeness percentage
report.summary.completenessPercentage = Math.round(
(report.summary.implementedHorizontals / report.summary.totalHorizontals) * 100
);
// Generate completeness assessment
report.completenessAssessment = this.generateCompletenessAssessment(report);
// Generate and save report
const reportContent = this.generateVerticalReportMarkdown(report);
const reportPath = path.join(this.verticalReportsDir, `${vertical}-sync.md`);
await fs.writeFile(reportPath, reportContent, 'utf8');
return {
success: true,
report,
reportPath,
summary: `Generated vertical sync report for '${vertical}' - ${report.summary.completenessPercentage}% complete (${report.summary.implementedHorizontals}/${report.summary.totalHorizontals} implemented)`
};
}
/**
* Analyze evolution patterns in content
*/
analyzeEvolution(content, vertical) {
if (!content || content.trim().length === 0) {
return { stage: 'none', complexity: 0, patterns: [] };
}
const patterns = [];
const lines = content.split('\n');
let complexity = 0;
// Analyze content complexity and patterns
if (content.includes('class ') || content.includes('function ')) {
patterns.push('code-implementation');
complexity += 3;
}
if (content.includes('TODO') || content.includes('FIXME')) {
patterns.push('work-in-progress');
complexity += 1;
}
if (lines.length > 50) {
patterns.push('detailed-implementation');
complexity += 2;
}
if (content.includes('test') || content.includes('spec')) {
patterns.push('testing');
complexity += 2;
}
let stage = 'basic';
if (complexity >= 6) stage = 'advanced';
else if (complexity >= 3) stage = 'intermediate';
return { stage, complexity, patterns };
}
/**
* Generate evolution pattern analysis across verticals
*/
generateEvolutionPattern(verticalDetails) {
const patterns = [];
const stages = verticalDetails.map(v => v.evolution?.stage || 'none');
// Identify progression patterns
const stageOrder = ['none', 'basic', 'intermediate', 'advanced'];
let progression = 'scattered';
const implementedStages = stages.filter(s => s !== 'none');
if (implementedStages.length > 0) {
const avgStageIndex = implementedStages.reduce((acc, stage) =>
acc + stageOrder.indexOf(stage), 0) / implementedStages.length;
if (avgStageIndex >= 2.5) progression = 'mature';
else if (avgStageIndex >= 1.5) progression = 'developing';
else progression = 'emerging';
}
patterns.push({
type: 'progression',
value: progression,
description: `Overall evolution stage: ${progression}`
});
// Identify common implementation patterns
const allPatterns = verticalDetails
.flatMap(v => v.evolution?.patterns || [])
.reduce((acc, pattern) => {
acc[pattern] = (acc[pattern] || 0) + 1;
return acc;
}, {});
Object.entries(allPatterns).forEach(([pattern, count]) => {
if (count > 1) {
patterns.push({
type: 'common-pattern',
value: pattern,
count,
description: `${pattern} appears in ${count} verticals`
});
}
});
return patterns;
}
/**
* Extract consolidated state from most complete implementation
*/
extractConsolidatedState(verticalDetails) {
const implemented = verticalDetails.filter(v => v.status === 'implemented');
if (implemented.length === 0) {
return {
source: null,
content: null,
stage: 'none',
summary: 'No implementations found'
};
}
// Find the most advanced implementation
const mostAdvanced = implemented.reduce((best, current) => {
const currentComplexity = current.evolution?.complexity || 0;
const bestComplexity = best.evolution?.complexity || 0;
return currentComplexity > bestComplexity ? current : best;
});
return {
source: mostAdvanced.vertical,
content: mostAdvanced.preview,
stage: mostAdvanced.evolution?.stage || 'basic',
summary: `Most advanced implementation from ${mostAdvanced.vertical} vertical`
};
}
/**
* Analyze implementation quality and completeness
*/
analyzeImplementation(content, horizontal) {
if (!content || content.trim().length === 0) {
return { quality: 0, completeness: 0, indicators: [] };
}
const indicators = [];
let quality = 0;
let completeness = 0;
// Quality indicators
if (content.includes('/**') || content.includes('//')) {
indicators.push('documented');
quality += 20;
}
if (content.includes('test') || content.includes('spec')) {
indicators.push('tested');
quality += 25;
}
if (content.includes('class ') || content.includes('module.exports')) {
indicators.push('structured');
quality += 20;
}
if (content.includes('async') || content.includes('Promise')) {
indicators.push('async-ready');
quality += 15;
}
if (!content.includes('TODO') && !content.includes('FIXME')) {
indicators.push('production-ready');
quality += 20;
}
// Completeness indicators
const lines = content.split('\n').filter(line => line.trim().length > 0);
completeness = Math.min(100, (lines.length / 10) * 100); // Basic heuristic
return {
quality: Math.min(100, quality),
completeness: Math.min(100, completeness),
indicators
};
}
/**
* Generate completeness assessment for vertical
*/
generateCompletenessAssessment(report) {
const { summary, horizontalDetails } = report;
let assessment = 'incomplete';
let recommendations = [];
if (summary.completenessPercentage >= 90) {
assessment = 'excellent';
recommendations.push('Consider code review and optimization');
} else if (summary.completenessPercentage >= 75) {
assessment = 'good';
recommendations.push('Focus on completing remaining implementations');
} else if (summary.completenessPercentage >= 50) {
assessment = 'moderate';
recommendations.push('Prioritize high-impact horizontals');
} else if (summary.completenessPercentage >= 25) {
assessment = 'poor';
recommendations.push('Systematic implementation approach needed');
} else {
assessment = 'critical';
recommendations.push('Immediate attention required');
}
// Add specific recommendations based on missing horizontals
const missingCritical = horizontalDetails
.filter(h => h.status === 'missing' && this.isCriticalHorizontal(h.horizontal))
.map(h => h.horizontal);
if (missingCritical.length > 0) {
recommendations.push(`Critical missing: ${missingCritical.join(', ')}`);
}
return {
level: assessment,
percentage: summary.completenessPercentage,
recommendations
};
}
/**
* Check if horizontal is considered critical
*/
isCriticalHorizontal(horizontal) {
const criticalKeywords = ['core', 'main', 'primary', 'essential', 'base', 'fundamental'];
return criticalKeywords.some(keyword =>
horizontal.toLowerCase().includes(keyword)
);
}
/**
* Generate markdown content for horizontal sync report
*/
generateHorizontalReportMarkdown(report) {
const { horizontal, timestamp, summary, evolutionPattern, verticalDetails, consolidatedState } = report;
let markdown = `# Horizontal Sync Report: ${horizontal}
*Generated on: ${new Date(timestamp).toLocaleString()}*
## 📊 Summary
- **Total Verticals**: ${summary.totalVerticals}
- **Implemented**: ${summary.implementedVerticals} (${Math.round((summary.implementedVerticals/summary.totalVerticals)*100)}%)
- **Empty**: ${summary.emptyVerticals} (${Math.round((summary.emptyVerticals/summary.totalVerticals)*100)}%)
- **Missing**: ${summary.missingVerticals} (${Math.round((summary.missingVerticals/summary.totalVerticals)*100)}%)
## 🔄 Evolution Pattern Analysis
`;
evolutionPattern.forEach(pattern => {
markdown += `- **${pattern.type}**: ${pattern.description}\n`;
});
markdown += `
## 📋 Vertical Implementation Details
| Vertical | Status | Content Length | Evolution Stage | Last Modified |
|----------|--------|----------------|-----------------|---------------|
`;
verticalDetails.forEach(detail => {
const statusIcon = detail.status === 'implemented' ? '✅' :
detail.status === 'empty' ? '⬜' : '❌';
const stage = detail.evolution?.stage || 'none';
const modified = detail.lastModified ?
new Date(detail.lastModified).toLocaleDateString() : 'N/A';
markdown += `| ${detail.vertical} | ${statusIcon} ${detail.status} | ${detail.contentLength} chars | ${stage} | ${modified} |\n`;
});
markdown += `
## 📝 Content Previews
`;
verticalDetails
.filter(detail => detail.preview)
.forEach(detail => {
markdown += `### ${detail.vertical}
\`\`\`
${detail.preview}
\`\`\`
`;
});
if (consolidatedState && consolidatedState.content) {
markdown += `## 🎯 Consolidated State
**Source**: ${consolidatedState.source}
**Stage**: ${consolidatedState.stage}
**Summary**: ${consolidatedState.summary}
### Current Implementation
\`\`\`
${consolidatedState.content}
\`\`\`
`;
}
return markdown;
}
/**
* Generate markdown content for vertical sync report
*/
generateVerticalReportMarkdown(report) {
const { vertical, timestamp, summary, horizontalDetails, completenessAssessment } = report;
let markdown = `# Vertical Sync Report: ${vertical}
*Generated on: ${new Date(timestamp).toLocaleString()}*
## 📊 Summary
- **Total Horizontals**: ${summary.totalHorizontals}
- **Implemented**: ${summary.implementedHorizontals} ✅
- **Empty**: ${summary.emptyHorizontals} ⬜
- **Missing**: ${summary.missingHorizontals} ❌
- **Completeness**: ${summary.completenessPercentage}%
## 🎯 Completeness Assessment
**Level**: ${completenessAssessment.level.toUpperCase()}
### Recommendations:
`;
completenessAssessment.recommendations.forEach(rec => {
markdown += `- ${rec}\n`;
});
markdown += `
## 📋 Implementation Status
| Horizontal | Status | Content Length | Implementation Quality | Last Modified |
|------------|--------|----------------|------------------------|---------------|
`;
horizontalDetails.forEach(detail => {
const quality = detail.implementation?.quality || 0;
const qualityText = quality >= 80 ? 'High' : quality >= 60 ? 'Medium' : quality >= 40 ? 'Low' : 'Poor';
const modified = detail.lastModified ?
new Date(detail.lastModified).toLocaleDateString() : 'N/A';
markdown += `| ${detail.horizontal} | ${detail.statusIcon} ${detail.status} | ${detail.contentLength} chars | ${qualityText} (${quality}%) | ${modified} |\n`;
});
markdown += `
## 📝 Implementation Previews
`;
horizontalDetails
.filter(detail => detail.preview)
.forEach(detail => {
markdown += `### ${detail.horizontal}
**Quality**: ${detail.implementation?.quality || 0}% | **Indicators**: ${(detail.implementation?.indicators || []).join(', ')}
\`\`\`
${detail.preview}
\`\`\`
`;
});
return markdown;
}
}
module.exports = SyncEngine;
