@chen-rmag/core-infra 1.0.0

package/src/repositories/DirectoryRepository.ts

@@ -0,0 +1,393 @@
+import { BaseRepository } from './BaseRepository';
+import { DirectoryInfo, TestDirectory, TestCase } from '../types';
+import { join, dirname } from 'path';
+import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, readdirSync, renameSync, statSync } from 'fs';
+import { validateDirectoryName, validateDirectoryPath } from '../directory-validator';
+
+/**
+ * DirectoryRepository handles all storage operations for test case directories
+ * Manages the hierarchical organization of test cases (up to 3 levels)
+ * Each directory can have an info.json file with metadata (description, createdAt, etc.)
+ */
+export class DirectoryRepository extends BaseRepository {
+  constructor(projectId: string) {
+    super(join("projects", projectId, 'tests'));
+  }
+
+  /**
+   * Create a new directory at the specified path
+   * @param path - Directory path like 'folder1' or 'folder1/subfolder' (max 3 levels)
+   * @param info - Directory metadata
+   */
+  createDirectory(path: string, info: Omit<DirectoryInfo, 'id' | 'path'>): DirectoryInfo {
+    // Validate path
+    const validation = validateDirectoryPath(path);
+    if (!validation.valid) {
+      throw new Error(validation.error);
+    }
+
+    const fullPath = join(this.getBaseDir(), path);
+
+    // Check if directory already exists
+    if (existsSync(fullPath)) {
+      throw new Error(`Directory already exists: ${path}`);
+    }
+
+    // Create directory
+    mkdirSync(fullPath, { recursive: true });
+
+    // Create directory info
+    const directoryInfo: DirectoryInfo = {
+      id: `dir_${Date.now()}`,
+      name: path.split('/').pop() || path,
+      description: info.description,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    };
+
+    // Save info.json
+    this.saveDirectoryInfo(path, directoryInfo);
+
+    return directoryInfo;
+  }
+
+  /**
+   * Get directory info from info.json
+   */
+  getDirectoryInfo(path: string): DirectoryInfo | null {
+    const infoPath = join(this.getBaseDir(), path, 'info.json');
+    if (!existsSync(infoPath)) {
+      return null;
+    }
+
+    try {
+      const content = readFileSync(infoPath, 'utf-8');
+      return JSON.parse(content) as DirectoryInfo;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Update directory metadata
+   */
+  updateDirectoryInfo(path: string, updates: Partial<Omit<DirectoryInfo, 'id' | 'path'>>): DirectoryInfo {
+    const existing = this.getDirectoryInfo(path);
+    if (!existing) {
+      throw new Error(`Directory does not exist: ${path}`);
+    }
+
+    const updated: DirectoryInfo = {
+      ...existing,
+      ...updates,
+      updatedAt: Date.now(),
+    };
+
+    this.saveDirectoryInfo(path, updated);
+    return updated;
+  }
+
+  /**
+   * Delete a directory (must be empty)
+   */
+  deleteDirectory(path: string): void {
+    const fullPath = join(this.getBaseDir(), path);
+
+    if (!existsSync(fullPath)) {
+      throw new Error(`Directory does not exist: ${path}`);
+    }
+
+    // Delete the directory
+    rmSync(fullPath, { recursive: true, force: true });
+  }
+
+  /**
+   * Rename a directory
+   */
+  renameDirectory(oldPath: string, newName: string): DirectoryInfo {
+    // Validate new name
+    const nameValidation = validateDirectoryName(newName);
+    if (!nameValidation.valid) {
+      throw new Error(nameValidation.error);
+    }
+
+    const oldFullPath = join(this.getBaseDir(), oldPath);
+    const parentPath = oldPath.split('/').slice(0, -1).join('/');
+    const newPath = parentPath ? `${parentPath}/${newName}` : newName;
+    const newFullPath = join(this.getBaseDir(), newPath);
+
+    if (!existsSync(oldFullPath)) {
+      throw new Error(`Directory does not exist: ${oldPath}`);
+    }
+
+    if (existsSync(newFullPath)) {
+      throw new Error(`Directory already exists: ${newPath}`);
+    }
+
+    // Rename directory
+    renameSync(oldFullPath, newFullPath);
+
+    // Update all test cases in the renamed directory and its subdirectories
+    this.updateTestPathsRecursively(newFullPath, oldPath, newPath);
+
+    // Update info.json
+    const dirInfo = this.getDirectoryInfo(newPath);
+    if (dirInfo) {
+      dirInfo.name = newName;
+      dirInfo.updatedAt = Date.now();
+      this.saveDirectoryInfo(newPath, dirInfo);
+    }
+
+    return dirInfo || { id: '', name: newName, createdAt: Date.now(), updatedAt: Date.now() };
+  }
+
+  /**
+   * Build the complete directory tree with tests
+   * This is the main method to get the hierarchical structure
+   */
+  buildDirectoryTree(basePath: string = ''): TestDirectory {
+    const fullPath = join(this.getBaseDir(), basePath);
+
+    // Ensure directory exists
+    if (!existsSync(fullPath)) {
+      mkdirSync(fullPath, { recursive: true });
+    }
+
+    const pathParts = basePath ? basePath.split('/') : [];
+    const name = pathParts.length > 0 ? pathParts[pathParts.length - 1] : 'root';
+
+    const infoData = basePath ? this.getDirectoryInfo(basePath) : null;
+    const info = infoData || undefined;
+
+    const tree: TestDirectory = {
+      path: basePath,
+      name,
+      info,
+      children: [],
+      tests: [],
+    };
+
+    try {
+      const items = readdirSync(fullPath);
+
+      for (const item of items) {
+        const itemPath = join(fullPath, item);
+        const stat = statSync(itemPath);
+
+        if (stat.isDirectory() && item !== 'info.json') {
+          const subPath = basePath ? `${basePath}/${item}` : item;
+
+          // Check depth (max 3 levels)
+          if (subPath.split('/').length <= 3) {
+            tree.children.push(this.buildDirectoryTree(subPath));
+          }
+        }
+      }
+
+      // Load test files (only .json files that are test cases)
+      for (const item of items) {
+        if (item.endsWith('.json') && item !== 'info.json') {
+          const testPath = join(fullPath, item);
+          try {
+            const content = readFileSync(testPath, 'utf-8');
+            const testCase = JSON.parse(content) as TestCase;
+            // Only add tests that belong to this directory (no path or matching path)
+            if (testCase.path === basePath) {
+              tree.tests.push(testCase);
+            }
+          } catch {
+            // Skip invalid test files
+          }
+        }
+      }
+
+      // Sort children by name
+      tree.children.sort((a, b) => a.name.localeCompare(b.name));
+      // Sort tests by creation date (newest first)
+      tree.tests.sort((a, b) => b.createdAt - a.createdAt);
+    } catch {
+      // Return empty tree if unable to read directory
+    }
+
+    return tree;
+  }
+
+  /**
+   * Get all directories at a specific level (flat list)
+   */
+  getDirectoriesAtPath(path: string = ''): DirectoryInfo[] {
+    const fullPath = join(this.getBaseDir(), path);
+
+    if (!existsSync(fullPath)) {
+      return [];
+    }
+
+    const directories: DirectoryInfo[] = [];
+
+    try {
+      const items = readdirSync(fullPath);
+
+      for (const item of items) {
+        const itemPath = join(fullPath, item);
+        const stat = statSync(itemPath);
+
+        if (stat.isDirectory() && item !== 'info.json') {
+          const subPath = path ? `${path}/${item}` : item;
+          const info = this.getDirectoryInfo(subPath);
+
+          if (info) {
+            directories.push(info);
+          }
+        }
+      }
+    } catch {
+      // Return empty array if unable to read directory
+    }
+
+    return directories.sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  /**
+   * Check if a path is valid (exists and is a directory)
+   */
+  isValidDirectory(path: string): boolean {
+    const fullPath = join(this.getBaseDir(), path);
+    return existsSync(fullPath) && statSync(fullPath).isDirectory();
+  }
+
+  /**
+   * Move a directory to a new parent directory
+   * @param sourcePath - The current directory path
+   * @param targetParentPath - The target parent directory path (or empty string for root)
+   */
+  moveDirectory(sourcePath: string, targetParentPath: string): DirectoryInfo {
+    const sourceFullPath = join(this.getBaseDir(), sourcePath);
+    const directoryName = sourcePath.split('/').pop() || sourcePath;
+    
+    // Validate paths
+    if (!existsSync(sourceFullPath)) {
+      throw new Error(`Source directory does not exist: ${sourcePath}`);
+    }
+
+    const targetPath = targetParentPath ? `${targetParentPath}/${directoryName}` : directoryName;
+    const targetFullPath = join(this.getBaseDir(), targetPath);
+
+    // Check if target already exists
+    if (existsSync(targetFullPath)) {
+      throw new Error(`Target path already exists: ${targetPath}`);
+    }
+
+    // Validate target path
+    const pathValidation = validateDirectoryPath(targetPath);
+    if (!pathValidation.valid) {
+      throw new Error(pathValidation.error);
+    }
+
+    // Ensure target parent directory exists
+    const targetParentFullPath = dirname(targetFullPath);
+    if (!existsSync(targetParentFullPath)) {
+      mkdirSync(targetParentFullPath, { recursive: true });
+    }
+
+    // Move the directory
+    renameSync(sourceFullPath, targetFullPath);
+
+    // Update all test cases in the moved directory and its subdirectories
+    this.updateTestPathsRecursively(targetFullPath, sourcePath, targetPath);
+
+    // Get the directory info
+    const dirInfo = this.getDirectoryInfo(targetPath);
+    return dirInfo || { id: '', name: directoryName, createdAt: Date.now(), updatedAt: Date.now() };
+  }
+
+  /**
+   * Recursively update the path field in all test case JSON files
+   * @param dirFullPath - Full filesystem path to the directory
+   * @param oldBasePath - Old logical path (e.g., 'folder1/subfolder')
+   * @param newBasePath - New logical path (e.g., 'folder2/subfolder')
+   */
+  private updateTestPathsRecursively(dirFullPath: string, oldBasePath: string, newBasePath: string): void {
+    if (!existsSync(dirFullPath)) {
+      return;
+    }
+
+    try {
+      const items = readdirSync(dirFullPath);
+
+      for (const item of items) {
+        const itemPath = join(dirFullPath, item);
+        const stat = statSync(itemPath);
+
+        if (stat.isDirectory() && item !== 'info.json') {
+          // Recursively update subdirectories
+          this.updateTestPathsRecursively(itemPath, oldBasePath, newBasePath);
+        } else if (item.endsWith('.json') && item !== 'info.json') {
+          // Update test case file
+          try {
+            const content = readFileSync(itemPath, 'utf-8');
+            const testCase = JSON.parse(content) as TestCase;
+            
+            // Update the path field if it starts with the old base path
+            if (testCase.path && testCase.path.startsWith(oldBasePath)) {
+              const relativePath = testCase.path.substring(oldBasePath.length);
+              testCase.path = newBasePath + relativePath;
+              
+              // Save the updated test case
+              writeFileSync(itemPath, JSON.stringify(testCase, null, 2), 'utf-8');
+            }
+          } catch (error) {
+            console.error(`Failed to update test case ${item}:`, error);
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`Failed to update test paths in ${dirFullPath}:`, error);
+    }
+  }
+
+  /**
+   * Move a test case to a different directory
+   * @param testId - The test case ID
+   * @param sourceDir - The current directory path
+   * @param targetDir - The target directory path
+   */
+  moveTestCase(testId: string, sourceDir: string, targetDir: string): boolean {
+    const sourceFile = join(this.getBaseDir(), sourceDir, `${testId}.json`);
+    const targetFile = join(this.getBaseDir(), targetDir, `${testId}.json`);
+
+    // Check if source file exists
+    if (!existsSync(sourceFile)) {
+      throw new Error(`Test case file does not exist: ${sourceFile}`);
+    }
+
+    // Check if target directory exists
+    const targetDirFullPath = join(this.getBaseDir(), targetDir);
+    if (!existsSync(targetDirFullPath)) {
+      throw new Error(`Target directory does not exist: ${targetDir}`);
+    }
+
+    // Check if file already exists in target
+    if (existsSync(targetFile)) {
+      throw new Error(`Test case already exists in target directory`);
+    }
+
+    // Move the file
+    renameSync(sourceFile, targetFile);
+    return true;
+  }
+
+  /**
+   * Save directory info to info.json
+   */
+  private saveDirectoryInfo(path: string, info: DirectoryInfo): void {
+    const infoPath = join(this.getBaseDir(), path, 'info.json');
+
+    // Ensure parent directory exists
+    const dir = dirname(infoPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+
+    writeFileSync(infoPath, JSON.stringify(info, null, 2), 'utf-8');
+  }
+}

package/src/repositories/ExplorationRepository.ts

@@ -0,0 +1,57 @@
+import { join } from 'path';
+import { BaseRepository } from './BaseRepository';
+import { ExplorationRecord } from '../types';
+
+/**
+ * ExplorationRepository handles all storage operations for exploration records
+ * Responsible for managing web exploration and test generation history
+ */
+export class ExplorationRepository extends BaseRepository {
+    constructor(projectId: string) {
+    super(join("projects", projectId, 'explorations'));
+  }
+
+  /**
+   * Save an exploration record
+   */
+  async saveExplorationRecord(record: ExplorationRecord): Promise<void> {
+    await this.save(record.id, record, 'json');
+  }
+
+  /**
+   * Load an exploration record by ID
+   */
+  async loadExplorationRecord(recordId: string): Promise<ExplorationRecord | null> {
+    return this.load<ExplorationRecord>(recordId, 'json');
+  }
+
+  /**
+   * List all exploration records sorted by start time (newest first)
+   */
+  async listExplorationRecords(): Promise<ExplorationRecord[]> {
+    const records = await this.listAll<ExplorationRecord>();
+    return records.sort((a, b) => b.startedAt - a.startedAt);
+  }
+
+  /**
+   * Update an exploration record
+   */
+  async updateExplorationRecord(record: ExplorationRecord): Promise<void> {
+    await this.saveExplorationRecord(record);
+  }
+
+  /**
+   * Delete an exploration record
+   */
+  async deleteExplorationRecord(recordId: string): Promise<void> {
+    await this.delete(recordId, 'json');
+  }
+
+  /**
+   * Get exploration records for a specific URL
+   */
+  async getRecordsByUrl(url: string): Promise<ExplorationRecord[]> {
+    const records = await this.listExplorationRecords();
+    return records.filter(r => r.url === url);
+  }
+}

package/src/repositories/FileRepository.ts

@@ -0,0 +1,153 @@
+import { existsSync, mkdirSync, readdirSync, unlinkSync, readFileSync, writeFileSync, statSync, rmSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const STORAGE_DIR = join(homedir(), '.test_agent');
+
+export interface FileInfo {
+  name: string;
+  size: number;
+  uploadedAt: string;
+  path: string;
+}
+
+/**
+ * FileRepository - Handles file storage for test cases
+ * Each test case has its own files directory
+ */
+export class FileRepository {
+  private projectId: string;
+  private filesBaseDir: string;
+
+  constructor(projectId: string) {
+    this.projectId = projectId;
+    this.filesBaseDir = join(STORAGE_DIR, 'projects', projectId, 'files');
+    this.ensureBaseDir();
+  }
+
+  /**
+   * Ensure base files directory exists
+   */
+  private ensureBaseDir(): void {
+    if (!existsSync(this.filesBaseDir)) {
+      mkdirSync(this.filesBaseDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Get files directory for a specific test case
+   */
+  getTestFilesDir(testId: string): string {
+    return join(this.filesBaseDir, testId);
+  }
+
+  /**
+   * Ensure test files directory exists
+   */
+  private ensureTestFilesDir(testId: string): void {
+    const dir = this.getTestFilesDir(testId);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  /**
+   * Save a file for a test case
+   */
+  saveFile(testId: string, fileName: string, content: Buffer): FileInfo {
+    this.ensureTestFilesDir(testId);
+    const filePath = join(this.getTestFilesDir(testId), fileName);
+
+    writeFileSync(filePath, content);
+
+    const stats = statSync(filePath);
+    return {
+      name: fileName,
+      size: stats.size,
+      uploadedAt: new Date().toISOString(),
+      path: filePath,
+    };
+  }
+
+  /**
+   * Load a file for a test case
+   */
+  loadFile(testId: string, fileName: string): Buffer | null {
+    const filePath = join(this.getTestFilesDir(testId), fileName);
+    if (!existsSync(filePath)) {
+      return null;
+    }
+    return readFileSync(filePath);
+  }
+
+  /**
+   * List all files for a test case
+   */
+  listFiles(testId: string): FileInfo[] {
+    const dir = this.getTestFilesDir(testId);
+    if (!existsSync(dir)) {
+      return [];
+    }
+
+    const files = readdirSync(dir);
+    return files.map(fileName => {
+      const filePath = join(dir, fileName);
+      const stats = statSync(filePath);
+      return {
+        name: fileName,
+        size: stats.size,
+        uploadedAt: stats.mtime.toISOString(),
+        path: filePath,
+      };
+    });
+  }
+
+  /**
+   * Delete a file for a test case
+   */
+  deleteFile(testId: string, fileName: string): boolean {
+    const filePath = join(this.getTestFilesDir(testId), fileName);
+    if (!existsSync(filePath)) {
+      return false;
+    }
+    unlinkSync(filePath);
+    return true;
+  }
+
+  /**
+   * Delete all files for a test case
+   */
+  deleteAllFiles(testId: string): void {
+    const dir = this.getTestFilesDir(testId);
+    if (!existsSync(dir)) {
+      return;
+    }
+    rmSync(dir, { recursive: true });
+  }
+
+  /**
+   * Check if a file exists
+   */
+  fileExists(testId: string, fileName: string): boolean {
+    const filePath = join(this.getTestFilesDir(testId), fileName);
+    return existsSync(filePath);
+  }
+
+  /**
+   * Get file info
+   */
+  getFileInfo(testId: string, fileName: string): FileInfo | null {
+    const filePath = join(this.getTestFilesDir(testId), fileName);
+    if (!existsSync(filePath)) {
+      return null;
+    }
+
+    const stats = statSync(filePath);
+    return {
+      name: fileName,
+      size: stats.size,
+      uploadedAt: stats.mtime.toISOString(),
+      path: filePath,
+    };
+  }
+}

package/src/repositories/ModelConfigRepository.ts

@@ -0,0 +1,55 @@
+import { BaseRepository } from './BaseRepository';
+import { ModelConfig } from '../types';
+
+/**
+ * ModelConfigRepository handles all storage operations for model configurations
+ * Responsible for managing AI model settings and credentials
+ */
+export class ModelConfigRepository extends BaseRepository {
+  constructor() {
+    super('models');
+  }
+
+  /**
+   * Save a model configuration
+   */
+  async saveModelConfig(config: ModelConfig): Promise<void> {
+    await this.save(config.id, config, 'json');
+  }
+
+  /**
+   * Load a model configuration by ID
+   */
+  async loadModelConfig(configId: string): Promise<ModelConfig | null> {
+    return this.load<ModelConfig>(configId, 'json');
+  }
+
+  /**
+   * List all model configurations sorted by update time (newest first)
+   */
+  async listModelConfigs(): Promise<ModelConfig[]> {
+    const configs = await this.listAll<ModelConfig>();
+    return configs.sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+
+  /**
+   * Update a model configuration
+   */
+  async updateModelConfig(config: ModelConfig): Promise<void> {
+    await this.saveModelConfig(config);
+  }
+
+  /**
+   * Delete a model configuration
+   */
+  async deleteModelConfig(configId: string): Promise<void> {
+    await this.delete(configId, 'json');
+  }
+
+  /**
+   * Check if a model configuration exists
+   */
+  async exists(configId: string): Promise<boolean> {
+    return this.existsSync(configId, 'json');
+  }
+}