@renxqoo/renx-code 0.0.8 → 0.0.10

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

@@ -1,211 +0,0 @@
-import * as fs from 'node:fs/promises';
-import { createHash } from 'node:crypto';
-import { z } from 'zod';
-import { BaseTool, type ToolConfirmDetails, type 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

@@ -1,171 +0,0 @@
-import { z } from 'zod';
-import { BaseTool, type ToolConfirmDetails, type 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;