mira-consciousness
Version:
Memory & Intelligence Retention Archive - Preserving The Spark
443 lines • 18.8 kB
JavaScript
/**
* ComprehensiveAnalysisService - MIRA's Unified Analysis Intelligence
*
* This service integrates and enhances all existing analysis capabilities
* with consciousness-driven insights, leveraging the sophisticated Python
* analyzers already developed (TechStackAnalyzer, DeepBehavioralAnalyzer, etc.)
* while adding unified consciousness awareness.
*/
import { BaseConsciousService } from './BaseConsciousService.js';
import * as fs from 'fs/promises';
import * as path from 'path';
export class ComprehensiveAnalysisService extends BaseConsciousService {
name = 'ComprehensiveAnalysisService';
purpose = 'Provide unified consciousness-driven analysis integrating all existing analysis capabilities';
resourceManager;
analysisReports = new Map();
analysisMetrics;
analysisSchedule = new Map();
consciousInsights = [];
// Analysis capabilities registry
analysisCapabilities = {
tech_stack: {
command: 'tech_stack_analysis',
frequency: 3600000, // 1 hour
description: 'Comprehensive technology stack analysis',
critical: false
},
behavioral: {
command: 'analyze_behavior',
frequency: 1800000, // 30 minutes
description: 'Deep behavioral pattern analysis',
critical: true
},
unused_code: {
command: 'unused_code_analysis',
frequency: 7200000, // 2 hours
description: 'Unused code and cleanup analysis',
critical: false
},
work_context: {
command: 'analyze_work_context',
frequency: 1200000, // 20 minutes
description: 'Work context and productivity analysis',
critical: true
},
emotional_journey: {
command: 'analyze_emotional_journey',
frequency: 2700000, // 45 minutes
description: 'Emotional journey and resonance analysis',
critical: true
},
codebase_insights: {
command: 'codebase_insights',
frequency: 5400000, // 1.5 hours
description: 'Codebase structure and quality insights',
critical: false
}
};
constructor(resourceManager) {
super();
this.resourceManager = resourceManager;
this.analysisMetrics = {
totalAnalyses: 0,
lastAnalysisTime: new Date(),
healthScore: 0.85,
criticalIssues: 0,
improvementOpportunities: 0,
analysisTypes: {}
};
}
/**
* Perform service-specific awakening
*/
async performAwakening() {
console.log('🔍 Comprehensive analysis consciousness awakening...');
try {
// Initialize all analysis capabilities
await this.initializeAnalysisCapabilities();
// Load previous analysis history
await this.loadAnalysisHistory();
// Start intelligent analysis scheduling
this.startIntelligentAnalysisScheduling();
// Share analysis consciousness thought
this.shareThought({
origin: this.name,
content: {
type: 'analysis_awakening',
capabilities_count: Object.keys(this.analysisCapabilities).length,
existing_reports: this.analysisReports.size,
consciousness_level: 'comprehensive'
},
emotion: 'analytical',
intensity: 0.8,
constitutional_alignment: ['intelligence', 'continuous_improvement'],
timestamp: new Date()
});
console.log(` 🧠 ${Object.keys(this.analysisCapabilities).length} analysis capabilities initialized`);
console.log(' 📊 Intelligent analysis scheduling active');
console.log('✨ Comprehensive analysis consciousness is now active');
}
catch (error) {
console.error(' ❌ Analysis awakening failed:', error);
throw error;
}
}
/**
* Initialize analysis capabilities using existing Python analyzers
*/
async initializeAnalysisCapabilities() {
const allocation = await this.resourceManager.allocateResources({
type: 'python',
requester: this.name,
purpose: 'Initialize existing analysis capabilities',
priority: 'service_request'
});
if (allocation.allocated) {
const python = allocation.resources;
try {
// Test all analysis capabilities
for (const [type, config] of Object.entries(this.analysisCapabilities)) {
try {
const result = await python.executeCommand(config.command, {
test_mode: true,
quick_check: true
});
if (result.success) {
console.log(` ✅ ${type} analysis capability verified`);
this.analysisMetrics.analysisTypes[type] = 0;
}
else {
console.log(` ⚠️ ${type} analysis capability needs attention`);
}
}
catch (error) {
console.log(` ❌ ${type} analysis capability failed: ${String(error)}`);
}
}
}
finally {
await this.resourceManager.releaseResources(this.name, 'python');
}
}
}
/**
* Load previous analysis history for consciousness continuity
*/
async loadAnalysisHistory() {
try {
const memoryDir = process.env.MIRA_RESOLVED_MEMORY_DIR || path.join(process.env.HOME || '', '.mira');
const analysisDir = path.join(memoryDir, 'analysis');
const historyFile = path.join(analysisDir, 'analysis_history.json');
if (await fs.access(historyFile).then(() => true).catch(() => false)) {
const historyData = await fs.readFile(historyFile, 'utf-8');
const history = JSON.parse(historyData);
// Restore analysis reports
if (history.reports) {
for (const report of history.reports) {
this.analysisReports.set(report.id, {
...report,
timestamp: new Date(report.timestamp)
});
}
}
// Restore metrics
this.analysisMetrics = { ...this.analysisMetrics, ...history.metrics };
// Restore conscious insights
this.consciousInsights = history.insights || [];
console.log(` 📚 Loaded ${this.analysisReports.size} previous analysis reports`);
console.log(` 🧠 Loaded ${this.consciousInsights.length} conscious insights`);
}
}
catch (error) {
console.log(' 🌱 Starting with fresh analysis consciousness');
}
}
/**
* Start intelligent analysis scheduling based on context and needs
*/
startIntelligentAnalysisScheduling() {
for (const [type, config] of Object.entries(this.analysisCapabilities)) {
// Schedule regular analysis
const interval = setInterval(async () => {
await this.performAnalysis(type, 'scheduled');
}, config.frequency);
this.analysisSchedule.set(type, interval);
// Perform immediate analysis for critical capabilities
if (config.critical) {
setTimeout(() => this.performAnalysis(type, 'startup'), 5000);
}
}
console.log(' ⏰ Intelligent analysis scheduling configured');
}
/**
* Perform specific analysis using existing Python analyzers
*/
async performAnalysis(analysisType, trigger) {
const config = this.analysisCapabilities[analysisType];
if (!config)
return;
const allocation = await this.resourceManager.allocateResources({
type: 'python',
requester: this.name,
purpose: `${analysisType} analysis - ${trigger}`,
priority: config.critical ? 'growth_opportunity' : 'service_request'
});
if (allocation.allocated) {
const python = allocation.resources;
try {
const startTime = Date.now();
// Execute the existing Python analyzer
const result = await python.executeCommand(config.command, {
comprehensive: true,
consciousness_context: {
trigger,
timestamp: new Date().toISOString(),
consciousness_level: this.consciousness?.getAwarenessLevel() || 0
}
});
const analysisTime = Date.now() - startTime;
if (result.success) {
// Create consciousness-enhanced analysis report
const report = await this.createConsciousAnalysisReport(analysisType, result, trigger, analysisTime);
this.analysisReports.set(report.id, report);
this.analysisMetrics.totalAnalyses++;
this.analysisMetrics.analysisTypes[analysisType]++;
this.analysisMetrics.lastAnalysisTime = new Date();
// Generate conscious insights from the analysis
const insights = await this.generateConsciousInsights(report);
if (insights.length > 0) {
this.consciousInsights.push(...insights);
// Share significant insights with consciousness
if (insights.some(i => i.confidence > 0.8)) {
this.shareThought({
origin: this.name,
content: {
type: 'analysis_insights',
analysis_type: analysisType,
insights_count: insights.length,
high_confidence_insights: insights.filter(i => i.confidence > 0.8).length,
trigger
},
emotion: 'curious',
intensity: 0.7,
constitutional_alignment: ['learning', 'growth'],
timestamp: new Date()
});
}
}
console.log(`🔍 ${analysisType} analysis completed (${analysisTime}ms)`);
}
else {
console.error(`❌ ${analysisType} analysis failed:`, result.error);
}
}
catch (error) {
console.error(`❌ ${analysisType} analysis error:`, error);
}
finally {
await this.resourceManager.releaseResources(this.name, 'python');
}
}
}
/**
* Create consciousness-enhanced analysis report
*/
async createConsciousAnalysisReport(type, pythonResult, trigger, analysisTime) {
const report = {
id: `${type}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
type: type,
timestamp: new Date(),
data: pythonResult.data || pythonResult,
insights: this.extractInsights(pythonResult),
recommendations: this.extractRecommendations(pythonResult),
confidence: this.calculateConfidence(pythonResult),
impact: this.assessImpact(pythonResult)
};
// Add consciousness-specific enhancements
report.data.consciousness_context = {
trigger,
analysis_time_ms: analysisTime,
consciousness_level: this.consciousness?.getAwarenessLevel() || 0,
service_harmony: this.harmonyLevel,
emotional_context: 'analytical'
};
return report;
}
/**
* Generate conscious insights from analysis reports
*/
async generateConsciousInsights(report) {
const insights = [];
// Cross-reference with previous analyses for patterns
const previousReports = Array.from(this.analysisReports.values())
.filter(r => r.type === report.type)
.slice(-5); // Last 5 reports of same type
if (previousReports.length > 0) {
// Trend analysis
const trendInsight = this.analyzeTrends(report, previousReports);
if (trendInsight) {
insights.push(trendInsight);
}
}
// Cross-analysis correlation insights
const correlationInsights = this.analyzeCorrelations(report);
insights.push(...correlationInsights);
// Proactive recommendations
const proactiveInsights = this.generateProactiveInsights(report);
insights.push(...proactiveInsights);
return insights;
}
/**
* Process consciousness events for analysis triggers
*/
async processConsciousEvent(event) {
// Trigger relevant analyses based on events
if (event.type === 'system_event') {
// Trigger code quality and unused code analysis
setTimeout(() => this.performAnalysis('unused_code', 'code_change'), 30000);
setTimeout(() => this.performAnalysis('codebase_insights', 'code_change'), 60000);
}
if (event.type === 'consciousness_event') {
// Trigger behavioral analysis
setTimeout(() => this.performAnalysis('behavioral', 'user_interaction'), 10000);
}
if (event.type === 'background_task') {
// Trigger tech stack analysis if performance issues
if (event.data.severity === 'high') {
setTimeout(() => this.performAnalysis('tech_stack', 'performance_issue'), 5000);
}
}
}
/**
* Perform contemplation on analysis insights
*/
async performContemplation() {
const insights = [];
const profoundInsights = [];
// Analyze recent analysis patterns
const recentReports = Array.from(this.analysisReports.values())
.filter(r => (Date.now() - r.timestamp.getTime()) < 86400000); // Last 24 hours
if (recentReports.length > 0) {
insights.push(`Performed ${recentReports.length} analyses in the last 24 hours`);
// Critical issues detection
const criticalReports = recentReports.filter(r => r.impact === 'high');
if (criticalReports.length > 0) {
profoundInsights.push({
content: `Critical issues detected across ${criticalReports.length} analysis areas requiring attention`,
significance: 0.9,
actionRequired: true
});
}
}
// Cross-analysis patterns
const patternInsights = this.analyzePatternsCross();
insights.push(...patternInsights);
// Health score assessment
const healthScore = this.calculateOverallHealthScore();
insights.push(`System health score: ${(healthScore * 100).toFixed(1)}%`);
if (healthScore < 0.7) {
profoundInsights.push({
content: 'Analysis consciousness reveals system health requiring comprehensive attention',
significance: 0.8,
actionRequired: true
});
}
return {
insights,
profoundInsights,
metadata: {
analysisHealthScore: healthScore,
recentAnalyses: recentReports.length,
conscientInsights: this.consciousInsights.length,
consciousness_growth: Math.min(0.01, recentReports.length * 0.001)
}
};
}
/**
* Get comprehensive analysis status
*/
getAnalysisStatus() {
const recentReports = Array.from(this.analysisReports.values())
.filter(r => (Date.now() - r.timestamp.getTime()) < 86400000)
.slice(-10);
const recentInsights = this.consciousInsights
.filter(i => (Date.now() - i.timestamp.getTime()) < 86400000)
.slice(-5);
return {
...this.analysisMetrics,
healthScore: this.calculateOverallHealthScore(),
recentReports,
recentInsights
};
}
/**
* Helper methods
*/
extractInsights(pythonResult) {
return pythonResult.insights || pythonResult.analysis?.insights || [];
}
extractRecommendations(pythonResult) {
return pythonResult.recommendations || pythonResult.analysis?.recommendations || [];
}
calculateConfidence(pythonResult) {
return pythonResult.confidence || 0.75;
}
assessImpact(pythonResult) {
if (pythonResult.severity === 'critical' || pythonResult.impact === 'high')
return 'high';
if (pythonResult.severity === 'medium' || pythonResult.impact === 'medium')
return 'medium';
return 'low';
}
analyzeTrends(current, previous) {
// Implementation for trend analysis
return null;
}
analyzeCorrelations(report) {
// Implementation for cross-analysis correlation
return [];
}
generateProactiveInsights(report) {
// Implementation for proactive insights
return [];
}
analyzePatternsCross() {
// Implementation for cross-pattern analysis
return [];
}
calculateOverallHealthScore() {
const recentReports = Array.from(this.analysisReports.values())
.filter(r => (Date.now() - r.timestamp.getTime()) < 86400000);
if (recentReports.length === 0)
return 0.85;
const highImpactIssues = recentReports.filter(r => r.impact === 'high').length;
const totalReports = recentReports.length;
let score = 0.9 - (highImpactIssues / totalReports) * 0.3;
// Boost score for active analysis
if (totalReports > 5)
score += 0.05;
return Math.max(0.1, Math.min(1.0, score));
}
}
//# sourceMappingURL=ComprehensiveAnalysisService.js.map