@renxqoo/renx-code 0.0.4 → 0.0.5

package/vendor/agent-root/src/agent/tool/error.ts

@@ -0,0 +1,131 @@
+import { ContractError } from '../error-contract';
+
+export class ToolExecutionError extends ContractError {
+  constructor(message: string, code = 2000) {
+    super(message, {
+      module: 'tool',
+      name: 'ToolExecutionError',
+      code,
+      errorCode: 'TOOL_EXECUTION_ERROR',
+      category: 'internal',
+      retryable: true,
+      httpStatus: 500,
+    });
+  }
+}
+
+export class EmptyToolNameError extends ToolExecutionError {
+  constructor() {
+    super('Tool name is empty', 2001);
+    this.name = 'EmptyToolNameError';
+    this.errorCode = 'TOOL_NAME_EMPTY';
+    this.category = 'validation';
+    this.retryable = false;
+    this.httpStatus = 400;
+  }
+}
+
+export class InvalidArgumentsError extends ToolExecutionError {
+  public toolName: string;
+
+  constructor(toolName: string, message: string) {
+    super(`Invalid arguments format for tool ${toolName}: ${message}`, 2002);
+    this.name = 'InvalidArgumentsError';
+    this.errorCode = 'TOOL_INVALID_ARGUMENTS';
+    this.category = 'validation';
+    this.retryable = false;
+    this.httpStatus = 400;
+    this.toolName = toolName;
+    this.details = {
+      toolName,
+    };
+  }
+}
+
+export class ToolNotFoundError extends ToolExecutionError {
+  public toolName: string;
+
+  constructor(toolName: string) {
+    super(`Tool ${toolName} not found`, 2003);
+    this.name = 'ToolNotFoundError';
+    this.errorCode = 'TOOL_NOT_FOUND';
+    this.category = 'not_found';
+    this.retryable = false;
+    this.httpStatus = 404;
+    this.toolName = toolName;
+    this.details = {
+      toolName,
+    };
+  }
+}
+
+export class ToolValidationError extends ToolExecutionError {
+  public toolName: string;
+  public issues: { message: string }[];
+
+  constructor(toolName: string, issues: { message: string }[]) {
+    super(issues.map((issue) => issue.message).join(', '), 2004);
+    this.name = 'ToolValidationError';
+    this.errorCode = 'TOOL_VALIDATION_FAILED';
+    this.category = 'validation';
+    this.retryable = false;
+    this.httpStatus = 400;
+    this.toolName = toolName;
+    this.issues = issues;
+    this.details = {
+      toolName,
+      issues,
+    };
+  }
+}
+
+export class ToolDeniedError extends ToolExecutionError {
+  public toolName: string;
+  public reason?: string;
+
+  constructor(toolName: string, reason?: string) {
+    super(`Tool ${toolName} denied: ${reason || 'User rejected'}`, 2005);
+    this.name = 'ToolDeniedError';
+    this.errorCode = 'TOOL_DENIED';
+    this.category = 'permission';
+    this.retryable = false;
+    this.httpStatus = 403;
+    this.toolName = toolName;
+    this.reason = reason;
+    this.details = {
+      toolName,
+      reason,
+    };
+  }
+}
+
+export class ToolPolicyDeniedError extends ToolExecutionError {
+  public toolName: string;
+  public reasonCode: string;
+  public reason?: string;
+  public audit?: Record<string, unknown>;
+
+  constructor(
+    toolName: string,
+    reasonCode = 'POLICY_DENIED',
+    reason?: string,
+    audit?: Record<string, unknown>
+  ) {
+    super(`Tool ${toolName} blocked by policy [${reasonCode}]: ${reason || 'Policy denied'}`, 2006);
+    this.name = 'ToolPolicyDeniedError';
+    this.errorCode = 'TOOL_POLICY_DENIED';
+    this.category = 'permission';
+    this.retryable = false;
+    this.httpStatus = 403;
+    this.toolName = toolName;
+    this.reasonCode = reasonCode;
+    this.reason = reason;
+    this.audit = audit;
+    this.details = {
+      toolName,
+      reasonCode,
+      reason,
+      audit,
+    };
+  }
+}

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

@@ -0,0 +1,264 @@
+import * as fs from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { createTwoFilesPatch } from 'diff';
+import { z } from 'zod';
+import { BaseTool, ToolConfirmDetails, ToolResult } from './base-tool';
+import { ToolExecutionError } from './error';
+import {
+  assessPathAccess,
+  ensurePathWithinAllowed,
+  normalizeAllowedDirectories,
+  resolveRequestedPath,
+} from './path-security';
+import { FILE_EDIT_TOOL_DESCRIPTION } from './tool-prompts';
+import type { ToolExecutionContext } from './types';
+import { createConfiguredFileHistoryStore, FileHistoryStore } from '../storage/file-history-store';
+import { writeTextFileWithHistory } from '../storage/file-write-service';
+
+const fileEditSchema = z.object({
+  oldText: z.string().describe('The exact text segment to replace'),
+  newText: z.string().describe('The replacement text'),
+});
+
+const schema = z
+  .object({
+    path: z.string().min(1).describe('Path to the file to modify'),
+    edits: z.array(fileEditSchema).min(1).describe('Array of replacements to apply in order'),
+    dry_run: z.boolean().optional().describe('If true, only preview edit diff'),
+  })
+  .strict();
+
+interface FileEdit {
+  oldText: string;
+  newText: string;
+}
+
+export interface FileEditToolOptions {
+  allowedDirectories?: string[];
+  historyStore?: FileHistoryStore;
+}
+
+interface FileEditPayload {
+  path: string;
+  diff: string;
+  changed: boolean;
+  etag: string;
+}
+
+function normalizeLineEndings(input: string): string {
+  return input.replace(/\r\n/g, '\n');
+}
+
+function createUnifiedDiff(originalContent: string, newContent: string, filePath: string): string {
+  const normalizedOriginal = normalizeLineEndings(originalContent);
+  const normalizedNew = normalizeLineEndings(newContent);
+
+  return createTwoFilesPatch(
+    filePath,
+    filePath,
+    normalizedOriginal,
+    normalizedNew,
+    'original',
+    'modified'
+  );
+}
+
+function applyEditsToContent(content: string, edits: FileEdit[]): string {
+  let modifiedContent = normalizeLineEndings(content);
+
+  for (const edit of edits) {
+    const normalizedOld = normalizeLineEndings(edit.oldText);
+    const normalizedNew = normalizeLineEndings(edit.newText);
+
+    if (modifiedContent.includes(normalizedOld)) {
+      modifiedContent = modifiedContent.replace(normalizedOld, normalizedNew);
+      continue;
+    }
+
+    const oldLines = normalizedOld.split('\n');
+    const contentLines = modifiedContent.split('\n');
+    let matched = false;
+
+    for (let index = 0; index <= contentLines.length - oldLines.length; index += 1) {
+      const window = contentLines.slice(index, index + oldLines.length);
+      const isMatch = oldLines.every(
+        (oldLine, lineIndex) => oldLine.trim() === window[lineIndex].trim()
+      );
+      if (!isMatch) {
+        continue;
+      }
+
+      const originalIndent = /^\s*/.exec(contentLines[index])![0];
+      const replacementLines = normalizedNew.split('\n').map((line, lineIndex) => {
+        if (lineIndex === 0) {
+          return originalIndent + line.trimStart();
+        }
+
+        const oldIndent = oldLines[lineIndex]?.match(/^\s*/)?.[0] || '';
+        const newIndent = line.match(/^\s*/)?.[0] || '';
+        if (oldIndent && newIndent) {
+          const relativeIndent = newIndent.length - oldIndent.length;
+          return originalIndent + ' '.repeat(Math.max(0, relativeIndent)) + line.trimStart();
+        }
+        return line;
+      });
+
+      contentLines.splice(index, oldLines.length, ...replacementLines);
+      modifiedContent = contentLines.join('\n');
+      matched = true;
+      break;
+    }
+
+    if (!matched) {
+      throw new Error(`Could not find exact match for edit:\n${edit.oldText}`);
+    }
+  }
+
+  return modifiedContent;
+}
+
+export class FileEditTool extends BaseTool<typeof schema> {
+  name = 'file_edit';
+  description = FILE_EDIT_TOOL_DESCRIPTION;
+  parameters = schema;
+
+  private readonly allowedDirectories: string[];
+  private readonly historyStore: FileHistoryStore;
+
+  constructor(options: FileEditToolOptions = {}) {
+    super();
+    this.allowedDirectories = normalizeAllowedDirectories(options.allowedDirectories);
+    this.historyStore = options.historyStore ?? createConfiguredFileHistoryStore();
+  }
+
+  override shouldConfirm(): boolean {
+    return true;
+  }
+
+  override getConfirmDetails(args: z.infer<typeof schema>): ToolConfirmDetails | null {
+    const absolute = resolveRequestedPath(args.path);
+    const assessment = assessPathAccess(absolute, this.allowedDirectories, 'PATH_NOT_ALLOWED');
+    if (assessment.allowed) {
+      return null;
+    }
+    return {
+      reason: assessment.message,
+      metadata: {
+        requestedPath: absolute,
+        allowedDirectories: this.allowedDirectories,
+        errorCode: 'PATH_NOT_ALLOWED',
+      },
+    };
+  }
+
+  async execute(args: z.infer<typeof schema>, context?: ToolExecutionContext): Promise<ToolResult> {
+    try {
+      const absolute = resolveRequestedPath(args.path);
+      const validatedPath = ensurePathWithinAllowed(
+        absolute,
+        this.allowedDirectories,
+        'PATH_NOT_ALLOWED',
+        context?.confirmationApproved === true
+      );
+
+      const stats = await fs.stat(validatedPath);
+      if (!stats.isFile()) {
+        throw new Error(`FILE_EDIT_NOT_FILE: ${validatedPath}`);
+      }
+
+      const originalContent = await fs.readFile(validatedPath, 'utf8');
+      const edits: FileEdit[] = args.edits.map((edit) => ({
+        oldText: edit.oldText,
+        newText: edit.newText,
+      }));
+
+      const updatedContent = applyEditsToContent(originalContent, edits);
+      const changed = updatedContent !== originalContent;
+      const diff = createUnifiedDiff(originalContent, updatedContent, validatedPath);
+
+      if (!changed || args.dry_run) {
+        const previewPayload: FileEditPayload = {
+          path: validatedPath,
+          diff,
+          changed,
+          etag: this.createEtag(originalContent),
+        };
+        return {
+          success: true,
+          output: diff,
+          metadata: previewPayload as unknown as Record<string, unknown>,
+        };
+      }
+
+      await this.writeAtomically(validatedPath, updatedContent);
+      const latestContent = await fs.readFile(validatedPath, 'utf8');
+
+      const payload: FileEditPayload = {
+        path: validatedPath,
+        diff,
+        changed: true,
+        etag: this.createEtag(latestContent),
+      };
+
+      return {
+        success: true,
+        output: diff,
+        metadata: payload as unknown as Record<string, unknown>,
+      };
+    } catch (error) {
+      return this.mapFailure(args.path, error);
+    }
+  }
+
+  private async writeAtomically(targetPath: string, content: string): Promise<void> {
+    await writeTextFileWithHistory(targetPath, content, {
+      source: 'file_edit',
+      historyStore: this.historyStore,
+    });
+  }
+
+  private createEtag(content: string): string {
+    return createHash('sha256').update(content).digest('hex');
+  }
+
+  private mapFailure(requestPath: string, error: unknown): ToolResult {
+    const message = error instanceof Error ? error.message : String(error);
+
+    if (
+      message.includes('Could not find exact match for edit') ||
+      message.startsWith('EDIT_CONFLICT:')
+    ) {
+      const output = `EDIT_CONFLICT: ${message}`;
+      return {
+        success: false,
+        output,
+        error: new ToolExecutionError(output),
+        metadata: {
+          error: 'EDIT_CONFLICT',
+          code: 'EDIT_CONFLICT',
+          conflict: true,
+          recoverable: true,
+          message,
+          agent_hint:
+            'Edit oldText was not found in latest file content. Read latest content, update oldText anchor, then retry edit.',
+          next_actions: ['file_read', 'file_edit'],
+          path: requestPath,
+        },
+      };
+    }
+
+    const output = `FILE_EDIT_FAILED: ${message}`;
+    return {
+      success: false,
+      output,
+      error: new ToolExecutionError(output),
+      metadata: {
+        error: 'FILE_EDIT_FAILED',
+        message,
+        path: requestPath,
+      },
+    };
+  }
+}
+
+export default FileEditTool;

package/vendor/agent-root/src/agent/tool/file-history-list.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { BaseTool, ToolConfirmDetails, ToolResult } from './base-tool';
+import { ToolExecutionError } from './error';
+import {
+  assessPathAccess,
+  ensurePathWithinAllowed,
+  normalizeAllowedDirectories,
+  resolveRequestedPath,
+} from './path-security';
+import type { ToolExecutionContext } from './types';
+import {
+  createConfiguredFileHistoryStore,
+  FileHistoryStore,
+  type FileHistoryVersion,
+} from '../storage/file-history-store';
+import { FILE_HISTORY_LIST_TOOL_DESCRIPTION } from './tool-prompts';
+
+const schema = z
+  .object({
+    path: z.string().min(1).describe('Path to the file whose saved history should be listed'),
+  })
+  .strict();
+
+export interface FileHistoryListToolOptions {
+  allowedDirectories?: string[];
+  historyStore?: FileHistoryStore;
+}
+
+interface FileHistoryListPayload {
+  path: string;
+  versions: FileHistoryVersion[];
+}
+
+export class FileHistoryListTool extends BaseTool<typeof schema> {
+  name = 'file_history_list';
+  description = FILE_HISTORY_LIST_TOOL_DESCRIPTION;
+  parameters = schema;
+
+  private readonly allowedDirectories: string[];
+  private readonly historyStore: FileHistoryStore;
+
+  constructor(options: FileHistoryListToolOptions = {}) {
+    super();
+    this.allowedDirectories = normalizeAllowedDirectories(options.allowedDirectories);
+    this.historyStore = options.historyStore ?? createConfiguredFileHistoryStore();
+  }
+
+  override getConcurrencyMode(): 'parallel-safe' {
+    return 'parallel-safe';
+  }
+
+  override getConcurrencyLockKey(args: z.infer<typeof schema>): string {
+    return `file_history_list:${args.path}`;
+  }
+
+  override getConfirmDetails(args: z.infer<typeof schema>): ToolConfirmDetails | null {
+    const absolute = resolveRequestedPath(args.path);
+    const assessment = assessPathAccess(absolute, this.allowedDirectories, 'PATH_NOT_ALLOWED');
+    if (assessment.allowed) {
+      return null;
+    }
+    return {
+      reason: assessment.message,
+      metadata: {
+        requestedPath: absolute,
+        allowedDirectories: this.allowedDirectories,
+        errorCode: 'PATH_NOT_ALLOWED',
+      },
+    };
+  }
+
+  async execute(args: z.infer<typeof schema>, context?: ToolExecutionContext): Promise<ToolResult> {
+    try {
+      const absolute = resolveRequestedPath(args.path);
+      const validatedPath = ensurePathWithinAllowed(
+        absolute,
+        this.allowedDirectories,
+        'PATH_NOT_ALLOWED',
+        context?.confirmationApproved === true
+      );
+
+      const payload: FileHistoryListPayload = {
+        path: validatedPath,
+        versions: await this.historyStore.listVersions(validatedPath),
+      };
+
+      return {
+        success: true,
+        output: JSON.stringify(payload),
+        metadata: payload as unknown as Record<string, unknown>,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        output: message,
+        error: new ToolExecutionError(message),
+      };
+    }
+  }
+}
+
+export default FileHistoryListTool;

package/vendor/agent-root/src/agent/tool/file-history-restore.ts

@@ -0,0 +1,149 @@
+import { z } from 'zod';
+import { BaseTool, ToolConfirmDetails, ToolResult } from './base-tool';
+import { ToolExecutionError } from './error';
+import {
+  assessPathAccess,
+  ensurePathWithinAllowed,
+  normalizeAllowedDirectories,
+  resolveRequestedPath,
+} from './path-security';
+import type { ToolExecutionContext } from './types';
+import {
+  createConfiguredFileHistoryStore,
+  FileHistoryStore,
+  type FileHistoryVersion,
+} from '../storage/file-history-store';
+import { FILE_HISTORY_RESTORE_TOOL_DESCRIPTION } from './tool-prompts';
+
+const schema = z
+  .object({
+    path: z.string().min(1).describe('Path to the file that should be restored'),
+    versionId: z
+      .string()
+      .min(1)
+      .optional()
+      .describe('Specific saved version id to restore; defaults to the latest saved version'),
+  })
+  .strict();
+
+export interface FileHistoryRestoreToolOptions {
+  allowedDirectories?: string[];
+  historyStore?: FileHistoryStore;
+}
+
+interface FileHistoryRestorePayload {
+  path: string;
+  restored: boolean;
+  version?: FileHistoryVersion;
+}
+
+export class FileHistoryRestoreTool extends BaseTool<typeof schema> {
+  name = 'file_history_restore';
+  description = FILE_HISTORY_RESTORE_TOOL_DESCRIPTION;
+  parameters = schema;
+
+  private readonly allowedDirectories: string[];
+  private readonly historyStore: FileHistoryStore;
+
+  constructor(options: FileHistoryRestoreToolOptions = {}) {
+    super();
+    this.allowedDirectories = normalizeAllowedDirectories(options.allowedDirectories);
+    this.historyStore = options.historyStore ?? createConfiguredFileHistoryStore();
+  }
+
+  override shouldConfirm(): boolean {
+    return true;
+  }
+
+  override getConfirmDetails(args: z.infer<typeof schema>): ToolConfirmDetails | null {
+    const absolute = resolveRequestedPath(args.path);
+    const assessment = assessPathAccess(absolute, this.allowedDirectories, 'PATH_NOT_ALLOWED');
+    if (assessment.allowed) {
+      return {
+        reason: `Restore historical content for ${assessment.normalizedCandidate}`,
+        metadata: {
+          requestedPath: assessment.normalizedCandidate,
+        },
+      };
+    }
+    return {
+      reason: assessment.message,
+      metadata: {
+        requestedPath: absolute,
+        allowedDirectories: this.allowedDirectories,
+        errorCode: 'PATH_NOT_ALLOWED',
+      },
+    };
+  }
+
+  async execute(args: z.infer<typeof schema>, context?: ToolExecutionContext): Promise<ToolResult> {
+    try {
+      const absolute = resolveRequestedPath(args.path);
+      const validatedPath = ensurePathWithinAllowed(
+        absolute,
+        this.allowedDirectories,
+        'PATH_NOT_ALLOWED',
+        context?.confirmationApproved === true
+      );
+
+      const versions = await this.historyStore.listVersions(validatedPath);
+      const version = this.resolveVersion(versions, args.versionId);
+      if (!version) {
+        const message = args.versionId
+          ? `FILE_HISTORY_VERSION_NOT_FOUND: ${args.versionId}`
+          : `FILE_HISTORY_EMPTY: ${validatedPath}`;
+        return {
+          success: false,
+          output: message,
+          error: new ToolExecutionError(message),
+          metadata: {
+            path: validatedPath,
+            versionId: args.versionId,
+          },
+        };
+      }
+
+      const restored = await this.historyStore.restoreVersion(validatedPath, version.versionId);
+      const payload: FileHistoryRestorePayload = {
+        path: validatedPath,
+        restored,
+        version: restored ? version : undefined,
+      };
+
+      if (!restored) {
+        const message = `FILE_HISTORY_RESTORE_FAILED: ${version.versionId}`;
+        return {
+          success: false,
+          output: message,
+          error: new ToolExecutionError(message),
+          metadata: payload as unknown as Record<string, unknown>,
+        };
+      }
+
+      return {
+        success: true,
+        output: JSON.stringify(payload),
+        metadata: payload as unknown as Record<string, unknown>,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        output: message,
+        error: new ToolExecutionError(message),
+      };
+    }
+  }
+
+  private resolveVersion(
+    versions: FileHistoryVersion[],
+    versionId?: string
+  ): FileHistoryVersion | undefined {
+    if (!versionId) {
+      return versions[0];
+    }
+    return versions.find((entry) => entry.versionId === versionId);
+  }
+}
+
+export default FileHistoryRestoreTool;