@agentmemory/agentmemory 0.9.27 → 0.9.29

package/docker-compose.yml

@@ -9,7 +9,7 @@ services:
     image: busybox:1.36
     user: "0:0"
     volumes:
-      - iii-data:/data
+      - "${AGENTMEMORY_DATA_DIR:-iii-data}:/data"
     entrypoint: ["sh", "-c", "chown -R 65532:65532 /data && chmod 755 /data"]
     restart: "no"
 
@@ -34,7 +34,7 @@ services:
       - "127.0.0.1:3112:3112"
       - "127.0.0.1:9464:9464"
     volumes:
-      - iii-data:/data
+      - "${AGENTMEMORY_DATA_DIR:-iii-data}:/data"
       - ./iii-config.docker.yaml:/app/config.yaml:ro
     restart: unless-stopped
     logging:

package/integrations/pi/README.md

@@ -0,0 +1,77 @@
+<p align="center">
+  <img src="../../assets/banner.png" alt="agentmemory" width="640" />
+</p>
+
+<h1 align="center">
+  &nbsp;agentmemory for pi
+</h1>
+
+<p align="center">
+  <strong>Your pi sessions remember everything. No more re-explaining.</strong><br/>
+  <sub>Persistent cross-session memory via <a href="https://github.com/rohitg00/agentmemory">agentmemory</a> — shared with Claude Code, Codex CLI, Gemini CLI, Hermes, OpenClaw, and more.</sub>
+</p>
+
+---
+
+## Quick setup
+
+Start the agentmemory server in a separate terminal:
+
+```bash
+npx @agentmemory/agentmemory
+```
+
+Copy this folder into pi's global extensions directory:
+
+```bash
+mkdir -p ~/.pi/agent/extensions/agentmemory
+cp integrations/pi/index.ts ~/.pi/agent/extensions/agentmemory/index.ts
+```
+
+Then enable it in `~/.pi/agent/settings.json` if you prefer explicit loading:
+
+```json
+{
+  "extensions": ["~/.pi/agent/extensions/agentmemory"]
+}
+```
+
+If you place it under `~/.pi/agent/extensions/agentmemory/`, pi will also auto-discover it and `/reload` can hot-reload it.
+
+## What it adds
+
+- `memory_health` — confirm the shared memory server is reachable
+- `memory_search` — search prior decisions, bugs, workflows, and preferences
+- `memory_save` — write durable facts back to long-term memory
+- `/agentmemory-status` — check health from inside pi
+- `before_agent_start` recall — injects relevant memories into the prompt
+- `agent_end` capture — saves completed conversation turns back to agentmemory
+
+## Environment variables
+
+| Variable | Default | Description |
+|---|---|---|
+| `AGENTMEMORY_URL` | `http://localhost:3111` | agentmemory server URL |
+| `AGENTMEMORY_SECRET` | (none) | Bearer token for protected instances |
+| `AGENTMEMORY_REQUIRE_HTTPS` | (off) | When set to `1`, refuse to send a bearer token over plaintext HTTP to a non-loopback host. Sends the token only when `AGENTMEMORY_URL` is `https://...` or points at `localhost`/`127.0.0.1`/`::1`. With this off, the plugin warns once but still sends. |
+
+## Smoke test
+
+Run pi and ask it to use the `memory_health` tool, or call the command directly:
+
+```text
+/agentmemory-status
+```
+
+You should see `agentmemory healthy` and a footer status like `🧠 agentmemory`.
+
+## Notes
+
+- This extension uses pi's extension API, not MCP, so it can hook directly into the agent lifecycle.
+- One local agentmemory server can be shared across pi, pi2, Hermes, OpenClaw, Claude Code, Codex CLI, and Gemini CLI.
+
+## See also
+
+- [agentmemory main README](../../README.md)
+- [Hermes integration](../hermes/README.md)
+- [OpenClaw integration](../openclaw/README.md)

package/integrations/pi/index.ts

@@ -0,0 +1,403 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import path from "node:path";
+import crypto from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { createPlaintextBearerAuthGuard } from "./security.js";
+
+type TextBlock = { type?: string; text?: string };
+type AssistantMessage = { role?: string; content?: unknown };
+type SmartSearchResult = {
+  title?: string;
+  narrative?: string;
+  type?: string;
+  combinedScore?: number;
+  score?: number;
+  observation?: {
+    title?: string;
+    narrative?: string;
+    type?: string;
+  };
+};
+
+type HealthResponse = {
+  status?: string;
+  service?: string;
+  version?: string;
+  health?: {
+    status?: string;
+    notes?: string[];
+  };
+};
+
+const DEFAULT_URL = process.env.AGENTMEMORY_URL || "http://localhost:3111";
+const guardPlaintextBearerAuth = createPlaintextBearerAuthGuard();
+const TOOL_GUIDANCE = [
+  "agentmemory is available for cross-session memory.",
+  "Use memory_search to recall prior decisions, preferences, bugs, and workflows.",
+  "Use memory_save when you discover durable facts worth remembering beyond this session.",
+].join(" ");
+
+function normalizeBaseUrl(url: string): string {
+  return url.replace(/\/+$/, "");
+}
+
+function getText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .flatMap((part) => {
+      if (!part || typeof part !== "object") return [] as string[];
+      const block = part as TextBlock;
+      if (block.type === "text" && typeof block.text === "string") return [block.text];
+      return [] as string[];
+    })
+    .join("\n")
+    .trim();
+}
+
+function getLastAssistantText(messages: unknown[]): string {
+  for (const msg of [...messages].reverse()) {
+    if (!msg || typeof msg !== "object") continue;
+    const assistant = msg as AssistantMessage;
+    if (assistant.role !== "assistant") continue;
+    const text = getText(assistant.content);
+    if (text) return text;
+  }
+  return "";
+}
+
+function formatSearchResults(results: SmartSearchResult[]): string {
+  if (!results.length) return "No relevant memories found.";
+  return results
+    .slice(0, 5)
+    .map((result, index) => {
+      const obs = result.observation ?? result;
+      const title = obs.title?.trim() || `Memory ${index + 1}`;
+      const narrative = obs.narrative?.trim() || "";
+      const type = obs.type?.trim() || "memory";
+      const score = result.combinedScore ?? result.score;
+      const scoreText = typeof score === "number" ? ` [score=${score.toFixed(3)}]` : "";
+      return `- ${title} (${type})${scoreText}${narrative ? `: ${narrative}` : ""}`;
+    })
+    .join("\n");
+}
+
+async function callAgentMemory<T>(
+  pathname: string,
+  options?: {
+    method?: "GET" | "POST";
+    body?: unknown;
+    baseUrl?: string;
+    timeoutMs?: number;
+  },
+): Promise<T | null> {
+  const baseUrl = normalizeBaseUrl(options?.baseUrl || process.env.AGENTMEMORY_URL || DEFAULT_URL);
+  const method = options?.method || "POST";
+  const url = `${baseUrl}/agentmemory/${pathname.replace(/^\/+/, "")}`;
+  const headers: Record<string, string> = {};
+  const secret = process.env.AGENTMEMORY_SECRET;
+  guardPlaintextBearerAuth(baseUrl, secret);
+  if (options?.body !== undefined) headers["Content-Type"] = "application/json";
+  if (secret) headers.Authorization = `Bearer ${secret}`;
+
+  try {
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+      signal: options?.timeoutMs ? AbortSignal.timeout(options.timeoutMs) : undefined,
+    });
+    if (!response.ok) return null;
+    return (await response.json()) as T;
+  } catch {
+    return null;
+  }
+}
+
+export default function agentmemoryExtension(pi: ExtensionAPI) {
+  if (process.env.AGENTMEMORY_REQUIRE_HTTPS === "1") {
+    guardPlaintextBearerAuth(
+      normalizeBaseUrl(process.env.AGENTMEMORY_URL || DEFAULT_URL),
+      process.env.AGENTMEMORY_SECRET,
+    );
+  }
+  let sessionId = `ephemeral-${crypto.randomUUID().slice(0, 8)}`;
+  // Canonical project scope, matching the hooks' resolveProject order (env
+  // override, git toplevel basename, cwd basename) so Pi sessions share a
+  // project bucket with every other agent instead of scoping on a raw path.
+  const projectCache = new Map<string, string>();
+  function resolveProjectName(dir: string): string {
+    const explicit = process.env["AGENTMEMORY_PROJECT_NAME"]?.trim();
+    if (explicit) return explicit;
+    const cached = projectCache.get(dir);
+    if (cached) return cached;
+    let name = path.basename(dir) || dir;
+    try {
+      const top = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+        cwd: dir,
+        stdio: ["ignore", "pipe", "ignore"],
+        encoding: "utf8",
+      }).trim();
+      if (top) name = path.basename(top);
+    } catch {
+      // not a git repo
+    }
+    projectCache.set(dir, name);
+    return name;
+  }
+  let currentCwd = process.cwd();
+  let currentProject = resolveProjectName(currentCwd);
+  let lastPrompt = "";
+  let lastHealthOk = false;
+
+  const toolObserveEnabled = process.env.AGENTMEMORY_TOOL_OBSERVE !== "0";
+
+  // Skips the round-trip when an auto-retry re-submits an identical prompt.
+  const DEDUP_WINDOW_MS = 5 * 60 * 1000;
+  const recentHashes = new Map<string, number>();
+  function isDuplicate(data: string): boolean {
+    const hash = crypto.createHash("sha256").update(data).digest("hex");
+    const now = Date.now();
+    const prev = recentHashes.get(hash);
+    if (prev !== undefined && now - prev < DEDUP_WINDOW_MS) return true;
+    if (recentHashes.size > 500) {
+      for (const [key, ts] of recentHashes) {
+        if (now - ts >= DEDUP_WINDOW_MS) recentHashes.delete(key);
+      }
+    }
+    recentHashes.set(hash, now);
+    return false;
+  }
+
+  async function getHealth() {
+    return await callAgentMemory<HealthResponse>("health", { method: "GET" });
+  }
+
+  async function refreshStatus(ctx: { ui: { setStatus: (key: string, text: string) => void } }) {
+    // Bind before the await: ctx goes stale if the session is replaced.
+    let setStatus: (key: string, text: string) => void;
+    try {
+      const ui = ctx.ui;
+      setStatus = ui.setStatus.bind(ui);
+    } catch {
+      return;
+    }
+    const health = await getHealth();
+    lastHealthOk =
+      !!health &&
+      (health.status === "ok" ||
+        health.status === "healthy" ||
+        health.health?.status === "healthy");
+    try {
+      setStatus("agentmemory", lastHealthOk ? "🧠 agentmemory" : "🧠 agentmemory off");
+    } catch {
+      // status is best-effort
+    }
+  }
+
+  pi.registerCommand("agentmemory-status", {
+    description: "Check local agentmemory server health",
+    handler: async (_args, ctx) => {
+      const health = await getHealth();
+      if (!health) {
+        ctx.ui.notify("agentmemory is unreachable at http://localhost:3111", "warning");
+        return;
+      }
+      ctx.ui.notify(
+        `agentmemory ${health.status || health.health?.status || "unknown"}${health.version ? ` v${health.version}` : ""}`,
+        "info",
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "memory_health",
+    label: "Memory Health",
+    description: "Check whether the local agentmemory server is reachable and healthy",
+    parameters: Type.Object({}),
+    async execute() {
+      const health = await getHealth();
+      if (!health) {
+        return {
+          content: [{ type: "text", text: "agentmemory is unreachable at http://localhost:3111" }],
+          details: { ok: false },
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `agentmemory status: ${health.status || health.health?.status || "unknown"}${health.version ? ` (v${health.version})` : ""}`,
+          },
+        ],
+        details: health,
+      };
+    },
+  });
+
+  pi.registerTool({
+    name: "memory_search",
+    label: "Memory Search",
+    description: "Search agentmemory for cross-session project memory, prior decisions, bugs, and user preferences",
+    parameters: Type.Object({
+      query: Type.String({ description: "What to search for in memory" }),
+      limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 10, default: 5, description: "Maximum results" })),
+    }),
+    async execute(_toolCallId, params) {
+      const result = await callAgentMemory<{ results?: SmartSearchResult[] }>("smart-search", {
+        body: { query: params.query, limit: params.limit ?? 5, project: currentProject },
+      });
+      const results = result?.results || [];
+      return {
+        content: [{ type: "text", text: formatSearchResults(results) }],
+        details: { query: params.query, results },
+      };
+    },
+  });
+
+  pi.registerTool({
+    name: "memory_save",
+    label: "Memory Save",
+    description: "Save a durable fact, convention, workflow, preference, or bug fix into agentmemory",
+    parameters: Type.Object({
+      content: Type.String({ description: "What should be remembered" }),
+      type: Type.Optional(
+        Type.String({
+          description: "Memory type",
+          default: "fact",
+        }),
+      ),
+    }),
+    async execute(_toolCallId, params) {
+      const result = await callAgentMemory<Record<string, unknown>>("remember", {
+        body: { content: params.content, type: params.type || "fact", project: currentProject },
+      });
+      if (!result) {
+        return {
+          content: [{ type: "text", text: "Failed to save memory to agentmemory." }],
+          details: { ok: false },
+        };
+      }
+      return {
+        content: [{ type: "text", text: `Saved memory (${params.type || "fact"}): ${params.content}` }],
+        details: result,
+      };
+    },
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    const sessionFile = ctx.sessionManager.getSessionFile();
+    sessionId = sessionFile ? path.basename(sessionFile).replace(/\.[^.]+$/, "") : `ephemeral-${crypto.randomUUID().slice(0, 8)}`;
+    currentCwd = process.cwd();
+    currentProject = resolveProjectName(currentCwd);
+    await refreshStatus(ctx);
+    // After refreshStatus: that is where lastHealthOk is first populated.
+    if (lastHealthOk) {
+      await callAgentMemory("session/start", {
+        body: { sessionId, project: currentProject, cwd: currentCwd },
+      });
+    }
+  });
+
+  pi.on("before_agent_start", async (event, ctx) => {
+    currentCwd = event.systemPromptOptions.cwd || process.cwd();
+    currentProject = resolveProjectName(currentCwd);
+    lastPrompt = event.prompt?.trim() || "";
+    if (!lastPrompt) return;
+
+    if (lastHealthOk && !isDuplicate(`prompt_submit:${sessionId}:${lastPrompt}`)) {
+      void callAgentMemory("observe", {
+        body: {
+          hookType: "prompt_submit",
+          sessionId,
+          project: currentProject,
+          cwd: currentCwd,
+          timestamp: new Date().toISOString(),
+          data: { prompt: lastPrompt },
+        },
+      });
+    }
+
+    const result = await callAgentMemory<{ results?: SmartSearchResult[] }>("smart-search", {
+      body: { query: lastPrompt, limit: 5, project: currentProject },
+    });
+    const results = result?.results || [];
+    const recallBlock = results.length
+      ? [
+          "Relevant long-term memory from agentmemory:",
+          formatSearchResults(results),
+        ].join("\n")
+      : "";
+
+    await refreshStatus(ctx);
+    return {
+      systemPrompt: [event.systemPrompt, TOOL_GUIDANCE, recallBlock].filter(Boolean).join("\n\n"),
+    };
+  });
+
+  pi.on("tool_result", (event) => {
+    if (!toolObserveEnabled || !lastHealthOk || !sessionId) return;
+    const toolName = event.toolName;
+    if (!toolName) return;
+    let input = "";
+    try {
+      input = typeof event.input === "string" ? event.input : JSON.stringify(event.input ?? {});
+    } catch {
+      // non-serializable
+    }
+    let output = "";
+    try {
+      output = typeof event.content === "string" ? event.content : JSON.stringify(event.content ?? "");
+    } catch {
+      // non-serializable
+    }
+    void callAgentMemory("observe", {
+      body: {
+        hookType: "post_tool_use",
+        sessionId,
+        project: currentProject,
+        cwd: currentCwd,
+        timestamp: new Date().toISOString(),
+        data: {
+          tool_name: toolName,
+          tool_input: input.slice(0, 8000),
+          tool_output: output.slice(0, 8000),
+          ...(event.isError ? { tool_error: true } : {}),
+        },
+      },
+    });
+  });
+
+  pi.on("agent_end", async (event) => {
+    if (!lastHealthOk || !lastPrompt) return;
+    const assistantText = getLastAssistantText(event.messages as unknown[]);
+    if (!assistantText) return;
+    void callAgentMemory("observe", {
+      body: {
+        hookType: "post_tool_use",
+        sessionId,
+        project: currentProject,
+        cwd: currentCwd,
+        timestamp: new Date().toISOString(),
+        data: {
+          tool_name: "conversation",
+          tool_input: lastPrompt.slice(0, 8000),
+          tool_output: assistantText.slice(0, 8000),
+        },
+      },
+    });
+  });
+
+  pi.on("session_shutdown", async (event) => {
+    // /new, /resume, /fork and reloads fire this too; only quit ends the session.
+    if (event.reason !== "quit") return;
+    if (!lastHealthOk || !sessionId) return;
+    // session/end already fans out the summary server-side (#1203).
+    await callAgentMemory("session/end", {
+      body: { sessionId },
+      timeoutMs: 5_000,
+    });
+    void callAgentMemory("consolidate", { body: {} });
+  });
+}

package/integrations/pi/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "agentmemory-pi-extension",
+  "version": "0.1.0",
+  "private": true,
+  "description": "agentmemory extension for the pi coding agent: memory recall on agent start, capture on agent end, memory_search / memory_save / memory_health tools, /agentmemory-status command",
+  "type": "module",
+  "license": "Apache-2.0",
+  "keywords": [
+    "pi-package",
+    "agentmemory",
+    "memory"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rohitg00/agentmemory.git",
+    "directory": "integrations/pi"
+  },
+  "files": [
+    "index.ts",
+    "security.ts",
+    "README.md"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  }
+}

package/integrations/pi/security.ts

@@ -0,0 +1,35 @@
+const LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "::1"]);
+
+function normalizedHostname(hostname: string): string {
+  return hostname.replace(/^\[|\]$/g, "").toLowerCase();
+}
+
+export function usesPlaintextBearerAuth(baseUrl: string, secret?: string): boolean {
+  if (!secret) return false;
+  try {
+    const parsed = new URL(baseUrl);
+    return parsed.protocol === "http:" && !LOOPBACK_HOSTS.has(normalizedHostname(parsed.hostname));
+  } catch {
+    return false;
+  }
+}
+
+export function plaintextBearerAuthMessage(baseUrl: string): string {
+  return `agentmemory: AGENTMEMORY_SECRET is configured for plaintext HTTP to ${baseUrl}. Bearer tokens and memory payloads can be observed on the network; use HTTPS or an SSH tunnel.`;
+}
+
+export function createPlaintextBearerAuthGuard(
+  warn: (message: string) => void = (message) => console.warn(message),
+  env?: { AGENTMEMORY_REQUIRE_HTTPS?: string },
+): (baseUrl: string, secret?: string) => void {
+  let warned = false;
+  return (baseUrl, secret) => {
+    if (!usesPlaintextBearerAuth(baseUrl, secret)) return;
+    const message = plaintextBearerAuthMessage(baseUrl);
+    if ((env || process.env).AGENTMEMORY_REQUIRE_HTTPS === "1") throw new Error(message);
+    if (!warned) {
+      warned = true;
+      warn(message);
+    }
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentmemory/agentmemory",
-  "version": "0.9.27",
+  "version": "0.9.29",
   "description": "Persistent memory for AI coding agents, powered by iii-engine's three primitives",
   "type": "module",
   "main": "dist/index.mjs",
@@ -25,6 +25,8 @@
     "test:watch": "vitest --exclude test/integration.test.ts",
     "test:integration": "vitest run test/integration.test.ts",
     "test:all": "vitest run",
+    "skills:gen": "tsx scripts/skills/generate.ts",
+    "skills:check": "tsx scripts/skills/generate.ts --check && tsx scripts/skills/check.ts",
     "bench:load": "node --import tsx benchmark/load-100k.ts",
     "eval:longmemeval": "tsx eval/runner/longmemeval.ts",
     "eval:coding-life": "tsx eval/runner/coding-life.ts"
@@ -43,6 +45,7 @@
   "files": [
     "dist/",
     "plugin/",
+    "integrations/pi/",
     "iii-config.yaml",
     "iii-config.docker.yaml",
     "docker-compose.yml",
@@ -63,13 +66,12 @@
     "@clack/prompts": "^1.2.0",
     "dotenv": "^17.4.2",
     "iii-sdk": "0.11.2",
+    "picocolors": "^1.1.1",
     "zod": "^4.0.0"
   },
   "optionalDependencies": {
+    "@huggingface/transformers": "^4.2.0",
     "@node-rs/jieba": "^2.0.1",
-    "@xenova/transformers": "^2.17.2",
-    "onnxruntime-node": "^1.14.0",
-    "onnxruntime-web": "^1.14.0",
     "tiny-segmenter": "^0.2.0"
   },
   "devDependencies": {

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agentmemory",
-  "version": "0.9.27",
-  "description": "Persistent memory for AI coding agents -- captures tool usage, compresses via LLM, injects context into future sessions. 12 hooks, 53 MCP tools, 8 skills, real-time viewer.",
+  "version": "0.9.29",
+  "description": "Persistent memory for AI coding agents -- captures tool usage, compresses via LLM, injects context into future sessions. 12 hooks, 54 MCP tools, 8 skills, real-time viewer.",
   "author": {
     "name": "Rohit Ghumare",
     "url": "https://github.com/rohitg00"

package/plugin/.codex-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agentmemory",
-  "version": "0.9.27",
-  "description": "Persistent memory for AI coding agents -- captures tool usage, compresses via LLM, injects context into future sessions. 6 hooks, 53 MCP tools, 8 skills, real-time viewer.",
+  "version": "0.9.29",
+  "description": "Persistent memory for AI coding agents -- captures tool usage, compresses via LLM, injects context into future sessions. 6 hooks, 54 MCP tools, 8 skills, real-time viewer.",
   "author": {
     "name": "Rohit Ghumare",
     "url": "https://github.com/rohitg00"

package/plugin/.devin-plugin/plugin.json

@@ -0,0 +1,32 @@
+{
+  "name": "agentmemory",
+  "version": "0.9.29",
+  "description": "Persistent memory for AI coding agents. Captures sessions, recalls with hybrid BM25 + vector + graph search, and exposes 54 memory tools over MCP. Keyless by default, runs on your machine.",
+  "author": {
+    "name": "Rohit Ghumare",
+    "email": "ghumare64@gmail.com"
+  },
+  "homepage": "https://agent-memory.dev",
+  "repository": "https://github.com/rohitg00/agentmemory",
+  "license": "Apache-2.0",
+  "keywords": [
+    "memory",
+    "mcp",
+    "recall",
+    "knowledge-graph",
+    "agent-memory"
+  ],
+  "mcpServers": {
+    "agentmemory": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@agentmemory/mcp"
+      ],
+      "env": {
+        "AGENTMEMORY_URL": "${AGENTMEMORY_URL:-http://localhost:3111}",
+        "AGENTMEMORY_SECRET": "${AGENTMEMORY_SECRET:-}"
+      }
+    }
+  }
+}