@memoryrelay/plugin-memoryrelay-ai 0.7.0 → 0.8.0

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");
+  }
+}

package/src/status-reporter.test.ts

@@ -0,0 +1,230 @@
+/**
+ * StatusReporter Tests (Simplified)
+ * 
+ * Tests matching actual implementation
+ */
+
+import { describe, test, expect, beforeEach } from "vitest";
+import { StatusReporter, type ConnectionStatus, type PluginConfig, type MemoryStats } from "./status-reporter";
+import { DebugLogger } from "./debug-logger";
+
+describe("StatusReporter", () => {
+  let reporter: StatusReporter;
+  let debugLogger: DebugLogger;
+  let mockConnection: ConnectionStatus;
+  let mockConfig: PluginConfig;
+  let mockStats: MemoryStats;
+
+  beforeEach(() => {
+    debugLogger = new DebugLogger({
+      enabled: true,
+      verbose: false,
+      maxEntries: 100,
+    });
+    reporter = new StatusReporter(debugLogger);
+
+    mockConnection = {
+      status: "connected",
+      endpoint: "https://api.memoryrelay.net",
+      lastCheck: new Date().toISOString(),
+      responseTime: 45,
+    };
+
+    mockConfig = {
+      agentId: "test-agent",
+      autoRecall: true,
+      autoCapture: false,
+      recallLimit: 5,
+      recallThreshold: 0.3,
+      excludeChannels: [],
+    };
+
+    mockStats = {
+      total_memories: 100,
+    };
+  });
+
+  test("records and clears tool failures", () => {
+    reporter.recordFailure("memory_store", "500 Error");
+    let issues = reporter.getIssues();
+    expect(issues).toHaveLength(1);
+    expect(issues[0].tool).toBe("memory_store");
+
+    reporter.recordSuccess("memory_store");
+    issues = reporter.getIssues();
+    expect(issues).toHaveLength(0);
+  });
+
+  test("buildReport creates status report", () => {
+    const toolGroups = {
+      "Core Memory": ["memory_store", "memory_recall"],
+      "Projects": ["project_list"],
+    };
+
+    const report = reporter.buildReport(
+      mockConnection,
+      mockConfig,
+      mockStats,
+      toolGroups,
+    );
+
+    expect(report.connection).toEqual(mockConnection);
+    expect(report.config).toEqual(mockConfig);
+    expect(report.stats).toEqual(mockStats);
+    expect(report.tools["Core Memory"]).toBeDefined();
+    expect(report.tools["Projects"]).toBeDefined();
+  });
+
+  test("buildReport includes tool status from debug logs", () => {
+    debugLogger.log({
+      timestamp: new Date().toISOString(),
+      tool: "memory_store",
+      method: "POST",
+      path: "/v1/memories",
+      duration: 142,
+      status: "success",
+    });
+
+    const toolGroups = {
+      "Core Memory": ["memory_store"],
+    };
+
+    const report = reporter.buildReport(
+      mockConnection,
+      mockConfig,
+      mockStats,
+      toolGroups,
+    );
+
+    const memoryTools = report.tools["Core Memory"];
+    expect(memoryTools.available).toBe(1);
+    expect(memoryTools.failed).toBe(0);
+    expect(memoryTools.tools[0].status).toBe("working");
+  });
+
+  test("buildReport shows failed tools", () => {
+    debugLogger.log({
+      timestamp: new Date().toISOString(),
+      tool: "memory_store",
+      method: "POST",
+      path: "/v1/memories",
+      duration: 156,
+      status: "error",
+      error: "500 Internal Server Error",
+    });
+
+    const toolGroups = {
+      "Core Memory": ["memory_store"],
+    };
+
+    const report = reporter.buildReport(
+      mockConnection,
+      mockConfig,
+      mockStats,
+      toolGroups,
+    );
+
+    const memoryTools = report.tools["Core Memory"];
+    expect(memoryTools.available).toBe(0);
+    expect(memoryTools.failed).toBe(1);
+    expect(memoryTools.tools[0].status).toBe("error");
+    expect(memoryTools.tools[0].error).toBe("500 Internal Server Error");
+  });
+
+  test("buildReport includes recent calls", () => {
+    debugLogger.log({
+      timestamp: new Date().toISOString(),
+      tool: "memory_store",
+      method: "POST",
+      path: "/v1/memories",
+      duration: 142,
+      status: "success",
+    });
+
+    const toolGroups = {
+      "Core Memory": ["memory_store"],
+    };
+
+    const report = reporter.buildReport(
+      mockConnection,
+      mockConfig,
+      mockStats,
+      toolGroups,
+    );
+
+    expect(report.recentCalls).toHaveLength(1);
+    expect(report.recentCalls[0].tool).toBe("memory_store");
+  });
+
+  test("formatReport creates human-readable output", () => {
+    const toolGroups = {
+      "Core Memory": ["memory_store", "memory_recall"],
+    };
+
+    const report = reporter.buildReport(
+      mockConnection,
+      mockConfig,
+      mockStats,
+      toolGroups,
+    );
+
+    const formatted = StatusReporter.formatReport(report);
+    expect(formatted).toContain("MemoryRelay Plugin Status");
+    expect(formatted).toContain("connected");
+    expect(formatted).toContain("Core Memory");
+  });
+
+  test("formatCompact creates brief output", () => {
+    const toolGroups = {
+      "Core Memory": ["memory_store"],
+    };
+
+    const report = reporter.buildReport(
+      mockConnection,
+      mockConfig,
+      mockStats,
+      toolGroups,
+    );
+
+    const compact = StatusReporter.formatCompact(report);
+    expect(compact).toContain("connected");
+    expect(compact.length).toBeLessThan(200); // Should be brief
+  });
+
+  test("handles disconnected status", () => {
+    mockConnection.status = "disconnected";
+
+    const toolGroups = {
+      "Core Memory": ["memory_store"],
+    };
+
+    const report = reporter.buildReport(
+      mockConnection,
+      mockConfig,
+      mockStats,
+      toolGroups,
+    );
+
+    expect(report.connection.status).toBe("disconnected");
+    const formatted = StatusReporter.formatReport(report);
+    expect(formatted).toContain("disconnected");
+  });
+
+  test("includes issues in report", () => {
+    reporter.recordFailure("memory_batch_store", "500 Error");
+
+    const toolGroups = {
+      "Core Memory": ["memory_batch_store"],
+    };
+
+    const report = reporter.buildReport(
+      mockConnection,
+      mockConfig,
+      mockStats,
+      toolGroups,
+    );
+
+    expect(report.issues).toHaveLength(1);
+    expect(report.issues[0].tool).toBe("memory_batch_store");
+  });
+});