shabti 2.1.0 → 2.3.0

package/README.md

@@ -128,7 +128,13 @@ npx shabti-mcp
 
 ### Claude Code configuration
 
-Add to your MCP settings:
+Generate the MCP settings JSON:
+
+```bash
+shabti mcp-config
+```
+
+Or manually add to your MCP settings:
 
 ```json
 {
@@ -147,6 +153,8 @@ Add to your MCP settings:
 | --------------- | -------------------------------------- |
 | `memory_store`  | Store a memory entry                   |
 | `memory_search` | Search memories by semantic similarity |
+| `memory_delete` | Delete a memory entry by ID            |
+| `memory_list`   | List recent memory entries             |
 | `memory_status` | Get engine status                      |
 
 ### Available resources

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shabti",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Agent Memory OS — semantic memory for AI agents",
   "type": "module",
   "main": "native.cjs",

package/src/commands/store.js

@@ -9,6 +9,7 @@ export function registerStore(program) {
     .option("-n, --namespace <ns>", "Namespace for the entry")
     .option("-s, --session <id>", "Session ID")
     .option("-t, --tags <tags>", "Comma-separated tags")
+    .option("--ttl <seconds>", "Time-to-live in seconds (auto-expires after this duration)")
     .action(async (content, opts) => {
       try {
         const engine = createEngine();
@@ -16,6 +17,7 @@ export function registerStore(program) {
         if (opts.namespace) options.namespace = opts.namespace;
         if (opts.session) options.sessionId = opts.session;
         if (opts.tags) options.tags = opts.tags.split(",").map((t) => t.trim());
+        if (opts.ttl) options.ttlSeconds = parseInt(opts.ttl, 10);
 
         // Model versioning check
         const currentModelId = engine.modelId();

package/src/index.js

@@ -78,6 +78,39 @@ function buildProgram() {
   registerSpin(program);
   registerStatus(program);
   registerStore(program);
+
+  program
+    .command("gc")
+    .description("Garbage collect expired memory entries")
+    .action(async () => {
+      const { createEngine } = await import("./core/engine.js");
+      const { success, error: showError } = await import("./utils/style.js");
+      try {
+        const engine = createEngine();
+        const removed = await engine.gc();
+        success(`GC complete: ${removed} expired entries removed`);
+        await engine.shutdown();
+      } catch (err) {
+        showError(err.message);
+        process.exitCode = 1;
+      }
+    });
+
+  program
+    .command("mcp-config")
+    .description("Print MCP server configuration JSON for Claude Code / Cursor")
+    .action(() => {
+      const config = {
+        mcpServers: {
+          "shabti-memory": {
+            command: "npx",
+            args: ["shabti-mcp"],
+          },
+        },
+      };
+      console.log(JSON.stringify(config, null, 2));
+    });
+
   return program;
 }
 

package/src/mcp/server.js

@@ -24,6 +24,10 @@ const TOOLS = [
           items: { type: "string" },
           description: "Tags to associate with the memory",
         },
+        ttl: {
+          type: "integer",
+          description: "Time-to-live in seconds (entry auto-expires after this duration)",
+        },
       },
       required: ["content"],
     },
@@ -44,6 +48,39 @@ const TOOLS = [
       required: ["query"],
     },
   },
+  {
+    name: "memory_delete",
+    description: "Delete a memory entry by ID",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "UUID of the memory entry to delete" },
+      },
+      required: ["id"],
+    },
+  },
+  {
+    name: "memory_list",
+    description: "List recent memory entries",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "integer",
+          description: "Maximum number of entries to return (default: 10)",
+        },
+        namespace: { type: "string", description: "Filter by namespace" },
+      },
+    },
+  },
+  {
+    name: "memory_gc",
+    description: "Garbage collect expired memory entries (removes entries past their TTL)",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+  },
   {
     name: "memory_status",
     description: "Get the current status of the memory engine",
@@ -70,9 +107,12 @@ const RESOURCES = [
 ];
 
 let engine = null;
+let engineInitAttempted = false;
 
 function initEngine() {
   if (engine) return engine;
+  if (engineInitAttempted) return null;
+  engineInitAttempted = true;
   try {
     engine = createEngine();
   } catch {
@@ -163,6 +203,7 @@ async function handleToolsCall(id, params) {
       const opts = {};
       if (args.namespace) opts.namespace = args.namespace;
       if (args.tags) opts.tags = args.tags;
+      if (args.ttl) opts.ttlSeconds = args.ttl;
       const result = await eng.store(content, opts);
       return respond(id, {
         content: [
@@ -213,6 +254,77 @@ async function handleToolsCall(id, params) {
     }
   }
 
+  if (name === "memory_delete") {
+    if (!eng) {
+      return respondError(id, -32603, "Engine not available");
+    }
+    const entryId = args?.id;
+    if (!entryId) {
+      return respondError(id, -32602, "Missing required parameter: id");
+    }
+    try {
+      await eng.delete(entryId);
+      return respond(id, {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ deleted: true, id: entryId }, null, 2),
+          },
+        ],
+      });
+    } catch (err) {
+      return respondError(id, -32603, err.message);
+    }
+  }
+
+  if (name === "memory_list") {
+    if (!eng) {
+      return respondError(id, -32603, "Engine not available");
+    }
+    try {
+      const limit = args?.limit || 10;
+      const queryObj = { text: "*", limit };
+      if (args?.namespace) queryObj.namespace = args.namespace;
+      const results = await eng.executeQuery(queryObj);
+      const entries = results.map((r) => ({
+        id: r.id,
+        content: r.content,
+        score: r.score,
+        namespace: r.namespace,
+        createdAt: r.createdAt,
+      }));
+      return respond(id, {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ entries, count: entries.length }, null, 2),
+          },
+        ],
+      });
+    } catch (err) {
+      return respondError(id, -32603, err.message);
+    }
+  }
+
+  if (name === "memory_gc") {
+    if (!eng) {
+      return respondError(id, -32603, "Engine not available");
+    }
+    try {
+      const removed = await eng.gc();
+      return respond(id, {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ removed }, null, 2),
+          },
+        ],
+      });
+    } catch (err) {
+      return respondError(id, -32603, err.message);
+    }
+  }
+
   respondError(id, -32601, `Unknown tool: ${name}`);
 }
 

package/src/repl/slashCommands.js

@@ -9,6 +9,7 @@ const COMMANDS = {
   "/history": "Show conversation history",
   "/remember": "Store a memory (e.g. /remember Tokyo is the capital of Japan)",
   "/recall": "Search memories (e.g. /recall capital of Japan)",
+  "/gc": "Garbage collect expired memory entries",
 };
 
 /**
@@ -75,6 +76,9 @@ export function handleSlashCommand(cmd, args, session, rl, engine = null) {
     case "/recall":
       return handleRecall(args, engine);
 
+    case "/gc":
+      return handleGc(engine);
+
     default:
       return false;
   }
@@ -136,3 +140,20 @@ async function handleRecall(query, engine) {
   console.log();
   return true;
 }
+
+async function handleGc(engine) {
+  if (!engine) {
+    console.log();
+    warn("Memory engine not available. Start Qdrant to enable memory features.");
+    console.log();
+    return true;
+  }
+  try {
+    const removed = await engine.gc();
+    success(`GC complete: ${removed} expired entries removed`);
+  } catch (err) {
+    error(`Failed to run GC: ${err.message}`);
+  }
+  console.log();
+  return true;
+}