chore: recovery checkpoint - v3.0 API successfully recovered
CRITICAL CHECKPOINT - DO NOT PUSH TO GITHUB Recovery Status: - Successfully recovered brainy.ts from compiled JavaScript - All core v3.0 API methods functional (add, get, update, delete, relate, find, etc.) - Neural subsystem intact (562KB embedded patterns, NLP working) - Augmentation pipeline operational (20+ augmentations) - HNSW clustering system complete - Triple Intelligence compiled (needs constructor fix) - Test suite validates functionality Changes preserved: - 898 files with changes from last 3 days - 144,475 insertions - All augmentation improvements - All test coverage enhancements - Complete v3.0 feature set This is a LOCAL checkpoint only - contains recovered work after corruption incident. Created backup in .backups/brainy-full-20250910-151314.tar.gz Branch: recovery-checkpoint-20250910-151433 Date: Wed Sep 10 03:18:04 PM PDT 2025
This commit is contained in:
parent
f65455fb22
commit
8ff382ca3b
895 changed files with 143654 additions and 28268 deletions
85
.recovery-workspace/dist-backup-20250910-141917/cortex/backupRestore.d.ts
vendored
Normal file
85
.recovery-workspace/dist-backup-20250910-141917/cortex/backupRestore.d.ts
vendored
Normal file
|
|
@ -0,0 +1,85 @@
|
|||
/**
|
||||
* Backup & Restore System - Atomic Age Data Preservation Protocol
|
||||
*
|
||||
* 🧠 Complete backup/restore with compression and verification
|
||||
* ⚛️ 1950s retro sci-fi aesthetic maintained throughout
|
||||
*/
|
||||
import { Brainy } from '../brainy.js';
|
||||
export interface BackupOptions {
|
||||
compress?: boolean;
|
||||
output?: string;
|
||||
includeMetadata?: boolean;
|
||||
includeStatistics?: boolean;
|
||||
verify?: boolean;
|
||||
password?: string;
|
||||
}
|
||||
export interface RestoreOptions {
|
||||
verify?: boolean;
|
||||
overwrite?: boolean;
|
||||
password?: string;
|
||||
dryRun?: boolean;
|
||||
}
|
||||
export interface BackupManifest {
|
||||
version: string;
|
||||
timestamp: string;
|
||||
brainyVersion: string;
|
||||
entityCount: number;
|
||||
relationshipCount: number;
|
||||
storageType: string;
|
||||
compressed: boolean;
|
||||
encrypted: boolean;
|
||||
checksum: string;
|
||||
metadata: {
|
||||
created: string;
|
||||
description?: string;
|
||||
tags?: string[];
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Backup & Restore Engine - The Brain's Memory Preservation System
|
||||
*/
|
||||
export declare class BackupRestore {
|
||||
private brainy;
|
||||
private colors;
|
||||
private emojis;
|
||||
constructor(brainy: Brainy);
|
||||
/**
|
||||
* Create a complete backup of Brainy data
|
||||
*/
|
||||
createBackup(options?: BackupOptions): Promise<string>;
|
||||
/**
|
||||
* Restore Brainy data from backup
|
||||
*/
|
||||
restoreBackup(backupPath: string, options?: RestoreOptions): Promise<void>;
|
||||
/**
|
||||
* List available backups in a directory
|
||||
*/
|
||||
listBackups(directory?: string): Promise<BackupManifest[]>;
|
||||
/**
|
||||
* Get backup manifest without loading full backup
|
||||
*/
|
||||
private getBackupManifest;
|
||||
/**
|
||||
* Collect all data for backup
|
||||
*/
|
||||
private collectBackupData;
|
||||
/**
|
||||
* Create backup manifest
|
||||
*/
|
||||
private createManifest;
|
||||
/**
|
||||
* Helper methods
|
||||
*/
|
||||
private generateBackupPath;
|
||||
private compressData;
|
||||
private decompressData;
|
||||
private encryptData;
|
||||
private decryptData;
|
||||
private verifyBackup;
|
||||
private verifyRestoreData;
|
||||
private executeRestore;
|
||||
private collectMetadata;
|
||||
private restoreMetadata;
|
||||
private calculateChecksum;
|
||||
private formatFileSize;
|
||||
}
|
||||
|
|
@ -0,0 +1,383 @@
|
|||
/**
|
||||
* Backup & Restore System - Atomic Age Data Preservation Protocol
|
||||
*
|
||||
* 🧠 Complete backup/restore with compression and verification
|
||||
* ⚛️ 1950s retro sci-fi aesthetic maintained throughout
|
||||
*/
|
||||
import * as fs from '../universal/fs.js';
|
||||
import * as path from '../universal/path.js';
|
||||
// @ts-ignore
|
||||
import chalk from 'chalk';
|
||||
// @ts-ignore
|
||||
import ora from 'ora';
|
||||
// @ts-ignore
|
||||
import boxen from 'boxen';
|
||||
// @ts-ignore
|
||||
import prompts from 'prompts';
|
||||
/**
|
||||
* Backup & Restore Engine - The Brain's Memory Preservation System
|
||||
*/
|
||||
export class BackupRestore {
|
||||
constructor(brainy) {
|
||||
this.colors = {
|
||||
primary: chalk.hex('#3A5F4A'),
|
||||
success: chalk.hex('#2D4A3A'),
|
||||
warning: chalk.hex('#D67441'),
|
||||
error: chalk.hex('#B85C35'),
|
||||
info: chalk.hex('#4A6B5A'),
|
||||
dim: chalk.hex('#8A9B8A'),
|
||||
highlight: chalk.hex('#E88B5A'),
|
||||
accent: chalk.hex('#F5E6D3'),
|
||||
brain: chalk.hex('#E88B5A')
|
||||
};
|
||||
this.emojis = {
|
||||
brain: '🧠',
|
||||
atom: '⚛️',
|
||||
disk: '💾',
|
||||
archive: '📦',
|
||||
shield: '🛡️',
|
||||
check: '✅',
|
||||
warning: '⚠️',
|
||||
sparkle: '✨',
|
||||
rocket: '🚀',
|
||||
gear: '⚙️',
|
||||
time: '⏰'
|
||||
};
|
||||
this.brainy = brainy;
|
||||
}
|
||||
/**
|
||||
* Create a complete backup of Brainy data
|
||||
*/
|
||||
async createBackup(options = {}) {
|
||||
const outputPath = options.output || this.generateBackupPath();
|
||||
console.log(boxen(`${this.emojis.archive} ${this.colors.brain('ATOMIC DATA PRESERVATION PROTOCOL')} ${this.emojis.atom}\n\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Initiating brain backup sequence')}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Output:')} ${this.colors.highlight(outputPath)}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Compression:')} ${this.colors.highlight(options.compress ? 'Enabled' : 'Disabled')}`, { padding: 1, borderStyle: 'round', borderColor: '#E88B5A' }));
|
||||
const spinner = ora(`${this.emojis.brain} Scanning neural pathways...`).start();
|
||||
try {
|
||||
// Phase 1: Collect data
|
||||
spinner.text = `${this.emojis.gear} Extracting neural data...`;
|
||||
const backupData = await this.collectBackupData(options);
|
||||
// Phase 2: Create manifest
|
||||
spinner.text = `${this.emojis.atom} Generating quantum manifest...`;
|
||||
const manifest = await this.createManifest(backupData, options);
|
||||
// Phase 3: Package data
|
||||
spinner.text = `${this.emojis.archive} Packaging atomic data...`;
|
||||
const packagedData = {
|
||||
manifest,
|
||||
data: backupData
|
||||
};
|
||||
// Phase 4: Compress if requested
|
||||
let finalData = JSON.stringify(packagedData, null, 2);
|
||||
if (options.compress) {
|
||||
spinner.text = `${this.emojis.gear} Applying quantum compression...`;
|
||||
finalData = await this.compressData(finalData);
|
||||
}
|
||||
// Phase 5: Encrypt if password provided
|
||||
if (options.password) {
|
||||
spinner.text = `${this.emojis.shield} Applying atomic encryption...`;
|
||||
finalData = await this.encryptData(finalData, options.password);
|
||||
}
|
||||
// Phase 6: Write to file
|
||||
spinner.text = `${this.emojis.disk} Storing in atomic vault...`;
|
||||
await fs.writeFile(outputPath, finalData);
|
||||
// Phase 7: Verify if requested
|
||||
if (options.verify) {
|
||||
spinner.text = `${this.emojis.check} Verifying atomic integrity...`;
|
||||
await this.verifyBackup(outputPath, options);
|
||||
}
|
||||
spinner.succeed(this.colors.success(`${this.emojis.sparkle} Backup complete! Neural pathways preserved in atomic vault.`));
|
||||
console.log(boxen(`${this.emojis.brain} ${this.colors.brain('BACKUP SUMMARY')}\n\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Entities:')} ${this.colors.primary(manifest.entityCount.toLocaleString())}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Relationships:')} ${this.colors.primary(manifest.relationshipCount.toLocaleString())}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Size:')} ${this.colors.highlight(this.formatFileSize(finalData.length))}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Location:')} ${this.colors.highlight(outputPath)}`, { padding: 1, borderStyle: 'round', borderColor: '#2D4A3A' }));
|
||||
return outputPath;
|
||||
}
|
||||
catch (error) {
|
||||
spinner.fail('Backup failed - atomic vault compromised!');
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Restore Brainy data from backup
|
||||
*/
|
||||
async restoreBackup(backupPath, options = {}) {
|
||||
console.log(boxen(`${this.emojis.rocket} ${this.colors.brain('ATOMIC RESTORATION PROTOCOL')} ${this.emojis.atom}\n\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Initiating neural restoration sequence')}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Source:')} ${this.colors.highlight(backupPath)}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Mode:')} ${this.colors.highlight(options.dryRun ? 'Simulation' : 'Full Restore')}`, { padding: 1, borderStyle: 'round', borderColor: '#E88B5A' }));
|
||||
const spinner = ora(`${this.emojis.brain} Loading atomic vault...`).start();
|
||||
try {
|
||||
// Phase 1: Load backup file
|
||||
spinner.text = `${this.emojis.disk} Reading atomic data...`;
|
||||
let rawData = await fs.readFile(backupPath, 'utf8');
|
||||
// Phase 2: Decrypt if needed
|
||||
if (options.password) {
|
||||
spinner.text = `${this.emojis.shield} Decrypting atomic data...`;
|
||||
rawData = await this.decryptData(rawData, options.password);
|
||||
}
|
||||
// Phase 3: Decompress if needed
|
||||
spinner.text = `${this.emojis.gear} Decompressing quantum data...`;
|
||||
const decompressedData = await this.decompressData(rawData);
|
||||
// Phase 4: Parse backup data
|
||||
const backupPackage = JSON.parse(decompressedData);
|
||||
const { manifest, data } = backupPackage;
|
||||
// Phase 5: Verify integrity
|
||||
if (options.verify) {
|
||||
spinner.text = `${this.emojis.check} Verifying atomic integrity...`;
|
||||
await this.verifyRestoreData(data, manifest);
|
||||
}
|
||||
// Phase 6: Display what will be restored
|
||||
console.log('\n' + boxen(`${this.emojis.brain} ${this.colors.brain('RESTORATION PREVIEW')}\n\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Backup Date:')} ${this.colors.highlight(new Date(manifest.timestamp).toLocaleString())}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Entities:')} ${this.colors.primary(manifest.entityCount.toLocaleString())}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Relationships:')} ${this.colors.primary(manifest.relationshipCount.toLocaleString())}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Storage Type:')} ${this.colors.highlight(manifest.storageType)}`, { padding: 1, borderStyle: 'round', borderColor: '#D67441' }));
|
||||
if (options.dryRun) {
|
||||
spinner.succeed(this.colors.success('Dry run complete - restoration simulation successful'));
|
||||
return;
|
||||
}
|
||||
// Phase 7: Confirm restoration
|
||||
if (!options.overwrite) {
|
||||
const { confirm } = await prompts({
|
||||
type: 'confirm',
|
||||
name: 'confirm',
|
||||
message: `${this.emojis.warning} This will replace current data. Continue?`,
|
||||
initial: false
|
||||
});
|
||||
if (!confirm) {
|
||||
spinner.info('Restoration cancelled by user');
|
||||
return;
|
||||
}
|
||||
}
|
||||
// Phase 8: Restore data
|
||||
spinner.text = `${this.emojis.rocket} Restoring neural pathways...`;
|
||||
await this.executeRestore(data, manifest);
|
||||
spinner.succeed(this.colors.success(`${this.emojis.sparkle} Restoration complete! Neural pathways successfully reconstructed.`));
|
||||
}
|
||||
catch (error) {
|
||||
spinner.fail('Restoration failed - atomic vault corrupted!');
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* List available backups in a directory
|
||||
*/
|
||||
async listBackups(directory = './backups') {
|
||||
try {
|
||||
const files = await fs.readdir(directory);
|
||||
const backupFiles = files.filter(f => f.endsWith('.brainy') || f.endsWith('.json'));
|
||||
const manifests = [];
|
||||
for (const file of backupFiles) {
|
||||
try {
|
||||
const filePath = path.join(directory, file);
|
||||
const manifest = await this.getBackupManifest(filePath);
|
||||
if (manifest)
|
||||
manifests.push(manifest);
|
||||
}
|
||||
catch (error) {
|
||||
// Skip invalid backup files
|
||||
}
|
||||
}
|
||||
return manifests.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
|
||||
}
|
||||
catch (error) {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Get backup manifest without loading full backup
|
||||
*/
|
||||
async getBackupManifest(backupPath) {
|
||||
try {
|
||||
const rawData = await fs.readFile(backupPath, 'utf8');
|
||||
const decompressedData = await this.decompressData(rawData);
|
||||
const backupPackage = JSON.parse(decompressedData);
|
||||
return backupPackage.manifest || null;
|
||||
}
|
||||
catch (error) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Collect all data for backup
|
||||
*/
|
||||
async collectBackupData(options) {
|
||||
const data = {
|
||||
entities: [],
|
||||
relationships: [],
|
||||
metadata: {},
|
||||
statistics: null
|
||||
};
|
||||
// For now, we'll create a simplified backup that just captures the current state
|
||||
// In a full implementation, this would use internal storage methods
|
||||
console.log(this.colors.warning('Note: Backup system is in beta - captures basic data only'));
|
||||
// Placeholder data collection
|
||||
data.entities = [];
|
||||
data.relationships = [];
|
||||
// Collect metadata if requested
|
||||
if (options.includeMetadata) {
|
||||
data.metadata = await this.collectMetadata();
|
||||
}
|
||||
// Statistics not yet implemented
|
||||
if (options.includeStatistics) {
|
||||
console.warn('Statistics collection not yet implemented in backup');
|
||||
}
|
||||
return data;
|
||||
}
|
||||
/**
|
||||
* Create backup manifest
|
||||
*/
|
||||
async createManifest(data, options) {
|
||||
return {
|
||||
version: '1.0.0',
|
||||
timestamp: new Date().toISOString(),
|
||||
brainyVersion: '0.55.0', // Would come from package.json
|
||||
entityCount: data.entities.length,
|
||||
relationshipCount: data.relationships.length,
|
||||
storageType: 'unknown', // Would detect from brainy instance
|
||||
compressed: options.compress || false,
|
||||
encrypted: !!options.password,
|
||||
checksum: await this.calculateChecksum(JSON.stringify(data)),
|
||||
metadata: {
|
||||
created: new Date().toISOString(),
|
||||
description: 'Atomic age brain backup',
|
||||
tags: ['brainy', 'neural-backup', 'atomic-data']
|
||||
}
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Helper methods
|
||||
*/
|
||||
generateBackupPath() {
|
||||
const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
|
||||
return `./brainy-backup-${timestamp}.brainy`;
|
||||
}
|
||||
async compressData(data) {
|
||||
// Use zlib gzip compression
|
||||
const { gzip } = await import('zlib');
|
||||
const { promisify } = await import('util');
|
||||
const gzipAsync = promisify(gzip);
|
||||
const compressed = await gzipAsync(Buffer.from(data, 'utf-8'));
|
||||
return compressed.toString('base64');
|
||||
}
|
||||
async decompressData(data) {
|
||||
// Use zlib gunzip decompression
|
||||
const { gunzip } = await import('zlib');
|
||||
const { promisify } = await import('util');
|
||||
const gunzipAsync = promisify(gunzip);
|
||||
const compressed = Buffer.from(data, 'base64');
|
||||
const decompressed = await gunzipAsync(compressed);
|
||||
return decompressed.toString('utf-8');
|
||||
}
|
||||
async encryptData(data, password) {
|
||||
// Use crypto module for AES-256 encryption
|
||||
const crypto = await import('crypto');
|
||||
// Generate key from password
|
||||
const key = crypto.createHash('sha256').update(password).digest();
|
||||
const iv = crypto.randomBytes(16);
|
||||
const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
|
||||
let encrypted = cipher.update(data, 'utf8', 'base64');
|
||||
encrypted += cipher.final('base64');
|
||||
// Prepend IV to encrypted data for decryption
|
||||
return iv.toString('base64') + ':' + encrypted;
|
||||
}
|
||||
async decryptData(data, password) {
|
||||
// Use crypto module for AES-256 decryption
|
||||
const crypto = await import('crypto');
|
||||
// Split IV and encrypted data
|
||||
const [ivString, encrypted] = data.split(':');
|
||||
const iv = Buffer.from(ivString, 'base64');
|
||||
// Generate key from password
|
||||
const key = crypto.createHash('sha256').update(password).digest();
|
||||
const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
|
||||
let decrypted = decipher.update(encrypted, 'base64', 'utf8');
|
||||
decrypted += decipher.final('utf8');
|
||||
return decrypted;
|
||||
}
|
||||
async verifyBackup(backupPath, options) {
|
||||
// Placeholder - would verify backup integrity
|
||||
}
|
||||
async verifyRestoreData(data, manifest) {
|
||||
const actualChecksum = await this.calculateChecksum(JSON.stringify(data));
|
||||
if (actualChecksum !== manifest.checksum) {
|
||||
throw new Error('Data integrity check failed - backup may be corrupted');
|
||||
}
|
||||
}
|
||||
async executeRestore(data, manifest) {
|
||||
console.log(this.colors.info('🔄 Starting restore process...'));
|
||||
// Phase 1: Validate data structure
|
||||
if (!data.entities || !Array.isArray(data.entities)) {
|
||||
throw new Error('Invalid backup data structure');
|
||||
}
|
||||
// Phase 2: Clear existing data if overwriting
|
||||
console.log(this.colors.dim('Clearing existing data...'));
|
||||
const dataAPI = await this.brainy.data();
|
||||
await dataAPI.clear({ force: true });
|
||||
// Phase 3: Restore entities
|
||||
console.log(this.colors.dim(`Restoring ${data.entities.length} entities...`));
|
||||
const entityMap = new Map(); // old ID -> new ID mapping
|
||||
for (const entity of data.entities) {
|
||||
const newId = await this.brainy.add({
|
||||
data: entity.metadata || entity.data,
|
||||
type: entity.type,
|
||||
metadata: entity.metadata,
|
||||
vector: entity.vector, // Preserve original vectors if available
|
||||
service: entity.service
|
||||
});
|
||||
entityMap.set(entity.id, newId);
|
||||
}
|
||||
// Phase 4: Restore relationships if they exist
|
||||
if (data.relationships && Array.isArray(data.relationships)) {
|
||||
console.log(this.colors.dim(`Restoring ${data.relationships.length} relationships...`));
|
||||
for (const rel of data.relationships) {
|
||||
// Map old IDs to new IDs
|
||||
const fromId = entityMap.get(rel.from) || rel.from;
|
||||
const toId = entityMap.get(rel.to) || rel.to;
|
||||
await this.brainy.relate({
|
||||
from: fromId,
|
||||
to: toId,
|
||||
type: rel.type,
|
||||
metadata: rel.metadata || {}
|
||||
});
|
||||
}
|
||||
}
|
||||
// Phase 5: Restore metadata if present
|
||||
if (data.metadata) {
|
||||
await this.restoreMetadata(data.metadata);
|
||||
}
|
||||
console.log(this.colors.success('✅ Restore completed successfully'));
|
||||
}
|
||||
async collectMetadata() {
|
||||
// Collect global metadata like statistics, configuration, etc.
|
||||
const stats = await this.brainy.query.entities({ limit: 1 });
|
||||
return {
|
||||
totalEntities: stats.totalCount || 0,
|
||||
timestamp: new Date().toISOString(),
|
||||
version: '3.0.0'
|
||||
};
|
||||
}
|
||||
async restoreMetadata(metadata) {
|
||||
// Store restored metadata for reference
|
||||
// Could be saved to a config store or logged
|
||||
console.log(this.colors.dim(`Restored from backup created at: ${metadata.timestamp}`));
|
||||
}
|
||||
async calculateChecksum(data) {
|
||||
// Use crypto module for SHA-256 checksum
|
||||
const crypto = await import('crypto');
|
||||
return crypto.createHash('sha256').update(data).digest('hex');
|
||||
}
|
||||
formatFileSize(bytes) {
|
||||
const units = ['B', 'KB', 'MB', 'GB'];
|
||||
let size = bytes;
|
||||
let unitIndex = 0;
|
||||
while (size >= 1024 && unitIndex < units.length - 1) {
|
||||
size /= 1024;
|
||||
unitIndex++;
|
||||
}
|
||||
return `${size.toFixed(1)} ${units[unitIndex]}`;
|
||||
}
|
||||
}
|
||||
//# sourceMappingURL=backupRestore.js.map
|
||||
File diff suppressed because one or more lines are too long
85
.recovery-workspace/dist-backup-20250910-141917/cortex/healthCheck.d.ts
vendored
Normal file
85
.recovery-workspace/dist-backup-20250910-141917/cortex/healthCheck.d.ts
vendored
Normal file
|
|
@ -0,0 +1,85 @@
|
|||
/**
|
||||
* Health Check System - Atomic Age Diagnostic Engine
|
||||
*
|
||||
* 🧠 Comprehensive health diagnostics for vector + graph operations
|
||||
* ⚛️ Auto-repair capabilities with 1950s retro sci-fi aesthetics
|
||||
* 🚀 Scalable health monitoring for high-performance databases
|
||||
*/
|
||||
import { Brainy } from '../brainy.js';
|
||||
export interface HealthCheckResult {
|
||||
component: string;
|
||||
status: 'healthy' | 'warning' | 'critical' | 'offline';
|
||||
score: number;
|
||||
message: string;
|
||||
details?: string[];
|
||||
autoFixAvailable?: boolean;
|
||||
lastChecked: string;
|
||||
responseTime?: number;
|
||||
}
|
||||
export interface SystemHealth {
|
||||
overall: HealthCheckResult;
|
||||
vector: HealthCheckResult;
|
||||
graph: HealthCheckResult;
|
||||
storage: HealthCheckResult;
|
||||
memory: HealthCheckResult;
|
||||
network: HealthCheckResult;
|
||||
embedding: HealthCheckResult;
|
||||
cache: HealthCheckResult;
|
||||
timestamp: string;
|
||||
recommendations: string[];
|
||||
}
|
||||
export interface RepairAction {
|
||||
id: string;
|
||||
name: string;
|
||||
description: string;
|
||||
severity: 'low' | 'medium' | 'high';
|
||||
automated: boolean;
|
||||
estimatedTime: string;
|
||||
riskLevel: 'safe' | 'moderate' | 'high';
|
||||
}
|
||||
/**
|
||||
* Comprehensive Health Check and Auto-Repair System
|
||||
*/
|
||||
export declare class HealthCheck {
|
||||
private brainy;
|
||||
private colors;
|
||||
private emojis;
|
||||
constructor(brainy: Brainy);
|
||||
/**
|
||||
* Run comprehensive system health check
|
||||
*/
|
||||
runHealthCheck(): Promise<SystemHealth>;
|
||||
/**
|
||||
* Display health check results in terminal
|
||||
*/
|
||||
displayHealthReport(health?: SystemHealth): Promise<void>;
|
||||
/**
|
||||
* Get available repair actions
|
||||
*/
|
||||
getRepairActions(): Promise<RepairAction[]>;
|
||||
/**
|
||||
* Execute automated repairs
|
||||
*/
|
||||
executeAutoRepairs(): Promise<{
|
||||
success: string[];
|
||||
failed: string[];
|
||||
}>;
|
||||
/**
|
||||
* Individual health check methods
|
||||
*/
|
||||
private checkVectorOperations;
|
||||
private checkGraphOperations;
|
||||
private checkStorageHealth;
|
||||
private checkMemoryHealth;
|
||||
private checkNetworkHealth;
|
||||
private checkEmbeddingHealth;
|
||||
private checkCacheHealth;
|
||||
/**
|
||||
* Helper methods
|
||||
*/
|
||||
private getOverallMessage;
|
||||
private generateRecommendations;
|
||||
private getHealthIcon;
|
||||
private getStatusColor;
|
||||
private executeRepairAction;
|
||||
}
|
||||
|
|
@ -0,0 +1,546 @@
|
|||
/**
|
||||
* Health Check System - Atomic Age Diagnostic Engine
|
||||
*
|
||||
* 🧠 Comprehensive health diagnostics for vector + graph operations
|
||||
* ⚛️ Auto-repair capabilities with 1950s retro sci-fi aesthetics
|
||||
* 🚀 Scalable health monitoring for high-performance databases
|
||||
*/
|
||||
// @ts-ignore
|
||||
import chalk from 'chalk';
|
||||
// @ts-ignore
|
||||
import boxen from 'boxen';
|
||||
// @ts-ignore
|
||||
import ora from 'ora';
|
||||
/**
|
||||
* Comprehensive Health Check and Auto-Repair System
|
||||
*/
|
||||
export class HealthCheck {
|
||||
constructor(brainy) {
|
||||
this.colors = {
|
||||
primary: chalk.hex('#3A5F4A'),
|
||||
success: chalk.hex('#2D4A3A'),
|
||||
warning: chalk.hex('#D67441'),
|
||||
error: chalk.hex('#B85C35'),
|
||||
info: chalk.hex('#4A6B5A'),
|
||||
dim: chalk.hex('#8A9B8A'),
|
||||
highlight: chalk.hex('#E88B5A'),
|
||||
accent: chalk.hex('#F5E6D3'),
|
||||
brain: chalk.hex('#E88B5A')
|
||||
};
|
||||
this.emojis = {
|
||||
brain: '🧠',
|
||||
atom: '⚛️',
|
||||
health: '💚',
|
||||
warning: '⚠️',
|
||||
critical: '🔥',
|
||||
offline: '💀',
|
||||
repair: '🔧',
|
||||
shield: '🛡️',
|
||||
rocket: '🚀',
|
||||
gear: '⚙️',
|
||||
check: '✅',
|
||||
cross: '❌',
|
||||
lightning: '⚡',
|
||||
sparkle: '✨'
|
||||
};
|
||||
this.brainy = brainy;
|
||||
}
|
||||
/**
|
||||
* Run comprehensive system health check
|
||||
*/
|
||||
async runHealthCheck() {
|
||||
console.log(boxen(`${this.emojis.shield} ${this.colors.brain('ATOMIC DIAGNOSTIC ENGINE')} ${this.emojis.atom}\n\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Initiating comprehensive system diagnostics')}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Scanning vector + graph database health')}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Auto-repair recommendations included')}`, { padding: 1, borderStyle: 'round', borderColor: '#E88B5A' }));
|
||||
const spinner = ora(`${this.emojis.brain} Running neural diagnostics...`).start();
|
||||
try {
|
||||
// Run all health checks in parallel for speed
|
||||
const [vectorHealth, graphHealth, storageHealth, memoryHealth, networkHealth, embeddingHealth, cacheHealth] = await Promise.all([
|
||||
this.checkVectorOperations(spinner),
|
||||
this.checkGraphOperations(spinner),
|
||||
this.checkStorageHealth(spinner),
|
||||
this.checkMemoryHealth(spinner),
|
||||
this.checkNetworkHealth(spinner),
|
||||
this.checkEmbeddingHealth(spinner),
|
||||
this.checkCacheHealth(spinner)
|
||||
]);
|
||||
// Calculate overall health
|
||||
const components = [vectorHealth, graphHealth, storageHealth, memoryHealth, networkHealth, embeddingHealth, cacheHealth];
|
||||
const averageScore = components.reduce((sum, c) => sum + c.score, 0) / components.length;
|
||||
const criticalIssues = components.filter(c => c.status === 'critical').length;
|
||||
const warnings = components.filter(c => c.status === 'warning').length;
|
||||
const overallStatus = criticalIssues > 0 ? 'critical' :
|
||||
warnings > 2 ? 'warning' :
|
||||
averageScore >= 90 ? 'healthy' : 'warning';
|
||||
const overall = {
|
||||
component: 'System Overall',
|
||||
status: overallStatus,
|
||||
score: Math.floor(averageScore),
|
||||
message: this.getOverallMessage(overallStatus, criticalIssues, warnings),
|
||||
lastChecked: new Date().toISOString()
|
||||
};
|
||||
const health = {
|
||||
overall,
|
||||
vector: vectorHealth,
|
||||
graph: graphHealth,
|
||||
storage: storageHealth,
|
||||
memory: memoryHealth,
|
||||
network: networkHealth,
|
||||
embedding: embeddingHealth,
|
||||
cache: cacheHealth,
|
||||
timestamp: new Date().toISOString(),
|
||||
recommendations: this.generateRecommendations(components)
|
||||
};
|
||||
spinner.succeed(this.colors.success(`${this.emojis.sparkle} Health check complete - Neural pathways analyzed`));
|
||||
return health;
|
||||
}
|
||||
catch (error) {
|
||||
spinner.fail('Health check failed - Diagnostic systems compromised!');
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Display health check results in terminal
|
||||
*/
|
||||
async displayHealthReport(health) {
|
||||
if (!health) {
|
||||
health = await this.runHealthCheck();
|
||||
}
|
||||
console.log('\n' + boxen(`${this.emojis.brain} ${this.colors.brain('SYSTEM HEALTH REPORT')} ${this.emojis.atom}\n` +
|
||||
`${this.colors.dim('Comprehensive Vector + Graph Database Diagnostics')}\n` +
|
||||
`${this.colors.accent('Overall Health:')} ${this.getHealthIcon(health.overall.status)} ${this.colors.primary(health.overall.score + '/100')}`, { padding: 1, borderStyle: 'double', borderColor: '#E88B5A', width: 80 }));
|
||||
// Component Health Status
|
||||
const components = [
|
||||
health.vector,
|
||||
health.graph,
|
||||
health.storage,
|
||||
health.memory,
|
||||
health.network,
|
||||
health.embedding,
|
||||
health.cache
|
||||
];
|
||||
console.log('\n' + this.colors.brain(`${this.emojis.gear} COMPONENT STATUS`));
|
||||
components.forEach(component => {
|
||||
const statusColor = this.getStatusColor(component.status);
|
||||
const icon = this.getHealthIcon(component.status);
|
||||
const timeStr = component.responseTime ? ` (${component.responseTime}ms)` : '';
|
||||
console.log(`${icon} ${statusColor(component.component.padEnd(20))} ` +
|
||||
`${this.colors.primary((component.score + '/100').padEnd(8))} ` +
|
||||
`${this.colors.dim(component.message)}${timeStr}`);
|
||||
if (component.details && component.details.length > 0) {
|
||||
component.details.forEach(detail => {
|
||||
console.log(` ${this.colors.dim('→')} ${this.colors.accent(detail)}`);
|
||||
});
|
||||
}
|
||||
});
|
||||
// Auto-repair recommendations
|
||||
if (health.recommendations.length > 0) {
|
||||
console.log('\n' + this.colors.warning(`${this.emojis.repair} AUTO-REPAIR RECOMMENDATIONS`));
|
||||
console.log(boxen(health.recommendations.map((rec, i) => `${this.colors.accent((i + 1) + '.')} ${this.colors.dim(rec)}`).join('\n'), { padding: 1, borderStyle: 'round', borderColor: '#D67441' }));
|
||||
}
|
||||
// Critical issues
|
||||
const criticalComponents = components.filter(c => c.status === 'critical');
|
||||
if (criticalComponents.length > 0) {
|
||||
console.log('\n' + this.colors.error(`${this.emojis.critical} CRITICAL ISSUES REQUIRING ATTENTION`));
|
||||
criticalComponents.forEach(component => {
|
||||
console.log(this.colors.error(` ${this.emojis.cross} ${component.component}: ${component.message}`));
|
||||
});
|
||||
}
|
||||
console.log('\n' + this.colors.dim(`Report generated: ${new Date(health.timestamp).toLocaleString()}`));
|
||||
}
|
||||
/**
|
||||
* Get available repair actions
|
||||
*/
|
||||
async getRepairActions() {
|
||||
const health = await this.runHealthCheck();
|
||||
const actions = [];
|
||||
// Vector operations repairs
|
||||
if (health.vector.status !== 'healthy') {
|
||||
actions.push({
|
||||
id: 'rebuild-vector-index',
|
||||
name: 'Rebuild Vector Index',
|
||||
description: 'Reconstruct HNSW index for optimal vector search performance',
|
||||
severity: 'medium',
|
||||
automated: true,
|
||||
estimatedTime: '2-5 minutes',
|
||||
riskLevel: 'safe'
|
||||
});
|
||||
}
|
||||
// Graph operations repairs
|
||||
if (health.graph.status !== 'healthy') {
|
||||
actions.push({
|
||||
id: 'optimize-graph-connections',
|
||||
name: 'Optimize Graph Connections',
|
||||
description: 'Clean up orphaned relationships and optimize graph traversal paths',
|
||||
severity: 'medium',
|
||||
automated: true,
|
||||
estimatedTime: '1-3 minutes',
|
||||
riskLevel: 'safe'
|
||||
});
|
||||
}
|
||||
// Memory optimization
|
||||
if (health.memory.score < 70) {
|
||||
actions.push({
|
||||
id: 'optimize-memory-usage',
|
||||
name: 'Optimize Memory Usage',
|
||||
description: 'Clear unused caches and optimize memory allocation',
|
||||
severity: 'low',
|
||||
automated: true,
|
||||
estimatedTime: '30 seconds',
|
||||
riskLevel: 'safe'
|
||||
});
|
||||
}
|
||||
// Cache optimization
|
||||
if (health.cache.score < 80) {
|
||||
actions.push({
|
||||
id: 'rebuild-cache-indexes',
|
||||
name: 'Rebuild Cache Indexes',
|
||||
description: 'Optimize cache data structures for better hit rates',
|
||||
severity: 'low',
|
||||
automated: true,
|
||||
estimatedTime: '1-2 minutes',
|
||||
riskLevel: 'safe'
|
||||
});
|
||||
}
|
||||
// Storage optimization
|
||||
if (health.storage.score < 75) {
|
||||
actions.push({
|
||||
id: 'compress-storage-data',
|
||||
name: 'Compress Storage Data',
|
||||
description: 'Apply compression to reduce storage size and improve I/O',
|
||||
severity: 'medium',
|
||||
automated: false,
|
||||
estimatedTime: '5-15 minutes',
|
||||
riskLevel: 'moderate'
|
||||
});
|
||||
}
|
||||
return actions;
|
||||
}
|
||||
/**
|
||||
* Execute automated repairs
|
||||
*/
|
||||
async executeAutoRepairs() {
|
||||
const actions = await this.getRepairActions();
|
||||
const automatedActions = actions.filter(a => a.automated && a.riskLevel === 'safe');
|
||||
if (automatedActions.length === 0) {
|
||||
console.log(this.colors.info('No safe automated repairs available'));
|
||||
return { success: [], failed: [] };
|
||||
}
|
||||
console.log(boxen(`${this.emojis.repair} ${this.colors.brain('AUTOMATED REPAIR SEQUENCE')} ${this.emojis.atom}\n\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Executing safe automated repairs')}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Actions:')} ${this.colors.highlight(automatedActions.length.toString())}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Risk Level:')} ${this.colors.success('Safe')}`, { padding: 1, borderStyle: 'round', borderColor: '#E88B5A' }));
|
||||
const success = [];
|
||||
const failed = [];
|
||||
for (const action of automatedActions) {
|
||||
const spinner = ora(`${this.emojis.gear} Executing: ${action.name}`).start();
|
||||
try {
|
||||
await this.executeRepairAction(action);
|
||||
spinner.succeed(this.colors.success(`${action.name} completed successfully`));
|
||||
success.push(action.name);
|
||||
}
|
||||
catch (error) {
|
||||
spinner.fail(this.colors.error(`${action.name} failed: ${error}`));
|
||||
failed.push(action.name);
|
||||
}
|
||||
}
|
||||
if (success.length > 0) {
|
||||
console.log(this.colors.success(`\n${this.emojis.sparkle} Auto-repair complete: ${success.length} actions successful`));
|
||||
}
|
||||
if (failed.length > 0) {
|
||||
console.log(this.colors.warning(`${this.emojis.warning} ${failed.length} actions failed - manual intervention required`));
|
||||
}
|
||||
return { success, failed };
|
||||
}
|
||||
/**
|
||||
* Individual health check methods
|
||||
*/
|
||||
async checkVectorOperations(spinner) {
|
||||
spinner.text = `${this.emojis.lightning} Checking vector operations...`;
|
||||
const startTime = Date.now();
|
||||
try {
|
||||
// Simulate vector health check
|
||||
await new Promise(resolve => setTimeout(resolve, 200 + Math.random() * 300));
|
||||
const responseTime = Date.now() - startTime;
|
||||
const score = Math.floor(85 + Math.random() * 15);
|
||||
const status = score >= 90 ? 'healthy' : score >= 70 ? 'warning' : 'critical';
|
||||
return {
|
||||
component: 'Vector Operations',
|
||||
status,
|
||||
score,
|
||||
message: status === 'healthy' ? 'Optimal vector search performance' :
|
||||
status === 'warning' ? 'Vector search slower than optimal' :
|
||||
'Vector search performance degraded',
|
||||
details: [
|
||||
`HNSW Index: ${score >= 85 ? 'Optimized' : 'Needs rebuilding'}`,
|
||||
`Embedding Cache: ${score >= 80 ? 'Efficient' : 'Cache misses high'}`,
|
||||
`Query Latency: ${responseTime}ms average`
|
||||
],
|
||||
autoFixAvailable: score < 85,
|
||||
lastChecked: new Date().toISOString(),
|
||||
responseTime
|
||||
};
|
||||
}
|
||||
catch (error) {
|
||||
return {
|
||||
component: 'Vector Operations',
|
||||
status: 'critical',
|
||||
score: 0,
|
||||
message: 'Vector operations failed',
|
||||
lastChecked: new Date().toISOString()
|
||||
};
|
||||
}
|
||||
}
|
||||
async checkGraphOperations(spinner) {
|
||||
spinner.text = `${this.emojis.gear} Checking graph operations...`;
|
||||
const startTime = Date.now();
|
||||
try {
|
||||
await new Promise(resolve => setTimeout(resolve, 150 + Math.random() * 200));
|
||||
const responseTime = Date.now() - startTime;
|
||||
const score = Math.floor(80 + Math.random() * 20);
|
||||
const status = score >= 90 ? 'healthy' : score >= 70 ? 'warning' : 'critical';
|
||||
return {
|
||||
component: 'Graph Operations',
|
||||
status,
|
||||
score,
|
||||
message: status === 'healthy' ? 'Graph traversal performing optimally' :
|
||||
status === 'warning' ? 'Graph queries slower than expected' :
|
||||
'Graph operations significantly degraded',
|
||||
details: [
|
||||
`Relationship Index: ${score >= 85 ? 'Optimized' : 'Fragmented'}`,
|
||||
`Traversal Cache: ${score >= 75 ? 'Efficient' : 'Low hit rate'}`,
|
||||
`Connection Health: ${score >= 80 ? 'Good' : 'Orphaned connections detected'}`
|
||||
],
|
||||
autoFixAvailable: score < 80,
|
||||
lastChecked: new Date().toISOString(),
|
||||
responseTime
|
||||
};
|
||||
}
|
||||
catch (error) {
|
||||
return {
|
||||
component: 'Graph Operations',
|
||||
status: 'critical',
|
||||
score: 0,
|
||||
message: 'Graph operations failed',
|
||||
lastChecked: new Date().toISOString()
|
||||
};
|
||||
}
|
||||
}
|
||||
async checkStorageHealth(spinner) {
|
||||
spinner.text = `${this.emojis.shield} Checking storage systems...`;
|
||||
try {
|
||||
await new Promise(resolve => setTimeout(resolve, 100 + Math.random() * 200));
|
||||
const score = Math.floor(88 + Math.random() * 12);
|
||||
const status = score >= 90 ? 'healthy' : score >= 75 ? 'warning' : 'critical';
|
||||
return {
|
||||
component: 'Storage Systems',
|
||||
status,
|
||||
score,
|
||||
message: status === 'healthy' ? 'Storage operating at peak efficiency' :
|
||||
status === 'warning' ? 'Storage performance below optimal' :
|
||||
'Storage systems experiencing issues',
|
||||
details: [
|
||||
`I/O Performance: ${score >= 85 ? 'Excellent' : 'Needs optimization'}`,
|
||||
`Data Integrity: ${score >= 90 ? 'Verified' : 'Minor inconsistencies'}`,
|
||||
`Compression Ratio: ${score >= 80 ? 'Optimal' : 'Can be improved'}`
|
||||
],
|
||||
autoFixAvailable: score < 85,
|
||||
lastChecked: new Date().toISOString()
|
||||
};
|
||||
}
|
||||
catch (error) {
|
||||
return {
|
||||
component: 'Storage Systems',
|
||||
status: 'offline',
|
||||
score: 0,
|
||||
message: 'Storage systems offline',
|
||||
lastChecked: new Date().toISOString()
|
||||
};
|
||||
}
|
||||
}
|
||||
async checkMemoryHealth(spinner) {
|
||||
spinner.text = `${this.emojis.brain} Analyzing memory usage...`;
|
||||
try {
|
||||
const memUsage = process.memoryUsage();
|
||||
const heapUsedMB = memUsage.heapUsed / (1024 * 1024);
|
||||
const heapTotalMB = memUsage.heapTotal / (1024 * 1024);
|
||||
const usage = (heapUsedMB / heapTotalMB) * 100;
|
||||
const score = usage < 70 ? 95 : usage < 85 ? 80 : usage < 95 ? 60 : 30;
|
||||
const status = score >= 80 ? 'healthy' : score >= 60 ? 'warning' : 'critical';
|
||||
return {
|
||||
component: 'Memory Management',
|
||||
status,
|
||||
score,
|
||||
message: status === 'healthy' ? 'Memory usage within optimal range' :
|
||||
status === 'warning' ? 'Memory usage elevated but stable' :
|
||||
'Memory usage critically high',
|
||||
details: [
|
||||
`Heap Usage: ${heapUsedMB.toFixed(1)}MB / ${heapTotalMB.toFixed(1)}MB (${usage.toFixed(1)}%)`,
|
||||
`Memory Efficiency: ${score >= 80 ? 'Excellent' : 'Needs optimization'}`,
|
||||
`GC Pressure: ${usage < 70 ? 'Low' : usage < 85 ? 'Moderate' : 'High'}`
|
||||
],
|
||||
autoFixAvailable: score < 75,
|
||||
lastChecked: new Date().toISOString()
|
||||
};
|
||||
}
|
||||
catch (error) {
|
||||
return {
|
||||
component: 'Memory Management',
|
||||
status: 'critical',
|
||||
score: 0,
|
||||
message: 'Memory analysis failed',
|
||||
lastChecked: new Date().toISOString()
|
||||
};
|
||||
}
|
||||
}
|
||||
async checkNetworkHealth(spinner) {
|
||||
spinner.text = `${this.emojis.rocket} Testing network connectivity...`;
|
||||
try {
|
||||
await new Promise(resolve => setTimeout(resolve, 50 + Math.random() * 100));
|
||||
const score = Math.floor(90 + Math.random() * 10);
|
||||
const status = 'healthy'; // Assume healthy for local operations
|
||||
return {
|
||||
component: 'Network/Connectivity',
|
||||
status,
|
||||
score,
|
||||
message: 'Network connectivity optimal',
|
||||
details: [
|
||||
'Local Operations: Excellent',
|
||||
'API Endpoints: Responsive',
|
||||
'Storage Access: Fast'
|
||||
],
|
||||
autoFixAvailable: false,
|
||||
lastChecked: new Date().toISOString()
|
||||
};
|
||||
}
|
||||
catch (error) {
|
||||
return {
|
||||
component: 'Network/Connectivity',
|
||||
status: 'critical',
|
||||
score: 0,
|
||||
message: 'Network connectivity issues',
|
||||
lastChecked: new Date().toISOString()
|
||||
};
|
||||
}
|
||||
}
|
||||
async checkEmbeddingHealth(spinner) {
|
||||
spinner.text = `${this.emojis.atom} Verifying embedding system...`;
|
||||
try {
|
||||
await new Promise(resolve => setTimeout(resolve, 300 + Math.random() * 200));
|
||||
const score = Math.floor(85 + Math.random() * 15);
|
||||
const status = score >= 90 ? 'healthy' : score >= 75 ? 'warning' : 'critical';
|
||||
return {
|
||||
component: 'Embedding System',
|
||||
status,
|
||||
score,
|
||||
message: status === 'healthy' ? 'Embedding generation optimal' :
|
||||
status === 'warning' ? 'Embedding performance acceptable' :
|
||||
'Embedding system issues detected',
|
||||
details: [
|
||||
`Model Loading: ${score >= 85 ? 'Cached' : 'Slow to load'}`,
|
||||
`Generation Speed: ${score >= 80 ? 'Fast' : 'Slower than expected'}`,
|
||||
`Quality Score: ${score >= 90 ? 'Excellent' : 'Good'}`
|
||||
],
|
||||
autoFixAvailable: score < 85,
|
||||
lastChecked: new Date().toISOString()
|
||||
};
|
||||
}
|
||||
catch (error) {
|
||||
return {
|
||||
component: 'Embedding System',
|
||||
status: 'critical',
|
||||
score: 0,
|
||||
message: 'Embedding system failed',
|
||||
lastChecked: new Date().toISOString()
|
||||
};
|
||||
}
|
||||
}
|
||||
async checkCacheHealth(spinner) {
|
||||
spinner.text = `${this.emojis.lightning} Analyzing cache performance...`;
|
||||
try {
|
||||
await new Promise(resolve => setTimeout(resolve, 100 + Math.random() * 150));
|
||||
const hitRate = 0.75 + Math.random() * 0.2;
|
||||
const score = Math.floor(hitRate * 100);
|
||||
const status = score >= 85 ? 'healthy' : score >= 70 ? 'warning' : 'critical';
|
||||
return {
|
||||
component: 'Cache System',
|
||||
status,
|
||||
score,
|
||||
message: status === 'healthy' ? 'Cache performance excellent' :
|
||||
status === 'warning' ? 'Cache hit rate below optimal' :
|
||||
'Cache system underperforming',
|
||||
details: [
|
||||
`Hit Rate: ${(hitRate * 100).toFixed(1)}%`,
|
||||
`Memory Efficiency: ${score >= 80 ? 'Good' : 'Needs optimization'}`,
|
||||
`Eviction Rate: ${score >= 85 ? 'Low' : 'High'}`
|
||||
],
|
||||
autoFixAvailable: score < 80,
|
||||
lastChecked: new Date().toISOString()
|
||||
};
|
||||
}
|
||||
catch (error) {
|
||||
return {
|
||||
component: 'Cache System',
|
||||
status: 'critical',
|
||||
score: 0,
|
||||
message: 'Cache system failed',
|
||||
lastChecked: new Date().toISOString()
|
||||
};
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Helper methods
|
||||
*/
|
||||
getOverallMessage(status, critical, warnings) {
|
||||
if (status === 'critical')
|
||||
return `${critical} critical issue${critical > 1 ? 's' : ''} detected`;
|
||||
if (status === 'warning')
|
||||
return `${warnings} warning${warnings > 1 ? 's' : ''} detected`;
|
||||
return 'All systems operating normally';
|
||||
}
|
||||
generateRecommendations(components) {
|
||||
const recommendations = [];
|
||||
components.forEach(component => {
|
||||
if (component.status === 'critical') {
|
||||
recommendations.push(`Immediate attention required for ${component.component}`);
|
||||
}
|
||||
else if (component.status === 'warning' && component.autoFixAvailable) {
|
||||
recommendations.push(`Run auto-repair for ${component.component} to improve performance`);
|
||||
}
|
||||
});
|
||||
if (recommendations.length === 0) {
|
||||
recommendations.push('All systems healthy - no actions required');
|
||||
}
|
||||
return recommendations;
|
||||
}
|
||||
getHealthIcon(status) {
|
||||
switch (status) {
|
||||
case 'healthy': return this.emojis.health;
|
||||
case 'warning': return this.emojis.warning;
|
||||
case 'critical': return this.emojis.critical;
|
||||
case 'offline': return this.emojis.offline;
|
||||
default: return this.emojis.gear;
|
||||
}
|
||||
}
|
||||
getStatusColor(status) {
|
||||
switch (status) {
|
||||
case 'healthy': return this.colors.success;
|
||||
case 'warning': return this.colors.warning;
|
||||
case 'critical': return this.colors.error;
|
||||
case 'offline': return this.colors.dim;
|
||||
default: return this.colors.info;
|
||||
}
|
||||
}
|
||||
async executeRepairAction(action) {
|
||||
// Simulate repair execution
|
||||
const delay = action.estimatedTime.includes('second') ? 1000 :
|
||||
action.estimatedTime.includes('minute') ? 2000 : 3000;
|
||||
await new Promise(resolve => setTimeout(resolve, delay));
|
||||
// Simulate occasional failure
|
||||
if (Math.random() < 0.1) {
|
||||
throw new Error('Repair action failed - manual intervention required');
|
||||
}
|
||||
}
|
||||
}
|
||||
//# sourceMappingURL=healthCheck.js.map
|
||||
File diff suppressed because one or more lines are too long
145
.recovery-workspace/dist-backup-20250910-141917/cortex/neuralImport.d.ts
vendored
Normal file
145
.recovery-workspace/dist-backup-20250910-141917/cortex/neuralImport.d.ts
vendored
Normal file
|
|
@ -0,0 +1,145 @@
|
|||
/**
|
||||
* Neural Import - Atomic Age AI-Powered Data Understanding System
|
||||
*
|
||||
* 🧠 Leveraging the brain-in-jar to understand and automatically structure data
|
||||
* ⚛️ Complete with confidence scoring and relationship weight calculation
|
||||
*/
|
||||
import { Brainy } from '../brainy.js';
|
||||
export interface NeuralAnalysisResult {
|
||||
detectedEntities: DetectedEntity[];
|
||||
detectedRelationships: DetectedRelationship[];
|
||||
confidence: number;
|
||||
insights: NeuralInsight[];
|
||||
preview: ProcessedData[];
|
||||
}
|
||||
export interface DetectedEntity {
|
||||
originalData: any;
|
||||
nounType: string;
|
||||
confidence: number;
|
||||
suggestedId: string;
|
||||
reasoning: string;
|
||||
alternativeTypes: Array<{
|
||||
type: string;
|
||||
confidence: number;
|
||||
}>;
|
||||
}
|
||||
export interface DetectedRelationship {
|
||||
sourceId: string;
|
||||
targetId: string;
|
||||
verbType: string;
|
||||
confidence: number;
|
||||
weight: number;
|
||||
reasoning: string;
|
||||
context: string;
|
||||
metadata?: Record<string, any>;
|
||||
}
|
||||
export interface NeuralInsight {
|
||||
type: 'hierarchy' | 'cluster' | 'pattern' | 'anomaly' | 'opportunity';
|
||||
description: string;
|
||||
confidence: number;
|
||||
affectedEntities: string[];
|
||||
recommendation?: string;
|
||||
}
|
||||
export interface ProcessedData {
|
||||
id: string;
|
||||
nounType: string;
|
||||
data: any;
|
||||
relationships: Array<{
|
||||
target: string;
|
||||
verbType: string;
|
||||
weight: number;
|
||||
confidence: number;
|
||||
}>;
|
||||
}
|
||||
export interface NeuralImportOptions {
|
||||
confidenceThreshold: number;
|
||||
autoApply: boolean;
|
||||
enableWeights: boolean;
|
||||
previewOnly: boolean;
|
||||
validateOnly: boolean;
|
||||
categoryFilter?: string[];
|
||||
skipDuplicates: boolean;
|
||||
}
|
||||
/**
|
||||
* Neural Import Engine - The Brain Behind the Analysis
|
||||
*/
|
||||
export declare class NeuralImport {
|
||||
private brainy;
|
||||
private colors;
|
||||
private emojis;
|
||||
constructor(brainy: Brainy);
|
||||
/**
|
||||
* Main Neural Import Function - The Master Controller
|
||||
*/
|
||||
neuralImport(filePath: string, options?: Partial<NeuralImportOptions>): Promise<NeuralAnalysisResult>;
|
||||
/**
|
||||
* Parse file based on extension
|
||||
*/
|
||||
private parseFile;
|
||||
/**
|
||||
* Basic CSV parser
|
||||
*/
|
||||
private parseCSV;
|
||||
/**
|
||||
* Neural Entity Detection - The Core AI Engine
|
||||
*/
|
||||
private detectEntitiesWithNeuralAnalysis;
|
||||
/**
|
||||
* Calculate entity type confidence using AI
|
||||
*/
|
||||
private calculateEntityTypeConfidence;
|
||||
/**
|
||||
* Field-based confidence calculation
|
||||
*/
|
||||
private calculateFieldBasedConfidence;
|
||||
/**
|
||||
* Pattern-based confidence calculation
|
||||
*/
|
||||
private calculatePatternBasedConfidence;
|
||||
/**
|
||||
* Generate reasoning for entity type selection
|
||||
*/
|
||||
private generateEntityReasoning;
|
||||
/**
|
||||
* Neural Relationship Detection
|
||||
*/
|
||||
private detectRelationshipsWithNeuralAnalysis;
|
||||
/**
|
||||
* Calculate relationship confidence
|
||||
*/
|
||||
private calculateRelationshipConfidence;
|
||||
/**
|
||||
* Calculate relationship weight/strength
|
||||
*/
|
||||
private calculateRelationshipWeight;
|
||||
/**
|
||||
* Generate Neural Insights - The Intelligence Layer
|
||||
*/
|
||||
private generateNeuralInsights;
|
||||
/**
|
||||
* Display Neural Analysis Results
|
||||
*/
|
||||
private displayNeuralAnalysisResults;
|
||||
/**
|
||||
* Helper methods for the neural system
|
||||
*/
|
||||
private extractMainText;
|
||||
private generateSmartId;
|
||||
private extractRelationshipContext;
|
||||
private calculateTypeCompatibility;
|
||||
private getVerbSpecificity;
|
||||
private getRelevantFields;
|
||||
private getMatchedPatterns;
|
||||
private pruneRelationships;
|
||||
private detectHierarchies;
|
||||
private detectClusters;
|
||||
private detectPatterns;
|
||||
private summarizeEntities;
|
||||
private summarizeRelationships;
|
||||
private calculateOverallConfidence;
|
||||
private generatePreview;
|
||||
private confirmNeuralImport;
|
||||
private executeNeuralImport;
|
||||
private generateRelationshipReasoning;
|
||||
private extractRelationshipMetadata;
|
||||
}
|
||||
|
|
@ -0,0 +1,623 @@
|
|||
/**
|
||||
* Neural Import - Atomic Age AI-Powered Data Understanding System
|
||||
*
|
||||
* 🧠 Leveraging the brain-in-jar to understand and automatically structure data
|
||||
* ⚛️ Complete with confidence scoring and relationship weight calculation
|
||||
*/
|
||||
import { NounType, VerbType } from '../types/graphTypes.js';
|
||||
import * as fs from '../universal/fs.js';
|
||||
import * as path from '../universal/path.js';
|
||||
// @ts-ignore
|
||||
import chalk from 'chalk';
|
||||
// @ts-ignore
|
||||
import ora from 'ora';
|
||||
// @ts-ignore
|
||||
import boxen from 'boxen';
|
||||
// @ts-ignore
|
||||
import Table from 'cli-table3';
|
||||
// @ts-ignore
|
||||
import prompts from 'prompts';
|
||||
/**
|
||||
* Neural Import Engine - The Brain Behind the Analysis
|
||||
*/
|
||||
export class NeuralImport {
|
||||
constructor(brainy) {
|
||||
this.colors = {
|
||||
primary: chalk.hex('#3A5F4A'),
|
||||
success: chalk.hex('#2D4A3A'),
|
||||
warning: chalk.hex('#D67441'),
|
||||
error: chalk.hex('#B85C35'),
|
||||
info: chalk.hex('#4A6B5A'),
|
||||
dim: chalk.hex('#8A9B8A'),
|
||||
highlight: chalk.hex('#E88B5A'),
|
||||
accent: chalk.hex('#F5E6D3'),
|
||||
brain: chalk.hex('#E88B5A')
|
||||
};
|
||||
this.emojis = {
|
||||
brain: '🧠',
|
||||
atom: '⚛️',
|
||||
lab: '🔬',
|
||||
data: '🎛️',
|
||||
magic: '⚡',
|
||||
check: '✅',
|
||||
warning: '⚠️',
|
||||
sparkle: '✨',
|
||||
rocket: '🚀',
|
||||
gear: '⚙️'
|
||||
};
|
||||
this.brainy = brainy;
|
||||
}
|
||||
/**
|
||||
* Main Neural Import Function - The Master Controller
|
||||
*/
|
||||
async neuralImport(filePath, options = {}) {
|
||||
const opts = {
|
||||
confidenceThreshold: 0.7,
|
||||
autoApply: false,
|
||||
enableWeights: true,
|
||||
previewOnly: false,
|
||||
validateOnly: false,
|
||||
skipDuplicates: true,
|
||||
...options
|
||||
};
|
||||
console.log(boxen(`${this.emojis.brain} ${this.colors.brain('NEURAL IMPORT INITIATED')} ${this.emojis.atom}\n\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Activating atomic age AI analysis')}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('File:')} ${this.colors.highlight(filePath)}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Confidence Threshold:')} ${this.colors.highlight(opts.confidenceThreshold.toString())}`, { padding: 1, borderStyle: 'round', borderColor: '#E88B5A' }));
|
||||
const spinner = ora(`${this.emojis.brain} Initializing neural analysis...`).start();
|
||||
try {
|
||||
// Phase 1: Data Parsing
|
||||
spinner.text = `${this.emojis.lab} Parsing data structure...`;
|
||||
const rawData = await this.parseFile(filePath);
|
||||
// Phase 2: Neural Entity Detection
|
||||
spinner.text = `${this.emojis.atom} Analyzing ${Object.keys(NounType).length} entity types...`;
|
||||
const detectedEntities = await this.detectEntitiesWithNeuralAnalysis(rawData, opts);
|
||||
// Phase 3: Neural Relationship Detection
|
||||
spinner.text = `${this.emojis.data} Testing ${Object.keys(VerbType).length} relationship patterns...`;
|
||||
const detectedRelationships = await this.detectRelationshipsWithNeuralAnalysis(detectedEntities, rawData, opts);
|
||||
// Phase 4: Neural Insights Generation
|
||||
spinner.text = `${this.emojis.magic} Computing neural insights...`;
|
||||
const insights = await this.generateNeuralInsights(detectedEntities, detectedRelationships);
|
||||
// Phase 5: Confidence Scoring
|
||||
const overallConfidence = this.calculateOverallConfidence(detectedEntities, detectedRelationships);
|
||||
spinner.stop();
|
||||
const result = {
|
||||
detectedEntities,
|
||||
detectedRelationships,
|
||||
confidence: overallConfidence,
|
||||
insights,
|
||||
preview: await this.generatePreview(detectedEntities, detectedRelationships)
|
||||
};
|
||||
// Display results
|
||||
await this.displayNeuralAnalysisResults(result, opts);
|
||||
// Handle execution based on options
|
||||
if (opts.previewOnly || opts.validateOnly) {
|
||||
return result;
|
||||
}
|
||||
if (!opts.autoApply) {
|
||||
const shouldExecute = await this.confirmNeuralImport(result);
|
||||
if (!shouldExecute) {
|
||||
console.log(this.colors.dim('Neural import cancelled'));
|
||||
return result;
|
||||
}
|
||||
}
|
||||
// Execute the import
|
||||
await this.executeNeuralImport(result, opts);
|
||||
return result;
|
||||
}
|
||||
catch (error) {
|
||||
spinner.fail('Neural analysis failed');
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Parse file based on extension
|
||||
*/
|
||||
async parseFile(filePath) {
|
||||
const ext = path.extname(filePath).toLowerCase();
|
||||
const content = await fs.readFile(filePath, 'utf8');
|
||||
switch (ext) {
|
||||
case '.json':
|
||||
const jsonData = JSON.parse(content);
|
||||
return Array.isArray(jsonData) ? jsonData : [jsonData];
|
||||
case '.csv':
|
||||
return this.parseCSV(content);
|
||||
case '.yaml':
|
||||
case '.yml':
|
||||
// For now, basic YAML support - in full implementation would use yaml parser
|
||||
return JSON.parse(content); // Placeholder
|
||||
default:
|
||||
throw new Error(`Unsupported file format: ${ext}`);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Basic CSV parser
|
||||
*/
|
||||
parseCSV(content) {
|
||||
const lines = content.split('\n').filter(line => line.trim());
|
||||
if (lines.length < 2)
|
||||
return [];
|
||||
const headers = lines[0].split(',').map(h => h.trim().replace(/"/g, ''));
|
||||
const data = [];
|
||||
for (let i = 1; i < lines.length; i++) {
|
||||
const values = lines[i].split(',').map(v => v.trim().replace(/"/g, ''));
|
||||
const row = {};
|
||||
headers.forEach((header, index) => {
|
||||
row[header] = values[index] || '';
|
||||
});
|
||||
data.push(row);
|
||||
}
|
||||
return data;
|
||||
}
|
||||
/**
|
||||
* Neural Entity Detection - The Core AI Engine
|
||||
*/
|
||||
async detectEntitiesWithNeuralAnalysis(rawData, options) {
|
||||
const entities = [];
|
||||
const nounTypes = Object.values(NounType);
|
||||
for (const [index, dataItem] of rawData.entries()) {
|
||||
const mainText = this.extractMainText(dataItem);
|
||||
const detections = [];
|
||||
// Test against all noun types using semantic similarity
|
||||
for (const nounType of nounTypes) {
|
||||
const confidence = await this.calculateEntityTypeConfidence(mainText, dataItem, nounType);
|
||||
if (confidence >= options.confidenceThreshold - 0.2) { // Allow slightly lower for alternatives
|
||||
const reasoning = await this.generateEntityReasoning(mainText, dataItem, nounType);
|
||||
detections.push({ type: nounType, confidence, reasoning });
|
||||
}
|
||||
}
|
||||
if (detections.length > 0) {
|
||||
// Sort by confidence
|
||||
detections.sort((a, b) => b.confidence - a.confidence);
|
||||
const primaryType = detections[0];
|
||||
const alternatives = detections.slice(1, 3); // Top 2 alternatives
|
||||
entities.push({
|
||||
originalData: dataItem,
|
||||
nounType: primaryType.type,
|
||||
confidence: primaryType.confidence,
|
||||
suggestedId: this.generateSmartId(dataItem, primaryType.type, index),
|
||||
reasoning: primaryType.reasoning,
|
||||
alternativeTypes: alternatives
|
||||
});
|
||||
}
|
||||
}
|
||||
return entities;
|
||||
}
|
||||
/**
|
||||
* Calculate entity type confidence using AI
|
||||
*/
|
||||
async calculateEntityTypeConfidence(text, data, nounType) {
|
||||
// Base semantic similarity using search instead of similarity method
|
||||
const searchResults = await this.brainy.search(text + ' ' + nounType, 1);
|
||||
const textSimilarity = searchResults.length > 0 ? searchResults[0].score : 0.5;
|
||||
// Field-based confidence boost
|
||||
const fieldBoost = this.calculateFieldBasedConfidence(data, nounType);
|
||||
// Pattern-based confidence boost
|
||||
const patternBoost = this.calculatePatternBasedConfidence(text, data, nounType);
|
||||
// Combine confidences with weights
|
||||
const combined = (textSimilarity * 0.5) + (fieldBoost * 0.3) + (patternBoost * 0.2);
|
||||
return Math.min(combined, 1.0);
|
||||
}
|
||||
/**
|
||||
* Field-based confidence calculation
|
||||
*/
|
||||
calculateFieldBasedConfidence(data, nounType) {
|
||||
const fields = Object.keys(data);
|
||||
let boost = 0;
|
||||
// Field patterns that boost confidence for specific noun types
|
||||
const fieldPatterns = {
|
||||
[NounType.Person]: ['name', 'email', 'phone', 'age', 'firstname', 'lastname', 'employee'],
|
||||
[NounType.Organization]: ['company', 'organization', 'corp', 'inc', 'ltd', 'department', 'team'],
|
||||
[NounType.Project]: ['project', 'task', 'deadline', 'status', 'milestone', 'deliverable'],
|
||||
[NounType.Location]: ['address', 'city', 'country', 'state', 'zip', 'location', 'coordinates'],
|
||||
[NounType.Product]: ['product', 'price', 'sku', 'inventory', 'category', 'brand'],
|
||||
[NounType.Event]: ['date', 'time', 'venue', 'event', 'meeting', 'conference', 'schedule']
|
||||
};
|
||||
const relevantPatterns = fieldPatterns[nounType] || [];
|
||||
for (const field of fields) {
|
||||
for (const pattern of relevantPatterns) {
|
||||
if (field.toLowerCase().includes(pattern)) {
|
||||
boost += 0.1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return Math.min(boost, 0.5);
|
||||
}
|
||||
/**
|
||||
* Pattern-based confidence calculation
|
||||
*/
|
||||
calculatePatternBasedConfidence(text, data, nounType) {
|
||||
let boost = 0;
|
||||
// Content patterns that indicate entity types
|
||||
const patterns = {
|
||||
[NounType.Person]: [
|
||||
/@.*\.com/i, // Email pattern
|
||||
/\b[A-Z][a-z]+ [A-Z][a-z]+\b/, // Name pattern
|
||||
/Mr\.|Mrs\.|Dr\.|Prof\./i // Title pattern
|
||||
],
|
||||
[NounType.Organization]: [
|
||||
/\bInc\.|Corp\.|LLC\.|Ltd\./i, // Corporate suffixes
|
||||
/Company|Corporation|Enterprise/i
|
||||
],
|
||||
[NounType.Location]: [
|
||||
/\b\d{5}(-\d{4})?\b/, // ZIP code
|
||||
/Street|Ave|Road|Blvd/i
|
||||
]
|
||||
};
|
||||
const relevantPatterns = patterns[nounType] || [];
|
||||
for (const pattern of relevantPatterns) {
|
||||
if (pattern.test(text)) {
|
||||
boost += 0.15;
|
||||
}
|
||||
}
|
||||
return Math.min(boost, 0.3);
|
||||
}
|
||||
/**
|
||||
* Generate reasoning for entity type selection
|
||||
*/
|
||||
async generateEntityReasoning(text, data, nounType) {
|
||||
const reasons = [];
|
||||
// Semantic similarity reason using search
|
||||
const searchResults = await this.brainy.search(text + ' ' + nounType, 1);
|
||||
const similarity = searchResults.length > 0 ? searchResults[0].score : 0.5;
|
||||
if (similarity > 0.7) {
|
||||
reasons.push(`High semantic similarity (${(similarity * 100).toFixed(1)}%)`);
|
||||
}
|
||||
// Field-based reasons
|
||||
const relevantFields = this.getRelevantFields(data, nounType);
|
||||
if (relevantFields.length > 0) {
|
||||
reasons.push(`Contains ${nounType}-specific fields: ${relevantFields.join(', ')}`);
|
||||
}
|
||||
// Pattern-based reasons
|
||||
const matchedPatterns = this.getMatchedPatterns(text, data, nounType);
|
||||
if (matchedPatterns.length > 0) {
|
||||
reasons.push(`Matches ${nounType} patterns: ${matchedPatterns.join(', ')}`);
|
||||
}
|
||||
return reasons.length > 0 ? reasons.join('; ') : 'General semantic match';
|
||||
}
|
||||
/**
|
||||
* Neural Relationship Detection
|
||||
*/
|
||||
async detectRelationshipsWithNeuralAnalysis(entities, rawData, options) {
|
||||
const relationships = [];
|
||||
const verbTypes = Object.values(VerbType);
|
||||
// For each pair of entities, test relationship possibilities
|
||||
for (let i = 0; i < entities.length; i++) {
|
||||
for (let j = i + 1; j < entities.length; j++) {
|
||||
const sourceEntity = entities[i];
|
||||
const targetEntity = entities[j];
|
||||
// Extract context for relationship detection
|
||||
const context = this.extractRelationshipContext(sourceEntity.originalData, targetEntity.originalData, rawData);
|
||||
// Test all verb types
|
||||
for (const verbType of verbTypes) {
|
||||
const confidence = await this.calculateRelationshipConfidence(sourceEntity, targetEntity, verbType, context);
|
||||
if (confidence >= options.confidenceThreshold - 0.1) { // Slightly lower threshold for relationships
|
||||
const weight = options.enableWeights ?
|
||||
this.calculateRelationshipWeight(sourceEntity, targetEntity, verbType, context) :
|
||||
0.5;
|
||||
const reasoning = await this.generateRelationshipReasoning(sourceEntity, targetEntity, verbType, context);
|
||||
relationships.push({
|
||||
sourceId: sourceEntity.suggestedId,
|
||||
targetId: targetEntity.suggestedId,
|
||||
verbType,
|
||||
confidence,
|
||||
weight,
|
||||
reasoning,
|
||||
context,
|
||||
metadata: this.extractRelationshipMetadata(sourceEntity.originalData, targetEntity.originalData, verbType)
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Sort by confidence and remove duplicates/conflicts
|
||||
return this.pruneRelationships(relationships);
|
||||
}
|
||||
/**
|
||||
* Calculate relationship confidence
|
||||
*/
|
||||
async calculateRelationshipConfidence(source, target, verbType, context) {
|
||||
// Semantic similarity between entities and verb type using search
|
||||
const relationshipText = `${this.extractMainText(source.originalData)} ${verbType} ${this.extractMainText(target.originalData)}`;
|
||||
const directResults = await this.brainy.search(relationshipText, 1);
|
||||
const directScore = directResults.length > 0 ? directResults[0].score : 0.4;
|
||||
const contextResults = await this.brainy.search(context + ' ' + verbType, 1);
|
||||
const contextSimilarity = contextResults.length > 0 ? contextResults[0].score : 0.5;
|
||||
// Entity type compatibility
|
||||
const typeCompatibility = this.calculateTypeCompatibility(source.nounType, target.nounType, verbType);
|
||||
// Combine with weights
|
||||
return (directScore * 0.4) + (contextSimilarity * 0.4) + (typeCompatibility * 0.2);
|
||||
}
|
||||
/**
|
||||
* Calculate relationship weight/strength
|
||||
*/
|
||||
calculateRelationshipWeight(source, target, verbType, context) {
|
||||
let weight = 0.5; // Base weight
|
||||
// Context richness (more descriptive = stronger)
|
||||
const contextWords = context.split(' ').length;
|
||||
weight += Math.min(contextWords / 20, 0.2);
|
||||
// Entity importance (higher confidence entities = stronger relationships)
|
||||
const avgEntityConfidence = (source.confidence + target.confidence) / 2;
|
||||
weight += avgEntityConfidence * 0.2;
|
||||
// Verb type specificity (more specific verbs = stronger)
|
||||
const verbSpecificity = this.getVerbSpecificity(verbType);
|
||||
weight += verbSpecificity * 0.1;
|
||||
return Math.min(weight, 1.0);
|
||||
}
|
||||
/**
|
||||
* Generate Neural Insights - The Intelligence Layer
|
||||
*/
|
||||
async generateNeuralInsights(entities, relationships) {
|
||||
const insights = [];
|
||||
// Detect hierarchies
|
||||
const hierarchies = this.detectHierarchies(relationships);
|
||||
hierarchies.forEach(hierarchy => {
|
||||
insights.push({
|
||||
type: 'hierarchy',
|
||||
description: `Detected ${hierarchy.type} hierarchy with ${hierarchy.levels} levels`,
|
||||
confidence: hierarchy.confidence,
|
||||
affectedEntities: hierarchy.entities,
|
||||
recommendation: `Consider visualizing the ${hierarchy.type} structure`
|
||||
});
|
||||
});
|
||||
// Detect clusters
|
||||
const clusters = this.detectClusters(entities, relationships);
|
||||
clusters.forEach(cluster => {
|
||||
insights.push({
|
||||
type: 'cluster',
|
||||
description: `Found cluster of ${cluster.size} ${cluster.primaryType} entities`,
|
||||
confidence: cluster.confidence,
|
||||
affectedEntities: cluster.entities,
|
||||
recommendation: `These ${cluster.primaryType}s might form a natural grouping`
|
||||
});
|
||||
});
|
||||
// Detect patterns
|
||||
const patterns = this.detectPatterns(relationships);
|
||||
patterns.forEach(pattern => {
|
||||
insights.push({
|
||||
type: 'pattern',
|
||||
description: `Common relationship pattern: ${pattern.description}`,
|
||||
confidence: pattern.confidence,
|
||||
affectedEntities: pattern.entities,
|
||||
recommendation: pattern.recommendation
|
||||
});
|
||||
});
|
||||
return insights;
|
||||
}
|
||||
/**
|
||||
* Display Neural Analysis Results
|
||||
*/
|
||||
async displayNeuralAnalysisResults(result, options) {
|
||||
// Entity summary
|
||||
const entityTable = new Table({
|
||||
head: [this.colors.brain('Entity Type'), this.colors.brain('Count'), this.colors.brain('Avg Confidence')],
|
||||
colWidths: [20, 10, 15]
|
||||
});
|
||||
const entitySummary = this.summarizeEntities(result.detectedEntities);
|
||||
Object.entries(entitySummary).forEach(([type, stats]) => {
|
||||
entityTable.push([
|
||||
this.colors.highlight(type),
|
||||
this.colors.primary(stats.count.toString()),
|
||||
this.colors.success(`${(stats.avgConfidence * 100).toFixed(1)}%`)
|
||||
]);
|
||||
});
|
||||
// Relationship summary
|
||||
const relationshipTable = new Table({
|
||||
head: [this.colors.brain('Relationship Type'), this.colors.brain('Count'), this.colors.brain('Avg Weight'), this.colors.brain('Avg Confidence')],
|
||||
colWidths: [20, 10, 12, 15]
|
||||
});
|
||||
const relationshipSummary = this.summarizeRelationships(result.detectedRelationships);
|
||||
Object.entries(relationshipSummary).forEach(([type, stats]) => {
|
||||
relationshipTable.push([
|
||||
this.colors.highlight(type),
|
||||
this.colors.primary(stats.count.toString()),
|
||||
this.colors.warning(`${stats.avgWeight.toFixed(2)}`),
|
||||
this.colors.success(`${(stats.avgConfidence * 100).toFixed(1)}%`)
|
||||
]);
|
||||
});
|
||||
console.log(boxen(`${this.emojis.atom} ${this.colors.brain('NEURAL CLASSIFICATION RESULTS')}\n\n` +
|
||||
entityTable.toString(), { padding: 1, borderStyle: 'round', borderColor: '#D67441' }));
|
||||
console.log(boxen(`${this.emojis.data} ${this.colors.brain('NEURAL RELATIONSHIP MAPPING')}\n\n` +
|
||||
relationshipTable.toString(), { padding: 1, borderStyle: 'round', borderColor: '#D67441' }));
|
||||
// Display insights
|
||||
if (result.insights.length > 0) {
|
||||
const insightsText = result.insights.map(insight => `${this.colors.accent('◆')} ${insight.description} (${(insight.confidence * 100).toFixed(1)}% confidence)`).join('\n');
|
||||
console.log(boxen(`${this.emojis.magic} ${this.colors.brain('NEURAL INSIGHTS')}\n\n` +
|
||||
insightsText, { padding: 1, borderStyle: 'round', borderColor: '#E88B5A' }));
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Helper methods for the neural system
|
||||
*/
|
||||
extractMainText(data) {
|
||||
// Extract the most relevant text from a data object
|
||||
const textFields = ['name', 'title', 'description', 'content', 'text', 'label'];
|
||||
for (const field of textFields) {
|
||||
if (data[field] && typeof data[field] === 'string') {
|
||||
return data[field];
|
||||
}
|
||||
}
|
||||
// Fallback: concatenate all string values
|
||||
return Object.values(data)
|
||||
.filter(v => typeof v === 'string')
|
||||
.join(' ')
|
||||
.substring(0, 200); // Limit length
|
||||
}
|
||||
generateSmartId(data, nounType, index) {
|
||||
const mainText = this.extractMainText(data);
|
||||
const cleanText = mainText.toLowerCase().replace(/[^a-z0-9]/g, '_').substring(0, 20);
|
||||
return `${nounType}_${cleanText}_${index}`;
|
||||
}
|
||||
extractRelationshipContext(source, target, allData) {
|
||||
// Extract context for relationship detection
|
||||
return [
|
||||
this.extractMainText(source),
|
||||
this.extractMainText(target),
|
||||
// Add more contextual information
|
||||
].join(' ');
|
||||
}
|
||||
calculateTypeCompatibility(sourceType, targetType, verbType) {
|
||||
// Define type compatibility matrix for relationships
|
||||
const compatibilityMatrix = {
|
||||
[NounType.Person]: {
|
||||
[NounType.Organization]: [VerbType.MemberOf, VerbType.WorksWith],
|
||||
[NounType.Project]: [VerbType.WorksWith, VerbType.Creates],
|
||||
[NounType.Person]: [VerbType.WorksWith, VerbType.Mentors, VerbType.ReportsTo]
|
||||
}
|
||||
// Add more compatibility rules
|
||||
};
|
||||
const sourceCompatibility = compatibilityMatrix[sourceType];
|
||||
if (sourceCompatibility && sourceCompatibility[targetType]) {
|
||||
return sourceCompatibility[targetType].includes(verbType) ? 1.0 : 0.3;
|
||||
}
|
||||
return 0.5; // Default compatibility
|
||||
}
|
||||
getVerbSpecificity(verbType) {
|
||||
// More specific verbs get higher scores
|
||||
const specificityScores = {
|
||||
[VerbType.RelatedTo]: 0.1, // Very generic
|
||||
[VerbType.WorksWith]: 0.7, // Specific
|
||||
[VerbType.Mentors]: 0.9, // Very specific
|
||||
[VerbType.ReportsTo]: 0.9, // Very specific
|
||||
[VerbType.Supervises]: 0.9 // Very specific
|
||||
};
|
||||
return specificityScores[verbType] || 0.5;
|
||||
}
|
||||
getRelevantFields(data, nounType) {
|
||||
// Implementation for finding relevant fields
|
||||
return [];
|
||||
}
|
||||
getMatchedPatterns(text, data, nounType) {
|
||||
// Implementation for finding matched patterns
|
||||
return [];
|
||||
}
|
||||
pruneRelationships(relationships) {
|
||||
// Remove duplicates and low-confidence relationships
|
||||
return relationships
|
||||
.sort((a, b) => b.confidence - a.confidence)
|
||||
.slice(0, 1000); // Limit to top 1000 relationships
|
||||
}
|
||||
detectHierarchies(relationships) {
|
||||
// Detect hierarchical structures
|
||||
return [];
|
||||
}
|
||||
detectClusters(entities, relationships) {
|
||||
// Detect entity clusters
|
||||
return [];
|
||||
}
|
||||
detectPatterns(relationships) {
|
||||
// Detect relationship patterns
|
||||
return [];
|
||||
}
|
||||
summarizeEntities(entities) {
|
||||
const summary = {};
|
||||
entities.forEach(entity => {
|
||||
if (!summary[entity.nounType]) {
|
||||
summary[entity.nounType] = { count: 0, totalConfidence: 0 };
|
||||
}
|
||||
summary[entity.nounType].count++;
|
||||
summary[entity.nounType].totalConfidence += entity.confidence;
|
||||
});
|
||||
Object.keys(summary).forEach(type => {
|
||||
summary[type].avgConfidence = summary[type].totalConfidence / summary[type].count;
|
||||
});
|
||||
return summary;
|
||||
}
|
||||
summarizeRelationships(relationships) {
|
||||
const summary = {};
|
||||
relationships.forEach(rel => {
|
||||
if (!summary[rel.verbType]) {
|
||||
summary[rel.verbType] = { count: 0, totalWeight: 0, totalConfidence: 0 };
|
||||
}
|
||||
summary[rel.verbType].count++;
|
||||
summary[rel.verbType].totalWeight += rel.weight;
|
||||
summary[rel.verbType].totalConfidence += rel.confidence;
|
||||
});
|
||||
Object.keys(summary).forEach(type => {
|
||||
const stats = summary[type];
|
||||
stats.avgWeight = stats.totalWeight / stats.count;
|
||||
stats.avgConfidence = stats.totalConfidence / stats.count;
|
||||
});
|
||||
return summary;
|
||||
}
|
||||
calculateOverallConfidence(entities, relationships) {
|
||||
const entityConfidence = entities.reduce((sum, e) => sum + e.confidence, 0) / entities.length;
|
||||
const relationshipConfidence = relationships.reduce((sum, r) => sum + r.confidence, 0) / relationships.length;
|
||||
return (entityConfidence + relationshipConfidence) / 2;
|
||||
}
|
||||
async generatePreview(entities, relationships) {
|
||||
return entities.slice(0, 5).map(entity => ({
|
||||
id: entity.suggestedId,
|
||||
nounType: entity.nounType,
|
||||
data: entity.originalData,
|
||||
relationships: relationships
|
||||
.filter(r => r.sourceId === entity.suggestedId)
|
||||
.slice(0, 3)
|
||||
.map(r => ({
|
||||
target: r.targetId,
|
||||
verbType: r.verbType,
|
||||
weight: r.weight,
|
||||
confidence: r.confidence
|
||||
}))
|
||||
}));
|
||||
}
|
||||
async confirmNeuralImport(result) {
|
||||
const { confirm } = await prompts({
|
||||
type: 'confirm',
|
||||
name: 'confirm',
|
||||
message: `${this.emojis.rocket} Execute neural import?`,
|
||||
initial: true
|
||||
});
|
||||
return confirm;
|
||||
}
|
||||
async executeNeuralImport(result, options) {
|
||||
const spinner = ora(`${this.emojis.gear} Executing neural import...`).start();
|
||||
try {
|
||||
// Add entities to Brainy
|
||||
for (const entity of result.detectedEntities) {
|
||||
await this.brainy.add({
|
||||
data: this.extractMainText(entity.originalData),
|
||||
type: entity.nounType,
|
||||
metadata: {
|
||||
...entity.originalData,
|
||||
confidence: entity.confidence,
|
||||
id: entity.suggestedId
|
||||
}
|
||||
});
|
||||
}
|
||||
// Add relationships to Brainy
|
||||
for (const relationship of result.detectedRelationships) {
|
||||
await this.brainy.relate({
|
||||
from: relationship.sourceId,
|
||||
to: relationship.targetId,
|
||||
type: relationship.verbType,
|
||||
weight: relationship.weight,
|
||||
metadata: {
|
||||
confidence: relationship.confidence,
|
||||
context: relationship.context,
|
||||
...relationship.metadata
|
||||
}
|
||||
});
|
||||
}
|
||||
spinner.succeed(this.colors.success(`${this.emojis.check} Neural import complete! ` +
|
||||
`${result.detectedEntities.length} entities and ` +
|
||||
`${result.detectedRelationships.length} relationships imported.`));
|
||||
}
|
||||
catch (error) {
|
||||
spinner.fail('Neural import failed');
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
async generateRelationshipReasoning(source, target, verbType, context) {
|
||||
return `Neural analysis detected ${verbType} relationship based on semantic context`;
|
||||
}
|
||||
extractRelationshipMetadata(sourceData, targetData, verbType) {
|
||||
return {
|
||||
sourceType: typeof sourceData,
|
||||
targetType: typeof targetData,
|
||||
detectedBy: 'neural-import',
|
||||
timestamp: new Date().toISOString()
|
||||
};
|
||||
}
|
||||
}
|
||||
//# sourceMappingURL=neuralImport.js.map
|
||||
File diff suppressed because one or more lines are too long
150
.recovery-workspace/dist-backup-20250910-141917/cortex/performanceMonitor.d.ts
vendored
Normal file
150
.recovery-workspace/dist-backup-20250910-141917/cortex/performanceMonitor.d.ts
vendored
Normal file
|
|
@ -0,0 +1,150 @@
|
|||
/**
|
||||
* Performance Monitor - Atomic Age Intelligence Observatory
|
||||
*
|
||||
* 🧠 Real-time performance tracking for vector + graph operations
|
||||
* ⚛️ Monitors query performance, storage usage, and system health
|
||||
* 🚀 Scalable performance analytics with atomic age aesthetics
|
||||
*/
|
||||
import { Brainy } from '../brainy.js';
|
||||
export interface PerformanceMetrics {
|
||||
queryLatency: {
|
||||
vector: {
|
||||
avg: number;
|
||||
p50: number;
|
||||
p95: number;
|
||||
p99: number;
|
||||
};
|
||||
graph: {
|
||||
avg: number;
|
||||
p50: number;
|
||||
p95: number;
|
||||
p99: number;
|
||||
};
|
||||
combined: {
|
||||
avg: number;
|
||||
p50: number;
|
||||
p95: number;
|
||||
p99: number;
|
||||
};
|
||||
};
|
||||
throughput: {
|
||||
vectorOps: number;
|
||||
graphOps: number;
|
||||
totalOps: number;
|
||||
};
|
||||
storage: {
|
||||
readLatency: number;
|
||||
writeLatency: number;
|
||||
cacheHitRate: number;
|
||||
totalSize: number;
|
||||
growthRate: number;
|
||||
};
|
||||
memory: {
|
||||
heapUsed: number;
|
||||
heapTotal: number;
|
||||
vectorCache: number;
|
||||
graphCache: number;
|
||||
efficiency: number;
|
||||
};
|
||||
errors: {
|
||||
total: number;
|
||||
rate: number;
|
||||
types: {
|
||||
[key: string]: number;
|
||||
};
|
||||
};
|
||||
health: {
|
||||
overall: number;
|
||||
vector: number;
|
||||
graph: number;
|
||||
storage: number;
|
||||
network: number;
|
||||
};
|
||||
timestamp: string;
|
||||
uptime: number;
|
||||
}
|
||||
export interface AlertRule {
|
||||
id: string;
|
||||
name: string;
|
||||
condition: string;
|
||||
threshold: number;
|
||||
severity: 'low' | 'medium' | 'high' | 'critical';
|
||||
action?: string;
|
||||
enabled: boolean;
|
||||
}
|
||||
export interface PerformanceAlert {
|
||||
id: string;
|
||||
rule: AlertRule;
|
||||
triggered: string;
|
||||
value: number;
|
||||
message: string;
|
||||
resolved?: string;
|
||||
}
|
||||
/**
|
||||
* Real-time Performance Monitoring System
|
||||
*/
|
||||
export declare class PerformanceMonitor {
|
||||
private brainy;
|
||||
private metrics;
|
||||
private alerts;
|
||||
private alertRules;
|
||||
private isMonitoring;
|
||||
private monitoringInterval?;
|
||||
private colors;
|
||||
private emojis;
|
||||
constructor(brainy: Brainy);
|
||||
/**
|
||||
* Start real-time monitoring
|
||||
*/
|
||||
startMonitoring(intervalMs?: number): Promise<void>;
|
||||
/**
|
||||
* Stop monitoring
|
||||
*/
|
||||
stopMonitoring(): void;
|
||||
/**
|
||||
* Get current performance metrics
|
||||
*/
|
||||
getCurrentMetrics(): Promise<PerformanceMetrics>;
|
||||
/**
|
||||
* Get performance dashboard data
|
||||
*/
|
||||
getDashboard(): Promise<{
|
||||
current: PerformanceMetrics;
|
||||
trends: PerformanceMetrics[];
|
||||
alerts: PerformanceAlert[];
|
||||
health: string;
|
||||
}>;
|
||||
/**
|
||||
* Display performance dashboard in terminal
|
||||
*/
|
||||
displayDashboard(): Promise<void>;
|
||||
/**
|
||||
* Collect current performance metrics
|
||||
*/
|
||||
private collectMetrics;
|
||||
/**
|
||||
* Initialize default alert rules
|
||||
*/
|
||||
private initializeDefaultAlerts;
|
||||
/**
|
||||
* Check alerts against current metrics
|
||||
*/
|
||||
private checkAlerts;
|
||||
/**
|
||||
* Evaluate alert condition against metrics
|
||||
*/
|
||||
private evaluateCondition;
|
||||
/**
|
||||
* Get metric value by dot notation path
|
||||
*/
|
||||
private getMetricValue;
|
||||
/**
|
||||
* Helper methods
|
||||
*/
|
||||
private getHealthStatus;
|
||||
private getHealthIcon;
|
||||
private getHealthBar;
|
||||
private getSeverityIcon;
|
||||
private formatUptime;
|
||||
private formatBytes;
|
||||
}
|
||||
|
|
@ -0,0 +1,371 @@
|
|||
/**
|
||||
* Performance Monitor - Atomic Age Intelligence Observatory
|
||||
*
|
||||
* 🧠 Real-time performance tracking for vector + graph operations
|
||||
* ⚛️ Monitors query performance, storage usage, and system health
|
||||
* 🚀 Scalable performance analytics with atomic age aesthetics
|
||||
*/
|
||||
// @ts-ignore
|
||||
import chalk from 'chalk';
|
||||
// @ts-ignore
|
||||
import boxen from 'boxen';
|
||||
/**
|
||||
* Real-time Performance Monitoring System
|
||||
*/
|
||||
export class PerformanceMonitor {
|
||||
constructor(brainy) {
|
||||
this.metrics = [];
|
||||
this.alerts = [];
|
||||
this.alertRules = [];
|
||||
this.isMonitoring = false;
|
||||
this.colors = {
|
||||
primary: chalk.hex('#3A5F4A'),
|
||||
success: chalk.hex('#2D4A3A'),
|
||||
warning: chalk.hex('#D67441'),
|
||||
error: chalk.hex('#B85C35'),
|
||||
info: chalk.hex('#4A6B5A'),
|
||||
dim: chalk.hex('#8A9B8A'),
|
||||
highlight: chalk.hex('#E88B5A'),
|
||||
accent: chalk.hex('#F5E6D3'),
|
||||
brain: chalk.hex('#E88B5A')
|
||||
};
|
||||
this.emojis = {
|
||||
brain: '🧠',
|
||||
atom: '⚛️',
|
||||
monitor: '📊',
|
||||
alert: '🚨',
|
||||
health: '💚',
|
||||
warning: '⚠️',
|
||||
critical: '🔥',
|
||||
rocket: '🚀',
|
||||
gear: '⚙️',
|
||||
chart: '📈',
|
||||
lightning: '⚡',
|
||||
shield: '🛡️'
|
||||
};
|
||||
this.brainy = brainy;
|
||||
this.initializeDefaultAlerts();
|
||||
}
|
||||
/**
|
||||
* Start real-time monitoring
|
||||
*/
|
||||
async startMonitoring(intervalMs = 30000) {
|
||||
if (this.isMonitoring) {
|
||||
console.log(this.colors.warning('Monitoring already running'));
|
||||
return;
|
||||
}
|
||||
console.log(boxen(`${this.emojis.monitor} ${this.colors.brain('ATOMIC PERFORMANCE OBSERVATORY')} ${this.emojis.atom}\n\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Initiating neural performance monitoring')}` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Monitoring Interval:')} ${this.colors.highlight(intervalMs + 'ms')}\n` +
|
||||
`${this.colors.accent('◆')} ${this.colors.dim('Vector + Graph Analytics:')} ${this.colors.highlight('Enabled')}`, { padding: 1, borderStyle: 'round', borderColor: '#E88B5A' }));
|
||||
this.isMonitoring = true;
|
||||
this.monitoringInterval = setInterval(async () => {
|
||||
try {
|
||||
const metrics = await this.collectMetrics();
|
||||
this.metrics.push(metrics);
|
||||
// Keep only last 1000 metrics (rolling window)
|
||||
if (this.metrics.length > 1000) {
|
||||
this.metrics = this.metrics.slice(-1000);
|
||||
}
|
||||
// Check alerts
|
||||
await this.checkAlerts(metrics);
|
||||
}
|
||||
catch (error) {
|
||||
console.error('Error collecting metrics:', error);
|
||||
}
|
||||
}, intervalMs);
|
||||
console.log(this.colors.success(`${this.emojis.rocket} Performance monitoring started - neural pathways under observation`));
|
||||
}
|
||||
/**
|
||||
* Stop monitoring
|
||||
*/
|
||||
stopMonitoring() {
|
||||
if (!this.isMonitoring) {
|
||||
console.log(this.colors.warning('Monitoring not running'));
|
||||
return;
|
||||
}
|
||||
if (this.monitoringInterval) {
|
||||
clearInterval(this.monitoringInterval);
|
||||
}
|
||||
this.isMonitoring = false;
|
||||
console.log(this.colors.info(`${this.emojis.gear} Performance monitoring stopped`));
|
||||
}
|
||||
/**
|
||||
* Get current performance metrics
|
||||
*/
|
||||
async getCurrentMetrics() {
|
||||
return await this.collectMetrics();
|
||||
}
|
||||
/**
|
||||
* Get performance dashboard data
|
||||
*/
|
||||
async getDashboard() {
|
||||
const current = await this.collectMetrics();
|
||||
const activeAlerts = this.alerts.filter(a => !a.resolved);
|
||||
return {
|
||||
current,
|
||||
trends: this.metrics.slice(-100), // Last 100 data points
|
||||
alerts: activeAlerts,
|
||||
health: this.getHealthStatus(current)
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Display performance dashboard in terminal
|
||||
*/
|
||||
async displayDashboard() {
|
||||
const dashboard = await this.getDashboard();
|
||||
const metrics = dashboard.current;
|
||||
console.clear();
|
||||
// Header
|
||||
console.log(boxen(`${this.emojis.brain} ${this.colors.brain('BRAINY PERFORMANCE DASHBOARD')} ${this.emojis.atom}\n` +
|
||||
`${this.colors.dim('Real-time Vector + Graph Database Performance')}\n` +
|
||||
`${this.colors.accent('Uptime:')} ${this.colors.highlight(this.formatUptime(metrics.uptime))} | ` +
|
||||
`${this.colors.accent('Health:')} ${this.getHealthIcon(metrics.health.overall)} ${this.colors.primary(metrics.health.overall + '/100')}`, { padding: 1, borderStyle: 'double', borderColor: '#E88B5A', width: 80 }));
|
||||
// Query Performance Section
|
||||
console.log('\n' + this.colors.brain(`${this.emojis.lightning} QUERY PERFORMANCE`));
|
||||
console.log(boxen(`${this.colors.accent('Vector Queries:')} ${this.colors.primary(metrics.queryLatency.vector.avg.toFixed(1) + 'ms avg')} | ` +
|
||||
`${this.colors.accent('P95:')} ${this.colors.highlight(metrics.queryLatency.vector.p95.toFixed(1) + 'ms')}\n` +
|
||||
`${this.colors.accent('Graph Queries:')} ${this.colors.primary(metrics.queryLatency.graph.avg.toFixed(1) + 'ms avg')} | ` +
|
||||
`${this.colors.accent('P95:')} ${this.colors.highlight(metrics.queryLatency.graph.p95.toFixed(1) + 'ms')}\n` +
|
||||
`${this.colors.accent('Combined Ops:')} ${this.colors.success(metrics.throughput.totalOps.toFixed(0) + ' ops/sec')}`, { padding: 1, borderStyle: 'round', borderColor: '#3A5F4A' }));
|
||||
// Storage & Memory Section
|
||||
console.log('\n' + this.colors.brain(`${this.emojis.shield} STORAGE & MEMORY`));
|
||||
console.log(boxen(`${this.colors.accent('Storage Size:')} ${this.colors.primary(this.formatBytes(metrics.storage.totalSize))} | ` +
|
||||
`${this.colors.accent('Growth:')} ${this.colors.highlight(metrics.storage.growthRate.toFixed(1) + '/hr')}\n` +
|
||||
`${this.colors.accent('Cache Hit Rate:')} ${this.colors.success((metrics.storage.cacheHitRate * 100).toFixed(1) + '%')} | ` +
|
||||
`${this.colors.accent('Memory:')} ${this.colors.primary(metrics.memory.heapUsed.toFixed(0) + 'MB')}\n` +
|
||||
`${this.colors.accent('Vector Cache:')} ${this.colors.info(metrics.memory.vectorCache.toFixed(1) + 'MB')} | ` +
|
||||
`${this.colors.accent('Graph Cache:')} ${this.colors.info(metrics.memory.graphCache.toFixed(1) + 'MB')}`, { padding: 1, borderStyle: 'round', borderColor: '#4A6B5A' }));
|
||||
// Health Scores Section
|
||||
console.log('\n' + this.colors.brain(`${this.emojis.health} SYSTEM HEALTH`));
|
||||
console.log(boxen(`${this.colors.accent('Vector Operations:')} ${this.getHealthBar(metrics.health.vector)} ${this.colors.primary(metrics.health.vector + '/100')}\n` +
|
||||
`${this.colors.accent('Graph Operations:')} ${this.getHealthBar(metrics.health.graph)} ${this.colors.primary(metrics.health.graph + '/100')}\n` +
|
||||
`${this.colors.accent('Storage System:')} ${this.getHealthBar(metrics.health.storage)} ${this.colors.primary(metrics.health.storage + '/100')}\n` +
|
||||
`${this.colors.accent('Network/Connectivity:')} ${this.getHealthBar(metrics.health.network)} ${this.colors.primary(metrics.health.network + '/100')}`, { padding: 1, borderStyle: 'round', borderColor: '#2D4A3A' }));
|
||||
// Active Alerts
|
||||
if (dashboard.alerts.length > 0) {
|
||||
console.log('\n' + this.colors.error(`${this.emojis.alert} ACTIVE ALERTS`));
|
||||
dashboard.alerts.forEach(alert => {
|
||||
const severityColor = alert.rule.severity === 'critical' ? this.colors.error :
|
||||
alert.rule.severity === 'high' ? this.colors.warning :
|
||||
this.colors.info;
|
||||
console.log(severityColor(` ${this.getSeverityIcon(alert.rule.severity)} ${alert.message}`));
|
||||
});
|
||||
}
|
||||
// Footer
|
||||
console.log('\n' + this.colors.dim(`Last updated: ${new Date().toLocaleTimeString()} | Press Ctrl+C to exit`));
|
||||
}
|
||||
/**
|
||||
* Collect current performance metrics
|
||||
*/
|
||||
async collectMetrics() {
|
||||
const now = Date.now();
|
||||
const uptime = process.uptime();
|
||||
// Simulate metrics collection (in real implementation, this would query actual systems)
|
||||
const metrics = {
|
||||
queryLatency: {
|
||||
vector: {
|
||||
avg: Math.random() * 50 + 10,
|
||||
p50: Math.random() * 40 + 8,
|
||||
p95: Math.random() * 100 + 30,
|
||||
p99: Math.random() * 200 + 50
|
||||
},
|
||||
graph: {
|
||||
avg: Math.random() * 30 + 5,
|
||||
p50: Math.random() * 25 + 4,
|
||||
p95: Math.random() * 80 + 15,
|
||||
p99: Math.random() * 150 + 25
|
||||
},
|
||||
combined: {
|
||||
avg: Math.random() * 40 + 7,
|
||||
p50: Math.random() * 35 + 6,
|
||||
p95: Math.random() * 90 + 20,
|
||||
p99: Math.random() * 180 + 40
|
||||
}
|
||||
},
|
||||
throughput: {
|
||||
vectorOps: Math.random() * 1000 + 500,
|
||||
graphOps: Math.random() * 800 + 300,
|
||||
totalOps: Math.random() * 1500 + 800
|
||||
},
|
||||
storage: {
|
||||
readLatency: Math.random() * 20 + 2,
|
||||
writeLatency: Math.random() * 30 + 5,
|
||||
cacheHitRate: 0.85 + Math.random() * 0.1,
|
||||
totalSize: 1024 * 1024 * 1024 * (10 + Math.random() * 50), // 10-60 GB
|
||||
growthRate: Math.random() * 100 + 10
|
||||
},
|
||||
memory: {
|
||||
heapUsed: process.memoryUsage().heapUsed / (1024 * 1024),
|
||||
heapTotal: process.memoryUsage().heapTotal / (1024 * 1024),
|
||||
vectorCache: Math.random() * 500 + 100,
|
||||
graphCache: Math.random() * 300 + 50,
|
||||
efficiency: 0.75 + Math.random() * 0.2
|
||||
},
|
||||
errors: {
|
||||
total: Math.floor(Math.random() * 10),
|
||||
rate: Math.random() * 2,
|
||||
types: {
|
||||
'timeout': Math.floor(Math.random() * 3),
|
||||
'network': Math.floor(Math.random() * 2),
|
||||
'storage': Math.floor(Math.random() * 2)
|
||||
}
|
||||
},
|
||||
health: {
|
||||
overall: Math.floor(85 + Math.random() * 15),
|
||||
vector: Math.floor(80 + Math.random() * 20),
|
||||
graph: Math.floor(85 + Math.random() * 15),
|
||||
storage: Math.floor(90 + Math.random() * 10),
|
||||
network: Math.floor(85 + Math.random() * 15)
|
||||
},
|
||||
timestamp: new Date().toISOString(),
|
||||
uptime
|
||||
};
|
||||
return metrics;
|
||||
}
|
||||
/**
|
||||
* Initialize default alert rules
|
||||
*/
|
||||
initializeDefaultAlerts() {
|
||||
this.alertRules = [
|
||||
{
|
||||
id: 'vector-latency-high',
|
||||
name: 'Vector Query Latency High',
|
||||
condition: 'queryLatency.vector.p95 > 200',
|
||||
threshold: 200,
|
||||
severity: 'medium',
|
||||
enabled: true
|
||||
},
|
||||
{
|
||||
id: 'graph-latency-high',
|
||||
name: 'Graph Query Latency High',
|
||||
condition: 'queryLatency.graph.p95 > 150',
|
||||
threshold: 150,
|
||||
severity: 'medium',
|
||||
enabled: true
|
||||
},
|
||||
{
|
||||
id: 'memory-high',
|
||||
name: 'Memory Usage High',
|
||||
condition: 'memory.heapUsed > 1000',
|
||||
threshold: 1000,
|
||||
severity: 'high',
|
||||
enabled: true
|
||||
},
|
||||
{
|
||||
id: 'cache-hit-low',
|
||||
name: 'Cache Hit Rate Low',
|
||||
condition: 'storage.cacheHitRate < 0.7',
|
||||
threshold: 0.7,
|
||||
severity: 'medium',
|
||||
enabled: true
|
||||
},
|
||||
{
|
||||
id: 'error-rate-high',
|
||||
name: 'Error Rate High',
|
||||
condition: 'errors.rate > 5',
|
||||
threshold: 5,
|
||||
severity: 'high',
|
||||
enabled: true
|
||||
}
|
||||
];
|
||||
}
|
||||
/**
|
||||
* Check alerts against current metrics
|
||||
*/
|
||||
async checkAlerts(metrics) {
|
||||
for (const rule of this.alertRules) {
|
||||
if (!rule.enabled)
|
||||
continue;
|
||||
const value = this.evaluateCondition(rule.condition, metrics);
|
||||
const isTriggered = value > rule.threshold;
|
||||
const existingAlert = this.alerts.find(a => a.rule.id === rule.id && !a.resolved);
|
||||
if (isTriggered && !existingAlert) {
|
||||
// Trigger new alert
|
||||
const alert = {
|
||||
id: `${rule.id}-${Date.now()}`,
|
||||
rule,
|
||||
triggered: new Date().toISOString(),
|
||||
value,
|
||||
message: `${rule.name}: ${value.toFixed(2)} > ${rule.threshold}`
|
||||
};
|
||||
this.alerts.push(alert);
|
||||
console.log(this.colors.warning(`${this.emojis.alert} ALERT: ${alert.message}`));
|
||||
}
|
||||
else if (!isTriggered && existingAlert) {
|
||||
// Resolve existing alert
|
||||
existingAlert.resolved = new Date().toISOString();
|
||||
console.log(this.colors.success(`${this.emojis.health} RESOLVED: ${existingAlert.message}`));
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Evaluate alert condition against metrics
|
||||
*/
|
||||
evaluateCondition(condition, metrics) {
|
||||
// Simple condition evaluation (in real implementation, use a proper expression parser)
|
||||
const parts = condition.split(' ');
|
||||
if (parts.length !== 3)
|
||||
return 0;
|
||||
const path = parts[0];
|
||||
const value = this.getMetricValue(path, metrics);
|
||||
return typeof value === 'number' ? value : 0;
|
||||
}
|
||||
/**
|
||||
* Get metric value by dot notation path
|
||||
*/
|
||||
getMetricValue(path, metrics) {
|
||||
return path.split('.').reduce((obj, key) => obj?.[key], metrics);
|
||||
}
|
||||
/**
|
||||
* Helper methods
|
||||
*/
|
||||
getHealthStatus(metrics) {
|
||||
const score = metrics.health.overall;
|
||||
if (score >= 90)
|
||||
return 'excellent';
|
||||
if (score >= 75)
|
||||
return 'good';
|
||||
if (score >= 60)
|
||||
return 'fair';
|
||||
return 'poor';
|
||||
}
|
||||
getHealthIcon(score) {
|
||||
if (score >= 90)
|
||||
return this.emojis.health;
|
||||
if (score >= 75)
|
||||
return '💛';
|
||||
if (score >= 60)
|
||||
return this.emojis.warning;
|
||||
return this.emojis.critical;
|
||||
}
|
||||
getHealthBar(score) {
|
||||
const filled = Math.floor(score / 10);
|
||||
const empty = 10 - filled;
|
||||
return this.colors.success('█'.repeat(filled)) + this.colors.dim('░'.repeat(empty));
|
||||
}
|
||||
getSeverityIcon(severity) {
|
||||
switch (severity) {
|
||||
case 'critical': return this.emojis.critical;
|
||||
case 'high': return this.emojis.alert;
|
||||
case 'medium': return this.emojis.warning;
|
||||
default: return this.emojis.gear;
|
||||
}
|
||||
}
|
||||
formatUptime(seconds) {
|
||||
const hours = Math.floor(seconds / 3600);
|
||||
const minutes = Math.floor((seconds % 3600) / 60);
|
||||
return `${hours}h ${minutes}m`;
|
||||
}
|
||||
formatBytes(bytes) {
|
||||
const units = ['B', 'KB', 'MB', 'GB', 'TB'];
|
||||
let size = bytes;
|
||||
let unitIndex = 0;
|
||||
while (size >= 1024 && unitIndex < units.length - 1) {
|
||||
size /= 1024;
|
||||
unitIndex++;
|
||||
}
|
||||
return `${size.toFixed(1)} ${units[unitIndex]}`;
|
||||
}
|
||||
}
|
||||
//# sourceMappingURL=performanceMonitor.js.map
|
||||
File diff suppressed because one or more lines are too long
Loading…
Add table
Add a link
Reference in a new issue