@memoryrelay/plugin-memoryrelay-ai 0.9.4 → 0.9.6

package/index.ts

@@ -1,6 +1,6 @@
 /**
  * OpenClaw Memory Plugin - MemoryRelay (Single File Version)
- * Version: 0.9.4
+ * Version: 0.9.6
  */
 
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";

package/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "kind": "memory",
   "name": "MemoryRelay AI",
   "description": "AI memory service with sessions, decisions, patterns & projects (api.memoryrelay.net)",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "uiHints": {
     "apiKey": {
       "label": "MemoryRelay API Key",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memoryrelay/plugin-memoryrelay-ai",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "OpenClaw memory plugin for MemoryRelay API - sessions, decisions, patterns, projects & semantic search",
   "type": "module",
   "main": "index.ts",
@@ -39,13 +39,11 @@
   "openclaw": {
     "id": "plugin-memoryrelay-ai",
     "extensions": [
-      "./index.ts"
+      "index.ts"
     ]
   },
   "files": [
     "index.ts",
-    "src/*.ts",
-    "!src/*.test.ts",
     "openclaw.plugin.json",
     "README.md",
     "LICENSE"

package/src/debug-logger.ts

@@ -1,169 +0,0 @@
-/**
- * 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/status-reporter.ts

@@ -1,284 +0,0 @@
-/**
- * Status Reporter for MemoryRelay OpenClaw Plugin
- * 
- * Provides comprehensive status reporting for openclaw status command
- * including connection status, tool breakdown, and recent activity.
- */
-
-import type { LogEntry, DebugLogger } from "./debug-logger";
-
-export interface ToolStatus {
-  enabled: number;
-  available: number;
-  failed: number;
-  tools: {
-    name: string;
-    status: "working" | "error" | "unknown";
-    error?: string;
-    lastSuccess?: string;
-    lastError?: string;
-  }[];
-}
-
-export interface ConnectionStatus {
-  status: "connected" | "disconnected" | "degraded";
-  endpoint: string;
-  lastCheck: string;
-  responseTime: number;
-}
-
-export interface MemoryStats {
-  total_memories: number;
-  memories_today?: number;
-  last_stored?: string;
-  search_count_24h?: number;
-}
-
-export interface PluginConfig {
-  agentId: string;
-  autoRecall: boolean;
-  autoCapture: boolean;
-  recallLimit: number;
-  recallThreshold: number;
-  excludeChannels: string[];
-  defaultProject?: string;
-}
-
-export interface StatusReport {
-  connection: ConnectionStatus;
-  config: PluginConfig;
-  stats: MemoryStats;
-  tools: Record<string, ToolStatus>;
-  recentCalls: LogEntry[];
-  issues: { tool: string; error: string; since: string }[];
-}
-
-export class StatusReporter {
-  private debugLogger?: DebugLogger;
-  private toolFailures: Map<string, { error: string; since: string }> = new Map();
-
-  constructor(debugLogger?: DebugLogger) {
-    this.debugLogger = debugLogger;
-  }
-
-  /**
-   * Record tool failure
-   */
-  recordFailure(toolName: string, error: string): void {
-    if (!this.toolFailures.has(toolName)) {
-      this.toolFailures.set(toolName, {
-        error,
-        since: new Date().toISOString(),
-      });
-    }
-  }
-
-  /**
-   * Record tool success (clears failure)
-   */
-  recordSuccess(toolName: string): void {
-    this.toolFailures.delete(toolName);
-  }
-
-  /**
-   * Get known issues
-   */
-  getIssues(): { tool: string; error: string; since: string }[] {
-    return Array.from(this.toolFailures.entries()).map(([tool, data]) => ({
-      tool,
-      error: data.error,
-      since: data.since,
-    }));
-  }
-
-  /**
-   * Build status report
-   */
-  buildReport(
-    connection: ConnectionStatus,
-    config: PluginConfig,
-    stats: MemoryStats,
-    toolGroups: Record<string, string[]>
-  ): StatusReport {
-    const recentCalls = this.debugLogger
-      ? this.debugLogger.getRecentLogs(10)
-      : [];
-
-    const tools: Record<string, ToolStatus> = {};
-
-    for (const [group, toolNames] of Object.entries(toolGroups)) {
-      const toolStatuses = toolNames.map(name => {
-        const logs = this.debugLogger?.getToolLogs(name, 1) || [];
-        const lastLog = logs[0];
-        const failure = this.toolFailures.get(name);
-
-        let status: "working" | "error" | "unknown" = "unknown";
-        let error: string | undefined;
-        let lastSuccess: string | undefined;
-        let lastError: string | undefined;
-
-        if (lastLog) {
-          status = lastLog.status === "success" ? "working" : "error";
-          if (lastLog.status === "success") {
-            lastSuccess = lastLog.timestamp;
-          } else {
-            lastError = lastLog.timestamp;
-            error = lastLog.error;
-          }
-        } else if (failure) {
-          status = "error";
-          error = failure.error;
-          lastError = failure.since;
-        }
-
-        return {
-          name,
-          status,
-          error,
-          lastSuccess,
-          lastError,
-        };
-      });
-
-      const available = toolStatuses.filter(t => t.status === "working").length;
-      const failed = toolStatuses.filter(t => t.status === "error").length;
-
-      tools[group] = {
-        enabled: toolNames.length,
-        available,
-        failed,
-        tools: toolStatuses,
-      };
-    }
-
-    return {
-      connection,
-      config,
-      stats,
-      tools,
-      recentCalls,
-      issues: this.getIssues(),
-    };
-  }
-
-  /**
-   * Format status report for CLI display
-   */
-  static formatReport(report: StatusReport): string {
-    const lines: string[] = [];
-
-    // Header
-    lines.push("");
-    lines.push("MemoryRelay Plugin Status");
-    lines.push("━".repeat(50));
-    lines.push("");
-
-    // Connection
-    lines.push("CONNECTION");
-    const connSymbol = report.connection.status === "connected" ? "✓" : "✗";
-    lines.push(`  Status:        ${connSymbol} ${report.connection.status}`);
-    lines.push(`  Endpoint:      ${report.connection.endpoint}`);
-    lines.push(`  Response Time: ${report.connection.responseTime}ms`);
-    lines.push(`  Last Check:    ${new Date(report.connection.lastCheck).toLocaleString()}`);
-    lines.push("");
-
-    // Configuration
-    lines.push("CONFIGURATION");
-    lines.push(`  Agent ID:      ${report.config.agentId}`);
-    const recallStatus = report.config.autoRecall
-      ? `✓ Enabled (limit: ${report.config.recallLimit}, threshold: ${report.config.recallThreshold})`
-      : "✗ Disabled";
-    lines.push(`  Auto-Recall:   ${recallStatus}`);
-    lines.push(`  Auto-Capture:  ${report.config.autoCapture ? "✓ Enabled" : "✗ Disabled"}`);
-    if (report.config.defaultProject) {
-      lines.push(`  Default Project: ${report.config.defaultProject}`);
-    }
-    lines.push("");
-
-    // Memory Statistics
-    lines.push("MEMORY STATISTICS");
-    lines.push(`  Total Memories: ${report.stats.total_memories}`);
-    if (report.stats.memories_today !== undefined) {
-      lines.push(`  Today:          ${report.stats.memories_today}`);
-    }
-    if (report.stats.last_stored) {
-      const lastStored = new Date(report.stats.last_stored);
-      const ago = this.formatTimeAgo(lastStored);
-      lines.push(`  Last Stored:    ${ago}`);
-    }
-    if (report.stats.search_count_24h !== undefined) {
-      lines.push(`  Searches (24h): ${report.stats.search_count_24h}`);
-    }
-    lines.push("");
-
-    // Tools Status
-    const totalEnabled = Object.values(report.tools).reduce((sum, g) => sum + g.enabled, 0);
-    const totalAvailable = Object.values(report.tools).reduce((sum, g) => sum + g.available, 0);
-    lines.push(`TOOLS STATUS (${totalAvailable}/${totalEnabled} working)`);
-
-    for (const [groupName, group] of Object.entries(report.tools)) {
-      const symbol = group.failed === 0 ? "✓" : group.failed === group.enabled ? "✗" : "⚠";
-      const label = groupName.charAt(0).toUpperCase() + groupName.slice(1);
-      lines.push(`  ${symbol} ${label}: ${group.available}/${group.enabled} working`);
-
-      // Show failed tools
-      const failedTools = group.tools.filter(t => t.status === "error");
-      for (const tool of failedTools) {
-        lines.push(`    ✗ ${tool.name} (${tool.error})`);
-      }
-    }
-    lines.push("");
-
-    // Recent Activity
-    if (report.recentCalls.length > 0) {
-      lines.push(`RECENT ACTIVITY (last ${report.recentCalls.length} calls)`);
-      for (const call of report.recentCalls.reverse()) {
-        const time = new Date(call.timestamp).toLocaleTimeString();
-        const status = call.status === "success" ? "✓" : "✗";
-        const duration = `${call.duration}ms`;
-        lines.push(`  ${time}  ${call.tool.padEnd(18)} ${duration.padStart(6)}  ${status}`);
-      }
-      lines.push("");
-    }
-
-    // Known Issues
-    if (report.issues.length > 0) {
-      lines.push(`KNOWN ISSUES (${report.issues.length})`);
-      for (const issue of report.issues) {
-        const since = this.formatTimeAgo(new Date(issue.since));
-        lines.push(`  ⚠ ${issue.tool} - ${issue.error} (since ${since})`);
-      }
-      lines.push("");
-    }
-
-    // Footer
-    lines.push("For detailed logs, run: openclaw memoryrelay logs");
-    lines.push("For troubleshooting: https://github.com/MemoryRelay/api/issues/213");
-    lines.push("");
-
-    return lines.join("\n");
-  }
-
-  /**
-   * Format time ago string
-   */
-  private static formatTimeAgo(date: Date): string {
-    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
-
-    if (seconds < 60) return `${seconds} seconds ago`;
-    if (seconds < 3600) return `${Math.floor(seconds / 60)} minutes ago`;
-    if (seconds < 86400) return `${Math.floor(seconds / 3600)} hours ago`;
-    return `${Math.floor(seconds / 86400)} days ago`;
-  }
-
-  /**
-   * Format compact status (for inline display)
-   */
-  static formatCompact(report: StatusReport): string {
-    const totalEnabled = Object.values(report.tools).reduce((sum, g) => sum + g.enabled, 0);
-    const totalAvailable = Object.values(report.tools).reduce((sum, g) => sum + g.available, 0);
-    const symbol = report.connection.status === "connected" ? "✓" : "✗";
-    
-    return `MemoryRelay: ${symbol} ${report.connection.status}, ${totalAvailable}/${totalEnabled} tools working`;
-  }
-}