@jcjeon/integration-cli 0.2.0 → 0.2.1

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

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

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

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

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

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

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

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

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

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

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