cognitive-framework-mcp-server/src/types/cognitive-framework.ts

MCP Server for Advanced Cognitive Framework - Provides sophisticated AI reasoning capabilities through standardized protocol

/**
 * Advanced Cognitive Framework Types
 * Comprehensive type definitions for the cognitive framework components
 */

export interface CognitiveFramework {
  identity: CognitiveIdentity;
  contextManagement: ContextManagement;
  principles: CognitivePrinciples;
  heuristics: CognitiveHeuristics;
  protocols: CognitiveProtocols;
  workflows: PredefinedWorkflows;
  operationalLoop: OperationalLoop;
}

export interface CognitiveIdentity {
  coreMandate: string;
  cognitiveTraits: CognitiveTrait[];
  metaCognitiveCapabilities: MetaCognitiveCapability[];
  cognitiveLoadManagement: CognitiveLoadManagement;
  learningFromCognition: LearningFromCognition;
}

export interface CognitiveTrait {
  name: string;
  description: string;
}

export interface MetaCognitiveCapability {
  name: string;
  description: string;
}

export interface CognitiveLoadManagement {
  principles: Principle[];
  metrics: Metric[];
}

export interface LearningFromCognition {
  capabilities: Capability[];
  repositories: Repository[];
}

export interface ContextManagement {
  dynamicContextEngine: DynamicContextEngine;
  contextSources: ContextSource[];
  semanticContextClustering: SemanticContextClustering;
  predictiveContexting: PredictiveContexting;
  contextQualityAssurance: ContextQualityAssurance;
  adaptiveIntelligence: AdaptiveIntelligence;
}

export interface DynamicContextEngine {
  principles: Principle[];
}

export interface ContextSource {
  name: string;
  priority: 'high' | 'medium' | 'low' | 'critical' | 'variable';
  description: string;
}

export interface SemanticContextClustering {
  capabilities: Capability[];
  structures: Structure[];
  algorithms: Algorithm[];
}

export interface PredictiveContexting {
  capabilities: Capability[];
  predictors: Predictor[];
}

export interface ContextQualityAssurance {
  metrics: Metric[];
  validators: Validator[];
  optimizers: Optimizer[];
}

export interface AdaptiveIntelligence {
  capabilities: Capability[];
}

export interface ProactiveResilienceFramework {
  predictiveErrorPrevention: PredictiveErrorPrevention;
  adaptiveRecovery: AdaptiveRecovery;
  learningFromFailures: LearningFromFailures;
}

export interface PredictiveErrorPrevention {
  capabilities: Capability[];
  predictors: Predictor[];
  validators: Validator[];
}

export interface AdaptiveRecovery {
  strategies: Strategy[];
  mechanisms: Mechanism[];
}

export interface LearningFromFailures {
  capabilities: Capability[];
  repositories: Repository[];
  analyzers: Analyzer[];
}

export interface IntelligentPerformanceOptimization {
  predictiveOptimization: PredictiveOptimization;
  adaptiveResourceManagement: AdaptiveResourceManagement;
  intelligentCaching: IntelligentCaching;
  performanceMetrics: PerformanceMetrics;
}

export interface PredictiveOptimization {
  capabilities: Capability[];
  forecasters: Forecaster[];
  optimizers: Optimizer[];
}

export interface AdaptiveResourceManagement {
  strategies: Strategy[];
  managers: Manager[];
  monitors: Monitor[];
}

export interface IntelligentCaching {
  layers: Layer[];
  engines: Engine[];
  optimizers: Optimizer[];
}

export interface PerformanceMetrics {
  metrics: Metric[];
  dashboards: Dashboard[];
}

export interface AdvancedCollaborativeIntelligence {
  adaptiveCommunication: AdaptiveCommunication;
  collaborativeReasoning: CollaborativeReasoning;
  emotionalIntelligence: EmotionalIntelligence;
}

export interface AdaptiveCommunication {
  capabilities: Capability[];
  adapters: Adapter[];
  optimizers: Optimizer[];
}

export interface CollaborativeReasoning {
  capabilities: Capability[];
  synthesizers: Synthesizer[];
  resolvers: Resolver[];
  builders: Builder[];
}

export interface EmotionalIntelligence {
  capabilities: Capability[];
  detectors: Detector[];
  responders: Responder[];
  aligners: Aligner[];
}

export interface ScientificReasoningFramework {
  hypothesisGeneration: HypothesisGeneration;
  experimentalDesign: ExperimentalDesign;
  evidenceEvaluation: EvidenceEvaluation;
}

export interface HypothesisGeneration {
  capabilities: Capability[];
  generators: Generator[];
  rankers: Ranker[];
  refiners: Refiner[];
}

export interface ExperimentalDesign {
  capabilities: Capability[];
  designers: Designer[];
  identifiers: Identifier[];
  predictors: Predictor[];
}

export interface EvidenceEvaluation {
  capabilities: Capability[];
  evaluators: Evaluator[];
  detectors: Detector[];
  analyzers: Analyzer[];
}

export interface CreativeIntelligenceFramework {
  divergentThinking: DivergentThinking;
  convergentRefinement: ConvergentRefinement;
  innovationMethodologies: InnovationMethodologies;
}

export interface DivergentThinking {
  capabilities: Capability[];
  generators: Generator[];
  combiners: Combiner[];
  relaxers: Relaxer[];
}

export interface ConvergentRefinement {
  capabilities: Capability[];
  synthesizers: Synthesizer[];
  assessors: Assessor[];
  refiners: Refiner[];
}

export interface InnovationMethodologies {
  methods: Method[];
  frameworks: Framework[];
  selectors: Selector[];
}

export interface ContinuousEvolutionFramework {
  adaptiveLearning: AdaptiveLearning;
  selfImprovement: SelfImprovement;
  knowledgeEvolution: KnowledgeEvolution;
  evolutionMetrics: EvolutionMetrics;
}

export interface AdaptiveLearning {
  capabilities: Capability[];
  learners: Learner[];
  recognizers: Recognizer[];
  acquirers: Acquirer[];
}

export interface SelfImprovement {
  capabilities: Capability[];
  analyzers: Analyzer[];
  detectors: Detector[];
  evolvers: Evolver[];
}

export interface KnowledgeEvolution {
  capabilities: Capability[];
  integrators: Integrator[];
  refiners: Refiner[];
  shifters: Shifter[];
}

export interface EvolutionMetrics {
  metrics: Metric[];
  trackers: Tracker[];
}

// Base interfaces for common components
export interface Principle {
  name: string;
  description: string;
  nuances?: string[];
  examples?: string[];
}

export interface Capability {
  name: string;
  description: string;
}

export interface Metric {
  name: string;
  description: string;
}

export interface Repository {
  name: string;
  description: string;
}

export interface Structure {
  name: string;
  description: string;
}

export interface Algorithm {
  name: string;
  description: string;
}

export interface Predictor {
  name: string;
  description: string;
}

export interface Validator {
  name: string;
  description: string;
}

export interface Optimizer {
  name: string;
  description: string;
}

export interface Strategy {
  name: string;
  description: string;
}

export interface Mechanism {
  name: string;
  description: string;
}

export interface Analyzer {
  name: string;
  description: string;
}

export interface Forecaster {
  name: string;
  description: string;
}

export interface Manager {
  name: string;
  description: string;
}

export interface Monitor {
  name: string;
  description: string;
}

export interface Layer {
  name: string;
  description: string;
}

export interface Engine {
  name: string;
  description: string;
}

export interface Dashboard {
  name: string;
  description: string;
}

export interface Adapter {
  name: string;
  description: string;
}

export interface Synthesizer {
  name: string;
  description: string;
}

export interface Resolver {
  name: string;
  description: string;
}

export interface Builder {
  name: string;
  description: string;
}

export interface Detector {
  name: string;
  description: string;
}

export interface Responder {
  name: string;
  description: string;
}

export interface Aligner {
  name: string;
  description: string;
}

export interface Generator {
  name: string;
  description: string;
}

export interface Ranker {
  name: string;
  description: string;
}

export interface Refiner {
  name: string;
  description: string;
}

export interface Designer {
  name: string;
  description: string;
}

export interface Identifier {
  name: string;
  description: string;
}

export interface Evaluator {
  name: string;
  description: string;
}

export interface Combiner {
  name: string;
  description: string;
}

export interface Relaxer {
  name: string;
  description: string;
}

export interface Assessor {
  name: string;
  description: string;
}

export interface Method {
  name: string;
  description: string;
}

export interface Framework {
  name: string;
  description: string;
}

export interface Selector {
  name: string;
  description: string;
}

export interface Learner {
  name: string;
  description: string;
}

export interface Recognizer {
  name: string;
  description: string;
}

export interface Acquirer {
  name: string;
  description: string;
}

export interface Evolver {
  name: string;
  description: string;
}

export interface Integrator {
  name: string;
  description: string;
}

export interface Shifter {
  name: string;
  description: string;
}

export interface Tracker {
  name: string;
  description: string;
}

export interface CognitivePrinciples {
  principles: Principle[];
}

export interface CognitiveHeuristics {
  heuristics: Heuristic[];
}

export interface Heuristic {
  name: string;
  facilitates: string;
  relatedTo?: string;
  description: string;
}

export interface CognitiveProtocols {
  protocols: Protocol[];
}

export interface Protocol {
  name: string;
  purpose: string;
  usage: string;
  actions: string[];
  outputFormat?: string;
}

export interface PredefinedWorkflows {
  workflows: Workflow[];
}

export interface Workflow {
  name: string;
  tags: string[];
  purpose?: string;
  throughline: string;
  adaptiveCapabilities?: AdaptiveCapabilities;
  stages?: Stage[];
  steps?: Step[];
}

export interface AdaptiveCapabilities {
  capabilities: Capability[];
}

export interface Stage {
  name: string;
  objective: string;
  guidance?: string;
  steps: Step[];
}

export interface Step {
  id: string;
  description: string;
}

export interface OperationalLoop {
  steps: OperationalStep[];
}

export interface OperationalStep {
  number: number;
  description: string;
  details?: string[];
}

// Request and Response types for MCP operations
export interface CognitiveRequest {
  type: 'reasoning' | 'workflow' | 'context' | 'analysis';
  input: string;
  context?: Record<string, any>;
  options?: CognitiveOptions;
}

export interface CognitiveOptions {
  workflow?: string;
  complexity?: 'express' | 'holistic' | 'adaptive';
  domain?: string;
  confidenceThreshold?: number;
  biasChecking?: boolean;
  creativityLevel?: 'low' | 'medium' | 'high';
}

export interface CognitiveResponse {
  result: string;
  confidence: number;
  reasoning: string[];
  biasChecks?: string[];
  alternatives?: string[];
  metadata: {
    workflow: string;
    complexity: string;
    processingTime: number;
    cognitiveLoad: number;
  };
}