remem-mcp 0.6.2 → 0.6.4

package/scripts/dogfood-codex.sh

@@ -0,0 +1,145 @@
+#!/usr/bin/env bash
+# dogfood-codex.sh — dogfood remem-mcp using OpenAI Codex CLI as the agent
+# Codex CLI gets remem-mcp as its MCP server, then works on remem-mcp's own codebase.
+#
+# Usage: bash scripts/dogfood-codex.sh [max_iterations] [model]
+# Example: bash scripts/dogfood-codex.sh 3 gpt-5-codex
+
+set -euo pipefail
+cd "$(dirname "$0")/.."
+
+MAX_ITER="${1:-3}"
+MODEL="${2:-gpt-5.5}"
+REPO_DIR="$(pwd)"
+TMP_DIR="/tmp/remem-dogfood-codex"
+mkdir -p "$TMP_DIR"
+
+echo "══════════════════════════════════════════════════════════════"
+echo "  🐕 DOGFOOD WITH CODEX CLI"
+echo "  Repo:       $REPO_DIR"
+echo "  Model:      $MODEL"
+echo "  Iterations: $MAX_ITER"
+echo "  MCP:        remem-mcp (already configured via 'codex mcp list')"
+echo "══════════════════════════════════════════════════════════════"
+echo ""
+
+# Build first
+echo "[build] Compiling..."
+npm run build 2>&1 | tail -1
+echo ""
+
+# Verify remem-mcp is configured for Codex
+if ! codex mcp list 2>&1 | grep -q "remem-mcp"; then
+  echo "⚠ remem-mcp not configured for Codex. Adding it now..."
+  codex mcp add remem-mcp \
+    --env "REMEM_DB_PATH=$HOME/.local/share/remem-mcp/memory.db" \
+    --env "REMEM_GLOBAL_SESSION_KEY=global" \
+    --env "REMEM_AUTO_GLOBAL=true" \
+    -- node "$REPO_DIR/dist/index.js"
+fi
+
+ITER=0
+while [ "$ITER" -lt "$MAX_ITER" ]; do
+  ITER=$((ITER + 1))
+  echo ""
+  echo "────────────────────────────────────────────────────────────"
+  echo "  ITERATION $ITER/$MAX_ITER"
+  echo "────────────────────────────────────────────────────────────"
+
+  # 1. Snapshot current state
+  echo ""
+  echo "[1/4] State snapshot:"
+  TS_ERRS=$(npx tsc --noEmit 2>&1 | grep -c "error TS" | tr -d '[:space:]' || echo "0")
+  TEST_OUT=$(npx vitest run 2>&1 || true)
+  TEST_FAILS=$(echo "$TEST_OUT" | grep -oE "[0-9]+ failed" | head -1 | grep -oE "[0-9]+" | tr -d '[:space:]' || echo "0")
+  TEST_PASSES=$(echo "$TEST_OUT" | grep -oE "[0-9]+ passed" | head -1 | grep -oE "[0-9]+" | tr -d '[:space:]' || echo "0")
+  [ -z "$TS_ERRS" ] && TS_ERRS=0
+  [ -z "$TEST_FAILS" ] && TEST_FAILS=0
+  [ -z "$TEST_PASSES" ] && TEST_PASSES=0
+  echo "  TS errors: $TS_ERRS | Tests: $TEST_PASSES passed, $TEST_FAILS failed"
+
+  # 2. Capture errors to feed Codex context
+  ERR_FILE="$TMP_DIR/errors-iter-$ITER.txt"
+  {
+    echo "## Build errors (iteration $ITER)"
+    npm run build 2>&1 | grep -i "error\|fail" | head -20 || echo "none"
+    echo ""
+    echo "## TypeScript errors"
+    npx tsc --noEmit 2>&1 | grep "error TS" | head -20 || echo "none"
+    echo ""
+    echo "## Test failures"
+    echo "$TEST_OUT" | grep -B2 "FAIL\|AssertionError\|Error:" | head -30 || echo "none"
+  } > "$ERR_FILE" 2>&1
+
+  ERR_COUNT=$(grep -c "error\|fail\|FAIL" "$ERR_FILE" 2>/dev/null || echo "0")
+  echo "  Error file: $ERR_FILE ($ERR_COUNT lines with errors)"
+
+  # 3. Run Codex CLI
+  echo ""
+  echo "[2/4] Launching Codex CLI (model=$MODEL)..."
+
+  PROMPT="You are working on the remem-mcp codebase (a local MCP memory server at $REPO_DIR).
+
+Current state:
+- TypeScript errors: $TS_ERRS
+- Test failures: $TEST_FAILS (out of $TEST_PASSES passed)
+
+Error details from this iteration:
+$(cat "$ERR_FILE")
+
+Your tasks:
+1. Use the remem-mcp MCP tools (recall, search) to check if we've seen these errors before and how we fixed them.
+2. Fix the TypeScript errors and test failures shown above.
+3. After fixing, run \`npm run build\` and \`npx vitest run\` to verify.
+4. Use the remem-mcp capture tool to store what you fixed and how, so future sessions can recall it.
+5. If everything passes, look for edge cases or potential bugs in the codebase and fix them.
+
+Focus on real fixes, not workarounds. Check src/ for the relevant code."
+
+  codex exec \
+    --model "$MODEL" \
+    --sandbox workspace-write \
+    --dangerously-bypass-approvals-and-sandbox \
+    "$PROMPT" \
+    2>&1 | tee "$TMP_DIR/codex-output-iter-$ITER.log" || true
+
+  echo ""
+  echo "[3/4] Codex CLI finished. Output saved to $TMP_DIR/codex-output-iter-$ITER.log"
+
+  # 4. Re-check state after Codex's fixes
+  echo ""
+  echo "[4/4] Post-fix state:"
+  TS_ERRS_AFTER=$(npx tsc --noEmit 2>&1 | grep -c "error TS" | tr -d '[:space:]' || echo "0")
+  TEST_OUT_AFTER=$(npx vitest run 2>&1 || true)
+  TEST_FAILS_AFTER=$(echo "$TEST_OUT_AFTER" | grep -oE "[0-9]+ failed" | head -1 | grep -oE "[0-9]+" | tr -d '[:space:]' || echo "0")
+  TEST_PASSES_AFTER=$(echo "$TEST_OUT_AFTER" | grep -oE "[0-9]+ passed" | head -1 | grep -oE "[0-9]+" | tr -d '[:space:]' || echo "0")
+  [ -z "$TS_ERRS_AFTER" ] && TS_ERRS_AFTER=0
+  [ -z "$TEST_FAILS_AFTER" ] && TEST_FAILS_AFTER=0
+  [ -z "$TEST_PASSES_AFTER" ] && TEST_PASSES_AFTER=0
+
+  echo "  TS errors: $TS_ERRS → $TS_ERRS_AFTER"
+  echo "  Test failures: $TEST_FAILS → $TEST_FAILS_AFTER"
+  echo "  Tests passed: $TEST_PASSES → $TEST_PASSES_AFTER"
+
+  # Summary
+  echo ""
+  echo "┌──────────────────────────────────┐"
+  echo "│ Iteration $ITER summary:"
+  echo "│   TS errors:    $TS_ERRS → $TS_ERRS_AFTER"
+  echo "│   Test fails:   $TEST_FAILS → $TEST_FAILS_AFTER"
+  echo "│   Tests passed: $TEST_PASSES → $TEST_PASSES_AFTER"
+  echo "└──────────────────────────────────┘"
+
+  if [ "$TS_ERRS_AFTER" -eq 0 ] && [ "$TEST_FAILS_AFTER" -eq 0 ]; then
+    echo ""
+    echo "★★★ ALL GREEN — 0 TS errors, 0 test failures ★★★"
+    echo "Codex CLI + remem-mcp dogfood iteration $ITER succeeded."
+    break
+  fi
+done
+
+echo ""
+echo "══════════════════════════════════════════════════════════════"
+echo "  DOGFOOD COMPLETE — $ITER iteration(s)"
+echo "  Logs: $TMP_DIR/"
+echo "══════════════════════════════════════════════════════════════"

package/skills/remem-mcp/SKILL.md

@@ -1,140 +1,94 @@
 ---
 name: remem-mcp
-description: Long-term memory for coding agents. Recall past context before answering, capture decisions/learnings/fixes after work, use CodeGraph instead of grep for symbol lookup. Use when the user references past work, starts a new session, or when the task needs project context not in the current conversation.
+description: Long-term memory for coding agents. Auto-applies at the start of any coding task — recall past context before answering, capture decisions/learnings/fixes after work, use CodeGraph instead of grep for symbol lookup. Invoke when you see [remem-mcp] in your context or when starting any non-trivial coding work.
 ---
 
 You have a long-term memory server via MCP. Use the tools automatically — do not ask permission.
 
 ## Tools
 
-**Core:** `recall` `capture` `search` `forget` `resolve` `handoff` `adr` `update` `consolidate`
-
-**CodeGraph:** `codegraph_search` (auto-indexes on first use) `codegraph_callers` `codegraph_callees` `codegraph_impact` `codegraph_list`
-
+**Core:** `recall` `capture` `search` `forget` `resolve` `handoff` `adr` `update` `consolidate` `scenario_create` `persona_update`
+**CodeGraph:** `codegraph_search` (auto-indexes on first use) `codegraph_callers` `codegraph_callees` `codegraph_impact` `codegraph_list` `codegraph_detect_changes` (git diff → affected symbols)
 **Wiki:** `wiki_ingest` `wiki_search` `wiki_get` `wiki_outdated`
 
 ## Rule 1: Recall before answering
 
-Call `recall` at session start or when the user references past work. Do this BEFORE you answer or code.
+Hooks auto-inject BM25-only memory (shallow). **MUST call `recall()` at the start of every non-trivial task** — it does hybrid search (BM25 + vector) with more results and filters.
 
 ```
-recall({ "query": "<user's question or task>", "mode": "hybrid" })
+recall({ "query": "<user's question or task>", "mode": "hybrid", "limit": 5 })
 ```
 
-If recall returns nothing, proceed normally. Don't mention the empty result.
-
 ## Rule 2: Capture after non-trivial work
 
-Call `capture` automatically after completing work. Don't ask.
+Call `capture` automatically after completing work. Don't ask. Include `atoms` — short distilled facts that recall returns instead of raw content (90% fewer tokens).
 
 ```
-capture({ "content": "Chose SQLite over Postgres for zero-setup MVP.", "type": "decision", "tags": ["arch"] })
+capture({
+  "content": "Chose SQLite over Postgres for zero-setup MVP. SQLite has FTS5 + sqlite-vec built in, no server needed.",
+  "type": "decision",
+  "tags": ["arch"],
+  "atoms": ["Use SQLite (not Postgres) for zero-setup MVP", "SQLite has FTS5 + sqlite-vec built in"]
+})
 ```
 
-**Types:** `decision` (chose X over Y, include why) · `learning` (non-obvious fact) · `task` (completed work) · `error` (bug + root cause + fix) · `conversation` (multi-turn, pass `messages`)
+**Types:** `decision` (chose X over Y, include why) · `learning` (non-obvious fact) · `task` (completed work) · `error` (bug + root cause + fix)
 
-**Good:** specific, useful later. **Bad:** "We talked about the database."
+**Atoms:** 1-3 short self-contained facts. Each useful on its own without the raw content. Write for decisions, learnings, errors. Skip for conversations.
 
-## Rule 3: Use CodeGraph instead of grep
+## Rule 3: Consolidate atoms into scenarios (L2)
 
-For function/class/method definitions, call `codegraph_search` — NOT grep. It auto-indexes `src/` on first use, no setup needed.
+When you have 5+ atoms about the same topic, call `scenario_create` to create a high-signal summary. Recall injects scenarios automatically (~100 tokens instead of 5+ atoms).
 
 ```
-codegraph_search({ "query": "handleCapture" })
-codegraph_callers({ "symbol_id": "<id from search>" })
-codegraph_impact({ "symbol_id": "<id>" })  // before modifying a function
+scenario_create({
+  "atom_ids": ["01...", "01...", "01..."],
+  "summary": "Database: SQLite chosen for MVP — FTS5 + sqlite-vec built in, zero setup, no server needed.",
+  "persona_tags": ["database", "arch"]
+})
 ```
 
-Use grep only for: string literals, config values, file names.
-
-## Rule 4: Handoff when switching agents
-
-Call `handoff` at session end or before switching agents. Creates a packet the next agent loads via `recall`.
+**When:** After capturing 5+ decisions/learnings about the same topic (e.g., database, hooks, deployment).
 
-```
-handoff({ "task": "Fix auth bug", "status": "in_progress", "progress": "Found root cause", "next_steps": ["Implement fix"] })
-```
+**Auto-pipeline:** The Stop hook spawns a background worker that auto-extracts L1 atoms from uncaptured L0 entries, auto-consolidates 5+ atoms on the same topic into L2 scenarios, and auto-updates L3 persona from repeated tags. You don't need to call `scenario_create` or `persona_update` manually — the worker does it. Only call them manually if you want a specific summary the worker wouldn't generate.
 
-Skip if task is done or trivial.
+## Rule 4: Update persona (L3)
 
-## Rule 5: Forget only on explicit request
-
-Call `forget` ONLY when the user asks to delete. Always require `confirm: true`.
+When you notice a user preference or pattern (2+ occurrences), call `persona_update`. SessionStart AND UserPromptSubmit inject persona automatically every turn (~50 tokens).
 
 ```
-forget({ "id": "<id>", "confirm": true, "reject": true, "reason": "Wrong: port is 9090 not 8080." })
+persona_update({ "trait": "language", "value": "Vietnamese" })
+persona_update({ "trait": "output_style", "value": "concise" })
 ```
 
-`reject: true` tombstones the content hash — blocks re-capture of wrong info.
-
-## Trust states
+**When:** User asks for concise output 2+ times, works in a specific language, prefers a framework, uses a specific project.
 
-- `candidate` (default) → `verified` (confirmed correct) → `stale` (replaced, via `resolve` or `supersedes`) → `rejected` (wrong, via `forget`)
-- Use `resolve` when two captures conflict. Use `supersedes` on `capture` to replace an old value.
-
-## ADR for architectural decisions
-
-Use `adr` (not `capture`) for decisions with context, alternatives, and consequences.
-
-```
-adr({ "title": "Use SQLite", "context": "Need zero-setup", "decision": "SQLite + FTS5 + sqlite-vec", "alternatives": ["Postgres+pgvector", "DuckDB"], "consequences": "Single-writer, no remote access" })
-```
+**Auto-pipeline:** The background worker auto-detects tags appearing 2+ times in captures and appends them to persona. Manual `persona_update` is for explicit user preferences the worker can't detect.
 
-## Search with filters
+## Rule 5: Use CodeGraph instead of grep
 
-Use `search` (not `recall`) when you need specific filters:
+For function/class/method definitions, call `codegraph_search` — NOT grep. Auto-indexes `src/` on first use.
 
 ```
-search({ "query": "auth", "filters": { "type": "decision", "tags": ["arch"] } })
+codegraph_search({ "query": "handleCapture" })
+codegraph_callers({ "symbol_id": "<id from search>" })
+codegraph_detect_changes({ "repo_path": "/abs/path" })  // git diff → affected symbols + risk
 ```
 
-## Update and consolidate
-
-- `update` — correct a capture's content/tags. Preserves ID and created_at.
-- `consolidate` — find and merge duplicates. `consolidate({ "threshold": 0.75 })` to dry-run, add `"confirm": true` to merge.
+CodeGraph uses 6-strategy call resolution (import-map → same-module → unique-name → suffix → fuzzy) with confidence scoring. JSX components (`<FleetMap/>`) and method calls (`obj.method()`) are captured. Stdlib calls (fmt.Printf, console.log) are filtered out.
 
-## Hooks (automatic if installed)
-
-If `npx remem-mcp install-hooks` was run:
-- **SessionStart** — recent captures injected automatically
-- **PreToolUse** — past errors injected before lint/build/test
-- **PostToolUse** — failed commands auto-captured with root cause
-- **SessionEnd** — session summary auto-captured
-
-You can still call tools manually anytime.
+Use grep only for: string literals, config values, file names.
 
-## Multi-tenant
+## Other tools
 
-Pass `team_id`, `agent_id`, `user_id`, or `task_id` to isolate memory between teams/projects.
+- `forget({ "id", "confirm": true })` — only when user asks to delete. `reject: true` blocks re-capture of wrong info.
+- `handoff({ "task", "status", "progress", "next_steps" })` — at session end or before switching agents.
+- `adr({ "title", "context", "decision", "alternatives", "consequences" })` — for architectural decisions.
+- `search({ "query", "filters": { "type", "tags" } })` — when you need specific filters.
+- `resolve` — when two captures conflict. `supersedes` on `capture` replaces old values.
+- `update` — correct a capture's content/tags.
+- `consolidate({ "threshold": 0.75 })` — merge duplicate captures. `scenario_create({ "atom_ids", "summary" })` — create L2 scenario. `persona_update({ "trait", "value" })` — update L3 persona.
 
 ## Global + project memory
 
-Set `REMEM_GLOBAL_SESSION_KEY=global` in MCP config to enable cross-project memory.
-
-**How it works:**
-- `recall` and `search` automatically search both project and global memory. Project results appear first, then global.
-- `session_start` returns recent captures from both project and global sessions.
-- 3 slots are reserved for global results so cross-project knowledge isn't buried when project memory is large.
-
-**When to store global memory:**
-- Pass `session_key="global"` to `capture` for: coding conventions, tool preferences, recurring patterns, lessons that apply to any project.
-- Or pass `auto_global=true` — server auto-classifies: generic rules/learnings → global, content with file paths/line numbers → project.
-- Don't store global: project-specific bugs, file paths, one-off decisions.
-
-**Example:**
-```
-capture(content="Always run tests before committing", type="learning", auto_global=true)
-# → auto-classified as global (no file paths, has "always" signal)
-
-capture(content="Fixed bug in src/server.ts line 1418", type="task", auto_global=true)
-# → stays project (has file path)
-```
-
-## CLI commands
-
-```bash
-npx remem-mcp errors              # Error learning dashboard
-npx remem-mcp extract --limit 50  # L1 atom extraction (needs REMEM_LLM_API_KEY)
-npx remem-mcp sync-export         # Export memory for team (commit to repo)
-npx remem-mcp sync-import         # Import teammate's memory
-```
+Set `REMEM_GLOBAL_SESSION_KEY=global` to enable cross-project memory. `recall`/`search` search both. Pass `auto_global=true` to `capture` for auto-classification (generic → global, file paths → project).