onbuzz 3.4.0 → 3.6.2

package/src/tools/__tests__/memoryTool.test.js

@@ -0,0 +1,297 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig } from '../../__test-utils__/mockFactories.js';
+
+// Mock constants
+jest.unstable_mockModule('../../utilities/constants.js', () => ({
+  TOOL_STATUS: { PENDING: 'pending', EXECUTING: 'executing', COMPLETED: 'completed', FAILED: 'failed' },
+  OPERATION_STATUS: { NOT_FOUND: 'not_found' },
+  ERROR_TYPES: {},
+  SYSTEM_DEFAULTS: { MAX_TOOL_EXECUTION_TIME: 300000 }
+}));
+
+// Create mock memory service
+const mockMemoryService = {
+  initialize: jest.fn().mockResolvedValue(undefined),
+  addMemory: jest.fn(),
+  updateMemory: jest.fn(),
+  deleteMemory: jest.fn(),
+  listMemories: jest.fn(),
+  readMemory: jest.fn(),
+  searchMemories: jest.fn(),
+  getMemoryStats: jest.fn()
+};
+
+jest.unstable_mockModule('../../services/memoryService.js', () => ({
+  getMemoryService: jest.fn(() => mockMemoryService)
+}));
+
+const { default: MemoryTool } = await import('../memoryTool.js');
+
+describe('MemoryTool', () => {
+  let tool;
+  let logger;
+  const context = { agentId: 'agent-1' };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    logger = createMockLogger();
+    tool = new MemoryTool({}, logger);
+  });
+
+  test('constructor sets metadata correctly', () => {
+    expect(tool.id).toBe('memory');
+    expect(tool.requiresProject).toBe(false);
+    expect(tool.timeout).toBe(30000);
+  });
+
+  test('getDescription contains all actions', () => {
+    const desc = tool.getDescription();
+    expect(desc).toContain('Memory Tool');
+    expect(desc).toContain('add');
+    expect(desc).toContain('update');
+    expect(desc).toContain('delete');
+    expect(desc).toContain('list');
+    expect(desc).toContain('read');
+    expect(desc).toContain('search');
+    expect(desc).toContain('stats');
+  });
+
+  test('getSupportedActions returns all 7 actions', () => {
+    expect(tool.getSupportedActions()).toEqual(
+      ['add', 'update', 'delete', 'list', 'read', 'search', 'stats']
+    );
+  });
+
+  test('getRequiredParameters returns action', () => {
+    expect(tool.getRequiredParameters()).toEqual(['action']);
+  });
+
+  test('getCapabilities includes persistent flag', () => {
+    const caps = tool.getCapabilities();
+    expect(caps.persistent).toBe(true);
+    expect(caps.actions).toEqual(tool.getSupportedActions());
+  });
+
+  test('getParameterSchema has action enum', () => {
+    const schema = tool.getParameterSchema();
+    expect(schema.properties.action.enum).toEqual(tool.getSupportedActions());
+  });
+
+  test('parseParameters returns content as-is', () => {
+    const input = { action: 'add', title: 'test' };
+    expect(tool.parseParameters(input)).toBe(input);
+  });
+
+  test('validateParameterTypes catches invalid action type', () => {
+    const result = tool.validateParameterTypes({ action: 123 });
+    expect(result.valid).toBe(false);
+  });
+
+  test('validateParameterTypes catches invalid level', () => {
+    const result = tool.validateParameterTypes({ level: 'invalid' });
+    expect(result.valid).toBe(false);
+  });
+
+  test('validateParameterTypes accepts valid params', () => {
+    const result = tool.validateParameterTypes({ action: 'add', title: 'test', level: 'titles' });
+    expect(result.valid).toBe(true);
+  });
+
+  test('customValidateParameters rejects unknown action', () => {
+    const result = tool.customValidateParameters({ action: 'unknown' });
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters requires title and content for add', () => {
+    const result = tool.customValidateParameters({ action: 'add' });
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('title'))).toBe(true);
+    expect(result.errors.some(e => e.includes('content'))).toBe(true);
+  });
+
+  test('customValidateParameters requires id for update', () => {
+    const result = tool.customValidateParameters({ action: 'update' });
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters requires id for delete', () => {
+    const result = tool.customValidateParameters({ action: 'delete' });
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters requires id for read', () => {
+    const result = tool.customValidateParameters({ action: 'read' });
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters requires query for search', () => {
+    const result = tool.customValidateParameters({ action: 'search' });
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters enforces length limits', () => {
+    const result = tool.customValidateParameters({
+      action: 'add',
+      title: 'a'.repeat(201),
+      content: 'c'.repeat(10001),
+      description: 'd'.repeat(501)
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errors.length).toBe(3);
+  });
+
+  test('execute throws without agentId', async () => {
+    await expect(tool.execute({ action: 'stats' }, {}))
+      .rejects.toThrow('Agent ID is required');
+  });
+
+  test('execute add action creates memory', async () => {
+    mockMemoryService.addMemory.mockResolvedValue({
+      id: 'mem-1', title: 'Test', createdAt: '2025-01-01', expiration: null
+    });
+
+    const result = await tool.execute(
+      { action: 'add', title: 'Test', content: 'content', description: 'desc' },
+      context
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.action).toBe('add');
+    expect(result.memory.id).toBe('mem-1');
+    expect(mockMemoryService.addMemory).toHaveBeenCalledWith('agent-1', expect.objectContaining({ title: 'Test' }));
+  });
+
+  test('execute update action modifies memory', async () => {
+    mockMemoryService.updateMemory.mockResolvedValue({
+      id: 'mem-1', title: 'Updated', updatedAt: '2025-01-02'
+    });
+
+    const result = await tool.execute(
+      { action: 'update', id: 'mem-1', title: 'Updated' },
+      context
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.action).toBe('update');
+  });
+
+  test('execute update returns failure when memory not found', async () => {
+    mockMemoryService.updateMemory.mockResolvedValue(null);
+
+    const result = await tool.execute(
+      { action: 'update', id: 'nonexistent', title: 'x' },
+      context
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('not found');
+  });
+
+  test('execute delete action removes memory', async () => {
+    mockMemoryService.deleteMemory.mockResolvedValue(true);
+
+    const result = await tool.execute({ action: 'delete', id: 'mem-1' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.action).toBe('delete');
+  });
+
+  test('execute delete returns failure when memory not found', async () => {
+    mockMemoryService.deleteMemory.mockResolvedValue(false);
+
+    const result = await tool.execute({ action: 'delete', id: 'nonexistent' }, context);
+
+    expect(result.success).toBe(false);
+  });
+
+  test('execute list action returns memories', async () => {
+    mockMemoryService.listMemories.mockResolvedValue({
+      count: 2,
+      grouped: { '2025-01-01': [{ id: 'mem-1' }, { id: 'mem-2' }] }
+    });
+
+    const result = await tool.execute({ action: 'list', level: 'titles' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.totalMemories).toBe(2);
+    expect(result.level).toBe('titles');
+  });
+
+  test('execute list with default level', async () => {
+    mockMemoryService.listMemories.mockResolvedValue({ count: 0, grouped: {} });
+
+    const result = await tool.execute({ action: 'list' }, context);
+
+    expect(result.level).toBe('titles');
+    expect(result.message).toContain('No memories');
+  });
+
+  test('execute read action loads memory', async () => {
+    mockMemoryService.readMemory.mockResolvedValue({
+      id: 'mem-1', title: 'Test', description: 'desc', content: 'full content',
+      createdAt: '2025-01-01', updatedAt: null, expiration: null, accessCount: 3
+    });
+
+    const result = await tool.execute({ action: 'read', id: 'mem-1' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.memory.content).toBe('full content');
+  });
+
+  test('execute read returns failure when not found', async () => {
+    mockMemoryService.readMemory.mockResolvedValue(null);
+
+    const result = await tool.execute({ action: 'read', id: 'nonexistent' }, context);
+
+    expect(result.success).toBe(false);
+  });
+
+  test('execute search action returns results', async () => {
+    mockMemoryService.searchMemories.mockResolvedValue([
+      { id: 'mem-1', title: 'Match' }
+    ]);
+
+    const result = await tool.execute({ action: 'search', query: 'Match' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.results.length).toBe(1);
+    expect(result.query).toBe('Match');
+  });
+
+  test('execute search with no results', async () => {
+    mockMemoryService.searchMemories.mockResolvedValue([]);
+
+    const result = await tool.execute({ action: 'search', query: 'nothing' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.results.length).toBe(0);
+    expect(result.message).toContain('No memories found');
+  });
+
+  test('execute stats action returns statistics', async () => {
+    mockMemoryService.getMemoryStats.mockResolvedValue({
+      totalMemories: 5, totalAccessCount: 20
+    });
+
+    const result = await tool.execute({ action: 'stats' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.stats.totalMemories).toBe(5);
+    expect(result.message).toContain('5 total memories');
+  });
+
+  test('execute throws on unknown action', async () => {
+    await expect(tool.execute({ action: 'unknown' }, context))
+      .rejects.toThrow('Unknown action');
+  });
+
+  test('execute logs and re-throws service errors', async () => {
+    mockMemoryService.addMemory.mockRejectedValue(new Error('DB error'));
+
+    await expect(
+      tool.execute({ action: 'add', title: 'x', content: 'y' }, context)
+    ).rejects.toThrow('DB error');
+
+    expect(logger.error).toHaveBeenCalled();
+  });
+});

package/src/tools/__tests__/seekTool.test.js

@@ -0,0 +1,282 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig } from '../../__test-utils__/mockFactories.js';
+
+// Mock fs/promises before import
+const mockFs = {
+  stat: jest.fn(),
+  readFile: jest.fn(),
+  readdir: jest.fn()
+};
+
+jest.unstable_mockModule('fs', () => ({
+  promises: mockFs,
+  default: { promises: mockFs }
+}));
+
+// Mock constants
+jest.unstable_mockModule('../../utilities/constants.js', () => ({
+  TOOL_STATUS: { PENDING: 'pending', EXECUTING: 'executing', COMPLETED: 'completed', FAILED: 'failed' },
+  OPERATION_STATUS: { EXECUTING: 'executing', COMPLETED: 'completed', FAILED: 'failed', NOT_FOUND: 'not_found' },
+  ERROR_TYPES: {},
+  SYSTEM_DEFAULTS: { MAX_TOOL_EXECUTION_TIME: 300000 }
+}));
+
+// Mock tagParser
+jest.unstable_mockModule('../../utilities/tagParser.js', () => ({
+  default: { extractContent: jest.fn(() => []) }
+}));
+
+const { default: SeekTool } = await import('../seekTool.js');
+
+describe('SeekTool', () => {
+  let tool;
+  let logger;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    logger = createMockLogger();
+    tool = new SeekTool({}, logger);
+  });
+
+  test('constructor sets metadata correctly', () => {
+    expect(tool.id).toBe('seek');
+    expect(tool.requiresProject).toBe(true);
+    expect(tool.isAsync).toBe(true);
+    expect(tool.timeout).toBe(120000);
+  });
+
+  test('getDescription returns seek description', () => {
+    const desc = tool.getDescription();
+    expect(desc).toContain('Seek Tool');
+    expect(desc).toContain('filePaths');
+    expect(desc).toContain('searchTerms');
+  });
+
+  test('getRequiredParameters returns filePaths and searchTerms', () => {
+    expect(tool.getRequiredParameters()).toEqual(['filePaths', 'searchTerms']);
+  });
+
+  test('parseParameters parses JSON content', () => {
+    const content = JSON.stringify({
+      filePaths: ['src/*.js'],
+      searchTerms: ['import React']
+    });
+    const result = tool.parseParameters(content);
+    expect(result.filePaths).toEqual(['src/*.js']);
+    expect(result.searchTerms).toEqual(['import React']);
+  });
+
+  test('parseParameters parses XML content', () => {
+    const content = `
+      <in-files>
+        src/index.js
+        src/app.js
+      </in-files>
+      <search-terms>
+        <term>useState</term>
+        <term>useEffect</term>
+      </search-terms>
+    `;
+    const result = tool.parseParameters(content);
+    expect(result.filePaths).toEqual(['src/index.js', 'src/app.js']);
+    expect(result.searchTerms).toEqual(['useState', 'useEffect']);
+  });
+
+  test('parseParameters returns parseError on invalid content', () => {
+    const result = tool.parseParameters('{ broken json');
+    expect(result).toHaveProperty('parseError');
+  });
+
+  test('customValidateParameters rejects empty filePaths', () => {
+    const result = tool.customValidateParameters({ filePaths: [], searchTerms: ['foo'] });
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters rejects empty searchTerms', () => {
+    const result = tool.customValidateParameters({ filePaths: ['a.js'], searchTerms: [] });
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters rejects path traversal', () => {
+    const result = tool.customValidateParameters({
+      filePaths: ['../../etc/passwd'],
+      searchTerms: ['test']
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('traversal'))).toBe(true);
+  });
+
+  test('customValidateParameters accepts valid params', () => {
+    const result = tool.customValidateParameters({
+      filePaths: ['src/index.js'],
+      searchTerms: ['import']
+    });
+    expect(result.valid).toBe(true);
+  });
+
+  test('execute searches file and returns matches', async () => {
+    const fileContent = 'line 1\nimport React from "react";\nline 3\nimport useState from "react";\n';
+
+    mockFs.stat.mockResolvedValue({
+      isFile: () => true,
+      isDirectory: () => false,
+      size: 100
+    });
+    mockFs.readFile.mockResolvedValue(fileContent);
+
+    const result = await tool.execute(
+      { filePaths: ['src/app.js'], searchTerms: ['import React'] },
+      { projectDir: '/project', agentId: 'agent-1' }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.totalMatches).toBe(1);
+    expect(result.filesSearched).toBe(1);
+  });
+
+  test('execute handles file not found', async () => {
+    mockFs.stat.mockRejectedValue({ code: 'ENOENT', message: 'not found' });
+
+    const result = await tool.execute(
+      { filePaths: ['missing.js'], searchTerms: ['test'] },
+      { projectDir: '/project', agentId: 'agent-1' }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.filesNotFound).toBe(1);
+    expect(result.totalMatches).toBe(0);
+  });
+
+  test('execute returns no matches when search term not found', async () => {
+    mockFs.stat.mockResolvedValue({
+      isFile: () => true,
+      isDirectory: () => false,
+      size: 50
+    });
+    mockFs.readFile.mockResolvedValue('no matching content here\n');
+
+    const result = await tool.execute(
+      { filePaths: ['src/app.js'], searchTerms: ['nonexistent'] },
+      { projectDir: '/project', agentId: 'agent-1' }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.totalMatches).toBe(0);
+  });
+
+  test('execute skips binary files', async () => {
+    mockFs.stat.mockResolvedValue({
+      isFile: () => true,
+      isDirectory: () => false,
+      size: 100
+    });
+
+    const result = await tool.execute(
+      { filePaths: ['image.png'], searchTerms: ['test'] },
+      { projectDir: '/project', agentId: 'agent-1' }
+    );
+
+    expect(result.success).toBe(true);
+    // Binary file is resolved but skipped during search
+    expect(mockFs.readFile).not.toHaveBeenCalled();
+  });
+
+  test('execute skips oversized files', async () => {
+    mockFs.stat
+      .mockResolvedValueOnce({ isFile: () => true, isDirectory: () => false, size: 100 })  // resolveFilePaths
+      .mockResolvedValueOnce({ size: 20 * 1024 * 1024 }); // searchFiles - too large
+
+    const result = await tool.execute(
+      { filePaths: ['large.js'], searchTerms: ['test'] },
+      { projectDir: '/project', agentId: 'agent-1' }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.filesWithErrors).toBe(1);
+  });
+
+  test('execute truncates long line content around match', async () => {
+    const longLine = 'a'.repeat(100) + 'MATCH_HERE' + 'b'.repeat(200);
+    mockFs.stat.mockResolvedValue({
+      isFile: () => true,
+      isDirectory: () => false,
+      size: 500
+    });
+    mockFs.readFile.mockResolvedValue(longLine + '\n');
+
+    const result = await tool.execute(
+      { filePaths: ['file.js'], searchTerms: ['MATCH_HERE'] },
+      { projectDir: '/project', agentId: 'agent-1' }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.totalMatches).toBe(1);
+  });
+
+  test('execute uses directoryAccess when provided', async () => {
+    mockFs.stat.mockResolvedValue({
+      isFile: () => true,
+      isDirectory: () => false,
+      size: 50
+    });
+    mockFs.readFile.mockResolvedValue('hello world\n');
+
+    const result = await tool.execute(
+      { filePaths: ['test.js'], searchTerms: ['hello'] },
+      {
+        projectDir: '/project',
+        agentId: 'agent-1',
+        directoryAccess: {
+          workingDirectory: '/project',
+          readOnlyDirectories: ['/shared'],
+          writeEnabledDirectories: ['/output']
+        }
+      }
+    );
+
+    expect(result.success).toBe(true);
+  });
+
+  test('matchesPattern handles wildcard patterns', () => {
+    expect(tool.matchesPattern('file.js', '*.js')).toBe(true);
+    expect(tool.matchesPattern('file.ts', '*.js')).toBe(false);
+    expect(tool.matchesPattern('test.spec.js', '*.spec.js')).toBe(true);
+  });
+
+  test('shouldSkipDirectory returns true for node_modules', () => {
+    expect(tool.shouldSkipDirectory('node_modules')).toBe(true);
+    expect(tool.shouldSkipDirectory('.git')).toBe(true);
+    expect(tool.shouldSkipDirectory('src')).toBe(false);
+  });
+
+  test('shouldSkipFile returns true for binary extensions', () => {
+    expect(tool.shouldSkipFile('image.png')).toBe(true);
+    expect(tool.shouldSkipFile('script.js')).toBe(false);
+  });
+
+  test('formatResults with no matches', () => {
+    const output = tool.formatResults([], [], [], 5);
+    expect(output).toContain('No matches found');
+  });
+
+  test('formatResults with matches', () => {
+    const matches = [
+      { term: 'foo', filePath: 'a.js', lineNumber: 10, lineContent: 'const foo = 1;' }
+    ];
+    const output = tool.formatResults(matches, [], [], 1);
+    expect(output).toContain('SEARCH RESULTS');
+    expect(output).toContain('foo');
+    expect(output).toContain('a.js:10');
+  });
+
+  test('formatResults with not found and error files', () => {
+    const output = tool.formatResults(
+      [],
+      [{ filePath: 'err.js', error: 'read error' }],
+      ['missing.js (ENOENT)'],
+      0
+    );
+    expect(output).toContain('FILES NOT FOUND');
+    expect(output).toContain('FILES WITH ERRORS');
+  });
+});