@renxqoo/renx-code 0.0.4 → 0.0.6

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

@@ -0,0 +1,192 @@
+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

@@ -0,0 +1,300 @@
+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

@@ -0,0 +1,214 @@
+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');
+  });
+});