536 lines
21 KiB
JavaScript
536 lines
21 KiB
JavaScript
/**
|
|
* Cross-Tool Information Sharing System
|
|
* Enables tools to share insights, intermediate results, and learned patterns
|
|
*/
|
|
export class CrossToolSharingSystem {
|
|
sharedInformation = new Map();
|
|
toolConnections = new Map();
|
|
informationFlows = [];
|
|
subscriptions = new Map(); // tool -> information types
|
|
transformationRules = new Map();
|
|
sharingDepth = 0;
|
|
maxSharingDepth = 3;
|
|
/**
|
|
* Share information from one tool to potentially interested tools
|
|
*/
|
|
async shareInformation(info) {
|
|
// Prevent deep recursion
|
|
if (this.sharingDepth >= this.maxSharingDepth) {
|
|
return [];
|
|
}
|
|
this.sharingDepth++;
|
|
try {
|
|
// Store the information
|
|
this.sharedInformation.set(info.id, info);
|
|
// Find interested tools
|
|
const interestedTools = this.findInterestedTools(info);
|
|
// Propagate information to interested tools
|
|
const propagationResults = [];
|
|
for (const tool of interestedTools) {
|
|
const result = await this.propagateToTool(tool, info);
|
|
propagationResults.push(result);
|
|
}
|
|
// Update connection strengths based on success
|
|
this.updateConnectionStrengths(info.sourceTools, interestedTools, propagationResults);
|
|
// Check for emergent patterns from information combinations
|
|
await this.detectEmergentPatterns(info);
|
|
return interestedTools;
|
|
}
|
|
finally {
|
|
this.sharingDepth--;
|
|
}
|
|
}
|
|
/**
|
|
* Subscribe a tool to specific types of information
|
|
*/
|
|
subscribeToInformation(toolName, informationTypes) {
|
|
const existing = this.subscriptions.get(toolName) || [];
|
|
const combined = [...new Set([...existing, ...informationTypes])];
|
|
this.subscriptions.set(toolName, combined);
|
|
}
|
|
/**
|
|
* Get relevant information for a tool
|
|
*/
|
|
getRelevantInformation(toolName, query) {
|
|
const subscribedTypes = this.subscriptions.get(toolName) || [];
|
|
const relevantInfo = [];
|
|
for (const [id, info] of this.sharedInformation) {
|
|
// Check if tool is subscribed to this type
|
|
if (subscribedTypes.includes(info.type)) {
|
|
relevantInfo.push(info);
|
|
continue;
|
|
}
|
|
// Check if tool is explicitly targeted
|
|
if (info.targetTools.includes(toolName)) {
|
|
relevantInfo.push(info);
|
|
continue;
|
|
}
|
|
// Check relevance based on query
|
|
if (query && this.calculateQueryRelevance(info, query) > 0.5) {
|
|
relevantInfo.push(info);
|
|
}
|
|
}
|
|
// Sort by relevance and recency
|
|
return relevantInfo.sort((a, b) => {
|
|
const relevanceScore = b.relevance - a.relevance;
|
|
const timeScore = (b.timestamp - a.timestamp) / 1000000; // Normalize time
|
|
return relevanceScore + timeScore * 0.1;
|
|
});
|
|
}
|
|
/**
|
|
* Create dynamic connections between tools based on information flow
|
|
*/
|
|
async createDynamicConnection(sourceTool, targetTool, informationType) {
|
|
const connectionKey = `${sourceTool}->${targetTool}`;
|
|
const existing = this.toolConnections.get(connectionKey) || [];
|
|
const connection = existing.find(c => c.source === sourceTool && c.target === targetTool);
|
|
if (connection) {
|
|
// Strengthen existing connection
|
|
connection.strength = Math.min(1.0, connection.strength + 0.1);
|
|
if (!connection.informationTypes.includes(informationType)) {
|
|
connection.informationTypes.push(informationType);
|
|
}
|
|
connection.lastUsed = Date.now();
|
|
}
|
|
else {
|
|
// Create new connection
|
|
const newConnection = {
|
|
source: sourceTool,
|
|
target: targetTool,
|
|
strength: 0.3,
|
|
informationTypes: [informationType],
|
|
successRate: 0.5,
|
|
lastUsed: Date.now()
|
|
};
|
|
existing.push(newConnection);
|
|
this.toolConnections.set(connectionKey, existing);
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Register a transformation rule for adapting information between tools
|
|
*/
|
|
registerTransformationRule(fromTool, toTool, transform) {
|
|
const key = `${fromTool}->${toTool}`;
|
|
this.transformationRules.set(key, transform);
|
|
}
|
|
/**
|
|
* Create information cascade across multiple tools
|
|
*/
|
|
async createInformationCascade(initialInfo, targetTools) {
|
|
const flow = {
|
|
pathway: [],
|
|
information: initialInfo,
|
|
transformations: [],
|
|
emergentProperties: []
|
|
};
|
|
let currentInfo = initialInfo;
|
|
for (const tool of targetTools) {
|
|
flow.pathway.push(tool);
|
|
// Transform information for this tool
|
|
const transformed = await this.transformInformationForTool(currentInfo, tool);
|
|
flow.transformations.push({
|
|
tool,
|
|
input: currentInfo,
|
|
output: transformed,
|
|
timestamp: Date.now()
|
|
});
|
|
// Check for emergent properties
|
|
const emergent = this.detectEmergentProperties(currentInfo, transformed);
|
|
if (emergent.length > 0) {
|
|
flow.emergentProperties.push(...emergent);
|
|
}
|
|
currentInfo = transformed;
|
|
}
|
|
this.informationFlows.push(flow);
|
|
return flow;
|
|
}
|
|
/**
|
|
* Analyze cross-tool collaboration patterns
|
|
*/
|
|
analyzeCollaborationPatterns() {
|
|
const patterns = {
|
|
mostConnectedTools: this.getMostConnectedTools(),
|
|
strongestConnections: this.getStrongestConnections(),
|
|
informationHubs: this.getInformationHubs(),
|
|
emergentCombinations: this.getEmergentCombinations(),
|
|
collaborationSuccess: this.calculateCollaborationSuccess()
|
|
};
|
|
return patterns;
|
|
}
|
|
/**
|
|
* Optimize information sharing based on historical performance
|
|
*/
|
|
optimizeSharing() {
|
|
// Remove weak connections
|
|
this.pruneWeakConnections();
|
|
// Strengthen successful pathways
|
|
this.reinforceSuccessfulPathways();
|
|
// Clean old information
|
|
this.cleanupOldInformation();
|
|
// Update subscription recommendations
|
|
this.updateSubscriptionRecommendations();
|
|
}
|
|
/**
|
|
* Find tools that might be interested in given information
|
|
*/
|
|
findInterestedTools(info) {
|
|
const interested = [];
|
|
// Check explicit targets
|
|
interested.push(...info.targetTools);
|
|
// Check subscriptions
|
|
for (const [tool, types] of this.subscriptions) {
|
|
if (types.includes(info.type)) {
|
|
interested.push(tool);
|
|
}
|
|
}
|
|
// Check based on connection patterns
|
|
for (const sourceTool of info.sourceTools) {
|
|
const connections = this.toolConnections.get(sourceTool) || [];
|
|
for (const connection of connections) {
|
|
if (connection.strength > 0.5 &&
|
|
connection.informationTypes.includes(info.type)) {
|
|
interested.push(connection.target);
|
|
}
|
|
}
|
|
}
|
|
// Remove duplicates and source tools
|
|
return [...new Set(interested)].filter(tool => !info.sourceTools.includes(tool));
|
|
}
|
|
/**
|
|
* Propagate information to a specific tool
|
|
*/
|
|
async propagateToTool(toolName, info) {
|
|
try {
|
|
// Transform information for the target tool
|
|
const transformed = await this.transformInformationForTool(info, toolName);
|
|
// Create new shared information entry
|
|
const propagatedInfo = {
|
|
id: `${info.id}_propagated_${toolName}_${Date.now()}`,
|
|
sourceTools: [...info.sourceTools, 'sharing_system'],
|
|
targetTools: [toolName],
|
|
content: transformed,
|
|
type: info.type,
|
|
timestamp: Date.now(),
|
|
relevance: info.relevance * 0.8, // Slight relevance decay
|
|
persistence: info.persistence,
|
|
metadata: {
|
|
...info.metadata,
|
|
propagatedFrom: info.id,
|
|
transformedFor: toolName
|
|
}
|
|
};
|
|
this.sharedInformation.set(propagatedInfo.id, propagatedInfo);
|
|
return true;
|
|
}
|
|
catch (error) {
|
|
console.error(`Failed to propagate to ${toolName}:`, error);
|
|
return false;
|
|
}
|
|
}
|
|
/**
|
|
* Transform information to be suitable for a specific tool
|
|
*/
|
|
async transformInformationForTool(info, toolName) {
|
|
// Check for registered transformation rule
|
|
for (const sourceTool of info.sourceTools) {
|
|
const transformKey = `${sourceTool}->${toolName}`;
|
|
const transform = this.transformationRules.get(transformKey);
|
|
if (transform) {
|
|
return transform(info.content);
|
|
}
|
|
}
|
|
// Default transformation based on tool type
|
|
return this.defaultTransformation(info.content, toolName);
|
|
}
|
|
/**
|
|
* Default transformation logic
|
|
*/
|
|
defaultTransformation(content, toolName) {
|
|
switch (toolName) {
|
|
case 'matrix-solver':
|
|
return this.transformToMatrixFormat(content);
|
|
case 'consciousness':
|
|
return this.transformToConsciousnessFormat(content);
|
|
case 'psycho-symbolic':
|
|
return this.transformToSymbolicFormat(content);
|
|
case 'temporal':
|
|
return this.transformToTemporalFormat(content);
|
|
default:
|
|
return content; // No transformation
|
|
}
|
|
}
|
|
/**
|
|
* Calculate relevance between information and query
|
|
*/
|
|
calculateQueryRelevance(info, query) {
|
|
// Simple relevance calculation based on content similarity
|
|
const infoStr = JSON.stringify(info.content).toLowerCase();
|
|
const queryStr = JSON.stringify(query).toLowerCase();
|
|
// Check for common keywords
|
|
const infoWords = infoStr.split(/\W+/);
|
|
const queryWords = queryStr.split(/\W+/);
|
|
const commonWords = infoWords.filter(word => queryWords.includes(word));
|
|
const relevance = commonWords.length / Math.max(queryWords.length, 1);
|
|
return Math.min(1.0, relevance);
|
|
}
|
|
/**
|
|
* Update connection strengths based on propagation success
|
|
*/
|
|
updateConnectionStrengths(sourceTools, targetTools, results) {
|
|
for (const source of sourceTools) {
|
|
targetTools.forEach((target, index) => {
|
|
const connectionKey = `${source}->${target}`;
|
|
const connections = this.toolConnections.get(connectionKey) || [];
|
|
const connection = connections.find(c => c.source === source && c.target === target);
|
|
if (connection) {
|
|
const success = results[index];
|
|
const updateStrength = success ? 0.1 : -0.05;
|
|
connection.strength = Math.max(0, Math.min(1.0, connection.strength + updateStrength));
|
|
// Update success rate
|
|
const totalAttempts = connection.successRate * 10; // Approximate
|
|
const newSuccessRate = (connection.successRate * totalAttempts + (success ? 1 : 0)) / (totalAttempts + 1);
|
|
connection.successRate = newSuccessRate;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
/**
|
|
* Detect emergent patterns from information combinations
|
|
*/
|
|
async detectEmergentPatterns(newInfo) {
|
|
// Look for patterns when information from different tools combines
|
|
const recentInfo = Array.from(this.sharedInformation.values())
|
|
.filter(info => Date.now() - info.timestamp < 60000) // Last minute
|
|
.filter(info => info.id !== newInfo.id);
|
|
for (const existing of recentInfo) {
|
|
const emergent = this.detectEmergentProperties(existing, newInfo);
|
|
if (emergent.length > 0) {
|
|
// Create new emergent information
|
|
const emergentInfo = {
|
|
id: `emergent_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
|
|
sourceTools: [...existing.sourceTools, ...newInfo.sourceTools],
|
|
targetTools: [],
|
|
content: { emergentProperties: emergent, sources: [existing.id, newInfo.id] },
|
|
type: 'pattern',
|
|
timestamp: Date.now(),
|
|
relevance: 0.8,
|
|
persistence: 'session',
|
|
metadata: { emergent: true, sourceCount: 2 }
|
|
};
|
|
await this.shareInformation(emergentInfo);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Detect emergent properties from two pieces of information
|
|
*/
|
|
detectEmergentProperties(info1, info2) {
|
|
const emergent = [];
|
|
// Check for complementary patterns
|
|
if (this.areComplementary(info1.content, info2.content)) {
|
|
emergent.push({
|
|
type: 'complementary_pattern',
|
|
description: 'Information pieces complement each other',
|
|
synergy: this.calculateSynergy(info1.content, info2.content)
|
|
});
|
|
}
|
|
// Check for amplification effects
|
|
if (this.checkAmplification(info1.content, info2.content)) {
|
|
emergent.push({
|
|
type: 'amplification',
|
|
description: 'Information pieces amplify each other',
|
|
amplification_factor: this.calculateAmplificationFactor(info1.content, info2.content)
|
|
});
|
|
}
|
|
// Check for novel combinations
|
|
const novelCombination = this.generateNovelCombination(info1.content, info2.content);
|
|
if (novelCombination) {
|
|
emergent.push({
|
|
type: 'novel_combination',
|
|
description: 'Unexpected combination creates new insight',
|
|
combination: novelCombination
|
|
});
|
|
}
|
|
return emergent;
|
|
}
|
|
// Transformation methods for different tool types
|
|
transformToMatrixFormat(content) {
|
|
if (Array.isArray(content)) {
|
|
return { matrix: content, format: 'dense' };
|
|
}
|
|
return { scalar: content };
|
|
}
|
|
transformToConsciousnessFormat(content) {
|
|
return {
|
|
emergenceLevel: this.extractEmergenceLevel(content),
|
|
integrationData: content,
|
|
timestamp: Date.now()
|
|
};
|
|
}
|
|
transformToSymbolicFormat(content) {
|
|
return {
|
|
symbols: this.extractSymbols(content),
|
|
relations: this.extractRelations(content),
|
|
domain: 'cross_tool_sharing'
|
|
};
|
|
}
|
|
transformToTemporalFormat(content) {
|
|
return {
|
|
temporalData: content,
|
|
timestamp: Date.now(),
|
|
sequence: this.extractSequence(content)
|
|
};
|
|
}
|
|
// Analysis methods
|
|
getMostConnectedTools() {
|
|
const toolCounts = new Map();
|
|
for (const connections of this.toolConnections.values()) {
|
|
for (const connection of connections) {
|
|
toolCounts.set(connection.source, (toolCounts.get(connection.source) || 0) + 1);
|
|
toolCounts.set(connection.target, (toolCounts.get(connection.target) || 0) + 1);
|
|
}
|
|
}
|
|
return Array.from(toolCounts.entries())
|
|
.sort((a, b) => b[1] - a[1])
|
|
.slice(0, 5);
|
|
}
|
|
getStrongestConnections() {
|
|
const allConnections = [];
|
|
for (const connections of this.toolConnections.values()) {
|
|
allConnections.push(...connections);
|
|
}
|
|
return allConnections
|
|
.sort((a, b) => b.strength - a.strength)
|
|
.slice(0, 10);
|
|
}
|
|
getInformationHubs() {
|
|
const hubScores = new Map();
|
|
for (const info of this.sharedInformation.values()) {
|
|
for (const source of info.sourceTools) {
|
|
hubScores.set(source, (hubScores.get(source) || 0) + 1);
|
|
}
|
|
for (const target of info.targetTools) {
|
|
hubScores.set(target, (hubScores.get(target) || 0) + 0.5);
|
|
}
|
|
}
|
|
return Array.from(hubScores.entries())
|
|
.sort((a, b) => b[1] - a[1])
|
|
.slice(0, 5)
|
|
.map(entry => entry[0]);
|
|
}
|
|
getEmergentCombinations() {
|
|
return this.informationFlows
|
|
.filter(flow => flow.emergentProperties.length > 0)
|
|
.map(flow => ({
|
|
pathway: flow.pathway,
|
|
emergentCount: flow.emergentProperties.length,
|
|
properties: flow.emergentProperties
|
|
}));
|
|
}
|
|
calculateCollaborationSuccess() {
|
|
const allConnections = [];
|
|
for (const connections of this.toolConnections.values()) {
|
|
allConnections.push(...connections);
|
|
}
|
|
if (allConnections.length === 0)
|
|
return 0;
|
|
const avgSuccessRate = allConnections.reduce((sum, conn) => sum + conn.successRate, 0) / allConnections.length;
|
|
return avgSuccessRate;
|
|
}
|
|
// Optimization methods
|
|
pruneWeakConnections() {
|
|
for (const [key, connections] of this.toolConnections) {
|
|
const strongConnections = connections.filter(conn => conn.strength > 0.2);
|
|
if (strongConnections.length !== connections.length) {
|
|
this.toolConnections.set(key, strongConnections);
|
|
}
|
|
}
|
|
}
|
|
reinforceSuccessfulPathways() {
|
|
for (const flow of this.informationFlows) {
|
|
if (flow.emergentProperties.length > 0) {
|
|
// Strengthen connections in successful pathways
|
|
for (let i = 0; i < flow.pathway.length - 1; i++) {
|
|
const source = flow.pathway[i];
|
|
const target = flow.pathway[i + 1];
|
|
this.createDynamicConnection(source, target, 'pattern');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
cleanupOldInformation() {
|
|
const oneHour = 60 * 60 * 1000;
|
|
const now = Date.now();
|
|
for (const [id, info] of this.sharedInformation) {
|
|
if (info.persistence === 'temporary' && now - info.timestamp > oneHour) {
|
|
this.sharedInformation.delete(id);
|
|
}
|
|
}
|
|
}
|
|
updateSubscriptionRecommendations() {
|
|
// Analyze successful information sharing and recommend new subscriptions
|
|
// This would be implemented based on analysis of collaboration patterns
|
|
}
|
|
// Utility methods for pattern detection
|
|
areComplementary(content1, content2) {
|
|
// Check if two pieces of content complement each other
|
|
// This is a simplified implementation
|
|
return JSON.stringify(content1) !== JSON.stringify(content2);
|
|
}
|
|
checkAmplification(content1, content2) {
|
|
// Check if combination amplifies the effect
|
|
return true; // Simplified
|
|
}
|
|
calculateSynergy(content1, content2) {
|
|
return Math.random() * 0.5 + 0.5; // Simplified
|
|
}
|
|
calculateAmplificationFactor(content1, content2) {
|
|
return Math.random() * 2 + 1; // Simplified
|
|
}
|
|
generateNovelCombination(content1, content2) {
|
|
return {
|
|
combined: true,
|
|
elements: [content1, content2],
|
|
novelty: Math.random()
|
|
};
|
|
}
|
|
extractEmergenceLevel(content) {
|
|
return Math.random() * 0.5 + 0.5; // Simplified
|
|
}
|
|
extractSymbols(content) {
|
|
return ['symbol1', 'symbol2']; // Simplified
|
|
}
|
|
extractRelations(content) {
|
|
return []; // Simplified
|
|
}
|
|
extractSequence(content) {
|
|
return []; // Simplified
|
|
}
|
|
/**
|
|
* Get sharing system statistics
|
|
*/
|
|
getStats() {
|
|
return {
|
|
totalSharedInformation: this.sharedInformation.size,
|
|
totalConnections: Array.from(this.toolConnections.values()).reduce((sum, arr) => sum + arr.length, 0),
|
|
totalFlows: this.informationFlows.length,
|
|
averageConnectionStrength: this.calculateAverageConnectionStrength(),
|
|
emergentPatternsDetected: this.countEmergentPatterns(),
|
|
mostActiveTools: this.getMostConnectedTools().slice(0, 3)
|
|
};
|
|
}
|
|
calculateAverageConnectionStrength() {
|
|
const allConnections = [];
|
|
for (const connections of this.toolConnections.values()) {
|
|
allConnections.push(...connections);
|
|
}
|
|
if (allConnections.length === 0)
|
|
return 0;
|
|
return allConnections.reduce((sum, conn) => sum + conn.strength, 0) / allConnections.length;
|
|
}
|
|
countEmergentPatterns() {
|
|
return this.informationFlows.reduce((sum, flow) => sum + flow.emergentProperties.length, 0);
|
|
}
|
|
}
|