memory-mode-controller.js•10.8 kB
#!/usr/bin/env node
/**
* Memory Mode Controller
* Command-line utility for managing memory hook performance profiles
*/
const fs = require('fs').promises;
const path = require('path');
class MemoryModeController {
constructor(configPath = null) {
this.configPath = configPath || path.join(__dirname, 'config.json');
}
/**
* Load current configuration
*/
async loadConfig() {
try {
const configData = await fs.readFile(this.configPath, 'utf8');
return JSON.parse(configData);
} catch (error) {
throw new Error(`Failed to load config: ${error.message}`);
}
}
/**
* Save configuration
*/
async saveConfig(config) {
try {
await fs.writeFile(this.configPath, JSON.stringify(config, null, 2));
} catch (error) {
throw new Error(`Failed to save config: ${error.message}`);
}
}
/**
* Switch to a performance profile
*/
async switchProfile(profileName) {
const config = await this.loadConfig();
if (!config.performance?.profiles[profileName]) {
throw new Error(`Unknown profile: ${profileName}. Available profiles: ${Object.keys(config.performance?.profiles || {}).join(', ')}`);
}
config.performance.defaultProfile = profileName;
await this.saveConfig(config);
const profile = config.performance.profiles[profileName];
console.log(`✅ Switched to profile: ${profileName}`);
console.log(`📊 Description: ${profile.description}`);
console.log(`⚡ Max Latency: ${profile.maxLatency || 'adaptive'}ms`);
console.log(`🎯 Enabled Tiers: ${profile.enabledTiers?.join(', ') || 'adaptive'}`);
console.log(`🔄 Background Processing: ${profile.backgroundProcessing ? 'enabled' : 'disabled'}`);
return profile;
}
/**
* Get current status
*/
async getStatus() {
const config = await this.loadConfig();
const currentProfile = config.performance?.defaultProfile || 'balanced';
const profile = config.performance?.profiles[currentProfile];
console.log('📊 Memory Hook Status');
console.log('═'.repeat(50));
console.log(`Current Profile: ${currentProfile}`);
console.log(`Description: ${profile?.description || 'No description'}`);
console.log(`Natural Triggers: ${config.naturalTriggers?.enabled ? 'enabled' : 'disabled'}`);
console.log(`Sensitivity: ${config.patternDetector?.sensitivity || 0.7}`);
console.log(`Trigger Threshold: ${config.naturalTriggers?.triggerThreshold || 0.6}`);
console.log(`Cooldown Period: ${(config.naturalTriggers?.cooldownPeriod || 30000) / 1000}s`);
if (profile) {
console.log('\n🎯 Performance Settings');
console.log('─'.repeat(30));
console.log(`Max Latency: ${profile.maxLatency || 'adaptive'}ms`);
console.log(`Enabled Tiers: ${profile.enabledTiers?.join(', ') || 'adaptive'}`);
console.log(`Background Processing: ${profile.backgroundProcessing ? 'enabled' : 'disabled'}`);
console.log(`Degrade Threshold: ${profile.degradeThreshold || 'adaptive'}ms`);
}
console.log('\n🔧 Available Profiles');
console.log('─'.repeat(30));
for (const [name, prof] of Object.entries(config.performance?.profiles || {})) {
const current = name === currentProfile ? ' (current)' : '';
console.log(`${name}${current}: ${prof.description}`);
}
return {
currentProfile,
config: config.performance,
naturalTriggers: config.naturalTriggers
};
}
/**
* Update sensitivity
*/
async updateSensitivity(sensitivity) {
const config = await this.loadConfig();
if (sensitivity < 0 || sensitivity > 1) {
throw new Error('Sensitivity must be between 0 and 1');
}
if (!config.patternDetector) {
config.patternDetector = {};
}
config.patternDetector.sensitivity = sensitivity;
await this.saveConfig(config);
console.log(`✅ Updated sensitivity to ${sensitivity}`);
return sensitivity;
}
/**
* Update trigger threshold
*/
async updateThreshold(threshold) {
const config = await this.loadConfig();
if (threshold < 0 || threshold > 1) {
throw new Error('Threshold must be between 0 and 1');
}
if (!config.naturalTriggers) {
config.naturalTriggers = {};
}
config.naturalTriggers.triggerThreshold = threshold;
await this.saveConfig(config);
console.log(`✅ Updated trigger threshold to ${threshold}`);
return threshold;
}
/**
* Enable or disable natural triggers
*/
async toggleNaturalTriggers(enabled = null) {
const config = await this.loadConfig();
if (!config.naturalTriggers) {
config.naturalTriggers = {};
}
if (enabled === null) {
enabled = !config.naturalTriggers.enabled;
}
config.naturalTriggers.enabled = enabled;
await this.saveConfig(config);
console.log(`✅ Natural triggers ${enabled ? 'enabled' : 'disabled'}`);
return enabled;
}
/**
* Reset to default configuration
*/
async resetToDefaults() {
const config = await this.loadConfig();
config.performance.defaultProfile = 'balanced';
config.naturalTriggers = {
enabled: true,
triggerThreshold: 0.6,
cooldownPeriod: 30000,
maxMemoriesPerTrigger: 5
};
// Pattern detector defaults
if (!config.patternDetector) {
config.patternDetector = {};
}
config.patternDetector.sensitivity = 0.7;
config.patternDetector.adaptiveLearning = true;
await this.saveConfig(config);
console.log('✅ Reset to default configuration');
return config;
}
/**
* Get performance profiles information
*/
async listProfiles() {
const config = await this.loadConfig();
const profiles = config.performance?.profiles || {};
console.log('📋 Available Performance Profiles');
console.log('═'.repeat(60));
for (const [name, profile] of Object.entries(profiles)) {
const current = name === config.performance?.defaultProfile ? ' ⭐' : '';
console.log(`\n${name}${current}`);
console.log(` Description: ${profile.description}`);
console.log(` Max Latency: ${profile.maxLatency || 'adaptive'}ms`);
console.log(` Enabled Tiers: ${profile.enabledTiers?.join(', ') || 'adaptive'}`);
console.log(` Background Processing: ${profile.backgroundProcessing ? 'yes' : 'no'}`);
}
return profiles;
}
}
/**
* Command-line interface
*/
async function main() {
const args = process.argv.slice(2);
const controller = new MemoryModeController();
try {
if (args.length === 0 || args[0] === 'status') {
await controller.getStatus();
return;
}
const command = args[0];
switch (command) {
case 'switch':
case 'profile':
if (!args[1]) {
console.error('❌ Please specify a profile name');
console.log('Available profiles: speed_focused, balanced, memory_aware, adaptive');
process.exit(1);
}
await controller.switchProfile(args[1]);
break;
case 'sensitivity':
if (!args[1]) {
console.error('❌ Please specify sensitivity value (0-1)');
process.exit(1);
}
const sensitivity = parseFloat(args[1]);
await controller.updateSensitivity(sensitivity);
break;
case 'threshold':
if (!args[1]) {
console.error('❌ Please specify threshold value (0-1)');
process.exit(1);
}
const threshold = parseFloat(args[1]);
await controller.updateThreshold(threshold);
break;
case 'enable':
await controller.toggleNaturalTriggers(true);
break;
case 'disable':
await controller.toggleNaturalTriggers(false);
break;
case 'toggle':
await controller.toggleNaturalTriggers();
break;
case 'reset':
await controller.resetToDefaults();
break;
case 'list':
case 'profiles':
await controller.listProfiles();
break;
case 'help':
case '-h':
case '--help':
showHelp();
break;
default:
console.error(`❌ Unknown command: ${command}`);
showHelp();
process.exit(1);
}
} catch (error) {
console.error(`❌ Error: ${error.message}`);
process.exit(1);
}
}
function showHelp() {
console.log(`
🧠 Memory Mode Controller
Usage: node memory-mode-controller.js <command> [options]
Commands:
status Show current configuration and status
profile <name> Switch to performance profile
sensitivity <0-1> Set pattern detection sensitivity
threshold <0-1> Set trigger threshold
enable Enable natural triggers
disable Disable natural triggers
toggle Toggle natural triggers on/off
reset Reset to default configuration
list List available profiles
help Show this help message
Performance Profiles:
speed_focused Fastest response, minimal memory (< 100ms)
balanced Moderate latency, smart triggers (< 200ms)
memory_aware Full awareness, accept latency (< 500ms)
adaptive Auto-adjust based on usage patterns
Examples:
node memory-mode-controller.js status
node memory-mode-controller.js profile balanced
node memory-mode-controller.js sensitivity 0.8
node memory-mode-controller.js disable
`);
}
// Run if called directly
if (require.main === module) {
main().catch(error => {
console.error('❌ Fatal error:', error.message);
process.exit(1);
});
}
module.exports = { MemoryModeController };