@renxqoo/renx-code 0.0.4 → 0.0.6

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

@@ -0,0 +1,211 @@
+import * as fs from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+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_READ_TOOL_DESCRIPTION } from './tool-prompts';
+import type { ToolExecutionContext } from './types';
+
+const schema = z
+  .object({
+    path: z.string().min(1).describe('The absolute or relative path to the file'),
+    // 起始行号（0-based）
+    startLine: z.coerce
+      .number()
+      .min(0)
+      .describe('The line number to start reading from (0-based)')
+      .optional(),
+    // 读取行数
+    limit: z.coerce
+      .number()
+      .min(1)
+      .describe('The number of lines to read (defaults to 1000)')
+      .optional(),
+  })
+  .strict();
+
+export interface FileReadToolOptions {
+  allowedDirectories?: string[];
+  maxOutputLength?: number;
+}
+
+interface FileReadPayload {
+  path: string;
+  content: string;
+  etag: string;
+  truncated: boolean;
+  originalLength?: number;
+}
+
+export class FileReadTool extends BaseTool<typeof schema> {
+  name = 'file_read';
+  description = FILE_READ_TOOL_DESCRIPTION;
+  parameters = schema;
+
+  private readonly allowedDirectories: string[];
+  private readonly maxOutputLength: number;
+
+  constructor(options: FileReadToolOptions = {}) {
+    super();
+    this.allowedDirectories = normalizeAllowedDirectories(options.allowedDirectories);
+    this.maxOutputLength =
+      options.maxOutputLength && options.maxOutputLength > 0 ? options.maxOutputLength : 2000;
+  }
+
+  override getConcurrencyMode(): 'parallel-safe' {
+    return 'parallel-safe';
+  }
+
+  override getConcurrencyLockKey(args: z.infer<typeof schema>): string {
+    return `file_read:${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> {
+    const limit = args.limit ?? 1000;
+    if (limit < 1) {
+      const message = 'FILE_READ_INVALID_LIMIT: limit must be >= 1';
+      return {
+        success: false,
+        output: message,
+        error: new ToolExecutionError(message),
+        metadata: {
+          error: 'FILE_READ_INVALID_LIMIT',
+          message: 'limit must be greater than or equal to 1',
+          path: args.path,
+          limit,
+        },
+      };
+    }
+
+    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_READ_NOT_FILE: ${validatedPath}`);
+      }
+
+      const fullContent = await fs.readFile(validatedPath, 'utf8');
+      const slicedContent = this.sliceContentByLines(fullContent, args.startLine, limit);
+      const truncatedResult = this.truncateOutput(slicedContent);
+
+      const payload: FileReadPayload = {
+        path: validatedPath,
+        content: truncatedResult.output,
+        etag: this.createEtag(fullContent),
+        truncated: truncatedResult.truncated,
+        originalLength: truncatedResult.truncated ? slicedContent.length : undefined,
+      };
+
+      return {
+        success: true,
+        output: payload.content,
+        metadata: payload as unknown as Record<string, unknown>,
+      };
+    } catch (error) {
+      const message = this.toFailureMessage(args.path, error);
+      return {
+        success: false,
+        output: message,
+        error: new ToolExecutionError(message),
+      };
+    }
+  }
+
+  private toFailureMessage(requestPath: string, error: unknown): string {
+    const nodeError = error as NodeJS.ErrnoException;
+    if (nodeError?.message?.startsWith('PATH_NOT_ALLOWED:')) {
+      return nodeError.message;
+    }
+
+    if (nodeError?.code === 'ENOENT') {
+      return `FILE_READ_NOT_FOUND: ${requestPath}`;
+    }
+    if (nodeError?.code === 'EACCES' || nodeError?.code === 'EPERM') {
+      return `FILE_READ_NO_PERMISSION: ${requestPath}`;
+    }
+
+    const message = error instanceof Error ? error.message : String(error);
+    return `FILE_READ_FAILED: ${message}`;
+  }
+
+  private sliceContentByLines(content: string, startLine?: number, limit?: number): string {
+    if (startLine === undefined && limit === undefined) {
+      return content;
+    }
+
+    const normalized = content.replace(/\r\n/g, '\n');
+    const lines = normalized.split('\n');
+    if (lines.length > 0 && lines[lines.length - 1] === '') {
+      lines.pop();
+    }
+
+    const start = Math.max(startLine ?? 0, 0);
+    const endExclusive = limit === undefined ? lines.length : Math.min(start + limit, lines.length);
+    if (start >= lines.length || endExclusive <= start) {
+      return '';
+    }
+
+    return lines.slice(start, endExclusive).join('\n');
+  }
+
+  private truncateOutput(input: string): { output: string; truncated: boolean } {
+    if (input.length <= this.maxOutputLength) {
+      return { output: input, truncated: false };
+    }
+
+    const marker = '\n\n[... Output Truncated ...]';
+    const available = this.maxOutputLength - marker.length;
+    if (available <= 20) {
+      return {
+        output: input.slice(0, this.maxOutputLength),
+        truncated: true,
+      };
+    }
+
+    const head = input.slice(0, available);
+    const tailLineBreak = head.lastIndexOf('\n');
+    const safeTailBreakThreshold = Math.floor(available * 0.6);
+    const trimmedHead =
+      tailLineBreak > safeTailBreakThreshold ? head.slice(0, tailLineBreak) : head;
+
+    return {
+      output: `${trimmedHead}${marker}`,
+      truncated: true,
+    };
+  }
+
+  private createEtag(content: string): string {
+    return createHash('sha256').update(content).digest('hex');
+  }
+}
+
+export default FileReadTool;

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

@@ -0,0 +1,171 @@
+import { z } from 'zod';
+import { BaseTool, ToolConfirmDetails, ToolResult } from './base-tool';
+import { ToolExecutionError } from './error';
+import { collectFilesByGlob, DEFAULT_IGNORE_GLOBS, resolveSearchRoot } from './search/common';
+import {
+  assessPathAccess,
+  ensurePathWithinAllowed,
+  normalizeAllowedDirectories,
+  resolveRequestedPath,
+} from './path-security';
+import { GLOB_TOOL_DESCRIPTION } from './tool-prompts';
+import type { ToolExecutionContext } from './types';
+
+const schema = z
+  .object({
+    pattern: z.string().min(1).describe('Glob pattern like **/*.ts or src/**/*.test.ts'),
+    path: z.string().optional().describe('Base directory (default: current working directory)'),
+    include_hidden: z
+      .boolean()
+      .optional()
+      .default(false)
+      .describe('Include hidden files/directories'),
+    ignore_patterns: z
+      .array(z.string())
+      .optional()
+      .describe('Additional ignore patterns applied before matching'),
+    max_results: z
+      .number()
+      .int()
+      .min(1)
+      .max(10000)
+      .optional()
+      .default(200)
+      .describe('Maximum number of matched files to return'),
+  })
+  .strict();
+
+export interface GlobToolOptions {
+  allowedDirectories?: string[];
+}
+
+interface GlobSuccessPayload {
+  pattern: string;
+  path: string;
+  files: string[];
+  relative_files?: string[];
+  total: number;
+  truncated: boolean;
+}
+
+export class GlobTool extends BaseTool<typeof schema> {
+  name = 'glob';
+  description = GLOB_TOOL_DESCRIPTION;
+  parameters = schema;
+
+  private readonly allowedDirectories: string[];
+
+  constructor(options: GlobToolOptions = {}) {
+    super();
+    this.allowedDirectories = normalizeAllowedDirectories(options.allowedDirectories);
+  }
+
+  override getConcurrencyMode(): 'parallel-safe' {
+    return 'parallel-safe';
+  }
+
+  override getConcurrencyLockKey(args: z.infer<typeof schema>): string {
+    return `glob:${args.path || process.cwd()}`;
+  }
+
+  override getConfirmDetails(args: z.infer<typeof schema>): ToolConfirmDetails | null {
+    const requestedPath = args.path?.trim().length ? args.path : process.cwd();
+    const absolute = resolveRequestedPath(requestedPath);
+    const assessment = assessPathAccess(
+      absolute,
+      this.allowedDirectories,
+      'SEARCH_PATH_NOT_ALLOWED'
+    );
+    if (assessment.allowed) {
+      return null;
+    }
+    return {
+      reason: assessment.message,
+      metadata: {
+        requestedPath: absolute,
+        allowedDirectories: this.allowedDirectories,
+        errorCode: 'SEARCH_PATH_NOT_ALLOWED',
+      },
+    };
+  }
+
+  async execute(args: z.infer<typeof schema>, context?: ToolExecutionContext): Promise<ToolResult> {
+    try {
+      let rootPath: string;
+      if (context?.confirmationApproved === true) {
+        const requestedPath = args.path?.trim().length ? args.path : process.cwd();
+        const absolute = resolveRequestedPath(requestedPath);
+        rootPath = ensurePathWithinAllowed(
+          absolute,
+          this.allowedDirectories,
+          'SEARCH_PATH_NOT_ALLOWED',
+          true
+        );
+      } else {
+        ({ rootPath } = await resolveSearchRoot({
+          requestedPath: args.path,
+          allowedDirectories: this.allowedDirectories,
+        }));
+      }
+
+      const ignorePatterns = [...DEFAULT_IGNORE_GLOBS, ...(args.ignore_patterns || [])];
+      const { files, truncated } = await collectFilesByGlob({
+        rootPath,
+        pattern: args.pattern,
+        includeHidden: args.include_hidden,
+        ignorePatterns,
+        maxResults: args.max_results,
+      });
+
+      if (files.length === 0) {
+        return {
+          success: true,
+          output: `No files found matching pattern: ${args.pattern}`,
+          metadata: {
+            pattern: args.pattern,
+            path: rootPath,
+            files: [],
+            total: 0,
+            truncated: false,
+          } as unknown as Record<string, unknown>,
+        };
+      }
+
+      const payload: GlobSuccessPayload = {
+        pattern: args.pattern,
+        path: rootPath,
+        files: files.map((file) => file.absolutePath),
+        relative_files: files.map((file) => file.relativePath),
+        total: files.length,
+        truncated,
+      };
+
+      return {
+        success: true,
+        output: `Found ${files.length} file(s) matching pattern: ${args.pattern}`,
+        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),
+        metadata: {
+          error: this.extractErrorCode(message),
+          message,
+        },
+      };
+    }
+  }
+
+  private extractErrorCode(message: string): string {
+    const matched = message.match(/^([A-Z][A-Z0-9_]{2,})(?::|$)/);
+    if (matched?.[1]) {
+      return matched[1];
+    }
+    return 'GLOB_OPERATION_FAILED';
+  }
+}
+
+export default GlobTool;