@memoryrelay/plugin-memoryrelay-ai 0.12.0 → 0.12.2

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,169 @@
+/**
+ * Debug Logger for MemoryRelay OpenClaw Plugin
+ * 
+ * Provides comprehensive logging of API calls with request/response capture
+ * for troubleshooting and performance analysis.
+ * 
+ * Note: File logging has been removed in v0.8.4 to pass OpenClaw security validation.
+ * All logs are kept in-memory only. Use gateway methods (coming in v0.9.0) to access logs.
+ */
+
+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; // Deprecated: File logging removed for security compliance
+}
+
+export class DebugLogger {
+  private logs: LogEntry[] = [];
+  private config: DebugLoggerConfig;
+
+  constructor(config: DebugLoggerConfig) {
+    this.config = config;
+    
+    // logFile is no longer supported (v0.8.4)
+    if (config.logFile) {
+      console.warn(
+        "memoryrelay: logFile is deprecated and ignored. " +
+        "Use gateway methods to access debug logs (coming in v0.9.0)"
+      );
+    }
+  }
+
+  /**
+   * 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();
+    }
+  }
+
+  /**
+   * 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),
+    };
+  }
+
+  /**
+   * 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/heartbeat/daily-stats.ts

@@ -0,0 +1,233 @@
+/**
+ * Daily Memory Stats for Heartbeat (Phase 1 - Issue #10)
+ * 
+ * Provides morning and evening memory stat summaries for agent heartbeat checks.
+ * Shows growth trends, categories, and most valuable memories.
+ */
+
+export interface DailyStatsConfig {
+  enabled: boolean;
+  morningTime?: string; // HH:MM format (default: "09:00")
+  eveningTime?: string; // HH:MM format (default: "20:00")
+  timezone?: string; // IANA timezone (default: system timezone)
+}
+
+export interface MemoryStats {
+  total: number;
+  today: number;
+  thisWeek: number;
+  weeklyGrowth: number; // Percentage change from last week
+  topCategories: Array<{ category: string; count: number }>;
+  mostValuable?: {
+    id: string;
+    content: string;
+    recallCount: number;
+  };
+}
+
+export interface HeartbeatResult {
+  shouldNotify: boolean;
+  message?: string;
+  stats?: MemoryStats;
+}
+
+/**
+ * Calculate memory statistics for the current period
+ */
+export async function calculateStats(
+  getAllMemories: () => Promise<Array<{ id: string; content: string; metadata: Record<string, string>; created_at: number }>>,
+  getRecallCount: (memoryId: string) => number = () => 0
+): Promise<MemoryStats> {
+  const memories = await getAllMemories();
+  const now = Date.now();
+  const todayStart = new Date().setHours(0, 0, 0, 0);
+  const weekStart = now - 7 * 24 * 60 * 60 * 1000;
+  const lastWeekStart = now - 14 * 24 * 60 * 60 * 1000;
+
+  // Count memories by period
+  const total = memories.length;
+  const today = memories.filter((m) => m.created_at >= todayStart).length;
+  const thisWeek = memories.filter((m) => m.created_at >= weekStart).length;
+  const lastWeek = memories.filter(
+    (m) => m.created_at >= lastWeekStart && m.created_at < weekStart
+  ).length;
+
+  // Calculate weekly growth
+  const weeklyGrowth = lastWeek > 0 ? ((thisWeek - lastWeek) / lastWeek) * 100 : 0;
+
+  // Top categories
+  const categoryCount = new Map<string, number>();
+  for (const memory of memories) {
+    const category = memory.metadata.category || "uncategorized";
+    categoryCount.set(category, (categoryCount.get(category) || 0) + 1);
+  }
+
+  const topCategories = Array.from(categoryCount.entries())
+    .map(([category, count]) => ({ category, count }))
+    .sort((a, b) => b.count - a.count)
+    .slice(0, 5);
+
+  // Most valuable memory (by recall count - simulated for now)
+  let mostValuable: MemoryStats["mostValuable"];
+  if (memories.length > 0) {
+    const memoriesWithRecalls = memories.map((m) => ({
+      ...m,
+      recallCount: getRecallCount(m.id),
+    }));
+    memoriesWithRecalls.sort((a, b) => b.recallCount - a.recallCount);
+
+    if (memoriesWithRecalls[0].recallCount > 0) {
+      mostValuable = {
+        id: memoriesWithRecalls[0].id,
+        content: memoriesWithRecalls[0].content.slice(0, 100) + "...",
+        recallCount: memoriesWithRecalls[0].recallCount,
+      };
+    }
+  }
+
+  return {
+    total,
+    today,
+    thisWeek,
+    weeklyGrowth,
+    topCategories,
+    mostValuable,
+  };
+}
+
+/**
+ * Morning check: Show memory stats and growth
+ */
+export async function morningCheck(
+  stats: MemoryStats
+): Promise<HeartbeatResult> {
+  // Don't notify if no activity or very early in adoption
+  if (stats.total < 5 && stats.today === 0) {
+    return { shouldNotify: false };
+  }
+
+  // Build morning message
+  const lines: string[] = [];
+  lines.push("📊 Morning Memory Check");
+  lines.push("");
+  lines.push(`📚 Total memories: ${stats.total}`);
+  
+  if (stats.today > 0) {
+    lines.push(`✨ Added today: ${stats.today}`);
+  }
+  
+  if (stats.thisWeek > 0) {
+    const growthIndicator = stats.weeklyGrowth > 0 ? "📈" : stats.weeklyGrowth < 0 ? "📉" : "➡️";
+    lines.push(`${growthIndicator} This week: ${stats.thisWeek} (${stats.weeklyGrowth > 0 ? '+' : ''}${stats.weeklyGrowth.toFixed(0)}%)`);
+  }
+
+  if (stats.topCategories.length > 0) {
+    lines.push("");
+    lines.push("🏆 Top categories:");
+    for (const cat of stats.topCategories.slice(0, 3)) {
+      lines.push(`  • ${cat.category}: ${cat.count}`);
+    }
+  }
+
+  return {
+    shouldNotify: true,
+    message: lines.join("\n"),
+    stats,
+  };
+}
+
+/**
+ * Evening review: Show today's activity and most valuable memory
+ */
+export async function eveningReview(
+  stats: MemoryStats
+): Promise<HeartbeatResult> {
+  // Don't notify if no activity today
+  if (stats.today === 0 && !stats.mostValuable) {
+    return { shouldNotify: false };
+  }
+
+  const lines: string[] = [];
+  lines.push("🌙 Evening Memory Review");
+  lines.push("");
+
+  if (stats.today > 0) {
+    lines.push(`✅ Stored today: ${stats.today} memories`);
+  } else {
+    lines.push("📝 No new memories today");
+  }
+
+  if (stats.mostValuable) {
+    lines.push("");
+    lines.push("💎 Most valuable memory:");
+    lines.push(`  "${stats.mostValuable.content}"`);
+    lines.push(`  Recalled ${stats.mostValuable.recallCount} times`);
+  }
+
+  return {
+    shouldNotify: stats.today > 0 || (stats.mostValuable !== undefined),
+    message: lines.join("\n"),
+    stats,
+  };
+}
+
+/**
+ * Check if it's time for a heartbeat notification
+ */
+export function shouldRunHeartbeat(
+  config: DailyStatsConfig,
+  currentTime: Date = new Date()
+): "morning" | "evening" | null {
+  if (!config.enabled) return null;
+
+  const morningTime = config.morningTime || "09:00";
+  const eveningTime = config.eveningTime || "20:00";
+
+  const [morningHour, morningMin] = morningTime.split(":").map(Number);
+  const [eveningHour, eveningMin] = eveningTime.split(":").map(Number);
+
+  const currentHour = currentTime.getHours();
+  const currentMin = currentTime.getMinutes();
+
+  // Check if within 5-minute window of morning time
+  const morningStart = morningHour * 60 + morningMin;
+  const morningEnd = morningStart + 5;
+  const currentMinutes = currentHour * 60 + currentMin;
+
+  if (currentMinutes >= morningStart && currentMinutes < morningEnd) {
+    return "morning";
+  }
+
+  // Check if within 5-minute window of evening time
+  const eveningStart = eveningHour * 60 + eveningMin;
+  const eveningEnd = eveningStart + 5;
+
+  if (currentMinutes >= eveningStart && currentMinutes < eveningEnd) {
+    return "evening";
+  }
+
+  return null;
+}
+
+/**
+ * Format stats for console/log output
+ */
+export function formatStatsForDisplay(stats: MemoryStats): string {
+  const lines: string[] = [];
+  lines.push(`Total: ${stats.total} | Today: ${stats.today} | Week: ${stats.thisWeek}`);
+  
+  if (stats.weeklyGrowth !== 0) {
+    const sign = stats.weeklyGrowth > 0 ? "+" : "";
+    lines.push(`Growth: ${sign}${stats.weeklyGrowth.toFixed(0)}%`);
+  }
+
+  if (stats.topCategories.length > 0) {
+    const topCats = stats.topCategories
+      .slice(0, 3)
+      .map((c) => `${c.category}(${c.count})`)
+      .join(", ");
+    lines.push(`Top: ${topCats}`);
+  }
+
+  return lines.join(" | ");
+}