@renxqoo/renx-code 0.0.8 → 0.0.10

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

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

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

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