@renxqoo/renx-code 0.0.8 → 0.0.10

package/vendor/agent-root/src/agent/agent/tool-execution-ledger.ts

@@ -1,164 +0,0 @@
-import type { Message } from '../types';
-
-export interface ToolExecutionLedgerRecord {
-  success: boolean;
-  output: string;
-  summary: string;
-  payload?: unknown;
-  metadata?: Record<string, unknown>;
-  errorName?: string;
-  errorMessage?: string;
-  errorCode?: string;
-  recordedAt: number;
-}
-
-export interface ToolExecutionOnceResult {
-  record: ToolExecutionLedgerRecord;
-  fromCache: boolean;
-}
-
-export interface ToolExecutionLedger {
-  get(executionId: string, toolCallId: string): Promise<ToolExecutionLedgerRecord | undefined>;
-  set(executionId: string, toolCallId: string, record: ToolExecutionLedgerRecord): Promise<void>;
-  executeOnce(
-    executionId: string,
-    toolCallId: string,
-    execute: () => Promise<ToolExecutionLedgerRecord>
-  ): Promise<ToolExecutionOnceResult>;
-}
-
-export class NoopToolExecutionLedger implements ToolExecutionLedger {
-  async get(
-    _executionId: string,
-    _toolCallId: string
-  ): Promise<ToolExecutionLedgerRecord | undefined> {
-    return undefined;
-  }
-
-  async set(
-    _executionId: string,
-    _toolCallId: string,
-    _record: ToolExecutionLedgerRecord
-  ): Promise<void> {
-    return;
-  }
-
-  async executeOnce(
-    _executionId: string,
-    _toolCallId: string,
-    execute: () => Promise<ToolExecutionLedgerRecord>
-  ): Promise<ToolExecutionOnceResult> {
-    const record = await execute();
-    return {
-      record,
-      fromCache: false,
-    };
-  }
-}
-
-export class InMemoryToolExecutionLedger implements ToolExecutionLedger {
-  private readonly store = new Map<string, ToolExecutionLedgerRecord>();
-  private readonly inflight = new Map<string, Promise<ToolExecutionLedgerRecord>>();
-
-  async get(
-    executionId: string,
-    toolCallId: string
-  ): Promise<ToolExecutionLedgerRecord | undefined> {
-    return this.store.get(this.buildKey(executionId, toolCallId));
-  }
-
-  async set(
-    executionId: string,
-    toolCallId: string,
-    record: ToolExecutionLedgerRecord
-  ): Promise<void> {
-    this.store.set(this.buildKey(executionId, toolCallId), record);
-  }
-
-  async executeOnce(
-    executionId: string,
-    toolCallId: string,
-    execute: () => Promise<ToolExecutionLedgerRecord>
-  ): Promise<ToolExecutionOnceResult> {
-    const key = this.buildKey(executionId, toolCallId);
-    const cached = this.store.get(key);
-    if (cached) {
-      return {
-        record: cached,
-        fromCache: true,
-      };
-    }
-
-    const inflight = this.inflight.get(key);
-    if (inflight) {
-      const record = await inflight;
-      return {
-        record,
-        fromCache: true,
-      };
-    }
-
-    const pending = (async () => {
-      const record = await execute();
-      this.store.set(key, record);
-      return record;
-    })();
-    this.inflight.set(key, pending);
-
-    try {
-      const record = await pending;
-      return {
-        record,
-        fromCache: false,
-      };
-    } finally {
-      this.inflight.delete(key);
-    }
-  }
-
-  private buildKey(executionId: string, toolCallId: string): string {
-    return `${executionId}:${toolCallId}`;
-  }
-}
-
-export function createToolResultMessage(params: {
-  toolCallId: string;
-  content: string;
-  metadata?: Record<string, unknown>;
-  createMessageId: () => string;
-}): Message {
-  const { toolCallId, content, metadata, createMessageId } = params;
-  return {
-    messageId: createMessageId(),
-    type: 'tool-result',
-    role: 'tool',
-    content,
-    tool_call_id: toolCallId,
-    timestamp: Date.now(),
-    metadata,
-  };
-}
-
-export async function executeToolCallWithLedger(params: {
-  ledger: ToolExecutionLedger;
-  executionId: string | undefined;
-  toolCallId: string;
-  execute: () => Promise<ToolExecutionLedgerRecord>;
-  onError?: (error: unknown) => void;
-}): Promise<ToolExecutionOnceResult> {
-  const { ledger, executionId, toolCallId, execute, onError } = params;
-  try {
-    if (!executionId) {
-      const record = await execute();
-      return {
-        record,
-        fromCache: false,
-      };
-    }
-
-    return await ledger.executeOnce(executionId, toolCallId, execute);
-  } catch (error) {
-    onError?.(error);
-    throw error;
-  }
-}

package/vendor/agent-root/src/agent/agent/write-buffer.ts

@@ -1,188 +0,0 @@
-import * as path from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { promises as fs } from 'node:fs';
-import { resolveWriteBufferBaseDir } from '../storage/file-storage-config';
-import { createConfiguredFileHistoryStore } from '../storage/file-history-store';
-import { writeTextFileWithHistory } from '../storage/file-write-service';
-
-export interface WriteBufferSessionMeta {
-  bufferId: string;
-  messageId: string;
-  toolCallId?: string;
-  targetPath?: string;
-  baseDir: string;
-  rawArgsPath: string;
-  contentPath: string;
-  metaPath: string;
-  createdAt: number;
-  updatedAt: number;
-  rawArgsBytes: number;
-  contentBytes: number;
-  status: 'active' | 'finalized' | 'aborted';
-}
-
-export interface CreateWriteBufferSessionInput {
-  messageId?: string;
-  toolCallId?: string;
-  targetPath?: string;
-  baseDir?: string;
-}
-
-export interface AppendResult {
-  bytesWritten: number;
-  totalBytes: number;
-  updatedAt: number;
-}
-
-function getDefaultBaseDir(): string {
-  return resolveWriteBufferBaseDir();
-}
-
-function safeSegment(input: string): string {
-  return input.replace(/[^a-zA-Z0-9_-]/g, '_');
-}
-
-async function writeMeta(meta: WriteBufferSessionMeta): Promise<void> {
-  await fs.writeFile(meta.metaPath, JSON.stringify(meta, null, 2), 'utf8');
-}
-
-async function readMeta(metaPath: string): Promise<WriteBufferSessionMeta> {
-  const content = await fs.readFile(metaPath, 'utf8');
-  return JSON.parse(content) as WriteBufferSessionMeta;
-}
-
-export function resolveBufferId(toolCallId?: string): string {
-  if (typeof toolCallId === 'string' && toolCallId.trim().length > 0) {
-    return toolCallId.trim();
-  }
-  return `buffer_${randomUUID()}`;
-}
-
-export async function createWriteBufferSession(
-  input: CreateWriteBufferSessionInput
-): Promise<WriteBufferSessionMeta> {
-  const now = Date.now();
-  const baseDir = input.baseDir ? path.resolve(input.baseDir) : getDefaultBaseDir();
-  const messageId = input.messageId?.trim() || `msg_${now}`;
-  const bufferId = resolveBufferId(input.toolCallId);
-  const uniqueSuffix = `${now}_${randomUUID().slice(0, 8)}`;
-  const fileStem = `${safeSegment(messageId)}_${safeSegment(bufferId)}_${uniqueSuffix}`;
-
-  await fs.mkdir(baseDir, { recursive: true });
-
-  const rawArgsPath = path.join(baseDir, `${fileStem}.args.tmp`);
-  const contentPath = path.join(baseDir, `${fileStem}.content.tmp`);
-  const metaPath = path.join(baseDir, `${fileStem}.meta.json`);
-
-  await fs.writeFile(rawArgsPath, '', 'utf8');
-  await fs.writeFile(contentPath, '', 'utf8');
-
-  const meta: WriteBufferSessionMeta = {
-    bufferId,
-    messageId,
-    toolCallId: input.toolCallId,
-    targetPath: input.targetPath,
-    baseDir,
-    rawArgsPath,
-    contentPath,
-    metaPath,
-    createdAt: now,
-    updatedAt: now,
-    rawArgsBytes: 0,
-    contentBytes: 0,
-    status: 'active',
-  };
-
-  await writeMeta(meta);
-  return meta;
-}
-
-export async function appendRawArgs(
-  session: Pick<WriteBufferSessionMeta, 'rawArgsPath' | 'metaPath'>,
-  chunk: string
-): Promise<AppendResult> {
-  const bytesWritten = Buffer.byteLength(chunk, 'utf8');
-  await fs.appendFile(session.rawArgsPath, chunk, 'utf8');
-
-  const meta = await readMeta(session.metaPath);
-  const updatedAt = Date.now();
-  meta.updatedAt = updatedAt;
-  meta.rawArgsBytes += bytesWritten;
-  await writeMeta(meta);
-
-  return {
-    bytesWritten,
-    totalBytes: meta.rawArgsBytes,
-    updatedAt,
-  };
-}
-
-export async function appendContent(
-  session: Pick<WriteBufferSessionMeta, 'contentPath' | 'metaPath'>,
-  chunk: string
-): Promise<AppendResult> {
-  const bytesWritten = Buffer.byteLength(chunk, 'utf8');
-  await fs.appendFile(session.contentPath, chunk, 'utf8');
-
-  const meta = await readMeta(session.metaPath);
-  const updatedAt = Date.now();
-  meta.updatedAt = updatedAt;
-  meta.contentBytes += bytesWritten;
-  await writeMeta(meta);
-
-  return {
-    bytesWritten,
-    totalBytes: meta.contentBytes,
-    updatedAt,
-  };
-}
-
-export async function finalizeWriteBufferSession(
-  session: Pick<WriteBufferSessionMeta, 'contentPath' | 'metaPath' | 'targetPath'>
-): Promise<WriteBufferSessionMeta> {
-  if (!session.targetPath) {
-    throw new Error('targetPath is required to finalize write buffer session');
-  }
-
-  const meta = await readMeta(session.metaPath);
-  if (meta.status !== 'active') {
-    throw new Error(`cannot finalize session in status=${meta.status}`);
-  }
-
-  const targetPath = path.resolve(session.targetPath);
-  const content = await fs.readFile(session.contentPath, 'utf8');
-  await writeTextFileWithHistory(targetPath, content, {
-    source: 'write_buffer_finalize',
-    historyStore: createConfiguredFileHistoryStore(),
-  });
-
-  meta.targetPath = targetPath;
-  meta.updatedAt = Date.now();
-  meta.status = 'finalized';
-  await writeMeta(meta);
-
-  return meta;
-}
-
-export async function abortWriteBufferSession(
-  session: Pick<WriteBufferSessionMeta, 'rawArgsPath' | 'contentPath' | 'metaPath'>
-): Promise<void> {
-  const meta = await readMeta(session.metaPath);
-  meta.status = 'aborted';
-  meta.updatedAt = Date.now();
-  await writeMeta(meta);
-}
-
-export async function cleanupWriteBufferSessionFiles(
-  session: Pick<WriteBufferSessionMeta, 'rawArgsPath' | 'contentPath' | 'metaPath'>
-): Promise<void> {
-  await Promise.all([
-    fs.rm(session.rawArgsPath, { force: true }),
-    fs.rm(session.contentPath, { force: true }),
-    fs.rm(session.metaPath, { force: true }),
-  ]);
-}
-
-export async function loadWriteBufferSession(metaPath: string): Promise<WriteBufferSessionMeta> {
-  return readMeta(metaPath);
-}

package/vendor/agent-root/src/agent/agent/write-file-session.ts

@@ -1,238 +0,0 @@
-import type { ToolCall } from '../../providers';
-import {
-  appendContent,
-  appendRawArgs,
-  cleanupWriteBufferSessionFiles,
-  createWriteBufferSession,
-  loadWriteBufferSession,
-  type WriteBufferSessionMeta,
-} from './write-buffer';
-
-export const WRITE_FILE_TOOL_NAME = 'write_file';
-
-export interface WriteBufferRuntime {
-  session: WriteBufferSessionMeta;
-  bufferedContentChars: number;
-}
-
-interface WriteFileProtocolPayload {
-  ok: boolean;
-  code:
-    | 'OK'
-    | 'WRITE_FILE_PARTIAL_BUFFERED'
-    | 'WRITE_FILE_NEED_FINALIZE'
-    | 'WRITE_FILE_FINALIZE_OK';
-  nextAction: 'finalize' | 'none';
-}
-
-export function buildWriteFileSessionKey(params: {
-  executionId?: string;
-  stepIndex: number;
-  toolCallId: string;
-}): string {
-  const { executionId, stepIndex, toolCallId } = params;
-  const executionKey = executionId && executionId.trim().length > 0 ? executionId : '__anonymous__';
-  return `${executionKey}:${stepIndex}:${toolCallId}`;
-}
-
-export function isWriteFileToolCall(toolCall: ToolCall): boolean {
-  return toolCall.function.name?.trim() === WRITE_FILE_TOOL_NAME;
-}
-
-export function extractWriteFileContentPrefix(argumentsText: string): string | null {
-  const contentMarkerMatch = /"content"\s*:\s*"/.exec(argumentsText);
-  if (!contentMarkerMatch || typeof contentMarkerMatch.index !== 'number') {
-    return null;
-  }
-
-  let cursor = contentMarkerMatch.index + contentMarkerMatch[0].length;
-  let output = '';
-
-  while (cursor < argumentsText.length) {
-    const ch = argumentsText[cursor];
-    if (ch === '"') {
-      return output;
-    }
-
-    if (ch !== '\\') {
-      output += ch;
-      cursor += 1;
-      continue;
-    }
-
-    if (cursor + 1 >= argumentsText.length) {
-      return output;
-    }
-
-    const esc = argumentsText[cursor + 1];
-    if (esc === '"' || esc === '\\' || esc === '/') {
-      output += esc;
-      cursor += 2;
-    } else if (esc === 'b') {
-      output += '\b';
-      cursor += 2;
-    } else if (esc === 'f') {
-      output += '\f';
-      cursor += 2;
-    } else if (esc === 'n') {
-      output += '\n';
-      cursor += 2;
-    } else if (esc === 'r') {
-      output += '\r';
-      cursor += 2;
-    } else if (esc === 't') {
-      output += '\t';
-      cursor += 2;
-    } else if (esc === 'u') {
-      const unicodeHex = argumentsText.slice(cursor + 2, cursor + 6);
-      if (!/^[0-9a-fA-F]{4}$/.test(unicodeHex)) {
-        return output;
-      }
-      output += String.fromCharCode(parseInt(unicodeHex, 16));
-      cursor += 6;
-    } else {
-      output += esc;
-      cursor += 2;
-    }
-  }
-
-  return output;
-}
-
-export async function bufferWriteFileToolCallChunk(params: {
-  toolCall: ToolCall;
-  argumentsChunk: string;
-  messageId: string;
-  sessionKey?: string;
-  sessions: Map<string, WriteBufferRuntime>;
-  onError?: (error: unknown) => void;
-}): Promise<void> {
-  const { toolCall, argumentsChunk, messageId, sessionKey, sessions, onError } = params;
-  if (!isWriteFileToolCall(toolCall)) {
-    return;
-  }
-
-  try {
-    const runtimeKey = sessionKey || toolCall.id;
-    let runtime = sessions.get(runtimeKey);
-    if (!runtime) {
-      const session = await createWriteBufferSession({
-        messageId,
-        toolCallId: toolCall.id,
-      });
-      runtime = {
-        session,
-        bufferedContentChars: 0,
-      };
-      sessions.set(runtimeKey, runtime);
-    }
-
-    if (argumentsChunk) {
-      await appendRawArgs(runtime.session, argumentsChunk);
-    }
-
-    const decodedContentPrefix = extractWriteFileContentPrefix(toolCall.function.arguments);
-    if (decodedContentPrefix === null) {
-      return;
-    }
-
-    if (decodedContentPrefix.length <= runtime.bufferedContentChars) {
-      return;
-    }
-
-    const contentDelta = decodedContentPrefix.slice(runtime.bufferedContentChars);
-    await appendContent(runtime.session, contentDelta);
-    runtime.bufferedContentChars = decodedContentPrefix.length;
-  } catch (error) {
-    onError?.(error);
-  }
-}
-
-export async function enrichWriteFileToolError(
-  toolCall: ToolCall,
-  content: string,
-  sessions: Map<string, WriteBufferRuntime>,
-  sessionKey?: string
-): Promise<string> {
-  if (!isWriteFileToolCall(toolCall)) {
-    return content;
-  }
-  const runtime = sessions.get(sessionKey || toolCall.id);
-  if (!runtime) {
-    return JSON.stringify({
-      ok: false,
-      code: 'WRITE_FILE_NEED_FINALIZE',
-      message: content,
-      nextAction: 'finalize',
-    });
-  }
-  try {
-    const meta = await loadWriteBufferSession(runtime.session.metaPath);
-    return JSON.stringify({
-      ok: false,
-      code: 'WRITE_FILE_PARTIAL_BUFFERED',
-      message: content,
-      buffer: {
-        bufferId: meta.bufferId,
-        path: meta.targetPath || '',
-        bufferedBytes: meta.contentBytes,
-        maxChunkBytes: 32768,
-      },
-      nextAction: 'finalize',
-    });
-  } catch {
-    return JSON.stringify({
-      ok: false,
-      code: 'WRITE_FILE_NEED_FINALIZE',
-      message: content,
-      nextAction: 'finalize',
-    });
-  }
-}
-
-export function isWriteFileProtocolOutput(content: string | undefined): content is string {
-  if (!content || content.trim().length === 0) {
-    return false;
-  }
-  try {
-    const parsed = JSON.parse(content) as Partial<WriteFileProtocolPayload>;
-    if (!parsed || typeof parsed !== 'object') {
-      return false;
-    }
-    return (
-      typeof parsed.code === 'string' &&
-      typeof parsed.ok === 'boolean' &&
-      (parsed.nextAction === 'finalize' || parsed.nextAction === 'none')
-    );
-  } catch {
-    return false;
-  }
-}
-
-export function shouldEnrichWriteFileFailure(
-  error: { name?: string } | undefined,
-  output?: string
-): boolean {
-  if (isWriteFileProtocolOutput(output)) {
-    return false;
-  }
-  const errorName = error?.name;
-  return errorName === 'InvalidArgumentsError' || errorName === 'ToolValidationError';
-}
-
-export async function cleanupWriteFileBufferIfNeeded(
-  toolCall: ToolCall,
-  sessions: Map<string, WriteBufferRuntime>,
-  sessionKey?: string
-): Promise<void> {
-  if (!isWriteFileToolCall(toolCall)) {
-    return;
-  }
-  const runtimeKey = sessionKey || toolCall.id;
-  const runtime = sessions.get(runtimeKey);
-  if (!runtime) {
-    return;
-  }
-  sessions.delete(runtimeKey);
-  await cleanupWriteBufferSessionFiles(runtime.session);
-}