@memoryrelay/plugin-memoryrelay-ai 0.6.2 → 0.8.0

package/openclaw.plugin.json

@@ -2,14 +2,14 @@
   "id": "plugin-memoryrelay-ai",
   "kind": "memory",
   "name": "MemoryRelay AI",
-  "description": "AI memory service using MemoryRelay API (api.memoryrelay.net)",
-  "version": "0.6.2",
+  "description": "AI memory service with sessions, decisions, patterns & projects (api.memoryrelay.net)",
+  "version": "0.7.0",
   "uiHints": {
     "apiKey": {
       "label": "MemoryRelay API Key",
       "sensitive": true,
       "placeholder": "mem_prod_...",
-      "help": "API key from memoryrelay.io (or use ${MEMORYRELAY_API_KEY} env var)"
+      "help": "API key from memoryrelay.ai (or use ${MEMORYRELAY_API_KEY} env var)"
     },
     "agentId": {
       "label": "Agent ID",
@@ -22,6 +22,17 @@
       "advanced": true,
       "help": "MemoryRelay API endpoint (or use ${MEMORYRELAY_API_URL} env var)"
     },
+    "defaultProject": {
+      "label": "Default Project",
+      "placeholder": "my-api",
+      "help": "Default project slug for scoping sessions, decisions, and memories"
+    },
+    "enabledTools": {
+      "label": "Enabled Tools",
+      "placeholder": "memory,entity,agent,session,decision,pattern,project,health",
+      "advanced": true,
+      "help": "Comma-separated list of tool groups to enable (default: all)"
+    },
     "autoCapture": {
       "label": "Auto-Capture",
       "help": "Automatically capture important information from conversations"
@@ -54,6 +65,14 @@
         "type": "string",
         "default": "https://api.memoryrelay.net"
       },
+      "defaultProject": {
+        "type": "string",
+        "description": "Default project slug for scoping sessions, decisions, and memories"
+      },
+      "enabledTools": {
+        "type": "string",
+        "description": "Comma-separated tool groups to enable: memory, entity, agent, session, decision, pattern, project, health, or 'all' (default: all)"
+      },
       "autoCapture": {
         "type": "boolean",
         "default": false

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@memoryrelay/plugin-memoryrelay-ai",
-  "version": "0.6.2",
-  "description": "OpenClaw memory plugin for MemoryRelay API - long-term memory with semantic search (ENHANCED)",
+  "version": "0.8.0",
+  "description": "OpenClaw memory plugin for MemoryRelay API - sessions, decisions, patterns, projects & semantic search",
   "type": "module",
   "main": "index.ts",
   "scripts": {
@@ -43,8 +43,16 @@
       "./index.ts"
     ]
   },
+  "bin": {
+    "memoryrelay-logs": "./bin/memoryrelay-logs.js",
+    "memoryrelay-health": "./bin/memoryrelay-health.js",
+    "memoryrelay-test": "./bin/memoryrelay-test.js",
+    "memoryrelay-metrics": "./bin/memoryrelay-metrics.js"
+  },
   "files": [
     "index.ts",
+    "src/",
+    "bin/",
     "openclaw.plugin.json",
     "README.md",
     "LICENSE"

package/src/debug-logger.test.ts

@@ -0,0 +1,233 @@
+/**
+ * DebugLogger Tests (Corrected)
+ * 
+ * Tests matching actual implementation
+ */
+
+import { describe, test, expect, beforeEach, vi } from "vitest";
+import { DebugLogger, type LogEntry } from "./debug-logger";
+import * as fs from "fs";
+
+vi.mock("fs");
+
+describe("DebugLogger", () => {
+  let logger: DebugLogger;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    logger = new DebugLogger({
+      enabled: true,
+      verbose: false,
+      maxEntries: 5,
+    });
+  });
+
+  test("logs are stored when enabled", () => {
+    logger.log({
+      timestamp: new Date().toISOString(),
+      tool: "memory_store",
+      method: "POST",
+      path: "/v1/memories",
+      duration: 142,
+      status: "success",
+    });
+
+    const logs = logger.getAllLogs();
+    expect(logs).toHaveLength(1);
+  });
+
+  test("logs are not stored when disabled", () => {
+    const disabledLogger = new DebugLogger({
+      enabled: false,
+      verbose: false,
+      maxEntries: 5,
+    });
+
+    disabledLogger.log({
+      timestamp: new Date().toISOString(),
+      tool: "memory_store",
+      method: "POST",
+      path: "/v1/memories",
+      duration: 142,
+      status: "success",
+    });
+
+    const logs = disabledLogger.getAllLogs();
+    expect(logs).toHaveLength(0);
+  });
+
+  test("respects circular buffer limit (FIFO)", () => {
+    for (let i = 0; i < 10; i++) {
+      logger.log({
+        timestamp: new Date(Date.now() + i).toISOString(),
+        tool: `tool_${i}`,
+        method: "GET",
+        path: `/test/${i}`,
+        duration: 100,
+        status: "success",
+      });
+    }
+
+    const logs = logger.getAllLogs();
+    expect(logs).toHaveLength(5); // maxEntries = 5
+    expect(logs[0].tool).toBe("tool_5"); // Oldest kept
+    expect(logs[4].tool).toBe("tool_9"); // Newest
+  });
+
+  test("getRecentLogs returns last N entries", () => {
+    for (let i = 0; i < 3; i++) {
+      logger.log({
+        timestamp: new Date(Date.now() + i).toISOString(),
+        tool: `tool_${i}`,
+        method: "GET",
+        path: `/test/${i}`,
+        duration: 100,
+        status: "success",
+      });
+    }
+
+    const logs = logger.getRecentLogs(2);
+    expect(logs).toHaveLength(2);
+    expect(logs[0].tool).toBe("tool_1"); // Second-to-last
+    expect(logs[1].tool).toBe("tool_2"); // Last
+  });
+
+  test("getToolLogs filters by tool name", () => {
+    logger.log({
+      timestamp: new Date().toISOString(),
+      tool: "memory_store",
+      method: "POST",
+      path: "/v1/memories",
+      duration: 142,
+      status: "success",
+    });
+    logger.log({
+      timestamp: new Date().toISOString(),
+      tool: "memory_recall",
+      method: "POST",
+      path: "/v1/memories/search",
+      duration: 78,
+      status: "success",
+    });
+    logger.log({
+      timestamp: new Date().toISOString(),
+      tool: "memory_store",
+      method: "POST",
+      path: "/v1/memories",
+      duration: 156,
+      status: "error",
+      error: "500",
+    });
+
+    const logs = logger.getToolLogs("memory_store", 10);
+    expect(logs).toHaveLength(2);
+    expect(logs.every(l => l.tool === "memory_store")).toBe(true);
+  });
+
+  test("getErrorLogs filters by error status", () => {
+    logger.log({
+      timestamp: new Date().toISOString(),
+      tool: "memory_store",
+      method: "POST",
+      path: "/v1/memories",
+      duration: 142,
+      status: "success",
+    });
+    logger.log({
+      timestamp: new Date().toISOString(),
+      tool: "memory_recall",
+      method: "POST",
+      path: "/v1/memories/search",
+      duration: 78,
+      status: "error",
+      error: "404",
+    });
+
+    const logs = logger.getErrorLogs(10);
+    expect(logs).toHaveLength(1);
+    expect(logs[0].status).toBe("error");
+  });
+
+  test("getStats calculates correctly", () => {
+    logger.log({
+      timestamp: new Date().toISOString(),
+      tool: "memory_store",
+      method: "POST",
+      path: "/v1/memories",
+      duration: 100,
+      status: "success",
+    });
+    logger.log({
+      timestamp: new Date().toISOString(),
+      tool: "memory_recall",
+      method: "POST",
+      path: "/v1/memories/search",
+      duration: 200,
+      status: "success",
+    });
+    logger.log({
+      timestamp: new Date().toISOString(),
+      tool: "memory_store",
+      method: "POST",
+      path: "/v1/memories",
+      duration: 150,
+      status: "error",
+      error: "500",
+    });
+
+    const stats = logger.getStats();
+    expect(stats.total).toBe(3);
+    expect(stats.successful).toBe(2);
+    expect(stats.failed).toBe(1);
+    expect(stats.avgDuration).toBe(150); // (100+200+150)/3 = 150
+  });
+
+  test("clear() empties logs", () => {
+    logger.log({
+      timestamp: new Date().toISOString(),
+      tool: "memory_store",
+      method: "POST",
+      path: "/v1/memories",
+      duration: 142,
+      status: "success",
+    });
+
+    logger.clear();
+    const logs = logger.getAllLogs();
+    expect(logs).toHaveLength(0);
+  });
+
+  test("formatEntry creates human-readable output", () => {
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      tool: "memory_store",
+      method: "POST",
+      path: "/v1/memories",
+      duration: 142,
+      status: "success",
+    };
+
+    const formatted = DebugLogger.formatEntry(entry);
+    expect(formatted).toContain("memory_store");
+    expect(formatted).toContain("142ms");
+    expect(formatted).toContain("✓");
+  });
+
+  test("formatEntry shows error", () => {
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      tool: "memory_store",
+      method: "POST",
+      path: "/v1/memories",
+      duration: 156,
+      status: "error",
+      error: "500 Internal Server Error",
+    };
+
+    const formatted = DebugLogger.formatEntry(entry);
+    expect(formatted).toContain("memory_store");
+    expect(formatted).toContain("156ms");
+    expect(formatted).toContain("✗");
+    expect(formatted).toContain("500 Internal Server Error");
+  });
+});

package/src/debug-logger.ts

@@ -0,0 +1,187 @@
+/**
+ * Debug Logger for MemoryRelay OpenClaw Plugin
+ * 
+ * Provides comprehensive logging of API calls with request/response capture
+ * for troubleshooting and performance analysis.
+ */
+
+export interface LogEntry {
+  timestamp: string;
+  tool: string;
+  method: string;
+  path: string;
+  duration: number;
+  status: "success" | "error";
+  requestBody?: unknown;
+  responseBody?: unknown;
+  responseStatus?: number;
+  error?: string;
+  retries?: number;
+}
+
+export interface DebugLoggerConfig {
+  enabled: boolean;
+  verbose: boolean;
+  maxEntries: number;
+  logFile?: string;
+}
+
+export class DebugLogger {
+  private logs: LogEntry[] = [];
+  private config: DebugLoggerConfig;
+  private fs?: typeof import("fs");
+
+  constructor(config: DebugLoggerConfig) {
+    this.config = config;
+    
+    // Only load fs if logFile is specified
+    if (config.logFile) {
+      try {
+        this.fs = require("fs");
+      } catch (err) {
+        console.warn("fs module not available, file logging disabled");
+      }
+    }
+  }
+
+  /**
+   * Log an API call
+   */
+  log(entry: LogEntry): void {
+    if (!this.config.enabled) return;
+
+    // Add to in-memory buffer
+    this.logs.push(entry);
+    
+    // Trim if exceeds max
+    if (this.logs.length > this.config.maxEntries) {
+      this.logs.shift();
+    }
+
+    // Write to file if configured
+    if (this.config.logFile && this.fs) {
+      this.writeToFile(entry);
+    }
+  }
+
+  /**
+   * Get recent logs
+   */
+  getRecentLogs(limit: number = 10): LogEntry[] {
+    return this.logs.slice(-limit);
+  }
+
+  /**
+   * Get logs for specific tool
+   */
+  getToolLogs(toolName: string, limit: number = 10): LogEntry[] {
+    return this.logs
+      .filter(log => log.tool === toolName)
+      .slice(-limit);
+  }
+
+  /**
+   * Get error logs only
+   */
+  getErrorLogs(limit: number = 10): LogEntry[] {
+    return this.logs
+      .filter(log => log.status === "error")
+      .slice(-limit);
+  }
+
+  /**
+   * Get all logs
+   */
+  getAllLogs(): LogEntry[] {
+    return [...this.logs];
+  }
+
+  /**
+   * Clear logs
+   */
+  clear(): void {
+    this.logs = [];
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats() {
+    const total = this.logs.length;
+    const successful = this.logs.filter(l => l.status === "success").length;
+    const failed = total - successful;
+    const avgDuration = total > 0
+      ? this.logs.reduce((sum, l) => sum + l.duration, 0) / total
+      : 0;
+
+    return {
+      total,
+      successful,
+      failed,
+      successRate: total > 0 ? (successful / total) * 100 : 0,
+      avgDuration: Math.round(avgDuration),
+    };
+  }
+
+  /**
+   * Write log entry to file
+   */
+  private writeToFile(entry: LogEntry): void {
+    if (!this.fs || !this.config.logFile) return;
+
+    try {
+      const logLine = JSON.stringify(entry) + "\n";
+      this.fs.appendFileSync(this.config.logFile, logLine, "utf8");
+    } catch (err) {
+      console.error(`Failed to write debug log: ${err}`);
+    }
+  }
+
+  /**
+   * Format log entry for display
+   */
+  static formatEntry(entry: LogEntry): string {
+    const timestamp = new Date(entry.timestamp).toLocaleTimeString();
+    const status = entry.status === "success" ? "✓" : "✗";
+    const duration = `${entry.duration}ms`;
+    
+    let output = `${timestamp}  ${entry.tool.padEnd(20)} ${duration.padStart(6)}  ${status}`;
+    
+    if (entry.error) {
+      output += `\n          Error: ${entry.error}`;
+    }
+    
+    if (entry.retries && entry.retries > 0) {
+      output += ` (${entry.retries} retries)`;
+    }
+    
+    return output;
+  }
+
+  /**
+   * Format logs as table
+   */
+  static formatTable(logs: LogEntry[]): string {
+    if (logs.length === 0) {
+      return "No logs available";
+    }
+
+    const lines = [
+      "TIMESTAMP          TOOL                    DURATION  STATUS  ERROR",
+      "━━━━━━━━━━━━━━━━━  ━━━━━━━━━━━━━━━━━━━━━  ━━━━━━━━  ━━━━━━  ━━━━━━━━━━━━━━━━━━━━━━━━━",
+    ];
+
+    for (const entry of logs) {
+      const timestamp = new Date(entry.timestamp).toLocaleTimeString();
+      const status = entry.status === "success" ? "✓" : "✗";
+      const duration = `${entry.duration}ms`;
+      const error = entry.error ? entry.error.substring(0, 30) : "";
+      
+      lines.push(
+        `${timestamp}  ${entry.tool.padEnd(20)}  ${duration.padStart(8)}  ${status.padEnd(6)}  ${error}`
+      );
+    }
+
+    return lines.join("\n");
+  }
+}