@jcjeon/integration-cli 0.2.0 → 0.2.1

package/apps/server/src/modules/tasks/task.gateway.ts

@@ -1,140 +0,0 @@
-import { Logger } from '@nestjs/common';
-import {
-  ConnectedSocket,
-  MessageBody,
-  OnGatewayConnection,
-  OnGatewayDisconnect,
-  OnGatewayInit,
-  SubscribeMessage,
-  WebSocketGateway,
-  WebSocketServer,
-} from '@nestjs/websockets';
-import { Server, Socket } from 'socket.io';
-
-import { TaskExecutionService } from './task-execution.service';
-import type {
-  AgentDoneEvent,
-  AgentErrorEvent,
-  AgentOutputEvent,
-  AgentToolEvent,
-  TaskStatusEvent,
-} from './task-execution.service';
-
-/**
- * WebSocket 프로토콜 (/tasks 네임스페이스)
- *
- * Client → Server
- *   task:subscribe    { taskId }  특정 태스크 룸 구독 (에이전트 출력 수신)
- *   task:unsubscribe  { taskId }  특정 태스크 룸 구독 해제
- *   task:get-logs     { taskId }  버퍼된 로그 요청 (늦은 구독자)
- *   task:watch-all              전역 알림 룸 구독 (모든 task:status 수신)
- *   task:unwatch-all            전역 알림 룸 구독 해제
- *
- * Server → Client
- *   agent:output        { taskId, agentId, text }
- *   agent:tool          { taskId, agentId, tool, input }
- *   agent:done          { taskId, agentId, result, isError, durationMs, costUsd }
- *   agent:error         { taskId, agentId, message }
- *   task:status         { taskId, status, title? }  — 특정 룸 + 전역 알림 룸
- *   task:buffered-logs  { taskId, logs }
- */
-
-const NOTIFICATIONS_ROOM = 'task:notifications';
-
-@WebSocketGateway({ namespace: '/tasks', cors: { origin: '*' } })
-export class TaskGateway implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect {
-  @WebSocketServer()
-  private readonly server!: Server;
-
-  private readonly logger = new Logger(TaskGateway.name);
-
-  constructor(private readonly executionService: TaskExecutionService) {}
-
-  afterInit(): void {
-    this.executionService.on('agent:output', (e: AgentOutputEvent) => {
-      this.server.to(`task:${e.taskId}`).emit('agent:output', e);
-    });
-
-    this.executionService.on('agent:tool', (e: AgentToolEvent) => {
-      this.server.to(`task:${e.taskId}`).emit('agent:tool', e);
-    });
-
-    this.executionService.on('agent:done', (e: AgentDoneEvent) => {
-      this.server.to(`task:${e.taskId}`).emit('agent:done', e);
-    });
-
-    this.executionService.on('agent:error', (e: AgentErrorEvent) => {
-      this.server.to(`task:${e.taskId}`).emit('agent:error', e);
-    });
-
-    this.executionService.on('task:status', (e: TaskStatusEvent) => {
-      // 1. 특정 태스크 룸 (에이전트 출력 패널용)
-      this.server.to(`task:${e.taskId}`).emit('task:status', e);
-      // 2. 전역 알림 룸 (useTaskNotification 구독자 전체)
-      this.server.to(NOTIFICATIONS_ROOM).emit('task:status', e);
-    });
-
-    this.logger.log('TaskGateway initialised — namespace: /tasks');
-  }
-
-  handleConnection(client: Socket): void {
-    this.logger.debug(`Client connected: ${client.id}`);
-  }
-
-  handleDisconnect(client: Socket): void {
-    this.logger.debug(`Client disconnected: ${client.id}`);
-  }
-
-  // ─── 특정 태스크 구독 ─────────────────────────────────────────────────────
-
-  @SubscribeMessage('task:subscribe')
-  handleSubscribe(
-    @ConnectedSocket() client: Socket,
-    @MessageBody('taskId') taskId: string,
-  ): void {
-    void client.join(`task:${taskId}`);
-    this.logger.debug(`${client.id} subscribed to task:${taskId}`);
-  }
-
-  @SubscribeMessage('task:unsubscribe')
-  handleUnsubscribe(
-    @ConnectedSocket() client: Socket,
-    @MessageBody('taskId') taskId: string,
-  ): void {
-    void client.leave(`task:${taskId}`);
-  }
-
-  /** 늦은 구독자용 — 버퍼 우선, 없으면 DB에서 복원 */
-  @SubscribeMessage('task:get-logs')
-  handleGetLogs(
-    @ConnectedSocket() client: Socket,
-    @MessageBody('taskId') taskId: string,
-  ): void {
-    const buffered = this.executionService.getBufferedLogs(taskId);
-
-    if (buffered.length > 0) {
-      client.emit('task:buffered-logs', { taskId, logs: buffered });
-      return;
-    }
-
-    // 서버 재시작 후 버퍼 소실 — DB에서 복원
-    void this.executionService.getLogsFromDb(taskId).then((logs) => {
-      client.emit('task:buffered-logs', { taskId, logs });
-    });
-  }
-
-  // ─── 전역 알림 룸 ─────────────────────────────────────────────────────────
-
-  /** 모든 task:status 이벤트를 받는 전역 알림 룸 가입 */
-  @SubscribeMessage('task:watch-all')
-  handleWatchAll(@ConnectedSocket() client: Socket): void {
-    void client.join(NOTIFICATIONS_ROOM);
-    this.logger.debug(`${client.id} joined notifications room`);
-  }
-
-  /** 전역 알림 룸 탈퇴 */
-  @SubscribeMessage('task:unwatch-all')
-  handleUnwatchAll(@ConnectedSocket() client: Socket): void {
-    void client.leave(NOTIFICATIONS_ROOM);
-  }
-}

package/apps/server/src/modules/tasks/tasks.controller.spec.ts

@@ -1,210 +0,0 @@
-import { Test, TestingModule } from '@nestjs/testing';
-
-import { TasksController } from './tasks.controller';
-import { TasksService } from './tasks.service';
-import type { TaskEntity } from '../../database/entities/task.entity';
-import type { TaskRunEntity } from '../../database/entities/task-run.entity';
-
-const mockTask: TaskEntity = {
-  id: 'task-1',
-  title: 'Test Task',
-  status: 'pending',
-  workingDir: '/tmp/project',
-  claudeSessionId: null,
-  archived: false,
-  createdAt: new Date('2024-01-01'),
-  updatedAt: new Date('2024-01-01'),
-  requirements: [],
-  agents: [],
-};
-
-describe('TasksController', () => {
-  let controller: TasksController;
-  let service: jest.Mocked<TasksService>;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      controllers: [TasksController],
-      providers: [
-        {
-          provide: TasksService,
-          useValue: {
-            create: jest.fn(),
-            findAll: jest.fn(),
-            findOne: jest.fn(),
-            update: jest.fn(),
-            execute: jest.fn(),
-            stop: jest.fn(),
-            rerun: jest.fn(),
-            rerunAgent: jest.fn(),
-            getRuns: jest.fn(),
-            archive: jest.fn(),
-            mergeAgentAll: jest.fn(),
-            mergeAgentFile: jest.fn(),
-            remove: jest.fn(),
-          },
-        },
-      ],
-    }).compile();
-
-    controller = module.get(TasksController);
-    service = module.get(TasksService) as jest.Mocked<TasksService>;
-  });
-
-  afterEach(() => jest.clearAllMocks());
-
-  describe('create', () => {
-    it('service.create를 호출하고 결과를 반환한다', async () => {
-      service.create.mockResolvedValue(mockTask);
-
-      const result = await controller.create({ title: 'Test Task' });
-
-      expect(service.create).toHaveBeenCalledWith({ title: 'Test Task' });
-      expect(result).toBe(mockTask);
-    });
-  });
-
-  describe('findAll', () => {
-    it('service.findAll를 호출하고 task 목록을 반환한다', async () => {
-      service.findAll.mockResolvedValue([mockTask]);
-
-      const result = await controller.findAll();
-
-      expect(service.findAll).toHaveBeenCalled();
-      expect(result).toEqual([mockTask]);
-    });
-  });
-
-  describe('findOne', () => {
-    it('service.findOne를 id와 함께 호출한다', async () => {
-      service.findOne.mockResolvedValue(mockTask);
-
-      const result = await controller.findOne('task-1');
-
-      expect(service.findOne).toHaveBeenCalledWith('task-1');
-      expect(result).toBe(mockTask);
-    });
-  });
-
-  describe('update', () => {
-    it('service.update를 id와 dto와 함께 호출한다', async () => {
-      const updated = { ...mockTask, title: 'Updated' };
-      service.update.mockResolvedValue(updated);
-
-      const result = await controller.update('task-1', { title: 'Updated' });
-
-      expect(service.update).toHaveBeenCalledWith('task-1', { title: 'Updated' });
-      expect(result).toBe(updated);
-    });
-  });
-
-  describe('execute', () => {
-    it('service.execute를 호출한다', async () => {
-      const running = { ...mockTask, status: 'running' };
-      service.execute.mockResolvedValue(running);
-
-      const result = await controller.execute('task-1', { agentTestCodePreferences: [{ agentId: 1, writeTestCode: true }] });
-
-      expect(service.execute).toHaveBeenCalledWith('task-1', [{ agentId: 1, writeTestCode: true }]);
-      expect(result).toBe(running);
-    });
-  });
-
-  describe('stop', () => {
-    it('service.stop를 호출한다', async () => {
-      const stopped = { ...mockTask, status: 'stopped' };
-      service.stop.mockResolvedValue(stopped);
-
-      const result = await controller.stop('task-1');
-
-      expect(service.stop).toHaveBeenCalledWith('task-1');
-      expect(result).toBe(stopped);
-    });
-  });
-
-  describe('rerun', () => {
-    it('service.rerun을 supplementNote와 함께 호출한다', async () => {
-      service.rerun.mockResolvedValue(mockTask);
-
-      const result = await controller.rerun('task-1', { supplementNote: '보완 작업' });
-
-      expect(service.rerun).toHaveBeenCalledWith('task-1', '보완 작업', undefined);
-      expect(result).toBe(mockTask);
-    });
-
-    it('supplementNote 없이 호출할 수 있다', async () => {
-      service.rerun.mockResolvedValue(mockTask);
-
-      await controller.rerun('task-1', {});
-
-      expect(service.rerun).toHaveBeenCalledWith('task-1', undefined, undefined);
-    });
-  });
-
-  describe('rerunAgent', () => {
-    it('service.rerunAgent를 agentId와 supplementNote로 호출한다', async () => {
-      service.rerunAgent.mockResolvedValue(mockTask);
-
-      const result = await controller.rerunAgent('task-1', '2', { supplementNote: 'agent only', writeTestCode: true });
-
-      expect(service.rerunAgent).toHaveBeenCalledWith('task-1', 2, 'agent only', true);
-      expect(result).toBe(mockTask);
-    });
-  });
-
-  describe('getRuns', () => {
-    it('service.getRuns를 호출하고 실행 이력을 반환한다', async () => {
-      const runs: TaskRunEntity[] = [
-        { id: 1, taskId: 'task-1', version: 1, supplementNote: null, status: 'completed', startedAt: new Date(), completedAt: null, task: mockTask, agentRuns: [] },
-      ];
-      service.getRuns.mockResolvedValue(runs);
-
-      const result = await controller.getRuns('task-1');
-
-      expect(service.getRuns).toHaveBeenCalledWith('task-1');
-      expect(result).toBe(runs);
-    });
-  });
-
-  describe('archive', () => {
-    it('service.archive를 호출한다', async () => {
-      service.archive.mockResolvedValue(undefined);
-
-      await controller.archive('task-1');
-
-      expect(service.archive).toHaveBeenCalledWith('task-1');
-    });
-  });
-
-  describe('mergeAgentAll', () => {
-    it('service.mergeAgentAll을 id와 agentId로 호출한다', async () => {
-      service.mergeAgentAll.mockResolvedValue({ success: true, message: '완료' });
-
-      const result = await controller.mergeAgentAll('task-1', '2');
-
-      expect(service.mergeAgentAll).toHaveBeenCalledWith('task-1', 2);
-      expect(result).toEqual({ success: true, message: '완료' });
-    });
-  });
-
-  describe('mergeAgentFile', () => {
-    it('service.mergeAgentFile을 filePath와 함께 호출한다', async () => {
-      service.mergeAgentFile.mockResolvedValue({ success: true, message: '완료' });
-
-      const result = await controller.mergeAgentFile('task-1', '2', { filePath: 'src/app.ts' });
-
-      expect(service.mergeAgentFile).toHaveBeenCalledWith('task-1', 2, 'src/app.ts');
-      expect(result).toEqual({ success: true, message: '완료' });
-    });
-  });
-
-  describe('remove', () => {
-    it('service.remove를 호출한다', async () => {
-      service.remove.mockResolvedValue(undefined);
-
-      await controller.remove('task-1');
-
-      expect(service.remove).toHaveBeenCalledWith('task-1');
-    });
-  });
-});

package/apps/server/src/modules/tasks/tasks.controller.ts

@@ -1,139 +0,0 @@
-import {
-  Body,
-  Controller,
-  Delete,
-  Get,
-  HttpCode,
-  HttpStatus,
-  Param,
-  Patch,
-  Post,
-  UsePipes,
-  ValidationPipe,
-} from '@nestjs/common';
-import { ApiNoContentResponse, ApiOkResponse, ApiOperation, ApiTags } from '@nestjs/swagger';
-
-import { CreateTaskDto } from './dto/create-task.dto';
-import { ExecuteTaskDto } from './dto/execute-task.dto';
-import { MergeFileDto } from './dto/merge-file.dto';
-import { RerunTaskDto } from './dto/rerun-task.dto';
-import { UpdateTaskDto } from './dto/update-task.dto';
-import { TasksService } from './tasks.service';
-
-@ApiTags('tasks')
-@UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-@Controller('tasks')
-export class TasksController {
-  constructor(private readonly tasksService: TasksService) {}
-
-  @ApiOperation({ summary: '작업 생성' })
-  @ApiOkResponse({ description: '생성된 작업 정보' })
-  @Post()
-  create(@Body() dto: CreateTaskDto) {
-    return this.tasksService.create(dto);
-  }
-
-  @ApiOperation({ summary: '전체 작업 목록 조회' })
-  @ApiOkResponse({ description: '작업 목록 (에이전트 로그 포함)' })
-  @Get()
-  findAll() {
-    return this.tasksService.findAll();
-  }
-
-  @ApiOperation({ summary: '특정 작업 조회' })
-  @ApiOkResponse({ description: '작업 상세 정보' })
-  @Get(':id')
-  findOne(@Param('id') id: string) {
-    return this.tasksService.findOne(id);
-  }
-
-  @ApiOperation({ summary: '작업 수정 (제목·디렉토리·요구사항·에이전트)' })
-  @ApiOkResponse({ description: '수정된 작업 정보' })
-  @Patch(':id')
-  update(@Param('id') id: string, @Body() dto: UpdateTaskDto) {
-    return this.tasksService.update(id, dto);
-  }
-
-  @ApiOperation({
-    summary: '작업 실행',
-    description: '실시간 출력은 WebSocket `/tasks` 네임스페이스의 `agent:output` / `task:status` 이벤트로 수신',
-  })
-  @ApiOkResponse({ description: '실행 시작 확인' })
-  @Post(':id/execute')
-  @HttpCode(HttpStatus.OK)
-  execute(@Param('id') id: string, @Body() dto: ExecuteTaskDto = {}) {
-    return this.tasksService.execute(id, dto.agentTestCodePreferences);
-  }
-
-  @ApiOperation({ summary: '실행 중인 작업 중지' })
-  @ApiOkResponse({ description: '중지 확인' })
-  @Post(':id/stop')
-  @HttpCode(HttpStatus.OK)
-  stop(@Param('id') id: string) {
-    return this.tasksService.stop(id);
-  }
-
-  @ApiOperation({ summary: '작업 재실행', description: '보완 메모를 추가하여 동일 작업을 다시 실행' })
-  @ApiOkResponse({ description: '재실행 시작 확인' })
-  @Post(':id/rerun')
-  @HttpCode(HttpStatus.OK)
-  rerun(@Param('id') id: string, @Body() dto: RerunTaskDto) {
-    return this.tasksService.rerun(id, dto.supplementNote, dto.writeTestCode);
-  }
-
-  @ApiOperation({ summary: '에이전트 단위 작업 재실행', description: '보완 메모를 추가하여 특정 에이전트만 다시 실행' })
-  @ApiOkResponse({ description: '에이전트 재실행 시작 확인' })
-  @Post(':id/agents/:agentId/rerun')
-  @HttpCode(HttpStatus.OK)
-  rerunAgent(
-    @Param('id') id: string,
-    @Param('agentId') agentId: string,
-    @Body() dto: RerunTaskDto,
-  ) {
-    return this.tasksService.rerunAgent(id, Number(agentId), dto.supplementNote, dto.writeTestCode);
-  }
-
-  @ApiOperation({ summary: '실행 버전 이력 조회' })
-  @ApiOkResponse({ description: '버전별 실행 기록 (supplementNote, 상태, 에이전트 결과 포함)' })
-  @Get(':id/runs')
-  getRuns(@Param('id') id: string) {
-    return this.tasksService.getRuns(id);
-  }
-
-  @ApiOperation({ summary: '작업 보관' })
-  @ApiNoContentResponse({ description: '보관 완료 (응답 본문 없음)' })
-  @Post(':id/archive')
-  @HttpCode(HttpStatus.NO_CONTENT)
-  archive(@Param('id') id: string) {
-    return this.tasksService.archive(id);
-  }
-
-  @ApiOperation({ summary: '에이전트 전체 변경사항 병합' })
-  @ApiOkResponse({ description: '병합 결과' })
-  @Post(':id/agents/:agentId/merge')
-  mergeAgentAll(
-    @Param('id') id: string,
-    @Param('agentId') agentId: string,
-  ) {
-    return this.tasksService.mergeAgentAll(id, Number(agentId));
-  }
-
-  @ApiOperation({ summary: '에이전트 단일 파일 병합' })
-  @ApiOkResponse({ description: '병합 결과' })
-  @Post(':id/agents/:agentId/merge-file')
-  mergeAgentFile(
-    @Param('id') id: string,
-    @Param('agentId') agentId: string,
-    @Body() dto: MergeFileDto,
-  ) {
-    return this.tasksService.mergeAgentFile(id, Number(agentId), dto.filePath);
-  }
-
-  @ApiOperation({ summary: '작업 삭제' })
-  @ApiNoContentResponse({ description: '삭제 완료 (응답 본문 없음)' })
-  @Delete(':id')
-  @HttpCode(HttpStatus.NO_CONTENT)
-  remove(@Param('id') id: string) {
-    return this.tasksService.remove(id);
-  }
-}

package/apps/server/src/modules/tasks/tasks.module.ts

@@ -1,30 +0,0 @@
-import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-
-import { TaskAgentEntity } from '../../database/entities/task-agent.entity';
-import { TaskAgentRunEntity } from '../../database/entities/task-agent-run.entity';
-import { TaskRequirementEntity } from '../../database/entities/task-requirement.entity';
-import { TaskEntity } from '../../database/entities/task.entity';
-import { TaskRunEntity } from '../../database/entities/task-run.entity';
-import { GeminiModule } from '../agents/gemini/gemini.module';
-import { ConversationModule } from '../conversations/conversation.module';
-import { ChangelogModule } from '../changelog/changelog.module';
-import { HarnessModule } from '../harness/harness.module';
-import { TaskExecutionService } from './task-execution.service';
-import { TaskGateway } from './task.gateway';
-import { TasksController } from './tasks.controller';
-import { TasksService } from './tasks.service';
-
-@Module({
-  imports: [
-    TypeOrmModule.forFeature([TaskEntity, TaskRequirementEntity, TaskAgentEntity, TaskRunEntity, TaskAgentRunEntity]),
-    GeminiModule,
-    ConversationModule,
-    ChangelogModule,
-    HarnessModule,
-  ],
-  controllers: [TasksController],
-  providers: [TasksService, TaskExecutionService, TaskGateway],
-  exports: [TasksService],
-})
-export class TasksModule {}