src/tools/config.ts (1)

18-25: Expose raw bytes (non-breaking) and capture timestamp for observability

Keep the human-friendly MB strings, but also include raw byte counters and a capture timestamp to enable machine use and time correlation.

-    const memory = {
-      rss: `${(memoryUsage.rss / 1024 / 1024).toFixed(2)} MB`,
-      heapTotal: `${(memoryUsage.heapTotal / 1024 / 1024).toFixed(2)} MB`,
-      heapUsed: `${(memoryUsage.heapUsed / 1024 / 1024).toFixed(2)} MB`,
-      external: `${(memoryUsage.external / 1024 / 1024).toFixed(2)} MB`,
-      arrayBuffers: `${(memoryUsage.arrayBuffers / 1024 / 1024).toFixed(2)} MB`
-    };
+    const memory = {
+      // human-friendly
+      rss: `${(memoryUsage.rss / 1024 / 1024).toFixed(2)} MB`,
+      heapTotal: `${(memoryUsage.heapTotal / 1024 / 1024).toFixed(2)} MB`,
+      heapUsed: `${(memoryUsage.heapUsed / 1024 / 1024).toFixed(2)} MB`,
+      external: `${(memoryUsage.external / 1024 / 1024).toFixed(2)} MB`,
+      arrayBuffers: `${(memoryUsage.arrayBuffers / 1024 / 1024).toFixed(2)} MB`,
+      // machine-friendly
+      raw: {
+        rss: memoryUsage.rss,
+        heapTotal: memoryUsage.heapTotal,
+        heapUsed: memoryUsage.heapUsed,
+        external: memoryUsage.external,
+        arrayBuffers: memoryUsage.arrayBuffers
+      },
+      capturedAt: new Date().toISOString()
+    };

README.md (1)

439-440: Document defaults/filters inline for quicker adoption

Add defaults/filters to the row so users know how to scope results without hunting.

-| | `get_recent_tool_calls` | Get recent tool call history with arguments and outputs for debugging and context recovery |
+| | `get_recent_tool_calls` | Get recent tool call history with arguments and outputs (default: last 50; filters: `toolName?`, `since?`, `maxResults<=1000`) for debugging and context recovery |

manifest.template.json (1)

125-128: Align description with persisted history (avoid “during this session”)

Since history is persisted, “during this session” can mislead. Use “recent” and mention persistence.

-      "description": "Get recent tool call history with their arguments and outputs. Returns chronological list of tool calls made during this session for debugging, context recovery, and onboarding new chats."
+      "description": "Get recent tool call history with their arguments and outputs. Returns a chronological list of recent (persisted) tool calls for debugging, context recovery, and onboarding new chats."

src/tools/schemas.ts (1)

141-146: Tighten schema: simpler default, trimmed toolName, timezone-aware datetime

Small Zod tweaks improve DX and reduce parsing edge cases.

-export const GetRecentToolCallsArgsSchema = z.object({
-  maxResults: z.number().min(1).max(1000).optional().default(50),
-  toolName: z.string().optional(),
-  since: z.string().datetime().optional(),
-});
+export const GetRecentToolCallsArgsSchema = z.object({
+  maxResults: z.number().min(1).max(1000).default(50),
+  toolName: z.string().trim().optional(),
+  // require/accept timezone in ISO-8601; keeps server-side comparisons unambiguous
+  since: z.string().datetime({ offset: true }).optional(),
+});

Optionally support numeric epoch and/or coerce to Date in the handler if needed.

src/utils/toolHistory.ts (2)

57-88: Use appropriate log level for non-error conditions.

Line 60 logs "No history file found, starting fresh" as an error via console.error, but this is an expected condition on first run and should be informational. Consider using a standard log or removing this message entirely since it's not actionable.

Apply this diff to use a more appropriate log level:

       if (!fs.existsSync(this.historyFile)) {
-        console.error('[ToolHistory] No history file found, starting fresh');
+        console.log('[ToolHistory] No history file found, starting fresh');
         return;
       }

---

124-142: Consider limiting write queue growth on persistent failures.

If disk writes repeatedly fail (lines 136-138), failed entries are continuously pushed back to the queue with unshift, potentially causing unbounded memory growth. While rare, persistent I/O failures (full disk, permissions) could accumulate entries over time.

Consider adding a maximum retry count or queue size limit:

   } catch (error) {
     console.error('[ToolHistory] Failed to write to disk:', error);
-    // Put back in queue on failure
-    this.writeQueue.unshift(...toWrite);
+    // Put back in queue on failure (with limit to prevent unbounded growth)
+    if (this.writeQueue.length + toWrite.length < this.MAX_ENTRIES * 2) {
+      this.writeQueue.unshift(...toWrite);
+    } else {
+      console.error('[ToolHistory] Write queue full, dropping oldest entries');
+    }
   } finally {

src/server.ts (1)

1182-1190: Clarify which tools are excluded from history.

The tool description (line 827) states "Does not track its own calls or other meta/query tools", but the exclusion list only contains get_recent_tool_calls. Other query-oriented tools like get_config, get_usage_stats, list_sessions, etc. are recorded in history.

This might be intentional for context restoration purposes, but the description should be clarified to match the implementation.

If the current behavior is intended (only excluding get_recent_tool_calls to prevent recursion), update the tool description:

-                        Note: Does not track its own calls or other meta/query tools.
+                        Note: Does not track its own calls (to prevent recursion).

Alternatively, if other meta tools should also be excluded, add them to the EXCLUDED_TOOLS array and verify this doesn't break context restoration use cases.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/utils/toolHistory.ts (3)

6-12: Consider using unknown instead of any for the arguments field.

The any type bypasses type checking. Using unknown would preserve type safety while maintaining flexibility—consumers would need to validate/narrow the type before use.

Apply this diff:

 export interface ToolCallRecord {
   timestamp: string;
   toolName: string;
-  arguments: any;
+  arguments: unknown;
   output: ServerResult;
   duration?: number;
 }

---

14-26: Consider respecting user's locale preference.

The function hardcodes 'en-US' locale. Using the default locale (omit the locale parameter) would respect the user's system settings and provide a more localized experience.

Apply this diff:

 function formatLocalTimestamp(isoTimestamp: string): string {
   const date = new Date(isoTimestamp);
-  return date.toLocaleString('en-US', {
+  return date.toLocaleString(undefined, {
     year: 'numeric',
     month: '2-digit',
     day: '2-digit',
     hour: '2-digit',
     minute: '2-digit',
     second: '2-digit',
     hour12: false
   });
 }

---

36-53: Synchronous file operations block initialization.

The constructor uses fs.existsSync and fs.mkdirSync, which block the event loop during startup. For a singleton initialized at module load, this is generally acceptable, but consider documenting this trade-off or providing an async initialization method if startup performance becomes a concern.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro