@memorystack/clawdbot-memorystack 1.1.0 → 1.2.0

package/commands/cli.ts

@@ -0,0 +1,161 @@
+import type { ClawdbotPluginApi } from "clawdbot/plugin-sdk";
+import { MemoryStackClient } from "@memorystack/sdk";
+import type { MemorystackConfig } from "../config.ts";
+import { log } from "../logger.ts";
+
+export function registerCliCommands(
+    api: ClawdbotPluginApi,
+    cfg: MemorystackConfig,
+): void {
+    api.registerCli(
+        // biome-ignore lint/suspicious/noExplicitAny: clawdbot SDK does not ship types
+        ({ program }: { program: any }) => {
+            const cmd = program
+                .command("memorystack")
+                .description("MemoryStack long-term memory commands");
+
+            // clawdbot memorystack search <query>
+            cmd
+                .command("search")
+                .argument("<query>", "Search query")
+                .option("--limit <n>", "Max results", "5")
+                .option("--type <type>", "Filter by memory type (fact, preference, episode)")
+                .action(async (query: string, opts: { limit: string; type?: string }) => {
+                    const limit = Number.parseInt(opts.limit, 10) || 5;
+                    log.debug(`cli search: query="${query}" limit=${limit}`);
+
+                    try {
+                        const client = new MemoryStackClient({
+                            apiKey: cfg.apiKey,
+                            baseUrl: cfg.baseUrl,
+                            enableLogging: cfg.debug,
+                        });
+
+                        const results = await client.search(query, {
+                            limit,
+                            memory_type: opts.type,
+                        });
+
+                        if (results.count === 0) {
+                            console.log("No memories found.");
+                            return;
+                        }
+
+                        console.log(`Found ${results.count} memories:\n`);
+                        for (const r of results.results) {
+                            const conf = r.confidence
+                                ? ` (${(r.confidence * 100).toFixed(0)}%)`
+                                : "";
+                            const type = r.memory_type ? ` [${r.memory_type}]` : "";
+                            console.log(`- ${r.content}${type}${conf}`);
+                        }
+                    } catch (err) {
+                        console.error("Search failed:", err);
+                    }
+                });
+
+            // clawdbot memorystack stats
+            cmd
+                .command("stats")
+                .description("View usage statistics")
+                .action(async () => {
+                    log.debug("cli stats");
+
+                    try {
+                        const client = new MemoryStackClient({
+                            apiKey: cfg.apiKey,
+                            baseUrl: cfg.baseUrl,
+                            enableLogging: cfg.debug,
+                        });
+
+                        const stats = await client.getStats();
+
+                        console.log("\n📊 MemoryStack Statistics\n");
+                        console.log(`Total Memories:      ${stats.totals.total_memories}`);
+                        console.log(`Total API Calls:     ${stats.totals.total_api_calls}`);
+                        console.log(`This Month's Calls:  ${stats.usage.current_month_api_calls}/${stats.usage.monthly_api_limit}`);
+                        console.log(`Plan:                ${stats.plan_tier || "Free"}`);
+                    } catch (err) {
+                        console.error("Failed to get stats:", err);
+                    }
+                });
+
+            // clawdbot memorystack add <text>
+            cmd
+                .command("add")
+                .argument("<text>", "Text to save as memory")
+                .option("--type <type>", "Memory type (fact, preference, episode)")
+                .action(async (text: string, opts: { type?: string }) => {
+                    log.debug(`cli add: "${text.slice(0, 50)}"`);
+
+                    try {
+                        const client = new MemoryStackClient({
+                            apiKey: cfg.apiKey,
+                            baseUrl: cfg.baseUrl,
+                            enableLogging: cfg.debug,
+                        });
+
+                        await client.add(text, {
+                            metadata: {
+                                source: "clawdbot_cli",
+                                memory_type: opts.type,
+                            },
+                        });
+
+                        console.log(`✓ Saved: "${text.length > 60 ? text.slice(0, 60) + "…" : text}"`);
+                    } catch (err) {
+                        console.error("Failed to add memory:", err);
+                    }
+                });
+
+            // clawdbot memorystack deleteall (destructive!)
+            cmd
+                .command("deleteall")
+                .description("Delete ALL your memories (destructive, requires confirmation)")
+                .action(async () => {
+                    const readline = await import("node:readline");
+                    const rl = readline.createInterface({
+                        input: process.stdin,
+                        output: process.stdout,
+                    });
+
+                    const answer = await new Promise<string>((resolve) => {
+                        rl.question(
+                            "⚠️  This will permanently delete ALL your memories. Type 'yes' to confirm: ",
+                            resolve,
+                        );
+                    });
+                    rl.close();
+
+                    if (answer.trim().toLowerCase() !== "yes") {
+                        console.log("Aborted.");
+                        return;
+                    }
+
+                    log.debug("cli wipe: confirmed");
+
+                    try {
+                        const client = new MemoryStackClient({
+                            apiKey: cfg.apiKey,
+                            baseUrl: cfg.baseUrl,
+                            enableLogging: cfg.debug,
+                        });
+
+                        // List all memories first, then delete them
+                        const memories = await client.listMemories({ limit: 1000 });
+                        if (memories.count === 0) {
+                            console.log("No memories to delete.");
+                            return;
+                        }
+
+                        const memoryIds = memories.results.map(m => m.id);
+                        const result = await client.deleteMemories(memoryIds, true);
+                        console.log(`Wiped ${result.deleted_count} memories.`);
+                    } catch (err) {
+                        console.error("Failed to wipe memories:", err);
+                    }
+                });
+        },
+        { commands: ["memorystack"] },
+    );
+}

package/commands/slash.ts

@@ -0,0 +1,130 @@
+import type { ClawdbotPluginApi } from "clawdbot/plugin-sdk";
+import { MemoryStackClient } from "@memorystack/sdk";
+import type { MemorystackConfig } from "../config.ts";
+import { log } from "../logger.ts";
+
+export function registerSlashCommands(
+    api: ClawdbotPluginApi,
+    cfg: MemorystackConfig,
+    getSessionKey: () => string | undefined,
+    getContext: () => Record<string, any>,
+): void {
+    // /add <text> - Save something to memory
+    api.registerCommand({
+        name: "add",
+        description: "Save something to long-term memory",
+        acceptsArgs: true,
+        requireAuth: true,
+        handler: async (ctx: { args?: string }) => {
+            const text = ctx.args?.trim();
+            if (!text) {
+                return { text: "Usage: /add <text to remember>" };
+            }
+
+            log.debug(`/add command: "${text.slice(0, 50)}"`);
+
+            try {
+                const client = new MemoryStackClient({
+                    apiKey: cfg.apiKey,
+                    baseUrl: cfg.baseUrl,
+                    enableLogging: cfg.debug,
+                });
+
+                const context = getContext();
+                const sessionKey = getSessionKey();
+                const effectiveAgentId = context.subagentId || context.agentId || "main";
+
+                await client.add(text, {
+                    agentId: effectiveAgentId,
+                    sessionId: sessionKey,
+                    metadata: {
+                        source: "clawdbot_command",
+                        session_key: sessionKey,
+                    },
+                });
+
+                const preview = text.length > 60 ? `${text.slice(0, 60)}…` : text;
+                return { text: `✓ Saved to memory: "${preview}"` };
+            } catch (err) {
+                log.error("/add failed", err);
+                return { text: "Failed to save memory. Check logs for details." };
+            }
+        },
+    });
+
+    // /search <query> - Search memories
+    api.registerCommand({
+        name: "search",
+        description: "Search your long-term memories",
+        acceptsArgs: true,
+        requireAuth: true,
+        handler: async (ctx: { args?: string }) => {
+            const query = ctx.args?.trim();
+            if (!query) {
+                return { text: "Usage: /search <search query>" };
+            }
+
+            log.debug(`/search command: "${query}"`);
+
+            try {
+                const client = new MemoryStackClient({
+                    apiKey: cfg.apiKey,
+                    baseUrl: cfg.baseUrl,
+                    enableLogging: cfg.debug,
+                });
+
+                const results = await client.search(query, { limit: 5 });
+
+                if (results.count === 0) {
+                    return { text: `No memories found for: "${query}"` };
+                }
+
+                const lines = results.results.map((r, i) => {
+                    const conf = r.confidence
+                        ? ` (${(r.confidence * 100).toFixed(0)}%)`
+                        : "";
+                    const type = r.memory_type ? ` [${r.memory_type}]` : "";
+                    return `${i + 1}. ${r.content}${type}${conf}`;
+                });
+
+                return {
+                    text: `Found ${results.count} memories:\n\n${lines.join("\n")}`,
+                };
+            } catch (err) {
+                log.error("/search failed", err);
+                return { text: "Failed to search memories. Check logs for details." };
+            }
+        },
+    });
+
+    // /stats - View memory usage statistics
+    api.registerCommand({
+        name: "stats",
+        description: "View your memory usage statistics",
+        acceptsArgs: false,
+        requireAuth: true,
+        handler: async () => {
+            log.debug("/stats command");
+
+            try {
+                const client = new MemoryStackClient({
+                    apiKey: cfg.apiKey,
+                    baseUrl: cfg.baseUrl,
+                    enableLogging: cfg.debug,
+                });
+
+                const stats = await client.getStats();
+
+                return {
+                    text: `📊 Memory Statistics\n\n` +
+                        `Total Memories: ${stats.totals.total_memories}\n` +
+                        `API Calls (this month): ${stats.usage.current_month_api_calls}/${stats.usage.monthly_api_limit}\n` +
+                        `Plan: ${stats.plan_tier || "Free"}`,
+                };
+            } catch (err) {
+                log.error("/stats failed", err);
+                return { text: "Failed to get stats. Check logs for details." };
+            }
+        },
+    });
+}

package/index.ts

@@ -9,6 +9,8 @@ import { registerReflectTool } from "./tools/reflect.ts";
 import { registerConsolidateTool } from "./tools/consolidate.ts";
 import { buildRecallHandler } from "./hooks/recall.ts";
 import { buildCaptureHandler } from "./hooks/capture.ts";
+import { registerSlashCommands } from "./commands/slash.ts";
+import { registerCliCommands } from "./commands/cli.ts";
 
 // Helper to properly parse Moltbot session keys
 // Format: "agent:{agentId}:{rest}" where rest may be "subagent:{uuid}" or "main" etc.
@@ -115,6 +117,12 @@ export default {
             });
         }
 
+        // Register slash commands (/add, /search, /stats)
+        registerSlashCommands(api, cfg, getSessionKey, getContext);
+
+        // Register CLI commands (memorystack search, stats, add, wipe)
+        registerCliCommands(api, cfg);
+
         // Register service
         api.registerService({
             id: "clawdbot-memorystack",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@memorystack/clawdbot-memorystack",
-    "version": "1.1.0",
+    "version": "1.2.0",
     "type": "module",
     "description": "Clawdbot MemoryStack memory plugin - long-term memory for your AI assistant",
     "license": "MIT",