@chen-rmag/core-infra 1.0.0

package/src/repositories/ProjectRepository.ts

@@ -0,0 +1,70 @@
+import { join } from 'path';
+import { BaseRepository } from './BaseRepository';
+import type { Project } from '../types';
+import { readdirSync, rmSync } from 'fs';
+
+/**
+ * ProjectRepository handles all CRUD operations for projects
+ * Projects are stored at ~/.test_agent/projects
+ */
+export class ProjectRepository extends BaseRepository {
+  private projectJSON: string = "project";
+
+  constructor() {
+    super('projects');
+  }
+
+  /**
+   * Save a new project or update an existing one
+   */
+  saveProject(project: Project): void {
+    this.saveSync(join(project.id, this.projectJSON), project);
+  }
+
+  /**
+   * Load a single project by ID
+   */
+  loadProject(projectId: string): Project | null {
+    return this.loadSync<Project>(join(projectId, this.projectJSON));
+  }
+
+  /**
+   * List all projects
+   */
+  listProjects(): Project[] {
+    const projectDir = this.getBaseDir();
+    const projectIds = this.listDirectories(projectDir);
+    const projects: Project[] = [];
+    for (const projectId of projectIds) {
+      const project = this.loadSync<Project>(join(projectId, this.projectJSON));
+      if (project) {
+        projects.push(project);
+      } else {
+        projects.push({ id: 'default', 'description': 'Default Project', 'name': 'Default', 'createdAt': 0, isActive: false });
+      }
+    }
+    return projects;
+  }
+
+  private listDirectories(dirPath: string): string[] {
+    return readdirSync(dirPath, { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory())
+      .map(dirent => dirent.name);
+  }
+
+  /**
+   * Delete a project by ID
+   */
+  deleteProject(projectId: string): void {
+    const projectDir = this.getBaseDir();
+    rmSync(join(projectDir, projectId), { recursive: true });
+  }
+
+  /**
+   * Check if a project exists
+   */
+  async exists(projectId: string): Promise<boolean> {
+    const project = this.loadProject(join(projectId, this.projectJSON));
+    return project !== null;
+  }
+}

package/src/repositories/SettingsRepository.ts

@@ -0,0 +1,38 @@
+import { BaseRepository } from './BaseRepository';
+import { AppSettings } from '../types';
+
+/**
+ * SettingsRepository handles all storage operations for application settings
+ * Responsible for managing user preferences and configuration
+ */
+export class SettingsRepository extends BaseRepository {
+  private readonly SETTINGS_ID = 'settings';
+
+  constructor() {
+    super('.');
+  }
+
+  /**
+   * Save application settings
+   */
+  async saveSettings(settings: AppSettings): Promise<void> {
+    // Save at root of storage directory
+    const path = `${this.storageDir}/settings.json`;
+    const fs = await import('fs/promises');
+    await fs.writeFile(path, JSON.stringify(settings, null, 2), 'utf-8');
+  }
+
+  /**
+   * Load application settings
+   */
+  async loadSettings(): Promise<AppSettings | null> {
+    const path = `${this.storageDir}/settings.json`;
+    try {
+      const fs = await import('fs/promises');
+      const content = await fs.readFile(path, 'utf-8');
+      return JSON.parse(content) as AppSettings;
+    } catch {
+      return null;
+    }
+  }
+}

package/src/repositories/TableDataRepository.ts

@@ -0,0 +1,33 @@
+import { BaseRepository } from './BaseRepository';
+import type { TableData } from '../types';
+
+/**
+ * TableDataRepository handles storage operations for test table data
+ * Stores table data in data directory as {testId}.json
+ */
+export class TableDataRepository extends BaseRepository {
+  constructor(projectId: string) {
+    super(`projects/${projectId}/data`);
+  }
+
+  /**
+   * Save table data for a test
+   */
+  async saveTableData(tableData: TableData): Promise<void> {
+    await this.save(tableData.testId, tableData);
+  }
+
+  /**
+   * Load table data for a test
+   */
+  async loadTableData(testId: string): Promise<TableData | null> {
+    return this.load<TableData>(testId);
+  }
+
+  /**
+   * Delete table data for a test
+   */
+  async deleteTableData(testId: string): Promise<void> {
+    await this.delete(testId);
+  }
+}

package/src/repositories/TestCaseRepository.ts

@@ -0,0 +1,521 @@
+import { BaseRepository } from './BaseRepository';
+import { TestCase, TestStep, TestDirectory } from '../types';
+import { join, relative } from 'path';
+import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, readdirSync, statSync } from 'fs';
+
+/**
+ * TestCaseRepository handles all storage operations for test cases
+ * Responsible for managing test case data, steps, and associated scripts
+ * Supports hierarchical directory organization (up to 3 levels)
+ */
+export class TestCaseRepository extends BaseRepository {
+  constructor(projectId: string) {
+    super(join("projects", projectId, 'tests'));
+  }
+
+  /**
+   * Get scripts directory - project-aware
+   * When project is active: ~/.test_agent/projects/{projectId}/scripts
+   * When no project: ~/.test_agent/scripts
+   */
+  private getScriptsDir(): string {
+    const testsBaseDir = this.getBaseDir(); // ~/.test_agent/projects/{projectId}/tests or ~/.test_agent/tests
+    const parentDir = join(testsBaseDir, '..');
+    return join(parentDir, 'scripts');
+  }
+
+  /**
+   * Get steps directory - project-aware
+   * When project is active: ~/.test_agent/projects/{projectId}/steps
+   * When no project: ~/.test_agent/steps
+   */
+  private getStepsDir(): string {
+    const testsBaseDir = this.getBaseDir(); // ~/.test_agent/projects/{projectId}/tests or ~/.test_agent/tests
+    const parentDir = join(testsBaseDir, '..');
+    return join(parentDir, 'steps');
+  }
+
+  /**
+   * Ensure scripts directory exists
+   */
+  private ensureScriptsDir(): void {
+    const scriptsDir = this.getScriptsDir();
+    if (!existsSync(scriptsDir)) {
+      mkdirSync(scriptsDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Ensure steps directory exists
+   */
+  private ensureStepsDir(): void {
+    const stepsDir = this.getStepsDir();
+    if (!existsSync(stepsDir)) {
+      mkdirSync(stepsDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Save a test case with support for directory paths
+   */
+  saveTestCase(testCase: TestCase): void {
+    const dirPath = join(this.getBaseDir(), testCase.path);
+
+    // Ensure directory exists
+    if (!existsSync(dirPath)) {
+      mkdirSync(dirPath, { recursive: true });
+    }
+
+    // Save to file within the directory path
+    const filePath = join(dirPath, `${testCase.id}.json`);
+    // C:\Users\85847\.test_agent\projects\43af4db4-3249-4135-b279-97b24f27106b\tests\aaa\ccc\ddd
+    writeFileSync(filePath, JSON.stringify(testCase, (key, value) => {
+      if (key === 'steps' || key === 'playwrightScript' || key === 'table') {
+        return undefined;  // Return undefined to ignore this field
+      }
+      return value;
+    }, 2), 'utf-8');
+  }
+
+  /**
+   * Load a test case with its steps and script
+   */
+  loadTestCase(testId: string, path?: string): TestCase | null {
+    let filePath: string;
+
+    if (path) {
+      filePath = join(this.getBaseDir(), path, `${testId}.json`);
+    } else {
+      // Try to find test case in the base directory or any subdirectory
+      filePath = join(this.getBaseDir(), `${testId}.json`);
+      if (!existsSync(filePath)) {
+        // Search in all directories
+        const found = this.findTestCaseFile(testId, this.getBaseDir());
+        if (!found) {
+          return null;
+        }
+        filePath = found;
+      }
+    }
+
+    if (!existsSync(filePath)) {
+      return null;
+    }
+
+    try {
+      const content = readFileSync(filePath, 'utf-8');
+      const testCase = JSON.parse(content) as TestCase;
+
+      // Load associated steps
+      const steps = this.loadTestSteps(testId);
+      testCase.steps = steps;
+
+      return testCase;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Recursively find a test case file by ID
+   */
+  private findTestCaseFile(testId: string, searchPath: string): string | null {
+    try {
+      const items = readdirSync(searchPath);
+
+      for (const item of items) {
+        const itemPath = join(searchPath, item);
+        const stat = statSync(itemPath);
+
+        if (stat.isDirectory() && item !== 'info.json') {
+          // Skip deep nesting (max 3 levels from tests root)
+          const relativePath = relative(this.getBaseDir(), itemPath);
+          if (relativePath.split(/[\/\\]/).length > 3) {
+            continue;
+          }
+          const result = this.findTestCaseFile(testId, itemPath);
+          if (result) {
+            return result;
+          }
+        } else if (item === `${testId}.json`) {
+          return itemPath;
+        }
+      }
+    } catch {
+      // Skip if unable to read directory
+    }
+
+    return null;
+  }
+
+  /**
+   * List all test cases sorted by creation date (newest first)
+   * Returns a hierarchical directory tree
+   */
+  listTestCases(): TestCase[] {
+    return this.listTestCasesInDirectory(this.getBaseDir());
+  }
+
+  /**
+   * Build complete directory tree
+   */
+  buildDirectoryTree(): TestDirectory {
+    return this.buildDirectoryTreeRecursive(this.getBaseDir(), '');
+  }
+
+  /**
+   * Recursively build directory tree
+   */
+  private buildDirectoryTreeRecursive(fullPath: string, relativePath: string): TestDirectory {
+    const pathParts = relativePath ? relativePath.split('/') : [];
+    const name = pathParts.length > 0 ? pathParts[pathParts.length - 1] : 'root';
+
+    // Load directory info if exists
+    let info = undefined;
+    const infoPath = join(fullPath, 'info.json');
+    if (existsSync(infoPath)) {
+      try {
+        const content = readFileSync(infoPath, 'utf-8');
+        info = JSON.parse(content);
+      } catch {
+        // Skip invalid info.json
+      }
+    }
+
+    const tree: TestDirectory = {
+      path: relativePath,
+      name,
+      info,
+      children: [],
+      tests: [],
+    };
+
+    try {
+      const items = readdirSync(fullPath);
+
+      for (const item of items) {
+        if (item === 'info.json') {
+          continue;
+        }
+
+        const itemPath = join(fullPath, item);
+        const stat = statSync(itemPath);
+
+        if (stat.isDirectory()) {
+          const subPath = relativePath ? `${relativePath}/${item}` : item;
+
+          // Check depth (max 3 levels)
+          if (subPath.split('/').length <= 3) {
+            tree.children.push(this.buildDirectoryTreeRecursive(itemPath, subPath));
+          }
+        }
+      }
+
+      // Load test files from current directory
+      for (const item of items) {
+        if (item.endsWith('.json') && item !== 'info.json') {
+          try {
+            const content = readFileSync(join(fullPath, item), 'utf-8');
+            const testCase = JSON.parse(content) as TestCase;
+            // Only include tests that belong to this directory
+            if (testCase.path === relativePath) {
+              tree.tests.push(testCase);
+            }
+          } catch {
+            // Skip invalid test files
+          }
+        }
+      }
+
+      // Sort children by name and tests by creation date
+      tree.children.sort((a, b) => a.name.localeCompare(b.name));
+      tree.tests.sort((a, b) => b.createdAt - a.createdAt);
+    } catch {
+      // Return tree with no children/tests if unable to read
+    }
+
+    return tree;
+  }
+
+  /**
+ * List test cases in a specific directory recursively.
+ * Loads full test data including steps
+ */
+  listTestCasesRecursively(dirPath: string, seen: Set<string> = new Set()): TestCase[] {
+    const fullPath = join(this.getBaseDir(), dirPath);
+    const tests: TestCase[] = [];
+
+    const items = readdirSync(fullPath);
+
+    for (const item of items) {
+      const itemPath = join(fullPath, item);
+      const stat = statSync(itemPath);
+
+      if (stat.isDirectory()) {
+        // Recursively list tests in subdirectories
+        const subDirPath = dirPath ? `${dirPath}/${item}` : item;
+        tests.push(...this.listTestCasesRecursively(subDirPath, seen));
+      } else if (item.endsWith('.json') && item !== 'info.json') {
+        // Load test case file
+        const testId = item.replace('.json', '');
+        if (seen.has(testId)) {
+          continue; // Skip duplicates
+        }
+        seen.add(testId);
+        const testCase = this.loadTestCase(testId, dirPath);
+        if (testCase) {
+          tests.push(testCase);
+        }
+      }
+    }
+
+    return tests.sort((a, b) => b.createdAt - a.createdAt);
+  }
+
+  /**
+   * List test cases in a specific directory
+   */
+  private listTestCasesInDirectory(dirPath: string): TestCase[] {
+    const tests: TestCase[] = [];
+
+    try {
+      const items = readdirSync(dirPath);
+
+      for (const item of items) {
+        if (item.endsWith('.json') && item !== 'info.json') {
+          try {
+            const content = readFileSync(join(dirPath, item), 'utf-8');
+            tests.push(JSON.parse(content) as TestCase);
+          } catch {
+            // Skip invalid files
+          }
+        } else {
+          const itemPath = join(dirPath, item);
+          const stat = statSync(itemPath);
+          if (stat.isDirectory()) {
+            tests.push(...this.listTestCasesInDirectory(itemPath));
+          }
+        }
+      }
+    } catch {
+      // Return empty array if unable to read
+    }
+
+    return tests.sort((a, b) => b.createdAt - a.createdAt);
+  }
+
+  /**
+   * Delete a test case and its associated data
+   */
+  deleteTestCase(testId: string): void {
+    const filePath = this.findTestCaseFile(testId, this.getBaseDir());
+    if (filePath) {
+      rmSync(filePath);
+    }
+    this.deleteTestSteps(testId);
+    this.deleteTestScript(testId);
+  }
+
+  /**
+   * Save test case steps
+   */
+  saveTestSteps(testId: string, steps: TestStep[]): void {
+    // Ensure steps directory exists
+    this.ensureStepsDir();
+
+    // Reset any running steps
+    let runningFound = false;
+    steps.forEach(step => {
+      if (runningFound || step.status === 'running') {
+        runningFound = true;
+        step.status = undefined;
+        step.error = undefined;
+      }
+    });
+
+    const stepsFile = this.getStepsFilePath(testId);
+    writeFileSync(stepsFile, JSON.stringify(steps, null, 2), 'utf-8');
+  }
+
+  /**
+   * Load test case steps
+   */
+  loadTestSteps(testId: string): TestStep[] {
+    const stepsFile = this.getStepsFilePath(testId);
+    if (!existsSync(stepsFile)) {
+      return [];
+    }
+    const content = readFileSync(stepsFile, 'utf-8');
+    return JSON.parse(content) as TestStep[];
+  }
+
+  /**
+   * Delete all steps for a test case
+   */
+  private deleteTestSteps(testId: string): void {
+    const stepsFile = this.getStepsFilePath(testId);
+    if (existsSync(stepsFile)) {
+      rmSync(stepsFile);
+    }
+  }
+
+  /**
+   * Save a single test step or insert a new one
+   * @returns true if updated, false if created
+   */
+  saveTestStep(
+    testId: string,
+    step: { id: string; description?: string; isBreakpoint?: boolean; isAI?: boolean; reusedTestIds?: string[] },
+    afterStepId?: string
+  ): boolean {
+    const testCase = this.loadTestCase(testId);
+    if (!testCase) {
+      throw new Error(`Test case ${testId} not found`);
+    }
+
+    testCase.status = 'draft';
+
+    let updated = false;
+    let insertIndex = 0;
+    const dbStep = testCase.steps.find(s => s.id === step.id);
+
+    if (!dbStep) {
+      if (afterStepId) {
+        insertIndex = testCase.steps.findIndex(s => s.id === afterStepId);
+        if (insertIndex !== -1) {
+          insertIndex += 1;
+        } else {
+          insertIndex = testCase.steps.length;
+        }
+        testCase.steps.splice(insertIndex, 0, step as TestStep);
+      } else {
+        testCase.steps.push(step as TestStep);
+      }
+    }
+
+    if (dbStep) {
+      if (step.description) {
+        dbStep.description = step.description;
+      }
+      if (step.isBreakpoint !== undefined && step.isBreakpoint !== null) {
+        dbStep.isBreakpoint = step.isBreakpoint;
+      }
+      if (step.isAI !== undefined && step.isAI !== null) {
+        dbStep.isAI = step.isAI;
+      }
+      if (step.reusedTestIds !== undefined) {
+        dbStep.reusedTestIds = step.reusedTestIds;
+      }
+      dbStep.status = undefined;
+      dbStep.error = undefined;
+      updated = true;
+    }
+
+    this.saveTestSteps(testId, testCase.steps);
+    return updated;
+  }
+
+  /**
+   * Insert a new step after a specific step
+   */
+  insertStep(
+    testId: string,
+    afterStepId: string | null | undefined,
+    newStep: TestStep
+  ): void {
+    const testCase = this.loadTestCase(testId);
+    if (!testCase) {
+      throw new Error(`Test case ${testId} not found`);
+    }
+
+    testCase.status = 'draft';
+
+    let insertIndex = 0;
+    if (afterStepId) {
+      insertIndex = testCase.steps.findIndex(s => s.id === afterStepId);
+      if (insertIndex !== -1) {
+        insertIndex += 1;
+      } else {
+        insertIndex = testCase.steps.length;
+      }
+    }
+
+    testCase.steps.splice(insertIndex, 0, newStep);
+    this.saveTestSteps(testId, testCase.steps);
+  }
+
+  /**
+   * Delete a specific step by ID
+   */
+  deleteStep(testId: string, stepId: string): boolean {
+    let steps = this.loadTestSteps(testId);
+    if (steps.length === 0) {
+      return false;
+    }
+
+    const index = steps.findIndex(s => s.id === stepId);
+    steps = [
+      ...steps.slice(0, index),
+      ...steps.slice(index + 1),
+    ];
+    this.saveTestSteps(testId, steps);
+
+    const testCase = this.loadTestCase(testId);
+    if (testCase && testCase.status !== 'draft') {
+      testCase.status = 'draft';
+      this.saveTestCase(testCase);
+    }
+
+    return true;
+  }
+
+  /**
+   * Save Playwright script for a test case
+   */
+  saveTestScript(testId: string, script: string): void {
+    // Ensure scripts directory exists
+    this.ensureScriptsDir();
+
+    const scriptPath = this.getScriptFilePath(testId);
+    writeFileSync(scriptPath, script, 'utf-8');
+  }
+
+  /**
+   * Load Playwright script for a test case
+   */
+  loadTestScript(testId: string): string | undefined {
+    const scriptPath = this.getScriptFilePath(testId);
+    if (!existsSync(scriptPath)) {
+      return undefined;
+    }
+    return readFileSync(scriptPath, 'utf-8');
+  }
+
+  hasTestScript(testId: string): boolean {
+    return existsSync(this.getScriptFilePath(testId));
+  }
+
+  /**
+   * Delete Playwright script for a test case
+   */
+  private deleteTestScript(testId: string): void {
+    const scriptPath = this.getScriptFilePath(testId);
+    if (existsSync(scriptPath)) {
+      rmSync(scriptPath);
+    }
+  }
+
+  /**
+   * Get the file path for a test step file
+   */
+  private getStepsFilePath(testId: string): string {
+    return join(this.getStepsDir(), `${testId}.json`);
+  }
+
+  /**
+   * Get the file path for a test script file
+   */
+  private getScriptFilePath(testId: string): string {
+    return join(this.getScriptsDir(), `${testId}.ts`);
+  }
+}