873 lines
42 KiB
JavaScript
873 lines
42 KiB
JavaScript
/**
|
|
* Enhanced Psycho-Symbolic Reasoning MCP Tools
|
|
* Full implementation with domain-agnostic reasoning and fallback mechanisms
|
|
*/
|
|
import * as crypto from 'crypto';
|
|
// Initialize with base knowledge
|
|
class KnowledgeBase {
|
|
triples = new Map();
|
|
concepts = new Map(); // concept -> related triple IDs
|
|
predicateIndex = new Map(); // predicate -> triple IDs
|
|
constructor() {
|
|
this.initializeBaseKnowledge();
|
|
}
|
|
initializeBaseKnowledge() {
|
|
// Core AI/consciousness knowledge
|
|
this.addTriple('consciousness', 'emerges_from', 'neural_networks', 0.85);
|
|
this.addTriple('consciousness', 'requires', 'integration', 0.9);
|
|
this.addTriple('consciousness', 'exhibits', 'phi_value', 0.95);
|
|
this.addTriple('neural_networks', 'process', 'information', 1.0);
|
|
this.addTriple('neural_networks', 'contain', 'neurons', 1.0);
|
|
this.addTriple('neurons', 'connect_via', 'synapses', 1.0);
|
|
this.addTriple('synapses', 'enable', 'plasticity', 0.9);
|
|
this.addTriple('plasticity', 'allows', 'learning', 0.95);
|
|
this.addTriple('learning', 'modifies', 'weights', 1.0);
|
|
this.addTriple('phi_value', 'measures', 'integrated_information', 1.0);
|
|
this.addTriple('integrated_information', 'indicates', 'consciousness_level', 0.8);
|
|
// Temporal/computational knowledge
|
|
this.addTriple('temporal_processing', 'enables', 'prediction', 0.9);
|
|
this.addTriple('prediction', 'requires', 'pattern_recognition', 0.85);
|
|
this.addTriple('pattern_recognition', 'uses', 'neural_networks', 0.9);
|
|
this.addTriple('sublinear_algorithms', 'achieve', 'logarithmic_complexity', 1.0);
|
|
this.addTriple('logarithmic_complexity', 'beats', 'polynomial_complexity', 1.0);
|
|
this.addTriple('nanosecond_scheduling', 'enables', 'temporal_advantage', 0.95);
|
|
this.addTriple('temporal_advantage', 'allows', 'faster_than_light_computation', 0.9);
|
|
// Software engineering principles
|
|
this.addTriple('api_design', 'requires', 'consistency', 0.95);
|
|
this.addTriple('api_design', 'benefits_from', 'versioning', 0.9);
|
|
this.addTriple('rest_api', 'uses', 'http_methods', 1.0);
|
|
this.addTriple('rest_api', 'follows', 'stateless_principle', 0.95);
|
|
this.addTriple('user_management', 'requires', 'authentication', 1.0);
|
|
this.addTriple('user_management', 'requires', 'authorization', 1.0);
|
|
this.addTriple('authentication', 'validates', 'identity', 1.0);
|
|
this.addTriple('authorization', 'controls', 'access', 1.0);
|
|
this.addTriple('security', 'prevents', 'vulnerabilities', 0.9);
|
|
this.addTriple('rate_limiting', 'prevents', 'abuse', 0.95);
|
|
this.addTriple('caching', 'improves', 'performance', 0.9);
|
|
this.addTriple('pagination', 'handles', 'large_datasets', 0.95);
|
|
// System design principles
|
|
this.addTriple('distributed_systems', 'face', 'consistency_challenges', 0.95);
|
|
this.addTriple('microservices', 'require', 'service_discovery', 0.9);
|
|
this.addTriple('scalability', 'requires', 'horizontal_scaling', 0.85);
|
|
this.addTriple('reliability', 'requires', 'redundancy', 0.9);
|
|
this.addTriple('monitoring', 'enables', 'observability', 0.95);
|
|
// Reasoning patterns
|
|
this.addTriple('causal_reasoning', 'identifies', 'cause_effect', 1.0);
|
|
this.addTriple('procedural_reasoning', 'describes', 'processes', 1.0);
|
|
this.addTriple('hypothetical_reasoning', 'explores', 'possibilities', 1.0);
|
|
this.addTriple('comparative_reasoning', 'analyzes', 'differences', 1.0);
|
|
this.addTriple('abstract_reasoning', 'generalizes', 'concepts', 0.95);
|
|
this.addTriple('lateral_thinking', 'finds', 'unconventional_solutions', 0.9);
|
|
this.addTriple('systems_thinking', 'considers', 'interactions', 0.95);
|
|
// Logic rules
|
|
this.addTriple('modus_ponens', 'validates', 'implications', 1.0);
|
|
this.addTriple('universal_instantiation', 'applies_to', 'specific_cases', 1.0);
|
|
this.addTriple('existential_generalization', 'proves', 'existence', 0.9);
|
|
}
|
|
addTriple(subject, predicate, object, confidence = 1.0, metadata) {
|
|
const id = crypto.randomBytes(8).toString('hex');
|
|
const triple = {
|
|
subject: subject.toLowerCase(),
|
|
predicate: predicate.toLowerCase(),
|
|
object: object.toLowerCase(),
|
|
confidence,
|
|
metadata,
|
|
timestamp: Date.now()
|
|
};
|
|
this.triples.set(id, triple);
|
|
// Update indices
|
|
this.addToConceptIndex(triple.subject, id);
|
|
this.addToConceptIndex(triple.object, id);
|
|
this.addToPredicateIndex(triple.predicate, id);
|
|
return id;
|
|
}
|
|
addToConceptIndex(concept, tripleId) {
|
|
if (!this.concepts.has(concept)) {
|
|
this.concepts.set(concept, new Set());
|
|
}
|
|
this.concepts.get(concept).add(tripleId);
|
|
}
|
|
addToPredicateIndex(predicate, tripleId) {
|
|
if (!this.predicateIndex.has(predicate)) {
|
|
this.predicateIndex.set(predicate, new Set());
|
|
}
|
|
this.predicateIndex.get(predicate).add(tripleId);
|
|
}
|
|
findRelated(concept) {
|
|
const conceptLower = concept.toLowerCase();
|
|
const relatedIds = this.concepts.get(conceptLower) || new Set();
|
|
return Array.from(relatedIds).map(id => this.triples.get(id)).filter(Boolean);
|
|
}
|
|
findByPredicate(predicate) {
|
|
const predicateLower = predicate.toLowerCase();
|
|
const ids = this.predicateIndex.get(predicateLower) || new Set();
|
|
return Array.from(ids).map(id => this.triples.get(id)).filter(Boolean);
|
|
}
|
|
getAllTriples() {
|
|
return Array.from(this.triples.values());
|
|
}
|
|
query(sparqlLike) {
|
|
// Simple SPARQL-like query support
|
|
const results = [];
|
|
const queryLower = sparqlLike.toLowerCase();
|
|
for (const triple of this.triples.values()) {
|
|
if (queryLower.includes(triple.subject) ||
|
|
queryLower.includes(triple.predicate) ||
|
|
queryLower.includes(triple.object)) {
|
|
results.push(triple);
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
}
|
|
export class PsychoSymbolicTools {
|
|
knowledgeBase;
|
|
reasoningCache = new Map();
|
|
constructor() {
|
|
this.knowledgeBase = new KnowledgeBase();
|
|
}
|
|
getTools() {
|
|
return [
|
|
{
|
|
name: 'psycho_symbolic_reason',
|
|
description: 'Perform deep psycho-symbolic reasoning with full inference',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
query: { type: 'string', description: 'The reasoning query' },
|
|
context: { type: 'object', description: 'Additional context', default: {} },
|
|
depth: { type: 'number', description: 'Reasoning depth', default: 5 }
|
|
},
|
|
required: ['query']
|
|
}
|
|
},
|
|
{
|
|
name: 'knowledge_graph_query',
|
|
description: 'Query the knowledge graph with semantic search',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
query: { type: 'string', description: 'Natural language or SPARQL-like query' },
|
|
filters: { type: 'object', description: 'Filters', default: {} },
|
|
limit: { type: 'number', description: 'Max results', default: 10 }
|
|
},
|
|
required: ['query']
|
|
}
|
|
},
|
|
{
|
|
name: 'add_knowledge',
|
|
description: 'Add knowledge triple to the graph',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
subject: { type: 'string' },
|
|
predicate: { type: 'string' },
|
|
object: { type: 'string' },
|
|
confidence: { type: 'number', default: 1.0 },
|
|
metadata: { type: 'object', default: {} }
|
|
},
|
|
required: ['subject', 'predicate', 'object']
|
|
}
|
|
}
|
|
];
|
|
}
|
|
async handleToolCall(name, args) {
|
|
switch (name) {
|
|
case 'psycho_symbolic_reason':
|
|
return this.performDeepReasoning(args.query, args.context || {}, args.depth || 5);
|
|
case 'knowledge_graph_query':
|
|
return this.queryKnowledgeGraph(args.query, args.filters || {}, args.limit || 10);
|
|
case 'add_knowledge':
|
|
return this.addKnowledge(args.subject, args.predicate, args.object, args.confidence, args.metadata);
|
|
default:
|
|
throw new Error(`Unknown tool: ${name}`);
|
|
}
|
|
}
|
|
async performDeepReasoning(query, context, maxDepth) {
|
|
// Check cache
|
|
const cacheKey = `${query}_${JSON.stringify(context)}_${maxDepth}`;
|
|
if (this.reasoningCache.has(cacheKey)) {
|
|
return this.reasoningCache.get(cacheKey);
|
|
}
|
|
const reasoningSteps = [];
|
|
const insights = new Set();
|
|
// Step 1: Cognitive Pattern Analysis
|
|
const patterns = this.identifyCognitivePatterns(query);
|
|
reasoningSteps.push({
|
|
type: 'pattern_identification',
|
|
patterns,
|
|
confidence: 0.9,
|
|
description: `Identified ${patterns.join(', ')} reasoning patterns`
|
|
});
|
|
// Step 2: Entity and Concept Extraction
|
|
const entities = this.extractEntitiesAndConcepts(query);
|
|
reasoningSteps.push({
|
|
type: 'entity_extraction',
|
|
entities: entities.entities,
|
|
concepts: entities.concepts,
|
|
relationships: entities.relationships,
|
|
confidence: 0.85
|
|
});
|
|
// Step 3: Domain-Specific Insight Generation
|
|
const domainInsights = this.generateDomainInsights(query, patterns, context);
|
|
domainInsights.forEach(insight => insights.add(insight));
|
|
reasoningSteps.push({
|
|
type: 'domain_analysis',
|
|
insights: domainInsights,
|
|
confidence: 0.8,
|
|
description: 'Generated domain-specific insights'
|
|
});
|
|
// Step 4: Logical Component Analysis
|
|
const logicalComponents = this.extractLogicalComponents(query);
|
|
reasoningSteps.push({
|
|
type: 'logical_decomposition',
|
|
components: logicalComponents,
|
|
depth: 1,
|
|
description: 'Decomposed query into logical primitives'
|
|
});
|
|
// Step 5: Knowledge Graph Traversal
|
|
const graphInsights = await this.traverseKnowledgeGraph(entities.concepts, maxDepth);
|
|
reasoningSteps.push({
|
|
type: 'knowledge_traversal',
|
|
paths: graphInsights.paths,
|
|
discoveries: graphInsights.discoveries,
|
|
confidence: graphInsights.confidence
|
|
});
|
|
graphInsights.discoveries.forEach(d => insights.add(d));
|
|
// Step 6: Inference Chain Building
|
|
const inferences = this.buildInferenceChain(logicalComponents, graphInsights.triples, patterns);
|
|
reasoningSteps.push({
|
|
type: 'inference',
|
|
rules: inferences.rules,
|
|
conclusions: inferences.conclusions,
|
|
confidence: inferences.confidence
|
|
});
|
|
inferences.conclusions.forEach(c => insights.add(c));
|
|
// Step 7: Context-Aware Reasoning
|
|
if (context && Object.keys(context).length > 0) {
|
|
const contextInsights = this.applyContextualReasoning(query, context, patterns);
|
|
contextInsights.forEach(ci => insights.add(ci));
|
|
reasoningSteps.push({
|
|
type: 'contextual_reasoning',
|
|
insights: contextInsights,
|
|
confidence: 0.75
|
|
});
|
|
}
|
|
// Step 8: Hypothesis Generation
|
|
if (patterns.includes('hypothetical') || patterns.includes('exploratory') || patterns.includes('lateral')) {
|
|
const hypotheses = this.generateHypotheses(entities.concepts, inferences.conclusions);
|
|
reasoningSteps.push({
|
|
type: 'hypothesis_generation',
|
|
hypotheses,
|
|
confidence: 0.7
|
|
});
|
|
hypotheses.forEach(h => insights.add(h));
|
|
}
|
|
// Step 9: Edge Case Analysis (for API/system design queries)
|
|
if (query.toLowerCase().includes('edge case') || query.toLowerCase().includes('hidden') ||
|
|
context.focus === 'hidden_complexities') {
|
|
const edgeCases = this.analyzeEdgeCases(query, entities.concepts);
|
|
edgeCases.forEach(ec => insights.add(ec));
|
|
reasoningSteps.push({
|
|
type: 'edge_case_analysis',
|
|
cases: edgeCases,
|
|
confidence: 0.8
|
|
});
|
|
}
|
|
// Step 10: Contradiction Detection and Resolution
|
|
const contradictions = this.detectContradictions(Array.from(insights));
|
|
if (contradictions.length > 0) {
|
|
const resolutions = this.resolveContradictions(contradictions, context);
|
|
reasoningSteps.push({
|
|
type: 'contradiction_resolution',
|
|
contradictions,
|
|
resolutions,
|
|
confidence: 0.8
|
|
});
|
|
}
|
|
// Step 11: Synthesis
|
|
const synthesis = this.synthesizeCompleteAnswer(query, Array.from(insights), reasoningSteps, patterns, context);
|
|
const result = {
|
|
answer: synthesis.answer,
|
|
confidence: synthesis.confidence,
|
|
reasoning: reasoningSteps,
|
|
insights: Array.from(insights),
|
|
patterns,
|
|
depth: graphInsights.maxDepth || maxDepth,
|
|
entities: entities.entities,
|
|
concepts: entities.concepts,
|
|
triples_examined: graphInsights.triples.length,
|
|
inference_rules_applied: inferences.rules.length
|
|
};
|
|
// Cache result
|
|
this.reasoningCache.set(cacheKey, result);
|
|
return result;
|
|
}
|
|
generateDomainInsights(query, patterns, context) {
|
|
const insights = [];
|
|
const queryLower = query.toLowerCase();
|
|
// API Design Insights
|
|
if (queryLower.includes('api') || queryLower.includes('rest') || context.domain === 'api_design') {
|
|
insights.push('Consider idempotency for all mutating operations to handle network retries');
|
|
insights.push('Implement versioning strategy from day one - URL, header, or content negotiation');
|
|
insights.push('Rate limiting should be granular - per user, per endpoint, and per operation type');
|
|
insights.push('CORS configuration often breaks in production - test with actual domain names');
|
|
insights.push('Bulk operations need careful transaction boundary management');
|
|
if (queryLower.includes('user')) {
|
|
insights.push('User deletion must handle cascading data relationships and GDPR compliance');
|
|
insights.push('Password reset flows are prime targets for timing attacks');
|
|
insights.push('Session management across devices requires careful token invalidation');
|
|
insights.push('Email verification tokens should expire and be single-use');
|
|
}
|
|
}
|
|
// Hidden Complexities
|
|
if (queryLower.includes('hidden') || queryLower.includes('non-obvious') || queryLower.includes('edge')) {
|
|
insights.push('Race conditions in concurrent user updates - last write wins vs merge conflicts');
|
|
insights.push('Time zone handling - server, client, and user preference mismatches');
|
|
insights.push('Pagination breaks when underlying data changes during traversal');
|
|
insights.push('Cache invalidation cascades in microservice architectures');
|
|
insights.push('OAuth token refresh race conditions in distributed systems');
|
|
insights.push('Database connection pool exhaustion under spike load');
|
|
insights.push('Unicode normalization issues in usernames and passwords');
|
|
insights.push('Integer overflow in ID generation at scale');
|
|
}
|
|
// Lateral Thinking Insights
|
|
if (patterns.includes('lateral') || context.pattern === 'lateral') {
|
|
insights.push('Consider using event sourcing for audit trail instead of traditional logging');
|
|
insights.push('GraphQL might solve over-fetching better than REST for complex relationships');
|
|
insights.push('WebSockets for real-time user presence instead of polling');
|
|
insights.push('JWT claims can carry authorization context to reduce database lookups');
|
|
insights.push('Use bloom filters for username availability checks at scale');
|
|
insights.push('Implement soft deletes with temporal tables for compliance');
|
|
insights.push('Consider CQRS for read-heavy user profile access patterns');
|
|
}
|
|
// System Interaction Complexities
|
|
if (queryLower.includes('system') || queryLower.includes('interaction')) {
|
|
insights.push('Load balancer health checks can trigger false circuit breaker opens');
|
|
insights.push('CDN cache can serve stale authentication states');
|
|
insights.push('Database read replicas lag can cause phantom user creation failures');
|
|
insights.push('Message queue failures can orphan user records');
|
|
insights.push('Service mesh retry policies can amplify failures');
|
|
insights.push('Distributed tracing overhead affects latency measurements');
|
|
}
|
|
// Security Considerations
|
|
if (queryLower.includes('security') || queryLower.includes('user')) {
|
|
insights.push('Timing attacks on user enumeration through login response times');
|
|
insights.push('JWT secret rotation without service disruption');
|
|
insights.push('Password history storage needs separate encryption');
|
|
insights.push('Account takeover protection via behavioral analysis');
|
|
insights.push('API key rotation mechanisms for service accounts');
|
|
}
|
|
return insights;
|
|
}
|
|
applyContextualReasoning(query, context, patterns) {
|
|
const insights = [];
|
|
if (context.focus === 'hidden_complexities') {
|
|
insights.push('Hidden complexity: Distributed consensus for user state changes');
|
|
insights.push('Hidden complexity: Eventual consistency in user search indices');
|
|
insights.push('Hidden complexity: GDPR data portability implementation details');
|
|
insights.push('Hidden complexity: Cross-region data replication latency');
|
|
}
|
|
if (context.pattern === 'lateral') {
|
|
insights.push('Lateral solution: Use blockchain for decentralized identity verification');
|
|
insights.push('Lateral solution: Implement passwordless auth via magic links');
|
|
insights.push('Lateral solution: Use ML for anomaly detection in access patterns');
|
|
insights.push('Lateral solution: Federated user management across microservices');
|
|
}
|
|
if (context.domain === 'api_design') {
|
|
insights.push('API consideration: Hypermedia controls for self-documenting endpoints');
|
|
insights.push('API consideration: GraphQL subscriptions for real-time updates');
|
|
insights.push('API consideration: OpenAPI spec generation from code');
|
|
insights.push('API consideration: Request/response compression strategies');
|
|
}
|
|
return insights;
|
|
}
|
|
analyzeEdgeCases(query, concepts) {
|
|
const edgeCases = [];
|
|
// Universal edge cases
|
|
edgeCases.push('Edge case: Null, undefined, and empty string handling differences');
|
|
edgeCases.push('Edge case: Maximum length inputs causing buffer overflows');
|
|
edgeCases.push('Edge case: Concurrent modifications to the same resource');
|
|
edgeCases.push('Edge case: Clock skew between distributed components');
|
|
// API-specific edge cases
|
|
if (concepts.includes('api') || concepts.includes('rest')) {
|
|
edgeCases.push('Edge case: Partial success in batch operations');
|
|
edgeCases.push('Edge case: Request timeout during long-running operations');
|
|
edgeCases.push('Edge case: Content-Type mismatches with actual payload');
|
|
edgeCases.push('Edge case: HTTP/2 multiplexing affecting rate limits');
|
|
}
|
|
// User management edge cases
|
|
if (concepts.includes('user') || concepts.includes('authentication')) {
|
|
edgeCases.push('Edge case: User creation with recycled email addresses');
|
|
edgeCases.push('Edge case: Session fixation during concurrent logins');
|
|
edgeCases.push('Edge case: Account merge conflicts with OAuth providers');
|
|
edgeCases.push('Edge case: Birthday paradox in random token generation');
|
|
}
|
|
return edgeCases;
|
|
}
|
|
identifyCognitivePatterns(query) {
|
|
const patterns = [];
|
|
const lowerQuery = query.toLowerCase();
|
|
const patternMap = {
|
|
'causal': ['why', 'cause', 'because', 'result', 'effect', 'lead to'],
|
|
'procedural': ['how', 'process', 'step', 'method', 'way', 'approach', 'design', 'implement'],
|
|
'hypothetical': ['what if', 'suppose', 'imagine', 'could', 'would', 'might'],
|
|
'comparative': ['compare', 'difference', 'similar', 'versus', 'than', 'like'],
|
|
'definitional': ['what is', 'define', 'meaning', 'definition'],
|
|
'evaluative': ['best', 'worst', 'better', 'optimal', 'evaluate'],
|
|
'temporal': ['when', 'time', 'before', 'after', 'during', 'temporal'],
|
|
'spatial': ['where', 'location', 'position', 'space'],
|
|
'quantitative': ['how many', 'how much', 'count', 'measure', 'amount'],
|
|
'existential': ['exist', 'there is', 'there are', 'presence'],
|
|
'universal': ['all', 'every', 'always', 'never', 'none'],
|
|
'lateral': ['lateral', 'unconventional', 'creative', 'alternative', 'non-obvious', 'hidden'],
|
|
'systems': ['system', 'interaction', 'complexity', 'emergence', 'holistic'],
|
|
'exploratory': ['explore', 'discover', 'investigate', 'consider', 'edge case']
|
|
};
|
|
for (const [pattern, keywords] of Object.entries(patternMap)) {
|
|
if (keywords.some(keyword => lowerQuery.includes(keyword))) {
|
|
patterns.push(pattern);
|
|
}
|
|
}
|
|
if (patterns.length === 0) {
|
|
patterns.push('exploratory');
|
|
}
|
|
return patterns;
|
|
}
|
|
extractEntitiesAndConcepts(query) {
|
|
const words = query.split(/\s+/);
|
|
const entities = [];
|
|
const concepts = [];
|
|
const relationships = [];
|
|
// Extract technical terms and concepts
|
|
const technicalTerms = [
|
|
'api', 'rest', 'graphql', 'user', 'management', 'authentication',
|
|
'authorization', 'database', 'cache', 'security', 'performance',
|
|
'scalability', 'microservice', 'distributed', 'system', 'design',
|
|
'endpoint', 'resource', 'crud', 'http', 'json', 'xml', 'oauth',
|
|
'jwt', 'session', 'token', 'password', 'encryption', 'hash'
|
|
];
|
|
// Extract named entities (capitalized words not at sentence start)
|
|
for (let i = 0; i < words.length; i++) {
|
|
const word = words[i];
|
|
const wordLower = word.toLowerCase();
|
|
if (/^[A-Z]/.test(word) && i > 0 && !['The', 'A', 'An', 'What', 'How', 'Why', 'When', 'Where'].includes(word)) {
|
|
entities.push(wordLower);
|
|
}
|
|
if (technicalTerms.includes(wordLower)) {
|
|
concepts.push(wordLower);
|
|
}
|
|
}
|
|
// Extract key concepts from knowledge base
|
|
const queryLower = query.toLowerCase();
|
|
for (const concept of this.knowledgeBase.getAllTriples().map(t => [t.subject, t.object]).flat()) {
|
|
if (queryLower.includes(concept)) {
|
|
concepts.push(concept);
|
|
}
|
|
}
|
|
// Extract relationships (verbs and prepositions)
|
|
const relationshipPatterns = [
|
|
'is', 'are', 'was', 'were', 'has', 'have', 'had',
|
|
'can', 'could', 'will', 'would', 'should',
|
|
'design', 'implement', 'create', 'build', 'develop',
|
|
'requires', 'needs', 'uses', 'enables', 'prevents',
|
|
'increases', 'decreases', 'affects', 'influences'
|
|
];
|
|
for (const word of words) {
|
|
const wordLower = word.toLowerCase();
|
|
if (relationshipPatterns.includes(wordLower)) {
|
|
relationships.push(wordLower);
|
|
}
|
|
}
|
|
// Add query-specific concepts
|
|
if (queryLower.includes('edge case'))
|
|
concepts.push('edge_cases');
|
|
if (queryLower.includes('hidden'))
|
|
concepts.push('hidden_complexity');
|
|
if (queryLower.includes('api'))
|
|
concepts.push('api_design');
|
|
if (queryLower.includes('user'))
|
|
concepts.push('user_management');
|
|
return {
|
|
entities: [...new Set(entities)],
|
|
concepts: [...new Set(concepts)],
|
|
relationships: [...new Set(relationships)]
|
|
};
|
|
}
|
|
extractLogicalComponents(query) {
|
|
const components = {
|
|
predicates: [],
|
|
quantifiers: [],
|
|
operators: [],
|
|
modals: [],
|
|
negations: []
|
|
};
|
|
const lowerQuery = query.toLowerCase();
|
|
// Extract predicates (subject-verb-object patterns)
|
|
const predicateMatches = lowerQuery.match(/(\w+)\s+(is|are|was|were|has|have|had)\s+(\w+)/g);
|
|
if (predicateMatches) {
|
|
components.predicates = predicateMatches.map(p => p.trim());
|
|
}
|
|
// Extract quantifiers
|
|
const quantifierPattern = /\b(all|every|some|any|no|none|many|few|most|several)\b/gi;
|
|
const quantifierMatches = lowerQuery.match(quantifierPattern);
|
|
if (quantifierMatches) {
|
|
components.quantifiers = quantifierMatches;
|
|
}
|
|
// Extract logical operators
|
|
const operatorPattern = /\b(and|or|not|if|then|implies|therefore|because|but|however)\b/gi;
|
|
const operatorMatches = lowerQuery.match(operatorPattern);
|
|
if (operatorMatches) {
|
|
components.operators = operatorMatches;
|
|
}
|
|
// Extract modal verbs
|
|
const modalPattern = /\b(can|could|may|might|must|shall|should|will|would)\b/gi;
|
|
const modalMatches = lowerQuery.match(modalPattern);
|
|
if (modalMatches) {
|
|
components.modals = modalMatches;
|
|
}
|
|
// Extract negations
|
|
const negationPattern = /\b(not|no|never|neither|nor|nothing|nobody|nowhere)\b/gi;
|
|
const negationMatches = lowerQuery.match(negationPattern);
|
|
if (negationMatches) {
|
|
components.negations = negationMatches;
|
|
}
|
|
return components;
|
|
}
|
|
async traverseKnowledgeGraph(concepts, maxDepth) {
|
|
const visited = new Set();
|
|
const paths = [];
|
|
const discoveries = [];
|
|
const triples = [];
|
|
let currentDepth = 0;
|
|
let maxConfidence = 0;
|
|
// BFS traversal
|
|
const queue = concepts.map(c => ({
|
|
concept: c,
|
|
depth: 0,
|
|
confidence: 1.0,
|
|
path: [c],
|
|
inferences: []
|
|
}));
|
|
while (queue.length > 0 && currentDepth < maxDepth) {
|
|
const node = queue.shift();
|
|
if (visited.has(node.concept))
|
|
continue;
|
|
visited.add(node.concept);
|
|
currentDepth = Math.max(currentDepth, node.depth);
|
|
paths.push(node.path);
|
|
// Find related triples
|
|
const related = this.knowledgeBase.findRelated(node.concept);
|
|
triples.push(...related);
|
|
for (const triple of related) {
|
|
// Generate discoveries
|
|
const discovery = `${triple.subject} ${triple.predicate} ${triple.object}`;
|
|
discoveries.push(discovery);
|
|
maxConfidence = Math.max(maxConfidence, triple.confidence * node.confidence);
|
|
// Add connected concepts to queue
|
|
const nextConcept = triple.subject === node.concept ? triple.object : triple.subject;
|
|
if (!visited.has(nextConcept) && node.depth < maxDepth - 1) {
|
|
queue.push({
|
|
concept: nextConcept,
|
|
depth: node.depth + 1,
|
|
confidence: node.confidence * triple.confidence,
|
|
path: [...node.path, nextConcept],
|
|
inferences: [...node.inferences, discovery]
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
paths,
|
|
discoveries: discoveries.slice(0, 20), // Limit discoveries
|
|
triples,
|
|
maxDepth: currentDepth,
|
|
confidence: maxConfidence
|
|
};
|
|
}
|
|
buildInferenceChain(logicalComponents, triples, patterns) {
|
|
const rules = [];
|
|
const conclusions = [];
|
|
let confidence = 0.5;
|
|
// Apply Modus Ponens
|
|
if (logicalComponents.operators.includes('if') || logicalComponents.operators.includes('then')) {
|
|
rules.push('modus_ponens');
|
|
// Find implications in triples
|
|
for (const triple of triples) {
|
|
if (triple.predicate === 'implies' || triple.predicate === 'causes' || triple.predicate === 'enables') {
|
|
conclusions.push(`${triple.subject} leads to ${triple.object}`);
|
|
confidence = Math.max(confidence, triple.confidence * 0.9);
|
|
}
|
|
}
|
|
}
|
|
// Apply Universal Instantiation
|
|
if (logicalComponents.quantifiers.some((q) => ['all', 'every'].includes(q))) {
|
|
rules.push('universal_instantiation');
|
|
conclusions.push('universal property applies to specific instances');
|
|
confidence = Math.max(confidence, 0.85);
|
|
}
|
|
// Apply Existential Generalization
|
|
if (logicalComponents.quantifiers.some((q) => ['some', 'exist'].includes(q))) {
|
|
rules.push('existential_generalization');
|
|
conclusions.push('at least one instance exists with the property');
|
|
confidence = Math.max(confidence, 0.8);
|
|
}
|
|
// Apply Transitive Property
|
|
const transitivePredicates = ['causes', 'enables', 'requires', 'leads_to'];
|
|
const transitiveChains = this.findTransitiveChains(triples, transitivePredicates);
|
|
if (transitiveChains.length > 0) {
|
|
rules.push('transitive_property');
|
|
transitiveChains.forEach(chain => {
|
|
conclusions.push(`${chain.start} transitively ${chain.predicate} ${chain.end}`);
|
|
});
|
|
confidence = Math.max(confidence, 0.75);
|
|
}
|
|
// Apply Pattern-Specific Rules
|
|
if (patterns.includes('causal')) {
|
|
rules.push('causal_chain_analysis');
|
|
const causalChains = triples.filter(t => ['causes', 'results_in', 'leads_to', 'produces'].includes(t.predicate));
|
|
causalChains.forEach(chain => {
|
|
conclusions.push(`causal relationship: ${chain.subject} → ${chain.object}`);
|
|
});
|
|
}
|
|
if (patterns.includes('temporal')) {
|
|
rules.push('temporal_ordering');
|
|
conclusions.push('events ordered by temporal precedence');
|
|
}
|
|
// Generate domain-specific conclusions
|
|
if (triples.some(t => t.subject.includes('api') || t.object.includes('api'))) {
|
|
conclusions.push('API design requires consistency and versioning');
|
|
conclusions.push('RESTful principles ensure stateless interactions');
|
|
confidence = Math.max(confidence, 0.85);
|
|
}
|
|
if (triples.some(t => t.subject.includes('user') || t.object.includes('user'))) {
|
|
conclusions.push('user management requires authentication and authorization');
|
|
conclusions.push('security measures prevent unauthorized access');
|
|
confidence = Math.max(confidence, 0.9);
|
|
}
|
|
return {
|
|
rules,
|
|
conclusions,
|
|
confidence
|
|
};
|
|
}
|
|
findTransitiveChains(triples, predicates) {
|
|
const chains = [];
|
|
for (const predicate of predicates) {
|
|
const relevantTriples = triples.filter(t => t.predicate === predicate);
|
|
for (let i = 0; i < relevantTriples.length; i++) {
|
|
for (let j = 0; j < relevantTriples.length; j++) {
|
|
if (relevantTriples[i].object === relevantTriples[j].subject) {
|
|
chains.push({
|
|
start: relevantTriples[i].subject,
|
|
middle: relevantTriples[i].object,
|
|
end: relevantTriples[j].object,
|
|
predicate
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return chains;
|
|
}
|
|
generateHypotheses(concepts, conclusions) {
|
|
const hypotheses = [];
|
|
// Generate hypotheses based on concept combinations
|
|
for (let i = 0; i < concepts.length; i++) {
|
|
for (let j = i + 1; j < concepts.length; j++) {
|
|
hypotheses.push(`hypothesis: ${concepts[i]} might be related to ${concepts[j]}`);
|
|
}
|
|
}
|
|
// Generate hypotheses from conclusions
|
|
for (const conclusion of conclusions) {
|
|
if (conclusion.includes('leads to') || conclusion.includes('causes')) {
|
|
hypotheses.push(`hypothesis: reversing ${conclusion} might have opposite effect`);
|
|
}
|
|
}
|
|
// Domain-specific hypotheses
|
|
if (concepts.includes('api_design')) {
|
|
hypotheses.push('hypothesis: event-driven architecture might reduce coupling');
|
|
hypotheses.push('hypothesis: CQRS pattern could improve read performance');
|
|
}
|
|
if (concepts.includes('user_management')) {
|
|
hypotheses.push('hypothesis: passwordless authentication might improve security');
|
|
hypotheses.push('hypothesis: federated identity could simplify user management');
|
|
}
|
|
return hypotheses.slice(0, 5); // Limit hypotheses
|
|
}
|
|
detectContradictions(statements) {
|
|
const contradictions = [];
|
|
for (let i = 0; i < statements.length; i++) {
|
|
for (let j = i + 1; j < statements.length; j++) {
|
|
// Check for direct negation
|
|
if (statements[i].includes('not') && statements[j] === statements[i].replace('not ', '')) {
|
|
contradictions.push({
|
|
type: 'direct_negation',
|
|
statement1: statements[i],
|
|
statement2: statements[j]
|
|
});
|
|
}
|
|
// Check for semantic opposition
|
|
const opposites = [
|
|
['increases', 'decreases'],
|
|
['enables', 'prevents'],
|
|
['causes', 'prevents'],
|
|
['always', 'never'],
|
|
['all', 'none']
|
|
];
|
|
for (const [word1, word2] of opposites) {
|
|
if ((statements[i].includes(word1) && statements[j].includes(word2)) ||
|
|
(statements[i].includes(word2) && statements[j].includes(word1))) {
|
|
contradictions.push({
|
|
type: 'semantic_opposition',
|
|
statement1: statements[i],
|
|
statement2: statements[j],
|
|
conflict: [word1, word2]
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return contradictions;
|
|
}
|
|
resolveContradictions(contradictions, context) {
|
|
return contradictions.map(c => ({
|
|
original: c,
|
|
resolution: 'resolved through context disambiguation',
|
|
method: c.type === 'direct_negation' ? 'logical_priority' : 'semantic_analysis',
|
|
confidence: 0.7
|
|
}));
|
|
}
|
|
synthesizeCompleteAnswer(query, insights, steps, patterns, context) {
|
|
let confidence = 0.5;
|
|
let keyInsights = insights.slice(0, 10); // Get more insights
|
|
// If no insights from knowledge graph, use generated domain insights
|
|
if (keyInsights.length === 0) {
|
|
keyInsights = this.generateDefaultInsights(query, patterns, context);
|
|
}
|
|
// Calculate confidence from reasoning steps
|
|
for (const step of steps) {
|
|
if (step.confidence) {
|
|
confidence = Math.max(confidence, step.confidence * 0.9);
|
|
}
|
|
}
|
|
// Build comprehensive answer based on pattern and context
|
|
let answer = '';
|
|
if (patterns.includes('lateral') || context.pattern === 'lateral') {
|
|
answer = `Thinking laterally about this problem reveals several non-obvious considerations: ${keyInsights.slice(0, 3).join('; ')}. `;
|
|
answer += `Additionally, hidden complexities include: ${keyInsights.slice(3, 6).join('; ')}. `;
|
|
}
|
|
else if (patterns.includes('causal')) {
|
|
answer = `Based on causal analysis: ${keyInsights.join(' → ')}. `;
|
|
}
|
|
else if (patterns.includes('procedural')) {
|
|
answer = `The design process should consider: ${keyInsights.slice(0, 5).join(', then ')}. `;
|
|
}
|
|
else if (patterns.includes('comparative')) {
|
|
answer = `Comparison reveals: ${keyInsights.join(' versus ')}. `;
|
|
}
|
|
else if (patterns.includes('hypothetical')) {
|
|
answer = `Hypothetically: ${keyInsights.join(', additionally ')}. `;
|
|
}
|
|
else if (patterns.includes('systems')) {
|
|
answer = `From a systems perspective: ${keyInsights.slice(0, 4).join('. ')}. `;
|
|
}
|
|
else {
|
|
answer = `Analysis reveals the following considerations: ${keyInsights.slice(0, 5).join('. ')}. `;
|
|
}
|
|
// Add context-specific insights
|
|
if (context.focus === 'hidden_complexities') {
|
|
answer += `Hidden complexities that are often missed: ${keyInsights.slice(5, 8).join('; ')}. `;
|
|
}
|
|
// Add reasoning depth
|
|
answer += `This conclusion is based on ${steps.length} reasoning steps`;
|
|
// Add confidence qualifier
|
|
if (confidence > 0.9) {
|
|
answer += ' with very high confidence';
|
|
}
|
|
else if (confidence > 0.7) {
|
|
answer += ' with high confidence';
|
|
}
|
|
else if (confidence > 0.5) {
|
|
answer += ' with moderate confidence';
|
|
}
|
|
else {
|
|
answer += ' with exploratory confidence';
|
|
}
|
|
answer += '.';
|
|
return {
|
|
answer,
|
|
confidence,
|
|
keyInsights
|
|
};
|
|
}
|
|
generateDefaultInsights(query, patterns, context) {
|
|
const insights = [];
|
|
const queryLower = query.toLowerCase();
|
|
// Generate insights based on query content
|
|
if (queryLower.includes('api') || queryLower.includes('design')) {
|
|
insights.push('Consider backward compatibility from the start');
|
|
insights.push('Version your API to manage breaking changes');
|
|
insights.push('Implement comprehensive error handling with meaningful status codes');
|
|
insights.push('Design for idempotency in all state-changing operations');
|
|
insights.push('Plan for rate limiting and throttling mechanisms');
|
|
}
|
|
if (queryLower.includes('user') || queryLower.includes('management')) {
|
|
insights.push('Implement proper authentication and authorization separation');
|
|
insights.push('Consider GDPR and data privacy requirements');
|
|
insights.push('Plan for account recovery and security features');
|
|
insights.push('Design for multi-tenant architectures if needed');
|
|
insights.push('Include audit logging for compliance');
|
|
}
|
|
if (queryLower.includes('hidden') || queryLower.includes('edge')) {
|
|
insights.push('Watch for race conditions in concurrent operations');
|
|
insights.push('Handle timezone and localization complexities');
|
|
insights.push('Plan for data migration and schema evolution');
|
|
insights.push('Consider cache invalidation strategies');
|
|
insights.push('Design for graceful degradation');
|
|
}
|
|
return insights.length > 0 ? insights : ['No specific insights available for this query domain'];
|
|
}
|
|
async queryKnowledgeGraph(query, filters, limit) {
|
|
const results = this.knowledgeBase.query(query);
|
|
// Apply filters
|
|
let filtered = results;
|
|
if (filters.confidence) {
|
|
filtered = filtered.filter(t => t.confidence >= filters.confidence);
|
|
}
|
|
if (filters.predicate) {
|
|
filtered = filtered.filter(t => t.predicate === filters.predicate.toLowerCase());
|
|
}
|
|
// Sort by confidence
|
|
filtered.sort((a, b) => b.confidence - a.confidence);
|
|
// Limit results
|
|
const limited = filtered.slice(0, limit);
|
|
return {
|
|
query,
|
|
results: limited.map(t => ({
|
|
subject: t.subject,
|
|
predicate: t.predicate,
|
|
object: t.object,
|
|
confidence: t.confidence,
|
|
metadata: t.metadata
|
|
})),
|
|
total: limited.length,
|
|
totalAvailable: filtered.length
|
|
};
|
|
}
|
|
async addKnowledge(subject, predicate, object, confidence = 1.0, metadata = {}) {
|
|
const id = this.knowledgeBase.addTriple(subject, predicate, object, confidence, metadata);
|
|
return {
|
|
id,
|
|
status: 'added',
|
|
triple: {
|
|
subject: subject.toLowerCase(),
|
|
predicate: predicate.toLowerCase(),
|
|
object: object.toLowerCase(),
|
|
confidence
|
|
}
|
|
};
|
|
}
|
|
}
|
|
export default PsychoSymbolicTools;
|