@renxqoo/renx-code 0.0.9 → 0.0.10

package/vendor/agent-root/src/agent/storage/__test__/file-history-store.test.ts

@@ -1,98 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import { promises as fs } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { FileHistoryStore } from '../file-history-store';
-import type { FileStorageConfig } from '../file-storage-config';
-
-const tempDirs: string[] = [];
-
-async function createTempDir(): Promise<string> {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-file-history-'));
-  tempDirs.push(dir);
-  return dir;
-}
-
-function createHistoryStore(
-  rootDir: string,
-  historyDir: string,
-  overrides: Partial<FileStorageConfig> = {}
-) {
-  return new FileHistoryStore({
-    config: {
-      rootDir,
-      writeBufferDir: path.join(rootDir, 'cache', 'write-buffer'),
-      historyDir,
-      historyEnabled: true,
-      historyMaxPerFile: 20,
-      historyMaxAgeDays: 14,
-      historyMaxTotalBytes: 1024 * 1024,
-      ...overrides,
-    },
-  });
-}
-
-afterEach(async () => {
-  await Promise.all(tempDirs.splice(0).map((dir) => fs.rm(dir, { recursive: true, force: true })));
-});
-
-describe('FileHistoryStore', () => {
-  it('stores previous versions and restores a chosen snapshot', async () => {
-    const rootDir = await createTempDir();
-    const historyDir = path.join(rootDir, 'history');
-    const store = createHistoryStore(rootDir, historyDir);
-    const targetPath = path.join(rootDir, 'demo.txt');
-
-    await fs.writeFile(targetPath, 'v1', 'utf8');
-    await store.snapshotBeforeWrite({
-      targetPath,
-      nextContent: 'v2',
-      source: 'write_file',
-    });
-    await fs.writeFile(targetPath, 'v2', 'utf8');
-
-    await store.snapshotBeforeWrite({
-      targetPath,
-      nextContent: 'v3',
-      source: 'file_edit',
-    });
-    await fs.writeFile(targetPath, 'v3', 'utf8');
-
-    const versions = await store.listVersions(targetPath);
-    expect(versions).toHaveLength(2);
-    expect(versions.map((version) => version.source).sort()).toEqual(['file_edit', 'write_file']);
-
-    const originalVersion = versions.find((version) => version.source === 'write_file');
-    expect(originalVersion).toBeDefined();
-
-    const restored = await store.restoreVersion(targetPath, originalVersion!.versionId);
-    expect(restored).toBe(true);
-    expect(await fs.readFile(targetPath, 'utf8')).toBe('v1');
-  });
-
-  it('prunes older snapshots when per-file retention is exceeded', async () => {
-    const rootDir = await createTempDir();
-    const historyDir = path.join(rootDir, 'history');
-    const store = createHistoryStore(rootDir, historyDir, {
-      historyMaxPerFile: 1,
-    });
-    const targetPath = path.join(rootDir, 'retained.txt');
-
-    await fs.writeFile(targetPath, 'old-1', 'utf8');
-    await store.snapshotBeforeWrite({
-      targetPath,
-      nextContent: 'old-2',
-      source: 'write_file',
-    });
-    await fs.writeFile(targetPath, 'old-2', 'utf8');
-    await store.snapshotBeforeWrite({
-      targetPath,
-      nextContent: 'old-3',
-      source: 'write_file',
-    });
-
-    const versions = await store.listVersions(targetPath);
-    expect(versions).toHaveLength(1);
-    expect(versions[0].contentHash).toBeDefined();
-  });
-});

package/vendor/agent-root/src/agent/storage/file-history-store.ts

@@ -1,313 +0,0 @@
-import * as syncFs from 'node:fs';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { createHash, randomUUID } from 'node:crypto';
-import { getFileStorageConfig, type FileStorageConfig } from './file-storage-config';
-import {
-  readJsonFileIfExists,
-  writeJsonFileAtomically,
-  writeTextFileAtomically,
-} from './file-system';
-
-interface FileHistoryManifest {
-  schemaVersion: 1;
-  targetPath: string;
-  pathKey: string;
-  versions: FileHistoryVersion[];
-}
-
-export interface FileHistoryVersion {
-  versionId: string;
-  createdAt: number;
-  byteSize: number;
-  contentHash: string;
-  source: string;
-  snapshotFile: string;
-}
-
-export interface SnapshotBeforeWriteInput {
-  targetPath: string;
-  nextContent: string;
-  source: string;
-}
-
-export interface FileHistoryStoreOptions {
-  config?: FileStorageConfig;
-}
-
-export class FileHistoryStore {
-  private readonly config: FileStorageConfig;
-
-  constructor(options: FileHistoryStoreOptions = {}) {
-    this.config = options.config ?? getFileStorageConfig();
-  }
-
-  async snapshotBeforeWrite(input: SnapshotBeforeWriteInput): Promise<FileHistoryVersion | null> {
-    if (!this.config.historyEnabled) {
-      return null;
-    }
-
-    const targetPath = this.normalizeTargetPath(input.targetPath);
-    let currentContent: string;
-    try {
-      currentContent = await fs.readFile(targetPath, 'utf8');
-    } catch (error) {
-      if (this.isNotFoundError(error)) {
-        return null;
-      }
-      throw error;
-    }
-
-    if (currentContent === input.nextContent) {
-      return null;
-    }
-
-    const manifest = (await this.loadManifest(targetPath)) || this.createManifest(targetPath);
-    const createdAt = Date.now();
-    const versionId = `v_${createdAt}_${randomUUID().slice(0, 8)}`;
-    const version: FileHistoryVersion = {
-      versionId,
-      createdAt,
-      byteSize: Buffer.byteLength(currentContent, 'utf8'),
-      contentHash: createHash('sha256').update(currentContent).digest('hex'),
-      source: input.source,
-      snapshotFile: path.join(manifest.pathKey, `${versionId}.snapshot`),
-    };
-
-    await this.writeSnapshot(version.snapshotFile, currentContent);
-    manifest.versions.push(version);
-
-    await this.pruneManifest(manifest);
-    await this.saveManifest(manifest);
-    await this.pruneTotalSize();
-
-    return version;
-  }
-
-  async listVersions(targetPath: string): Promise<FileHistoryVersion[]> {
-    const manifest = await this.loadManifest(targetPath);
-    return manifest
-      ? [...manifest.versions].sort((left, right) => right.createdAt - left.createdAt)
-      : [];
-  }
-
-  async restoreVersion(targetPath: string, versionId: string): Promise<boolean> {
-    const normalizedTargetPath = this.normalizeTargetPath(targetPath);
-    const manifest = await this.loadManifest(normalizedTargetPath);
-    if (!manifest) {
-      return false;
-    }
-
-    const version = manifest.versions.find((entry) => entry.versionId === versionId);
-    if (!version) {
-      return false;
-    }
-
-    const snapshotPath = this.resolveSnapshotPath(version.snapshotFile);
-    const content = await fs.readFile(snapshotPath, 'utf8');
-    await this.snapshotBeforeWrite({
-      targetPath: normalizedTargetPath,
-      nextContent: content,
-      source: 'file_history_restore',
-    });
-    await writeTextFileAtomically(normalizedTargetPath, content);
-    return true;
-  }
-
-  private createManifest(targetPath: string): FileHistoryManifest {
-    return {
-      schemaVersion: 1,
-      targetPath,
-      pathKey: this.pathKey(targetPath),
-      versions: [],
-    };
-  }
-
-  private async loadManifest(targetPath: string): Promise<FileHistoryManifest | null> {
-    const resolvedTargetPath = this.normalizeTargetPath(targetPath);
-    const manifestPath = this.manifestPathByTarget(resolvedTargetPath);
-    return readJsonFileIfExists<FileHistoryManifest>(manifestPath);
-  }
-
-  private async saveManifest(manifest: FileHistoryManifest): Promise<void> {
-    await writeJsonFileAtomically(this.manifestPath(manifest.pathKey), manifest);
-  }
-
-  private async writeSnapshot(snapshotFile: string, content: string): Promise<void> {
-    const snapshotPath = this.resolveSnapshotPath(snapshotFile);
-    await writeTextFileAtomically(snapshotPath, content);
-  }
-
-  private async pruneManifest(manifest: FileHistoryManifest): Promise<void> {
-    let versions = [...manifest.versions].sort((left, right) => left.createdAt - right.createdAt);
-    const maxPerFile = this.config.historyMaxPerFile;
-    const maxAgeDays = this.config.historyMaxAgeDays;
-
-    if (maxAgeDays > 0) {
-      const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
-      const removed = versions.filter((entry) => entry.createdAt < cutoff);
-      versions = versions.filter((entry) => entry.createdAt >= cutoff);
-      await this.deleteSnapshots(removed);
-    }
-
-    if (maxPerFile > 0 && versions.length > maxPerFile) {
-      const overflow = versions.length - maxPerFile;
-      const removed = versions.slice(0, overflow);
-      versions = versions.slice(overflow);
-      await this.deleteSnapshots(removed);
-    }
-
-    manifest.versions = versions;
-  }
-
-  private async pruneTotalSize(): Promise<void> {
-    const maxTotalBytes = this.config.historyMaxTotalBytes;
-    if (maxTotalBytes <= 0) {
-      return;
-    }
-
-    const manifestsDir = this.manifestsDir();
-    let manifestFiles: string[] = [];
-    try {
-      manifestFiles = await fs.readdir(manifestsDir);
-    } catch (error) {
-      if (this.isNotFoundError(error)) {
-        return;
-      }
-      throw error;
-    }
-
-    const manifests = (
-      await Promise.all(
-        manifestFiles
-          .filter((entry) => entry.endsWith('.json'))
-          .map(async (entry) =>
-            readJsonFileIfExists<FileHistoryManifest>(path.join(manifestsDir, entry))
-          )
-      )
-    ).filter((manifest): manifest is FileHistoryManifest => manifest !== null);
-
-    const allVersions = manifests
-      .flatMap((manifest) =>
-        manifest.versions.map((version) => ({
-          manifest,
-          version,
-        }))
-      )
-      .sort((left, right) => left.version.createdAt - right.version.createdAt);
-
-    let totalBytes = allVersions.reduce((sum, item) => sum + item.version.byteSize, 0);
-    if (totalBytes <= maxTotalBytes) {
-      return;
-    }
-
-    const removals = new Map<string, Set<string>>();
-    const snapshotsToDelete: FileHistoryVersion[] = [];
-
-    for (const item of allVersions) {
-      if (totalBytes <= maxTotalBytes) {
-        break;
-      }
-      totalBytes -= item.version.byteSize;
-      snapshotsToDelete.push(item.version);
-      const manifestRemovals = removals.get(item.manifest.pathKey) || new Set<string>();
-      manifestRemovals.add(item.version.versionId);
-      removals.set(item.manifest.pathKey, manifestRemovals);
-    }
-
-    await this.deleteSnapshots(snapshotsToDelete);
-
-    await Promise.all(
-      manifests.map(async (manifest) => {
-        const manifestRemovals = removals.get(manifest.pathKey);
-        if (!manifestRemovals || manifestRemovals.size === 0) {
-          return;
-        }
-        manifest.versions = manifest.versions.filter(
-          (version) => !manifestRemovals.has(version.versionId)
-        );
-        await this.saveManifest(manifest);
-      })
-    );
-  }
-
-  private async deleteSnapshots(versions: FileHistoryVersion[]): Promise<void> {
-    await Promise.all(
-      versions.map((version) =>
-        fs.rm(this.resolveSnapshotPath(version.snapshotFile), { force: true })
-      )
-    );
-  }
-
-  private manifestPathByTarget(targetPath: string): string {
-    return this.manifestPath(this.pathKey(targetPath));
-  }
-
-  private manifestPath(pathKey: string): string {
-    return path.join(this.manifestsDir(), `${pathKey}.json`);
-  }
-
-  private manifestsDir(): string {
-    return path.join(this.config.historyDir, 'manifests');
-  }
-
-  private resolveSnapshotPath(snapshotFile: string): string {
-    return path.join(this.config.historyDir, 'snapshots', snapshotFile);
-  }
-
-  private pathKey(targetPath: string): string {
-    return createHash('sha256')
-      .update(this.normalizeTargetPath(targetPath))
-      .digest('hex')
-      .slice(0, 24);
-  }
-
-  private normalizeTargetPath(targetPath: string): string {
-    const absolute = path.resolve(targetPath);
-    try {
-      return syncFs.realpathSync(absolute);
-    } catch (error) {
-      const nodeError = error as NodeJS.ErrnoException;
-      if (nodeError.code !== 'ENOENT' && nodeError.code !== 'ENOTDIR') {
-        return absolute;
-      }
-    }
-
-    let current = absolute;
-    const trailingSegments: string[] = [];
-
-    for (;;) {
-      try {
-        const realCurrent = syncFs.realpathSync(current);
-        if (trailingSegments.length === 0) {
-          return realCurrent;
-        }
-        return path.join(realCurrent, ...trailingSegments.reverse());
-      } catch (error) {
-        const nodeError = error as NodeJS.ErrnoException;
-        if (nodeError.code !== 'ENOENT' && nodeError.code !== 'ENOTDIR') {
-          return absolute;
-        }
-        const parent = path.dirname(current);
-        if (parent === current) {
-          return absolute;
-        }
-        trailingSegments.push(path.basename(current));
-        current = parent;
-      }
-    }
-  }
-
-  private isNotFoundError(error: unknown): boolean {
-    return (
-      typeof error === 'object' &&
-      error !== null &&
-      'code' in error &&
-      (error as { code?: string }).code === 'ENOENT'
-    );
-  }
-}
-
-export function createConfiguredFileHistoryStore(): FileHistoryStore {
-  return new FileHistoryStore();
-}

package/vendor/agent-root/src/agent/storage/file-storage-config.ts

@@ -1,94 +0,0 @@
-import * as path from 'node:path';
-import { resolveRenxStorageRoot } from '../../config/paths';
-
-export const AGENT_FILE_HISTORY_ENABLED_ENV = 'AGENT_FILE_HISTORY_ENABLED';
-export const AGENT_FILE_HISTORY_MAX_PER_FILE_ENV = 'AGENT_FILE_HISTORY_MAX_PER_FILE';
-export const AGENT_FILE_HISTORY_MAX_AGE_DAYS_ENV = 'AGENT_FILE_HISTORY_MAX_AGE_DAYS';
-export const AGENT_FILE_HISTORY_MAX_TOTAL_MB_ENV = 'AGENT_FILE_HISTORY_MAX_TOTAL_MB';
-
-const DEFAULT_WRITE_BUFFER_SUBDIR = path.join('cache', 'write-buffer');
-const DEFAULT_HISTORY_SUBDIR = path.join('history', 'file-versions');
-const DEFAULT_HISTORY_ENABLED = true;
-const DEFAULT_HISTORY_MAX_PER_FILE = 20;
-const DEFAULT_HISTORY_MAX_AGE_DAYS = 14;
-const DEFAULT_HISTORY_MAX_TOTAL_MB = 500;
-
-export interface FileStorageConfig {
-  rootDir: string;
-  writeBufferDir: string;
-  historyDir: string;
-  historyEnabled: boolean;
-  historyMaxPerFile: number;
-  historyMaxAgeDays: number;
-  historyMaxTotalBytes: number;
-}
-
-function parseBoolean(raw: string | undefined, fallback: boolean): boolean {
-  if (!raw || raw.trim().length === 0) {
-    return fallback;
-  }
-
-  const normalized = raw.trim().toLowerCase();
-  if (['1', 'true', 'yes', 'on'].includes(normalized)) {
-    return true;
-  }
-  if (['0', 'false', 'no', 'off'].includes(normalized)) {
-    return false;
-  }
-  return fallback;
-}
-
-function parseNonNegativeInteger(raw: string | undefined, fallback: number): number {
-  if (!raw || raw.trim().length === 0) {
-    return fallback;
-  }
-
-  const parsed = Number.parseInt(raw.trim(), 10);
-  if (!Number.isFinite(parsed) || parsed < 0) {
-    return fallback;
-  }
-  return parsed;
-}
-
-export function getFileStorageConfig(): FileStorageConfig {
-  const rootDir = resolveRenxStorageRoot(process.env);
-  const writeBufferDir = path.join(rootDir, DEFAULT_WRITE_BUFFER_SUBDIR);
-  const historyDir = path.join(rootDir, DEFAULT_HISTORY_SUBDIR);
-  const historyEnabled = parseBoolean(
-    process.env[AGENT_FILE_HISTORY_ENABLED_ENV],
-    DEFAULT_HISTORY_ENABLED
-  );
-  const historyMaxPerFile = parseNonNegativeInteger(
-    process.env[AGENT_FILE_HISTORY_MAX_PER_FILE_ENV],
-    DEFAULT_HISTORY_MAX_PER_FILE
-  );
-  const historyMaxAgeDays = parseNonNegativeInteger(
-    process.env[AGENT_FILE_HISTORY_MAX_AGE_DAYS_ENV],
-    DEFAULT_HISTORY_MAX_AGE_DAYS
-  );
-  const historyMaxTotalMb = parseNonNegativeInteger(
-    process.env[AGENT_FILE_HISTORY_MAX_TOTAL_MB_ENV],
-    DEFAULT_HISTORY_MAX_TOTAL_MB
-  );
-
-  return {
-    rootDir,
-    writeBufferDir,
-    historyDir,
-    historyEnabled,
-    historyMaxPerFile,
-    historyMaxAgeDays,
-    historyMaxTotalBytes: historyMaxTotalMb * 1024 * 1024,
-  };
-}
-
-export function resolveWriteBufferBaseDir(override?: string): string {
-  if (override && override.trim().length > 0) {
-    return path.resolve(override);
-  }
-  return getFileStorageConfig().writeBufferDir;
-}
-
-export function getWriteBufferCandidateDirs(primaryDir?: string): string[] {
-  return [resolveWriteBufferBaseDir(primaryDir)];
-}

package/vendor/agent-root/src/agent/storage/file-system.ts

@@ -1,31 +0,0 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { randomUUID } from 'node:crypto';
-
-export async function writeTextFileAtomically(targetPath: string, content: string): Promise<void> {
-  await fs.mkdir(path.dirname(targetPath), { recursive: true });
-  const tempPath = `${targetPath}.tmp.${randomUUID().slice(0, 8)}`;
-  await fs.writeFile(tempPath, content, 'utf8');
-  await fs.rename(tempPath, targetPath);
-}
-
-export async function writeJsonFileAtomically(targetPath: string, value: unknown): Promise<void> {
-  await writeTextFileAtomically(targetPath, JSON.stringify(value, null, 2));
-}
-
-export async function readJsonFileIfExists<T>(targetPath: string): Promise<T | null> {
-  try {
-    const content = await fs.readFile(targetPath, 'utf8');
-    return JSON.parse(content) as T;
-  } catch (error) {
-    if (
-      typeof error === 'object' &&
-      error !== null &&
-      'code' in error &&
-      (error as { code?: string }).code === 'ENOENT'
-    ) {
-      return null;
-    }
-    throw error;
-  }
-}

package/vendor/agent-root/src/agent/storage/file-write-service.ts

@@ -1,21 +0,0 @@
-import { createConfiguredFileHistoryStore, FileHistoryStore } from './file-history-store';
-import { writeTextFileAtomically } from './file-system';
-
-export interface WriteTextFileWithHistoryOptions {
-  source: string;
-  historyStore?: FileHistoryStore;
-}
-
-export async function writeTextFileWithHistory(
-  targetPath: string,
-  content: string,
-  options: WriteTextFileWithHistoryOptions
-): Promise<void> {
-  const historyStore = options.historyStore ?? createConfiguredFileHistoryStore();
-  await historyStore.snapshotBeforeWrite({
-    targetPath,
-    nextContent: content,
-    source: options.source,
-  });
-  await writeTextFileAtomically(targetPath, content);
-}