feat(mem0-plugin): add export/import skills + competing tool importers
Tier 3 implementation: - #10: Unified project_id resolver already complete (shared scripts/) - #11: /mem0:export dumps all project memories as YAML-frontmatter markdown; /mem0:import restores from same format. Round-trip capable. parse_export_file.py handles parsing (stdlib-only). - #12: import_competing_tools.py imports from .cursorrules, copilot instructions, cline memory-bank, continue.dev rules. Splits by section headers, POSTs with app_id + infer=False.
This commit is contained in:
kartik-mem0
@@ -0,0 +1,81 @@
|
||||
---
|
||||
name: mem0-export
|
||||
description: >
|
||||
Export all memories for the current project to a local Markdown file.
|
||||
Each memory is written as a YAML-frontmatter block that can be re-imported later.
|
||||
TRIGGER: user runs /mem0:export, or asks "export memories", "backup memories",
|
||||
"download my memories", "save memories to file".
|
||||
---
|
||||
|
||||
# Mem0 Export
|
||||
|
||||
Export all memories for the current project to a portable Markdown file.
|
||||
|
||||
## Execution
|
||||
|
||||
### Step 1: Resolve identity
|
||||
|
||||
Determine the active identity:
|
||||
- `user_id` from `MEM0_USER_ID` env var, else `$USER`, else `"default"`
|
||||
- `project_id` (used as `app_id`) from `MEM0_PROJECT_ID` env var, or via the project resolver
|
||||
|
||||
### Step 2: Fetch all memories
|
||||
|
||||
Call `get_memories` with:
|
||||
- `user_id=<active_user_id>`
|
||||
- `app_id=<active_project_id>`
|
||||
- `page_size=200`
|
||||
|
||||
If the response is paginated (i.e. the result contains a `next` cursor or the count equals `page_size`), continue fetching pages until all memories are retrieved.
|
||||
|
||||
### Step 3: Format each memory as a YAML-frontmatter block
|
||||
|
||||
For each memory record, produce a block in this exact format:
|
||||
|
||||
```
|
||||
---
|
||||
id: <memory.id>
|
||||
created_at: <memory.created_at>
|
||||
type: <memory.metadata.type or "">
|
||||
confidence: <memory.metadata.confidence or "">
|
||||
branch: <memory.metadata.branch or "">
|
||||
files: <memory.metadata.files joined with ", " or "">
|
||||
categories: <memory.categories joined with ", " or "">
|
||||
---
|
||||
<memory.memory or memory content string>
|
||||
|
||||
```
|
||||
|
||||
Notes:
|
||||
- The `---` delimiters must be on their own lines with no extra whitespace.
|
||||
- `files` and `categories` are written as comma-separated values on a single line.
|
||||
- Leave a blank line after the content before the next `---` (for readability).
|
||||
- If a field is missing or null, write an empty string (not "null").
|
||||
|
||||
### Step 4: Write the export file
|
||||
|
||||
Determine the output filename:
|
||||
|
||||
```
|
||||
mem0-export-<project_id>-<YYYY-MM-DD>.md
|
||||
```
|
||||
|
||||
Where `<YYYY-MM-DD>` is today's date in UTC.
|
||||
|
||||
Write all formatted blocks to this file using the Write tool (or equivalent). The file is written to the current working directory.
|
||||
|
||||
### Step 5: Print summary
|
||||
|
||||
```
|
||||
Exported <N> memories to <filename>
|
||||
```
|
||||
|
||||
Where `<N>` is the total number of memory blocks written.
|
||||
|
||||
## Error Handling
|
||||
|
||||
- If `get_memories` returns an error or zero memories, print:
|
||||
```
|
||||
No memories found for project <project_id>. Nothing exported.
|
||||
```
|
||||
- If the write fails, report the error to the user.
|
||||
@@ -0,0 +1,106 @@
|
||||
---
|
||||
name: mem0-import-tools
|
||||
description: >
|
||||
Import memories from competing AI tool configuration files into mem0.
|
||||
Supports Cursor (.cursorrules), GitHub Copilot (.github/copilot-instructions.md),
|
||||
Cline (memory-bank/), and Continue (.continue/rules.md).
|
||||
TRIGGER: user runs /mem0:import-tools, or asks "import from cursor",
|
||||
"import cursorrules", "import from cline", "import from copilot",
|
||||
"import from continue", "migrate from cursor", "migrate memories".
|
||||
---
|
||||
|
||||
# Mem0 Import from Competing Tools
|
||||
|
||||
Import configuration and memory files from other AI coding tools into mem0.
|
||||
|
||||
## Supported Tools
|
||||
|
||||
| Tool | Default file/directory |
|
||||
|------|----------------------|
|
||||
| Cursor | `.cursorrules` |
|
||||
| GitHub Copilot | `.github/copilot-instructions.md` |
|
||||
| Cline | `memory-bank/` (directory of `.md` files) |
|
||||
| Continue | `.continue/rules.md` |
|
||||
|
||||
## Execution
|
||||
|
||||
### Step 1: Detect which tool files exist
|
||||
|
||||
Check for the presence of each tool's file/directory in the current working directory:
|
||||
|
||||
```bash
|
||||
# Check each location
|
||||
test -f .cursorrules && echo "cursor: .cursorrules"
|
||||
test -f .github/copilot-instructions.md && echo "copilot: .github/copilot-instructions.md"
|
||||
test -d memory-bank/ && echo "cline: memory-bank/"
|
||||
test -f .continue/rules.md && echo "continue: .continue/rules.md"
|
||||
```
|
||||
|
||||
### Step 2: Report findings and ask user
|
||||
|
||||
List all found files to the user. For example:
|
||||
|
||||
```
|
||||
Found the following tool configuration files:
|
||||
[1] Cursor rules: .cursorrules
|
||||
[2] Cline memory bank: memory-bank/
|
||||
|
||||
Which would you like to import? (enter numbers, comma-separated, or "all"):
|
||||
```
|
||||
|
||||
If no files are found, print:
|
||||
```
|
||||
No competing tool configuration files found in the current directory.
|
||||
Checked: .cursorrules, .github/copilot-instructions.md, memory-bank/, .continue/rules.md
|
||||
```
|
||||
and stop.
|
||||
|
||||
### Step 3: Run the import script for each selected tool
|
||||
|
||||
Determine the plugin root. Use the appropriate variable for the current platform:
|
||||
- Claude Code: `${CLAUDE_PLUGIN_ROOT}`
|
||||
- Codex: `${CODEX_PLUGIN_ROOT}`
|
||||
- Cursor: `${CURSOR_PLUGIN_ROOT}`
|
||||
|
||||
For each tool the user selected, run the corresponding sub-command:
|
||||
|
||||
**Cursor (.cursorrules):**
|
||||
```bash
|
||||
python3 "<PLUGIN_ROOT>/scripts/import_competing_tools.py" cursorrules --path .cursorrules
|
||||
```
|
||||
|
||||
**GitHub Copilot:**
|
||||
```bash
|
||||
python3 "<PLUGIN_ROOT>/scripts/import_competing_tools.py" copilot --path .github/copilot-instructions.md
|
||||
```
|
||||
|
||||
**Cline:**
|
||||
```bash
|
||||
python3 "<PLUGIN_ROOT>/scripts/import_competing_tools.py" cline --path memory-bank/
|
||||
```
|
||||
|
||||
**Continue:**
|
||||
```bash
|
||||
python3 "<PLUGIN_ROOT>/scripts/import_competing_tools.py" continue --path .continue/rules.md
|
||||
```
|
||||
|
||||
### Step 4: Report results
|
||||
|
||||
After each script runs, echo its output to the user. Then print a combined summary:
|
||||
|
||||
```
|
||||
Import complete.
|
||||
Cursor: <N> memories
|
||||
Copilot: <N> memories
|
||||
Total: <N> memories imported into project <project_id>
|
||||
```
|
||||
|
||||
Adjust the summary to reflect only the tools that were actually imported.
|
||||
|
||||
## Notes
|
||||
|
||||
- Memories are imported with `infer=False` — no AI inference is applied, content is stored as-is.
|
||||
- Each section or file becomes a separate memory tagged with `metadata.source=<tool>-import` and `metadata.type=project_profile`.
|
||||
- Sections shorter than 50 characters are automatically skipped (too short to be useful).
|
||||
- Content longer than 10,000 characters is automatically truncated per chunk.
|
||||
- You can re-run this skill safely — duplicate content will be caught by mem0's deduplication.
|
||||
@@ -0,0 +1,104 @@
|
||||
---
|
||||
name: mem0-import
|
||||
description: >
|
||||
Import memories from a mem0 export file back into the current project.
|
||||
Reads a YAML-frontmatter Markdown file produced by /mem0:export and
|
||||
adds each memory block to mem0.
|
||||
TRIGGER: user runs /mem0:import, or asks "import memories", "restore memories",
|
||||
"load memories from file", "reimport backup".
|
||||
---
|
||||
|
||||
# Mem0 Import
|
||||
|
||||
Import memories from a mem0 export file into the current project.
|
||||
|
||||
## Execution
|
||||
|
||||
### Step 1: Determine the export file to import
|
||||
|
||||
If the user provided a filename as an argument to `/mem0:import <filename>`, use that file.
|
||||
|
||||
Otherwise, list `.md` files in the current directory whose names contain `mem0-export`:
|
||||
|
||||
```bash
|
||||
ls -1 *.md 2>/dev/null | grep mem0-export || echo "No export files found"
|
||||
```
|
||||
|
||||
If multiple files are found, ask the user which one to import. If none are found, print:
|
||||
```
|
||||
No mem0-export files found in the current directory.
|
||||
Run /mem0:export first, or provide the filename: /mem0:import <path-to-file>
|
||||
```
|
||||
|
||||
### Step 2: Parse the export file
|
||||
|
||||
Determine the plugin root. Use the appropriate variable for the current platform:
|
||||
- Claude Code: `${CLAUDE_PLUGIN_ROOT}`
|
||||
- Codex: `${CODEX_PLUGIN_ROOT}`
|
||||
- Cursor: `${CURSOR_PLUGIN_ROOT}`
|
||||
|
||||
Run the parser script to extract memory records as JSON:
|
||||
|
||||
```bash
|
||||
python3 "<PLUGIN_ROOT>/scripts/parse_export_file.py" "<path-to-export-file>"
|
||||
```
|
||||
|
||||
This outputs a JSON array where each element has:
|
||||
- `id` — original memory ID (for reference only; a new ID will be assigned on import)
|
||||
- `type` — metadata type
|
||||
- `confidence` — metadata confidence value
|
||||
- `branch` — metadata branch
|
||||
- `files` — list of associated files
|
||||
- `categories` — list of categories
|
||||
- `content` — the memory text
|
||||
|
||||
If the script fails or outputs `[]`, print:
|
||||
```
|
||||
Failed to parse <filename> or file contains no valid memory blocks.
|
||||
```
|
||||
and stop.
|
||||
|
||||
### Step 3: Resolve identity
|
||||
|
||||
Determine the active identity:
|
||||
- `user_id` from `MEM0_USER_ID` env var, else `$USER`, else `"default"`
|
||||
- `project_id` (used as `app_id`) from `MEM0_PROJECT_ID` env var, or via the project resolver
|
||||
|
||||
### Step 4: Import each memory
|
||||
|
||||
For each record in the parsed JSON array, call `add_memory` with:
|
||||
|
||||
- `messages=[{"role": "user", "content": "<record.content>"}]`
|
||||
- `user_id=<active_user_id>`
|
||||
- `app_id=<active_project_id>`
|
||||
- `metadata={`
|
||||
- `"type": "<record.type>"` (if non-empty)
|
||||
- `"confidence": "<record.confidence>"` (if non-empty)
|
||||
- `"branch": "<record.branch>"` (if non-empty)
|
||||
- `"files": <record.files>` (the list, if non-empty)
|
||||
- `"source": "import"`
|
||||
- `}`
|
||||
- `infer=False`
|
||||
|
||||
Notes:
|
||||
- Do NOT pass the original `id` — the platform assigns a new ID.
|
||||
- Skip records where `content` is empty (the parser already filters these, but be defensive).
|
||||
- Continue importing even if individual records fail; track the count of successes.
|
||||
|
||||
### Step 5: Print results
|
||||
|
||||
```
|
||||
Imported <N> memories into project <project_id>
|
||||
```
|
||||
|
||||
Where `<N>` is the number of successfully imported memories.
|
||||
|
||||
If any failed:
|
||||
```
|
||||
Imported <N>/<total> memories into project <project_id> (<failed> failed)
|
||||
```
|
||||
|
||||
## Error Handling
|
||||
|
||||
- If the parser script is not found at `<PLUGIN_ROOT>/scripts/parse_export_file.py`, print an error and stop.
|
||||
- If `add_memory` calls fail consistently (e.g. auth error), report the issue and stop early.
|
||||
Reference in New Issue
Block a user