memorylake-openclaw 0.0.5-beta.1 → 0.0.5-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorylake-openclaw",
-  "version": "0.0.5-beta.1",
+  "version": "0.0.5-beta.2",
   "type": "module",
   "description": "MemoryLake memory backend for OpenClaw",
   "license": "MIT",

package/.claude/settings.local.json

@@ -1,22 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "WebFetch(domain:10.71.10.71)",
-      "Bash(find /Users/henry/work/github/memorylake-openclaw -maxdepth 2 \\\\\\( -name \".env*\" -o -name \"*.config.*\" -o -name \"openclaw.json\" \\\\\\) 2>/dev/null | grep -v node_modules)",
-      "Bash(jq '.env' /Users/henry/.openclaw/openclaw.json)",
-      "Bash(wc -l /Users/henry/.openclaw/agents/main/sessions/*.jsonl)",
-      "Bash(curl -s http://10.71.10.71:8001/v3/api-docs/open-api 2>&1 | head -5000)",
-      "Bash(cat /Users/henry/.claude/projects/-Users-henry-work-github-memorylake-openclaw/667ef3f7-2edf-4030-b7cf-239a4d916489/tool-results/bf9jm64sc.txt | python3 -c \"\nimport json, sys\ndata = json.load\\(sys.stdin\\)\n# Extract the memories endpoint\npaths = data.get\\('paths', {}\\)\nfor path, methods in paths.items\\(\\):\n    if 'memories' in path:\n        print\\(f'\\\\\\\\n=== {path} ==='\\)\n        for method, spec in methods.items\\(\\):\n            print\\(f'\\\\\\\\n--- {method.upper\\(\\)} ---'\\)\n            print\\(json.dumps\\(spec, indent=2\\)\\)\n\n# Also print relevant schemas\nschemas = data.get\\('components', {}\\).get\\('schemas', {}\\)\nfor name, schema in schemas.items\\(\\):\n    if 'memory' in name.lower\\(\\) or 'Memory' in name or 'Message' in name:\n        print\\(f'\\\\\\\\n=== Schema: {name} ==='\\)\n        print\\(json.dumps\\(schema, indent=2\\)\\)\n\")",
-      "Bash(cat /Users/henry/.openclaw/openclaw.json | python3 -c \"\nimport json, sys\ndata = json.load\\(sys.stdin\\)\n# Look for plugin-related config\nfor key in data:\n    if 'plugin' in key.lower\\(\\) or 'memory' in key.lower\\(\\) or 'memorylake' in key.lower\\(\\) or 'extension' in key.lower\\(\\):\n        print\\(f'=== {key} ==='\\)\n        print\\(json.dumps\\(data[key], indent=2\\)[:3000]\\)\n# Also print top-level keys\nprint\\('\\\\\\\\n=== Top-level keys ==='\\)\nprint\\(list\\(data.keys\\(\\)\\)\\)\n\")",
-      "Bash(cat /Users/henry/.openclaw/agents/main/sessions/sessions.json | python3 -c \"\nimport json, sys\ndata = json.load\\(sys.stdin\\)\nfor key, val in data.items\\(\\):\n    print\\(f'Key: {key}'\\)\n    print\\(f'  sessionId: {val.get\\(\\\\\"sessionId\\\\\"\\)}'\\)\n    print\\(f'  chatType: {val.get\\(\\\\\"chatType\\\\\"\\)}'\\)\n    print\\(f'  channel: {val.get\\(\\\\\"channel\\\\\"\\)}'\\)\n    print\\(f'  displayName: {val.get\\(\\\\\"displayName\\\\\"\\)}'\\)\n    print\\(f'  subject: {val.get\\(\\\\\"subject\\\\\"\\)}'\\)\n    print\\(f'  sessionFile: {val.get\\(\\\\\"sessionFile\\\\\"\\)}'\\)\n    print\\(\\)\n\")",
-      "Bash(head -20 /Users/henry/.openclaw/agents/main/sessions/8cc2bff3-a3af-4725-b071-43caffb36771.jsonl | python3 -c \"\nimport json, sys\nfor line in sys.stdin:\n    line = line.strip\\(\\)\n    if not line:\n        continue\n    obj = json.loads\\(line\\)\n    t = obj.get\\('type'\\)\n    if t == 'message':\n        msg = obj.get\\('message', {}\\)\n        role = msg.get\\('role'\\)\n        content = msg.get\\('content', []\\)\n        # Truncate content for display\n        content_str = str\\(content\\)[:200]\n        print\\(f'Type: {t}, Role: {role}, Content: {content_str}...'\\)\n    else:\n        print\\(f'Type: {t}, Keys: {list\\(obj.keys\\(\\)\\)}'\\)\n\")",
-      "Bash(ls ~/.openclaw/agents/main/sessions/*.jsonl 2>/dev/null | head -3)",
-      "Bash(cat ~/.openclaw/agents/main/sessions/sessions.json 2>/dev/null | python3 -c \"import json,sys; d=json.load\\(sys.stdin\\); print\\(json.dumps\\(dict\\(list\\(d.items\\(\\)\\)[:2]\\), indent=2\\)\\)\" 2>/dev/null || echo \"No sessions.json or parse error\")",
-      "Bash(head -5 ~/.openclaw/agents/main/sessions/372112f5-ea26-4440-995f-aa756c707858.jsonl 2>/dev/null | python3 -c \"\nimport json, sys\nfor line in sys.stdin:\n    line = line.strip\\(\\)\n    if not line: continue\n    d = json.loads\\(line\\)\n    print\\(json.dumps\\({k: d[k] for k in list\\(d.keys\\(\\)\\)[:3]}, indent=2, ensure_ascii=False\\)\\)\n    if d.get\\('type'\\) == 'message':\n        msg = d.get\\('message', {}\\)\n        role = msg.get\\('role'\\)\n        content = msg.get\\('content'\\)\n        if isinstance\\(content, list\\):\n            types = [c.get\\('type'\\) for c in content]\n            print\\(f'  role={role}, content_types={types}'\\)\n        else:\n            print\\(f'  role={role}, content type={type\\(content\\).__name__}'\\)\n\")",
-      "Bash(python3 -c \"\nimport json\nwith open\\('/Users/henry/.openclaw/agents/main/sessions/372112f5-ea26-4440-995f-aa756c707858.jsonl'\\) as f:\n    for line in f:\n        line = line.strip\\(\\)\n        if not line: continue\n        d = json.loads\\(line\\)\n        if d.get\\('type'\\) != 'message': continue\n        msg = d.get\\('message', {}\\)\n        role = msg.get\\('role'\\)\n        content = msg.get\\('content'\\)\n        if isinstance\\(content, list\\):\n            types = [c.get\\('type'\\) for c in content]\n            print\\(f'role={role}, content_types={types}'\\)\n        elif isinstance\\(content, str\\):\n            print\\(f'role={role}, content=str[{len\\(content\\)}]'\\)\n        else:\n            print\\(f'role={role}, content={type\\(content\\).__name__}'\\)\n\" | head -20)",
-      "Bash(python3 << 'PYEOF'\nimport json\nwith open\\(\"/Users/henry/.openclaw/agents/main/sessions/372112f5-ea26-4440-995f-aa756c707858.jsonl\"\\) as f:\n    for line in f:\n        line = line.strip\\(\\)\n        if not line:\n            continue\n        d = json.loads\\(line\\)\n        if d.get\\(\"type\"\\) != \"message\":\n            continue\n        msg = d.get\\(\"message\", {}\\)\n        role = msg.get\\(\"role\"\\)\n        content = msg.get\\(\"content\"\\)\n        if isinstance\\(content, list\\):\n            types = [c.get\\(\"type\"\\) for c in content]\n            print\\(f\"role={role}, content_types={types}\"\\)\n        elif isinstance\\(content, str\\):\n            print\\(f\"role={role}, content=str[{len\\(content\\)}]\"\\)\n        else:\n            print\\(f\"role={role}, content={type\\(content\\).__name__}\"\\)\nPYEOF)",
-      "Bash(python3 << 'PYEOF'\nimport json\nwith open\\(\"/Users/henry/.openclaw/openclaw.json\"\\) as f:\n    config = json.load\\(f\\)\n# Show agents structure\nagents = config.get\\(\"agents\", {}\\)\nprint\\(json.dumps\\({\n    \"defaults\": agents.get\\(\"defaults\", {}\\),\n    \"list_keys\": [list\\(a.keys\\(\\)\\) for a in agents.get\\(\"list\", []\\)][:3],\n    \"list_sample\": agents.get\\(\"list\", []\\)[:2]\n}, indent=2, default=str\\)\\)\nPYEOF)",
-      "Bash(chmod +x /Users/henry/work/github/memorylake-openclaw/skills/migrate-memories-to-memorylake/migrate.mjs)"
-    ]
-  }
-}

package/.cursor/pr-review-2.md

@@ -1,79 +0,0 @@
-## PR #2 Review：Add advanced web search tool with plugin-level constraints
-
-> 之前那条简短英文评论格式不太好，这条为主，请以本评论为准。
-
-### 总体评价
-- **整体设计合理**：`advanced_web_search` 作为可选工具（`optional: true`），需要在 OpenClaw 侧显式允许，和现有工具体系一致。
-- **配置与文档同步到位**：新增的 `webSearch*` 配置在 README、OpenClaw 文档以及 `openclaw.plugin.json` 里都有说明，label/placeholder/help 也比较清晰。
-- **错误处理风格统一**：工具实现中的 try/catch、返回 `content` + `details` 的方式，与现有 `document_search` 等工具保持一致。
-
-### 需要在合并前确认/修复的点（Blocking）
-1. **Web Search API 路径**
-
-   ```ts
-   this.webSearchPath = "api/v1/search";  //TODO: update to the new web search API `openapi/memorylake/api/v1/search`
-   ```
-
-   - 目前这里用的是 `api/v1/search`，但其它路径（memories/doc search）都是走 `openapi/memorylake/...`。
-   - TODO 里也写了目标路径可能是 `openapi/memorylake/api/v1/search`。
-   - **建议**：跟后端或 API 文档确认最终路径，二选一：
-     - 若最终是 `openapi/memorylake/api/v1/search`，这里改成该路径并删除 TODO；
-     - 若确实是 `api/v1/search`，则保留该值、删掉 TODO，并补一行注释说明这是 web search 的独立 endpoint。
-
-2. **统一搜索 API 的响应结构**
-
-   - 目前 `searchWeb` 是：
-
-     ```ts
-     const resp = await this.http
-       .post(this.webSearchPath, { json: body })
-       .json<WebSearchResponse>();
-     return normalizeWebSearchResponse(resp);
-     ```
-
-   - 但其它接口（memories/doc search）是走统一 `ApiResponse` 包装：先检查 `success`，再从 `data` 里取结果。
-   - 如果 unified web search API 实际返回的是 `{ success, data: { results, total_results } }` 这一套，那么这里会少了解包，`normalizeWebSearchResponse` 的入参就不对齐。
-   - **建议**：确认该接口真实响应：
-     - 若也是 `ApiResponse` 风格，就改成先解析 `ApiResponse`（含 `success` 判断），再对 `data` 做 `normalizeWebSearchResponse`，与其它接口保持一致；
-     - 若这个接口是裸的 `WebSearchResponse`（没有 `success/data` 包装），当前写法就 OK，可以在注释里说明这是一个特例。
-
-### 非阻塞的改进建议（Nice to have）
-1. **空数组语义**
-
-   - 现在发送请求前的判断是：
-
-     ```ts
-     if (options.include_domains?.length) body.include_domains = options.include_domains;
-     if (options.exclude_domains?.length) body.exclude_domains = options.exclude_domains;
-     ```
-
-   - 这意味着：当配置为 `[]` 时字段不会发送，仅当长度 > 0 才会发。
-   - 如果产品上不需要区分：“未配置” vs “显式设为空数组”，当前实现是合理的；
-   - 如果未来希望支持“显式禁用所有域名”之类的语义，可能需要改成 `options.include_domains !== undefined` 决定是否传字段。
-
-2. **normalizeWebSearchResponse 的稳健性**
-
-   - 当前只对顶层 `results`/`total_results` 做了类型兜底：
-
-     ```ts
-     return {
-       results: Array.isArray(raw?.results) ? raw.results : [],
-       total_results: typeof raw?.total_results === "number" ? raw.total_results : 0,
-     };
-     ```
-
-   - 如果后端在单条 result 的字段上（`url`/`title` 等）有可能返回 `null` 或非字符串，将来可以考虑在这里顺便做一层浅 normalize，减少下游使用时的防御性代码。不是必须，看 API 稳定性。
-
-3. **配置解析的测试**
-
-   - 新增的 `parseOptionalStringArray` / `parseOptionalString` 实现本身比较简单，但关系到配置体验。
-   - 如果项目中已有 config 相关的测试套件，可以考虑加一小组用例（合法/非法类型，`null`、`[]` 等），防止以后改动时出现回归。
-
-### 结论
-
-- **总体 LGTM**：设计、类型、文档和插件配置都比较完整。
-- 真正阻塞合并的主要是：
-  - 确认并固定 `webSearchPath` 路径；
-  - 确认统一搜索 API 的响应是否包在 `ApiResponse` 里，并根据结果决定是否需要像其它接口那样做一层解包。
-- 这两个点确认/修完之后，就可以放心合并了。
-

package/.cursor/skills/gh-pr-description-gen/SKILL.md

@@ -1,83 +0,0 @@
----
-name: gh-pr-description-gen
-description: Use when creating a GitHub PR with gh CLI and needing to generate title and description from git diff and optional issue context
----
-
-# gh PR Create with Generated Description
-
-## Overview
-
-Create a GitHub pull request using `gh pr create`, with title and body generated by the agent from the git diff. No external model calls—the agent generates the content directly.
-
-## When to Use
-
-- User wants to create a PR with `gh` and needs title/description written
-- User has uncommitted or committed changes and wants a PR created
-- User may reference related issues (e.g. "fixes #123") to include in context
-
-## Core Workflow
-
-1. **Gather context**
-   - Current branch: `git branch --show-current`
-   - Base branch: `git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's#.*/##'` or fallback to `main`/`master`
-   - Git diff: `git diff origin/{base}...HEAD` (or `git diff origin/{base}` if no merge base)
-   - Truncate diff to ~15000 chars if large
-   - Optional: if user provides issue numbers, run `gh issue view {number}` for each to get title and description
-
-2. **Generate title and body**
-   - Use the diff (and optionally issue context) to write a clear title and description
-   - Title: concise, descriptive, no "to #X:" prefix
-   - Body format:
-
-```
-### Motivation
-
-(Describe the motivation of this PR)
-
-### Modifications
-
-* (Modification 1)
-* (Modification 2)
-* ...
-```
-
-   - Use fluent, simple-yet-elegant English
-   - Keep meanings clear, sentences short, lines under ~150 characters
-   - If related to issues, add "Fixes #123" or "Closes #123" in body to auto-link
-
-3. **Create PR**
-   - `gh pr create --title "..." --body "..."` (or `--body-file -` with stdin)
-   - Add `--base` if base branch differs from default
-   - Add `--draft` if user wants a draft PR
-
-## Quick Reference
-
-| Step | Command |
-|------|---------|
-| Current branch | `git branch --show-current` |
-| Default base | `git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null \| sed 's#.*/##'` or `main` |
-| Diff | `git diff origin/{base}...HEAD` |
-| Issue view | `gh issue view {number} --json title,body` |
-| Create PR | `gh pr create -t "Title" -b "Body"` |
-
-## Body Template
-
-Use this structure when generating the description:
-
-```markdown
-### Motivation
-
-(Describe what problem this PR solves or why it matters)
-
-### Modifications
-
-* (First change)
-* (Second change)
-* ...
-```
-
-## Common Mistakes
-
-- **Forgetting to push**: Ensure branch is pushed before `gh pr create`; `gh` will prompt if not
-- **Long body**: Use `--body-file -` with heredoc when body is large or contains special chars
-- **Wrong base**: Use `--base branch` when base differs from default

package/.cursor/skills/git-create-branch/SKILL.md

@@ -1,97 +0,0 @@
----
-name: git-create-branch
-description: 标准化流程：先从远端获取最新 main，再创建 feature/bugfix 分支用于功能开发或 bug 修复。当你准备开始一项新开发任务并需要新分支时使用。
----
-
-# Git 新建分支流程（基于 main）
-
-## 前置约定
-
-- **默认远端名**：`origin`（如果项目不是用 `origin`，请将下面命令中的 `origin` 换成实际远端名）
-- **主干分支名**：`main`（如果项目主干是 `master` 或其他名字，同理替换）
-- **前提条件**：在运行本流程前，工作区应当是干净的（没有未提交更改，或明确知道自己在做什么）
-
-## 一、检查当前工作区状态
-
-1. 查看当前分支与工作区：
-
-   ```bash
-   git status
-   ```
-
-2. 如果有未提交的更改：
-   - 需要的话先提交：`git commit -am "your message"`
-   - 或者暂存：`git stash push -m "temp before new branch"`
-   - 或者放弃本地修改：`git restore .`（谨慎使用，会丢弃修改）
-
-目标：在继续之前，`git status` 应尽量是干净状态。
-
-## 二、从远端获取最新 main
-
-1. 抓取远端最新记录（包括 main）：
-
-   ```bash
-   git fetch origin main
-   ```
-
-2. 切换到本地 `main` 分支（如果当前还不在）：
-
-   ```bash
-   git checkout main
-   ```
-
-3. 将本地 `main` 更新到与远端一致，避免产生多余 merge 提交：
-
-   ```bash
-   git pull --ff-only origin main
-   ```
-
-如果 `--ff-only` 报错，说明本地 `main` 有额外提交，需要先确认是否应该保留；通常建议保持本地 `main` 与远端完全一致，没有额外提交。
-
-## 三、从最新 main 创建开发分支
-
-1. 根据需求选择分支前缀：
-   - 功能开发：`feature/xxx-简短描述`
-   - Bug 修复：`bugfix/xxx-简短描述`
-
-   示例：
-   - `feature/1234-add-knowledge-search`
-   - `bugfix/5678-fix-memory-sync`
-
-2. 从最新 `main` 创建并切换到新分支（将 `<new-branch-name>` 替换为你的实际分支名）：
-
-   ```bash
-   git checkout -b <new-branch-name> main
-   ```
-
-3. 确认当前分支确实是新建分支：
-
-   ```bash
-   git branch --show-current
-   git status
-   ```
-
-## 四、（可选）立即将新分支推送到远端
-
-如果你希望尽早在远端创建对应分支（方便备份或协作）：
-
-```bash
-git push -u origin <new-branch-name>
-```
-
-- `-u` 会设置默认上游分支，之后只需要 `git push` / `git pull` 即可。
-
-## 五、后续使用建议
-
-- **开始开发**：在新分支上进行所有与本任务相关的修改与提交。
-- **保持同步 main**：在开发周期较长时，周期性地从 `main` 合并或 rebase，避免与主干差异过大，例如：
-
-  ```bash
-  git checkout main
-  git pull --ff-only origin main
-  git checkout <new-branch-name>
-  git rebase main   # 或 git merge main，根据团队习惯
-  ```
-
-- **完成开发后**：通过 PR / Merge Request 将该分支合入主干，然后根据团队流程删除本地与远端分支。
-

package/docs/zh/openclaw.mdx

@@ -1,96 +0,0 @@
----
-title: OpenClaw（中文）
----
-
-通过 `memorylake-openclaw` 插件为 [OpenClaw](https://github.com/openclaw/openclaw) 代理添加长期记忆。你的代理在不同会话之间会忘记一切——这个插件会自动“观察”对话、提取重要信息，并在相关时把它们带回上下文，从而解决遗忘问题。
-
-## 概览
-
-{/*<Frame>
-  <img src="/images/openclaw-architecture.png" alt="OpenClaw MemoryLake Architecture" />
-</Frame>*/}
-
-该插件提供：
-1. **自动召回（Auto-Recall）** — 在代理回复前，将与当前消息匹配的记忆注入到上下文中
-2. **自动捕获（Auto-Capture）** — 在代理回复后，将本轮对话发送到 MemoryLake，由其判断哪些内容值得长期保存
-3. **代理工具（Agent Tools）** — 提供 5 个工具，便于在对话中显式进行记忆操作
-
-自动召回与自动捕获默认静默运行，无需手动配置即可生效。
-
-## 安装
-
-```bash
-openclaw plugins install memorylake-openclaw
-```
-
-## 设置与配置
-
-<Note>请从 [app.memorylake.ai](https://app.memorylake.ai) 获取 API key 和 project ID。</Note>
-
-在你的 `openclaw.json` 中添加：
-
-```json5
-// plugins.entries
-"memorylake-openclaw": {
-  "enabled": true,
-  "config": {
-    "apiKey": "${MEMORYLAKE_API_KEY}",
-    "projectId": "proj-..."
-  }
-}
-```
-
-## 代理工具
-
-代理在对话中可调用以下 5 个工具：
-
-| 工具 | 说明 |
-|------|------|
-| `memory_search` | 用自然语言搜索记忆 |
-| `memory_list` | 列出某个用户已存储的全部记忆 |
-| `memory_store` | 显式保存一条事实 |
-| `memory_get` | 通过 ID 读取一条记忆 |
-| `memory_forget` | 通过 ID 删除一条记忆 |
-
-## CLI 命令
-
-```bash
-# 搜索记忆
-openclaw memorylake search "what languages does the user know"
-
-# 查看统计信息
-openclaw memorylake stats
-```
-
-## 配置项
-
-| Key | 类型 | 默认值 | 说明 |
-|-----|------|--------|------|
-| `apiKey` | `string` | — | **必填。** MemoryLake API key（支持 `${MEMORYLAKE_API_KEY}`） |
-| `projectId` | `string` | — | **必填。** MemoryLake project ID |
-| `host` | `string` | `https://app.memorylake.ai` | MemoryLake 服务端点 URL |
-| `autoRecall` | `boolean` | `true` | 每轮对话前注入记忆 |
-| `autoCapture` | `boolean` | `true` | 每轮对话后存储事实 |
-| `topK` | `number` | `5` | 每次召回最多注入的记忆条数 |
-| `searchThreshold` | `number` | `0.3` | 最小相似度阈值（0–1） |
-| `rerank` | `boolean` | `true` | 对搜索结果重排以提升相关性 |
-
-## 关键特性
-
-1. **零配置** — 自动召回与自动捕获开箱即用，无需额外提示词或手动开关
-2. **异步处理** — 记忆提取通过 MemoryLake API 异步执行
-3. **会话追踪** — 对话会附带 `chat_session_id`，便于追溯与排查
-4. **工具完备** — 需要时可使用 5 个代理工具显式管理记忆
-
-## 总结
-
-`memorylake-openclaw` 插件让 OpenClaw 代理以极低成本获得持久记忆能力。你的代理可以跨会话自动记住用户偏好、事实与上下文，从而更稳定地连续协作。
-
-{/*<CardGroup cols={2}>
-  <Card title="MemoryLake" icon="brain" href="https://app.memorylake.ai">
-    MemoryLake platform
-  </Card>
-  <Card title="OpenClaw" icon="robot" href="https://github.com/openclaw/openclaw">
-    OpenClaw agent framework
-  </Card>
-</CardGroup>*/}

package/knowledge-search-usage-guide.md

@@ -1,371 +0,0 @@
-# Knowledge Search 接口调用与 LLM Context 拼接指南
-
-## 1. 整体思路
-
-```
-用户问题 (query)
-      │
-      ▼
-Knowledge Search API  ──  POST /api/v1/knowledge/dataset/{dataset_id}/search
-      │
-      ▼
-返回三类结果: table / paragraph / figure
-      │
-      ▼
-格式化为纯文本
-      │
-      ▼
-拼接到 LLM 的 prompt 中作为 context
-```
-
-核心逻辑就三步：**调接口 → 按类型解析结果 → 格式化为文本塞进 prompt**。
-
----
-
-## 2. Knowledge Search API
-
-### 请求
-
-```
-POST {endpoint}/api/v1/knowledge/dataset/{dataset_id}/search
-Content-Type: application/json
-```
-
-```json
-{
-    "user_query": "你的搜索查询",
-    "top_n": 5,
-    "datasource_list": null,
-    "__knobs": {"use_mini_aa": false}
-}
-```
-
-| 参数 | 类型 | 说明 |
-|------|------|------|
-| `user_query` | string | 搜索查询文本 |
-| `top_n` | int | 返回的最大结果数 |
-| `datasource_list` | list[string] \| null | 限定搜索范围的 datasource ID 列表，null 表示搜索全部 |
-
-### 响应
-
-```json
-{
-    "n": 3,
-    "results": [
-        { "type": "table", ... },
-        { "type": "paragraph", ... },
-        { "type": "figure", ... }
-    ]
-}
-```
-
-`results` 数组中每个元素通过 `type` 字段区分类型，共三种：
-
----
-
-### 2.1 type = "table"（表格结果）
-
-```json
-{
-    "type": "table",
-    "datasource_id": "ds_xxx",
-    "datasource_name": "销售报表.xlsx",
-    "sheet_name": "Sheet1",
-    "table_id": "tbl_xxx",
-    "table_region_info": "A1:F20",
-    "title": "2024年Q3销售汇总",
-    "footnote": "数据来源：财务部",
-    "highlight": {
-        "chunks": [],
-        "inner_tables": [
-            {
-                "id": "it_xxx",
-                "persist_path": "s3://bucket/path/to/table.parquet",
-                "columns": [
-                    {
-                        "id": "col_1",
-                        "name": "产品名称",
-                        "data_type": "string",
-                        "null_count": 0,
-                        "count": 100,
-                        "examples": ["产品A", "产品B"],
-                        "min_value": null,
-                        "max_value": null
-                    },
-                    {
-                        "id": "col_2",
-                        "name": "销售额",
-                        "data_type": "decimal",
-                        "null_count": 0,
-                        "count": 100,
-                        "examples": [12345.67],
-                        "min_value": "100.00",
-                        "max_value": "99999.99"
-                    }
-                ],
-                "data_range": "A1:F20",
-                "num_rows": 100
-            }
-        ],
-        "figure": null
-    }
-}
-```
-
-**关键字段提取**：
-- `title` / `footnote`：表格的标题和备注
-- `highlight.inner_tables[].columns`：列名、数据类型、示例值、min/max
-- `highlight.inner_tables[].persist_path`：表格数据文件的存储路径（如果需要加载实际数据）
-- `highlight.inner_tables[].num_rows`：行数
-
----
-
-### 2.2 type = "paragraph"（文本段落结果）
-
-```json
-{
-    "type": "paragraph",
-    "datasource_id": "ds_yyy",
-    "datasource_name": "公司简介.pdf",
-    "sheet_name": null,
-    "highlight": {
-        "chunks": [
-            {
-                "text": "公司成立于2010年，主要从事...",
-                "range": null
-            }
-        ],
-        "inner_tables": [],
-        "figure": null
-    }
-}
-```
-
-**关键字段提取**：
-- `highlight.chunks[].text`：文本内容（这是最有价值的信息）
-- `datasource_name`：来源文件名
-
----
-
-### 2.3 type = "figure"（图表结果）
-
-```json
-{
-    "type": "figure",
-    "figure_id": 1,
-    "datasource_id": "ds_zzz",
-    "datasource_name": "年报.pdf",
-    "sheet_name": null,
-    "highlight": {
-        "chunks": [],
-        "inner_tables": [],
-        "figure": {
-            "id": "fig_xxx",
-            "text": "图表中提取的文本内容...",
-            "caption": "图1: 2024年营收趋势",
-            "persist_path": "s3://bucket/path/to/figure.png",
-            "summary_text": "该图展示了2024年各季度营收数据..."
-        }
-    }
-}
-```
-
-**关键字段提取**：
-- `highlight.figure.caption`：图表标题
-- `highlight.figure.text`：从图表中提取的文本
-- `highlight.figure.summary_text`：图表内容摘要
-- `highlight.figure.persist_path`：图片文件路径
-
----
-
-## 3. 解析与格式化逻辑（伪代码）
-
-下面是与框架无关的伪代码，描述如何把 API 响应转化为 LLM context：
-
-```
-function build_context(api_response):
-    context_parts = []
-
-    for result in api_response.results:
-
-        if result.type == "table":
-            # 拼表格元信息
-            append "### Table: {result.title} (from {result.datasource_name})"
-            if result.footnote:
-                append "Note: {result.footnote}"
-            for inner_table in result.highlight.inner_tables:
-                # 拼列信息：列名(类型) 的列表
-                col_desc = join(
-                    "{col.name}({col.data_type})" for col in inner_table.columns
-                )
-                append "Columns: {col_desc}"
-                append "Rows: {inner_table.num_rows}"
-
-                # 【可选】如果需要样本数据，从 persist_path 加载前 N 行
-                # df = load_dataframe(inner_table.persist_path)
-                # append df.head(10).to_markdown()
-
-        elif result.type == "paragraph":
-            append "### Paragraph (from {result.datasource_name}):"
-            for chunk in result.highlight.chunks:
-                if chunk.text:
-                    # 限制长度，避免单个 chunk 占太多 token
-                    text = chunk.text[:10000]
-                    append text
-
-        elif result.type == "figure":
-            figure = result.highlight.figure
-            if figure:
-                append "### Figure (from {result.datasource_name}):"
-                if figure.caption:
-                    append "Caption: {figure.caption}"
-                if figure.text:
-                    append figure.text
-                elif figure.summary_text:
-                    append figure.summary_text
-
-    return join(context_parts, "\n\n")
-```
-
----
-
-## 4. 拼接到 LLM Prompt 的模式
-
-```
-system_prompt = """
-You are a helpful assistant. Answer the user's question based on the following retrieved context.
-
-<context>
-{上面 build_context 的输出}
-</context>
-
-If the context doesn't contain enough information to answer, say so.
-"""
-
-messages = [
-    {"role": "system", "content": system_prompt},
-    {"role": "user", "content": 用户原始问题},
-]
-
-# 发送给 LLM
-response = llm.chat(messages)
-```
-
----
-
-## 5. 实际调用示例 (Python + httpx)
-
-以下是一个完全独立、可以在任意 Python 项目中使用的实现：
-
-```python
-import httpx
-
-
-async def knowledge_search(
-    endpoint: str,
-    dataset_id: str,
-    query: str,
-    top_n: int = 5,
-    datasource_list: list[str] | None = None,
-    timeout: int = 60,
-) -> dict:
-    """调用 knowledge search API，返回原始 JSON 响应。"""
-    async with httpx.AsyncClient() as client:
-        resp = await client.post(
-            f"{endpoint}/api/v1/knowledge/dataset/{dataset_id}/search",
-            json={
-                "user_query": query,
-                "top_n": top_n,
-                "datasource_list": datasource_list,
-                "__knobs": {"use_mini_aa": False},
-            },
-            timeout=timeout,
-        )
-        resp.raise_for_status()
-        return resp.json()
-
-
-def build_llm_context(search_response: dict, max_chunk_length: int = 10000) -> str:
-    """将 knowledge search 响应解析并格式化为 LLM context 文本。"""
-    parts: list[str] = []
-
-    for result in search_response.get("results", []):
-        result_type = result.get("type")
-        source = result.get("datasource_name", "unknown")
-        highlight = result.get("highlight", {})
-
-        if result_type == "table":
-            title = result.get("title") or "Untitled Table"
-            parts.append(f"### Table: {title} (from {source})")
-
-            footnote = result.get("footnote")
-            if footnote:
-                parts.append(f"Note: {footnote}")
-
-            for inner_table in highlight.get("inner_tables", []):
-                columns = inner_table.get("columns", [])
-                col_desc = ", ".join(
-                    f"{c['name']}({c['data_type']})" for c in columns
-                )
-                parts.append(f"Columns: {col_desc}")
-                parts.append(f"Rows: {inner_table.get('num_rows', '?')}")
-
-            for chunk in highlight.get("chunks", []):
-                text = chunk.get("text", "")
-                if text:
-                    parts.append(text[:max_chunk_length])
-
-        elif result_type == "paragraph":
-            parts.append(f"### Paragraph (from {source}):")
-            for chunk in highlight.get("chunks", []):
-                text = chunk.get("text", "")
-                if text:
-                    parts.append(text[:max_chunk_length])
-
-        elif result_type == "figure":
-            figure = highlight.get("figure")
-            if figure:
-                parts.append(f"### Figure (from {source}):")
-                caption = figure.get("caption")
-                if caption:
-                    parts.append(f"Caption: {caption}")
-                text = figure.get("text") or figure.get("summary_text") or ""
-                if text:
-                    parts.append(text)
-
-        parts.append("")  # 空行分隔
-
-    return "\n".join(parts)
-
-
-async def query_with_knowledge(
-    endpoint: str,
-    dataset_id: str,
-    query: str,
-    top_n: int = 5,
-) -> str:
-    """完整流程：搜索 → 构建 context → 返回可用于 LLM 的 prompt。"""
-    response = await knowledge_search(endpoint, dataset_id, query, top_n)
-    context = build_llm_context(response)
-
-    system_prompt = (
-        "You are a helpful assistant. "
-        "Answer the user's question based on the following retrieved context.\n\n"
-        f"<context>\n{context}\n</context>\n\n"
-        "If the context doesn't contain enough information to answer, say so."
-    )
-    return system_prompt
-```
-
----
-
-## 6. 设计要点总结
-
-| 要点 | 说明 |
-|------|------|
-| **一次请求返回三种类型** | search API 的 results 混合了 table / paragraph / figure，需要按 `type` 字段分别处理 |
-| **表格数据需二次加载** | search API 只返回列元信息，实际数据存在 `inner_tables[].persist_path` 指向的文件中（通常是 S3 上的 parquet），如果只需要元信息就不用加载 |
-| **文本内容在 chunks 里** | paragraph 类型的实际文本在 `highlight.chunks[].text` 中 |
-| **图表有三个文本字段** | `figure.caption`（标题）、`figure.text`（提取文本）、`figure.summary_text`（摘要），取其中有值的即可 |
-| **context 长度控制** | 需要根据 LLM 的 token 限制控制总 context 长度，建议对单个 chunk 做截断 + 控制 top_n |
-| **API 幂等且可缓存** | 相同 dataset_id + query + top_n 的请求返回相同结果，适合做客户端缓存 |

package/skills/migrate-memories-to-memorylake/SKILL copy.md

@@ -1,182 +0,0 @@
----
-name: migrate-memories-to-memorylake
-description: Migrates memories, conversations to MemoryLake. Use when the user wants to import existing memories, conversations into MemoryLake.
----
-
-# Migrate Memories to MemoryLake
-
-## Overview
-
-Extract memory files and conversation history from session files, then submit them to MemoryLake's API so memories are persisted in the platform.
-
-## When to Use
-
-- User wants to migrate memories or conversations into MemoryLake
-- User is setting up MemoryLake and needs to import existing memories or conversations
-
-## Prerequisites
-
-The caller must provide:
-- **`user_id`**: The user ID to tag memories with (e.g., a Feishu user ID like `ou_xxx`)
-- **`agent`**: The agent name (e.g., `main`)
-
-## Step 1 — Read MemoryLake Config
-
-Read `~/.openclaw/openclaw.json` and extract the plugin config:
-
-```bash
-cat ~/.openclaw/openclaw.json | jq '.plugins.entries["memorylake-openclaw"].config'
-```
-
-Extract these values:
-- **`host`** — API host (default: `https://app.memorylake.ai`)
-- **`apiKey`** — API key for authentication
-- **`projectId`** — MemoryLake project ID
-
-## Step 2 — Identify User and Agent
-
-Use the `user_id` and `agent` provided by the caller. These are used to:
-- Filter sessions in Step 3 (session keys contain the user ID)
-- Tag all submitted memories with `user_id`
-
-## Step 3 — Filter Sessions by User ID
-
-Read the session index:
-
-```bash
-cat ~/.openclaw/agents/{agent}/sessions/sessions.json
-```
-
-This file maps session keys to session metadata. Session keys follow the format:
-
-```
-agent:{agent}:{channel}:{type}:{user_id}
-```
-
-Filter entries whose key contains the `user_id`. Collect the matching session IDs and their corresponding `.jsonl` file paths at:
-
-```
-~/.openclaw/agents/{agent}/sessions/{sessionId}.jsonl
-```
-
-## Step 4 — Read Memory Files
-
-Read the workspace path from config:
-
-```bash
-cat ~/.openclaw/openclaw.json | jq -r '.agents.defaults.workspace'
-```
-
-Then read:
-- `{workspace}/MEMORY.md`
-- All files in `{workspace}/memory/` directory
-
-These contain curated memory that should also be migrated.
-
-## Step 5 — Submit Data to MemoryLake
-
-### 5a — Submit Session Conversations
-
-For each matched `.jsonl` session file:
-
-1. **Parse the JSONL file** line by line
-2. **Extract message entries**: lines where `type` is `"message"`
-3. **Extract text content** from message content blocks:
-
-   ```json
-   {"type":"message","message":{"role":"user","content":[{"type":"text","text":"actual message text"}]}}
-   ```
-
-   - Filter to `role: "user"` and `role: "assistant"` only
-   - For each content block array, concatenate all `text` blocks into a single string
-   - Skip entries with empty text content
-
-4. **Build the messages array**: `[{role, content}, {role, content}, ...]`
-
-5. **POST to the API**:
-
-   ```bash
-   curl -X POST "{host}/openapi/memorylake/api/v2/projects/{projectId}/memories" \
-     -H "Authorization: Bearer {apiKey}" \
-     -H "Content-Type: application/json" \
-     -d '{
-       "messages": [
-         {"role": "user", "content": "..."},
-         {"role": "assistant", "content": "..."}
-       ],
-       "user_id": "{user_id}",
-       "chat_session_id": "{sessionId}",
-       "metadata": {"source": "OPENCLAW_MIGRATION"},
-       "infer": true
-     }'
-   ```
-
-   **Important**: If a session has many messages, batch them in chunks of ~20 messages per request to avoid timeouts. Preserve message order within each batch.
-
-6. **Log the result**: Each successful response returns:
-
-   ```json
-   {
-     "success": true,
-     "data": {
-       "results": [
-         {"event_id": "...", "status": "...", "message": "..."}
-       ]
-     }
-   }
-   ```
-### 5b — Submit Memory Files
-
-For each memory file (`MEMORY.md` and files in `memory/`):
-
-1. **Read the file content**
-2. **Wrap as a single user message**:
-
-   ```json
-   [{"role": "user", "content": "<file content here>"}]
-   ```
-
-3. **POST to the API**:
-
-   ```bash
-   curl -X POST "{host}/openapi/memorylake/api/v2/projects/{projectId}/memories" \
-     -H "Authorization: Bearer {apiKey}" \
-     -H "Content-Type: application/json" \
-     -d '{
-       "messages": [{"role": "user", "content": "..."}],
-       "user_id": "{user_id}",
-       "metadata": {"source": "OPENCLAW_MIGRATION", "file": "{filename}"},
-       "infer": true
-     }'
-   ```
-
-## Progress Tracking
-
-Report progress after each submission:
-- `[session X/N] Submitted {count} messages from session {sessionId} — {status}`
-- `[file X/N] Submitted {filename} — {status}`
-
-At the end, print a summary:
-- Total sessions processed
-- Total memory files processed
-- Total API calls made
-- Any errors encountered
-
-## Error Handling
-
-- If a session file is missing or unreadable, log a warning and continue with the next one
-- If an API call fails, log the error with the session/file context and continue
-- If `apiKey` or `projectId` is missing from config, stop immediately and inform the user
-
-## Quick Reference
-
-| Item | Path / Value |
-|------|-------------|
-| Config file | `~/.openclaw/openclaw.json` |
-| Plugin config key | `plugins.entries["memorylake-openclaw"].config` |
-| Session index | `~/.openclaw/agents/{agent}/sessions/sessions.json` |
-| Session files | `~/.openclaw/agents/{agent}/sessions/{id}.jsonl` |
-| Workspace path | `agents.defaults.workspace` in config |
-| API endpoint | `{host}/openapi/memorylake/api/v2/projects/{projectId}/memories` |
-| Auth header | `Authorization: Bearer {apiKey}` |
-| Default host | `https://app.memorylake.ai` |

package/skills/migrate-openclaw-memories/SKILL.md

@@ -1,210 +0,0 @@
----
-name: migrate-memories-to-memorylake
-description: Use when the user asks to migrate memories, conversations, or history into MemoryLake. This is THE skill for any migration of OpenClaw data to MemoryLake.
----
-
-# Migrate OpenClaw Memories to MemoryLake
-
-## Overview
-
-Extract conversation history from OpenClaw session files and curated workspace memory files, then submit them to MemoryLake's API so memories are persisted in the platform.
-
-## When to Use
-
-- User wants to migrate existing OpenClaw data into MemoryLake
-- User wants to backfill MemoryLake with historical conversations
-- User is setting up MemoryLake for the first time and has existing OpenClaw sessions
-
-- User wants to migrate OpenClaw conversation history or workspace memories into MemoryLake
-- User wants to backfill MemoryLake with historical OpenClaw sessions
-- User is setting up MemoryLake and needs to import existing OpenClaw data
-
-## Prerequisites
-
-The caller must provide:
-- **`user_id`**: The user ID to tag memories with (e.g., a Feishu user ID like `ou_xxx`)
-- **`agent`**: The OpenClaw agent name (e.g., `main`)
-
-## Step 1 — Read MemoryLake Config
-
-Read `~/.openclaw/openclaw.json` and extract the plugin config:
-
-```bash
-cat ~/.openclaw/openclaw.json | jq '.plugins.entries["memorylake-openclaw"].config'
-```
-
-Extract these values:
-- **`host`** — API host (default: `https://app.memorylake.ai`)
-- **`apiKey`** — API key for authentication
-- **`projectId`** — MemoryLake project ID
-
-The API base path used by the plugin is:
-
-```
-{host}/openapi/memorylake/api/v2/projects/{projectId}/memories
-```
-
-Auth header for all requests:
-
-```
-Authorization: Bearer {apiKey}
-```
-
-## Step 2 — Identify User and Agent
-
-Use the `user_id` and `agent` provided by the caller. These are used to:
-- Filter sessions in Step 3 (session keys contain the user ID)
-- Tag all submitted memories with `user_id`
-
-## Step 3 — Filter Sessions by User ID
-
-Read the session index:
-
-```bash
-cat ~/.openclaw/agents/{agent}/sessions/sessions.json
-```
-
-This file maps session keys to session metadata. Session keys follow the format:
-
-```
-agent:{agent}:{channel}:{type}:{userId}
-```
-
-Filter entries whose key contains the `user_id`. Collect the matching session IDs and their corresponding `.jsonl` file paths at:
-
-```
-~/.openclaw/agents/{agent}/sessions/{sessionId}.jsonl
-```
-
-## Step 4 — Read Workspace Memory Files
-
-Read the workspace path from config:
-
-```bash
-cat ~/.openclaw/openclaw.json | jq -r '.agents.defaults.workspace'
-```
-
-Then read:
-- `{workspace}/MEMORY.md`
-- All files in `{workspace}/memory/` directory
-
-These contain curated memory that should also be migrated.
-
-## Step 5 — Verify API Format (Optional)
-
-Fetch the OpenAPI spec to confirm the request schema:
-
-```bash
-curl -s "{host}/v3/api-docs/open-api" | jq '.paths["/api/v2/projects/{id}/memories"].post'
-```
-
-This is optional — the format is documented below in Step 6.
-
-## Step 6 — Submit Data to MemoryLake
-
-### 6a — Submit Session Conversations
-
-For each matched `.jsonl` session file:
-
-1. **Parse the JSONL file** line by line
-2. **Extract message entries**: lines where `type` is `"message"`
-3. **Extract text content** from message content blocks:
-
-   ```json
-   {"type":"message","message":{"role":"user","content":[{"type":"text","text":"actual message text"}]}}
-   ```
-
-   - Filter to `role: "user"` and `role: "assistant"` only
-   - For each content block array, concatenate all `text` blocks into a single string
-   - Skip entries with empty text content
-
-4. **Build the messages array**: `[{role, content}, {role, content}, ...]`
-
-5. **POST to the API**:
-
-   ```bash
-   curl -X POST "{host}/openapi/memorylake/api/v2/projects/{projectId}/memories" \
-     -H "Authorization: Bearer {apiKey}" \
-     -H "Content-Type: application/json" \
-     -d '{
-       "messages": [
-         {"role": "user", "content": "..."},
-         {"role": "assistant", "content": "..."}
-       ],
-       "user_id": "{user_id}",
-       "chat_session_id": "{sessionId}",
-       "metadata": {"source": "OPENCLAW_MIGRATION"},
-       "infer": true
-     }'
-   ```
-
-   **Important**: If a session has many messages, batch them in chunks of ~20 messages per request to avoid timeouts. Preserve message order within each batch.
-
-6. **Log the result**: Each successful response returns:
-
-   ```json
-   {
-     "success": true,
-     "data": {
-       "results": [
-         {"event_id": "...", "status": "...", "message": "..."}
-       ]
-     }
-   }
-   ```
-
-### 6b — Submit Workspace Memory Files
-
-For each workspace memory file (`MEMORY.md` and files in `memory/`):
-
-1. **Read the file content**
-2. **Wrap as a single user message**:
-
-   ```json
-   [{"role": "user", "content": "<file content here>"}]
-   ```
-
-3. **POST to the API**:
-
-   ```bash
-   curl -X POST "{host}/openapi/memorylake/api/v2/projects/{projectId}/memories" \
-     -H "Authorization: Bearer {apiKey}" \
-     -H "Content-Type: application/json" \
-     -d '{
-       "messages": [{"role": "user", "content": "..."}],
-       "user_id": "{user_id}",
-       "metadata": {"source": "OPENCLAW_MIGRATION", "file": "{filename}"},
-       "infer": true
-     }'
-   ```
-
-## Progress Tracking
-
-Report progress after each submission:
-- `[session X/N] Submitted {count} messages from session {sessionId} — {status}`
-- `[file X/N] Submitted {filename} — {status}`
-
-At the end, print a summary:
-- Total sessions processed
-- Total memory files processed
-- Total API calls made
-- Any errors encountered
-
-## Error Handling
-
-- If a session file is missing or unreadable, log a warning and continue with the next one
-- If an API call fails, log the error with the session/file context and continue
-- If `apiKey` or `projectId` is missing from config, stop immediately and inform the user
-
-## Quick Reference
-
-| Item | Path / Value |
-|------|-------------|
-| OpenClaw config | `~/.openclaw/openclaw.json` |
-| Plugin config key | `plugins.entries["memorylake-openclaw"].config` |
-| Session index | `~/.openclaw/agents/{agent}/sessions/sessions.json` |
-| Session files | `~/.openclaw/agents/{agent}/sessions/{id}.jsonl` |
-| Workspace path | `agents.defaults.workspace` in config |
-| API endpoint | `{host}/openapi/memorylake/api/v2/projects/{projectId}/memories` |
-| Auth header | `Authorization: Bearer {apiKey}` |
-| Default host | `https://app.memorylake.ai` |