@renxqoo/renx-code 0.0.4 → 0.0.6

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

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

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

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

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

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