/mem0-test-integration

name: mem0-test-integration
description: >
  Verify a Mem0 integration produced by /mem0-integrate. Runs in the same
  workspace on the same branch (loose coupling) — installs dependencies,
  runs the repo's native test suite, then exercises a real end-to-end
  smoke flow against the user's API key. Produces a scorecard.
  TRIGGER when: user has just run /mem0-integrate and says "verify",
  "test the integration", "run /mem0-test-integration", or when a
  .mem0-integration/ directory exists and tests have not been run yet
  on the current branch.
  DO NOT TRIGGER when: the user wants to run general project tests
  (defer to the repo's native test command), or when no prior /mem0-integrate
  run exists in the current branch (ask them to run /mem0-integrate first).
  This skill ONLY catches compile and runtime bugs by design. Logical
  integration errors — wrong data stored, wrong time retrieved, wrong
  user scoping — are on the human reviewer.
license: Apache-2.0
metadata:
  author: mem0ai
  version: "0.1.0"
  category: ai-memory
  tags: "memory, integration, testing, tdd, platform, oss"
  coupling: loose
  mem0_tested_versions: "mem0ai (PyPI) >=2.0.0,<3.0.0; mem0ai (npm) >=3.0.0,<4.0.0"

mem0-test-integration

Verifies what `/mem0-integrate` produced. Runs in the same workspace, on the same feature branch. Loose coupling — fast, catches compile and runtime bugs, does not catch logical errors.

Canonical sources (use these, not ambient knowledge)

All static checks and smoke-test shapes validate against these URLs. `WebFetch` each before running step 3.

• Scope-tagged docs index: https://docs.mem0.ai/llms.txt
• OpenAPI (Platform REST): https://docs.mem0.ai/openapi.json
• Published SDK skill (canonical call patterns): https://raw.githubusercontent.com/mem0ai/mem0/main/skills/mem0/SKILL.md
• Vercel AI SDK skill (if the target repo uses `@ai-sdk/*`): https://raw.githubusercontent.com/mem0ai/mem0/main/skills/mem0-vercel-ai-sdk/SKILL.md
• SDK source (cross-check version against frontmatter `mem0_tested_versions`):
• Repo root: https://github.com/mem0ai/mem0
• Python: https://github.com/mem0ai/mem0/tree/main/mem0
• TypeScript: https://github.com/mem0ai/mem0/tree/main/mem0-ts

Read the `Delegated skill:` field in `.mem0-integration/plan.md` — if it names a skill URL, fetch that skill and use its example blocks as the reference for both static checks (step 3) and the smoke test (step 5).

Non-invasiveness contract

Every check in this skill assumes the integration is **additive and feature-flagged** (see `/mem0-integrate` "Integration principles"). Specifically:

• `product.json` must contain a `feature_flag` field.
• Steps 4–6 run in two passes:
• **Pass A — flag unset.** All pre-existing tests must pass, smoke/E2E

skip. The repo must behave like `main`. Any failure here is a **hard fail** — do not let the self-heal loop attempt a patch.

• **Pass B — flag set.** New tests must pass, smoke and E2E run.
• If Pass A fails, the scorecard marks `non_invasive: false` and sets

`overall: fail` with a distinct reason code the integrator's heal loop refuses to touch.

Preconditions

Refuse to start unless ALL of the following are true:

• `.mem0-integration/` directory exists in the repo root.
• `.mem0-integration/product.json`, `goal.md`, and `plan.md` are readable

and internally consistent (JSON parses, docs non-empty).

• Current branch name begins with `mem0-integrate/` (set by the companion

skill). Prevents accidental runs on unrelated branches.

• Working tree is clean. The skill never modifies source files; any dirty

state means the integration is mid-edit and not ready to verify.

• The same API key the integration used is available in the environment

(`MEM0_API_KEY` for Platform, `OPENAI_API_KEY` for OSS — read which from `product.json`). Interactive mode asks if missing; CI mode exits 2.

Exit with a written rationale on any precondition failure. Never attempt to "fix up" state.

Pipeline

1. Read the contract

Load:

• `product.json` → which language, which product (Platform vs OSS), which

mem0 version, `write_site`, `read_site`.

• `plan.md` → the mechanical contract (write pattern, read pattern,

preserved behavior).

• `goal.md` → the intent (displayed in the scorecard only; not tested).

2. Install dependencies

Route by language from `product.json`:

| Language | Command | |---|---| | Python | `pip install -e .` if editable, else `pip install -r requirements.txt`. Then `pip install mem0ai` if not already present at the pinned version. | | TypeScript / JavaScript | `npm install` (or `pnpm install` / `yarn install` if detected by lockfile). |

If install fails → exit code 2 with stderr tail. Never move to testing if dependencies don't resolve.

3. Static sanity checks (fast, local, no API calls)

• **Import check**: does the write-site file import the expected Mem0

surface? Authoritative list comes from `## Identify the User's Setup` in `https://docs.mem0.ai/llms.txt`:

• Platform Python → `from mem0 import MemoryClient`
• Platform TS → `import MemoryClient from "mem0ai"`
• OSS Python → `from mem0 import Memory`
• OSS TS → `import { Memory } from "mem0ai/oss"`

If `plan.md` names a delegated skill (e.g., Vercel AI), use *that* skill's import signature instead of the list above. Mismatch → fail with line number.

• **Version check**: installed `mem0ai` version falls in the range from

this skill's `mem0_tested_versions`. Out of range → warn but continue.

• **Type check** (TS tracks only): run `tsc --noEmit` or `tsup --dts`.

Non-zero → fail.

• **Lint** (if the repo has a linter configured): run the repo's own

lint command. Lint failures from this skill's changes → fail; pre-existing lint failures → surface as a warning.

• **Eager-init check**: grep the `write_site` and `read_site` files (paths

from `product.json`) for `MemoryClient(` or `Memory(` at module scope — i.e., not inside a function, method, o