@renxqoo/renx-code 0.0.4 → 0.0.5

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

@@ -0,0 +1,164 @@
+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

@@ -0,0 +1,188 @@
+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

@@ -0,0 +1,238 @@
+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);
+}