@renxqoo/renx-code 0.0.8 → 0.0.10

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

@@ -1,368 +0,0 @@
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { promises as fs } from 'node:fs';
-import { afterEach, describe, expect, it } from 'vitest';
-import { WriteFileTool } from '../write-file';
-import { appendContent, appendRawArgs, createWriteBufferSession } from '../../agent/write-buffer';
-
-const tempDirs: string[] = [];
-
-async function createTempDir(): Promise<string> {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-write-file-tool-'));
-  tempDirs.push(dir);
-  return dir;
-}
-
-afterEach(async () => {
-  await Promise.all(tempDirs.splice(0).map((dir) => fs.rm(dir, { recursive: true, force: true })));
-});
-
-function parseOutput<T>(output: string | undefined): T {
-  return JSON.parse(output || '{}') as T;
-}
-
-describe('WriteFileTool', () => {
-  it('writes small content directly with OK response', async () => {
-    const allowedDir = await createTempDir();
-    const bufferDir = await createTempDir();
-    const tool = new WriteFileTool({
-      allowedDirectories: [allowedDir],
-      bufferBaseDir: bufferDir,
-      maxChunkBytes: 64,
-    });
-    const target = path.join(allowedDir, 'a.txt');
-
-    const result = await tool.execute({
-      path: target,
-      content: 'hello',
-      mode: 'direct',
-    });
-
-    expect(result.success).toBe(true);
-    const payload = parseOutput<{
-      ok: boolean;
-      code: string;
-      message: string;
-      nextAction: string;
-    }>(result.output);
-    expect(payload).toMatchObject({
-      ok: true,
-      code: 'OK',
-      nextAction: 'none',
-    });
-    expect(payload.message).toContain('File written successfully');
-    expect(await fs.readFile(target, 'utf8')).toBe('hello');
-  });
-
-  it('allows write when target path goes through a symlinked directory inside allowed roots', async () => {
-    const allowedDir = await createTempDir();
-    const linkBaseDir = await createTempDir();
-    const bufferDir = await createTempDir();
-    const linkDir = path.join(linkBaseDir, 'allowed-link');
-    await fs.symlink(allowedDir, linkDir);
-
-    const tool = new WriteFileTool({
-      allowedDirectories: [allowedDir],
-      bufferBaseDir: bufferDir,
-      maxChunkBytes: 64,
-    });
-
-    const targetViaLink = path.join(linkDir, 'through-link.txt');
-    const result = await tool.execute({
-      path: targetViaLink,
-      content: 'hello-link',
-      mode: 'direct',
-    });
-
-    expect(result.success).toBe(true);
-    expect(await fs.readFile(path.join(allowedDir, 'through-link.txt'), 'utf8')).toBe('hello-link');
-  });
-
-  it('buffers large direct write and requests finalize', async () => {
-    const allowedDir = await createTempDir();
-    const bufferDir = await createTempDir();
-    const tool = new WriteFileTool({
-      allowedDirectories: [allowedDir],
-      bufferBaseDir: bufferDir,
-      maxChunkBytes: 8,
-    });
-    const target = path.join(allowedDir, 'large.txt');
-
-    const result = await tool.execute(
-      {
-        path: target,
-        content: '0123456789012345',
-        mode: 'direct',
-      },
-      {
-        toolCallId: 'write_call_1',
-        loopIndex: 1,
-        agent: {},
-      }
-    );
-
-    expect(result.success).toBe(false);
-    const payload = parseOutput<{
-      ok: boolean;
-      code: string;
-      nextAction: string;
-      buffer: { bufferId: string; bufferedBytes: number; maxChunkBytes: number };
-    }>(result.output);
-    expect(payload.ok).toBe(false);
-    expect(payload.code).toBe('WRITE_FILE_PARTIAL_BUFFERED');
-    expect(payload.nextAction).toBe('finalize');
-    expect(payload.buffer.bufferId).toBe('write_call_1');
-    expect(payload.buffer.bufferedBytes).toBe(Buffer.byteLength('0123456789012345', 'utf8'));
-    expect(payload.buffer.maxChunkBytes).toBe(8);
-  });
-
-  it('finalizes a fully buffered direct write without any intermediate chunk step', async () => {
-    const allowedDir = await createTempDir();
-    const bufferDir = await createTempDir();
-    const tool = new WriteFileTool({
-      allowedDirectories: [allowedDir],
-      bufferBaseDir: bufferDir,
-      maxChunkBytes: 8,
-    });
-    const target = path.join(allowedDir, 'finalize.txt');
-    const fullContent = 'abcdefghi';
-
-    const direct = await tool.execute(
-      {
-        path: target,
-        content: 'abcdefghi',
-        mode: 'direct',
-      },
-      {
-        toolCallId: 'write_call_2',
-        loopIndex: 1,
-        agent: {},
-      }
-    );
-    const directPayload = parseOutput<{ buffer: { bufferId: string } }>(direct.output);
-
-    const finalize = await tool.execute({
-      path: target,
-      mode: 'finalize',
-      bufferId: directPayload.buffer.bufferId,
-    });
-    const finalizePayload = parseOutput<{ ok: boolean; code: string; nextAction: string }>(
-      finalize.output
-    );
-    expect(finalizePayload).toMatchObject({
-      ok: true,
-      code: 'WRITE_FILE_FINALIZE_OK',
-      nextAction: 'none',
-    });
-    expect(await fs.readFile(target, 'utf8')).toBe(fullContent);
-  });
-
-  it('finalizes buffered content to the original full direct payload', async () => {
-    const allowedDir = await createTempDir();
-    const bufferDir = await createTempDir();
-    const tool = new WriteFileTool({
-      allowedDirectories: [allowedDir],
-      bufferBaseDir: bufferDir,
-      maxChunkBytes: 8,
-    });
-    const target = path.join(allowedDir, 'finalize-no-checksum.txt');
-    const content = 'abcdefghijk';
-
-    const direct = await tool.execute(
-      {
-        path: target,
-        content,
-        mode: 'direct',
-      },
-      {
-        toolCallId: 'write_call_3',
-        loopIndex: 1,
-        agent: {},
-      }
-    );
-    const directPayload = parseOutput<{ buffer: { bufferId: string } }>(direct.output);
-
-    const finalize = await tool.execute({
-      path: target,
-      mode: 'finalize',
-      bufferId: directPayload.buffer.bufferId,
-    });
-    const finalizePayload = parseOutput<{ ok: boolean; code: string; nextAction: string }>(
-      finalize.output
-    );
-    expect(finalizePayload).toMatchObject({
-      ok: true,
-      code: 'WRITE_FILE_FINALIZE_OK',
-      nextAction: 'none',
-    });
-    expect(await fs.readFile(target, 'utf8')).toBe(content);
-  });
-
-  it('finalizes a buffered direct write by bufferId without requiring path and keeps full content', async () => {
-    const allowedDir = await createTempDir();
-    const bufferDir = await createTempDir();
-    const tool = new WriteFileTool({
-      allowedDirectories: [allowedDir],
-      bufferBaseDir: bufferDir,
-      maxChunkBytes: 8,
-    });
-    const target = path.join(allowedDir, 'finalize-by-buffer-id.txt');
-    const content = 'abcdefghijklmno';
-
-    const direct = await tool.execute(
-      {
-        path: target,
-        content,
-        mode: 'direct',
-      },
-      {
-        toolCallId: 'write_call_finalize_by_id',
-        loopIndex: 1,
-        agent: {},
-      }
-    );
-    const directPayload = parseOutput<{ ok: boolean; buffer: { bufferId: string } }>(direct.output);
-    expect(directPayload.ok).toBe(false);
-
-    const finalize = await tool.execute({
-      mode: 'finalize',
-      bufferId: directPayload.buffer.bufferId,
-    } as never);
-    const finalizePayload = parseOutput<{ ok: boolean; code: string; nextAction: string }>(
-      finalize.output
-    );
-    expect(finalizePayload).toMatchObject({
-      ok: true,
-      code: 'WRITE_FILE_FINALIZE_OK',
-      nextAction: 'none',
-    });
-    expect(await fs.readFile(target, 'utf8')).toBe(content);
-  });
-
-  it('finalizes an orphaned buffered session by scanning meta/rawArgs when pointer is missing', async () => {
-    const allowedDir = await createTempDir();
-    const bufferDir = await createTempDir();
-    const tool = new WriteFileTool({
-      allowedDirectories: [allowedDir],
-      bufferBaseDir: bufferDir,
-      maxChunkBytes: 8,
-    });
-    const target = path.join(allowedDir, 'finalize-orphaned-session.txt');
-    const content = 'orphaned buffered content';
-    const session = await createWriteBufferSession({
-      messageId: 'msg_orphaned',
-      toolCallId: 'write_call_orphaned',
-      baseDir: bufferDir,
-    });
-
-    await appendRawArgs(
-      session,
-      JSON.stringify({
-        mode: 'direct',
-        path: target,
-        content,
-      })
-    );
-    await appendContent(session, content);
-
-    const finalize = await tool.execute({
-      mode: 'finalize',
-      bufferId: session.bufferId,
-    } as never);
-    const payload = parseOutput<{ ok: boolean; code: string; nextAction: string }>(finalize.output);
-
-    expect(payload).toMatchObject({
-      ok: true,
-      code: 'WRITE_FILE_FINALIZE_OK',
-      nextAction: 'none',
-    });
-    expect(await fs.readFile(target, 'utf8')).toBe(content);
-  });
-
-  it('returns NEED_FINALIZE when finalize is missing bufferId', async () => {
-    const allowedDir = await createTempDir();
-    const bufferDir = await createTempDir();
-    const tool = new WriteFileTool({
-      allowedDirectories: [allowedDir],
-      bufferBaseDir: bufferDir,
-      maxChunkBytes: 8,
-    });
-    const payload = parseOutput<{
-      ok: boolean;
-      code: string;
-      nextAction: string;
-    }>(
-      (
-        await tool.execute({
-          mode: 'finalize',
-        } as never)
-      ).output
-    );
-
-    expect(payload.ok).toBe(false);
-    expect(payload.code).toBe('WRITE_FILE_NEED_FINALIZE');
-    expect(payload.nextAction).toBe('finalize');
-  });
-
-  it('prevents finalize from committing buffered content to a different target path', async () => {
-    const allowedDir = await createTempDir();
-    const bufferDir = await createTempDir();
-    const tool = new WriteFileTool({
-      allowedDirectories: [allowedDir],
-      bufferBaseDir: bufferDir,
-      maxChunkBytes: 8,
-    });
-    const targetA = path.join(allowedDir, 'target-a.txt');
-    const targetB = path.join(allowedDir, 'target-b.txt');
-
-    const direct = await tool.execute(
-      {
-        path: targetA,
-        content: 'abcdefghijk',
-        mode: 'direct',
-      },
-      {
-        toolCallId: 'write_call_path_mismatch',
-        loopIndex: 1,
-        agent: {},
-      }
-    );
-    const directPayload = parseOutput<{ buffer: { bufferId: string } }>(direct.output);
-
-    const finalize = await tool.execute({
-      path: targetB,
-      mode: 'finalize',
-      bufferId: directPayload.buffer.bufferId,
-    });
-    const payload = parseOutput<{ ok: boolean; code: string; message: string; nextAction: string }>(
-      finalize.output
-    );
-
-    expect(payload.ok).toBe(false);
-    expect(payload.code).toBe('WRITE_FILE_NEED_FINALIZE');
-    expect(payload.message).toContain('Target path does not match');
-    expect(payload.nextAction).toBe('finalize');
-    await expect(fs.readFile(targetB, 'utf8')).rejects.toBeDefined();
-  });
-
-  it('returns execution failure when path is outside allowed directories', async () => {
-    const allowedDir = await createTempDir();
-    const bufferDir = await createTempDir();
-    const tool = new WriteFileTool({
-      allowedDirectories: [allowedDir],
-      bufferBaseDir: bufferDir,
-      maxChunkBytes: 32,
-    });
-    const outside = path.resolve(allowedDir, '..', 'outside.txt');
-
-    const result = await tool.execute({
-      path: outside,
-      content: 'x',
-      mode: 'direct',
-    });
-
-    expect(result.success).toBe(false);
-    expect(result.error?.name).toBe('ToolExecutionError');
-    expect(result.output).toContain('Path is outside allowed directories');
-  });
-});

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

@@ -1,345 +0,0 @@
-import { z } from 'zod';
-import type { LLMTool, ToolConcurrencyMode, ToolExecutionContext } from './types';
-import { ToolExecutionError } from './error';
-
-export type ToolParameterSchema = z.ZodType;
-
-interface ZodDef {
-  typeName?: string;
-  shape?: unknown;
-  description?: string;
-  checks?: Array<{
-    kind?: string;
-    value?: number;
-    regex?: { source: string };
-    check?: string;
-    minimum?: number;
-    maximum?: number;
-    pattern?: string | RegExp;
-    format?: string;
-    inclusive?: boolean;
-  }>;
-  type?: z.ZodType | string;
-  values?: unknown[];
-  entries?: Record<string, unknown>;
-  value?: unknown;
-  innerType?: z.ZodType;
-  defaultValue?: unknown;
-  left?: z.ZodType;
-  right?: z.ZodType;
-  valueType?: z.ZodType;
-  items?: z.ZodType[];
-  options?: z.ZodType[];
-  element?: z.ZodType;
-}
-
-function normalizeTypeName(rawTypeName?: string): string | undefined {
-  if (!rawTypeName) return undefined;
-  const trimmed = rawTypeName.trim();
-  if (!trimmed) return undefined;
-  const withoutPrefix = trimmed.startsWith('Zod') ? trimmed.slice(3) : trimmed;
-  return withoutPrefix.toLowerCase();
-}
-
-function getSchemaDef(schemaAny: unknown): ZodDef | undefined {
-  return ((schemaAny as { _zod_def?: ZodDef })._zod_def ||
-    (schemaAny as { _def?: ZodDef })._def) as ZodDef | undefined;
-}
-
-function getSchemaKind(schemaAny: unknown): string | undefined {
-  const def = getSchemaDef(schemaAny);
-  const rawType = (def as { type?: unknown } | undefined)?.type;
-  const fromTypeField = typeof rawType === 'string' ? rawType : undefined;
-  const nestedTypeName = (rawType as { _def?: { typeName?: string } } | undefined)?._def?.typeName;
-  return normalizeTypeName(def?.typeName || fromTypeField || nestedTypeName);
-}
-
-function zodToJsonSchema(schema: z.ZodType): Record<string, unknown> {
-  const schemaAny = schema as unknown;
-
-  if (typeof (z as unknown as { toJSONSchema?: unknown }).toJSONSchema === 'function') {
-    try {
-      const result = (z as unknown as { toJSONSchema: (s: z.ZodType) => unknown }).toJSONSchema(
-        schema
-      );
-      if (result && typeof result === 'object') {
-        return result as Record<string, unknown>;
-      }
-    } catch {
-      // fallback to local conversion
-    }
-  }
-
-  if (typeof (schemaAny as { toJSONSchema?: unknown }).toJSONSchema === 'function') {
-    try {
-      const result = (schemaAny as { toJSONSchema: () => Record<string, unknown> }).toJSONSchema();
-      if (result && typeof result === 'object') {
-        return result;
-      }
-    } catch {
-      // fallback to local conversion
-    }
-  }
-
-  const def = getSchemaDef(schemaAny);
-  const typeName = getSchemaKind(schemaAny);
-
-  if (typeName === 'object') {
-    const properties: Record<string, unknown> = {};
-    const required: string[] = [];
-
-    if (!def) return { type: 'object' };
-
-    const shape = typeof def.shape === 'function' ? (def.shape as () => unknown)() : def.shape;
-
-    for (const [key, value] of Object.entries(shape as Record<string, unknown>)) {
-      const valueAny = value as unknown;
-      properties[key] = zodToJsonSchema(valueAny as z.ZodType);
-
-      const propTypeName = getSchemaKind(valueAny);
-      if (propTypeName !== 'optional' && propTypeName !== 'default') {
-        required.push(key);
-      }
-    }
-
-    return {
-      type: 'object',
-      properties,
-      required: required.length > 0 ? required : undefined,
-    };
-  }
-
-  if (typeName === 'string') {
-    const result: Record<string, unknown> = { type: 'string' };
-    if (def?.description) {
-      result.description = def.description;
-    }
-    if (def?.checks) {
-      for (const check of def.checks) {
-        const checkKind = check.kind || check.check;
-        if (checkKind === 'min') {
-          result.minLength = check.value;
-        } else if (checkKind === 'max') {
-          result.maxLength = check.value;
-        } else if (checkKind === 'regex') {
-          result.pattern = check.regex?.source;
-        } else if (checkKind === 'min_length') {
-          result.minLength = check.minimum;
-        } else if (checkKind === 'max_length') {
-          result.maxLength = check.maximum;
-        } else if (checkKind === 'string_format' && check.format === 'regex') {
-          result.pattern =
-            typeof check.pattern === 'string'
-              ? check.pattern
-              : check.pattern instanceof RegExp
-                ? check.pattern.source
-                : undefined;
-        }
-      }
-    }
-    return result;
-  }
-
-  if (typeName === 'number') {
-    const result: Record<string, unknown> = { type: 'number' };
-    if (def?.description) {
-      result.description = def.description;
-    }
-    if (def?.checks) {
-      for (const check of def.checks) {
-        const checkKind = check.kind || check.check;
-        if (checkKind === 'min') {
-          result.minimum = check.value;
-        } else if (checkKind === 'max') {
-          result.maximum = check.value;
-        } else if (checkKind === 'int') {
-          result.type = 'integer';
-        } else if (checkKind === 'greater_than') {
-          if (check.inclusive) {
-            result.minimum = check.value;
-          } else {
-            result.exclusiveMinimum = check.value;
-          }
-        } else if (checkKind === 'less_than') {
-          if (check.inclusive) {
-            result.maximum = check.value;
-          } else {
-            result.exclusiveMaximum = check.value;
-          }
-        } else if (checkKind === 'number_format') {
-          result.type = 'integer';
-        }
-      }
-    }
-    return result;
-  }
-
-  if (typeName === 'boolean') {
-    return {
-      type: 'boolean',
-      ...(def?.description && { description: def.description }),
-    };
-  }
-
-  if (typeName === 'array') {
-    const itemSchema = def?.element || (def?.type as z.ZodType | undefined);
-    return {
-      type: 'array',
-      items: itemSchema ? zodToJsonSchema(itemSchema as z.ZodType) : {},
-      ...(def?.description && { description: def.description }),
-    };
-  }
-
-  if (typeName === 'enum') {
-    const enumValues = def?.values || (def?.entries ? Object.values(def.entries) : []);
-    return {
-      type: 'string',
-      enum: enumValues,
-      ...(def?.description && { description: def.description }),
-    };
-  }
-
-  if (typeName === 'literal') {
-    const value = def?.value ?? def?.values?.[0];
-    if (typeof value === 'string') {
-      return { type: 'string', const: value };
-    }
-    if (typeof value === 'number') {
-      return { type: 'number', const: value };
-    }
-    if (typeof value === 'boolean') {
-      return { type: 'boolean', const: value };
-    }
-    return { const: value };
-  }
-
-  if (typeName === 'optional') {
-    return def?.innerType ? zodToJsonSchema(def.innerType as unknown as z.ZodType) : {};
-  }
-
-  if (typeName === 'default') {
-    const innerSchema = def?.innerType
-      ? zodToJsonSchema(def.innerType as unknown as z.ZodType)
-      : {};
-    return {
-      ...innerSchema,
-      default:
-        typeof def?.defaultValue === 'function'
-          ? (def.defaultValue as () => unknown)()
-          : def?.defaultValue,
-    };
-  }
-
-  if (typeName === 'nullable') {
-    const innerSchema = def?.innerType
-      ? zodToJsonSchema(def.innerType as unknown as z.ZodType)
-      : {};
-    return {
-      ...innerSchema,
-      nullable: true,
-    };
-  }
-
-  if (typeName === 'union') {
-    return {
-      oneOf:
-        def?.options?.map((option: z.ZodType) => zodToJsonSchema(option as unknown as z.ZodType)) ||
-        [],
-    };
-  }
-
-  if (typeName === 'intersection') {
-    return {
-      allOf: [
-        def?.left ? zodToJsonSchema(def.left as unknown as z.ZodType) : {},
-        def?.right ? zodToJsonSchema(def.right as unknown as z.ZodType) : {},
-      ],
-    };
-  }
-
-  if (typeName === 'record') {
-    return {
-      type: 'object',
-      additionalProperties: def?.valueType
-        ? zodToJsonSchema(def.valueType as unknown as z.ZodType)
-        : {},
-    };
-  }
-
-  if (typeName === 'tuple') {
-    return {
-      type: 'array',
-      items:
-        def?.items?.map((item: z.ZodType) => zodToJsonSchema(item as unknown as z.ZodType)) || [],
-    };
-  }
-
-  if (typeName === 'null') {
-    return { type: 'null' };
-  }
-
-  if (typeName === 'any' || typeName === 'unknown') {
-    return {};
-  }
-
-  return {};
-}
-
-export interface ToolResult {
-  success: boolean;
-  output?: string;
-  summary?: string;
-  payload?: unknown;
-  error?: ToolExecutionError;
-  metadata?: Record<string, unknown>;
-}
-
-export interface ToolConfirmDetails {
-  reason?: string;
-  metadata?: Record<string, unknown>;
-}
-
-export abstract class BaseTool<T extends ToolParameterSchema = ToolParameterSchema> {
-  abstract name: string;
-  abstract description: string;
-  abstract parameters: T;
-
-  shouldConfirm(_args: z.input<T>): boolean {
-    return false;
-  }
-
-  getConfirmDetails(_args: z.input<T>): ToolConfirmDetails | null {
-    return null;
-  }
-
-  getConcurrencyMode(_args: z.input<T>): ToolConcurrencyMode {
-    return 'exclusive';
-  }
-
-  getConcurrencyLockKey(_args: z.input<T>): string | undefined {
-    return undefined;
-  }
-
-  abstract execute(args: z.input<T>, context?: ToolExecutionContext): Promise<ToolResult>;
-
-  safeValidateArgs(
-    args: Record<string, unknown>
-  ): { success: true; data: z.infer<T> } | { success: false; error: z.ZodError } {
-    const result = this.parameters.safeParse(args);
-    if (result.success) {
-      return { success: true, data: result.data };
-    }
-    return { success: false, error: result.error };
-  }
-
-  toToolSchema(): LLMTool {
-    return {
-      type: 'function',
-      function: {
-        name: this.name,
-        description: this.description,
-        parameters: zodToJsonSchema(this.parameters),
-      },
-    };
-  }
-}