@ghl-ai/aw 0.1.37-beta.30 → 0.1.37-beta.32

package/commands/memory.mjs

@@ -35,7 +35,7 @@ async function memoryStore(args) {
   if (args['--tags'])      params.tags = args['--tags'].split(',').map(s => s.trim());
 
   const s = fmt.spinner();
-  s.start('Storing memory via memory_curated_store...');
+  s.start('Storing memory...');
   try {
     const result = await callMemoryTool('memory_curated_store', params);
     s.stop('Memory stored');
@@ -156,40 +156,53 @@ async function memoryStats(args) {
   const s = fmt.spinner();
   s.start('Fetching memory statistics...');
   try {
-    const result = await callMemoryTool('memory_stats', params);
+    // No dedicated stats tool — use memory_search with broad query and aggregate
+    const result = await callMemoryTool('memory_search', { query: '*', limit: 200, ...params });
     s.stop('Stats loaded');
 
-    const stats = result?.stats ?? result;
+    const memories = result?.memories ?? result?.results ?? [];
+    const total = memories.length;
+
+    // Aggregate by layer, overlay, angle
+    const byLayer = {};
+    const byOverlay = {};
+    const byAngle = {};
+    for (const mem of memories) {
+      const layer = mem.layer || 'unclassified';
+      byLayer[layer] = (byLayer[layer] || 0) + 1;
+      for (const o of (mem.overlay || mem.overlays || [])) {
+        byOverlay[o] = (byOverlay[o] || 0) + 1;
+      }
+      for (const a of (mem.angle || mem.angles || [])) {
+        byAngle[a] = (byAngle[a] || 0) + 1;
+      }
+    }
 
-    if (stats.by_layer) {
-      const layerLines = Object.entries(stats.by_layer)
+    if (Object.keys(byLayer).length) {
+      const layerLines = Object.entries(byLayer)
+        .sort((a, b) => b[1] - a[1])
         .map(([layer, count]) => `  ${chalk.cyan(layer.padEnd(20))} ${count}`)
         .join('\n');
       fmt.note(layerLines, 'By Layer');
     }
 
-    if (stats.by_overlay) {
-      const overlayLines = Object.entries(stats.by_overlay)
+    if (Object.keys(byOverlay).length) {
+      const overlayLines = Object.entries(byOverlay)
+        .sort((a, b) => b[1] - a[1])
         .map(([overlay, count]) => `  ${chalk.magenta(overlay.padEnd(20))} ${count}`)
         .join('\n');
       fmt.note(overlayLines, 'By Overlay');
     }
 
-    if (stats.by_angle) {
-      const angleLines = Object.entries(stats.by_angle)
+    if (Object.keys(byAngle).length) {
+      const angleLines = Object.entries(byAngle)
+        .sort((a, b) => b[1] - a[1])
         .map(([angle, count]) => `  ${chalk.yellow(angle.padEnd(20))} ${count}`)
         .join('\n');
       fmt.note(angleLines, 'By Angle');
     }
 
-    if (stats.total != null) {
-      fmt.logStep(`Total memories: ${chalk.bold(stats.total)}`);
-    }
-
-    if (stats.recent_activity) {
-      fmt.logStep(`Recent activity: ${chalk.dim(stats.recent_activity)}`);
-    }
-
+    fmt.logStep(`Total memories: ${chalk.bold(total)}`);
     fmt.outro('Stats complete');
   } catch (err) {
     s.stop(chalk.red('Failed'));

package/memory-bridge.mjs

@@ -0,0 +1,68 @@
+// memory-bridge.mjs — Bridge between CLI and MCP memory backend (JSON-RPC)
+
+import { MCP_BASE_URL } from './constants.mjs';
+
+let _rpcId = 1;
+
+/**
+ * Call an MCP memory tool by name via JSON-RPC 2.0 (Streamable HTTP).
+ * @param {string} toolName — MCP tool name (e.g. 'memory_curated_store', 'memory_search')
+ * @param {object} params  — Tool arguments
+ * @returns {Promise<object>} Parsed tool result
+ */
+export async function callMemoryTool(toolName, params) {
+  const response = await fetch(MCP_BASE_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json, text/event-stream',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: _rpcId++,
+      method: 'tools/call',
+      params: { name: toolName, arguments: params },
+    }),
+    signal: AbortSignal.timeout(30000),
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => '');
+    throw new Error(`MCP ${toolName} failed: ${response.status} ${body}`);
+  }
+
+  const contentType = response.headers.get('content-type') || '';
+
+  // Handle SSE responses (text/event-stream)
+  if (contentType.includes('text/event-stream')) {
+    const text = await response.text();
+    const lines = text.split('\n');
+    for (const line of lines) {
+      if (line.startsWith('data: ')) {
+        try {
+          const event = JSON.parse(line.slice(6));
+          if (event.result) return extractToolResult(event.result);
+          if (event.error) throw new Error(`MCP ${toolName}: ${event.error.message}`);
+        } catch (e) {
+          if (e.message.startsWith('MCP ')) throw e;
+        }
+      }
+    }
+    throw new Error(`MCP ${toolName}: no result in SSE stream`);
+  }
+
+  // Handle direct JSON responses
+  const json = await response.json();
+  if (json.error) throw new Error(`MCP ${toolName}: ${json.error.message}`);
+  return extractToolResult(json.result);
+}
+
+/** Extract the actual content from an MCP tools/call result. */
+function extractToolResult(result) {
+  if (!result) return {};
+  // MCP tools/call returns { content: [{ type: 'text', text: '...' }] }
+  const content = result.content;
+  if (Array.isArray(content) && content.length > 0 && content[0].text) {
+    try { return JSON.parse(content[0].text); } catch { return { text: content[0].text }; }
+  }
+  return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.37-beta.30",
+  "version": "0.1.37-beta.32",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": "bin.js",
@@ -26,7 +26,8 @@
     "hooks.mjs",
     "ecc.mjs",
     "render-rules.mjs",
-    "telemetry.mjs"
+    "telemetry.mjs",
+    "memory-bridge.mjs"
   ],
   "engines": {
     "node": ">=18.0.0"