@jcjeon/integration-cli 0.2.0

package/apps/server/src/modules/harness/harness.service.spec.ts

@@ -0,0 +1,217 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { BadRequestException } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { JI_PATHS } from '../../common/ji-paths';
+import { HarnessService } from './harness.service';
+
+jest.mock('fs');
+
+describe('HarnessService', () => {
+  let service: HarnessService;
+
+  const harnessDir = JI_PATHS.harness;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [HarnessService],
+    }).compile();
+
+    service = module.get(HarnessService);
+    jest.clearAllMocks();
+  });
+
+  // ─── findAll ─────────────────────────────────────────────────────────────
+
+  describe('findAll', () => {
+    it('존재하는 harness 파일들을 모두 반환한다', () => {
+      (fs.existsSync as jest.Mock).mockImplementation((p: string) =>
+        p === path.join(harnessDir, 'common.md') || p === path.join(harnessDir, 'frontend.tsx'),
+      );
+      (fs.readFileSync as jest.Mock).mockReturnValue('# content');
+
+      const result = service.findAll();
+
+      expect(result).toHaveLength(2);
+      expect(result[0]).toEqual({ role: 'common', ext: 'md', content: '# content' });
+      expect(result[1]).toEqual({ role: 'frontend', ext: 'tsx', content: '# content' });
+    });
+
+    it('파일이 없으면 빈 배열을 반환한다', () => {
+      (fs.existsSync as jest.Mock).mockReturnValue(false);
+
+      const result = service.findAll();
+
+      expect(result).toEqual([]);
+    });
+
+    it('md와 tsx 중 먼저 찾은 파일을 반환한다', () => {
+      (fs.existsSync as jest.Mock).mockImplementation((p: string) =>
+        p === path.join(harnessDir, 'backend.md'),
+      );
+      (fs.readFileSync as jest.Mock).mockReturnValue('backend content');
+
+      const result = service.findAll();
+
+      const backendEntry = result.find((h) => h.role === 'backend');
+      expect(backendEntry?.ext).toBe('md');
+    });
+  });
+
+  // ─── findOne ─────────────────────────────────────────────────────────────
+
+  describe('findOne', () => {
+    it('md 파일이 있으면 반환한다', () => {
+      (fs.existsSync as jest.Mock).mockImplementation((p: string) =>
+        p === path.join(harnessDir, 'common.md'),
+      );
+      (fs.readFileSync as jest.Mock).mockReturnValue('# common template');
+
+      const result = service.findOne('common');
+
+      expect(result).toEqual({ role: 'common', ext: 'md', content: '# common template' });
+    });
+
+    it('tsx 파일을 md보다 우선하지 않는다 (md 먼저 확인)', () => {
+      (fs.existsSync as jest.Mock).mockImplementation((p: string) =>
+        p === path.join(harnessDir, 'frontend.tsx'),
+      );
+      (fs.readFileSync as jest.Mock).mockReturnValue('export default () => <div/>;');
+
+      const result = service.findOne('frontend');
+
+      expect(result).toEqual({ role: 'frontend', ext: 'tsx', content: 'export default () => <div/>;' });
+    });
+
+    it('파일이 없으면 null을 반환한다', () => {
+      (fs.existsSync as jest.Mock).mockReturnValue(false);
+
+      const result = service.findOne('backend');
+
+      expect(result).toBeNull();
+    });
+
+    it('readFileSync를 utf8로 호출한다', () => {
+      const mdPath = path.join(harnessDir, 'doc.md');
+      (fs.existsSync as jest.Mock).mockImplementation((p: string) => p === mdPath);
+      (fs.readFileSync as jest.Mock).mockReturnValue('content');
+
+      service.findOne('doc');
+
+      expect(fs.readFileSync).toHaveBeenCalledWith(mdPath, 'utf8');
+    });
+
+    it('허용되지 않는 role이면 파일 시스템 접근 전에 거부한다', () => {
+      expect(() => service.findOne('../common')).toThrow(BadRequestException);
+      expect(fs.existsSync).not.toHaveBeenCalled();
+      expect(fs.readFileSync).not.toHaveBeenCalled();
+    });
+  });
+
+  // ─── save ─────────────────────────────────────────────────────────────────
+
+  describe('save', () => {
+    it('md 파일을 저장한다', () => {
+      (fs.existsSync as jest.Mock).mockReturnValue(false);
+
+      const result = service.save('common', '# new content', 'md');
+
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        path.join(harnessDir, 'common.md'),
+        '# new content',
+        'utf8',
+      );
+      expect(result).toEqual({ role: 'common', ext: 'md', content: '# new content' });
+    });
+
+    it('tsx 파일을 저장한다', () => {
+      (fs.existsSync as jest.Mock).mockReturnValue(false);
+
+      const result = service.save('frontend', 'const X = () => null;', 'tsx');
+
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        path.join(harnessDir, 'frontend.tsx'),
+        'const X = () => null;',
+        'utf8',
+      );
+      expect(result).toEqual({ role: 'frontend', ext: 'tsx', content: 'const X = () => null;' });
+    });
+
+    it('확장자 변경 시 기존 파일을 삭제한다', () => {
+      const oldPath = path.join(harnessDir, 'common.tsx');
+      (fs.existsSync as jest.Mock).mockImplementation((p: string) => p === oldPath);
+
+      service.save('common', 'content', 'md');
+
+      expect(fs.unlinkSync).toHaveBeenCalledWith(oldPath);
+    });
+
+    it('다른 확장자 파일이 없으면 삭제하지 않는다', () => {
+      (fs.existsSync as jest.Mock).mockReturnValue(false);
+
+      service.save('operation', 'content', 'md');
+
+      expect(fs.unlinkSync).not.toHaveBeenCalled();
+    });
+
+    it('허용되지 않는 role이면 파일 쓰기를 수행하지 않는다', () => {
+      expect(() => service.save('../common', 'content', 'md')).toThrow(BadRequestException);
+      expect(fs.existsSync).not.toHaveBeenCalled();
+      expect(fs.unlinkSync).not.toHaveBeenCalled();
+      expect(fs.writeFileSync).not.toHaveBeenCalled();
+    });
+
+    it('허용되지 않는 확장자이면 파일 쓰기를 수행하지 않는다', () => {
+      expect(() => service.save('common', 'content', 'json' as never)).toThrow(BadRequestException);
+      expect(fs.existsSync).not.toHaveBeenCalled();
+      expect(fs.unlinkSync).not.toHaveBeenCalled();
+      expect(fs.writeFileSync).not.toHaveBeenCalled();
+    });
+  });
+
+  // ─── remove ──────────────────────────────────────────────────────────────
+
+  describe('remove', () => {
+    it('md 파일을 삭제한다', () => {
+      const mdPath = path.join(harnessDir, 'common.md');
+      (fs.existsSync as jest.Mock).mockImplementation((p: string) => p === mdPath);
+
+      service.remove('common');
+
+      expect(fs.unlinkSync).toHaveBeenCalledWith(mdPath);
+    });
+
+    it('tsx 파일을 삭제한다', () => {
+      const tsxPath = path.join(harnessDir, 'frontend.tsx');
+      (fs.existsSync as jest.Mock).mockImplementation((p: string) => p === tsxPath);
+
+      service.remove('frontend');
+
+      expect(fs.unlinkSync).toHaveBeenCalledWith(tsxPath);
+    });
+
+    it('두 확장자 모두 존재하면 둘 다 삭제한다', () => {
+      (fs.existsSync as jest.Mock).mockReturnValue(true);
+
+      service.remove('backend');
+
+      expect(fs.unlinkSync).toHaveBeenCalledTimes(2);
+    });
+
+    it('파일이 없으면 삭제하지 않는다', () => {
+      (fs.existsSync as jest.Mock).mockReturnValue(false);
+
+      service.remove('other');
+
+      expect(fs.unlinkSync).not.toHaveBeenCalled();
+    });
+
+    it('허용되지 않는 role이면 파일 삭제를 수행하지 않는다', () => {
+      expect(() => service.remove('../common')).toThrow(BadRequestException);
+      expect(fs.existsSync).not.toHaveBeenCalled();
+      expect(fs.unlinkSync).not.toHaveBeenCalled();
+    });
+  });
+});

package/apps/server/src/modules/harness/harness.service.ts

@@ -0,0 +1,112 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { BadRequestException, Injectable, InternalServerErrorException } from '@nestjs/common';
+
+import { JI_PATHS } from '../../common/ji-paths';
+
+export const HARNESS_ROLES = ['common', 'frontend', 'backend', 'doc', 'operation', 'other'] as const;
+const HARNESS_EXTENSIONS = ['md', 'tsx'] as const;
+
+export type HarnessRole = (typeof HARNESS_ROLES)[number];
+export type HarnessExt = (typeof HARNESS_EXTENSIONS)[number];
+
+export interface Harness {
+  role: HarnessRole;
+  ext: HarnessExt;
+  content: string;
+}
+
+const ALL_ROLES: HarnessRole[] = [...HARNESS_ROLES];
+const HARNESS_ROOT = path.resolve(JI_PATHS.harness);
+
+@Injectable()
+export class HarnessService {
+
+  findAll(): Harness[] {
+    try {
+      return ALL_ROLES.map((role) => this.findOne(role)).filter(Boolean) as Harness[];
+    } catch (err) {
+      this.rethrowHarnessError(err);
+    }
+  }
+
+  findOne(role: string): Harness | null {
+    try {
+      const harnessRole = this.parseRole(role);
+
+      for (const ext of HARNESS_EXTENSIONS) {
+        const filePath = this.resolveHarnessPath(harnessRole, ext);
+        if (fs.existsSync(filePath)) {
+          return { role: harnessRole, ext, content: fs.readFileSync(filePath, 'utf8') };
+        }
+      }
+      return null;
+    } catch (err) {
+      this.rethrowHarnessError(err);
+    }
+  }
+
+  save(role: string, content: string, ext: HarnessExt): Harness {
+    try {
+      const harnessRole = this.parseRole(role);
+      const harnessExt = this.parseExt(ext);
+      const targetPath = this.resolveHarnessPath(harnessRole, harnessExt);
+      const otherExt: HarnessExt = harnessExt === 'md' ? 'tsx' : 'md';
+      const otherPath = this.resolveHarnessPath(harnessRole, otherExt);
+
+      // 다른 확장자 파일 존재 시 제거 (확장자 변경 처리)
+      if (fs.existsSync(otherPath)) fs.unlinkSync(otherPath);
+
+      fs.writeFileSync(targetPath, content, 'utf8');
+      return { role: harnessRole, ext: harnessExt, content };
+    } catch (err) {
+      this.rethrowHarnessError(err);
+    }
+  }
+
+  remove(role: string): void {
+    try {
+      const harnessRole = this.parseRole(role);
+
+      for (const ext of HARNESS_EXTENSIONS) {
+        const filePath = this.resolveHarnessPath(harnessRole, ext);
+        if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+      }
+    } catch (err) {
+      this.rethrowHarnessError(err);
+    }
+  }
+
+  private parseRole(role: string): HarnessRole {
+    if (!HARNESS_ROLES.includes(role as HarnessRole)) {
+      throw new BadRequestException(`지원하지 않는 harness role입니다: ${role}`);
+    }
+    return role as HarnessRole;
+  }
+
+  private parseExt(ext: string): HarnessExt {
+    if (!HARNESS_EXTENSIONS.includes(ext as HarnessExt)) {
+      throw new BadRequestException(`지원하지 않는 harness 확장자입니다: ${ext}`);
+    }
+    return ext as HarnessExt;
+  }
+
+  private resolveHarnessPath(role: HarnessRole, ext: HarnessExt): string {
+    const targetPath = path.resolve(HARNESS_ROOT, `${role}.${ext}`);
+
+    if (path.dirname(targetPath) !== HARNESS_ROOT) {
+      throw new BadRequestException(`유효하지 않은 harness 경로입니다: ${role}`);
+    }
+
+    return targetPath;
+  }
+
+  private rethrowHarnessError(err: unknown): never {
+    if (err instanceof BadRequestException) {
+      throw err;
+    }
+
+    throw new InternalServerErrorException('하네스 파일 처리 중 오류가 발생했습니다.');
+  }
+}

package/apps/server/src/modules/sessions/session.controller.spec.ts

@@ -0,0 +1,68 @@
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { SessionEntity } from '../../database/entities/session.entity';
+import { SessionController } from './session.controller';
+import { SessionService } from './session.service';
+
+const baseSession: SessionEntity = {
+  sessionId: 'sess-uuid-1',
+  agentType: 'claude',
+  title: 'Test Session',
+  createdAt: new Date('2024-01-01'),
+};
+
+describe('SessionController', () => {
+  let controller: SessionController;
+  let service: jest.Mocked<SessionService>;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [SessionController],
+      providers: [
+        {
+          provide: SessionService,
+          useValue: {
+            findAll: jest.fn(),
+            findOne: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    controller = module.get(SessionController);
+    service = module.get(SessionService) as jest.Mocked<SessionService>;
+  });
+
+  afterEach(() => jest.clearAllMocks());
+
+  describe('findAll', () => {
+    it('agentType 없이 전체 목록을 반환한다', async () => {
+      service.findAll.mockResolvedValue([baseSession]);
+
+      const result = await controller.findAll();
+
+      expect(service.findAll).toHaveBeenCalledWith(undefined);
+      expect(result).toEqual([baseSession]);
+    });
+
+    it('agentType 필터와 함께 목록을 반환한다', async () => {
+      service.findAll.mockResolvedValue([baseSession]);
+
+      const result = await controller.findAll('claude');
+
+      expect(service.findAll).toHaveBeenCalledWith('claude');
+      expect(result).toEqual([baseSession]);
+    });
+  });
+
+  describe('findOne', () => {
+    it('service.findOne을 sessionId로 호출한다', async () => {
+      service.findOne.mockResolvedValue(baseSession);
+
+      const result = await controller.findOne('sess-uuid-1');
+
+      expect(service.findOne).toHaveBeenCalledWith('sess-uuid-1');
+      expect(result).toBe(baseSession);
+    });
+  });
+});

package/apps/server/src/modules/sessions/session.controller.ts

@@ -0,0 +1,43 @@
+import { Body, Controller, Get, HttpCode, HttpStatus, Param, Patch, Query } from '@nestjs/common';
+import { ApiOkResponse, ApiOperation, ApiQuery, ApiTags } from '@nestjs/swagger';
+import { IsNotEmpty, IsString } from 'class-validator';
+
+import { SessionService } from './session.service';
+
+class UpdateTitleDto {
+  @IsString()
+  @IsNotEmpty()
+  title!: string;
+}
+
+@ApiTags('sessions')
+@Controller('sessions')
+export class SessionController {
+  constructor(private readonly sessionService: SessionService) {}
+
+  @ApiOperation({ summary: 'DB 저장 세션 목록 조회' })
+  @ApiQuery({ name: 'agentType', required: false, enum: ['claude', 'gemini'], description: '에이전트 필터' })
+  @ApiOkResponse({ description: '세션 목록' })
+  @Get()
+  findAll(@Query('agentType') agentType?: string) {
+    return this.sessionService.findAll(agentType);
+  }
+
+  @ApiOperation({ summary: 'DB 저장 세션 단건 조회' })
+  @ApiOkResponse({ description: '세션 정보' })
+  @Get(':sessionId')
+  findOne(@Param('sessionId') sessionId: string) {
+    return this.sessionService.findOne(sessionId);
+  }
+
+  @ApiOperation({ summary: '세션 타이틀 수정' })
+  @ApiOkResponse({ description: '수정된 세션 정보' })
+  @Patch(':sessionId/title')
+  @HttpCode(HttpStatus.OK)
+  updateTitle(
+    @Param('sessionId') sessionId: string,
+    @Body() dto: UpdateTitleDto,
+  ) {
+    return this.sessionService.updateTitle(sessionId, dto.title);
+  }
+}

package/apps/server/src/modules/sessions/session.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { SessionEntity } from '../../database/entities/session.entity';
+import { SessionController } from './session.controller';
+import { SessionService } from './session.service';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([SessionEntity])],
+  controllers: [SessionController],
+  providers: [SessionService],
+  exports: [SessionService],
+})
+export class SessionModule {}

package/apps/server/src/modules/sessions/session.service.spec.ts

@@ -0,0 +1,106 @@
+import { NotFoundException } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+
+import { SessionEntity } from '../../database/entities/session.entity';
+import { SessionService } from './session.service';
+
+const mockRepo = () => ({
+  findOne: jest.fn(),
+  find: jest.fn(),
+});
+
+describe('SessionService', () => {
+  let service: SessionService;
+  let repo: ReturnType<typeof mockRepo>;
+
+  const baseSession: SessionEntity = {
+    sessionId: 'sess-uuid-1',
+    agentType: 'claude',
+    title: 'Test Session',
+    createdAt: new Date('2024-01-01'),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        SessionService,
+        { provide: getRepositoryToken(SessionEntity), useFactory: mockRepo },
+      ],
+    }).compile();
+
+    service = module.get(SessionService);
+    repo = module.get(getRepositoryToken(SessionEntity));
+  });
+
+  afterEach(() => jest.clearAllMocks());
+
+  // ─── findAll ─────────────────────────────────────────────────────────────
+
+  describe('findAll', () => {
+    it('전체 세션 목록을 최신순으로 반환한다', async () => {
+      repo.find.mockResolvedValue([baseSession]);
+
+      const result = await service.findAll();
+
+      expect(result).toEqual([baseSession]);
+      expect(repo.find).toHaveBeenCalledWith({
+        where: undefined,
+        order: { createdAt: 'DESC' },
+      });
+    });
+
+    it('agentType 필터로 세션을 조회한다', async () => {
+      repo.find.mockResolvedValue([baseSession]);
+
+      const result = await service.findAll('claude');
+
+      expect(result).toEqual([baseSession]);
+      expect(repo.find).toHaveBeenCalledWith({
+        where: { agentType: 'claude' },
+        order: { createdAt: 'DESC' },
+      });
+    });
+
+    it('gemini agentType 필터를 지원한다', async () => {
+      const geminiSession = { ...baseSession, agentType: 'gemini' };
+      repo.find.mockResolvedValue([geminiSession]);
+
+      const result = await service.findAll('gemini');
+
+      expect(result).toEqual([geminiSession]);
+      expect(repo.find).toHaveBeenCalledWith({
+        where: { agentType: 'gemini' },
+        order: { createdAt: 'DESC' },
+      });
+    });
+
+    it('결과가 없으면 빈 배열을 반환한다', async () => {
+      repo.find.mockResolvedValue([]);
+
+      const result = await service.findAll();
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  // ─── findOne ─────────────────────────────────────────────────────────────
+
+  describe('findOne', () => {
+    it('sessionId로 세션을 조회한다', async () => {
+      repo.findOne.mockResolvedValue(baseSession);
+
+      const result = await service.findOne('sess-uuid-1');
+
+      expect(result).toBe(baseSession);
+      expect(repo.findOne).toHaveBeenCalledWith({ where: { sessionId: 'sess-uuid-1' } });
+    });
+
+    it('존재하지 않는 sessionId는 NotFoundException을 던진다', async () => {
+      repo.findOne.mockResolvedValue(null);
+
+      await expect(service.findOne('not-exist')).rejects.toThrow(NotFoundException);
+      await expect(service.findOne('not-exist')).rejects.toThrow('Session not-exist not found');
+    });
+  });
+});

package/apps/server/src/modules/sessions/session.service.ts

@@ -0,0 +1,35 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { SessionEntity } from '../../database/entities/session.entity';
+
+@Injectable()
+export class SessionService {
+  constructor(
+    @InjectRepository(SessionEntity)
+    private readonly repo: Repository<SessionEntity>,
+  ) {}
+
+  /** 전체 세션 목록 (최신순), agentType 필터 옵션 */
+  findAll(agentType?: string): Promise<SessionEntity[]> {
+    return this.repo.find({
+      where: agentType ? { agentType } : undefined,
+      order: { createdAt: 'DESC' },
+    });
+  }
+
+  /** 단건 조회 */
+  async findOne(sessionId: string): Promise<SessionEntity> {
+    const entity = await this.repo.findOne({ where: { sessionId } });
+    if (!entity) throw new NotFoundException(`Session ${sessionId} not found`);
+    return entity;
+  }
+
+  /** 타이틀 업데이트 */
+  async updateTitle(sessionId: string, title: string): Promise<SessionEntity> {
+    const entity = await this.findOne(sessionId);
+    entity.title = title;
+    return this.repo.save(entity);
+  }
+}

package/apps/server/src/modules/tasks/dto/create-task.dto.ts

@@ -0,0 +1,54 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { IsArray, IsOptional, IsString, ValidateNested } from 'class-validator';
+
+export class CreateRequirementDto {
+  @ApiProperty({ example: 'TypeScript로 마이그레이션', description: '요구 사항 내용' })
+  @IsString()
+  content!: string;
+
+  @ApiPropertyOptional({ example: 0, description: '순서 인덱스' })
+  @IsOptional()
+  orderIndex?: number;
+}
+
+export class CreateAgentDto {
+  @ApiPropertyOptional({ enum: ['claude', 'gemini'], example: 'claude', description: '에이전트 종류' })
+  @IsOptional()
+  @IsString()
+  agentType?: string;
+
+  @ApiProperty({ example: 'developer', description: '에이전트 역할' })
+  @IsString()
+  role!: string;
+
+  @ApiPropertyOptional({ example: '시니어 백엔드 개발자', description: '커스텀 역할 설명' })
+  @IsOptional()
+  @IsString()
+  customRole?: string;
+}
+
+export class CreateTaskDto {
+  @ApiProperty({ example: 'API 리팩터링', description: '작업 제목' })
+  @IsString()
+  title!: string;
+
+  @ApiPropertyOptional({ example: '/Users/me/my-project', description: '작업 디렉토리' })
+  @IsOptional()
+  @IsString()
+  workingDir?: string;
+
+  @ApiPropertyOptional({ type: [CreateRequirementDto], description: '요구 사항 목록' })
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => CreateRequirementDto)
+  requirements?: CreateRequirementDto[];
+
+  @ApiPropertyOptional({ type: [CreateAgentDto], description: '투입 에이전트 목록' })
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => CreateAgentDto)
+  agents?: CreateAgentDto[];
+}

package/apps/server/src/modules/tasks/dto/execute-task.dto.ts

@@ -0,0 +1,22 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { IsArray, IsBoolean, IsNumber, IsOptional, ValidateNested } from 'class-validator';
+
+export class AgentTestCodePreferenceDto {
+  @ApiPropertyOptional({ example: 1, description: '에이전트 ID' })
+  @IsNumber()
+  agentId!: number;
+
+  @ApiPropertyOptional({ example: true, description: '테스트 코드 작성 여부' })
+  @IsBoolean()
+  writeTestCode!: boolean;
+}
+
+export class ExecuteTaskDto {
+  @ApiPropertyOptional({ type: [AgentTestCodePreferenceDto], description: '에이전트별 테스트 코드 작성 여부' })
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => AgentTestCodePreferenceDto)
+  agentTestCodePreferences?: AgentTestCodePreferenceDto[];
+}

package/apps/server/src/modules/tasks/dto/merge-file.dto.ts

@@ -0,0 +1,7 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class MergeFileDto {
+  @IsString()
+  @IsNotEmpty()
+  filePath!: string;
+}