#!/usr/bin/env python3
|
"""
|
memory-md-learning 学习记录脚本
|
记录陷阱、教训和解决方案到长期记忆和 MEMORY.md
|
"""
|
|
import os
|
import re
|
import sys
|
import argparse
|
from datetime import datetime
|
from pathlib import Path
|
|
# 配置
|
MEMORY_FILE = Path.home() / ".openclaw" / "workspace" / "MEMORY.md"
|
ARCHIVE_THRESHOLD_KB = 50
|
|
|
def read_memory_file():
|
"""读取 memory.md 文件内容"""
|
if not MEMORY_FILE.exists():
|
return ""
|
return MEMORY_FILE.read_text(encoding='utf-8')
|
|
|
def write_memory_file(content):
|
"""写入 memory.md 文件"""
|
MEMORY_FILE.parent.mkdir(parents=True, exist_ok=True)
|
MEMORY_FILE.write_text(content, encoding='utf-8')
|
|
|
def get_file_size():
|
"""获取文件大小（字节）"""
|
if not MEMORY_FILE.exists():
|
return 0
|
return MEMORY_FILE.stat().st_size
|
|
|
def extract_learning_entries(content):
|
"""从内容中提取学习事件条目"""
|
learning_events = []
|
|
lines = content.split('\n')
|
in_learning = False
|
|
for line in lines:
|
stripped = line.strip()
|
|
# 检测学习事件区块
|
if '学习事件' in stripped and stripped.startswith('#'):
|
in_learning = True
|
continue
|
elif stripped.startswith('#') and in_learning:
|
in_learning = False
|
|
# 收集学习事件
|
if in_learning and (stripped.startswith('-') or stripped.startswith('*')):
|
if len(stripped) > 10:
|
learning_events.append(line)
|
|
return learning_events
|
|
|
def store_technical_memory(trap, cause, fix, prevent):
|
"""
|
存储技术层记忆
|
格式：陷阱：[现象]。原因：[根本原因]。修复：[解决方案]。预防：[如何避免]
|
"""
|
content = f"陷阱：{trap}。原因：{cause}。修复：{fix}。预防：{prevent}"
|
|
# 使用 memory_store 工具存储
|
# 注意：实际调用需要通过外部机制，这里返回内容供调用方使用
|
return {
|
'content': content,
|
'category': 'fact',
|
'importance': 0.8,
|
'keywords': extract_keywords(content)
|
}
|
|
|
def store_principle_memory(principle, trigger, action, tag):
|
"""
|
存储原则层记忆
|
格式：决策原则（[标签]）：[行为准则]。触发条件：[何时]。行动：[做什么]
|
"""
|
content = f"决策原则（{tag}）：{principle}。触发条件：{trigger}。行动：{action}"
|
|
return {
|
'content': content,
|
'category': 'decision',
|
'importance': 0.85,
|
'keywords': extract_keywords(content)
|
}
|
|
|
def extract_keywords(text):
|
"""从文本中提取关键词"""
|
# 简单实现：提取中文字符和英文单词
|
import re
|
chinese_chars = re.findall(r'[\u4e00-\u9fff]{2,}', text)
|
english_words = re.findall(r'[a-zA-Z]{3,}', text)
|
return list(set(chinese_chars + english_words))[:10] # 最多10个关键词
|
|
|
def verify_memory_recall(keywords, timeout=5):
|
"""
|
验证记忆是否能被正确召回
|
返回: {'verified': bool, 'results': list}
|
"""
|
# 实际实现中需要调用 memory_recall
|
# 这里返回模拟结果
|
return {
|
'verified': True,
|
'results': [],
|
'message': '记忆召回验证需要调用 memory_recall 工具'
|
}
|
|
|
def update_memory_md_learning(summary, keywords):
|
"""
|
更新 MEMORY.md 的学习事件区块
|
"""
|
content = read_memory_file()
|
if not content:
|
# 如果文件不存在，先创建一个基础结构
|
content = generate_base_content()
|
|
# 检查是否已有学习事件区块
|
if '## 📚 学习事件' not in content:
|
# 在学习事件区块不存在时，在文件末尾添加
|
learning_section = f"""
|
|
---
|
|
## 📚 学习事件
|
|
> 记录从陷阱和教训中学习的经验。
|
> 所有学习记录永久保留，可使用 memory-md-archive 技能归档瘦身。
|
|
"""
|
# 在归档提示之前插入
|
if '---' in content and '*文件大小:' in content:
|
# 找到最后一个分隔符之前
|
last_sep = content.rfind('---\n\n*文件大小:')
|
if last_sep > 0:
|
content = content[:last_sep] + learning_section + content[last_sep:]
|
else:
|
content = content + learning_section
|
else:
|
content = content + learning_section
|
|
# 提取现有的学习事件
|
existing_events = extract_learning_entries(content)
|
|
# 添加新的学习事件
|
now = datetime.now()
|
date_str = now.strftime('%Y-%m-%d')
|
time_str = now.strftime('%H:%M')
|
new_event = f"- {date_str} {time_str} | {summary} | {keywords}"
|
|
# 检查是否已存在
|
if any(new_event.strip() in existing.strip() for existing in existing_events):
|
return {'added': False, 'message': '学习事件已存在'}
|
|
# 找到学习事件区块并插入新事件
|
lines = content.split('\n')
|
new_lines = []
|
in_learning = False
|
learning_inserted = False
|
|
for i, line in enumerate(lines):
|
stripped = line.strip()
|
|
# 检测学习事件区块开始
|
if '## 📚 学习事件' in stripped:
|
in_learning = True
|
new_lines.append(line)
|
continue
|
|
# 检测学习事件区块结束（遇到下一个标题或文件末尾信息）
|
if in_learning and stripped.startswith('#') and '学习事件' not in stripped:
|
if not learning_inserted:
|
new_lines.append(new_event)
|
learning_inserted = True
|
in_learning = False
|
new_lines.append(line)
|
continue
|
|
# 在学习事件区块内，跳过空行后插入新事件
|
if in_learning and not learning_inserted:
|
if stripped == '' and i > 0 and '记录从陷阱' not in lines[i-1] and '所有学习记录' not in lines[i-1]:
|
new_lines.append(new_event)
|
new_lines.append('')
|
learning_inserted = True
|
continue
|
|
new_lines.append(line)
|
|
# 如果在文件末尾，确保插入了事件
|
if in_learning and not learning_inserted:
|
new_lines.append(new_event)
|
|
# 更新文件大小信息
|
new_content = '\n'.join(new_lines)
|
|
# 更新文件大小统计
|
write_memory_file(new_content)
|
new_size = get_file_size()
|
size_kb = round(new_size / 1024, 2)
|
|
# 更新底部统计信息
|
new_content = update_footer_stats(new_content, size_kb)
|
write_memory_file(new_content)
|
|
return {
|
'added': True,
|
'event': new_event,
|
'size_kb': size_kb,
|
'archive_suggested': size_kb > ARCHIVE_THRESHOLD_KB
|
}
|
|
|
def update_footer_stats(content, size_kb):
|
"""更新文件底部的统计信息"""
|
# 统计学习事件数量
|
learning_events = extract_learning_entries(content)
|
learning_count = len(learning_events)
|
|
# 替换或添加归档提示
|
if '*归档提示:' in content:
|
# 替换现有提示
|
content = re.sub(
|
r'\*归档提示:.*\*',
|
f"*归档提示: 文件较大时请使用 memory-md-archive 技能归档（当前 {size_kb}KB，{learning_count} 条学习事件）*",
|
content
|
)
|
elif '---' in content and '*文件大小:' in content:
|
# 在文件大小行后添加
|
content = content.replace(
|
'*维护脚本:',
|
f"*归档提示: 文件较大时请使用 memory-md-archive 技能归档（当前 {size_kb}KB，{learning_count} 条学习事件）*\n*维护脚本:"
|
)
|
|
return content
|
|
|
def generate_base_content():
|
"""生成基础的 memory.md 内容"""
|
today = datetime.now().strftime('%Y-%m-%d')
|
return f"""# MEMORY.md - 热记忆 / 活跃记忆
|
|
> 本文件记录近期发生的重要事情，详细信息可通过记忆检索获取。
|
|
---
|
|
## 🔔 重要事件
|
|
> 记录具有全局长期性影响的重要决策和事件。
|
> 添加重要事件时会告知用户。
|
|
<!-- 重要事件在此添加 -->
|
|
---
|
|
## 📅 事件流水
|
|
> 按天分组，每天主要事情的概要。
|
> 所有记录永久保留，可使用 memory-md-archive 技能归档瘦身。
|
|
### {today}
|
|
- {today} --:-- | 暂无记录 | --
|
|
---
|
|
*文件大小: ~0.5KB | 事件数: 0*
|
*维护脚本: `memory-md-hot/scripts/daily_maintenance.py`*
|
*归档提示: 文件较大时请使用 memory-md-archive 技能归档*
|
"""
|
|
|
def record_learning(trap, cause, fix, prevent, principle, trigger, action, tag, summary, keywords):
|
"""
|
记录学习的主函数
|
|
Returns:
|
dict: 操作结果
|
"""
|
result = {
|
'success': False,
|
'technical_memory': None,
|
'principle_memory': None,
|
'learning_event': None,
|
'recall_verified': False,
|
'messages': []
|
}
|
|
# 1. 准备技术层记忆
|
technical = store_technical_memory(trap, cause, fix, prevent)
|
result['technical_memory'] = technical
|
result['messages'].append(f"技术层记忆已准备: {technical['content'][:50]}...")
|
|
# 2. 准备原则层记忆
|
principle_mem = store_principle_memory(principle, trigger, action, tag)
|
result['principle_memory'] = principle_mem
|
result['messages'].append(f"原则层记忆已准备: {principle_mem['content'][:50]}...")
|
|
# 3. 更新 MEMORY.md 学习事件
|
learning_result = update_memory_md_learning(summary, keywords)
|
result['learning_event'] = learning_result
|
if learning_result['added']:
|
result['messages'].append(f"学习事件已记录: {learning_result['event']}")
|
else:
|
result['messages'].append(f"学习事件: {learning_result['message']}")
|
|
# 4. 验证记忆召回（模拟）
|
all_keywords = technical['keywords'] + principle_mem['keywords']
|
verify_result = verify_memory_recall(all_keywords)
|
result['recall_verified'] = verify_result['verified']
|
result['messages'].append(f"记忆召回验证: {verify_result['message']}")
|
|
# 5. 归档提示
|
if learning_result.get('archive_suggested'):
|
result['messages'].append(f"提示: 文件大小 {learning_result['size_kb']}KB，建议使用 memory-md-archive 技能归档")
|
|
result['success'] = True
|
return result
|
|
|
def main():
|
"""主函数 - 供命令行调用"""
|
parser = argparse.ArgumentParser(description='记录学习成果')
|
parser.add_argument('--trap', required=True, help='陷阱现象描述')
|
parser.add_argument('--cause', required=True, help='根本原因分析')
|
parser.add_argument('--fix', required=True, help='解决方案')
|
parser.add_argument('--prevent', required=True, help='预防措施')
|
parser.add_argument('--principle', required=True, help='行为准则')
|
parser.add_argument('--trigger', required=True, help='触发条件')
|
parser.add_argument('--action', required=True, help='具体行动')
|
parser.add_argument('--tag', required=True, help='原则标签')
|
parser.add_argument('--summary', required=True, help='一句话概要')
|
parser.add_argument('--keywords', required=True, help='关键词，逗号分隔')
|
|
args = parser.parse_args()
|
|
result = record_learning(
|
trap=args.trap,
|
cause=args.cause,
|
fix=args.fix,
|
prevent=args.prevent,
|
principle=args.principle,
|
trigger=args.trigger,
|
action=args.action,
|
tag=args.tag,
|
summary=args.summary,
|
keywords=args.keywords
|
)
|
|
if result['success']:
|
print("✅ 学习记录完成")
|
print(f"\n技术层记忆:")
|
print(f" {result['technical_memory']['content']}")
|
print(f"\n原则层记忆:")
|
print(f" {result['principle_memory']['content']}")
|
print(f"\n学习事件:")
|
if result['learning_event']['added']:
|
print(f" {result['learning_event']['event']}")
|
else:
|
print(f" {result['learning_event']['message']}")
|
print(f"\n记忆召回验证: {'通过' if result['recall_verified'] else '待验证'}")
|
print("\n注意：技术层和原则层记忆需要调用 memory_store 工具实际存储到长期记忆")
|
for msg in result['messages']:
|
if '提示' in msg:
|
print(f"\n{msg}")
|
else:
|
print("❌ 学习记录失败")
|
for msg in result['messages']:
|
print(f" - {msg}")
|
sys.exit(1)
|
|
|
if __name__ == "__main__":
|
main()
|
