@shadowforge0/aquifer-memory 1.8.1 → 1.9.1

package/consumers/shared/openclaw-product-tools.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const {
+  formatMemoryStatsInterface,
+  formatPendingRowsInterface,
+  formatPendingWorkInterface,
+} = require('../../core/interface');
+const { MCP_TOOL_MANIFEST } = require('../../core/mcp-manifest');
+
+function manifestToolDescription(name, fallback) {
+  return MCP_TOOL_MANIFEST.find(tool => tool.name === name)?.description || fallback;
+}
+
+function clampLimit(value, fallback = 20, max = 200) {
+  const parsed = parseInt(value ?? fallback, 10);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.max(1, Math.min(max, parsed));
+}
+
+function pendingSessionOpts(params = {}) {
+  return {
+    limit: clampLimit(params.limit, 20, 200),
+    source: params.source || undefined,
+    agentId: params.agentId || params.agent_id || undefined,
+    status: params.status || undefined,
+  };
+}
+
+function normalizeSkipTools(value) {
+  if (!value) return new Set();
+  if (value instanceof Set) return value;
+  if (Array.isArray(value)) return new Set(value);
+  return new Set();
+}
+
+function registerOpenClawProductStatusTools(api, aquifer, opts = {}) {
+  if (!api || typeof api.registerTool !== 'function') {
+    throw new Error('OpenClaw-compatible api.registerTool is required');
+  }
+  if (!aquifer) {
+    throw new Error('aquifer instance is required');
+  }
+  const skipTools = normalizeSkipTools(opts.skipTools);
+
+  if (!skipTools.has('memory_stats')) {
+    api.registerTool((ctx) => {
+      if ((ctx?.sessionKey || '').includes('subagent')) return null;
+
+      return {
+        name: 'memory_stats',
+        description: manifestToolDescription('memory_stats', 'Return Aquifer product status.'),
+        parameters: {
+          type: 'object',
+          properties: {
+            diagnostics: { type: 'boolean', description: 'Include raw storage counters and serving diagnostics. Default false.' },
+          },
+        },
+        async execute(_toolCallId, params = {}) {
+          try {
+            const stats = await aquifer.getStats();
+            const text = formatMemoryStatsInterface(stats, { diagnostics: params.diagnostics === true });
+            return { content: [{ type: 'text', text }] };
+          } catch (err) {
+            return {
+              content: [{ type: 'text', text: `memory_stats error: ${err.message}` }],
+              isError: true,
+            };
+          }
+        },
+      };
+    }, { name: 'memory_stats' });
+  }
+
+  if (!skipTools.has('memory_pending')) {
+    api.registerTool((ctx) => {
+      if ((ctx?.sessionKey || '').includes('subagent')) return null;
+
+      return {
+        name: 'memory_pending',
+        description: manifestToolDescription('memory_pending', 'Return saved-content preparation status.'),
+        parameters: {
+          type: 'object',
+          properties: {
+            limit: { type: 'number', description: 'Max results (default 20)' },
+            source: { type: 'string', description: 'Filter by source' },
+            agentId: { type: 'string', description: 'Filter by agent ID' },
+            agent_id: { type: 'string', description: 'Filter by agent ID' },
+            status: { type: 'string', enum: ['pending', 'failed'], description: 'Filter by processing status' },
+            diagnostics: { type: 'boolean', description: 'Include source/agent/status buckets, guidance, and samples. Default false.' },
+          },
+        },
+        async execute(_toolCallId, params = {}) {
+          try {
+            const opts = pendingSessionOpts(params);
+            const report = typeof aquifer.getPendingWork === 'function'
+              ? await aquifer.getPendingWork(opts)
+              : null;
+            const text = report
+              ? formatPendingWorkInterface(report, {
+                  diagnostics: params.diagnostics === true,
+                  includePlan: false,
+                })
+              : formatPendingRowsInterface(
+                  typeof aquifer.getPendingSessions === 'function'
+                    ? await aquifer.getPendingSessions(opts)
+                    : [],
+                  { diagnostics: params.diagnostics === true }
+                );
+            return { content: [{ type: 'text', text }] };
+          } catch (err) {
+            return {
+              content: [{ type: 'text', text: `memory_pending error: ${err.message}` }],
+              isError: true,
+            };
+          }
+        },
+      };
+    }, { name: 'memory_pending' });
+  }
+
+  return { aquifer, productStatusToolsRegistered: true };
+}
+
+module.exports = {
+  clampLimit,
+  manifestToolDescription,
+  normalizeSkipTools,
+  pendingSessionOpts,
+  registerOpenClawProductStatusTools,
+};

package/consumers/shared/recall-format.js

@@ -2,8 +2,8 @@
 
 // ---------------------------------------------------------------------------
 // Shared recall formatter — turns aquifer.recall() rows into human-readable
-// text. The default is English and markdown-ish; consumers with a persona
-// (Miranda: zh-TW narrative) can override individual renderers.
+// text. The default is English and markdown-ish; persona adapters can override
+// individual renderers.
 // ---------------------------------------------------------------------------
 
 function truncate(s, n) {