@renxqoo/renx-code 0.0.3 → 0.0.5

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

@@ -0,0 +1,258 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { FileEditTool } from '../file-edit-tool';
+import { FileReadTool } from '../file-read-tool';
+import { FileHistoryStore } from '../../storage/file-history-store';
+import type { FileStorageConfig } from '../../storage/file-storage-config';
+
+function createHistoryStore(rootDir: string): FileHistoryStore {
+  const config: FileStorageConfig = {
+    rootDir,
+    writeBufferDir: path.join(rootDir, 'cache', 'write-buffer'),
+    historyDir: path.join(rootDir, 'history'),
+    historyEnabled: true,
+    historyMaxPerFile: 20,
+    historyMaxAgeDays: 14,
+    historyMaxTotalBytes: 1024 * 1024,
+  };
+
+  return new FileHistoryStore({ config });
+}
+
+describe('FileEditTool', () => {
+  let rootDir: string;
+  let outsideDir: string;
+  let editTool: FileEditTool;
+  let readTool: FileReadTool;
+
+  beforeEach(async () => {
+    rootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-file-edit-tool-'));
+    outsideDir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-file-edit-outside-'));
+
+    editTool = new FileEditTool({ allowedDirectories: [rootDir] });
+    readTool = new FileReadTool({ allowedDirectories: [rootDir] });
+  });
+
+  afterEach(async () => {
+    await fs.rm(rootDir, { recursive: true, force: true });
+    await fs.rm(outsideDir, { recursive: true, force: true });
+  });
+
+  it('previews and applies edits', async () => {
+    const targetPath = path.join(rootDir, 'edit.txt');
+    await fs.writeFile(targetPath, 'const value = 1;\nconsole.log(value);\n', 'utf8');
+
+    const preview = await editTool.execute({
+      path: targetPath,
+      edits: [{ oldText: 'value = 1', newText: 'value = 2' }],
+      dry_run: true,
+    });
+
+    expect(preview.success).toBe(true);
+    expect(preview.output).toContain('value = 2');
+    expect((preview.metadata as { changed: boolean }).changed).toBe(true);
+
+    const apply = await editTool.execute({
+      path: targetPath,
+      edits: [{ oldText: 'value = 1', newText: 'value = 2' }],
+    });
+
+    expect(apply.success).toBe(true);
+    expect((apply.metadata as { changed: boolean }).changed).toBe(true);
+
+    const readBack = await readTool.execute({ path: targetPath });
+    expect(readBack.success).toBe(true);
+    expect(readBack.output).toContain('value = 2');
+  });
+
+  it('stores the previous file version before applying edits', async () => {
+    const historyStore = createHistoryStore(rootDir);
+    editTool = new FileEditTool({
+      allowedDirectories: [rootDir],
+      historyStore,
+    });
+
+    const targetPath = path.join(rootDir, 'history-edit.txt');
+    await fs.writeFile(targetPath, 'const value = 1;\n', 'utf8');
+
+    const result = await editTool.execute({
+      path: targetPath,
+      edits: [{ oldText: 'value = 1', newText: 'value = 2' }],
+    });
+
+    expect(result.success).toBe(true);
+    const versions = await historyStore.listVersions(targetPath);
+    expect(versions).toHaveLength(1);
+
+    const restored = await historyStore.restoreVersion(targetPath, versions[0].versionId);
+    expect(restored).toBe(true);
+    expect(await fs.readFile(targetPath, 'utf8')).toBe('const value = 1;\n');
+  });
+
+  it('returns no-change metadata when replacement is identical', async () => {
+    const targetPath = path.join(rootDir, 'same.txt');
+    await fs.writeFile(targetPath, 'const answer = 42;\n', 'utf8');
+
+    const result = await editTool.execute({
+      path: targetPath,
+      edits: [{ oldText: 'const answer = 42;', newText: 'const answer = 42;' }],
+    });
+
+    expect(result.success).toBe(true);
+    expect((result.metadata as { changed: boolean }).changed).toBe(false);
+    expect(result.output).toContain('Index:');
+  });
+
+  it('returns EDIT_CONFLICT when oldText does not match', async () => {
+    const targetPath = path.join(rootDir, 'conflict.txt');
+    await fs.writeFile(targetPath, 'const answer = 42;\n', 'utf8');
+
+    const result = await editTool.execute({
+      path: targetPath,
+      edits: [{ oldText: 'const answer = 100;', newText: 'const answer = 7;' }],
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain('EDIT_CONFLICT');
+
+    const metadata = result.metadata as {
+      error: string;
+      code: string;
+      recoverable: boolean;
+      next_actions: string[];
+    };
+
+    expect(metadata.error).toBe('EDIT_CONFLICT');
+    expect(metadata.code).toBe('EDIT_CONFLICT');
+    expect(metadata.recoverable).toBe(true);
+    expect(metadata.next_actions).toEqual(['file_read', 'file_edit']);
+  });
+
+  it('rejects path outside allowed directories', async () => {
+    const outsidePath = path.join(outsideDir, 'outside.txt');
+    await fs.writeFile(outsidePath, 'x', 'utf8');
+
+    const result = await editTool.execute({
+      path: outsidePath,
+      edits: [{ oldText: 'x', newText: 'y' }],
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain('FILE_EDIT_FAILED');
+    expect(result.output).toContain('PATH_NOT_ALLOWED');
+  });
+
+  it('always requires confirmation', () => {
+    expect(editTool.shouldConfirm()).toBe(true);
+  });
+
+  it('returns failure when target path is not a file', async () => {
+    const result = await editTool.execute({
+      path: rootDir,
+      edits: [{ oldText: 'a', newText: 'b' }],
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain('FILE_EDIT_FAILED');
+    expect(result.output).toContain('FILE_EDIT_NOT_FILE');
+  });
+
+  it('supports whitespace-tolerant edit matching', async () => {
+    const targetPath = path.join(rootDir, 'whitespace.txt');
+    await fs.writeFile(targetPath, '  const answer = 42;\n', 'utf8');
+
+    const result = await editTool.execute({
+      path: targetPath,
+      edits: [{ oldText: 'const answer = 42;', newText: 'const answer = 7;' }],
+    });
+
+    expect(result.success).toBe(true);
+
+    const readBack = await readTool.execute({ path: targetPath });
+    expect(readBack.success).toBe(true);
+    expect(readBack.output).toContain('const answer = 7;');
+  });
+
+  it('rebuilds relative indentation for multi-line tolerant matches', async () => {
+    const targetPath = path.join(rootDir, 'indent-relative.ts');
+    await fs.writeFile(
+      targetPath,
+      ['  if (flag) {', '    console.log("old");', '  }', ''].join('\n'),
+      'utf8'
+    );
+
+    const result = await editTool.execute({
+      path: targetPath,
+      edits: [
+        {
+          oldText: ['if (flag) {', '  console.log("old");', '}'].join('\n'),
+          newText: ['if (flag) {', '    console.log("new");', '}'].join('\n'),
+        },
+      ],
+    });
+
+    expect(result.success).toBe(true);
+    const readBack = await readTool.execute({ path: targetPath });
+    expect(readBack.success).toBe(true);
+    expect(readBack.output).toContain('  if (flag) {');
+    expect(readBack.output).toContain('    console.log("new");');
+  });
+
+  it('keeps replacement line as-is when indent mapping cannot be derived', async () => {
+    const targetPath = path.join(rootDir, 'indent-fallback.ts');
+    await fs.writeFile(targetPath, ['  if (ready) {', '    work();', '  }', ''].join('\n'), 'utf8');
+
+    const result = await editTool.execute({
+      path: targetPath,
+      edits: [
+        {
+          oldText: ['if (ready) {', '  work();', '}'].join('\n'),
+          newText: ['if (ready) {', 'workNow();', '}'].join('\n'),
+        },
+      ],
+    });
+
+    expect(result.success).toBe(true);
+    const readBack = await readTool.execute({ path: targetPath });
+    expect(readBack.success).toBe(true);
+    expect(readBack.output).toContain('workNow();');
+  });
+
+  it('maps pre-prefixed conflict messages to EDIT_CONFLICT envelope', () => {
+    const helper = editTool as unknown as {
+      mapFailure: (
+        requestPath: string,
+        error: unknown
+      ) => {
+        success: boolean;
+        output?: string;
+        metadata?: Record<string, unknown>;
+      };
+    };
+
+    const result = helper.mapFailure('demo.ts', new Error('EDIT_CONFLICT: anchored'));
+    expect(result.success).toBe(false);
+    expect(result.output).toContain('EDIT_CONFLICT');
+    expect(result.metadata?.error).toBe('EDIT_CONFLICT');
+  });
+
+  it('maps non-error failures to FILE_EDIT_FAILED envelope', () => {
+    const helper = editTool as unknown as {
+      mapFailure: (
+        requestPath: string,
+        error: unknown
+      ) => {
+        success: boolean;
+        output?: string;
+        metadata?: Record<string, unknown>;
+      };
+    };
+
+    const result = helper.mapFailure('demo.ts', 1234);
+    expect(result.success).toBe(false);
+    expect(result.output).toBe('FILE_EDIT_FAILED: 1234');
+    expect(result.metadata?.error).toBe('FILE_EDIT_FAILED');
+  });
+});

package/vendor/agent-root/src/agent/tool/__test__/file-history-tools.test.ts

@@ -0,0 +1,121 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { promises as fs } from 'node:fs';
+import * as syncFs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { FileHistoryStore } from '../../storage/file-history-store';
+import type { FileStorageConfig } from '../../storage/file-storage-config';
+import { FileHistoryListTool } from '../file-history-list';
+import { FileHistoryRestoreTool } from '../file-history-restore';
+
+function createHistoryStore(rootDir: string): FileHistoryStore {
+  const config: FileStorageConfig = {
+    rootDir,
+    writeBufferDir: path.join(rootDir, 'cache', 'write-buffer'),
+    historyDir: path.join(rootDir, 'history'),
+    historyEnabled: true,
+    historyMaxPerFile: 20,
+    historyMaxAgeDays: 14,
+    historyMaxTotalBytes: 1024 * 1024,
+  };
+
+  return new FileHistoryStore({ config });
+}
+
+function parseOutput<T>(output: string | undefined): T {
+  return JSON.parse(output || '{}') as T;
+}
+
+describe('file history tools', () => {
+  let rootDir: string;
+  let listTool: FileHistoryListTool;
+  let restoreTool: FileHistoryRestoreTool;
+  let historyStore: FileHistoryStore;
+
+  beforeEach(async () => {
+    rootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-file-history-tool-'));
+    historyStore = createHistoryStore(rootDir);
+    listTool = new FileHistoryListTool({
+      allowedDirectories: [rootDir],
+      historyStore,
+    });
+    restoreTool = new FileHistoryRestoreTool({
+      allowedDirectories: [rootDir],
+      historyStore,
+    });
+  });
+
+  afterEach(async () => {
+    await fs.rm(rootDir, { recursive: true, force: true });
+  });
+
+  it('lists saved versions for a file', async () => {
+    const targetPath = path.join(rootDir, 'demo.ts');
+    await fs.writeFile(targetPath, 'const value = 1;\n', 'utf8');
+    await historyStore.snapshotBeforeWrite({
+      targetPath,
+      nextContent: 'const value = 2;\n',
+      source: 'write_file',
+    });
+
+    const result = await listTool.execute({ path: targetPath });
+    const payload = parseOutput<{ path: string; versions: Array<{ versionId: string }> }>(
+      result.output
+    );
+
+    expect(result.success).toBe(true);
+    expect(payload.path).toBe(syncFs.realpathSync(targetPath));
+    expect(payload.versions).toHaveLength(1);
+    expect(payload.versions[0].versionId).toBeTruthy();
+  });
+
+  it('restores the latest saved version when versionId is omitted', async () => {
+    const targetPath = path.join(rootDir, 'restore.ts');
+    await fs.writeFile(targetPath, 'const value = 1;\n', 'utf8');
+    await historyStore.snapshotBeforeWrite({
+      targetPath,
+      nextContent: 'const value = 2;\n',
+      source: 'write_file',
+    });
+    await fs.writeFile(targetPath, 'const value = 2;\n', 'utf8');
+
+    const result = await restoreTool.execute(
+      { path: targetPath },
+      {
+        toolCallId: 'restore-history',
+        loopIndex: 1,
+        agent: {},
+        confirmationApproved: true,
+      }
+    );
+    const payload = parseOutput<{ restored: boolean; version: { versionId: string } }>(
+      result.output
+    );
+
+    expect(result.success).toBe(true);
+    expect(payload.restored).toBe(true);
+    expect(payload.version.versionId).toBeTruthy();
+    expect(await fs.readFile(targetPath, 'utf8')).toBe('const value = 1;\n');
+
+    const versions = await historyStore.listVersions(targetPath);
+    expect(versions).toHaveLength(2);
+  });
+
+  it('returns a typed error when no history exists for restore', async () => {
+    const targetPath = path.join(rootDir, 'missing.ts');
+    await fs.writeFile(targetPath, 'const value = 1;\n', 'utf8');
+
+    const result = await restoreTool.execute(
+      { path: targetPath },
+      {
+        toolCallId: 'restore-history-empty',
+        loopIndex: 1,
+        agent: {},
+        confirmationApproved: true,
+      }
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain('FILE_HISTORY_EMPTY');
+  });
+});

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

@@ -0,0 +1,210 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { FileReadTool } from '../file-read-tool';
+
+describe('FileReadTool', () => {
+  let rootDir: string;
+  let outsideDir: string;
+  let tool: FileReadTool;
+
+  beforeEach(async () => {
+    rootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-file-read-tool-'));
+    outsideDir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-file-read-outside-'));
+    tool = new FileReadTool({
+      allowedDirectories: [rootDir],
+      maxOutputLength: 300,
+    });
+  });
+
+  afterEach(async () => {
+    await fs.rm(rootDir, { recursive: true, force: true });
+    await fs.rm(outsideDir, { recursive: true, force: true });
+  });
+
+  it('reads full content and returns metadata', async () => {
+    const targetPath = path.join(rootDir, 'note.txt');
+    await fs.writeFile(targetPath, 'hello\nworld\n', 'utf8');
+
+    const result = await tool.execute({ path: targetPath });
+
+    expect(result.success).toBe(true);
+    expect(result.output).toBe('hello\nworld');
+
+    const metadata = result.metadata as {
+      path: string;
+      etag: string;
+      truncated: boolean;
+    };
+
+    expect(metadata.path).toBe(await fs.realpath(targetPath));
+    expect(metadata.etag).toBeDefined();
+    expect(metadata.truncated).toBe(false);
+  });
+
+  it('reads content by line range', async () => {
+    const targetPath = path.join(rootDir, 'range.txt');
+    await fs.writeFile(targetPath, 'line-1\nline-2\nline-3\nline-4\n', 'utf8');
+
+    const result = await tool.execute({
+      path: targetPath,
+      startLine: 2,
+      limit: 3,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.output).toBe('line-3\nline-4');
+  });
+
+  it('supports open-ended line slicing', async () => {
+    const targetPath = path.join(rootDir, 'open-ended.txt');
+    await fs.writeFile(targetPath, 'line-1\nline-2\nline-3\nline-4\n', 'utf8');
+
+    const toEnd = await tool.execute({
+      path: targetPath,
+      startLine: 2,
+    });
+    expect(toEnd.success).toBe(true);
+    expect(toEnd.output).toBe('line-3\nline-4');
+
+    const fromStart = await tool.execute({
+      path: targetPath,
+      limit: 2,
+    });
+    expect(fromStart.success).toBe(true);
+    expect(fromStart.output).toBe('line-1\nline-2');
+  });
+
+  it('rejects invalid limit', async () => {
+    const targetPath = path.join(rootDir, 'x.txt');
+    await fs.writeFile(targetPath, 'content', 'utf8');
+
+    const result = await tool.execute({
+      path: targetPath,
+      limit: 0,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain('FILE_READ_INVALID_LIMIT');
+  });
+
+  it('truncates oversized content', async () => {
+    const targetPath = path.join(rootDir, 'large.txt');
+    await fs.writeFile(targetPath, 'x'.repeat(5000), 'utf8');
+
+    const result = await tool.execute({ path: targetPath });
+
+    expect(result.success).toBe(true);
+    expect((result.output || '').length).toBeLessThanOrEqual(300);
+    expect(result.output || '').toContain('[... Output Truncated ...]');
+
+    const metadata = result.metadata as {
+      truncated: boolean;
+      originalLength?: number;
+    };
+    expect(metadata.truncated).toBe(true);
+    expect(metadata.originalLength).toBe(5000);
+  });
+
+  it('keeps a contiguous prefix when truncating content', async () => {
+    const targetPath = path.join(rootDir, 'prefix-only.txt');
+    const content =
+      Array.from({ length: 180 }, (_, index) => `line-${index + 1}`).join('\n') +
+      '\nTAIL_SENTINEL_END';
+    await fs.writeFile(targetPath, content, 'utf8');
+
+    const result = await tool.execute({ path: targetPath });
+    expect(result.success).toBe(true);
+    expect(result.output || '').toContain('[... Output Truncated ...]');
+    expect(result.output || '').toContain('line-1');
+    expect(result.output || '').not.toContain('TAIL_SENTINEL_END');
+  });
+
+  it('rejects path outside allowed directories', async () => {
+    const outsidePath = path.join(outsideDir, 'outside.txt');
+    await fs.writeFile(outsidePath, 'blocked', 'utf8');
+
+    const result = await tool.execute({ path: outsidePath });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain('PATH_NOT_ALLOWED');
+  });
+
+  it('exposes parallel-safe concurrency policy and lock key', () => {
+    expect(tool.getConcurrencyMode()).toBe('parallel-safe');
+    expect(
+      tool.getConcurrencyLockKey({
+        path: 'a.txt',
+      })
+    ).toBe('file_read:a.txt');
+  });
+
+  it('returns not-found error code for missing files', async () => {
+    const result = await tool.execute({
+      path: path.join(rootDir, 'missing.txt'),
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain('FILE_READ_NOT_FOUND');
+  });
+
+  it('returns failure for directory path', async () => {
+    const result = await tool.execute({
+      path: rootDir,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain('FILE_READ_FAILED');
+    expect(result.output).toContain('FILE_READ_NOT_FILE');
+  });
+
+  it('returns empty output when requested range is outside file bounds', async () => {
+    const targetPath = path.join(rootDir, 'bounds.txt');
+    await fs.writeFile(targetPath, 'one\ntwo\n', 'utf8');
+
+    const result = await tool.execute({
+      path: targetPath,
+      startLine: 99,
+      limit: 10,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.output).toBe('');
+  });
+
+  it('uses hard truncation branch when output budget is very small', async () => {
+    const tinyTool = new FileReadTool({
+      allowedDirectories: [rootDir],
+      maxOutputLength: 16,
+    });
+    const targetPath = path.join(rootDir, 'tiny-budget.txt');
+    await fs.writeFile(targetPath, 'a'.repeat(120), 'utf8');
+
+    const result = await tinyTool.execute({ path: targetPath });
+    expect(result.success).toBe(true);
+    expect((result.output || '').length).toBeLessThanOrEqual(16);
+    expect(result.output || '').not.toContain('[... Output Truncated ...]');
+  });
+
+  it('maps permission and generic errors in toFailureMessage helper', () => {
+    const helper = tool as unknown as {
+      toFailureMessage: (requestedPath: string, error: unknown) => string;
+    };
+    const permissionMessage = helper.toFailureMessage('a.txt', {
+      code: 'EACCES',
+    });
+    const genericMessage = helper.toFailureMessage('a.txt', new Error('boom'));
+
+    expect(permissionMessage).toBe('FILE_READ_NO_PERMISSION: a.txt');
+    expect(genericMessage).toBe('FILE_READ_FAILED: boom');
+  });
+
+  it('maps non-error values in toFailureMessage helper', () => {
+    const helper = tool as unknown as {
+      toFailureMessage: (requestedPath: string, error: unknown) => string;
+    };
+    const genericMessage = helper.toFailureMessage('a.txt', 12345);
+    expect(genericMessage).toBe('FILE_READ_FAILED: 12345');
+  });
+});