@renxqoo/renx-code 0.0.3 → 0.0.5

package/vendor/agent-root/src/agent/tool/__test__/glob.test.ts

@@ -0,0 +1,139 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { GlobTool } from '../glob';
+
+describe('GlobTool', () => {
+  let rootDir: string;
+  let tool: GlobTool;
+
+  beforeEach(async () => {
+    rootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-glob-tool-'));
+    tool = new GlobTool({ allowedDirectories: [rootDir] });
+  });
+
+  afterEach(async () => {
+    await fs.rm(rootDir, { recursive: true, force: true });
+  });
+
+  it('finds files by pattern and returns metadata', async () => {
+    await fs.mkdir(path.join(rootDir, 'src'), { recursive: true });
+    await fs.writeFile(path.join(rootDir, 'src', 'a.ts'), 'export const a = 1;', 'utf8');
+    await fs.writeFile(path.join(rootDir, 'src', 'b.ts'), 'export const b = 2;', 'utf8');
+    await fs.writeFile(path.join(rootDir, 'src', 'c.js'), 'module.exports = {};', 'utf8');
+
+    const result = await tool.execute({
+      pattern: '**/*.ts',
+      path: rootDir,
+      include_hidden: false,
+      max_results: 200,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.output).toContain('Found 2 file(s)');
+
+    const metadata = result.metadata as {
+      total: number;
+      files: string[];
+      relative_files: string[];
+      truncated: boolean;
+    };
+
+    expect(metadata.total).toBe(2);
+    expect(metadata.files.every((file) => file.endsWith('.ts'))).toBe(true);
+    expect(metadata.relative_files).toEqual(['src/a.ts', 'src/b.ts']);
+    expect(metadata.truncated).toBe(false);
+  });
+
+  it('supports include_hidden flag', async () => {
+    await fs.writeFile(path.join(rootDir, '.hidden.ts'), 'export const hidden = true;', 'utf8');
+
+    const hiddenOff = await tool.execute({
+      pattern: '**/*.ts',
+      path: rootDir,
+      include_hidden: false,
+      max_results: 200,
+    });
+    expect(hiddenOff.success).toBe(true);
+    expect((hiddenOff.metadata as { total: number }).total).toBe(0);
+
+    const hiddenOn = await tool.execute({
+      pattern: '**/*.ts',
+      path: rootDir,
+      include_hidden: true,
+      max_results: 200,
+    });
+    expect(hiddenOn.success).toBe(true);
+    expect((hiddenOn.metadata as { total: number }).total).toBe(1);
+  });
+
+  it('returns failure for path outside allowed directories', async () => {
+    const result = await tool.execute({
+      pattern: '**/*.ts',
+      path: path.resolve(rootDir, '..'),
+      include_hidden: false,
+      max_results: 200,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain('SEARCH_PATH_NOT_ALLOWED');
+  });
+
+  it('exposes parallel-safe concurrency policy and stable lock key', () => {
+    const mode = tool.getConcurrencyMode();
+    const lockKey = tool.getConcurrencyLockKey({
+      pattern: '**/*.ts',
+      path: rootDir,
+      include_hidden: false,
+      max_results: 10,
+    });
+
+    expect(mode).toBe('parallel-safe');
+    expect(lockKey).toBe(`glob:${rootDir}`);
+  });
+
+  it('uses cwd fallback in lock key when path is omitted', () => {
+    const lockKey = tool.getConcurrencyLockKey({
+      pattern: '**/*.ts',
+      include_hidden: false,
+      max_results: 10,
+    });
+
+    expect(lockKey).toBe(`glob:${process.cwd()}`);
+  });
+
+  it('falls back to default error code for non-prefixed messages', () => {
+    const errorCode = (
+      tool as unknown as { extractErrorCode: (msg: string) => string }
+    ).extractErrorCode('plain error text');
+    expect(errorCode).toBe('GLOB_OPERATION_FAILED');
+  });
+
+  it('stringifies non-Error throws from internals', async () => {
+    vi.resetModules();
+    vi.doMock('../search/common', async () => {
+      const actual = await vi.importActual<typeof import('../search/common')>('../search/common');
+      return {
+        ...actual,
+        resolveSearchRoot: vi.fn(async () => {
+          throw 'plain string thrown';
+        }),
+      };
+    });
+
+    const { GlobTool: MockedGlobTool } = await import('../glob');
+    const mockedTool = new MockedGlobTool({ allowedDirectories: [rootDir] });
+    const result = await mockedTool.execute({
+      pattern: '**/*.ts',
+      path: rootDir,
+      include_hidden: false,
+      max_results: 10,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toBe('plain string thrown');
+    expect((result.metadata as { error: string }).error).toBe('GLOB_OPERATION_FAILED');
+    vi.doUnmock('../search/common');
+  });
+});

package/vendor/agent-root/src/agent/tool/__test__/grep.mocked-coverage.test.ts

@@ -0,0 +1,456 @@
+import { EventEmitter } from 'node:events';
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { PassThrough } from 'node:stream';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { GrepTool } from '../grep';
+
+const { spawnMock, spawnSyncMock } = vi.hoisted(() => ({
+  spawnMock: vi.fn(),
+  spawnSyncMock: vi.fn(),
+}));
+
+vi.mock('node:child_process', () => ({
+  spawn: spawnMock,
+  spawnSync: spawnSyncMock,
+}));
+
+vi.mock('@vscode/ripgrep', () => ({
+  rgPath: '/mock/vscode-rg',
+}));
+
+function createChild(options: { withStdout?: boolean; withStderr?: boolean } = {}) {
+  const child = new EventEmitter() as EventEmitter & {
+    stdout?: PassThrough;
+    stderr?: PassThrough;
+    killed: boolean;
+    kill: (signal?: string) => boolean;
+  };
+  if (options.withStdout !== false) {
+    child.stdout = new PassThrough();
+  }
+  if (options.withStderr !== false) {
+    child.stderr = new PassThrough();
+  }
+  child.killed = false;
+  child.kill = vi.fn((): boolean => {
+    child.killed = true;
+    child.emit('close', 0, null);
+    return true;
+  }) as unknown as (signal?: string) => boolean;
+  return child;
+}
+
+describe('GrepTool mocked branch coverage', () => {
+  let rootDir: string;
+
+  beforeEach(async () => {
+    rootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-grep-mocked-'));
+    spawnMock.mockReset();
+    spawnSyncMock.mockReset();
+    spawnSyncMock.mockReturnValue({ status: 0, error: undefined });
+    delete process.env.RIPGREP_PATH;
+  });
+
+  afterEach(async () => {
+    vi.restoreAllMocks();
+    delete process.env.RIPGREP_PATH;
+    await fs.rm(rootDir, { recursive: true, force: true });
+  });
+
+  it('returns RIPGREP_NOT_FOUND when all candidate probes fail', async () => {
+    process.env.RIPGREP_PATH = 'env-rg';
+    spawnSyncMock.mockReturnValue({
+      status: 1,
+      error: new Error('missing'),
+    });
+
+    const tool = new GrepTool({
+      allowedDirectories: [rootDir],
+      rgPath: 'custom-rg',
+    });
+    const result = await tool.execute({
+      pattern: 'hello',
+      path: rootDir,
+      timeout_ms: 1000,
+      max_results: 10,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain('RIPGREP_NOT_FOUND');
+    expect((result.metadata as { error: string }).error).toBe('RIPGREP_NOT_FOUND');
+  });
+
+  it('maps non-Error execute failures using String(error)', async () => {
+    const tool = new GrepTool({ allowedDirectories: [rootDir], rgPath: 'custom-rg' });
+    const helper = tool as unknown as {
+      runRipgrep: () => Promise<never>;
+    };
+    vi.spyOn(helper, 'runRipgrep').mockRejectedValueOnce('plain failure');
+
+    const result = await tool.execute({
+      pattern: 'hello',
+      path: rootDir,
+      timeout_ms: 1000,
+      max_results: 10,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toBe('plain failure');
+    expect((result.metadata as { error: string }).error).toBe('GREP_EXECUTION_ERROR');
+  });
+
+  it('covers parser fallbacks, stderr chunk handling, and max-results truncation', async () => {
+    const tool = new GrepTool({ allowedDirectories: [rootDir] });
+    const helper = tool as unknown as {
+      runRipgrep: (
+        ripgrepBinary: string,
+        commandArgs: string[],
+        rootPath: string,
+        args: { pattern: string; timeout_ms: number; max_results: number },
+        context?: { onChunk?: (chunk: unknown) => Promise<void> | void }
+      ) => Promise<{ data: Record<string, unknown>; output: string }>;
+    };
+
+    const child = createChild();
+    spawnMock.mockReturnValueOnce(child);
+
+    const chunks: unknown[] = [];
+    const run = helper.runRipgrep(
+      'rg',
+      ['--json'],
+      rootDir,
+      { pattern: 'hello', timeout_ms: 2000, max_results: 1 },
+      {
+        onChunk: async (chunk) => {
+          chunks.push(chunk);
+        },
+      }
+    );
+
+    child.stderr?.emit('data', 'stderr-string');
+    child.stderr?.write(Buffer.from('stderr-line'));
+    child.stdout?.write('\n');
+    child.stdout?.write('123\n');
+    child.stdout?.write('{"type":"match","data":null}\n');
+    child.stdout?.write(
+      '{"type":"match","data":{"path":123,"lines":{"text":"skip\\n"},"line_number":3}}\n'
+    );
+    child.stdout?.write(
+      '{"type":"match","data":{"path":{},"lines":{"text":"skip\\n"},"line_number":4}}\n'
+    );
+    child.stdout?.write(
+      '{"type":"match","data":{"path":{"bytes":"ZmlsZS50cw=="},"lines":{"bytes":"aGVsbG8K"},"line_number":"x","submatches":"oops"}}\n'
+    );
+    child.stdout?.end();
+
+    const result = await run;
+    expect((result.data as { truncated: boolean }).truncated).toBe(true);
+    expect(result.output).toContain('(truncated)');
+    expect(chunks.length).toBeGreaterThan(0);
+  });
+
+  it('covers stderr Buffer chunk decoding branch', async () => {
+    const tool = new GrepTool({ allowedDirectories: [rootDir] });
+    const helper = tool as unknown as {
+      runRipgrep: (
+        ripgrepBinary: string,
+        commandArgs: string[],
+        rootPath: string,
+        args: { pattern: string; timeout_ms: number; max_results: number }
+      ) => Promise<{ data: Record<string, unknown>; output: string }>;
+    };
+
+    const child = createChild();
+    const stderrEmitter = new EventEmitter() as EventEmitter & {
+      setEncoding: (encoding: string) => void;
+    };
+    stderrEmitter.setEncoding = vi.fn();
+    child.stderr = stderrEmitter as unknown as PassThrough;
+    spawnMock.mockReturnValueOnce(child);
+
+    const run = helper.runRipgrep('rg', ['--json'], rootDir, {
+      pattern: 'x',
+      timeout_ms: 1000,
+      max_results: 10,
+    });
+
+    stderrEmitter.emit('data', Buffer.from('stderr-buffer'));
+    child.stdout?.end();
+    child.emit('close', 1, null);
+
+    const result = await run;
+    expect(result.output).toBe('No matches found');
+  });
+
+  it('covers timeout branch and killChild catch branch', async () => {
+    const tool = new GrepTool({ allowedDirectories: [rootDir] });
+    const helper = tool as unknown as {
+      runRipgrep: (
+        ripgrepBinary: string,
+        commandArgs: string[],
+        rootPath: string,
+        args: { pattern: string; timeout_ms: number; max_results: number }
+      ) => Promise<{ data: Record<string, unknown>; output: string }>;
+    };
+
+    const child = createChild();
+    child.kill = vi.fn((): boolean => {
+      throw new Error('kill failed');
+    }) as unknown as (signal?: string) => boolean;
+    spawnMock.mockReturnValueOnce(child);
+
+    const run = helper.runRipgrep('rg', ['--json'], rootDir, {
+      pattern: 'slow',
+      timeout_ms: 10,
+      max_results: 100,
+    });
+    setTimeout(() => {
+      child.stdout?.end();
+      child.emit('close', null, 'SIGTERM');
+    }, 30);
+
+    const result = await run;
+    expect(result.output).toContain('Search timed out after 10ms');
+    expect((result.data as { timed_out: boolean }).timed_out).toBe(true);
+  });
+
+  it('throws RIPGREP_ERROR when stdout stream cannot be captured', async () => {
+    const tool = new GrepTool({ allowedDirectories: [rootDir] });
+    const helper = tool as unknown as {
+      runRipgrep: (
+        ripgrepBinary: string,
+        commandArgs: string[],
+        rootPath: string,
+        args: { pattern: string; timeout_ms: number; max_results: number }
+      ) => Promise<{ data: Record<string, unknown>; output: string }>;
+    };
+
+    const child = createChild({ withStdout: false });
+    spawnMock.mockReturnValueOnce(child);
+
+    await expect(
+      helper.runRipgrep('rg', ['--json'], rootDir, {
+        pattern: 'x',
+        timeout_ms: 1000,
+        max_results: 10,
+      })
+    ).rejects.toThrow('RIPGREP_ERROR: failed to capture ripgrep stdout stream');
+  });
+
+  it('throws RIPGREP_STREAM_ERROR on stdout stream failures', async () => {
+    const tool = new GrepTool({ allowedDirectories: [rootDir] });
+    const helper = tool as unknown as {
+      runRipgrep: (
+        ripgrepBinary: string,
+        commandArgs: string[],
+        rootPath: string,
+        args: { pattern: string; timeout_ms: number; max_results: number }
+      ) => Promise<{ data: Record<string, unknown>; output: string }>;
+    };
+
+    const child = createChild();
+    spawnMock.mockReturnValueOnce(child);
+
+    const run = helper.runRipgrep('rg', ['--json'], rootDir, {
+      pattern: 'x',
+      timeout_ms: 1000,
+      max_results: 10,
+    });
+
+    child.stdout?.emit('error', new Error('stream exploded'));
+    child.emit('close', 0, null);
+    await expect(run).rejects.toThrow('RIPGREP_STREAM_ERROR: stream exploded');
+
+    const secondChild = createChild();
+    spawnMock.mockReturnValueOnce(secondChild);
+    const secondRun = helper.runRipgrep('rg', ['--json'], rootDir, {
+      pattern: 'x',
+      timeout_ms: 1000,
+      max_results: 10,
+    });
+    secondChild.stdout?.emit('error', 'string-stream-error');
+    secondChild.emit('close', 0, null);
+    await expect(secondRun).rejects.toThrow('RIPGREP_STREAM_ERROR: string-stream-error');
+  });
+
+  it('throws signal and exit-code errors from ripgrep process', async () => {
+    const tool = new GrepTool({ allowedDirectories: [rootDir] });
+    const helper = tool as unknown as {
+      runRipgrep: (
+        ripgrepBinary: string,
+        commandArgs: string[],
+        rootPath: string,
+        args: { pattern: string; timeout_ms: number; max_results: number }
+      ) => Promise<{ data: Record<string, unknown>; output: string }>;
+    };
+
+    const signalChild = createChild();
+    spawnMock.mockReturnValueOnce(signalChild);
+    const signalRun = helper.runRipgrep('rg', ['--json'], rootDir, {
+      pattern: 'x',
+      timeout_ms: 1000,
+      max_results: 10,
+    });
+    signalChild.stdout?.end();
+    signalChild.emit('close', null, 'SIGTERM');
+    await expect(signalRun).rejects.toThrow('RIPGREP_ERROR: ripgrep terminated by signal SIGTERM');
+
+    const code2Child = createChild();
+    spawnMock.mockReturnValueOnce(code2Child);
+    const code2Run = helper.runRipgrep('rg', ['--json'], rootDir, {
+      pattern: 'x',
+      timeout_ms: 1000,
+      max_results: 10,
+    });
+    code2Child.stderr?.write('bad regex');
+    code2Child.stdout?.end();
+    code2Child.emit('close', 2, null);
+    await expect(code2Run).rejects.toThrow('RIPGREP_ERROR: bad regex');
+
+    const code2FallbackChild = createChild();
+    spawnMock.mockReturnValueOnce(code2FallbackChild);
+    const code2FallbackRun = helper.runRipgrep('rg', ['--json'], rootDir, {
+      pattern: 'x',
+      timeout_ms: 1000,
+      max_results: 10,
+    });
+    code2FallbackChild.stdout?.end();
+    code2FallbackChild.emit('close', 2, null);
+    await expect(code2FallbackRun).rejects.toThrow('RIPGREP_ERROR: ripgrep execution failed');
+
+    const code5Child = createChild();
+    spawnMock.mockReturnValueOnce(code5Child);
+    const code5Run = helper.runRipgrep('rg', ['--json'], rootDir, {
+      pattern: 'x',
+      timeout_ms: 1000,
+      max_results: 10,
+    });
+    code5Child.stdout?.end();
+    code5Child.emit('close', 5, null);
+    await expect(code5Run).rejects.toThrow('RIPGREP_ERROR: ripgrep exited with code 5');
+  });
+
+  it('covers decodeTextField base64 catch path with mocked Buffer.from failure', async () => {
+    const tool = new GrepTool({ allowedDirectories: [rootDir] });
+    const helper = tool as unknown as {
+      runRipgrep: (
+        ripgrepBinary: string,
+        commandArgs: string[],
+        rootPath: string,
+        args: { pattern: string; timeout_ms: number; max_results: number }
+      ) => Promise<{ data: Record<string, unknown>; output: string }>;
+    };
+
+    const originalBufferFrom = Buffer.from.bind(Buffer);
+    const originalBufferFromString = originalBufferFrom as unknown as (
+      value: string,
+      encoding?: BufferEncoding
+    ) => Buffer;
+    const originalBufferFromBytes = originalBufferFrom as unknown as (
+      value: ArrayLike<number>
+    ) => Buffer;
+    const bufferSpy = vi.spyOn(Buffer, 'from').mockImplementation(((
+      value: string | ArrayBuffer | SharedArrayBuffer | ArrayBufferView,
+      encodingOrOffset?: BufferEncoding | number,
+      length?: number
+    ) => {
+      if (encodingOrOffset === 'base64') {
+        throw new Error('bad-base64');
+      }
+      if (typeof value === 'string') {
+        return originalBufferFromString(value, encodingOrOffset as BufferEncoding | undefined);
+      }
+      if (typeof encodingOrOffset === 'number') {
+        return originalBufferFromBytes(
+          new Uint8Array(value as ArrayBuffer | SharedArrayBuffer).subarray(
+            encodingOrOffset,
+            typeof length === 'number' ? encodingOrOffset + length : undefined
+          )
+        );
+      }
+      if (ArrayBuffer.isView(value)) {
+        return originalBufferFromBytes(
+          new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+        );
+      }
+      return originalBufferFromBytes(new Uint8Array(value as ArrayBuffer | SharedArrayBuffer));
+    }) as typeof Buffer.from);
+
+    const child = createChild();
+    spawnMock.mockReturnValueOnce(child);
+    const run = helper.runRipgrep('rg', ['--json'], rootDir, {
+      pattern: 'x',
+      timeout_ms: 1000,
+      max_results: 10,
+    });
+
+    child.stdout?.write(
+      '{"type":"match","data":{"path":{"bytes":"bm90LXVzZWQ="},"lines":{"text":"line\\n"},"line_number":1,"submatches":[{"start":0}]}}\n'
+    );
+    child.stdout?.end();
+    child.emit('close', 1, null);
+
+    const result = await run;
+    expect(result.output).toBe('No matches found');
+    bufferSpy.mockRestore();
+  });
+
+  it('covers line label fallback and lock-key cwd fallback', () => {
+    const tool = new GrepTool({ allowedDirectories: [rootDir] });
+    const helper = tool as unknown as {
+      buildSuccessResult: (
+        fileMap: Map<
+          string,
+          {
+            file: string;
+            matchCount: number;
+            matches: Array<{ line: number | null; column: number | null; text: string }>;
+          }
+        >,
+        totalMatches: number,
+        options: {
+          pattern: string;
+          rootPath: string;
+          truncated: boolean;
+          timedOut: boolean;
+          message: string;
+        }
+      ) => { data: Record<string, unknown>; output: string };
+    };
+    const map = new Map<
+      string,
+      {
+        file: string;
+        matchCount: number;
+        matches: Array<{ line: number | null; column: number | null; text: string }>;
+      }
+    >([
+      [
+        'a.ts',
+        {
+          file: 'a.ts',
+          matchCount: 1,
+          matches: [{ line: null, column: null, text: 'hello' }],
+        },
+      ],
+    ]);
+
+    const built = helper.buildSuccessResult(map, 1, {
+      pattern: 'hello',
+      rootPath: rootDir,
+      truncated: false,
+      timedOut: false,
+      message: 'Search completed',
+    });
+    expect(built.output).toContain('Line ?');
+
+    const lockKey = tool.getConcurrencyLockKey({
+      pattern: 'hello',
+      timeout_ms: 1000,
+      max_results: 10,
+    });
+    expect(lockKey).toBe(`grep:${process.cwd()}:hello`);
+  });
+});