onbuzz 3.4.0 → 3.6.2

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

@@ -0,0 +1,348 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig } from '../../__test-utils__/mockFactories.js';
+
+// Mock fs before import
+const mockFsPromises = {
+  stat: jest.fn(),
+  readFile: jest.fn(),
+  readdir: jest.fn()
+};
+
+jest.unstable_mockModule('fs', () => ({
+  default: { promises: mockFsPromises, readFileSync: jest.fn(() => { throw new Error('no file'); }) },
+  promises: mockFsPromises,
+  readFileSync: jest.fn(() => { throw new Error('no file'); })
+}));
+
+// 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 }
+}));
+
+const { default: CodeMapTool } = await import('../codeMapTool.js');
+
+describe('CodeMapTool', () => {
+  let tool;
+  let logger;
+  const context = { projectDir: '/project', agentId: 'agent-1' };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    logger = createMockLogger();
+    tool = new CodeMapTool({}, logger);
+  });
+
+  test('constructor sets metadata correctly', () => {
+    expect(tool.id).toBe('code-map');
+    expect(tool.requiresProject).toBe(true);
+    expect(tool.isAsync).toBe(true);
+  });
+
+  test('getDescription mentions skeleton and read-range', () => {
+    const desc = tool.getDescription();
+    expect(desc).toContain('skeleton');
+    expect(desc).toContain('read-range');
+  });
+
+  test('getRequiredParameters returns action', () => {
+    expect(tool.getRequiredParameters()).toEqual(['action']);
+  });
+
+  test('parseParameters parses JSON content', () => {
+    const content = JSON.stringify({
+      action: 'skeleton',
+      path: 'src/',
+      level: 'B.0'
+    });
+    const result = tool.parseParameters(content);
+    expect(result.action).toBe('skeleton');
+    expect(result.path).toBe('src/');
+    expect(result.level).toBe('B.0');
+  });
+
+  test('parseParameters parses nested parameters JSON', () => {
+    const content = JSON.stringify({
+      parameters: { action: 'read-range', filePath: 'index.js', startLine: 1, endLine: 10 }
+    });
+    const result = tool.parseParameters(content);
+    expect(result.action).toBe('read-range');
+    expect(result.filePath).toBe('index.js');
+    expect(result.startLine).toBe(1);
+    expect(result.endLine).toBe(10);
+  });
+
+  test('parseParameters parses XML content', () => {
+    const content = '<action>skeleton</action><path>src/</path><level>A.0</level>';
+    const result = tool.parseParameters(content);
+    expect(result.action).toBe('skeleton');
+    expect(result.path).toBe('src/');
+    expect(result.level).toBe('A.0');
+  });
+
+  test('parseParameters returns parseError on bad JSON', () => {
+    const result = tool.parseParameters('{ broken');
+    expect(result).toHaveProperty('parseError');
+  });
+
+  test('customValidateParameters rejects missing action', () => {
+    const result = tool.customValidateParameters({});
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters rejects invalid action', () => {
+    const result = tool.customValidateParameters({ action: 'invalid' });
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters requires path for skeleton', () => {
+    const result = tool.customValidateParameters({ action: 'skeleton' });
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('path'))).toBe(true);
+  });
+
+  test('customValidateParameters rejects invalid level', () => {
+    const result = tool.customValidateParameters({ action: 'skeleton', path: 'src/', level: 'X.9' });
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters requires filePath/startLine/endLine for read-range', () => {
+    const result = tool.customValidateParameters({ action: 'read-range' });
+    expect(result.valid).toBe(false);
+    expect(result.errors.length).toBeGreaterThanOrEqual(3);
+  });
+
+  test('customValidateParameters rejects endLine < startLine', () => {
+    const result = tool.customValidateParameters({
+      action: 'read-range', filePath: 'a.js', startLine: 10, endLine: 5
+    });
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters rejects range exceeding max', () => {
+    const result = tool.customValidateParameters({
+      action: 'read-range', filePath: 'a.js', startLine: 1, endLine: 600
+    });
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters accepts valid skeleton params', () => {
+    const result = tool.customValidateParameters({ action: 'skeleton', path: 'src/' });
+    expect(result.valid).toBe(true);
+  });
+
+  test('execute skeleton on single JS file', async () => {
+    const jsContent = [
+      'import express from "express";',
+      '',
+      'export class App {',
+      '  constructor() {}',
+      '  start() {',
+      '    console.log("started");',
+      '  }',
+      '}',
+      '',
+      'export function main() {',
+      '  return new App();',
+      '}'
+    ].join('\n');
+
+    mockFsPromises.stat.mockResolvedValue({
+      isFile: () => true,
+      isDirectory: () => false,
+      size: jsContent.length
+    });
+    mockFsPromises.readFile.mockResolvedValue(jsContent);
+
+    const result = await tool.execute(
+      { action: 'skeleton', path: 'src/app.js', level: 'B.0' },
+      context
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.action).toBe('skeleton');
+    expect(result.totalFiles).toBeGreaterThanOrEqual(1);
+    expect(result.totalEntries).toBeGreaterThanOrEqual(1);
+  });
+
+  test('execute skeleton on directory with JS files', async () => {
+    // First stat: directory check
+    mockFsPromises.stat
+      .mockResolvedValueOnce({ isFile: () => false, isDirectory: () => true })  // path stat
+      .mockResolvedValueOnce({ size: 100 }); // file stat
+
+    // Discover files - readdir for root
+    mockFsPromises.readdir.mockResolvedValueOnce([
+      { name: 'index.js', isDirectory: () => false, isFile: () => true, isSymbolicLink: () => false }
+    ]);
+
+    mockFsPromises.readFile
+      .mockRejectedValueOnce(new Error('no .gitignore'))  // _loadGitignoreRules
+      .mockResolvedValueOnce('export function hello() { return 1; }\n'); // file content
+
+    const result = await tool.execute(
+      { action: 'skeleton', path: 'src/', level: 'A.0' },
+      context
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.action).toBe('skeleton');
+  });
+
+  test('execute skeleton returns empty when no supported files', async () => {
+    mockFsPromises.stat.mockResolvedValue({ isFile: () => false, isDirectory: () => true });
+    mockFsPromises.readdir.mockResolvedValue([]);
+    mockFsPromises.readFile.mockRejectedValue(new Error('no file'));
+
+    const result = await tool.execute(
+      { action: 'skeleton', path: 'empty/' },
+      context
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.totalFiles).toBe(0);
+    expect(result.message).toContain('No supported files');
+  });
+
+  test('execute skeleton throws for non-existent path', async () => {
+    mockFsPromises.stat.mockRejectedValue(new Error('ENOENT'));
+
+    await expect(tool.execute(
+      { action: 'skeleton', path: 'missing/' },
+      context
+    )).rejects.toThrow('Path not found');
+  });
+
+  test('execute read-range returns formatted lines', async () => {
+    const content = 'line1\nline2\nline3\nline4\nline5\n';
+    mockFsPromises.readFile.mockResolvedValue(content);
+
+    const result = await tool.execute(
+      { action: 'read-range', filePath: 'src/index.js', startLine: 2, endLine: 4 },
+      context
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.action).toBe('read-range');
+    expect(result.linesReturned).toBe(3);
+    expect(result.content).toContain('line2');
+    expect(result.content).toContain('line3');
+    expect(result.content).toContain('line4');
+  });
+
+  test('execute read-range throws when startLine exceeds file length', async () => {
+    mockFsPromises.readFile.mockResolvedValue('line1\nline2\n');
+
+    await expect(tool.execute(
+      { action: 'read-range', filePath: 'a.js', startLine: 100, endLine: 110 },
+      context
+    )).rejects.toThrow('exceeds file length');
+  });
+
+  test('execute read-range throws for missing file', async () => {
+    mockFsPromises.readFile.mockRejectedValue(new Error('ENOENT'));
+
+    await expect(tool.execute(
+      { action: 'read-range', filePath: 'missing.js', startLine: 1, endLine: 5 },
+      context
+    )).rejects.toThrow('File not found');
+  });
+
+  test('execute throws on unknown action', async () => {
+    await expect(tool.execute(
+      { action: 'unknown' },
+      context
+    )).rejects.toThrow('Unknown action');
+  });
+
+  test('_langOf detects python files', () => {
+    expect(tool._langOf('script.py')).toBe('python');
+    expect(tool._langOf('app.js')).toBe('js');
+    expect(tool._langOf('component.tsx')).toBe('js');
+  });
+
+  test('_parseJS extracts exported functions', () => {
+    const lines = [
+      'export function hello() {',
+      '  return 1;',
+      '}'
+    ];
+    const entries = tool._parseJS(lines, { publicOnly: true, withComments: false, includeImports: false });
+    expect(entries.length).toBeGreaterThanOrEqual(1);
+    expect(entries[0].kind).toBe('signature');
+  });
+
+  test('_parseJS extracts imports when includeImports is true', () => {
+    const lines = [
+      'import express from "express";',
+      'const x = require("path");',
+      'export function hello() {}'
+    ];
+    const entries = tool._parseJS(lines, { publicOnly: false, withComments: false, includeImports: true });
+    const imports = entries.filter(e => e.kind === 'import');
+    expect(imports.length).toBe(2);
+  });
+
+  test('_parseJS includes comments when withComments is true', () => {
+    const lines = [
+      '/** My doc */',
+      'export function hello() {}'
+    ];
+    const entries = tool._parseJS(lines, { publicOnly: false, withComments: true, includeImports: false });
+    const comments = entries.filter(e => e.kind === 'comment');
+    expect(comments.length).toBeGreaterThanOrEqual(1);
+  });
+
+  test('_parsePython extracts def and class', () => {
+    const lines = [
+      'class MyClass:',
+      '    def __init__(self):',
+      '        pass',
+      '',
+      'def public_func():',
+      '    return 1'
+    ];
+    const entries = tool._parsePython(lines, { publicOnly: false, withComments: false, includeImports: false });
+    const sigs = entries.filter(e => e.kind === 'signature');
+    expect(sigs.length).toBeGreaterThanOrEqual(2);
+  });
+
+  test('_parsePython respects publicOnly', () => {
+    const lines = [
+      'def public_func():',
+      '    pass',
+      'def _private_func():',
+      '    pass'
+    ];
+    const entries = tool._parsePython(lines, { publicOnly: true, withComments: false, includeImports: false });
+    const sigs = entries.filter(e => e.kind === 'signature');
+    expect(sigs.length).toBe(1);
+    expect(sigs[0].text).toContain('public_func');
+  });
+
+  test('_parseGitignore parses rules', () => {
+    const content = '# comment\nnode_modules/\n*.log\n!important.log';
+    const rules = tool._parseGitignore(content, '');
+    expect(rules.length).toBe(3);
+    expect(rules[2].negate).toBe(true);
+  });
+
+  test('_gitignorePatternToRegex handles ** patterns', () => {
+    const re = tool._gitignorePatternToRegex('**/test');
+    expect(re).toContain('(.+/)?');
+  });
+
+  test('execute skeleton on unsupported file type throws', async () => {
+    mockFsPromises.stat.mockResolvedValue({
+      isFile: () => true,
+      isDirectory: () => false
+    });
+
+    await expect(tool.execute(
+      { action: 'skeleton', path: 'data.json' },
+      context
+    )).rejects.toThrow('Unsupported file type');
+  });
+});

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

@@ -0,0 +1,309 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig } from '../../__test-utils__/mockFactories.js';
+
+// Mock fs/promises
+const fsMock = {
+  readFile: jest.fn(),
+  writeFile: jest.fn().mockResolvedValue(undefined),
+  stat: jest.fn().mockResolvedValue({ size: 1000 }),
+  access: jest.fn().mockResolvedValue(undefined)
+};
+jest.unstable_mockModule('fs', () => ({
+  promises: fsMock,
+  default: { promises: fsMock }
+}));
+
+const { default: FileContentReplaceTool } = await import('../fileContentReplaceTool.js');
+
+describe('FileContentReplaceTool', () => {
+  let tool;
+  let logger;
+
+  beforeEach(() => {
+    logger = createMockLogger();
+    tool = new FileContentReplaceTool({}, logger);
+    jest.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    test('should set correct id and metadata', () => {
+      expect(tool.id).toBe('file-content-replace');
+      expect(tool.requiresProject).toBe(true);
+      expect(tool.isAsync).toBe(true);
+    });
+  });
+
+  describe('getDescription', () => {
+    test('should return description with usage info', () => {
+      const desc = tool.getDescription();
+      expect(desc).toContain('File Content Replace');
+      expect(desc).toContain('oldContent');
+      expect(desc).toContain('newContent');
+    });
+  });
+
+  describe('getRequiredParameters', () => {
+    test('should require files', () => {
+      expect(tool.getRequiredParameters()).toContain('files');
+    });
+  });
+
+  describe('parseParameters', () => {
+    test('should parse JSON format', () => {
+      const json = JSON.stringify({
+        files: [{
+          path: 'test.js',
+          replacements: [{ oldContent: 'old', newContent: 'new' }]
+        }]
+      });
+      const result = tool.parseParameters(json);
+      expect(result.files).toHaveLength(1);
+      expect(result.files[0].replacements[0].mode).toBe('trim');
+    });
+
+    test('should parse XML format', () => {
+      const xml = `<file path="test.js"><replace><old-content>old</old-content><new-content>new</new-content></replace></file>`;
+      const result = tool.parseParameters(xml);
+      expect(result.files).toHaveLength(1);
+      expect(result.files[0].path).toBe('test.js');
+    });
+
+    test('should throw on invalid JSON', () => {
+      expect(() => tool.parseParameters('{invalid}')).toThrow();
+    });
+  });
+
+  describe('parseJSON', () => {
+    test('should set default mode to trim', () => {
+      const result = tool.parseJSON(JSON.stringify({
+        files: [{ path: 'a.js', replacements: [{ oldContent: 'x', newContent: 'y' }] }]
+      }));
+      expect(result.files[0].replacements[0].mode).toBe('trim');
+    });
+
+    test('should throw when files is not an array', () => {
+      expect(() => tool.parseJSON('{"files": "not-array"}')).toThrow('files');
+    });
+  });
+
+  describe('applyTrimMode', () => {
+    test('should trim whitespace in trim mode', () => {
+      expect(tool.applyTrimMode('  hello  ', 'trim')).toBe('hello');
+    });
+
+    test('should only trim newlines in newlines mode', () => {
+      expect(tool.applyTrimMode('\n  hello  \n', 'newlines')).toBe('  hello  ');
+    });
+
+    test('should not modify in none mode', () => {
+      expect(tool.applyTrimMode('  hello  ', 'none')).toBe('  hello  ');
+    });
+  });
+
+  describe('countOccurrences', () => {
+    test('should count multiple occurrences', () => {
+      expect(tool.countOccurrences('abcabcabc', 'abc')).toBe(3);
+    });
+
+    test('should return 0 for no matches', () => {
+      expect(tool.countOccurrences('hello', 'xyz')).toBe(0);
+    });
+
+    test('should return 0 for empty substring', () => {
+      expect(tool.countOccurrences('hello', '')).toBe(0);
+    });
+  });
+
+  describe('parseLineRanges', () => {
+    test('should parse single line number', () => {
+      const result = tool.parseLineRanges('5');
+      expect(result.has(5)).toBe(true);
+      expect(result.size).toBe(1);
+    });
+
+    test('should parse comma-separated numbers', () => {
+      const result = tool.parseLineRanges('1,3,5');
+      expect(result.has(1)).toBe(true);
+      expect(result.has(3)).toBe(true);
+      expect(result.has(5)).toBe(true);
+    });
+
+    test('should parse ranges', () => {
+      const result = tool.parseLineRanges('5-8');
+      expect(result.has(5)).toBe(true);
+      expect(result.has(6)).toBe(true);
+      expect(result.has(7)).toBe(true);
+      expect(result.has(8)).toBe(true);
+    });
+
+    test('should parse mixed format', () => {
+      const result = tool.parseLineRanges('1,3-5,10');
+      expect(result.size).toBe(5);
+    });
+
+    test('should handle empty string', () => {
+      const result = tool.parseLineRanges('');
+      expect(result.size).toBe(0);
+    });
+
+    test('should handle null', () => {
+      const result = tool.parseLineRanges(null);
+      expect(result.size).toBe(0);
+    });
+  });
+
+  describe('applyReplacement', () => {
+    test('should replace all occurrences without line limit', async () => {
+      const result = await tool.applyReplacement('hello world hello', 'hello', 'hi', null, 'none');
+      expect(result.newContent).toBe('hi world hi');
+      expect(result.count).toBe(2);
+    });
+
+    test('should return 0 count when content not found', async () => {
+      const result = await tool.applyReplacement('hello world', 'xyz', 'abc', null, 'none');
+      expect(result.count).toBe(0);
+      expect(result.newContent).toBe('hello world');
+    });
+
+    test('should respect line limits', async () => {
+      const content = 'line1 old\nline2 old\nline3 old';
+      const result = await tool.applyReplacement(content, 'old', 'new', '2', 'none');
+      expect(result.count).toBe(1);
+      expect(result.newContent).toBe('line1 old\nline2 new\nline3 old');
+    });
+  });
+
+  describe('generateDiff', () => {
+    test('should return "No differences" for identical content', () => {
+      const result = tool.generateDiff('hello', 'hello');
+      expect(result).toBe('No differences');
+    });
+
+    test('should show changed lines', () => {
+      const original = 'line1\nold line\nline3';
+      const modified = 'line1\nnew line\nline3';
+      const result = tool.generateDiff(original, modified);
+      expect(result).toContain('- old line');
+      expect(result).toContain('+ new line');
+    });
+  });
+
+  describe('generateSummary', () => {
+    test('should format stats correctly', () => {
+      const summary = tool.generateSummary({
+        filesProcessed: 3,
+        filesModified: 2,
+        totalReplacements: 5,
+        backupsCreated: 2,
+        errors: 0
+      });
+      expect(summary).toContain('3 file(s)');
+      expect(summary).toContain('5');
+    });
+  });
+
+  describe('customValidateParameters', () => {
+    test('should reject non-array files', () => {
+      expect(() => tool.customValidateParameters({ files: 'not-array' })).toThrow();
+    });
+
+    test('should reject empty files array', () => {
+      expect(() => tool.customValidateParameters({ files: [] })).toThrow();
+    });
+
+    test('should reject file without path', () => {
+      expect(() => tool.customValidateParameters({
+        files: [{ replacements: [{ oldContent: 'a', newContent: 'b' }] }]
+      })).toThrow();
+    });
+
+    test('should reject path traversal', () => {
+      expect(() => tool.customValidateParameters({
+        files: [{ path: '../secret/file.js', replacements: [{ oldContent: 'a', newContent: 'b' }] }]
+      })).toThrow('traversal');
+    });
+
+    test('should reject invalid mode', () => {
+      expect(() => tool.customValidateParameters({
+        files: [{ path: 'a.js', replacements: [{ oldContent: 'a', newContent: 'b', mode: 'invalid' }] }]
+      })).toThrow('Invalid mode');
+    });
+
+    test('should accept valid params', () => {
+      const result = tool.customValidateParameters({
+        files: [{ path: 'a.js', replacements: [{ oldContent: 'a', newContent: 'b' }] }]
+      });
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe('isPathAccessible', () => {
+    test('should allow paths within working directory', () => {
+      const result = tool.isPathAccessible('/project/src/app.js', '/project', {});
+      expect(result).toBe(true);
+    });
+
+    test('should reject paths outside working directory', () => {
+      const result = tool.isPathAccessible('/other/secret.js', '/project', {});
+      expect(result).toBe(false);
+    });
+
+    test('should allow paths in writeEnabledDirectories', () => {
+      const result = tool.isPathAccessible('/shared/file.js', '/project', {
+        writeEnabledDirectories: ['/shared']
+      });
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('execute', () => {
+    test('should process files and return results', async () => {
+      fsMock.access.mockResolvedValue(undefined);
+      fsMock.stat.mockResolvedValue({ size: 100 });
+      fsMock.readFile.mockResolvedValue('const x = "old";');
+      fsMock.writeFile.mockResolvedValue(undefined);
+
+      const result = await tool.execute({
+        files: [{
+          path: 'test.js',
+          replacements: [{ oldContent: 'old', newContent: 'new', mode: 'none' }]
+        }]
+      }, { projectDir: '/project' });
+
+      expect(result.success).toBe(true);
+      expect(result.statistics.totalReplacements).toBe(1);
+    });
+
+    test('should handle string params by parsing', async () => {
+      fsMock.access.mockResolvedValue(undefined);
+      fsMock.stat.mockResolvedValue({ size: 100 });
+      fsMock.readFile.mockResolvedValue('hello old world');
+      fsMock.writeFile.mockResolvedValue(undefined);
+
+      const result = await tool.execute(
+        JSON.stringify({ files: [{ path: 'a.js', replacements: [{ oldContent: 'old', newContent: 'new' }] }] }),
+        { projectDir: '/project' }
+      );
+      expect(result.success).toBe(true);
+    });
+
+    test('should handle file not found error', async () => {
+      fsMock.access.mockRejectedValue(new Error('ENOENT'));
+
+      const result = await tool.execute({
+        files: [{
+          path: 'missing.js',
+          replacements: [{ oldContent: 'a', newContent: 'b', mode: 'none' }]
+        }]
+      }, { projectDir: '/project' });
+
+      expect(result.statistics.errors).toBe(1);
+    });
+  });
+
+  describe('cleanup', () => {
+    test('should complete without error', async () => {
+      await expect(tool.cleanup('op-1')).resolves.not.toThrow();
+    });
+  });
+});