const logger = require('@promptx/logger');
const Network = require('./Network');
const Remember = require('./Remember');
const Prime = require('./Prime');
const Memory = require('./Memory');
const { TemperatureWeightStrategy } = require('./WeightStrategy');
const TwoPhaseRecallStrategy = require('./TwoPhaseRecallStrategy');
/**
* CognitionSystem - 认知系统主控制器
*
* ## 设计理念
*
* CognitionSystem是整个认知模块的门面（Facade），统一管理所有认知操作。
* 它协调Network、Remember、Recall、Prime等组件，提供简单的API。
*
* ## 为什么这样设计
*
* 1. **统一入口**
* - 外部只需要与CognitionSystem交互
* - 隐藏内部复杂性
* - 便于版本升级和重构
*
* 2. **生命周期管理**
* - 管理Network的创建和销毁
* - 协调各操作的执行顺序
* - 处理频率更新等统计任务
*
* 3. **策略注入**
* - 统一的权重策略配置
* - 确保Remember和Recall使用相同策略
* - 便于切换不同的策略实现
*
* ## 架构位置
*
* ```
* 用户代码
* ↓
* CognitionSystem (协调器)
* ├── Network (容器)
* ├── Remember (写)
* ├── Recall (读)
* └── Prime (启动)
* ```
*
* @class CognitionSystem
*/
class CognitionSystem {
/**
* 创建认知系统
*
* @param {Object} options - 配置选项
* @param {string} options.dataPath - 数据文件路径
* @param {Object} options.strategyOptions - 策略配置
* @param {Object} options.rememberOptions - Remember配置
* @param {Object} options.recallOptions - Recall配置
*/
constructor(options = {}) {
/**
* 数据持久化路径
* @type {string}
*/
this.dataPath = options.dataPath || './cognition.json';
/**
* 全局认知网络
* @type {Network}
*/
this.network = new Network();
/**
* 权重计算策略
* @type {WeightStrategy}
*/
this.strategy = new TemperatureWeightStrategy({
decay: 0.9,
activationThreshold: 0.01, // 降低过滤阈值
frequencyFactor: 0.1, // 频率因子
temperature: 0.8, // 提高温度，允许适度扩散
contrastMode: 'auto', // 自动调节对比度
...options.strategyOptions
});
// 让策略能访问network（用于获取频率）
this.strategy.network = this.network;
/**
* Remember引擎配置
* @type {Object}
*/
this.rememberOptions = {
...options.rememberOptions,
strategy: this.strategy
};
/**
* Recall引擎配置
* @type {Object}
*/
this.recallOptions = {
...options.recallOptions,
weightStrategy: this.strategy // 传递权重策略
};
/**
* Remember引擎实例（延迟创建）
* @type {Remember|null}
*/
this.rememberEngine = null;
/**
* Recall引擎实例（延迟创建）
* @type {TwoPhaseRecallStrategy|null}
*/
this.recallEngine = null;
/**
* Memory存储实例（延迟创建）
* @type {Memory|null}
*/
this.memory = null;
logger.info('[CognitionSystem] Initialized', {
dataPath: this.dataPath,
strategyType: this.strategy.constructor.name
});
}
/**
* 获取Remember引擎（懒加载）
*
* @returns {Remember}
*/
getRememberEngine() {
if (!this.rememberEngine) {
this.rememberEngine = new Remember(this.network, this.rememberOptions);
}
return this.rememberEngine;
}
/**
* 获取Recall引擎（懒加载）
*
* @returns {TwoPhaseRecallStrategy}
*/
getRecallEngine() {
if (!this.recallEngine) {
// 使用新的两阶段召回策略
this.recallEngine = new TwoPhaseRecallStrategy({
// 第一阶段配置
maxActivations: this.recallOptions.maxActivations || 100,
// 第二阶段配置
typeWeights: this.recallOptions.typeWeights || {
'PATTERN': 2.0,
'LINK': 1.5,
'ATOMIC': 1.0
},
typeQuotas: this.recallOptions.typeQuotas || {
'PATTERN': 10,
'LINK': 15,
'ATOMIC': 25
},
totalLimit: this.recallOptions.totalLimit || 50,
// 传递权重策略
activationStrategy: this.recallOptions.activationStrategy,
weightFactors: this.recallOptions.weightFactors
});
// 注入依赖
this.recallEngine.setDependencies(this.network, this.getMemory());
}
return this.recallEngine;
}
/**
* 获取Memory存储（懒加载）
*
* @returns {Memory|null} Memory实例，如果没有directory则返回null
*/
getMemory() {
if (!this.memory && this.network.directory) {
const path = require('path');
const memoryPath = path.join(this.network.directory, 'engrams.db');
this.memory = new Memory(memoryPath);
}
return this.memory;
}
/**
* 记忆操作
*
* 执行流程：
* 1. 存储Engram到Memory（使用engram.id）
* 2. 调用Remember引擎处理Schema连接
* 3. 建立Cue到Engram.id的反向索引
*
* @param {Engram} engram - 记忆痕迹对象
* @returns {Promise<Object>} 记忆结果
*/
async remember(engram) {
logger.debug('[CognitionSystem] Remember operation', {
id: engram.id,
schemaLength: engram.length,
strength: engram.strength,
preview: engram.getPreview()
});
// 存储到Memory（使用engram.id作为key）
if (this.getMemory()) {
try {
await this.getMemory().store(engram);
logger.debug('[CognitionSystem] Stored engram to memory', { id: engram.id });
} catch (error) {
logger.error('[CognitionSystem] Failed to store engram to memory', {
id: engram.id,
error: error.message
});
throw error;
}
}
const remember = this.getRememberEngine();
const result = remember.execute(engram, engram.id);
// 注意：持久化由CognitionManager.saveSystem()负责
// 这里不再自动保存，避免路径冲突
return result;
}
/**
* 回忆操作
*
* 执行流程：
* 1. 调用Recall引擎激活网络
* 2. 加载与原始查询相关的Engrams
* 3. 更新被激活节点的频率
* 4. 返回激活的Mind（包含engrams）
*
* @param {string} word - 起始概念
* @param {Object} options - 可选参数
* @param {string} options.mode - 认知激活模式 ('creative' | 'balanced' | 'focused')
* @returns {Promise<Mind|null>} 激活的认知网络
*/
async recall(word, options = {}) {
const mode = options.mode || 'balanced';
logger.debug('[CognitionSystem] Recall operation', { word, mode });
// 如果指定了 mode，创建新的引擎实例
let recallEngine;
if (mode && mode !== 'balanced') {
const TwoPhaseRecallStrategy = require('./TwoPhaseRecallStrategy');
recallEngine = new TwoPhaseRecallStrategy({ mode });
recallEngine.setDependencies(this.network, this.getMemory());
logger.info('[CognitionSystem] Created recall engine with mode', { mode });
} else {
recallEngine = this.getRecallEngine();
}
// 使用新的两阶段召回策略
// TwoPhaseRecallStrategy已经在内部处理了engrams的加载和排序
const mind = await recallEngine.recall(word);
if (!mind) {
return null;
}
// 更新频率
if (mind.activatedCues.size > 0) {
this.network.updateRecallFrequency(mind.activatedCues);
logger.debug('[CognitionSystem] Updated frequencies after recall', {
activatedCount: mind.activatedCues.size,
engramCount: mind.engrams?.length || 0
});
}
return mind;
}
/**
* 加载与查询词直接相关的Engrams
*
* @param {Mind} mind - Mind对象
* @param {string} originalQuery - 原始查询词
* @returns {Promise<void>}
*/
async loadEngrams(mind, originalQuery) {
mind.engrams = [];
// Debug logging for loadEngrams process
logger.info('[CognitionSystem] DEBUG - loadEngrams process:', {
originalQuery,
networkCuesSize: this.network.cues.size,
hasMemorySystem: !!this.getMemory(),
networkCuesKeys: Array.from(this.network.cues.keys())
});
// 只加载与原始查询词直接相关的engrams
const queryCue = this.network.cues.get(originalQuery);
logger.info('[CognitionSystem] DEBUG - queryCue lookup:', {
originalQuery,
hasQueryCue: !!queryCue,
queryCueMemories: queryCue?.memories,
memoriesLength: queryCue?.memories?.length
});
if (queryCue && queryCue.memories) {
for (const engramId of queryCue.memories) {
const engramData = await this.getMemory().get(engramId);
logger.debug('[CognitionSystem] DEBUG - loading engram:', {
engramId,
hasEngramData: !!engramData,
engramContent: engramData?.content?.substring(0, 50)
});
if (engramData) {
mind.engrams.push({
id: engramData.id,
content: engramData.content,
schema: engramData.schema,
strength: engramData.strength,
type: engramData.type, // 添加type字段
timestamp: engramData.timestamp,
activatedBy: originalQuery
});
}
}
} else {
logger.info('[CognitionSystem] DEBUG - No engrams loaded - reason:', {
hasQueryCue: !!queryCue,
hasMemories: !!queryCue?.memories,
query: originalQuery
});
}
logger.debug('[CognitionSystem] Loaded engrams', {
query: originalQuery,
engramCount: mind.engrams.length
});
}
/**
* 启动操作
*
* 执行流程：
* 1. 从磁盘加载Network
* 2. 使用Prime选择起始点
* 3. 执行预热Recall
*
* @returns {Mind|null} 预热的认知网络
*/
async prime() {
logger.debug('[CognitionSystem] Prime operation');
// 注意：数据加载已由CognitionManager.getSystem()完成
// 这里直接使用已加载的network，不再重复加载
logger.info('[CognitionSystem] Using existing network', {
cues: this.network.size()
});
// 使用Prime执行启动，Prime.execute()已经包含了选择启动词和执行recall的逻辑
const prime = new Prime(this.network);
const mind = prime.execute();
if (!mind) {
logger.warn('[CognitionSystem] Prime found no suitable starting point or recall failed');
return null;
}
logger.info('[CognitionSystem] Prime completed', {
activatedNodes: mind.activatedCues?.size || 0,
connections: mind.connections?.length || 0,
centerWord: mind.centerWord
});
// 加载与prime中心词相关的engrams
if (this.getMemory() && mind.centerWord) {
try {
await this.loadEngrams(mind, mind.centerWord);
logger.info('[CognitionSystem] Loaded engrams for prime center word', {
centerWord: mind.centerWord,
engramCount: mind.engrams?.length || 0
});
} catch (error) {
logger.error('[CognitionSystem] Failed to load engrams for prime', {
centerWord: mind.centerWord,
error: error.message
});
// 不影响prime的核心功能，继续执行
}
}
// Prime时不更新频率，因为这是系统自动触发的
return mind;
}
/**
* 获取系统统计信息
*
* @returns {Object} 统计信息
*/
getStatistics() {
const networkStats = this.network.getStatistics();
const frequencyStats = this.network.getFrequencyStatistics();
return {
network: networkStats,
frequency: frequencyStats,
dataPath: this.dataPath,
strategy: {
type: this.strategy.constructor.name,
decay: this.strategy.decay,
frequencyFactor: this.strategy.frequencyFactor || 0
}
};
}
/**
* 清空系统
*
* 用于测试或重置。
*/
clear() {
this.network.clear();
this.rememberEngine = null;
this.recallEngine = null;
logger.info('[CognitionSystem] System cleared');
}
/**
* 手动保存
*
* 虽然remember会自动保存，但提供手动保存接口。
*/
save() {
this.network.persistSync(this.dataPath);
logger.info('[CognitionSystem] Manual save completed');
}
/**
* 手动加载
*
* 虽然prime会自动加载，但提供手动加载接口。
*/
load() {
this.network.loadSync(this.dataPath);
// 重置引擎，因为network变了
this.rememberEngine = null;
this.recallEngine = null;
logger.info('[CognitionSystem] Manual load completed');
}
}
module.exports = CognitionSystem;
