Merge pull request #30 from elizaos-plugins/odi-spider

feat: room(s) spider to memories, audit hooks, and better slash command interface

Author: odilitime

README.md

@@ -0,0 +1,268 @@
+import { describe, expect, it, beforeEach, mock } from 'bun:test';
+import { smartSplitMessage, splitMessage, needsSmartSplit, MAX_MESSAGE_LENGTH } from '../src/utils';
+import type { IAgentRuntime } from '@elizaos/core';
+import { ModelType } from '@elizaos/core';
+
+describe('Discord Utils - Smart Split Message', () => {
+  let mockRuntime: IAgentRuntime;
+  let mockLogger: any;
+
+  beforeEach(() => {
+    mockLogger = {
+      debug: mock(() => {}),
+      info: mock(() => {}),
+      warn: mock(() => {}),
+      error: mock(() => {}),
+    };
+
+    mockRuntime = {
+      useModel: mock(async () => ''),
+      logger: mockLogger,
+    } as any;
+  });
+
+  describe('parseJSONArrayFromText (via smartSplitMessage)', () => {
+    it('should successfully parse JSON array from LLM response', async () => {
+      const longContent = 'a'.repeat(3000);
+      const expectedChunks = ['chunk1', 'chunk2', 'chunk3'];
+      
+      // Mock LLM to return a valid JSON array
+      mockRuntime.useModel = mock(async () => JSON.stringify(expectedChunks));
+
+      const result = await smartSplitMessage(mockRuntime, longContent);
+      
+      expect(result).toEqual(expectedChunks);
+      expect(mockRuntime.useModel).toHaveBeenCalledWith(
+        ModelType.TEXT_SMALL,
+        expect.objectContaining({ prompt: expect.any(String) })
+      );
+    });
+
+    it('should parse JSON array wrapped in code blocks', async () => {
+      const longContent = 'a'.repeat(3000);
+      const expectedChunks = ['chunk1', 'chunk2'];
+      
+      // Mock LLM to return JSON array in code block
+      const llmResponse = '```json\n' + JSON.stringify(expectedChunks) + '\n```';
+      mockRuntime.useModel = mock(async () => llmResponse);
+
+      const result = await smartSplitMessage(mockRuntime, longContent);
+      
+      expect(result).toEqual(expectedChunks);
+    });
+
+    it('should parse JSON array with extra text around it', async () => {
+      const longContent = 'a'.repeat(3000);
+      const expectedChunks = ['chunk1', 'chunk2'];
+      
+      // Mock LLM to return JSON array with markdown code block
+      const llmResponse = 'Here are the chunks:\n```json\n' + JSON.stringify(expectedChunks) + '\n```\nDone!';
+      mockRuntime.useModel = mock(async () => llmResponse);
+
+      const result = await smartSplitMessage(mockRuntime, longContent);
+      
+      expect(result).toEqual(expectedChunks);
+    });
+
+    it('should validate chunk lengths and fallback if too long', async () => {
+      const longContent = 'a'.repeat(3000);
+      const tooLongChunks = ['a'.repeat(MAX_MESSAGE_LENGTH + 100)];
+      
+      // Mock LLM to return chunks that are too long
+      mockRuntime.useModel = mock(async () => JSON.stringify(tooLongChunks));
+
+      const result = await smartSplitMessage(mockRuntime, longContent);
+      
+      // Should fall back to simple split
+      expect(result).not.toEqual(tooLongChunks);
+      expect(result.length).toBeGreaterThan(0);
+      expect(result.every(chunk => chunk.length <= MAX_MESSAGE_LENGTH)).toBe(true);
+    });
+
+    it('should fallback to simple split when LLM returns invalid JSON', async () => {
+      const longContent = 'a'.repeat(3000);
+      
+      // Mock LLM to return invalid JSON
+      mockRuntime.useModel = mock(async () => 'This is not valid JSON');
+
+      const result = await smartSplitMessage(mockRuntime, longContent);
+      
+      // Should fall back to simple split
+      expect(result.length).toBeGreaterThan(0);
+      expect(result.every(chunk => chunk.length <= MAX_MESSAGE_LENGTH)).toBe(true);
+      // Debug logging should have been called (either for smart split attempt or fallback)
+      expect(mockLogger.debug).toHaveBeenCalled();
+    });
+
+    it('should fallback to simple split when LLM returns object instead of array', async () => {
+      const longContent = 'a'.repeat(3000);
+      
+      // Mock LLM to return a JSON object (wrong type)
+      mockRuntime.useModel = mock(async () => '{"chunk": "value"}');
+
+      const result = await smartSplitMessage(mockRuntime, longContent);
+      
+      // Should fall back to simple split
+      expect(result.length).toBeGreaterThan(0);
+      expect(result.every(chunk => chunk.length <= MAX_MESSAGE_LENGTH)).toBe(true);
+    });
+
+    it('should fallback to simple split when LLM returns empty array', async () => {
+      const longContent = 'a'.repeat(3000);
+      
+      // Mock LLM to return empty array
+      mockRuntime.useModel = mock(async () => '[]');
+
+      const result = await smartSplitMessage(mockRuntime, longContent);
+      
+      // Should fall back to simple split
+      expect(result.length).toBeGreaterThan(0);
+      expect(result.every(chunk => chunk.length <= MAX_MESSAGE_LENGTH)).toBe(true);
+    });
+
+    it('should fallback when array contains non-string values', async () => {
+      const longContent = 'a'.repeat(3000);
+      
+      // Mock LLM to return array with non-string values
+      mockRuntime.useModel = mock(async () => '[123, true, null]');
+
+      const result = await smartSplitMessage(mockRuntime, longContent);
+      
+      // Should fall back to simple split
+      expect(result.length).toBeGreaterThan(0);
+      expect(result.every(chunk => typeof chunk === 'string')).toBe(true);
+    });
+
+    it('should return single chunk when content fits in one message', async () => {
+      const shortContent = 'Short message';
+
+      const result = await smartSplitMessage(mockRuntime, shortContent);
+      
+      expect(result).toEqual([shortContent]);
+      // Should not call LLM for short content
+      expect(mockRuntime.useModel).not.toHaveBeenCalled();
+    });
+
+    it('should handle LLM errors gracefully', async () => {
+      const longContent = 'a'.repeat(3000);
+      
+      // Mock LLM to throw an error
+      mockRuntime.useModel = mock(async () => {
+        throw new Error('LLM error');
+      });
+
+      const result = await smartSplitMessage(mockRuntime, longContent);
+      
+      // Should fall back to simple split
+      expect(result.length).toBeGreaterThan(0);
+      expect(result.every(chunk => chunk.length <= MAX_MESSAGE_LENGTH)).toBe(true);
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        expect.stringContaining('Smart split failed')
+      );
+    });
+  });
+
+  describe('needsSmartSplit', () => {
+    it('should return true for content with code blocks', () => {
+      const content = 'Some text\n```javascript\ncode here\n```\nmore text';
+      expect(needsSmartSplit(content)).toBe(true);
+    });
+
+    it('should return true for content with markdown headers', () => {
+      const content = '# Header 1\nSome text\n## Header 2\nMore text';
+      expect(needsSmartSplit(content)).toBe(true);
+    });
+
+    it('should return true for content with numbered lists', () => {
+      const content = '1. First item\n2. Second item\n3. Third item';
+      expect(needsSmartSplit(content)).toBe(true);
+    });
+
+    it('should return true for content with long unbreakable lines', () => {
+      const content = 'a'.repeat(600);
+      expect(needsSmartSplit(content)).toBe(true);
+    });
+
+    it('should return false for simple text', () => {
+      const content = 'This is a simple text. It has sentences. But no special formatting.';
+      expect(needsSmartSplit(content)).toBe(false);
+    });
+  });
+
+  describe('splitMessage (fallback)', () => {
+    it('should split long content into chunks under max length', () => {
+      const longContent = 'a'.repeat(5000);
+      const result = splitMessage(longContent);
+      
+      expect(result.length).toBeGreaterThan(1);
+      expect(result.every(chunk => chunk.length <= MAX_MESSAGE_LENGTH)).toBe(true);
+    });
+
+    it('should return single chunk for short content', () => {
+      const shortContent = 'Short message';
+      const result = splitMessage(shortContent);
+      
+      expect(result).toEqual([shortContent]);
+    });
+
+    it('should preserve line breaks when possible', () => {
+      const content = 'Line 1\n'.repeat(100);
+      const result = splitMessage(content);
+      
+      expect(result.every(chunk => chunk.includes('\n') || chunk.length < 10)).toBe(true);
+    });
+  });
+
+  describe('Integration: smartSplitMessage with realistic content', () => {
+    it('should handle code-heavy content correctly', async () => {
+      const codeContent = `
+Here's a Python example:
+\`\`\`python
+def hello_world():
+    print("Hello, world!")
+    for i in range(100):
+        print(i)
+\`\`\`
+
+And here's another example:
+\`\`\`javascript
+function test() {
+  console.log("test");
+}
+\`\`\`
+`.repeat(5);
+
+      // Create valid chunks under the length limit
+      const chunk1 = codeContent.slice(0, 1500);
+      const chunk2 = codeContent.slice(1500);
+      const expectedChunks = [chunk1, chunk2].filter(c => c.length > 0);
+      mockRuntime.useModel = mock(async () => JSON.stringify(expectedChunks));
+
+      const result = await smartSplitMessage(mockRuntime, codeContent);
+      
+      // Verify the result matches what the LLM returned and all chunks are valid
+      expect(result).toEqual(expectedChunks);
+      expect(result.length).toBeGreaterThan(0);
+      expect(result.every(chunk => chunk.length <= MAX_MESSAGE_LENGTH)).toBe(true);
+      expect(result.every(chunk => typeof chunk === 'string' && chunk.length > 0)).toBe(true);
+    });
+
+    it('should handle markdown lists correctly', async () => {
+      const listContent = `
+# My List
+1. First item with lots of text to make it longer
+2. Second item with lots of text to make it longer
+3. Third item with lots of text to make it longer
+`.repeat(20);
+
+      const expectedChunks = [listContent.slice(0, 1500), listContent.slice(1500)];
+      mockRuntime.useModel = mock(async () => JSON.stringify(expectedChunks));
+
+      const result = await smartSplitMessage(mockRuntime, listContent);
+      
+      expect(result).toEqual(expectedChunks);
+      expect(result.every(chunk => chunk.length <= MAX_MESSAGE_LENGTH)).toBe(true);
+    });
+  });
+});
+

__tests__/utils.test.ts

@@ -25,7 +25,7 @@
     "@discordjs/opus": "^0.10.0",
     "@discordjs/rest": "2.4.3",
     "@discordjs/voice": "0.18.0",
-    "@elizaos/core": "^1.6.4",
+    "@elizaos/core": "1.6.5",
     "discord.js": "14.18.0",
     "fast-levenshtein": "^3.0.0",
     "fluent-ffmpeg": "^2.1.3",
@@ -34,11 +34,10 @@
     "opusscript": "^0.1.1",
     "prism-media": "1.3.5",
     "typescript": "^5.8.3",
-    "zod": "4.1.11"
+    "zod": "4.1.13"
   },
   "devDependencies": {
-    "@elizaos/config": "^1.6.5",
-    "@elizaos/plugin-ollama": "^1.2.4",
+    "@elizaos/config": "1.6.5",
     "@eslint/js": "^9.17.0",
     "@typescript-eslint/eslint-plugin": "^8.22.0",
     "@typescript-eslint/parser": "^8.22.0",
@@ -114,7 +113,13 @@
         "description": "If true, the bot will only respond when explicitly mentioned. Can be overridden by character settings.",
         "required": false,
         "sensitive": false
+      },
+      "DISCORD_LISTEN_CHANNEL_IDS": {
+        "type": "string",
+        "description": "Comma-separated list of Discord channel IDs where the bot will only listen (not respond).",
+        "required": false,
+        "sensitive": false
       }
     }
   }
-}
+}