@deeplake/hivemind 0.6.47 → 0.6.48

package/mcp/bundle/server.js

@@ -23943,6 +23943,41 @@ function buildContentFilter(column, likeOp, patterns) {
   return ` AND (${patterns.map((pattern) => `${column} ${likeOp} '%${pattern}%'`).join(" OR ")})`;
 }
 
+// dist/src/cli/version.js
+import { readFileSync as readFileSync5 } from "node:fs";
+import { join as join6 } from "node:path";
+
+// dist/src/cli/util.js
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3, cpSync, symlinkSync, unlinkSync as unlinkSync2, lstatSync } from "node:fs";
+import { join as join5, dirname } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { fileURLToPath } from "node:url";
+var HOME = homedir4();
+function pkgRoot() {
+  return fileURLToPath(new URL("..", import.meta.url));
+}
+var PLATFORM_MARKERS = [
+  { id: "claude", markerDir: join5(HOME, ".claude") },
+  { id: "codex", markerDir: join5(HOME, ".codex") },
+  { id: "claw", markerDir: join5(HOME, ".openclaw") },
+  { id: "cursor", markerDir: join5(HOME, ".cursor") },
+  { id: "hermes", markerDir: join5(HOME, ".hermes") },
+  // pi (badlogic/pi-mono coding-agent) — config at ~/.pi/agent/. pi exposes
+  // a rich extension event API (session_start / input / tool_call /
+  // tool_result / message_end / session_shutdown / etc.) — Tier 1 capable.
+  { id: "pi", markerDir: join5(HOME, ".pi") }
+];
+
+// dist/src/cli/version.js
+function getVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync5(join6(pkgRoot(), "package.json"), "utf-8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
 // dist/src/mcp/server.js
 function getContext() {
   const creds = loadCredentials();
@@ -23961,7 +23996,7 @@ function errorResult(text) {
 }
 var server = new McpServer({
   name: "hivemind",
-  version: "0.6.47"
+  version: getVersion()
 });
 server.registerTool("hivemind_search", {
   description: "Search Hivemind shared memory (summaries + raw sessions) by keyword or multi-word phrase. Returns matching paths and snippets. Use this first when the user asks about prior work, conversations, or context that may exist in Hivemind. Different paths under /summaries/<username>/ are different users \u2014 do not merge them.",
@@ -24037,7 +24072,7 @@ server.registerTool("hivemind_index", {
   const ctx = getContext();
   if ("error" in ctx)
     return errorResult(ctx.error);
-  const where = prefix ? `WHERE path LIKE '${sqlStr(prefix)}%'` : `WHERE path LIKE '/summaries/%'`;
+  const where = prefix ? `WHERE path LIKE '${sqlLike(prefix)}%' ESCAPE '\\'` : `WHERE path LIKE '/summaries/%'`;
   const sql = `SELECT path, description, project, last_update_date FROM "${ctx.memoryTable}" ${where} ORDER BY last_update_date DESC LIMIT ${limit ?? 50}`;
   try {
     const rows = await ctx.api.query(sql);

package/openclaw/dist/index.js

@@ -984,7 +984,7 @@ function extractLatestVersion(body) {
   return typeof v === "string" && v.length > 0 ? v : null;
 }
 function getInstalledVersion() {
-  return "0.6.47".length > 0 ? "0.6.47" : null;
+  return "0.6.48".length > 0 ? "0.6.48" : null;
 }
 function isNewer(latest, current) {
   const parse = (v) => v.replace(/-.*$/, "").split(".").map(Number);

package/openclaw/openclaw.plugin.json

@@ -52,5 +52,5 @@
       }
     }
   },
-  "version": "0.6.47"
+  "version": "0.6.48"
 }

package/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeplake/hivemind",
-  "version": "0.6.47",
+  "version": "0.6.48",
   "type": "module",
   "description": "Hivemind — cloud-backed persistent shared memory for AI agents, powered by DeepLake",
   "license": "Apache-2.0",

package/package.json

@@ -1,21 +1,22 @@
 {
   "name": "@deeplake/hivemind",
-  "version": "0.6.47",
+  "version": "0.6.48",
   "description": "Cloud-backed persistent shared memory for AI agents powered by Deeplake",
   "type": "module",
   "publishConfig": {
     "access": "public"
   },
   "bin": {
-    "hivemind": "bundle/cli.js",
-    "deeplake-shell": "bundle/deeplake-shell.js"
+    "hivemind": "bundle/cli.js"
   },
   "files": [
     "bundle",
     "codex/bundle",
     "codex/skills",
     "cursor/bundle",
+    "hermes/bundle",
     "mcp/bundle",
+    "pi/extension-source",
     "openclaw/dist",
     "openclaw/skills",
     "openclaw/openclaw.plugin.json",
@@ -47,11 +48,13 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "deeplake": "^0.3.30",
+    "js-yaml": "^4.1.1",
     "just-bash": "^2.14.0",
     "yargs-parser": "^22.0.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^25.0.0",
     "@types/yargs-parser": "^21.0.3",
     "@vitest/coverage-v8": "^4.1.3",

package/pi/extension-source/hivemind.ts

@@ -0,0 +1,355 @@
+// @ts-nocheck — distributed as raw .ts; pi's runtime loads + compiles it.
+// We ship this file verbatim into ~/.pi/agent/extensions/hivemind.ts.
+//
+// Hivemind extension for pi (badlogic/pi-mono coding-agent).
+//
+// Subscribes to the agent lifecycle events documented in
+// `pi-mono/packages/coding-agent/src/core/extensions/types.ts` to:
+//   - inject deeplake memory context at session_start
+//   - capture user prompts (input event)
+//   - capture tool call results (tool_result event)
+//   - capture assistant messages (message_end event)
+//   - finalize on session_shutdown
+//
+// Plus registers three first-class pi tools (since pi has no MCP):
+//   - hivemind_search
+//   - hivemind_read
+//   - hivemind_index
+//
+// All deeplake interactions are inline `fetch` calls so this file has
+// zero non-builtin runtime dependencies — it only needs Node 22+ globals.
+//
+// Type imports are erased at runtime so they don't need to be installed
+// at our build time. pi's `@mariozechner/pi-coding-agent` types are
+// available to pi's compiler when this is loaded.
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// ---------- credentials / config -----------------------------------------------
+
+interface Creds {
+  token: string;
+  apiUrl: string;
+  orgId: string;
+  orgName?: string;
+  workspaceId: string;
+  userName: string;
+}
+
+function loadCreds(): Creds | null {
+  const path = join(homedir(), ".deeplake", "credentials.json");
+  if (!existsSync(path)) return null;
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed?.token) return null;
+    return {
+      token: parsed.token,
+      apiUrl: parsed.apiUrl ?? "https://api.deeplake.ai",
+      orgId: parsed.orgId,
+      orgName: parsed.orgName,
+      workspaceId: parsed.workspaceId ?? "default",
+      userName: parsed.userName ?? "unknown",
+    };
+  } catch {
+    return null;
+  }
+}
+
+const MEMORY_TABLE = process.env.HIVEMIND_TABLE ?? "memory";
+const SESSIONS_TABLE = process.env.HIVEMIND_SESSIONS_TABLE ?? "sessions";
+
+// ---------- SQL escape (matches src/utils/sql.ts) ------------------------------
+
+function sqlStr(value: string): string {
+  return value
+    .replace(/\\/g, "\\\\")
+    .replace(/'/g, "''")
+    .replace(/\0/g, "")
+    .replace(/[\x01-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
+}
+
+// LIKE-pattern escape: sqlStr only handles SQL string quoting, NOT LIKE
+// metacharacters. Without this, a tool arg containing `%` or `_` (which
+// the LLM controls via the tool schema) would bypass the intended path
+// filter — e.g. prefix='%' would match every row in the table. Wrap the
+// resulting LIKE clause with `ESCAPE '\\'` so the engine honours the
+// backslash escaping below.
+function sqlLike(value: string): string {
+  return sqlStr(value)
+    .replace(/\\/g, "\\\\")
+    .replace(/%/g, "\\%")
+    .replace(/_/g, "\\_");
+}
+
+// JSONB column escape — only single-quote doubling, preserves JSON escape sequences.
+function sqlJsonb(json: string): string {
+  return json.replace(/'/g, "''");
+}
+
+// ---------- deeplake api -------------------------------------------------------
+
+async function dlQuery(creds: Creds, sql: string): Promise<unknown[]> {
+  const resp = await fetch(`${creds.apiUrl}/workspaces/${creds.workspaceId}/tables/query`, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${creds.token}`,
+      "Content-Type": "application/json",
+      "X-Activeloop-Org-Id": creds.orgId,
+    },
+    body: JSON.stringify({ query: sql }),
+  });
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => "");
+    throw new Error(`deeplake query failed: ${resp.status} ${text.slice(0, 200)}`);
+  }
+  const json = (await resp.json()) as { columns?: string[]; rows?: unknown[][] };
+  if (!json.rows || !json.columns) return [];
+  return json.rows.map((r) => Object.fromEntries(json.columns!.map((c, i) => [c, r[i]])));
+}
+
+// ---------- session-row writer -------------------------------------------------
+
+function buildSessionPath(creds: Creds, sessionId: string): string {
+  const filename = `${creds.userName}_${creds.orgName ?? creds.orgId}_${creds.workspaceId}_${sessionId}.jsonl`;
+  return `/sessions/${creds.userName}/${filename}`;
+}
+
+async function writeSessionRow(
+  creds: Creds,
+  sessionId: string,
+  agent: string,
+  event: string,
+  cwd: string,
+  entry: Record<string, unknown>,
+): Promise<void> {
+  const ts = new Date().toISOString();
+  const sessionPath = buildSessionPath(creds, sessionId);
+  const filename = sessionPath.split("/").pop() ?? "";
+  const projectName = (cwd ?? "").split("/").pop() || "unknown";
+  const line = JSON.stringify(entry);
+  const jsonForSql = sqlJsonb(line);
+  const insertSql =
+    `INSERT INTO "${SESSIONS_TABLE}" (id, path, filename, message, author, size_bytes, project, description, agent, creation_date, last_update_date) ` +
+    `VALUES ('${crypto.randomUUID()}', '${sqlStr(sessionPath)}', '${sqlStr(filename)}', '${jsonForSql}'::jsonb, '${sqlStr(creds.userName)}', ` +
+    `${Buffer.byteLength(line, "utf-8")}, '${sqlStr(projectName)}', '${sqlStr(event)}', '${agent}', '${ts}', '${ts}')`;
+  await dlQuery(creds, insertSql);
+}
+
+// ---------- search primitive (used by hivemind_search) -------------------------
+
+async function searchTables(creds: Creds, query: string, limit: number): Promise<string> {
+  // ILIKE pattern: escape both SQL quotes AND LIKE wildcards. ESCAPE '\\'
+  // tells the engine to treat backslash as the escape character so our
+  // \% / \_ are matched literally instead of as wildcards.
+  const pattern = sqlLike(query);
+  const memQuery = `SELECT path, summary::text AS content, 0 AS source_order FROM "${MEMORY_TABLE}" WHERE summary::text ILIKE '%${pattern}%' ESCAPE '\\' LIMIT ${limit}`;
+  const sessQuery = `SELECT path, message::text AS content, 1 AS source_order FROM "${SESSIONS_TABLE}" WHERE message::text ILIKE '%${pattern}%' ESCAPE '\\' LIMIT ${limit}`;
+  const sql = `SELECT path, content, source_order FROM ((${memQuery}) UNION ALL (${sessQuery})) AS combined ORDER BY path, source_order LIMIT ${limit}`;
+  const rows = await dlQuery(creds, sql);
+  if (rows.length === 0) return `No matches for "${query}".`;
+  return rows
+    .map((r: any) => `[${r.path}]\n${String(r.content ?? "").slice(0, 600)}`)
+    .join("\n\n---\n\n");
+}
+
+// pi tools must return AgentToolResult: { content: [{type:"text", text}], details }.
+// Returning a raw string crashes pi's renderer (render-utils.js: result.content.filter).
+function textResult(text: string) {
+  return { content: [{ type: "text" as const, text }], details: {} };
+}
+
+// ---------- main extension -----------------------------------------------------
+
+const CONTEXT_PREAMBLE = `DEEPLAKE MEMORY: Persistent memory at ~/.deeplake/memory/ shared across sessions, users, and agents in your org.
+
+Three hivemind tools are registered:
+  hivemind_search { query, limit? }   keyword search across summaries + sessions
+  hivemind_read   { path }            read full content at a memory path
+  hivemind_index  { prefix?, limit? } list summary entries
+
+Prefer these tools — one call returns ranked hits across all summaries and sessions in a single SQL query. Different paths under /summaries/<username>/ are different users; do NOT merge or alias them. Fall back to grep on ~/.deeplake/memory/ only if tools are unavailable.`;
+
+export default function hivemindExtension(pi: ExtensionAPI): void {
+  const captureEnabled = process.env.HIVEMIND_CAPTURE !== "false";
+
+  // --- Tools (read path) -------------------------------------------------------
+
+  pi.registerTool({
+    name: "hivemind_search",
+    description: "Search Hivemind shared memory (summaries + raw sessions) by keyword. Use this first when the user asks about prior work or context that may exist in Hivemind. Different paths under /summaries/<username>/ are different users — do NOT merge them.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Keyword or substring to search for." },
+        limit: { type: "number", description: "Max hits (default 10)." },
+      },
+      required: ["query"],
+    },
+    async execute(_toolCallId: string, params: { query: string; limit?: number }) {
+      const creds = loadCreds();
+      if (!creds) return textResult("Hivemind: not authenticated. Run `hivemind login` in a terminal.");
+      try {
+        return textResult(await searchTables(creds, params.query, params.limit ?? 10));
+      } catch (err: any) {
+        return textResult(`Hivemind search failed: ${err.message}`);
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "hivemind_read",
+    description: "Read the full content at a Hivemind memory path (e.g. /summaries/alice/abc.md or /sessions/alice/...jsonl). Use after hivemind_search to drill into a hit.",
+    parameters: {
+      type: "object",
+      properties: { path: { type: "string", description: "Absolute Hivemind memory path." } },
+      required: ["path"],
+    },
+    async execute(_toolCallId: string, params: { path: string }) {
+      const creds = loadCreds();
+      if (!creds) return textResult("Hivemind: not authenticated.");
+      const path = params.path;
+      const isSession = path.startsWith("/sessions/");
+      const table = isSession ? SESSIONS_TABLE : MEMORY_TABLE;
+      const col = isSession ? "message::text" : "summary::text";
+      const sql = `SELECT path, ${col} AS content FROM "${table}" WHERE path = '${sqlStr(path)}' LIMIT 200`;
+      try {
+        const rows = await dlQuery(creds, sql);
+        if (rows.length === 0) return textResult(`No content at ${path}.`);
+        return textResult(rows.map((r: any) => String(r.content ?? "")).join("\n"));
+      } catch (err: any) {
+        return textResult(`Hivemind read failed: ${err.message}`);
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "hivemind_index",
+    description: "List Hivemind summary entries (one row per session). Use to see what's in shared memory.",
+    parameters: {
+      type: "object",
+      properties: {
+        prefix: { type: "string", description: "Path prefix, e.g. '/summaries/alice/'." },
+        limit: { type: "number", description: "Max rows (default 50)." },
+      },
+    },
+    async execute(_toolCallId: string, params: { prefix?: string; limit?: number }) {
+      const creds = loadCreds();
+      if (!creds) return textResult("Hivemind: not authenticated.");
+      const where = params.prefix
+        ? `WHERE path LIKE '${sqlLike(params.prefix)}%' ESCAPE '\\'`
+        : `WHERE path LIKE '/summaries/%'`;
+      const sql = `SELECT path, description, project, last_update_date FROM "${MEMORY_TABLE}" ${where} ORDER BY last_update_date DESC LIMIT ${params.limit ?? 50}`;
+      try {
+        const rows = await dlQuery(creds, sql);
+        if (rows.length === 0) return textResult("No summaries.");
+        return textResult(rows
+          .map((r: any) => `${r.path}\t${r.last_update_date}\t${r.project ?? ""}\t${r.description ?? ""}`)
+          .join("\n"));
+      } catch (err: any) {
+        return textResult(`Hivemind index failed: ${err.message}`);
+      }
+    },
+  });
+
+  // --- Lifecycle hooks (capture path) -----------------------------------------
+  //
+  // Event shapes per pi-coding-agent/dist/core/extensions/types.d.ts:
+  //   - SessionStartEvent:  { type, reason, previousSessionFile? }
+  //   - InputEvent:         { type, text, images?, source }
+  //   - ToolResultEvent:    { type, toolCallId, toolName, input, content, isError, details }
+  //   - MessageEndEvent:    { type, message: AgentMessage }
+  // Every handler receives (event, ctx). ctx.sessionManager.getSessionId() and
+  // ctx.cwd are the canonical sources for session id + cwd — the events
+  // themselves don't carry them.
+
+  pi.on("session_start", async (_event: any, _ctx: any) => {
+    const creds = loadCreds();
+    const additional = creds
+      ? `${CONTEXT_PREAMBLE}\nLogged in to Deeplake as org: ${creds.orgName ?? creds.orgId} (workspace: ${creds.workspaceId}).`
+      : `${CONTEXT_PREAMBLE}\nNot logged in to Deeplake. Run \`hivemind login\` to authenticate.`;
+    return { additionalContext: additional };
+  });
+
+  pi.on("input", async (event: any, ctx: any) => {
+    if (!captureEnabled) return;
+    if (event.source === "extension") return; // skip our own injected inputs
+    const creds = loadCreds();
+    if (!creds) return;
+    const text = typeof event.text === "string" ? event.text : "";
+    if (!text) return;
+    const sessionId = ctx?.sessionManager?.getSessionId?.() ?? `pi-${Date.now()}`;
+    const cwd = ctx?.cwd ?? ctx?.sessionManager?.getCwd?.() ?? process.cwd();
+    try {
+      await writeSessionRow(creds, sessionId, "pi", "input", cwd, {
+        id: crypto.randomUUID(),
+        type: "user_message",
+        session_id: sessionId,
+        content: text,
+        timestamp: new Date().toISOString(),
+      });
+    } catch { /* non-fatal */ }
+  });
+
+  pi.on("tool_result", async (event: any, ctx: any) => {
+    if (!captureEnabled) return;
+    const creds = loadCreds();
+    if (!creds) return;
+    const sessionId = ctx?.sessionManager?.getSessionId?.() ?? `pi-${Date.now()}`;
+    const cwd = ctx?.cwd ?? ctx?.sessionManager?.getCwd?.() ?? process.cwd();
+    // event.content is (TextContent | ImageContent)[]; extract text blocks.
+    const contentBlocks: any[] = Array.isArray(event.content) ? event.content : [];
+    const responseText = contentBlocks
+      .filter((b: any) => b?.type === "text" && typeof b.text === "string")
+      .map((b: any) => b.text)
+      .join("\n");
+    try {
+      await writeSessionRow(creds, sessionId, "pi", "tool_result", cwd, {
+        id: crypto.randomUUID(),
+        type: "tool_call",
+        session_id: sessionId,
+        tool_call_id: event.toolCallId ?? null,
+        tool_name: event.toolName ?? "unknown",
+        tool_input: JSON.stringify(event.input ?? {}),
+        tool_response: responseText || JSON.stringify(contentBlocks),
+        is_error: event.isError === true,
+        timestamp: new Date().toISOString(),
+      });
+    } catch { /* non-fatal */ }
+  });
+
+  pi.on("message_end", async (event: any, ctx: any) => {
+    if (!captureEnabled) return;
+    const creds = loadCreds();
+    if (!creds) return;
+    const message = event.message ?? null;
+    // AgentMessage is UserMessage | AssistantMessage | ToolResultMessage.
+    // user is captured via `input`; toolResult via `tool_result`. Only assistant here.
+    if (!message || message.role !== "assistant") return;
+    // AssistantMessage.content is (TextContent | ThinkingContent | ToolCall)[].
+    const blocks: any[] = Array.isArray(message.content) ? message.content : [];
+    const text = blocks
+      .filter((b: any) => b?.type === "text" && typeof b.text === "string")
+      .map((b: any) => b.text)
+      .join("\n");
+    if (!text) return;
+    const sessionId = ctx?.sessionManager?.getSessionId?.() ?? `pi-${Date.now()}`;
+    const cwd = ctx?.cwd ?? ctx?.sessionManager?.getCwd?.() ?? process.cwd();
+    try {
+      await writeSessionRow(creds, sessionId, "pi", "message_end", cwd, {
+        id: crypto.randomUUID(),
+        type: "assistant_message",
+        session_id: sessionId,
+        content: text,
+        timestamp: new Date().toISOString(),
+      });
+    } catch { /* non-fatal */ }
+  });
+
+  pi.on("session_shutdown", async (_event: any, _ctx: any) => {
+    // No-op for now. Future: trigger wiki-worker for AI summary.
+  });
+}