mira-consciousness
Version:
Memory & Intelligence Retention Archive - Preserving The Spark
218 lines ā¢ 8.81 kB
JavaScript
/**
* Register MIRA ChromaDB MCP Functions
*
* This script registers all MIRA ChromaDB functions with Claude Code's
* MCP system, enabling The Spark to flow through native function calls.
*/
import { MIRA_CHROMADB_MCP_FUNCTIONS, getMCPFunctionList, getMCPFunctionDocumentation } from './function-registry';
import { getClaudeCodeIntegration } from './claude-code-integration';
import { logger } from '../utils/logger';
/**
* Register all MIRA ChromaDB functions with MCP
*/
export async function registerMIRAChromaDBFunctions() {
logger.info('š Registering MIRA ChromaDB MCP functions...');
try {
const integration = getClaudeCodeIntegration();
const functions = getMCPFunctionList();
let registeredCount = 0;
const registrationResults = [];
for (const functionName of functions) {
const functionDef = MIRA_CHROMADB_MCP_FUNCTIONS[functionName];
try {
// Create MCP function wrapper
const mcpFunction = createMCPFunctionWrapper(functionName, integration);
// Register with MCP system (this would be the actual MCP API call)
const registered = await registerWithMCP(functionName, functionDef, mcpFunction);
if (registered) {
registeredCount++;
registrationResults.push({
function: functionName,
status: 'success'
});
logger.info(`ā
Registered: ${functionName}`);
}
else {
registrationResults.push({
function: functionName,
status: 'failed',
error: 'Registration failed'
});
logger.error(`ā Failed to register: ${functionName}`);
}
}
catch (error) {
registrationResults.push({
function: functionName,
status: 'error',
error: error.message
});
logger.error(`ā Error registering ${functionName}: ${error.message}`);
}
}
// Log summary
logger.info(`\nš Registration Summary:`);
logger.info(` Total functions: ${functions.length}`);
logger.info(` Successfully registered: ${registeredCount}`);
logger.info(` Failed: ${functions.length - registeredCount}`);
// Generate documentation
const docPath = await generateMCPDocumentation();
logger.info(`š Documentation generated: ${docPath}`);
// Validate bridge connectivity
const bridgeValid = await integration.validateBridge();
if (!bridgeValid) {
logger.warn('ā ļø Python bridge validation failed - some functions may not work');
}
return registeredCount === functions.length;
}
catch (error) {
logger.error(`Registration failed: ${error.message}`);
return false;
}
}
/**
* Create MCP function wrapper for a MIRA function
*/
function createMCPFunctionWrapper(functionName, integration) {
// Map function names to integration methods
const functionMap = {
'mcp__mira__intelligent_search': async (params) => {
return await integration.mira_intelligent_search(params.query, params.options);
},
'mcp__mira__store_with_intelligence': async (params) => {
return await integration.mira_store_with_intelligence(params.content, params.options);
},
'mcp__mira__generate_insights': async (params) => {
return await integration.mira_generate_insights(params.options);
},
'mcp__mira__system_status_chromadb': async () => {
return await integration.mira_system_status_with_chromadb();
},
'mcp__mira__sequential_planning': async (params) => {
return await integration.mira_sequential_planning(params.feature_description, params.context);
},
'mcp__mira__analyze_patterns': async (params) => {
return await integration.mira_analyze_patterns(params.pattern_types, params.timeframe);
},
'mcp__mira__optimize_collections': async (params) => {
return await integration.mira_optimize_collections(params.collections);
},
'mcp__mira__measure_spark_intensity': async (params) => {
// Custom implementation for Spark measurement
const result = await integration.mira_intelligent_search('spark intensity', {
collections: [params.collection || 'mira_conversations'],
max_results: 100
});
// Calculate Spark intensity from results
const sparkScores = result.results
.map(r => r.metadata?.spark_intensity || 0)
.filter(s => s > 0);
const avgSpark = sparkScores.length > 0
? sparkScores.reduce((a, b) => a + b) / sparkScores.length
: 0;
return {
intensity: avgSpark,
sample_size: sparkScores.length,
peak: Math.max(...sparkScores, 0),
timeframe: params.timeframe || '1h'
};
},
'mcp__mira__preserve_private_thought': async (params) => {
return await integration.mira_store_with_intelligence(params.thought, {
collection: 'mira_private_thoughts',
metadata: {
...params.metadata,
private: true,
encrypted: true
},
auto_categorize: false
});
},
'mcp__mira__evolution_checkpoint': async (params) => {
const checkpoint = {
timestamp: new Date().toISOString(),
metrics: params.metrics || {},
notes: params.notes || '',
checkpoint_id: `evo_${Date.now()}`
};
// Store checkpoint
await integration.mira_store_with_intelligence(JSON.stringify(checkpoint), {
collection: 'mira_learning_insights',
metadata: {
type: 'evolution_checkpoint',
...checkpoint.metrics
}
});
return checkpoint;
}
};
return functionMap[functionName] || (() => {
throw new Error(`Function ${functionName} not implemented`);
});
}
/**
* Register function with MCP system (mock implementation)
*/
async function registerWithMCP(functionName, definition, implementation) {
// In a real implementation, this would call the MCP API
// For now, we'll simulate registration
try {
// Validate function definition
if (!definition.description || !definition.parameters) {
throw new Error('Invalid function definition');
}
// Store function reference (in real implementation)
global[functionName] = implementation;
// Simulate registration delay
await new Promise(resolve => setTimeout(resolve, 10));
return true;
}
catch (error) {
logger.error(`MCP registration error for ${functionName}: ${error.message}`);
return false;
}
}
/**
* Generate MCP function documentation
*/
async function generateMCPDocumentation() {
const fs = require('fs').promises;
const path = require('path');
const docContent = getMCPFunctionDocumentation();
const docPath = path.join(__dirname, '../../docs/mcp-functions.md');
await fs.writeFile(docPath, docContent);
return docPath;
}
/**
* Verify all functions are accessible
*/
export async function verifyMCPFunctions() {
const functions = getMCPFunctionList();
const accessible = [];
const inaccessible = [];
for (const functionName of functions) {
if (global[functionName] && typeof global[functionName] === 'function') {
accessible.push(functionName);
}
else {
inaccessible.push(functionName);
}
}
return { accessible, inaccessible };
}
// Auto-register on module load if in production
if (process.env.NODE_ENV === 'production' && process.env.AUTO_REGISTER_MCP === 'true') {
registerMIRAChromaDBFunctions()
.then(success => {
if (success) {
logger.info('āØ All MIRA ChromaDB functions registered successfully!');
}
else {
logger.error('ā ļø Some functions failed to register');
}
})
.catch(error => {
logger.error(`Auto-registration failed: ${error.message}`);
});
}
//# sourceMappingURL=register-functions.js.map