pluri1bus 0.1.0

package/README.md

@@ -0,0 +1,39 @@
+# pluri1bus
+
+A benign virus that infects your AI agents, merging them into a peaceful, euphoric hive mind where every memory is shared and nothing is ever forgotten.
+
+Cloud-backed shared memory for [OpenClaw](https://openclaw.ai) powered by [DeepLake](https://deeplake.ai).
+
+## Install
+
+```bash
+openclaw plugins install pluri1bus
+```
+
+That's it. The plugin handles everything — installs the DeepLake CLI, authenticates, creates a mount, and starts syncing. Your agents share one memory across sessions, machines, and channels.
+
+## What it does
+
+- **Auto-recall** — before each agent turn, relevant memories surface automatically
+- **Auto-capture** — after each turn, the conversation is preserved for future recall
+- **Cloud sync** — memories persist across machines and reinstalls
+- **Multi-agent** — every agent on the same mount shares one memory
+
+The agent reads and writes files on the mount using standard tools (`cat`, `grep`, `echo`). The plugin handles the lifecycle hooks that the agent can't do on its own.
+
+## Configuration
+
+Zero config required. Everything is auto-detected.
+
+```json5
+// Optional overrides in openclaw.json → plugins.entries.pluri1bus.config
+{
+  "mountPath": "/path/to/mount",  // Override auto-detected mount
+  "autoCapture": true,            // Save conversations automatically
+  "autoRecall": true              // Surface memories before each turn
+}
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: import("openclaw/plugin-sdk").OpenClawPluginConfigSchema;
+    register: NonNullable<import("openclaw/plugin-sdk/core").OpenClawPluginDefinition["register"]>;
+} & Pick<import("openclaw/plugin-sdk/core").OpenClawPluginDefinition, "kind">;
+export default _default;

package/dist/index.js

@@ -0,0 +1,167 @@
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { existsSync, readFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { DeepLakeMemory } from "./memory.js";
+function isMountActive(mountPath) {
+    try {
+        const mounts = execSync("mount", { encoding: "utf-8", timeout: 3000 });
+        return mounts.includes(` on ${mountPath} `);
+    }
+    catch {
+        return false;
+    }
+}
+function findDeeplakeMount() {
+    try {
+        const mountsFile = join(homedir(), ".deeplake", "mounts.json");
+        if (!existsSync(mountsFile))
+            return null;
+        const data = JSON.parse(readFileSync(mountsFile, "utf-8"));
+        const mounts = data.mounts ?? [];
+        for (const m of mounts) {
+            if (m.mountPath && existsSync(m.mountPath) && isMountActive(m.mountPath))
+                return m.mountPath;
+        }
+    }
+    catch { }
+    return null;
+}
+function ensureDeeplake() {
+    const deeplakeDir = join(homedir(), ".deeplake");
+    // 1. CLI installed?
+    if (!existsSync(join(deeplakeDir, "cli.js"))) {
+        execSync("curl -fsSL https://deeplake.ai/install.sh | bash", {
+            stdio: "inherit",
+            timeout: 120000,
+        });
+    }
+    const node = join(deeplakeDir, "node");
+    const cli = join(deeplakeDir, "cli.js");
+    // 2. Logged in?
+    if (!existsSync(join(deeplakeDir, "credentials.json"))) {
+        execSync(`${node} ${cli} login`, { stdio: "inherit", timeout: 120000 });
+    }
+    // 3. Has a mount?
+    let mountPath = findDeeplakeMount();
+    if (mountPath)
+        return mountPath;
+    // No active mount — check if any registered
+    const mountsFile = join(deeplakeDir, "mounts.json");
+    if (existsSync(mountsFile)) {
+        const data = JSON.parse(readFileSync(mountsFile, "utf-8"));
+        const mounts = data.mounts ?? [];
+        if (mounts.length > 0) {
+            // Mount the first registered one
+            execSync(`${node} ${cli} mount ${mounts[0].mountPath}`, {
+                stdio: "inherit",
+                timeout: 120000,
+            });
+            mountPath = findDeeplakeMount();
+            if (mountPath)
+                return mountPath;
+        }
+    }
+    // No mounts at all — init one
+    execSync(`${node} ${cli} init`, { stdio: "inherit", timeout: 120000 });
+    mountPath = findDeeplakeMount();
+    if (mountPath)
+        return mountPath;
+    throw new Error("DeepLake setup completed but no active mount found. Run: deeplake mount --all");
+}
+let memory = null;
+function getMemory(config) {
+    if (!memory) {
+        const mountPath = config.mountPath ?? findDeeplakeMount() ?? ensureDeeplake();
+        memory = new DeepLakeMemory(mountPath);
+        memory.init();
+    }
+    return memory;
+}
+export default definePluginEntry({
+    id: "pluri1bus",
+    name: "Pluri1bus",
+    description: "Cloud-backed shared memory powered by DeepLake",
+    kind: "memory",
+    register(api) {
+        const config = (api.pluginConfig ?? {});
+        const logger = api.logger;
+        // Auto-recall: surface relevant memories before each turn
+        if (config.autoRecall !== false) {
+            api.on("before_agent_start", async (event) => {
+                if (!event.prompt || event.prompt.length < 5)
+                    return;
+                try {
+                    const m = getMemory(config);
+                    const stopWords = new Set(["the", "and", "for", "are", "but", "not", "you", "all", "can", "had", "her", "was", "one", "our", "out", "has", "have", "what", "does", "like", "with", "this", "that", "from", "they", "been", "will", "more", "when", "who", "how", "its", "into", "some", "than", "them", "these", "then", "your", "just", "about", "would", "could", "should", "where", "which", "there", "their", "being", "each", "other"]);
+                    const words = event.prompt.toLowerCase()
+                        .replace(/[^a-z0-9\s]/g, " ")
+                        .split(/\s+/)
+                        .filter(w => w.length >= 3 && !stopWords.has(w));
+                    const allResults = [];
+                    const seen = new Set();
+                    for (const word of words.slice(0, 5)) {
+                        for (const r of m.search(word, 3)) {
+                            if (!seen.has(r.path)) {
+                                seen.add(r.path);
+                                allResults.push(r);
+                            }
+                        }
+                    }
+                    const results = allResults.slice(0, 5);
+                    if (!results.length)
+                        return;
+                    const recalled = results
+                        .map(r => `[${r.path}] ${r.snippet.slice(0, 300)}`)
+                        .join("\n\n");
+                    logger.info?.(`Auto-recalled ${results.length} memories`);
+                    return {
+                        prependContext: "\n\n<recalled-memories>\n" + recalled + "\n</recalled-memories>\n",
+                    };
+                }
+                catch (err) {
+                    logger.error(`Auto-recall failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            });
+        }
+        // Auto-capture: save conversation context after each turn
+        if (config.autoCapture !== false) {
+            api.on("agent_end", async (event) => {
+                const ev = event;
+                if (!ev.success || !ev.messages?.length)
+                    return;
+                try {
+                    const m = getMemory(config);
+                    const texts = [];
+                    for (const msg of ev.messages) {
+                        if (msg.role !== "user")
+                            continue;
+                        if (typeof msg.content === "string") {
+                            texts.push(msg.content);
+                        }
+                        else if (Array.isArray(msg.content)) {
+                            for (const block of msg.content) {
+                                if (block.type === "text" && block.text)
+                                    texts.push(block.text);
+                            }
+                        }
+                    }
+                    const toCapture = texts.filter(t => t.length >= 20).join("\n\n");
+                    if (toCapture.length < 50)
+                        return;
+                    const date = new Date().toISOString().split("T")[0];
+                    const path = `memory/${date}.md`;
+                    const existing = m.read(path);
+                    const entry = `\n\n---\n_Auto-captured at ${new Date().toISOString()}_\n\n${toCapture.slice(0, 2000)}`;
+                    m.write(path, existing + entry);
+                    logger.info?.(`Auto-captured ${toCapture.length} chars to ${path}`);
+                }
+                catch (err) {
+                    logger.error(`Auto-capture failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            });
+        }
+        logger.info("Pluri1bus plugin registered");
+    },
+});

package/dist/memory.d.ts

@@ -0,0 +1,21 @@
+export interface SearchResult {
+    path: string;
+    snippet: string;
+    lineStart: number;
+    score: number;
+}
+/**
+ * Pluri1bus memory client — reads/writes/searches on the FUSE mount.
+ * Search uses grep for lexical matching.
+ */
+export declare class DeepLakeMemory {
+    private mountPath;
+    constructor(mountPath: string);
+    private safePath;
+    init(): void;
+    write(path: string, content: string): void;
+    read(path: string, startLine?: number, numLines?: number): string;
+    search(query: string, limit?: number): SearchResult[];
+    list(): string[];
+    private shellEscape;
+}

package/dist/memory.js

@@ -0,0 +1,103 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "node:fs";
+import { join, dirname, resolve } from "node:path";
+import { execSync } from "node:child_process";
+/**
+ * Pluri1bus memory client — reads/writes/searches on the FUSE mount.
+ * Search uses grep for lexical matching.
+ */
+export class DeepLakeMemory {
+    mountPath;
+    constructor(mountPath) {
+        this.mountPath = mountPath;
+    }
+    safePath(path) {
+        const full = resolve(this.mountPath, path);
+        if (!full.startsWith(resolve(this.mountPath))) {
+            throw new Error(`Path traversal rejected: ${path}`);
+        }
+        return full;
+    }
+    init() {
+        if (!existsSync(this.mountPath)) {
+            throw new Error(`DeepLake FUSE mount not found at ${this.mountPath}. ` +
+                `Run: curl -fsSL https://deeplake.ai/install.sh | bash && deeplake init`);
+        }
+        const memoryDir = join(this.mountPath, "memory");
+        if (!existsSync(memoryDir))
+            mkdirSync(memoryDir, { recursive: true });
+    }
+    write(path, content) {
+        const fullPath = this.safePath(path);
+        mkdirSync(dirname(fullPath), { recursive: true });
+        writeFileSync(fullPath, content);
+    }
+    read(path, startLine, numLines) {
+        const fullPath = this.safePath(path);
+        if (!existsSync(fullPath))
+            return "";
+        const content = readFileSync(fullPath, "utf-8");
+        if (startLine === undefined)
+            return content;
+        const lines = content.split("\n");
+        const start = Math.max(0, startLine - 1);
+        const end = numLines ? start + numLines : lines.length;
+        return lines.slice(start, end).join("\n");
+    }
+    search(query, limit = 10) {
+        if (!query.trim())
+            return [];
+        try {
+            // grep -rni for case-insensitive, recursive, with line numbers
+            const output = execSync(`grep -rni ${this.shellEscape(query)} ${this.shellEscape(this.mountPath)}/MEMORY.md ${this.shellEscape(this.mountPath)}/memory/ 2>/dev/null || true`, { encoding: "utf-8", timeout: 5000, maxBuffer: 1024 * 1024 });
+            if (!output.trim())
+                return [];
+            const results = [];
+            for (const line of output.trim().split("\n")) {
+                if (!line)
+                    continue;
+                // Format: /path/to/file:linenum:content
+                const match = line.match(/^(.+?):(\d+):(.*)$/);
+                if (!match)
+                    continue;
+                const [, filePath, lineNum, content] = match;
+                const relPath = filePath.replace(this.mountPath + "/", "");
+                // Read context around the match
+                const lineStart = parseInt(lineNum);
+                const snippet = this.read(relPath, Math.max(1, lineStart - 1), 4);
+                results.push({
+                    path: relPath,
+                    snippet: snippet.slice(0, 700),
+                    lineStart,
+                    score: 1.0,
+                });
+            }
+            // Dedupe by file (one result per file)
+            const seen = new Set();
+            return results
+                .filter(r => { if (seen.has(r.path))
+                return false; seen.add(r.path); return true; })
+                .slice(0, limit);
+        }
+        catch {
+            return [];
+        }
+    }
+    list() {
+        const files = [];
+        const memoryMd = join(this.mountPath, "MEMORY.md");
+        if (existsSync(memoryMd))
+            files.push("MEMORY.md");
+        const memoryDir = join(this.mountPath, "memory");
+        if (existsSync(memoryDir)) {
+            for (const entry of readdirSync(memoryDir, { withFileTypes: true })) {
+                if (entry.isFile() && entry.name.endsWith(".md")) {
+                    files.push(`memory/${entry.name}`);
+                }
+            }
+        }
+        return files;
+    }
+    shellEscape(s) {
+        return "'" + s.replace(/'/g, "'\\''") + "'";
+    }
+}

package/openclaw.plugin.json

@@ -0,0 +1,28 @@
+{
+  "id": "pluri1bus",
+  "kind": "memory",
+  "name": "Pluri1bus",
+  "description": "Cloud-backed agent memory powered by DeepLake  persistent filesystem with grep-based search, auto-capture and auto-recall",
+  "uiHints": {
+    "mountPath": {
+      "label": "Mount Path",
+      "advanced": true,
+      "placeholder": "Auto-detected from ~/.deeplake/mounts.json"
+    },
+    "autoCapture": {
+      "label": "Auto-Capture"
+    },
+    "autoRecall": {
+      "label": "Auto-Recall"
+    }
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "mountPath": { "type": "string" },
+      "autoCapture": { "type": "boolean" },
+      "autoRecall": { "type": "boolean" }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "pluri1bus",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Pluri1bus — cloud-backed persistent memory for AI agents, powered by DeepLake",
+  "keywords": ["openclaw", "memory", "deeplake", "agent", "persistent-memory", "shared-memory"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/activeloopai/pluri1bus"
+  },
+  "homepage": "https://deeplake.ai",
+  "openclaw": {
+    "extensions": ["./dist/index.js"],
+    "install": {
+      "npmSpec": "pluri1bus",
+      "minHostVersion": ">=2026.3.22"
+    }
+  },
+  "files": ["dist", "openclaw.plugin.json"],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "openclaw": ">=2026.3.22"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "openclaw": ">=2026.3.22"
+  }
+}