@renxqoo/renx-code 0.0.9 → 0.0.12

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

@@ -1,192 +0,0 @@
-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 { spawnSync } from 'node:child_process';
-import { rgPath as vscodeRgPath } from '@vscode/ripgrep';
-import { GrepTool } from '../grep';
-
-function hasExecutable(binary: string | undefined): boolean {
-  if (!binary || !binary.trim()) {
-    return false;
-  }
-  const probe = spawnSync(binary, ['--version'], { stdio: 'ignore' });
-  return !probe.error && probe.status === 0;
-}
-
-const hasRipgrep = [process.env.RIPGREP_PATH, vscodeRgPath, 'rg'].some((candidate) =>
-  hasExecutable(candidate)
-);
-const itIfRipgrep = hasRipgrep ? it : it.skip;
-
-describe('GrepTool', () => {
-  let rootDir: string;
-  let tool: GrepTool;
-
-  beforeEach(async () => {
-    rootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-grep-tool-'));
-    tool = new GrepTool({ allowedDirectories: [rootDir] });
-  });
-
-  afterEach(async () => {
-    delete process.env.RIPGREP_PATH;
-    await fs.rm(rootDir, { recursive: true, force: true });
-  });
-
-  itIfRipgrep('finds matches in multiple files', async () => {
-    await fs.mkdir(path.join(rootDir, 'src'), { recursive: true });
-    await fs.writeFile(path.join(rootDir, 'src', 'a.ts'), 'const hello = "world";', 'utf8');
-    await fs.writeFile(path.join(rootDir, 'src', 'b.ts'), 'function hello() { return 1; }', 'utf8');
-    await fs.writeFile(path.join(rootDir, 'src', 'c.txt'), 'nothing', 'utf8');
-
-    const result = await tool.execute({
-      pattern: 'hello',
-      path: rootDir,
-      glob: '**/*.ts',
-      timeout_ms: 60000,
-      max_results: 200,
-    });
-
-    expect(result.success).toBe(true);
-    expect(result.output).toContain('Found');
-
-    const metadata = result.metadata as {
-      countFiles: number;
-      countMatches: number;
-      truncated: boolean;
-    };
-    expect(metadata.countFiles).toBe(2);
-    expect(metadata.countMatches).toBeGreaterThanOrEqual(2);
-    expect(metadata.truncated).toBe(false);
-  });
-
-  itIfRipgrep('returns success with no matches', async () => {
-    await fs.writeFile(path.join(rootDir, 'test.txt'), 'no matching text', 'utf8');
-
-    const result = await tool.execute({
-      pattern: 'THIS_PATTERN_DOES_NOT_EXIST_12345',
-      path: rootDir,
-      timeout_ms: 60000,
-      max_results: 200,
-    });
-
-    expect(result.success).toBe(true);
-    expect(result.output).toBe('No matches found');
-    expect((result.metadata as { countMatches: number }).countMatches).toBe(0);
-  });
-
-  it('rejects path outside allowed directories', async () => {
-    const result = await tool.execute({
-      pattern: 'anything',
-      path: path.resolve(rootDir, '..'),
-      timeout_ms: 60000,
-      max_results: 200,
-    });
-
-    expect(result.success).toBe(false);
-    expect(result.output).toContain('SEARCH_PATH_NOT_ALLOWED');
-  });
-
-  it('exposes parallel-safe concurrency policy and lock key', () => {
-    expect(tool.getConcurrencyMode()).toBe('parallel-safe');
-    expect(
-      tool.getConcurrencyLockKey({
-        pattern: 'hello',
-        path: rootDir,
-        timeout_ms: 1000,
-        max_results: 10,
-      })
-    ).toBe(`grep:${rootDir}:hello`);
-  });
-
-  it('falls back to default grep error code for non-prefixed errors', () => {
-    const errorCode = (
-      tool as unknown as { extractErrorCode: (text: string) => string }
-    ).extractErrorCode('plain error');
-    expect(errorCode).toBe('GREP_EXECUTION_ERROR');
-  });
-
-  it('runRipgrep helper returns enriched summary output envelope', async () => {
-    const helper = tool as unknown as {
-      runRipgrep: (
-        bin: string,
-        args: string[],
-        rootPath: string,
-        request: { pattern: string; timeout_ms: number; max_results: number },
-        context?: { onChunk?: (chunk: unknown) => Promise<void> | void }
-      ) => Promise<{ data: Record<string, unknown>; output: string }>;
-    };
-
-    const script = [
-      'const lines = [',
-      `'not-json',`,
-      `'{"type":"match","data":{"path":{"text":"file1.ts"},"lines":{"text":"hello\\\\n"},"line_number":1,"submatches":[{"start":0}]}}',`,
-      `'{"type":"match","data":{"path":{"text":"file2.ts"},"lines":{"text":"hello\\\\n"},"line_number":2,"submatches":[{"start":1}]}}'`,
-      '];',
-      'for (const line of lines) process.stdout.write(line + "\\n");',
-    ].join('');
-
-    const onChunk = vi.fn();
-    const result = await helper.runRipgrep(
-      process.execPath,
-      ['-e', script],
-      rootDir,
-      { pattern: 'hello', timeout_ms: 3000, max_results: 2 },
-      { onChunk }
-    );
-
-    expect((result.data as { truncated: boolean }).truncated).toBe(true);
-    expect(result.output).toContain('(truncated)');
-  });
-
-  it('buildSuccessResult prefixes non-default message and includes aggregation hints', () => {
-    const helper = tool as unknown as {
-      buildSuccessResult: (
-        map: Map<
-          string,
-          {
-            file: string;
-            matchCount: number;
-            matches: Array<{ line: number | null; column: number | null; text: string }>;
-          }
-        >,
-        total: 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 }>;
-      }
-    >();
-    for (let i = 0; i < 25; i += 1) {
-      map.set(`file-${i}`, {
-        file: `file-${i}`,
-        matchCount: 12,
-        matches: [{ line: 1, column: 1, text: 'hello' }],
-      });
-    }
-
-    const result = helper.buildSuccessResult(map, 300, {
-      pattern: 'hello',
-      rootPath: rootDir,
-      truncated: true,
-      timedOut: true,
-      message: 'Search timed out',
-    });
-
-    expect(result.output.startsWith('Search timed out')).toBe(true);
-    expect(result.output).toContain('... and 5 more files');
-    expect((result.data as { timed_out: boolean }).timed_out).toBe(true);
-  });
-});

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

@@ -1,300 +0,0 @@
-import { describe, expect, it, beforeEach, afterEach } from 'vitest';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { LspTool } from '../lsp';
-
-describe('LspTool', () => {
-  let tool: LspTool;
-  let tempDir: string;
-
-  beforeEach(() => {
-    // Create temp directory for test files
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lsp-test-'));
-    tool = new LspTool({ allowedDirectories: [tempDir] });
-  });
-
-  afterEach(() => {
-    // Cleanup temp directory
-    try {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    } catch {
-      // ignore
-    }
-  });
-
-  function createTestFile(name: string, content: string): string {
-    const filePath = path.join(tempDir, name);
-    fs.writeFileSync(filePath, content, 'utf-8');
-    return filePath;
-  }
-
-  describe('Path Security', () => {
-    it('rejects files outside allowed directories', async () => {
-      await expect(
-        tool.execute({
-          operation: 'documentSymbols',
-          filePath: '/etc/passwd',
-        })
-      ).rejects.toThrow('LSP_PATH_NOT_ALLOWED');
-    });
-
-    it('accepts files within allowed directories', async () => {
-      const filePath = createTestFile('test.ts', 'const x = 1;');
-      const result = await tool.execute({
-        operation: 'documentSymbols',
-        filePath,
-      });
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('File Validation', () => {
-    it('throws for non-existent files', async () => {
-      await expect(
-        tool.execute({
-          operation: 'documentSymbols',
-          filePath: path.join(tempDir, 'nonexistent.ts'),
-        })
-      ).rejects.toThrow('File not found');
-    });
-
-    it('throws for unsupported file types', async () => {
-      const filePath = createTestFile('test.txt', 'plain text');
-      await expect(
-        tool.execute({
-          operation: 'documentSymbols',
-          filePath,
-        })
-      ).rejects.toThrow('Unsupported file type');
-    });
-
-    it('supports .ts files', async () => {
-      const filePath = createTestFile('test.ts', 'const x = 1;');
-      const result = await tool.execute({
-        operation: 'documentSymbols',
-        filePath,
-      });
-      expect(result.success).toBe(true);
-    });
-
-    it('supports .tsx files', async () => {
-      const filePath = createTestFile('test.tsx', 'const Component = () => <div/>;');
-      const result = await tool.execute({
-        operation: 'documentSymbols',
-        filePath,
-      });
-      expect(result.success).toBe(true);
-    });
-
-    it('supports .js files', async () => {
-      const filePath = createTestFile('test.js', 'const x = 1;');
-      const result = await tool.execute({
-        operation: 'documentSymbols',
-        filePath,
-      });
-      expect(result.success).toBe(true);
-    });
-
-    it('supports .jsx files', async () => {
-      const filePath = createTestFile('test.jsx', 'const Component = () => <div/>;');
-      const result = await tool.execute({
-        operation: 'documentSymbols',
-        filePath,
-      });
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('documentSymbols', () => {
-    it('lists symbols in a TypeScript file', async () => {
-      const content = `
-export function greet(name: string): string {
-  return \`Hello, \${name}!\`;
-}
-
-export class Calculator {
-  add(a: number, b: number): number {
-    return a + b;
-  }
-}
-
-export const PI = 3.14159;
-`;
-      const filePath = createTestFile('symbols.ts', content);
-      const result = await tool.execute({
-        operation: 'documentSymbols',
-        filePath,
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.output).toContain('greet');
-      expect(result.output).toContain('Calculator');
-      expect(result.output).toContain('PI');
-      expect(result.metadata?.found).toBe(true);
-      expect((result.metadata?.count as number) ?? 0).toBeGreaterThan(0);
-    });
-
-    it('handles empty files', async () => {
-      const filePath = createTestFile('empty.ts', '');
-      const result = await tool.execute({
-        operation: 'documentSymbols',
-        filePath,
-      });
-
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('hover', () => {
-    it('returns type information for variables', async () => {
-      const content = `
-const message: string = "hello";
-const count: number = 42;
-`;
-      const filePath = createTestFile('hover.ts', content);
-      const result = await tool.execute({
-        operation: 'hover',
-        filePath,
-        line: 2,
-        character: 7, // on 'message'
-      });
-
-      expect(result.success).toBe(true);
-      // Hover may or may not find info depending on exact position
-    });
-
-    it('returns info for function parameters', async () => {
-      const content = `
-function add(a: number, b: number): number {
-  return a + b;
-}
-`;
-      const filePath = createTestFile('hover-func.ts', content);
-      const result = await tool.execute({
-        operation: 'hover',
-        filePath,
-        line: 2,
-        character: 14, // on 'a'
-      });
-
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('goToDefinition', () => {
-    it('finds definition within same file', async () => {
-      const content = `
-function helper(): void {}
-
-function main(): void {
-  helper();
-}
-`;
-      const filePath = createTestFile('definition.ts', content);
-      const result = await tool.execute({
-        operation: 'goToDefinition',
-        filePath,
-        line: 5,
-        character: 5, // on 'helper()' call
-      });
-
-      expect(result.success).toBe(true);
-      // May find definition or not depending on TS analysis
-    });
-  });
-
-  describe('findReferences', () => {
-    it('finds references within same file', async () => {
-      const content = `
-const value = 42;
-const doubled = value * 2;
-const tripled = value * 3;
-`;
-      const filePath = createTestFile('references.ts', content);
-      const result = await tool.execute({
-        operation: 'findReferences',
-        filePath,
-        line: 2,
-        character: 7, // on 'value'
-      });
-
-      expect(result.success).toBe(true);
-      // May find references or not depending on TS analysis
-    });
-  });
-
-  describe('Operation Validation', () => {
-    it('requires line and character for goToDefinition', () => {
-      const validation = tool.safeValidateArgs({
-        operation: 'goToDefinition',
-        filePath: '/test.ts',
-      });
-      expect(validation.success).toBe(false);
-    });
-
-    it('requires line and character for findReferences', () => {
-      const validation = tool.safeValidateArgs({
-        operation: 'findReferences',
-        filePath: '/test.ts',
-      });
-      expect(validation.success).toBe(false);
-    });
-
-    it('requires line and character for hover', () => {
-      const validation = tool.safeValidateArgs({
-        operation: 'hover',
-        filePath: '/test.ts',
-      });
-      expect(validation.success).toBe(false);
-    });
-
-    it('does not require line and character for documentSymbols', () => {
-      const validation = tool.safeValidateArgs({
-        operation: 'documentSymbols',
-        filePath: '/test.ts',
-      });
-      expect(validation.success).toBe(true);
-    });
-
-    it('validates operation enum', () => {
-      const validation = tool.safeValidateArgs({
-        operation: 'invalid',
-        filePath: '/test.ts',
-      });
-      expect(validation.success).toBe(false);
-    });
-
-    it('accepts valid arguments with all fields', () => {
-      const validation = tool.safeValidateArgs({
-        operation: 'goToDefinition',
-        filePath: '/test.ts',
-        line: 10,
-        character: 5,
-      });
-      expect(validation.success).toBe(true);
-    });
-  });
-
-  describe('tsconfig.json Support', () => {
-    it('loads tsconfig.json when present', async () => {
-      // Create a tsconfig.json
-      const tsconfig = {
-        compilerOptions: {
-          target: 'ES2020',
-          module: 'commonjs',
-          strict: true,
-        },
-      };
-      fs.writeFileSync(path.join(tempDir, 'tsconfig.json'), JSON.stringify(tsconfig), 'utf-8');
-
-      const filePath = createTestFile('with-config.ts', 'const x: number = 1;');
-      const result = await tool.execute({
-        operation: 'documentSymbols',
-        filePath,
-      });
-
-      expect(result.success).toBe(true);
-    });
-  });
-});

package/vendor/agent-root/src/agent/tool/__test__/outside-workspace-confirmation.test.ts

@@ -1,214 +0,0 @@
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { promises as fs } from 'node:fs';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { DefaultToolManager } from '../tool-manager';
-import { FileReadTool } from '../file-read-tool';
-import { FileEditTool } from '../file-edit-tool';
-import { WriteFileTool } from '../write-file';
-import { GlobTool } from '../glob';
-import { GrepTool } from '../grep';
-import type { ToolExecutionContext, ToolCall } from '../types';
-
-const tempDirs: string[] = [];
-
-async function createTempDir(prefix: string): Promise<string> {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), prefix));
-  tempDirs.push(dir);
-  return dir;
-}
-
-async function createMockRipgrep(): Promise<string> {
-  const binDir = await createTempDir('renx-rg-bin-');
-  const binPath = path.join(binDir, 'mock-rg.js');
-  const script = `#!/usr/bin/env node
-const args = process.argv.slice(2);
-if (args.includes('--version')) {
-  process.stdout.write('mock-rg 1.0.0\\n');
-  process.exit(0);
-}
-const rootPath = args[args.length - 1];
-process.stdout.write(JSON.stringify({
-  type: 'match',
-  data: {
-    path: { text: rootPath + '/sandbox-note.txt' },
-    lines: { text: 'sandbox marker\\n' },
-    line_number: 1,
-    submatches: [{ start: 0 }]
-  }
-}) + '\\n');
-process.exit(0);
-`;
-  await fs.writeFile(binPath, script, 'utf8');
-  await fs.chmod(binPath, 0o755);
-  return binPath;
-}
-
-function createContext(partial?: Partial<ToolExecutionContext>): ToolExecutionContext {
-  return {
-    toolCallId: 'call_outside_confirm',
-    loopIndex: 1,
-    agent: {},
-    ...partial,
-  };
-}
-
-function createToolCall(name: string, args: Record<string, unknown>): ToolCall {
-  return {
-    id: `call_${name}`,
-    type: 'function',
-    index: 0,
-    function: {
-      name,
-      arguments: JSON.stringify(args),
-    },
-  };
-}
-
-afterEach(async () => {
-  await Promise.all(tempDirs.splice(0).map((dir) => fs.rm(dir, { recursive: true, force: true })));
-});
-
-describe('outside workspace confirmation', () => {
-  it('allows file_read outside allowed directories after user approval', async () => {
-    const workspaceDir = await createTempDir('renx-confirm-workspace-');
-    const outsideDir = await createTempDir('renx-confirm-outside-');
-    const outsidePath = path.join(outsideDir, 'note.txt');
-    await fs.writeFile(outsidePath, 'outside content', 'utf8');
-
-    const manager = new DefaultToolManager({ confirmationMode: 'manual' });
-    manager.registerTool(new FileReadTool({ allowedDirectories: [workspaceDir] }));
-
-    const onConfirm = vi.fn().mockResolvedValue({ approved: true });
-    const result = await manager.execute(
-      createToolCall('file_read', { path: outsidePath }),
-      createContext({ onConfirm })
-    );
-
-    expect(onConfirm).toHaveBeenCalledOnce();
-    expect(result.success).toBe(true);
-    expect(result.output).toBe('outside content');
-  });
-
-  it('denies outside-workspace execution when user rejects confirmation', async () => {
-    const workspaceDir = await createTempDir('renx-confirm-workspace-');
-    const outsideDir = await createTempDir('renx-confirm-outside-');
-    const outsidePath = path.join(outsideDir, 'note.txt');
-    await fs.writeFile(outsidePath, 'outside content', 'utf8');
-
-    const manager = new DefaultToolManager({ confirmationMode: 'manual' });
-    manager.registerTool(new FileReadTool({ allowedDirectories: [workspaceDir] }));
-
-    const onConfirm = vi.fn().mockResolvedValue({ approved: false, message: 'deny outside path' });
-    const result = await manager.execute(
-      createToolCall('file_read', { path: outsidePath }),
-      createContext({ onConfirm })
-    );
-
-    expect(onConfirm).toHaveBeenCalledOnce();
-    expect(result.success).toBe(false);
-    expect(result.output).toContain('Tool file_read denied');
-  });
-
-  it('allows file_edit outside allowed directories after user approval', async () => {
-    const workspaceDir = await createTempDir('renx-confirm-workspace-');
-    const outsideDir = await createTempDir('renx-confirm-outside-');
-    const outsidePath = path.join(outsideDir, 'edit.txt');
-    await fs.writeFile(outsidePath, 'const value = 1;\n', 'utf8');
-
-    const manager = new DefaultToolManager({ confirmationMode: 'manual' });
-    manager.registerTool(new FileEditTool({ allowedDirectories: [workspaceDir] }));
-
-    const onConfirm = vi.fn().mockResolvedValue({ approved: true });
-    const result = await manager.execute(
-      createToolCall('file_edit', {
-        path: outsidePath,
-        edits: [{ oldText: 'value = 1', newText: 'value = 2' }],
-      }),
-      createContext({ onConfirm })
-    );
-
-    expect(onConfirm).toHaveBeenCalledOnce();
-    expect(result.success).toBe(true);
-    expect(await fs.readFile(outsidePath, 'utf8')).toContain('value = 2');
-  });
-
-  it('allows write_file outside allowed directories after user approval', async () => {
-    const workspaceDir = await createTempDir('renx-confirm-workspace-');
-    const outsideDir = await createTempDir('renx-confirm-outside-');
-    const bufferDir = await createTempDir('renx-confirm-buffer-');
-    const outsidePath = path.join(outsideDir, 'write.txt');
-
-    const manager = new DefaultToolManager({ confirmationMode: 'manual' });
-    manager.registerTool(
-      new WriteFileTool({
-        allowedDirectories: [workspaceDir],
-        bufferBaseDir: bufferDir,
-        maxChunkBytes: 64,
-      })
-    );
-
-    const onConfirm = vi.fn().mockResolvedValue({ approved: true });
-    const result = await manager.execute(
-      createToolCall('write_file', {
-        path: outsidePath,
-        content: 'written outside workspace',
-        mode: 'direct',
-      }),
-      createContext({ onConfirm })
-    );
-
-    expect(onConfirm).toHaveBeenCalledOnce();
-    expect(result.success).toBe(true);
-    expect(await fs.readFile(outsidePath, 'utf8')).toBe('written outside workspace');
-  });
-
-  it('allows glob outside allowed directories after user approval', async () => {
-    const workspaceDir = await createTempDir('renx-confirm-workspace-');
-    const outsideDir = await createTempDir('renx-confirm-outside-');
-    await fs.writeFile(path.join(outsideDir, 'sandbox-note.txt'), 'marker', 'utf8');
-
-    const manager = new DefaultToolManager({ confirmationMode: 'manual' });
-    manager.registerTool(new GlobTool({ allowedDirectories: [workspaceDir] }));
-
-    const onConfirm = vi.fn().mockResolvedValue({ approved: true });
-    const result = await manager.execute(
-      createToolCall('glob', {
-        pattern: '**/*sandbox*',
-        path: outsideDir,
-        include_hidden: false,
-        max_results: 50,
-      }),
-      createContext({ onConfirm })
-    );
-
-    expect(onConfirm).toHaveBeenCalledOnce();
-    expect(result.success).toBe(true);
-    expect(result.output).toContain('Found 1 file(s)');
-  });
-
-  it('allows grep outside allowed directories after user approval', async () => {
-    const workspaceDir = await createTempDir('renx-confirm-workspace-');
-    const outsideDir = await createTempDir('renx-confirm-outside-');
-    await fs.writeFile(path.join(outsideDir, 'sandbox-note.txt'), 'sandbox marker\n', 'utf8');
-    const mockRgPath = await createMockRipgrep();
-
-    const manager = new DefaultToolManager({ confirmationMode: 'manual' });
-    manager.registerTool(new GrepTool({ allowedDirectories: [workspaceDir], rgPath: mockRgPath }));
-
-    const onConfirm = vi.fn().mockResolvedValue({ approved: true });
-    const result = await manager.execute(
-      createToolCall('grep', {
-        pattern: 'sandbox',
-        path: outsideDir,
-        timeout_ms: 5000,
-        max_results: 50,
-      }),
-      createContext({ onConfirm })
-    );
-
-    expect(onConfirm).toHaveBeenCalledOnce();
-    expect(result.success).toBe(true);
-    expect(result.output).toContain('Found 1 matches in 1 files');
-  });
-});