@chen-rmag/core-infra 1.0.0

package/src/repositories/TestPlanRepository.ts

@@ -0,0 +1,89 @@
+import { BaseRepository } from './BaseRepository';
+import { TestPlan } from '../types';
+import { join } from 'path';
+import { existsSync, readdirSync } from 'fs';
+
+/**
+ * TestPlanRepository handles all storage operations for test plans
+ * Responsible for managing test plan data
+ * Data stored in: ~/.test_agent/projects/{projectId}/test_plans/
+ */
+export class TestPlanRepository extends BaseRepository {
+  constructor(projectId: string) {
+    super(join('projects', projectId, 'test_plans'));
+  }
+
+  /**
+   * Save a test plan
+   */
+  saveTestPlan(testPlan: TestPlan): void {
+    this.saveSync(testPlan.id, testPlan);
+  }
+
+  /**
+   * Load a test plan by ID
+   */
+  loadTestPlan(testPlanId: string): TestPlan | null {
+    return this.loadSync<TestPlan>(testPlanId);
+  }
+
+  /**
+   * List all test plans
+   */
+  listTestPlans(): TestPlan[] {
+    const baseDir = this.getBaseDir();
+    if (!existsSync(baseDir)) {
+      return [];
+    }
+
+    const files = readdirSync(baseDir);
+    const testPlans: TestPlan[] = [];
+
+    for (const file of files) {
+      if (file.endsWith('.json')) {
+        const testPlanId = file.replace('.json', '');
+        const testPlan = this.loadTestPlan(testPlanId);
+        if (testPlan) {
+          testPlans.push(testPlan);
+        }
+      }
+    }
+
+    // Sort by updatedAt descending
+    testPlans.sort((a, b) => b.updatedAt - a.updatedAt);
+
+    return testPlans;
+  }
+
+  /**
+   * Update a test plan
+   */
+  updateTestPlan(testPlan: TestPlan): void {
+    const existing = this.loadTestPlan(testPlan.id);
+    if (!existing) {
+      throw new Error(`Test plan with ID ${testPlan.id} not found`);
+    }
+
+    const updated: TestPlan = {
+      ...existing,
+      ...testPlan,
+      updatedAt: Date.now(),
+    };
+
+    this.saveSync(updated.id, updated);
+  }
+
+  /**
+   * Delete a test plan
+   */
+  deleteTestPlan(testPlanId: string): void {
+    this.deleteSync(testPlanId);
+  }
+
+  /**
+   * Check if a test plan exists
+   */
+  exists(testPlanId: string): boolean {
+    return this.existsSync(testPlanId);
+  }
+}

package/src/repositories/TestResultRepository.ts

@@ -0,0 +1,56 @@
+import { join } from 'path';
+import { BaseRepository } from './BaseRepository';
+import { TestResult } from '../types';
+
+/**
+ * TestResultRepository handles all storage operations for test results
+ * Responsible for managing test execution results and history
+ */
+export class TestResultRepository extends BaseRepository {
+    constructor(projectId: string) {
+    super(join("projects", projectId, 'results'));
+  }
+
+  /**
+   * Save a test result
+   */
+  async saveTestResult(result: TestResult): Promise<void> {
+    await this.save(result.id, result, 'json');
+  }
+
+  /**
+   * Load a test result by ID
+   */
+  async loadTestResult(resultId: string): Promise<TestResult | null> {
+    return this.load<TestResult>(resultId, 'json');
+  }
+
+  /**
+   * Load all results for a specific test case
+   */
+  async loadTestResults(testId: string): Promise<TestResult[]> {
+    const results = await this.listAll<TestResult>();
+    return results
+      .filter(r => r.testId === testId)
+      .sort((a, b) => b.executedAt - a.executedAt);
+  }
+
+  /**
+   * Delete a test result
+   */
+  async deleteTestResult(resultId: string): Promise<void> {
+    await this.delete(resultId, 'json');
+  }
+
+  /**
+   * Delete all results for a specific test case
+   */
+  async deleteTestResults(testId: string): Promise<void> {
+    const results = await this.listAll<TestResult>();
+    for (const result of results) {
+      if (result.testId === testId) {
+        await this.delete(result.id, 'json');
+      }
+    }
+  }
+}

package/src/repositories/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Repository layer
+ * Provides separated data access concerns for different business entities
+ * Following Repository Pattern to decouple business logic from data access
+ */
+
+export { BaseRepository } from './BaseRepository';
+export { TestCaseRepository } from './TestCaseRepository';
+export { TestResultRepository } from './TestResultRepository';
+export { ModelConfigRepository } from './ModelConfigRepository';
+export { ExplorationRepository } from './ExplorationRepository';
+export { SettingsRepository } from './SettingsRepository';
+export { ProjectRepository } from './ProjectRepository';
+export { DirectoryRepository } from './DirectoryRepository';
+export { TestPlanRepository } from './TestPlanRepository';
+export { TableDataRepository } from './TableDataRepository';
+export { FileRepository } from './FileRepository';

package/src/storageService.ts

@@ -0,0 +1,404 @@
+import { existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import {
+  TestCaseRepository,
+  TestResultRepository,
+  ModelConfigRepository,
+  ExplorationRepository,
+  SettingsRepository,
+  ProjectRepository,
+  DirectoryRepository,
+  TestPlanRepository,
+  TableDataRepository,
+  FileRepository,
+} from './repositories';
+import type { TestCase, TestResult, AppSettings, ModelConfig, TestStep, ExplorationRecord, Project, DirectoryInfo, TestDirectory, TestPlan, TableData } from './types';
+
+
+const STORAGE_DIR = join(homedir(), '.test_agent');
+
+let isInit = false;
+
+/**
+ * StorageService acts as a facade for all data storage operations
+ * Coordinates between different repositories and provides a unified interface
+ * This decouples business logic from repository implementation details
+ *
+ * Benefits:
+ * - Single point of entry for all storage operations
+ * - Encapsulates repository instantiation
+ * - Easy to add cross-cutting concerns (logging, caching, etc.)
+ * - Simplifies unit testing by allowing mock repositories
+ */
+export class StorageService {
+  private static instance: StorageService;
+  private testCaseRepo: TestCaseRepository;
+  private testResultRepo: TestResultRepository;
+  private modelConfigRepo: ModelConfigRepository;
+  private explorationRepo: ExplorationRepository;
+  private settingsRepo: SettingsRepository;
+  private projectRepo: ProjectRepository;
+  private directoryRepo: DirectoryRepository;
+  private testPlanRepo: TestPlanRepository;
+  private tableDataRepo: TableDataRepository;
+  private fileRepo: FileRepository;
+
+  private constructor(projectId: string) {
+    this.testCaseRepo = new TestCaseRepository(projectId);
+    this.testResultRepo = new TestResultRepository(projectId);
+    this.modelConfigRepo = new ModelConfigRepository();
+    this.explorationRepo = new ExplorationRepository(projectId);
+    this.settingsRepo = new SettingsRepository();
+    this.projectRepo = new ProjectRepository();
+    this.directoryRepo = new DirectoryRepository(projectId);
+    this.testPlanRepo = new TestPlanRepository(projectId);
+    this.tableDataRepo = new TableDataRepository(projectId);
+    this.fileRepo = new FileRepository(projectId);
+  }
+
+  private static instances: Map<string, StorageService> = new Map();
+
+  /**
+ * Get singleton instance of StorageService
+ */
+  static getInstance(projectId: string): StorageService {
+    if (isInit === false) {
+      isInit = true;
+      StorageService.createDirs(["models", "settings"]);
+    }
+
+    let instance = StorageService.instances.get(projectId);
+    if (!instance) {
+      instance = new StorageService(projectId);
+      StorageService.instances.set(projectId, instance);
+    }
+    return instance;
+  }
+
+  /**
+   * Reset instance (useful for testing)
+   */
+  static resetInstance(): void {
+    StorageService.instances.clear();
+    isInit = false;
+  }
+
+  /**
+   * Initialize storage directories
+   */
+  private static createDirs(dirs: string[]) {
+    for (const dir of dirs) {
+      const dirPath = join(STORAGE_DIR, dir);
+      if (!existsSync(dirPath)) {
+        mkdirSync(dirPath, { recursive: true });
+      }
+    }
+  }
+
+  /**
+   * Get storage root directory
+   */
+  getStorageDir(): string {
+    return STORAGE_DIR;
+  }
+
+  // ==================== TestCase Operations ====================
+
+  saveTestCase(testCase: TestCase): void {
+    this.testCaseRepo.saveTestCase(testCase);
+  }
+
+  loadTestCase(testId: string): TestCase | null {
+    return this.testCaseRepo.loadTestCase(testId);
+  }
+
+  listTestCases(): TestCase[] {
+    return this.testCaseRepo.listTestCases();
+  }
+
+  listResuableTestCases(currentId: string): TestCase[] {
+    const list = this.testCaseRepo.listTestCases();
+    return list.filter(test => test.reusable && test.id !== currentId && test.status === 'completed');
+  }
+
+  deleteTestCase(testId: string): void {
+    this.testCaseRepo.deleteTestCase(testId);
+    try {
+      this.tableDataRepo.deleteTableData(testId);
+    } catch (err) {
+      console.error(`Failed to delete table data for test case ${testId}:`, err);
+    }
+    try {
+      this.fileRepo.deleteAllFiles(testId);
+    } catch (err) {
+      console.error(`Failed to delete files for test case ${testId}:`, err);
+    }
+  }
+
+  listTestCasesRecursively(dirPath: string): TestCase[] {
+    return this.testCaseRepo.listTestCasesRecursively(dirPath);
+  }
+
+  saveTestScript(testId: string, script: string): void {
+    this.testCaseRepo.saveTestScript(testId, script);
+  }
+
+  hasTestScript(testId: string): boolean {
+    return this.testCaseRepo.hasTestScript(testId);
+  }
+
+  loadTestScript(testId: string): string | undefined {
+    return this.testCaseRepo.loadTestScript(testId);
+  }
+
+  saveTestSteps(testId: string, steps: TestStep[]): void {
+    this.testCaseRepo.saveTestSteps(testId, steps);
+  }
+
+  loadTestSteps(testId: string): TestStep[] {
+    return this.testCaseRepo.loadTestSteps(testId);
+  }
+
+  saveTestStep(
+    testId: string,
+    step: { id: string; description?: string; isBreakpoint?: boolean; isAI?: boolean; reusedFromTestId?: string },
+    afterStepId?: string
+  ): boolean {
+    return this.testCaseRepo.saveTestStep(testId, step, afterStepId);
+  }
+
+  insertStep(testId: string, afterStepId: string | null | undefined, newStep: TestStep): void {
+    this.testCaseRepo.insertStep(testId, afterStepId, newStep);
+  }
+
+  deleteStep(testId: string, stepId: string): boolean {
+    return this.testCaseRepo.deleteStep(testId, stepId);
+  }
+
+  buildTestDirectoryTree(): TestDirectory {
+    return this.testCaseRepo.buildDirectoryTree();
+  }
+
+  // ==================== Directory Operations ====================
+
+  createDirectory(path: string, info: Omit<DirectoryInfo, 'id' | 'path'>): DirectoryInfo {
+    return this.directoryRepo.createDirectory(path, info);
+  }
+
+  getDirectoryInfo(path: string): DirectoryInfo | null {
+    return this.directoryRepo.getDirectoryInfo(path);
+  }
+
+  updateDirectoryInfo(path: string, updates: Partial<Omit<DirectoryInfo, 'id' | 'path'>>): DirectoryInfo {
+    return this.directoryRepo.updateDirectoryInfo(path, updates);
+  }
+
+  deleteDirectory(path: string): void {
+    return this.directoryRepo.deleteDirectory(path);
+  }
+
+  renameDirectory(oldPath: string, newName: string): DirectoryInfo {
+    return this.directoryRepo.renameDirectory(oldPath, newName);
+  }
+
+  getDirectoriesAtPath(path?: string): DirectoryInfo[] {
+    return this.directoryRepo.getDirectoriesAtPath(path);
+  }
+
+  isValidDirectory(path: string): boolean {
+    return this.directoryRepo.isValidDirectory(path);
+  }
+
+  moveDirectory(sourcePath: string, targetParentPath: string): DirectoryInfo {
+    return this.directoryRepo.moveDirectory(sourcePath, targetParentPath);
+  }
+
+  moveTestCase(testId: string, sourceDir: string, targetDir: string): boolean {
+    return this.directoryRepo.moveTestCase(testId, sourceDir, targetDir);
+  }
+
+  // ==================== TestResult Operations ====================
+
+  async saveTestResult(result: TestResult): Promise<void> {
+    await this.testResultRepo.saveTestResult(result);
+  }
+
+  async loadTestResult(resultId: string): Promise<TestResult | null> {
+    return this.testResultRepo.loadTestResult(resultId);
+  }
+
+  async loadTestResults(testId: string): Promise<TestResult[]> {
+    return this.testResultRepo.loadTestResults(testId);
+  }
+
+  async deleteTestResult(resultId: string): Promise<void> {
+    await this.testResultRepo.deleteTestResult(resultId);
+  }
+
+  async deleteTestResults(testId: string): Promise<void> {
+    await this.testResultRepo.deleteTestResults(testId);
+  }
+
+  // ==================== ModelConfig Operations ====================
+
+  async saveModelConfig(config: ModelConfig): Promise<void> {
+    await this.modelConfigRepo.saveModelConfig(config);
+  }
+
+  async loadModelConfig(configId: string): Promise<ModelConfig | null> {
+    return this.modelConfigRepo.loadModelConfig(configId);
+  }
+
+  async listModelConfigs(): Promise<ModelConfig[]> {
+    return this.modelConfigRepo.listModelConfigs();
+  }
+
+  async updateModelConfig(config: ModelConfig): Promise<void> {
+    await this.modelConfigRepo.updateModelConfig(config);
+  }
+
+  async deleteModelConfig(configId: string): Promise<void> {
+    await this.modelConfigRepo.deleteModelConfig(configId);
+  }
+
+  async modelConfigExists(configId: string): Promise<boolean> {
+    return this.modelConfigRepo.exists(configId);
+  }
+
+  // ==================== ExplorationRecord Operations ====================
+
+  async saveExplorationRecord(record: ExplorationRecord): Promise<void> {
+    await this.explorationRepo.saveExplorationRecord(record);
+  }
+
+  async loadExplorationRecord(recordId: string): Promise<ExplorationRecord | null> {
+    return this.explorationRepo.loadExplorationRecord(recordId);
+  }
+
+  async listExplorationRecords(): Promise<ExplorationRecord[]> {
+    return this.explorationRepo.listExplorationRecords();
+  }
+
+  async updateExplorationRecord(record: ExplorationRecord): Promise<void> {
+    await this.explorationRepo.updateExplorationRecord(record);
+  }
+
+  async deleteExplorationRecord(recordId: string): Promise<void> {
+    await this.explorationRepo.deleteExplorationRecord(recordId);
+  }
+
+  async getExplorationRecordsByUrl(url: string): Promise<ExplorationRecord[]> {
+    return this.explorationRepo.getRecordsByUrl(url);
+  }
+
+  // ==================== Settings Operations ====================
+
+  async saveSettings(settings: AppSettings): Promise<void> {
+    await this.settingsRepo.saveSettings(settings);
+  }
+
+  async loadSettings(): Promise<AppSettings | null> {
+    return this.settingsRepo.loadSettings();
+  }
+
+  // ==================== Project Operations ====================
+
+  saveProject(project: Project): void {
+    this.projectRepo.saveProject(project);
+  }
+
+  loadProject(projectId: string): Project | null {
+    return this.projectRepo.loadProject(projectId);
+  }
+
+  listProjects(): Project[] {
+    return this.projectRepo.listProjects();
+  }
+
+  deleteProject(projectId: string): void {
+    this.projectRepo.deleteProject(projectId);
+  }
+
+  async projectExists(projectId: string): Promise<boolean> {
+    return this.projectRepo.exists(projectId);
+  }
+
+  // ==================== TestPlan Operations ====================
+
+  saveTestPlan(testPlan: TestPlan): void {
+    this.testPlanRepo.saveTestPlan(testPlan);
+  }
+
+  loadTestPlan(testPlanId: string): TestPlan | null {
+    return this.testPlanRepo.loadTestPlan(testPlanId);
+  }
+
+  listTestPlans(): TestPlan[] {
+    return this.testPlanRepo.listTestPlans();
+  }
+
+  updateTestPlan(testPlan: TestPlan): void {
+    this.testPlanRepo.updateTestPlan(testPlan);
+  }
+
+  deleteTestPlan(testPlanId: string): void {
+    this.testPlanRepo.deleteTestPlan(testPlanId);
+  }
+
+  testPlanExists(testPlanId: string): boolean {
+    return this.testPlanRepo.exists(testPlanId);
+  }
+
+  // ==================== TableData Operations ====================
+
+  async saveTableData(tableData: TableData): Promise<void> {
+    await this.tableDataRepo.saveTableData(tableData);
+  }
+
+  async loadTableData(testId: string): Promise<TableData | null> {
+    const data = await this.tableDataRepo.loadTableData(testId);
+    if (data && data.rows.length > 0) {
+      return data;
+    }
+    return null;
+  }
+
+  async deleteTableData(testId: string): Promise<void> {
+    await this.tableDataRepo.deleteTableData(testId);
+  }
+
+  // ==================== File Operations ====================
+
+  getFileDir(testId: string): string {
+    return this.fileRepo.getTestFilesDir(testId);
+  }
+
+  saveFile(testId: string, fileName: string, content: Buffer): { name: string; size: number; uploadedAt: string; path: string } {
+    return this.fileRepo.saveFile(testId, fileName, content);
+  }
+
+  loadFile(testId: string, fileName: string): Buffer | null {
+    return this.fileRepo.loadFile(testId, fileName);
+  }
+
+  listFiles(testId: string): { name: string; size: number; uploadedAt: string; path: string }[] {
+    return this.fileRepo.listFiles(testId);
+  }
+
+  deleteFile(testId: string, fileName: string): boolean {
+    return this.fileRepo.deleteFile(testId, fileName);
+  }
+
+  deleteAllFiles(testId: string): void {
+    this.fileRepo.deleteAllFiles(testId);
+  }
+
+  fileExists(testId: string, fileName: string): boolean {
+    return this.fileRepo.fileExists(testId, fileName);
+  }
+
+  getFileInfo(testId: string, fileName: string): { name: string; size: number; uploadedAt: string; path: string } | null {
+    return this.fileRepo.getFileInfo(testId, fileName);
+  }
+}