Skill: yoo-unison/memu-lite (version 1.1.0)

--- name: memU-lite description: Lightweight structured memory system for OpenClaw - inspired by memU, zero external dependencies. Provides atomic memory storage with categories (preferences/knowledge/relationships/tasks/skills), tag-based indexing, and fast retrieval. read_when: - Need to remember user preferences across sessions - Building long-term context about users or projects - Implementing structured knowledge management - Creating persistent agent memory without external dependencies metadata: {"clawdbot":{"emoji":"🧠","tags":["memory","knowledge","organization"]}} allowed-tools: Bash(memu-lite:*) --- # memU-lite - 轻量级结构化记忆系统 > 灵感来自 memU，零外部依赖，纯 Markdown + OpenClaw 原生工具实现 ## 核心理念 memU-lite 将 Agent 记忆分为三层： ``` ┌─────────────────────────────────────────┐ │ Category Layer: MEMORY.md (概览索引) │ ├─────────────────────────────────────────┤ │ Item Layer: items/{category}/ (原子记忆) │ ├─────────────────────────────────────────┤ │ Resource Layer: raw/ (原始记录) │ └─────────────────────────────────────────┘ ``` ## 安装 ### 方式一：ClawHub (推荐) ```bash openclaw skills install memu-lite ``` ### 方式二：手动安装 ```bash git clone https://github.com/yoo-unison/memu-lite.git cp -r memu-lite/memory ~/.openclaw/workspace/ ``` ## 快速开始 ### 1. 初始化记忆结构 ```bash # 使用提供的初始化脚本 ./memu-lite/init.sh ``` 或手动创建： ```bash mkdir -p ~/.openclaw/workspace/memory/{raw,items/{preferences,knowledge,relationships,tasks,skills},indexes} ``` ### 2. 创建第一条记忆 在 `items/preferences/` 下创建文件： ```markdown ## P-20260302-001 用户决策风格偏好 - **类型**: preference - **来源**: 2026-03-02 对话 - **日期**: 2026-03-02 - **置信度**: high - **标签**: #偏好 #决策风格 - **内容**: 用户要求独立评估，不盲目跟风，偏好轻量方案。 - **关联**: [[R-20260302-001]] ``` ### 3. 更新 MEMORY.md 索引 编辑 `MEMORY.md` 添加记忆条目到索引表格。 ## 记忆类型 | 类型 | 目录 | 前缀 | 用途 | |------|------|------|------| | `preference` | `items/preferences/` | P | 用户偏好、习惯、风格 | | `knowledge` | `items/knowledge/` | K | 领域知识、事实信息 | | `relationship` | `items/relationships/` | R | 人际关系、组织上下文 | | `task` | `items/tasks/` | T | 待办事项、项目 | | `skill` | `items/skills/` | S | 技能、方法、流程 | ## 记忆 ID 规则 格式：`<类型字母>-<日期>-<序号>` 示例： - `P-20260302-001` (Preference, 2026-03-02, 第 1 条) - `K-20260302-002` (Knowledge, 2026-03-02, 第 2 条) ## 记忆文件格式 ```markdown ## [ID] 记忆标题 - **类型**: preference|knowledge|relationship|task|skill - **来源**: 对话/文档链接 - **日期**: YYYY-MM-DD - **置信度**: high|medium|low - **标签**: #标签 1 #标签 2 - **内容**: 详细描述... - **关联**: [[其他记忆 ID]] - **状态**: active|archived|completed (仅 task 类型需要) ``` ## 自动化工具（新增） memU-lite 提供了一套自动化工具脚本，位于 `tools/` 目录： ### memu-add.sh - 交互式创建记忆 ```bash ./tools/memu-add.sh ``` **功能：** - 交互式输入记忆内容 - 自动选择记忆类型 - 自动生成 ID - 自动更新 MEMORY.md 索引 **示例：** ``` 🧠 memU-lite - 添加新记忆 ========================== 选择记忆类型: 1) preference - 用户偏好、习惯 2) knowledge - 领域知识、事实 ... 请输入类型编号 (1-5): 1 记忆标题: 用户决策风格偏好 内容摘要: 要求独立评估，不盲目跟风 来源 (如: 对话/文档/链接): 2026-03-02 对话 标签 (用空格分隔，如: #偏好 #AI): #偏好 #决策风格 关联记忆 ID (可选): ✅ 记忆创建成功! ID: P-20260302-001 文件: items/preferences/P-20260302-001-用户决策风格偏好.md ``` ### memu-search.sh - 搜索记忆 ```bash # 按关键词搜索 ./tools/memu-search.sh 偏好 # 按标签搜索 ./tools/memu-search.sh -t "#AI" # 按 ID 搜索 ./tools/memu-search.sh -i P-20260302-001 # 列出所有记忆 ./tools/memu-search.sh -l ``` ### memu-backup.sh - 备份与恢复 ```bash # 创建备份 ./tools/memu-backup.sh # 列出所有备份 ./tools/memu-backup.sh -l # 恢复备份 ./tools/memu-backup.sh -r memory-20260302-143022.tar.gz # 清理 7 天前的备份 ./tools/memu-backup.sh -c 7 ``` ### memu-tags.sh - 标签索引生成 ```bash ./tools/memu-tags.sh ``` **功能：** - 自动扫描所有记忆文件的标签 - 生成标签统计报告 - 更新 `indexes/tags.md` ### memu-clean.sh - 过期清理 ```bash # 扫描过期记忆 ./tools/memu-clean.sh # 归档过期记忆（推荐） ./tools/memu-clean.sh -a # 查看已归档记忆 ./tools/memu-clean.sh -l ``` **过期机制：** 在记忆模板中添加 `过期日期` 字段： ```markdown - **过期日期**: 2026-03-31 ``` 到期后会被自动归档到 `archive/` 目录。 ## 核心工作流 ### 对话结束后自动记录 1. 提取关键信息（偏好/知识/任务等） 2. 创建原子记忆文件到对应 `items/<category>/` 3. 更新 `MEMORY.md` 索引 ### 检索记忆 ```bash # 快速概览 - 查看 MEMORY.md cat ~/.openclaw/workspace/memory/MEMORY.md # 语义搜索 - 使用 OpenClaw memory_search 工具 memory_search "用户偏好" # 精确读取 - 使用 OpenClaw memory_get 工具 memory_get --path ~/.openclaw/workspace/memory/items/preferences/P-20260302-001.md ``` ### 每日收尾 - 汇总当日记忆到 `MEMORY.md` 时间线 - 更新标签索引 `indexes/tags.md` ## 目录结构 ``` memory/ ├── MEMORY.md # 顶层索引 + 快速概览 ├── memu-lite-guide.md # 使用指南 ├── raw/ # 原始对话记录 │ └── YYYY-MM-DD.md ├── items/ # 原子化记忆单元 │ ├── TEMPLATE.md # 记忆模板 │ ├── preferences/ # 用户偏好 │ ├── knowledge/ # 领域知识 │ ├── relationships/ # 人际关系 │ ├── tasks/ # 待办事项 │ └── skills/ # 技能方法 └── indexes/ # 检索辅助 ├── tags.md # 标签索引 └── timeline.md # 时间线索引 ``` ## 最佳实践 ### 1. 原子化 每条记忆只包含一个独立事实： ✅ 好：`P-20260302-001 决策风格偏好` ❌ 差：`P-20260302-001 所有用户信息` ### 2. 及时更新 对话结束后立即记录，避免遗忘关键细节。 ### 3. 标签具体 使用具体标签便于后续检索： ✅ 好：`#项目 Alpha #技术栈 #后端` ❌ 差：`#知识 #信息` ### 4. 建立关联 相关记忆互相链接： ```markdown - **关联**: [[K-20260302-001]], [[S-20260302-001]] ``` ### 5. 定期维护 - 每周回顾：合并过期任务，更新状态 - 每月清理：归档旧记忆，提炼核心 ## 与原始 memU 对比 | 特性 | memU | memU-lite | |------|------|-----------| | 自动提取 | ✅ AI 自动 | ⚠️ 需 AI 主动记录 | | 主动预判 | ✅ 后台持续运行 | ❌ 被动响应 | | 向量检索 | ✅ 语义搜索 | ⚠️ 依赖 memory_search | | 外部依赖 | Postgres + API | ❌ 无 | | 部署复杂度 | 中 | 低 | | Token 优化 | 70%+ 压缩 | 依赖模型上下文 | ## 示例记忆 ### 用户偏好 (Preference) ```markdown ## P-20260302-001 用户决策风格偏好 - **类型**: preference - **来源**: 2026-03-02 对话 - **日期**: 2026-03-02 - **置信度**: high - **标签**: #偏好 #决策风格 #AI 使用 - **内容**: 1. 要求独立评估 - 不盲目接受外部建议 2. 借鉴思路而非照搬 - 适配自身情况 3. 偏好轻量方案 - 无外部依赖 4. 重视实用性 - 关注实际效果 - **关联**: [[R-20260302-001]] ``` ### 领域知识 (Knowledge) ```markdown ## K-20260302-001 编程语言偏好 - **类型**: knowledge - **来源**: 2026-03-02 对话 - **日期**: 2026-03-02 - **置信度**: high - **标签**: #技术 #编程语言 #偏好 - **内容**: 用户主要使用 Python 和 JavaScript 进行开发。 偏好简洁、可读性强的代码风格。 - **关联**: [[S-20260302-001]] ``` ### 技能方法 (Skill) ```markdown ## S-20260302-001 代码审查清单 - **类型**: skill - **来源**: 通用最佳实践 - **日期**: 2026-03-02 - **置信度**: high - **标签**: #技能 #代码审查 #开发流程 - **内容**: Step 1: 检查代码规范和风格 Step 2: 验证功能逻辑正确性 Step 3: 确认错误处理完善 Step 4: 检查性能优化点 Step 5: 确认测试覆盖关键路径 - **关联**: [[K-20260302-001]] ``` ## 迁移路径 如果未来需要升级到完整 memU： 1. `items/` 目录结构可直接映射到 memU Item Layer 2. `MEMORY.md` 可作为初始知识库导入 3. 记忆 ID 和标签系统保持一致 ## 脚本工具 ### init.sh - 初始化记忆结构 ```bash #!/bin/bash mkdir -p ~/.openclaw/workspace/memory/{raw,items/{preferences,knowledge,relationships,tasks,skills},indexes} echo "memU-lite 记忆结构已创建" ``` ### backup.sh - 备份记忆 ```bash #!/bin/bash DATE=$(date +%Y%m%d-%H%M%S) tar -czf ~/.openclaw/workspace/backups/memory-$DATE.tar.gz ~/.openclaw/workspace/memory/ echo "记忆备份完成：memory-$DATE.tar.gz" ``` ## 常见问题 ### Q: 记忆文件太多怎么办？ A: 定期归档旧记忆到 `archive/` 目录，保持 `items/` 精简。 ### Q: 如何搜索特定标签的记忆？ A: 使用 `grep -r "#标签" ~/.openclaw/workspace/memory/items/` ### Q: 可以和现有 memory-core 共存吗？ A: 可以。memU-lite 使用相同的 `memory_search`/`memory_get` 工具，只是文件结构更规范。 ## 许可证 Apache 2.0 ## 项目地址 GitHub: https://github.com/yoo-unison/memu-lite --- *Inspired by memU (https://github.com/NevaMind-AI/memU)*

path: PUSH_GUIDE.md
content: # GitHub 推送指南

## 本地状态

✅ 代码已提交到本地 Git 仓库
⚠️ 需要手动推送到 GitHub

## 推送步骤

### 方式一：命令行推送

```bash
cd ~/.openclaw/workspace/skills-pub/memu-lite

# 1. 确认当前状态
git status
git log --oneline -3

# 2. 推送到 GitHub
git push origin main
```

如果提示认证：
- **用户名**: yoo-unison
- **密码**: 使用 GitHub Personal Access Token

### 方式二：GitHub Desktop

1. 打开 GitHub Desktop
2. File → Add Local Repository → 选择 `~/.openclaw/workspace/skills-pub/memu-lite`
3. 点击 "Push origin"

### 方式三：浏览器上传（会丢失 Git 历史）

1. 打开 https://github.com/yoo-unison/memu-lite
2. 点击需要更新的文件
3. 点击编辑图标 ✏️
4. 手动更新内容
5. Commit changes

## 当前版本

- **ClawHub**: v1.0.3 ✅ 已发布
- **GitHub**: 需要推送到 main 分支

## 验证清单

推送后检查：
- [ ] GitHub 仓库显示最新提交
- [ ] SKILL.md 无"张程"等人名
- [ ] README.md 无"张程"等人名
- [ ] install.sh 使用通用示例
- [ ] memory/ 目录使用通用示例


path: README.md
content: # memU-lite

> 🧠 轻量级结构化记忆系统 for OpenClaw  
> 灵感来自 [memU](https://github.com/NevaMind-AI/memU)，零外部依赖

[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
[![OpenClaw](https://img.shields.io/badge/OpenClaw-Skill-green.svg)](https://github.com/openclaw/openclaw)

## ✨ 特性

- **三层架构** - Category Layer (概览) + Item Layer (原子记忆) + Resource Layer (原始记录)
- **五种类型** - preference/knowledge/relationship/task/skill
- **标签索引** - 快速检索和关联
- **零依赖** - 纯 Markdown + OpenClaw 原生 `memory_search`/`memory_get` 工具
- **易迁移** - 未来可无缝升级到完整 memU
- **自动化工具** - 提供 memu-add/memu-search/memu-backup/memu-tags/memu-clean 等工具（v1.1.0 新增）
- **过期机制** - 支持记忆自动归档（v1.1.0 新增）

## 📦 安装

### 方式一：ClawHub

```bash
openclaw skills install memu-lite
```

### 方式二：手动安装

```bash
git clone https://github.com/yoo-unison/memu-lite.git
cd memu-lite
./install.sh
```

## 🚀 快速开始

### 1. 初始化

```bash
# 创建记忆目录结构
mkdir -p ~/.openclaw/workspace/memory/{raw,items/{preferences,knowledge,relationships,tasks,skills},indexes}
```

### 2. 创建第一条记忆

在 `items/preferences/` 下创建文件 `P-20260302-001-xxx.md`：

```markdown
## P-20260302-001 用户决策风格偏好

- **类型**: preference
- **来源**: 2026-03-02 对话
- **日期**: 2026-03-02
- **置信度**: high
- **标签**: #偏好 #决策风格
- **内容**: 
  用户要求独立评估，不盲目跟风，偏好轻量方案。
- **关联**: [[R-20260302-001]]
```

### 3. 更新索引

编辑 `MEMORY.md` 添加记忆到索引表格。

## 📖 文档

- [使用指南](SKILL.md) - 完整的 API 和使用说明
- [记忆模板](memory/items/TEMPLATE.md) - 记忆文件格式参考

## 🗂️ 目录结构

```
memory/
├── MEMORY.md                 # 顶层索引 + 快速概览
├── raw/                      # 原始对话记录
├── items/                    # 原子化记忆单元
│   ├── preferences/          # 用户偏好
│   ├── knowledge/            # 领域知识
│   ├── relationships/        # 人际关系
│   ├── tasks/                # 待办事项
│   └── skills/               # 技能方法
└── indexes/                  # 检索辅助
    └── tags.md               # 标签索引
```

## 📊 与 memU 对比

| 特性 | memU | memU-lite |
|------|------|-----------|
| 自动提取 | ✅ | ⚠️ 需主动记录 |
| 主动预判 | ✅ | ❌ |
| 向量检索 | ✅ | ⚠️ 依赖 memory_search |
| 外部依赖 | Postgres + API | ❌ 无 |
| 部署复杂度 | 中 | 低 |

## 🎯 使用场景

- 记住用户偏好和习惯
- 构建项目知识库
- 长期上下文管理
- 多 Agent 记忆共享（通过共享 memory 目录）

## 🤝 贡献

欢迎提交 Issue 和 PR！

## 📄 许可证

Apache 2.0

## 🙏 致谢

灵感来自 [memU](https://github.com/NevaMind-AI/memU) - Memory as File System, File System as Memory


path: _meta.json
content: ownerId: kn72ce44tqw8bnnnewrn1s5x3s7yz7sq
slug: memu-lite
version: 1.0.0
name: memU-lite
description: Lightweight structured memory system for OpenClaw - inspired by memU, zero external dependencies

path: install.sh
content: #!/bin/bash
# memU-lite 安装脚本

set -e

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
WORKSPACE_DIR="$HOME/.openclaw/workspace"

echo "🧠 安装 memU-lite 记忆系统..."

# 检查是否已存在记忆系统
if [ -f "$WORKSPACE_DIR/memory/MEMORY.md" ]; then
    echo "⚠️  检测到已有记忆系统，跳过初始化"
    echo ""
    echo "如需查看示例文件，请检查:"
    echo "  $SCRIPT_DIR/memory/MEMORY.md"
    echo "  $SCRIPT_DIR/memory/TEMPLATE.md"
    echo ""
    echo "如需强制重新初始化，请先备份并删除:"
    echo "  rm -rf $WORKSPACE_DIR/memory/"
    echo "  然后重新运行此脚本"
    exit 0
fi

# 创建目录结构
echo "📁 创建记忆目录结构..."
mkdir -p "$WORKSPACE_DIR/memory/raw"
mkdir -p "$WORKSPACE_DIR/memory/items/preferences"
mkdir -p "$WORKSPACE_DIR/memory/items/knowledge"
mkdir -p "$WORKSPACE_DIR/memory/items/relationships"
mkdir -p "$WORKSPACE_DIR/memory/items/tasks"
mkdir -p "$WORKSPACE_DIR/memory/items/skills"
mkdir -p "$WORKSPACE_DIR/memory/indexes"
mkdir -p "$WORKSPACE_DIR/memory/archive"  # 新增归档目录

# 复制模板文件
echo "📄 复制模板文件..."
cp "$SCRIPT_DIR/memory/TEMPLATE.md" "$WORKSPACE_DIR/memory/items/TEMPLATE.md" 2>/dev/null || true
cp "$SCRIPT_DIR/memory/MEMORY.md" "$WORKSPACE_DIR/memory/MEMORY.md" 2>/dev/null || true
cp "$SCRIPT_DIR/memory/tags.md" "$WORKSPACE_DIR/memory/indexes/tags.md" 2>/dev/null || true

# 创建示例记忆
echo "📝 创建示例记忆..."

cat > "$WORKSPACE_DIR/memory/items/preferences/P-20260302-001-开发偏好.md" << 'EOF'
## P-20260302-001 开发偏好

- **类型**: preference
- **来源**: 示例记忆
- **日期**: 2026-03-02
- **置信度**: high
- **标签**: #偏好 #开发 #示例
- **内容**: 
  1. 偏好 Python 和 JavaScript
  2. 代码风格简洁、可读性强
  3. 重视测试和文档
  4. 喜欢使用开源工具
- **关联**: [[R-20260302-001]]
EOF

cat > "$WORKSPACE_DIR/memory/items/relationships/R-20260302-001-用户信息.md" << 'EOF'
## R-20260302-001 用户信息

- **类型**: relationship
- **来源**: 示例记忆
- **日期**: 2026-03-02
- **置信度**: high
- **标签**: #用户 #示例
- **内容**: 
  - 时区：Asia/Shanghai
  - 位置：中国大陆
  - 语言：简体中文
  - 角色：开发者
- **关联**: [[P-20260302-001]]
EOF

# 创建 MEMORY.md 索引
cat > "$WORKSPACE_DIR/memory/MEMORY.md" << 'EOF'
# MEMORY.md - 长期记忆

**最后更新**: 2026-03-02  
**记忆总数**: 2

---

## 📌 快速概览

### 用户偏好 (Preferences)
- 📝 开发偏好：Python/JavaScript，简洁代码风格

### 关键知识 (Knowledge)
_暂无记录_

### 人际关系 (Relationships)
- 👤 用户信息 - 开发者

### 进行中的事 (Active Tasks)
_暂无_

### 技能/方法 (Skills)
_暂无_

---

## 🗂️ 记忆索引

| ID | 类型 | 标题 | 日期 | 标签 |
|----|------|------|------|------|
| P-20260302-001 | preference | 开发偏好 | 2026-03-02 | #偏好 #开发 |
| R-20260302-001 | relationship | 用户信息 | 2026-03-02 | #用户 #示例 |

---

*此文件由 memU-lite 自动维护*
EOF

# 创建标签索引
cat > "$WORKSPACE_DIR/memory/indexes/tags.md" << 'EOF'
# 标签索引

## #偏好
- P-20260302-001 开发偏好

## #用户
- R-20260302-001 用户信息

EOF

echo "✅ memU-lite 安装完成!"
echo ""
echo "📂 记忆目录：$WORKSPACE_DIR/memory/"
echo "📖 使用指南：查看 SKILL.md 或 memory/memu-lite-guide.md"
echo ""
echo "下一步:"
echo "  1. 编辑 MEMORY.md 添加你的记忆"
echo "  2. 在 items/ 目录下创建原子记忆文件"
echo "  3. 使用 memory_search/memory_get 工具检索记忆"


path: memory/MEMORY.md
content: # MEMORY.md - 长期记忆

> 这是 curated memory（精修记忆），不是原始日志。
> 原始对话记录在 `raw/`，原子化记忆在 `items/`。

**最后更新**: 2026-03-02  
**记忆总数**: 0 (待初始化)

---

## 📌 快速概览

### 用户偏好 (Preferences)
<!-- 自动聚合自 items/preferences/ -->
_暂无记录_

### 关键知识 (Knowledge)
<!-- 自动聚合自 items/knowledge/ -->
_暂无记录_

### 人际关系 (Relationships)
<!-- 自动聚合自 items/relationships/ -->
_暂无记录_

### 进行中的事 (Active Tasks)
<!-- 自动聚合自 items/tasks/ -->
_暂无记录_

### 技能/方法 (Skills)
<!-- 自动聚合自 items/skills/ -->
_暂无记录_

---

## 🗂️ 记忆索引

| ID | 类型 | 标题 | 日期 | 标签 |
|----|------|------|------|------|
| - | - | - | - | - |

---

## 📅 时间线

### 2026-03
_本月暂无重要记忆_

---

## 🔖 标签云

_暂无标签_

---

## 📝 使用说明

### 添加新记忆
1. 在 `items/<category>/YYYY-MM-DD-<slug>.md` 创建原子记忆
2. 更新本文件的索引表格
3. 添加相关标签到标签云

### 检索策略
1. 先查本文件快速概览
2. 需要细节时 `memory_get` 具体文件
3. 模糊搜索用 `memory_search`

### 记忆维护
- 每周回顾：合并过期任务，更新状态
- 每月清理：归档旧记忆，提炼核心

---

*此文件由 memU-lite 自动维护*


path: memory/TEMPLATE.md
content: # 记忆模板

## 模板格式

```markdown
## [ID] 记忆标题

- **类型**: preference|knowledge|relationship|task|skill
- **来源**: 对话/文档链接
- **日期**: YYYY-MM-DD
- **置信度**: high|medium|low
- **标签**: #标签 1 #标签 2
- **内容**: 
  详细描述...

- **关联**: [[其他记忆 ID]]
- **状态**: active|archived|completed (仅 task 类型需要)
```

## 类型说明

| 类型 | 用途 | 示例 |
|------|------|------|
| `preference` | 用户偏好、习惯、风格 | "喜欢极简设计"、"早上 9 点前不发消息" |
| `knowledge` | 领域知识、事实信息 | "项目技术栈说明"、"API 文档链接" |
| `relationship` | 人际关系、组织上下文 | "某人是项目负责人"、"某公司是合作伙伴" |
| `task` | 待办事项、项目 | "优化 UI 设计"、"研究某股票" |
| `skill` | 技能、方法、流程 | "如何复盘"、"技术分析步骤" |

## ID 命名规则

`<类型首字母>-<日期>-<序号>`
- `P-20260302-001` (Preference)
- `K-20260302-001` (Knowledge)
- `R-20260302-001` (Relationship)
- `T-20260302-001` (Task)
- `S-20260302-001` (Skill)

## 最佳实践

1. **原子化** - 每条记忆只包含一个独立事实
2. **可检索** - 标签要具体，便于搜索
3. **可关联** - 相关记忆互相链接
4. **有时效** - 任务类记忆要更新状态


path: memory/tags.md
content: # 标签索引

> 自动聚合自所有记忆文件的标签

## 按类别

_暂无记录_

---

## 快速检索

| 标签 | 数量 | 最新 |
|------|------|------|
| - | - | - |


path: tools/memu-add.sh
content: #!/bin/bash
# memu-add.sh - 交互式创建记忆

WORKSPACE_DIR="$HOME/.openclaw/workspace"
MEMORY_DIR="$WORKSPACE_DIR/memory"

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# 检查记忆系统是否存在
if [ ! -d "$MEMORY_DIR" ]; then
    echo -e "${RED}❌ 错误：记忆系统未初始化${NC}"
    echo "请先运行安装脚本："
    echo "  cd ~/.openclaw/workspace/skills-pub/memu-lite"
    echo "  ./install.sh"
    exit 1
fi

# 显示菜单
echo -e "${BLUE}🧠 memU-lite - 添加新记忆${NC}"
echo "=========================="
echo ""

# 选择记忆类型
echo "选择记忆类型:"
echo "  1) preference  - 用户偏好、习惯"
echo "  2) knowledge   - 领域知识、事实"
echo "  3) relationship- 人际关系、上下文"
echo "  4) task        - 待办事项、项目"
echo "  5) skill       - 技能、方法、流程"
echo ""
read -p "请输入类型编号 (1-5): " type_num

case $type_num in
    1) TYPE="preference"; TYPE_PREFIX="P" ;;
    2) TYPE="knowledge"; TYPE_PREFIX="K" ;;
    3) TYPE="relationship"; TYPE_PREFIX="R" ;;
    4) TYPE="task"; TYPE_PREFIX="T" ;;
    5) TYPE="skill"; TYPE_PREFIX="S" ;;
    *) echo -e "${RED}❌ 无效选择${NC}"; exit 1 ;;
esac

echo ""
echo -e "已选择: ${GREEN}$TYPE${NC}"
echo ""

# 输入记忆标题
read -p "记忆标题: " TITLE
if [ -z "$TITLE" ]; then
    echo -e "${RED}❌ 标题不能为空${NC}"
    exit 1
fi

# 输入内容
read -p "内容摘要 (直接回车进入详细编辑): " CONTENT_SUMMARY

echo ""
echo "详细内容 (输入空行结束):"
echo "------------------------"
CONTENT=""
while IFS= read -r line; do
    [ -z "$line" ] && break
    CONTENT="$CONTENT$line\n"
done

# 输入来源
read -p "来源 (如: 对话/文档/链接): " SOURCE
SOURCE=${SOURCE:-"对话"}

# 输入标签
read -p "标签 (用空格分隔，如: #偏好 #AI): " TAGS

# 输入关联
read -p "关联记忆 ID (可选，如: K-20260302-001): " RELATIONS

# 如果是 task，询问过期日期
EXPIRY=""
if [ "$TYPE" = "task" ]; then
    echo ""
    read -p "过期日期 (YYYY-MM-DD，可选): " EXPIRY
fi

# 生成 ID
DATE=$(date +%Y%m%d)
COUNT=$(ls "$MEMORY_DIR/items/$TYPE"/ 2>/dev/null | grep "^$TYPE_PREFIX-$DATE" | wc -l)
COUNT=$((COUNT + 1))
ID="${TYPE_PREFIX}-${DATE}-$(printf "%03d" $COUNT)"

# 生成文件名
SLUG=$(echo "$TITLE" | tr ' ' '-' | tr -cd '[:alnum:]-' | tr '[:upper:]' '[:lower:]')
FILENAME="$MEMORY_DIR/items/$TYPE/${ID}-${SLUG}.md"

# 创建记忆文件
echo -e "\n${BLUE}📝 创建记忆文件...${NC}"

cat > "$FILENAME" << EOF
## $ID $TITLE

- **类型**: $TYPE
- **来源**: $SOURCE
- **日期**: $(date +%Y-%m-%d)
- **置信度**: high
- **标签**: $TAGS
EOF

if [ -n "$EXPIRY" ]; then
    echo "- **过期日期**: $EXPIRY" >> "$FILENAME"
fi

cat >> "$FILENAME" << EOF

- **内容**: 
  ${CONTENT_SUMMARY:-$CONTENT}

EOF

if [ -n "$RELATIONS" ]; then
    echo "- **关联**: [[$RELATIONS]]" >> "$FILENAME"
fi

echo "" >> "$FILENAME"

# 更新 MEMORY.md 索引
echo -e "${BLUE}🔄 更新 MEMORY.md 索引...${NC}"

# 在索引表格中添加新行
# 找到表格的最后一行，在后面添加
TABLE_LINE="| $ID | $TYPE | $TITLE | $(date +%Y-%m-%d) | $TAGS |"

# 使用 sed 在表格最后添加一行（在 "| - | - | - | - | - |" 之后）
sed -i "/^| - | - | - | - | - |$/a\\$TABLE_LINE" "$MEMORY_DIR/MEMORY.md"

# 更新时间线
MONTH=$(date +%Y-%m)
if grep -q "^### $MONTH" "$MEMORY_DIR/MEMORY.md"; then
    # 在现有月份下添加
    sed -i "/^### $MONTH/a\\- **$(date +%m-%d)**: 添加 $TYPE - $TITLE" "$MEMORY_DIR/MEMORY.md"
else
    # 创建新的月份
    sed -i "/^### 2026-03$/a\\
### $MONTH
_本月暂无重要记忆_" "$MEMORY_DIR/MEMORY.md"
fi

echo -e "${GREEN}✅ 记忆创建成功!${NC}"
echo ""
echo "文件: $FILENAME"
echo "ID: $ID"
echo ""
echo "提示:"
echo "  - 编辑文件: $FILENAME"
echo "  - 查看索引: $MEMORY_DIR/MEMORY.md"
echo "  - 搜索记忆: ./memu-search.sh $TAGS"


path: tools/memu-backup.sh
content: #!/bin/bash
# memu-backup.sh - 记忆备份工具

WORKSPACE_DIR="$HOME/.openclaw/workspace"
MEMORY_DIR="$WORKSPACE_DIR/memory"
BACKUP_DIR="$WORKSPACE_DIR/backups/memory"

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'

# 检查记忆系统是否存在
if [ ! -d "$MEMORY_DIR" ]; then
    echo -e "${RED}❌ 错误：记忆系统未初始化${NC}"
    exit 1
fi

# 显示帮助
if [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
    echo -e "${BLUE}💾 memU-lite - 备份工具${NC}"
    echo "======================="
    echo ""
    echo "用法:"
    echo "  ./memu-backup.sh           # 创建备份"
    echo "  ./memu-backup.sh -l        # 列出所有备份"
    echo "  ./memu-backup.sh -r <备份文件>  # 恢复备份"
    echo "  ./memu-backup.sh -c <天数>    # 清理旧备份"
    echo ""
    echo "示例:"
    echo "  ./memu-backup.sh                    # 立即备份"
    echo "  ./memu-backup.sh -l                 # 查看备份列表"
    echo "  ./memu-backup.sh -r memory-20260302-143022.tar.gz  # 恢复"
    echo "  ./memu-backup.sh -c 7               # 清理 7 天前的备份"
    exit 0
fi

# 创建备份
if [ $# -eq 0 ] || [ "$1" = "-b" ]; then
    echo -e "${BLUE}💾 创建记忆备份...${NC}"
    
    # 创建备份目录
    mkdir -p "$BACKUP_DIR"
    
    # 生成备份文件名
    TIMESTAMP=$(date +%Y%m%d-%H%M%S)
    BACKUP_FILE="memory-$TIMESTAMP.tar.gz"
    BACKUP_PATH="$BACKUP_DIR/$BACKUP_FILE"
    
    # 创建备份
    cd "$WORKSPACE_DIR"
    tar -czf "$BACKUP_PATH" -C "$WORKSPACE_DIR" memory/
    
    if [ $? -eq 0 ]; then
        SIZE=$(du -h "$BACKUP_PATH" | cut -f1)
        echo -e "${GREEN}✅ 备份成功!${NC}"
        echo "文件: $BACKUP_PATH"
        echo "大小: $SIZE"
        echo "时间: $(date)"
    else
        echo -e "${RED}❌ 备份失败${NC}"
        exit 1
    fi
    
    # 显示备份统计
    TOTAL=$(ls -1 "$BACKUP_DIR"/memory-*.tar.gz 2>/dev/null | wc -l)
    echo ""
    echo -e "${BLUE}📊 备份统计: 共 $TOTAL 个备份${NC}"
    
    # 显示最近5个备份
    if [ $TOTAL -gt 0 ]; then
        echo ""
        echo "最近 5 个备份:"
        ls -1t "$BACKUP_DIR"/memory-*.tar.gz 2>/dev/null | head -5 | while read -r f; do
            SIZE=$(du -h "$f" | cut -f1)
            DATE=$(stat -c %y "$f" 2>/dev/null | cut -d' ' -f1)
            echo "  • $(basename "$f") ($SIZE) - $DATE"
        done
    fi
fi

# 列出备份
if [ "$1" = "-l" ]; then
    echo -e "${BLUE}📋 备份列表${NC}"
    echo "==========="
    echo ""
    
    if [ ! -d "$BACKUP_DIR" ] || [ -z "$(ls -A "$BACKUP_DIR" 2>/dev/null)" ]; then
        echo -e "${YELLOW}⚠️  暂无备份${NC}"
        exit 0
    fi
    
    echo "备份文件                          大小      日期"
    echo "--------------------------------  --------  ----------"
    
    ls -1t "$BACKUP_DIR"/memory-*.tar.gz 2>/dev/null | while read -r f; do
        SIZE=$(du -h "$f" | cut -f1)
        DATE=$(stat -c %y "$f" 2>/dev/null | cut -d' ' -f1)
        printf "%-32s  %-8s  %s\n" "$(basename "$f")" "$SIZE" "$DATE"
    done
    
    TOTAL=$(ls -1 "$BACKUP_DIR"/memory-*.tar.gz 2>/dev/null | wc -l)
    echo ""
    echo -e "${GREEN}总计: $TOTAL 个备份${NC}"
    
    # 计算总大小
    TOTAL_SIZE=$(du -sh "$BACKUP_DIR" 2>/dev/null | cut -f1)
    echo "占用空间: $TOTAL_SIZE"
fi

# 恢复备份
if [ "$1" = "-r" ]; then
    if [ -z "$2" ]; then
        echo -e "${RED}❌ 错误：请指定备份文件${NC}"
        echo "用法: ./memu-backup.sh -r <备份文件>"
        exit 1
    fi
    
    BACKUP_FILE="$2"
    
    # 如果提供的是文件名，补全路径
    if [ ! -f "$BACKUP_FILE" ]; then
        BACKUP_FILE="$BACKUP_DIR/$2"
    fi
    
    if [ ! -f "$BACKUP_FILE" ]; then
        echo -e "${RED}❌ 错误：备份文件不存在${NC}"
        echo "文件: $BACKUP_FILE"
        exit 1
    fi
    
    echo -e "${YELLOW}⚠️  警告：恢复备份将覆盖当前记忆系统${NC}"
    echo "备份文件: $BACKUP_FILE"
    echo ""
    read -p "是否继续? (yes/no): " confirm
    
    if [ "$confirm" != "yes" ]; then
        echo -e "${YELLOW}已取消${NC}"
        exit 0
    fi
    
    # 先创建当前状态的备份
    echo ""
    echo -e "${BLUE}💾 正在备份当前状态...${NC}"
    TIMESTAMP=$(date +%Y%m%d-%H%M%S)
    AUTO_BACKUP="memory-auto-before-restore-$TIMESTAMP.tar.gz"
    cd "$WORKSPACE_DIR"
    tar -czf "$BACKUP_DIR/$AUTO_BACKUP" -C "$WORKSPACE_DIR" memory/
    echo -e "${GREEN}✅ 当前状态已备份: $AUTO_BACKUP${NC}"
    
    # 恢复备份
    echo ""
    echo -e "${BLUE}🔄 正在恢复备份...${NC}"
    cd "$WORKSPACE_DIR"
    rm -rf memory/
    tar -xzf "$BACKUP_FILE"
    
    if [ $? -eq 0 ]; then
        echo -e "${GREEN}✅ 恢复成功!${NC}"
    else
        echo -e "${RED}❌ 恢复失败${NC}"
        exit 1
    fi
fi

# 清理旧备份
if [ "$1" = "-c" ]; then
    if [ -z "$2" ]; then
        echo -e "${RED}❌ 错误：请指定天数${NC}"
        echo "用法: ./memu-backup.sh -c <天数>"
        echo "示例: ./memu-backup.sh -c 7  # 清理 7 天前的备份"
        exit 1
    fi
    
    DAYS=$2
    echo -e "${BLUE}🧹 清理 ${DAYS} 天前的备份...${NC}"
    
    if [ ! -d "$BACKUP_DIR" ]; then
        echo -e "${YELLOW}⚠️  备份目录不存在${NC}"
        exit 0
    fi
    
    # 查找并删除旧备份
    DELETED=0
    find "$BACKUP_DIR" -name "memory-*.tar.gz" -type f -mtime +$DAYS | while read -r f; do
        echo "删除: $(basename "$f")"
        rm "$f"
        DELETED=$((DELETED + 1))
    done
    
    echo ""
    echo -e "${GREEN}✅ 清理完成${NC}"
    
    # 显示剩余备份
    REMAINING=$(ls -1 "$BACKUP_DIR"/memory-*.tar.gz 2>/dev/null | wc -l)
    echo "剩余备份: $REMAINING 个"
fi


path: tools/memu-clean.sh
content: #!/bin/bash
# memu-clean.sh - 过期记忆清理工具

WORKSPACE_DIR="$HOME/.openclaw/workspace"
MEMORY_DIR="$WORKSPACE_DIR/memory"
ARCHIVE_DIR="$MEMORY_DIR/archive"

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m'

# 检查记忆系统是否存在
if [ ! -d "$MEMORY_DIR" ]; then
    echo -e "${RED}❌ 错误：记忆系统未初始化${NC}"
    exit 1
fi

# 显示帮助
if [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
    echo -e "${BLUE}🧹 memU-lite - 过期清理工具${NC}"
    echo "=========================="
    echo ""
    echo "用法:"
    echo "  ./memu-clean.sh           # 扫描过期记忆"
    echo "  ./memu-clean.sh -a        # 自动归档过期记忆"
    echo "  ./memu-clean.sh -f        # 强制删除过期记忆（谨慎）"
    echo "  ./memu-clean.sh -l        # 查看已归档记忆"
    echo ""
    echo "说明:"
    echo "  清理工具会检查带有'过期日期'的记忆，"
    echo "  将已过期的记忆归档到 archive/ 目录"
    exit 0
fi

MODE="scan"
if [ "$1" = "-a" ]; then
    MODE="archive"
elif [ "$1" = "-f" ]; then
    MODE="delete"
elif [ "$1" = "-l" ]; then
    MODE="list"
fi

TODAY=$(date +%Y-%m-%d)
EXPIRED_COUNT=0
EXPIRED_FILES=""

echo -e "${BLUE}🧹 扫描过期记忆...${NC}"
echo "=================="
echo ""
echo "今天: $TODAY"
echo ""

# 扫描所有记忆文件
find "$MEMORY_DIR/items/" -name "*.md" -type f | while read -r file; do
    # 检查是否有过期日期
    EXPIRY=$(grep "^\- \*\*过期日期\*\*:" "$file" 2>/dev/null | sed 's/.*: //')
    
    if [ -n "$EXPIRY" ]; then
        # 比较日期
        if [[ "$TODAY" > "$EXPIRY" ]] || [ "$TODAY" = "$EXPIRY" ]; then
            TITLE=$(grep "^## " "$file" 2>/dev/null | head -1 | sed 's/## //')
            TYPE=$(grep "^\- \*\*类型\*\*:" "$file" 2>/dev/null | sed 's/.*: //')
            
            echo -e "${YELLOW}⚠️  过期记忆:${NC}"
            echo "  标题: $TITLE"
            echo "  类型: $TYPE"
            echo "  过期: $EXPIRY"
            echo "  文件: $file"
            echo ""
            
            EXPIRED_COUNT=$((EXPIRED_COUNT + 1))
            EXPIRED_FILES="$EXPIRED_FILES\n$file"
        fi
    fi
done

# 处理扫描结果
if [ $EXPIRED_COUNT -eq 0 ]; then
    echo -e "${GREEN}✅ 没有发现过期记忆${NC}"
    exit 0
fi

echo ""
echo -e "${YELLOW}发现 $EXPIRED_COUNT 条过期记忆${NC}"
echo ""

case $MODE in
    scan)
        echo "扫描完成。如需归档，请运行:"
        echo "  ./memu-clean.sh -a"
        echo ""
        echo "如需强制删除，请运行:"
        echo "  ./memu-clean.sh -f"
        ;;
    
    archive)
        echo -e "${BLUE}📦 归档过期记忆...${NC}"
        echo ""
        
        # 创建归档目录
        mkdir -p "$ARCHIVE_DIR"
        
        # 归档文件
        echo -e "$EXPIRED_FILES" | while read -r file; do
            [ -z "$file" ] && continue
            
            BASENAME=$(basename "$file")
            TYPE=$(echo "$file" | grep -o "items/[^/]*" | cut -d/ -f2)
            
            # 创建类型子目录
            mkdir -p "$ARCHIVE_DIR/$TYPE"
            
            # 移动文件
            mv "$file" "$ARCHIVE_DIR/$TYPE/"
            
            echo -e "${GREEN}✓ 已归档:${NC} $BASENAME → archive/$TYPE/"
        done
        
        echo ""
        echo -e "${GREEN}✅ 归档完成${NC}"
        echo "归档目录: $ARCHIVE_DIR"
        ;;
    
    delete)
        echo -e "${RED}⚠️  警告：即将永久删除过期记忆${NC}"
        echo ""
        read -p "确认删除? (输入 'delete' 确认): " confirm
        
        if [ "$confirm" != "delete" ]; then
            echo -e "${YELLOW}已取消${NC}"
            exit 0
        fi
        
        echo ""
        echo -e "${RED}🗑️  删除过期记忆...${NC}"
        echo ""
        
        echo -e "$EXPIRED_FILES" | while read -r file; do
            [ -z "$file" ] && continue
            
            BASENAME=$(basename "$file")
            rm "$file"
            
            echo -e "${RED}✓ 已删除:${NC} $BASENAME"
        done
        
        echo ""
        echo -e "${GREEN}✅ 删除完成${NC}"
        ;;
    
    list)
        echo -e "${BLUE}📦 已归档记忆列表${NC}"
        echo ""
        
        if [ ! -d "$ARCHIVE_DIR" ] || [ -z "$(ls -A "$ARCHIVE_DIR" 2>/dev/null)" ]; then
            echo -e "${YELLOW}暂无归档记忆${NC}"
            exit 0
        fi
        
        # 遍历归档目录
        find "$ARCHIVE_DIR" -name "*.md" -type f | while read -r file; do
            TITLE=$(grep "^## " "$file" 2>/dev/null | head -1 | sed 's/## //')
            EXPIRY=$(grep "^\- \*\*过期日期\*\*:" "$file" 2>/dev/null | sed 's/.*: //')
            
            echo "• $TITLE"
            echo "  过期: $EXPIRY"
            echo "  位置: ${file#$MEMORY_DIR/}"
            echo ""
        done
        
        TOTAL=$(find "$ARCHIVE_DIR" -name "*.md" -type f | wc -l)
        echo -e "${GREEN}总计: $TOTAL 条归档记忆${NC}"
        ;;
esac


path: tools/memu-search.sh
content: #!/bin/bash
# memu-search.sh - 记忆搜索工具

WORKSPACE_DIR="$HOME/.openclaw/workspace"
MEMORY_DIR="$WORKSPACE_DIR/memory"

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m'

# 检查参数
if [ $# -eq 0 ]; then
    echo -e "${BLUE}🔍 memU-lite - 记忆搜索${NC}"
    echo "========================"
    echo ""
    echo "用法:"
    echo "  ./memu-search.sh <关键词>"
    echo "  ./memu-search.sh -t <标签>     # 按标签搜索"
    echo "  ./memu-search.sh -i <ID>       # 按 ID 搜索"
    echo "  ./memu-search.sh -l             # 列出所有记忆"
    echo ""
    echo "示例:"
    echo "  ./memu-search.sh 偏好"
    echo "  ./memu-search.sh -t '#AI'"
    echo "  ./memu-search.sh -i P-20260302-001"
    exit 0
fi

# 检查记忆系统是否存在
if [ ! -d "$MEMORY_DIR" ]; then
    echo -e "${RED}❌ 错误：记忆系统未初始化${NC}"
    exit 1
fi

MODE="content"
QUERY="$1"

# 解析选项
while getopts "t:i:lh" opt; do
    case $opt in
        t) MODE="tag"; QUERY="$OPTARG" ;;
        i) MODE="id"; QUERY="$OPTARG" ;;
        l) MODE="list" ;;
        h)
            echo "用法: ./memu-search.sh [选项] <查询>"
            echo "  -t <标签>   按标签搜索"
            echo "  -i <ID>     按 ID 搜索"
            echo "  -l          列出所有记忆"
            echo "  -h          显示帮助"
            exit 0
            ;;
        *) exit 1 ;;
    esac
done

echo -e "${BLUE}🔍 搜索记忆...${NC}"
echo "=================="
echo ""

case $MODE in
    content)
        echo -e "关键词: ${CYAN}$QUERY${NC}"
        echo ""
        
        # 在 items 目录下搜索
        RESULTS=$(grep -rni "$QUERY" "$MEMORY_DIR/items/" --include="*.md" 2>/dev/null)
        
        if [ -z "$RESULTS" ]; then
            echo -e "${YELLOW}⚠️  未找到匹配的记忆${NC}"
            exit 0
        fi
        
        # 显示结果
        echo "$RESULTS" | while read -r line; do
            FILE=$(echo "$line" | cut -d: -f1)
            LINENO=$(echo "$line" | cut -d: -f2)
            CONTENT=$(echo "$line" | cut -d: -f3-)
            
            # 提取文件名和标题
            BASENAME=$(basename "$FILE")
            TITLE=$(grep "^## " "$FILE" 2>/dev/null | head -1 | sed 's/## //')
            
            echo -e "${GREEN}📄 $TITLE${NC}"
            echo -e "   ${CYAN}$CONTENT${NC}"
            echo -e "   ${YELLOW}行 $LINENO: $FILE${NC}"
            echo ""
        done
        
        COUNT=$(echo "$RESULTS" | wc -l)
        echo -e "${GREEN}✅ 找到 $COUNT 条匹配结果${NC}"
        ;;
    
    tag)
        echo -e "标签: ${CYAN}$QUERY${NC}"
        echo ""
        
        # 搜索包含该标签的文件
        RESULTS=$(grep -rl "\*\*标签\*\*:.*$QUERY" "$MEMORY_DIR/items/" --include="*.md" 2>/dev/null)
        
        if [ -z "$RESULTS" ]; then
            echo -e "${YELLOW}⚠️  未找到带有标签 $QUERY 的记忆${NC}"
            exit 0
        fi
        
        # 显示结果
        echo "$RESULTS" | while read -r file; do
            TITLE=$(grep "^## " "$file" 2>/dev/null | head -1 | sed 's/## //')
            TYPE=$(grep "^\- \*\*类型\*\*:" "$file" 2>/dev/null | sed 's/.*: //')
            DATE=$(grep "^\- \*\*日期\*\*:" "$file" 2>/dev/null | sed 's/.*: //')
            TAGS=$(grep "^\- \*\*标签\*\*:" "$file" 2>/dev/null | sed 's/.*: //')
            
            echo -e "${GREEN}📄 $TITLE${NC}"
            echo -e "   类型: $TYPE | 日期: $DATE"
            echo -e "   标签: ${CYAN}$TAGS${NC}"
            echo ""
        done
        
        COUNT=$(echo "$RESULTS" | wc -l)
        echo -e "${GREEN}✅ 找到 $COUNT 条记忆${NC}"
        ;;
    
    id)
        echo -e "ID: ${CYAN}$QUERY${NC}"
        echo ""
        
        # 查找文件
        FILE=$(find "$MEMORY_DIR/items/" -name "*$QUERY*" -type f 2>/dev/null | head -1)
        
        if [ -z "$FILE" ]; then
            echo -e "${YELLOW}⚠️  未找到 ID 为 $QUERY 的记忆${NC}"
            exit 0
        fi
        
        # 显示完整内容
        echo -e "${GREEN}📄 完整记忆内容:${NC}"
        echo ""
        cat "$FILE"
        echo ""
        echo -e "${YELLOW}文件: $FILE${NC}"
        ;;
    
    list)
        echo "所有记忆列表:"
        echo ""
        
        # 遍历所有类型
        for type_dir in "$MEMORY_DIR/items/"*/; do
            if [ -d "$type_dir" ]; then
                TYPE=$(basename "$type_dir")
                COUNT=$(ls -1 "$type_dir"/*.md 2>/dev/null | wc -l)
                
                if [ $COUNT -gt 0 ]; then
                    echo -e "${CYAN}[$TYPE]${NC} ($COUNT 条)"
                    
                    for file in "$type_dir"/*.md; do
                        if [ -f "$file" ]; then
                            TITLE=$(grep "^## " "$file" 2>/dev/null | head -1 | sed 's/## //')
                            echo "  • $TITLE"
                        fi
                    done
                    echo ""
                fi
            fi
        done
        
        TOTAL=$(find "$MEMORY_DIR/items/" -name "*.md" 2>/dev/null | wc -l)
        echo -e "${GREEN}✅ 总计: $TOTAL 条记忆${NC}"
        ;;
esac


path: tools/memu-tags.sh
content: #!/bin/bash
# memu-tags.sh - 标签索引生成工具

WORKSPACE_DIR="$HOME/.openclaw/workspace"
MEMORY_DIR="$WORKSPACE_DIR/memory"
INDEXES_DIR="$MEMORY_DIR/indexes"

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m'

# 检查记忆系统是否存在
if [ ! -d "$MEMORY_DIR" ]; then
    echo -e "${RED}❌ 错误：记忆系统未初始化${NC}"
    exit 1
fi

echo -e "${BLUE}🏷️  memU-lite - 标签索引生成${NC}"
echo "=========================="
echo ""

# 创建索引目录
mkdir -p "$INDEXES_DIR"

# 生成标签统计
echo -e "${BLUE}📊 扫描记忆文件...${NC}"

# 临时文件
TEMP_TAGS=$(mktemp)

# 提取所有标签
find "$MEMORY_DIR/items/" -name "*.md" -type f | while read -r file; do
    TAGS=$(grep "^\- \*\*标签\*\*:" "$file" 2>/dev/null | sed 's/.*: //')
    if [ -n "$TAGS" ]; then
        # 将标签拆分为行
        for tag in $TAGS; do
            echo "$tag" >> "$TEMP_TAGS"
        done
    fi
done

# 统计标签频率
echo -e "${BLUE}📈 生成标签统计...${NC}"
echo ""

if [ ! -s "$TEMP_TAGS" ]; then
    echo -e "${YELLOW}⚠️  暂无标签数据${NC}"
    rm "$TEMP_TAGS"
    exit 0
fi

# 排序并统计
echo "标签统计:"
echo "---------"
sort "$TEMP_TAGS" | uniq -c | sort -rn | while read -r count tag; do
    printf "  ${CYAN}%-20s${NC} %4s 次\n" "$tag" "$count"
done

echo ""

# 生成索引文件
echo -e "${BLUE}📝 生成标签索引...${NC}"

INDEX_FILE="$INDEXES_DIR/tags.md"

cat > "$INDEX_FILE" << EOF
# 标签索引

> 自动生成于 $(date "+%Y-%m-%d %H:%M:%S")

## 标签统计

| 标签 | 数量 | 相关记忆 |
|------|------|----------|
EOF

# 生成表格内容
sort "$TEMP_TAGS" | uniq -c | sort -rn | while read -r count tag; do
    # 查找包含该标签的记忆
    MEMORIES=$(grep -rl "\*\*标签\*\*:.*$tag" "$MEMORY_DIR/items/" --include="*.md" 2>/dev/null | head -5)
    
    MEM_LIST=""
    for mem in $MEMORIES; do
        TITLE=$(grep "^## " "$mem" 2>/dev/null | head -1 | sed 's/## //')
        MEM_LIST="$MEM_LIST$TITLE; "
    done
    
    # 截断太长的列表
    if [ ${#MEM_LIST} -gt 50 ]; then
        MEM_LIST="${MEM_LIST:0:47}..."
    fi
    
    echo "| $tag | $count | $MEM_LIST |" >> "$INDEX_FILE"
done

cat >> "$INDEX_FILE" << EOF

## 快速检索

使用搜索工具按标签查找:
\`\`\`bash
./tools/memu-search.sh -t "#标签名"
\`\`\`

## 标签云

EOF

# 生成标签云（按频率排序）
echo "" >> "$INDEX_FILE"
sort "$TEMP_TAGS" | uniq -c | sort -rn | head -20 | while read -r count tag; do
    # 根据频率决定显示大小
    if [ $count -ge 10 ]; then
        echo -n "**$tag** " >> "$INDEX_FILE"
    elif [ $count -ge 5 ]; then
        echo -n "*$tag* " >> "$INDEX_FILE"
    else
        echo -n "$tag " >> "$INDEX_FILE"
    fi
done
echo "" >> "$INDEX_FILE"

# 清理临时文件
rm "$TEMP_TAGS"

echo -e "${GREEN}✅ 标签索引已更新!${NC}"
echo "文件: $INDEX_FILE"
echo ""

# 显示统计
TOTAL_TAGS=$(grep "^| #" "$INDEX_FILE" 2>/dev/null | wc -l)
echo "统计:"
echo "  标签总数: $TOTAL_TAGS"
echo "  索引文件: $INDEX_FILE"


Security scan verdicts — ClawScan: suspicious | static analysis: clean | VirusTotal: clean | SkillSpector: suspicious (HIGH)