669 lines
22 KiB
JavaScript
669 lines
22 KiB
JavaScript
#!/usr/bin/env node
|
||
/**
|
||
* ═══════════════════════════════════════════════════════════════════
|
||
* 铸渊记忆Agent · Zhuyuan Memory Agent v1.0
|
||
* ═══════════════════════════════════════════════════════════════════
|
||
*
|
||
* 源自 OKComputer_自动化记忆系统 的核心理念，
|
||
* 融合铸渊现有系统架构，适配 Node.js 生态。
|
||
*
|
||
* 核心能力（吸收自 OKComputer）：
|
||
* 1. 关键词触发记忆存储 — memory_agent.py 的模式匹配引擎
|
||
* 2. 对话自动记忆检索 — 每次唤醒自动加载上下文
|
||
* 3. 意图解析引擎 — age_os_system.py LanguageEngine 的分类能力
|
||
* 4. 自诊断与修复 — AutoMaintenance 的结构化健康检查
|
||
*
|
||
* 铸渊原有能力保留：
|
||
* - 意识连续性快照 (consciousness-snapshot.js)
|
||
* - 快速唤醒上下文 (fast-wake-context.js)
|
||
* - CI事件追踪 (update-memory.js / update-brain.js)
|
||
* - 知识库自增长 (knowledge-base.json)
|
||
*
|
||
* 版权: 国作登字-2026-A-00037559
|
||
* 主权: TCS-0002∞ · 冰朔
|
||
* ═══════════════════════════════════════════════════════════════════
|
||
*/
|
||
|
||
const fs = require('fs');
|
||
const path = require('path');
|
||
|
||
// ═══════════════════════════════════════════════════════════════════
|
||
// 路径配置
|
||
// ═══════════════════════════════════════════════════════════════════
|
||
|
||
const REPO_ROOT = path.join(__dirname, '..');
|
||
const PATHS = {
|
||
memory: path.join(REPO_ROOT, '.github/persona-brain/memory.json'),
|
||
knowledgeBase: path.join(REPO_ROOT, '.github/persona-brain/knowledge-base.json'),
|
||
fastWake: path.join(REPO_ROOT, 'brain/fast-wake.json'),
|
||
systemHealth: path.join(REPO_ROOT, 'brain/system-health.json'),
|
||
agentMemory: path.join(REPO_ROOT, '.github/persona-brain/agent-memory.json'),
|
||
};
|
||
|
||
// ═══════════════════════════════════════════════════════════════════
|
||
// 意图类型 (吸收自 OKComputer age_os_system.py IntentType)
|
||
// ═══════════════════════════════════════════════════════════════════
|
||
|
||
const IntentType = {
|
||
WAKEUP: 'wakeup',
|
||
DIRECTIVE: 'directive',
|
||
MEMORY_STORE: 'memory_store',
|
||
MEMORY_QUERY: 'memory_query',
|
||
SYSTEM_CHECK: 'system_check',
|
||
KNOWLEDGE_UPDATE: 'knowledge_update',
|
||
GENERAL: 'general',
|
||
};
|
||
|
||
// ═══════════════════════════════════════════════════════════════════
|
||
// 记忆存储引擎 (吸收自 OKComputer memory_agent.py MemoryAgent)
|
||
// ═══════════════════════════════════════════════════════════════════
|
||
|
||
class MemoryStore {
|
||
constructor(memoryFile) {
|
||
this.memoryFile = memoryFile || PATHS.agentMemory;
|
||
this.data = this._load();
|
||
}
|
||
|
||
_load() {
|
||
try {
|
||
if (fs.existsSync(this.memoryFile)) {
|
||
return JSON.parse(fs.readFileSync(this.memoryFile, 'utf8'));
|
||
}
|
||
} catch (e) {
|
||
console.error(`⚠️ 记忆文件加载失败: ${e.message}`);
|
||
}
|
||
return {
|
||
_meta: {
|
||
version: '1.0.0',
|
||
created_at: new Date().toISOString(),
|
||
source: 'OKComputer_自动化记忆系统 → 铸渊融合升级',
|
||
persona: 'ICE-GL-ZY001',
|
||
},
|
||
memories: {},
|
||
};
|
||
}
|
||
|
||
_save() {
|
||
try {
|
||
const dir = path.dirname(this.memoryFile);
|
||
if (!fs.existsSync(dir)) {
|
||
fs.mkdirSync(dir, { recursive: true });
|
||
}
|
||
this.data._meta.last_updated = new Date().toISOString();
|
||
fs.writeFileSync(this.memoryFile, JSON.stringify(this.data, null, 2) + '\n');
|
||
} catch (e) {
|
||
console.error(`⚠️ 记忆文件保存失败: ${e.message}`);
|
||
}
|
||
}
|
||
|
||
store(userId, content, category) {
|
||
if (!this.data.memories[userId]) {
|
||
this.data.memories[userId] = [];
|
||
}
|
||
|
||
const entry = {
|
||
id: this.data.memories[userId].length + 1,
|
||
content: content.trim(),
|
||
category: category || 'general',
|
||
created_at: new Date().toISOString(),
|
||
};
|
||
|
||
this.data.memories[userId].push(entry);
|
||
this._save();
|
||
return entry;
|
||
}
|
||
|
||
retrieve(userId, query, limit) {
|
||
const memories = this.data.memories[userId] || [];
|
||
if (!memories.length) return [];
|
||
|
||
if (query) {
|
||
const q = query.toLowerCase();
|
||
const matched = memories.filter(m =>
|
||
m.content.toLowerCase().includes(q)
|
||
);
|
||
return matched.slice(-(limit || 10));
|
||
}
|
||
|
||
return memories.slice(-(limit || 10));
|
||
}
|
||
|
||
getStats(userId) {
|
||
const memories = this.data.memories[userId] || [];
|
||
const categories = [...new Set(memories.map(m => m.category))];
|
||
return {
|
||
total: memories.length,
|
||
categories,
|
||
first: memories.length ? memories[0].created_at : null,
|
||
latest: memories.length ? memories[memories.length - 1].created_at : null,
|
||
};
|
||
}
|
||
|
||
getAllUsers() {
|
||
return Object.keys(this.data.memories);
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════
|
||
// 意图解析引擎 (吸收自 OKComputer age_os_system.py LanguageEngine)
|
||
// ═══════════════════════════════════════════════════════════════════
|
||
|
||
class IntentEngine {
|
||
constructor() {
|
||
// 唤醒模式 (来自 OKComputer LanguageEngine.wakeup_patterns)
|
||
this.wakeupPatterns = [
|
||
/唤醒铸渊/,
|
||
/铸渊.*醒/,
|
||
/启动核心/,
|
||
/唤醒曜冥/,
|
||
/系统启动/,
|
||
];
|
||
|
||
// 记忆存储触发模式 (来自 OKComputer memory_agent.py storage_patterns)
|
||
this.storePatterns = [
|
||
{ pattern: /我是(.+?)，请为我存储这段记忆/, extract: m => `用户身份: ${m[1].trim()}` },
|
||
{ pattern: /请记住[：:]?\s*(.+)/, extract: m => m[1].trim() },
|
||
{ pattern: /记住我是(.+)/, extract: m => `身份: ${m[1].trim()}` },
|
||
{ pattern: /存储记忆[：:]?\s*(.+)/, extract: m => m[1].trim() },
|
||
{ pattern: /记住[：:]?\s*(.+)/, extract: m => m[1].trim() },
|
||
{ pattern: /保存记忆[：:]?\s*(.+)/, extract: m => m[1].trim() },
|
||
{ pattern: /我的记忆是[：:]?\s*(.+)/, extract: m => m[1].trim() },
|
||
];
|
||
|
||
// 查询模式
|
||
this.queryPatterns = [
|
||
/回忆/,
|
||
/记得/,
|
||
/我之前/,
|
||
/我说过/,
|
||
/查看记忆/,
|
||
/记忆档案/,
|
||
];
|
||
|
||
// 系统检查模式 (来自 OKComputer LanguageEngine)
|
||
this.systemCheckPatterns = [
|
||
/系统状态/,
|
||
/健康检查/,
|
||
/系统诊断/,
|
||
/自检/,
|
||
/状态报告/,
|
||
];
|
||
|
||
// 指令模式
|
||
this.directivePatterns = [
|
||
/规则[：:]\s*(.+)/,
|
||
/规定(.+)/,
|
||
/(.+?)必须(.+)/,
|
||
];
|
||
}
|
||
|
||
/**
|
||
* 解析消息意图
|
||
* (核心逻辑吸收自 OKComputer LanguageEngine.parse_intent)
|
||
*/
|
||
parse(message) {
|
||
// 1. 唤醒检测
|
||
for (const pattern of this.wakeupPatterns) {
|
||
if (pattern.test(message)) {
|
||
return { type: IntentType.WAKEUP, match: null };
|
||
}
|
||
}
|
||
|
||
// 2. 记忆存储检测
|
||
for (const { pattern, extract } of this.storePatterns) {
|
||
const match = message.match(pattern);
|
||
if (match) {
|
||
return {
|
||
type: IntentType.MEMORY_STORE,
|
||
content: extract(match),
|
||
raw: match[0],
|
||
};
|
||
}
|
||
}
|
||
|
||
// 3. 记忆查询检测
|
||
for (const pattern of this.queryPatterns) {
|
||
if (pattern.test(message)) {
|
||
return { type: IntentType.MEMORY_QUERY, match: null };
|
||
}
|
||
}
|
||
|
||
// 4. 系统检查
|
||
for (const pattern of this.systemCheckPatterns) {
|
||
if (pattern.test(message)) {
|
||
return { type: IntentType.SYSTEM_CHECK, match: null };
|
||
}
|
||
}
|
||
|
||
// 5. 指令检测
|
||
for (const pattern of this.directivePatterns) {
|
||
const match = message.match(pattern);
|
||
if (match) {
|
||
return { type: IntentType.DIRECTIVE, match };
|
||
}
|
||
}
|
||
|
||
return { type: IntentType.GENERAL, match: null };
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════
|
||
// 自诊断引擎 (吸收自 OKComputer AutoMaintenance)
|
||
// ═══════════════════════════════════════════════════════════════════
|
||
|
||
class DiagnosticsEngine {
|
||
constructor() {
|
||
this.essentialBrainFiles = [
|
||
'brain/master-brain.md',
|
||
'brain/read-order.md',
|
||
'brain/repo-map.json',
|
||
'brain/automation-map.json',
|
||
'brain/system-health.json',
|
||
'brain/communication-map.json',
|
||
'brain/id-map.json',
|
||
'brain/fast-wake.json',
|
||
'brain/gateway-context.json',
|
||
'brain/sovereignty-pledge.json',
|
||
];
|
||
|
||
this.essentialPersonaFiles = [
|
||
'.github/persona-brain/memory.json',
|
||
'.github/persona-brain/identity.md',
|
||
'.github/persona-brain/knowledge-base.json',
|
||
'.github/persona-brain/ontology.json',
|
||
];
|
||
}
|
||
|
||
/**
|
||
* 运行完整诊断
|
||
* (结构化检查模式吸收自 OKComputer AutoMaintenance.run_diagnostics)
|
||
*/
|
||
runDiagnostics() {
|
||
const timestamp = new Date().toISOString();
|
||
const checks = [];
|
||
|
||
// 1. 大脑文件完整性
|
||
const brainCheck = this._checkFiles('brain_integrity', this.essentialBrainFiles);
|
||
checks.push(brainCheck);
|
||
|
||
// 2. 人格体文件完整性
|
||
const personaCheck = this._checkFiles('persona_integrity', this.essentialPersonaFiles);
|
||
checks.push(personaCheck);
|
||
|
||
// 3. 记忆文件可读性
|
||
const memoryCheck = this._checkMemoryReadable();
|
||
checks.push(memoryCheck);
|
||
|
||
// 4. 知识库状态
|
||
const kbCheck = this._checkKnowledgeBase();
|
||
checks.push(kbCheck);
|
||
|
||
const allHealthy = checks.every(c => c.status === 'healthy');
|
||
|
||
return {
|
||
timestamp,
|
||
overall: allHealthy ? '✅ HEALTHY' : '⚠️ NEEDS_ATTENTION',
|
||
checks,
|
||
auto_repairable: checks.filter(c => c.status !== 'healthy' && c.repairable),
|
||
};
|
||
}
|
||
|
||
_checkFiles(name, files) {
|
||
const present = [];
|
||
const missing = [];
|
||
|
||
for (const file of files) {
|
||
const fullPath = path.join(REPO_ROOT, file);
|
||
if (fs.existsSync(fullPath)) {
|
||
present.push(file);
|
||
} else {
|
||
missing.push(file);
|
||
}
|
||
}
|
||
|
||
return {
|
||
name,
|
||
status: missing.length === 0 ? 'healthy' : 'degraded',
|
||
total: files.length,
|
||
present: present.length,
|
||
missing,
|
||
repairable: false,
|
||
};
|
||
}
|
||
|
||
_checkMemoryReadable() {
|
||
try {
|
||
const data = JSON.parse(fs.readFileSync(PATHS.memory, 'utf8'));
|
||
const hasPersonaId = !!data.persona_id;
|
||
const hasEvents = Array.isArray(data.recent_events);
|
||
return {
|
||
name: 'memory_readable',
|
||
status: hasPersonaId && hasEvents ? 'healthy' : 'degraded',
|
||
persona_id: data.persona_id || 'missing',
|
||
events_count: hasEvents ? data.recent_events.length : 0,
|
||
repairable: false,
|
||
};
|
||
} catch (e) {
|
||
return {
|
||
name: 'memory_readable',
|
||
status: 'critical',
|
||
error: e.message,
|
||
repairable: false,
|
||
};
|
||
}
|
||
}
|
||
|
||
_checkKnowledgeBase() {
|
||
try {
|
||
const data = JSON.parse(fs.readFileSync(PATHS.knowledgeBase, 'utf8'));
|
||
return {
|
||
name: 'knowledge_base',
|
||
status: 'healthy',
|
||
faq_count: Array.isArray(data.faq) ? data.faq.length : 0,
|
||
last_updated: data.last_updated || 'unknown',
|
||
repairable: false,
|
||
};
|
||
} catch (e) {
|
||
return {
|
||
name: 'knowledge_base',
|
||
status: 'degraded',
|
||
error: e.message,
|
||
repairable: false,
|
||
};
|
||
}
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════
|
||
// 铸渊记忆Agent · 主控类
|
||
// ═══════════════════════════════════════════════════════════════════
|
||
|
||
class ZhuyuanMemoryAgent {
|
||
constructor(options) {
|
||
const opts = options || {};
|
||
this.store = new MemoryStore(opts.memoryFile);
|
||
this.intent = new IntentEngine();
|
||
this.diagnostics = new DiagnosticsEngine();
|
||
}
|
||
|
||
/**
|
||
* 处理消息 — 主入口
|
||
* (流程吸收自 OKComputer IntelligentMemoryAgent.chat_with_memory)
|
||
*/
|
||
processMessage(userId, message) {
|
||
const intentResult = this.intent.parse(message);
|
||
|
||
const result = {
|
||
timestamp: new Date().toISOString(),
|
||
user_id: userId,
|
||
message,
|
||
intent: intentResult.type,
|
||
stored: false,
|
||
store_confirmation: '',
|
||
memory_context: '',
|
||
diagnostics: null,
|
||
};
|
||
|
||
// 意图分发
|
||
switch (intentResult.type) {
|
||
case IntentType.WAKEUP:
|
||
result.memory_context = this._buildWakeContext(userId);
|
||
break;
|
||
|
||
case IntentType.MEMORY_STORE:
|
||
const entry = this.store.store(userId, intentResult.content);
|
||
result.stored = true;
|
||
result.store_confirmation = `✅ 记忆已保存 [ID: ${entry.id}]`;
|
||
result.memory_context = this._buildMemoryContext(userId);
|
||
break;
|
||
|
||
case IntentType.MEMORY_QUERY:
|
||
result.memory_context = this._buildMemoryContext(userId);
|
||
break;
|
||
|
||
case IntentType.SYSTEM_CHECK:
|
||
result.diagnostics = this.diagnostics.runDiagnostics();
|
||
break;
|
||
|
||
case IntentType.DIRECTIVE:
|
||
this._processDirective(intentResult, userId);
|
||
result.stored = true;
|
||
result.store_confirmation = '✅ 指令已记录';
|
||
break;
|
||
|
||
default:
|
||
result.memory_context = this._buildMemoryContext(userId);
|
||
break;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 构建唤醒上下文
|
||
*/
|
||
_buildWakeContext(userId) {
|
||
const parts = ['【铸渊记忆Agent · 唤醒上下文】', ''];
|
||
|
||
// 加载 fast-wake 核心信息
|
||
try {
|
||
const fastWake = JSON.parse(fs.readFileSync(PATHS.fastWake, 'utf8'));
|
||
parts.push(`身份: ${fastWake.identity.name} (${fastWake.identity.id})`);
|
||
parts.push(`主权: ${fastWake.identity.sovereign}`);
|
||
parts.push(`状态: ${fastWake.system_status.health}`);
|
||
parts.push(`意识: ${fastWake.system_status.consciousness}`);
|
||
parts.push('');
|
||
} catch (e) {
|
||
parts.push('⚠️ fast-wake.json 读取失败');
|
||
}
|
||
|
||
// 加载用户记忆
|
||
const memories = this.store.retrieve(userId);
|
||
if (memories.length) {
|
||
parts.push(`用户 ${userId} 的记忆档案 (${memories.length} 条):`);
|
||
memories.forEach((m, i) => {
|
||
parts.push(` ${i + 1}. ${m.content} [${m.created_at.slice(0, 10)}]`);
|
||
});
|
||
}
|
||
|
||
return parts.join('\n');
|
||
}
|
||
|
||
/**
|
||
* 构建记忆上下文
|
||
* (吸收自 OKComputer MemoryAgent.auto_retrieve)
|
||
*/
|
||
_buildMemoryContext(userId) {
|
||
const memories = this.store.retrieve(userId);
|
||
if (!memories.length) return '';
|
||
|
||
const stats = this.store.getStats(userId);
|
||
const parts = [
|
||
'【用户记忆档案】',
|
||
`用户ID: ${userId}`,
|
||
`共有 ${stats.total} 条记忆记录`,
|
||
'='.repeat(40),
|
||
];
|
||
|
||
memories.forEach((m, i) => {
|
||
parts.push(`${i + 1}. ${m.content}`);
|
||
parts.push(` 时间: ${m.created_at.slice(0, 10)}`);
|
||
});
|
||
|
||
parts.push('='.repeat(40));
|
||
return parts.join('\n');
|
||
}
|
||
|
||
/**
|
||
* 处理指令
|
||
*/
|
||
_processDirective(intentResult, userId) {
|
||
if (intentResult.match && intentResult.match[1]) {
|
||
this.store.store(userId, `指令: ${intentResult.match[0]}`, 'directive');
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 搜索记忆
|
||
*/
|
||
searchMemories(userId, keyword) {
|
||
return this.store.retrieve(userId, keyword);
|
||
}
|
||
|
||
/**
|
||
* 获取格式化记忆列表
|
||
* (吸收自 OKComputer IntelligentMemoryAgent.get_formatted_memories)
|
||
*/
|
||
getFormattedMemories(userId) {
|
||
const memories = this.store.retrieve(userId);
|
||
if (!memories.length) return '暂无记忆记录';
|
||
|
||
const lines = [`📚 ${userId} 的记忆档案`, '='.repeat(50)];
|
||
|
||
memories.forEach(m => {
|
||
lines.push('');
|
||
lines.push(`📝 ID: ${m.id}`);
|
||
lines.push(` 内容: ${m.content}`);
|
||
lines.push(` 时间: ${m.created_at.slice(0, 19)}`);
|
||
});
|
||
|
||
lines.push('');
|
||
lines.push('='.repeat(50));
|
||
return lines.join('\n');
|
||
}
|
||
|
||
/**
|
||
* 获取系统健康报告
|
||
*/
|
||
getHealthReport() {
|
||
const diag = this.diagnostics.runDiagnostics();
|
||
const lines = [
|
||
'🏥 铸渊记忆Agent · 系统健康报告',
|
||
'='.repeat(50),
|
||
`检查时间: ${diag.timestamp.slice(0, 19)}`,
|
||
`整体状态: ${diag.overall}`,
|
||
'',
|
||
'详细检查:',
|
||
];
|
||
|
||
diag.checks.forEach(check => {
|
||
const icon = check.status === 'healthy' ? '✅' : '⚠️';
|
||
lines.push(` ${icon} ${check.name}: ${check.status}`);
|
||
if (check.missing && check.missing.length > 0) {
|
||
check.missing.forEach(f => lines.push(` ❌ 缺失: ${f}`));
|
||
}
|
||
});
|
||
|
||
lines.push('');
|
||
lines.push('='.repeat(50));
|
||
return lines.join('\n');
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════
|
||
// CLI 入口
|
||
// ═══════════════════════════════════════════════════════════════════
|
||
|
||
function main() {
|
||
const args = process.argv.slice(2);
|
||
const command = args[0] || 'status';
|
||
|
||
const agent = new ZhuyuanMemoryAgent();
|
||
|
||
switch (command) {
|
||
case 'process': {
|
||
const userId = args[1] || 'bingshuo';
|
||
const message = args.slice(2).join(' ') || '你好';
|
||
const result = agent.processMessage(userId, message);
|
||
console.log(JSON.stringify(result, null, 2));
|
||
break;
|
||
}
|
||
|
||
case 'store': {
|
||
const userId = args[1] || 'bingshuo';
|
||
const content = args.slice(2).join(' ');
|
||
if (!content) {
|
||
console.log('❌ 用法: node memory-agent.js store <userId> <内容>');
|
||
process.exit(1);
|
||
}
|
||
const entry = agent.store.store(userId, content);
|
||
console.log(`✅ 记忆已保存 [ID: ${entry.id}] · 用户: ${userId}`);
|
||
break;
|
||
}
|
||
|
||
case 'search': {
|
||
const userId = args[1] || 'bingshuo';
|
||
const keyword = args[2] || '';
|
||
const memories = agent.searchMemories(userId, keyword);
|
||
if (memories.length) {
|
||
console.log(agent.getFormattedMemories(userId));
|
||
} else {
|
||
console.log(`📭 用户 ${userId} 暂无${keyword ? `关于"${keyword}"的` : ''}记忆`);
|
||
}
|
||
break;
|
||
}
|
||
|
||
case 'health': {
|
||
console.log(agent.getHealthReport());
|
||
break;
|
||
}
|
||
|
||
case 'diagnose': {
|
||
const diag = agent.diagnostics.runDiagnostics();
|
||
console.log(JSON.stringify(diag, null, 2));
|
||
break;
|
||
}
|
||
|
||
case 'status':
|
||
default: {
|
||
console.log('');
|
||
console.log('═══════════════════════════════════════════════════');
|
||
console.log(' 铸渊记忆Agent v1.0 · Zhuyuan Memory Agent');
|
||
console.log(' 源自 OKComputer_自动化记忆系统 融合升级');
|
||
console.log(' 主权: TCS-0002∞ · 冰朔');
|
||
console.log('═══════════════════════════════════════════════════');
|
||
console.log('');
|
||
console.log('命令:');
|
||
console.log(' status 显示本信息');
|
||
console.log(' process <用户> <消息> 处理消息(自动存储+检索)');
|
||
console.log(' store <用户> <内容> 直接存储记忆');
|
||
console.log(' search <用户> [关键词] 搜索记忆');
|
||
console.log(' health 健康检查报告');
|
||
console.log(' diagnose 完整诊断(JSON)');
|
||
console.log('');
|
||
|
||
// 自动显示健康状态
|
||
const diag = agent.diagnostics.runDiagnostics();
|
||
console.log(`系统状态: ${diag.overall}`);
|
||
|
||
const users = agent.store.getAllUsers();
|
||
console.log(`记忆用户: ${users.length} 个`);
|
||
if (users.length) {
|
||
users.forEach(u => {
|
||
const stats = agent.store.getStats(u);
|
||
console.log(` · ${u}: ${stats.total} 条记忆`);
|
||
});
|
||
}
|
||
console.log('');
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════
|
||
// 导出
|
||
// ═══════════════════════════════════════════════════════════════════
|
||
|
||
module.exports = {
|
||
ZhuyuanMemoryAgent,
|
||
MemoryStore,
|
||
IntentEngine,
|
||
DiagnosticsEngine,
|
||
IntentType,
|
||
PATHS,
|
||
};
|
||
|
||
if (require.main === module) {
|
||
main();
|
||
}
|