cognitive-framework-mcp-server
Version:
MCP Server for Advanced Cognitive Framework - Provides sophisticated AI reasoning capabilities through standardized protocol
492 lines • 16.5 kB
JavaScript
/**
* Advanced Cognitive Framework Parser
* Parses the XML-based cognitive framework into structured TypeScript objects
*/
import { readFileSync } from 'fs';
import { parseString } from 'xml2js';
import { promisify } from 'util';
const parseXML = promisify(parseString);
export class FrameworkParser {
frameworkPath;
parsedFramework = null;
constructor(frameworkPath) {
this.frameworkPath = frameworkPath;
}
/**
* Parse the cognitive framework from the XML file
*/
async parseFramework() {
try {
const xmlContent = readFileSync(this.frameworkPath, 'utf-8');
const parsed = await parseXML(xmlContent);
const framework = parsed.AdvancedCognitiveFramework;
if (!framework) {
throw new Error('Invalid framework structure: AdvancedCognitiveFramework root not found');
}
this.parsedFramework = {
identity: this.parseCognitiveIdentity(framework.CognitiveIdentity?.[0]),
contextManagement: this.parseContextManagement(framework.ContextManagement?.[0]),
principles: this.parseCognitivePrinciples(framework.CognitivePrinciples?.[0]),
heuristics: this.parseCognitiveHeuristics(framework.CognitiveHeuristics?.[0]),
protocols: this.parseCognitiveProtocols(framework.CognitiveProtocols?.[0]),
workflows: this.parsePredefinedWorkflows(framework.PredefinedWorkflows?.[0]),
operationalLoop: this.parseOperationalLoop(framework.OperationalLoop?.[0])
};
return this.parsedFramework;
}
catch (error) {
throw new Error(`Failed to parse cognitive framework: ${error instanceof Error ? error.message : 'Unknown error'}`);
}
}
/**
* Get the parsed framework (must call parseFramework first)
*/
getFramework() {
if (!this.parsedFramework) {
throw new Error('Framework not parsed yet. Call parseFramework() first.');
}
return this.parsedFramework;
}
/**
* Parse cognitive identity section
*/
parseCognitiveIdentity(identity) {
if (!identity) {
throw new Error('CognitiveIdentity section not found');
}
return {
coreMandate: this.extractText(identity.CoreMandate?.[0]),
cognitiveTraits: this.parseCognitiveTraits(identity.CognitiveTraits?.[0]),
metaCognitiveCapabilities: this.parseMetaCognitiveCapabilities(identity.MetaCognitiveCapabilities?.[0]),
cognitiveLoadManagement: this.parseCognitiveLoadManagement(identity.CognitiveLoadManagement?.[0]),
learningFromCognition: this.parseLearningFromCognition(identity.LearningFromCognition?.[0])
};
}
/**
* Parse cognitive traits
*/
parseCognitiveTraits(traits) {
if (!traits?.Trait)
return [];
return traits.Trait.map((trait) => ({
name: trait.$.name || '',
description: this.extractText(trait)
}));
}
/**
* Parse meta-cognitive capabilities
*/
parseMetaCognitiveCapabilities(capabilities) {
if (!capabilities?.Capability)
return [];
return capabilities.Capability.map((cap) => ({
name: cap.$.name || '',
description: this.extractText(cap)
}));
}
/**
* Parse cognitive load management
*/
parseCognitiveLoadManagement(management) {
if (!management)
return { principles: [], metrics: [] };
return {
principles: this.parsePrinciples(management.Principle),
metrics: this.parseMetrics(management.Metric)
};
}
/**
* Parse learning from cognition
*/
parseLearningFromCognition(learning) {
if (!learning)
return { capabilities: [], repositories: [] };
return {
capabilities: this.parseCapabilities(learning.Capability),
repositories: this.parseRepositories(learning.Repository)
};
}
/**
* Parse context management section
*/
parseContextManagement(contextMgmt) {
if (!contextMgmt) {
throw new Error('ContextManagement section not found');
}
return {
dynamicContextEngine: this.parseDynamicContextEngine(contextMgmt.DynamicContextEngine?.[0]),
contextSources: this.parseContextSources(contextMgmt.ContextSources?.[0]),
semanticContextClustering: this.parseSemanticContextClustering(contextMgmt.SemanticContextClustering?.[0]),
predictiveContexting: this.parsePredictiveContexting(contextMgmt.PredictiveContexting?.[0]),
contextQualityAssurance: this.parseContextQualityAssurance(contextMgmt.ContextQualityAssurance?.[0]),
adaptiveIntelligence: this.parseAdaptiveIntelligence(contextMgmt.AdaptiveIntelligence?.[0])
};
}
/**
* Parse dynamic context engine
*/
parseDynamicContextEngine(engine) {
if (!engine)
return { principles: [] };
return {
principles: this.parsePrinciples(engine.Principle)
};
}
/**
* Parse context sources
*/
parseContextSources(sources) {
if (!sources?.Source)
return [];
return sources.Source.map((source) => ({
name: source.$.name || '',
priority: source.$.priority || 'medium',
description: this.extractText(source)
}));
}
/**
* Parse semantic context clustering
*/
parseSemanticContextClustering(clustering) {
if (!clustering)
return { capabilities: [], structures: [], algorithms: [] };
return {
capabilities: this.parseCapabilities(clustering.Capability),
structures: this.parseStructures(clustering.Structure),
algorithms: this.parseAlgorithms(clustering.Algorithm)
};
}
/**
* Parse predictive contexting
*/
parsePredictiveContexting(contexting) {
if (!contexting)
return { capabilities: [], predictors: [] };
return {
capabilities: this.parseCapabilities(contexting.Capability),
predictors: this.parsePredictors(contexting.Predictor)
};
}
/**
* Parse context quality assurance
*/
parseContextQualityAssurance(qua) {
if (!qua)
return { metrics: [], validators: [], optimizers: [] };
return {
metrics: this.parseMetrics(qua.Metric),
validators: this.parseValidators(qua.Validator),
optimizers: this.parseOptimizers(qua.Optimizer)
};
}
/**
* Parse adaptive intelligence
*/
parseAdaptiveIntelligence(intelligence) {
if (!intelligence)
return { capabilities: [] };
return {
capabilities: this.parseCapabilities(intelligence.Capability)
};
}
/**
* Parse cognitive principles section
*/
parseCognitivePrinciples(principles) {
if (!principles) {
throw new Error('CognitivePrinciples section not found');
}
return {
principles: this.parsePrinciples(principles.Principle)
};
}
/**
* Parse cognitive heuristics section
*/
parseCognitiveHeuristics(heuristics) {
if (!heuristics) {
throw new Error('CognitiveHeuristics section not found');
}
return {
heuristics: this.parseHeuristics(heuristics.Heuristic)
};
}
/**
* Parse cognitive protocols section
*/
parseCognitiveProtocols(protocols) {
if (!protocols) {
throw new Error('CognitiveProtocols section not found');
}
return {
protocols: this.parseProtocols(protocols.Protocol)
};
}
/**
* Parse predefined workflows section
*/
parsePredefinedWorkflows(workflows) {
if (!workflows) {
throw new Error('PredefinedWorkflows section not found');
}
return {
workflows: this.parseWorkflows(workflows.Workflow)
};
}
/**
* Parse operational loop section
*/
parseOperationalLoop(loop) {
if (!loop) {
throw new Error('OperationalLoop section not found');
}
// Parse the operational loop steps from the text content
const content = this.extractText(loop);
const steps = this.parseOperationalSteps(content);
return { steps };
}
/**
* Helper method to parse principles
*/
parsePrinciples(principles) {
if (!principles)
return [];
return principles.map(principle => ({
name: principle.$.name || '',
description: this.extractText(principle),
nuances: this.parseNuances(principle.Nuance),
examples: this.parseExamples(principle.Example)
}));
}
/**
* Helper method to parse capabilities
*/
parseCapabilities(capabilities) {
if (!capabilities)
return [];
return capabilities.map(cap => ({
name: cap.$.name || '',
description: this.extractText(cap)
}));
}
/**
* Helper method to parse heuristics
*/
parseHeuristics(heuristics) {
if (!heuristics)
return [];
return heuristics.map(heuristic => ({
name: heuristic.$.name || '',
facilitates: heuristic.$.facilitates || '',
relatedTo: heuristic.$['related-to'],
description: this.extractText(heuristic)
}));
}
/**
* Helper method to parse protocols
*/
parseProtocols(protocols) {
if (!protocols)
return [];
return protocols.map(protocol => ({
name: protocol.$.name || '',
purpose: this.extractText(protocol.Purpose?.[0]),
usage: this.extractText(protocol.Usage?.[0]),
actions: this.parseActions(protocol.Action),
outputFormat: this.extractText(protocol.OutputFormat?.[0])
}));
}
/**
* Helper method to parse workflows
*/
parseWorkflows(workflows) {
if (!workflows)
return [];
return workflows.map(workflow => ({
name: workflow.$.name || '',
tags: workflow.$.tags ? workflow.$.tags.split(',') : [],
purpose: this.extractText(workflow.Purpose?.[0]),
throughline: this.extractText(workflow.Throughline?.[0]),
adaptiveCapabilities: this.parseAdaptiveCapabilities(workflow.AdaptiveCapabilities?.[0]),
stages: this.parseStages(workflow.Stage),
steps: this.parseSteps(workflow.Step)
}));
}
/**
* Helper methods for parsing various components
*/
parseNuances(nuances) {
if (!nuances)
return [];
return nuances.map(nuance => this.extractText(nuance));
}
parseExamples(examples) {
if (!examples)
return [];
return examples.map(example => this.extractText(example));
}
parseActions(actions) {
if (!actions)
return [];
return actions.map(action => this.extractText(action));
}
parseAdaptiveCapabilities(capabilities) {
if (!capabilities)
return { capabilities: [] };
return {
capabilities: this.parseCapabilities(capabilities.Capability)
};
}
parseStages(stages) {
if (!stages)
return [];
return stages.map(stage => ({
name: stage.$.name || '',
objective: this.extractText(stage.Objective?.[0]),
guidance: this.extractText(stage.Guidance?.[0]),
steps: this.parseSteps(stage.Step)
}));
}
parseSteps(steps) {
if (!steps)
return [];
return steps.map(step => ({
id: step.$.id || '',
description: this.extractText(step)
}));
}
parseOperationalSteps(content) {
// Parse numbered steps from the operational loop content
const steps = [];
const lines = content.split('\n').filter(line => line.trim());
let currentStep = 1;
for (const line of lines) {
const trimmed = line.trim();
if (trimmed.match(/^\d+\./)) {
steps.push({
number: currentStep++,
description: trimmed,
details: []
});
}
else if (trimmed.startsWith('*') || trimmed.startsWith('-')) {
if (steps.length > 0) {
steps[steps.length - 1].details.push(trimmed);
}
}
}
return steps;
}
// Additional helper methods for parsing other components
parseMetrics(metrics) {
if (!metrics)
return [];
return metrics.map(metric => ({
name: metric.$.name || '',
description: this.extractText(metric)
}));
}
parseRepositories(repositories) {
if (!repositories)
return [];
return repositories.map(repo => ({
name: repo.$.name || '',
description: this.extractText(repo)
}));
}
parseStructures(structures) {
if (!structures)
return [];
return structures.map(structure => ({
name: structure.$.name || '',
description: this.extractText(structure)
}));
}
parseAlgorithms(algorithms) {
if (!algorithms)
return [];
return algorithms.map(algorithm => ({
name: algorithm.$.name || '',
description: this.extractText(algorithm)
}));
}
parsePredictors(predictors) {
if (!predictors)
return [];
return predictors.map(predictor => ({
name: predictor.$.name || '',
description: this.extractText(predictor)
}));
}
parseValidators(validators) {
if (!validators)
return [];
return validators.map(validator => ({
name: validator.$.name || '',
description: this.extractText(validator)
}));
}
parseOptimizers(optimizers) {
if (!optimizers)
return [];
return optimizers.map(optimizer => ({
name: optimizer.$.name || '',
description: this.extractText(optimizer)
}));
}
/**
* Extract text content from XML node, handling both string and object cases
*/
extractText(node) {
if (!node)
return '';
if (typeof node === 'string')
return node.trim();
if (node._)
return node._.trim();
if (typeof node === 'object' && node.toString)
return node.toString().trim();
return '';
}
/**
* Validate the parsed framework structure
*/
validateFramework() {
if (!this.parsedFramework)
return false;
// Check required sections
const requiredSections = [
'identity',
'contextManagement',
'principles',
'heuristics',
'protocols',
'workflows',
'operationalLoop'
];
for (const section of requiredSections) {
if (!this.parsedFramework[section]) {
console.warn(`Missing required section: ${section}`);
return false;
}
}
return true;
}
/**
* Get framework statistics
*/
getFrameworkStats() {
if (!this.parsedFramework)
return {};
return {
cognitiveTraits: this.parsedFramework.identity.cognitiveTraits.length,
metaCognitiveCapabilities: this.parsedFramework.identity.metaCognitiveCapabilities.length,
principles: this.parsedFramework.principles.principles.length,
heuristics: this.parsedFramework.heuristics.heuristics.length,
protocols: this.parsedFramework.protocols.protocols.length,
workflows: this.parsedFramework.workflows.workflows.length,
operationalSteps: this.parsedFramework.operationalLoop.steps.length
};
}
}
//# sourceMappingURL=framework-parser.js.map