@jcjeon/integration-cli 0.2.0

package/apps/server/src/modules/conversations/conversation.controller.spec.ts

@@ -0,0 +1,106 @@
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { ConversationEntity } from '../../database/entities/conversation.entity';
+import { ConversationController } from './conversation.controller';
+import { ConversationService } from './conversation.service';
+import { AgentModel, ConversationType } from './enums/conversation.enum';
+
+const baseConversation: ConversationEntity = {
+  id: 'conv-uuid-1',
+  sessionId: 'session-1',
+  promptId: 'prompt-1',
+  agentId: null,
+  runId: null,
+  content: '코드 분석해줘',
+  agentModel: AgentModel.CLAUDE,
+  type: ConversationType.USER_MESSAGE,
+  createdAt: new Date('2024-01-01'),
+};
+
+describe('ConversationController', () => {
+  let controller: ConversationController;
+  let service: jest.Mocked<ConversationService>;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [ConversationController],
+      providers: [
+        {
+          provide: ConversationService,
+          useValue: {
+            create: jest.fn(),
+            findBySession: jest.fn(),
+            findOne: jest.fn(),
+            remove: jest.fn(),
+            removeBySession: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    controller = module.get(ConversationController);
+    service = module.get(ConversationService) as jest.Mocked<ConversationService>;
+  });
+
+  afterEach(() => jest.clearAllMocks());
+
+  describe('create', () => {
+    it('service.create를 호출하고 결과를 반환한다', async () => {
+      service.create.mockResolvedValue(baseConversation);
+
+      const dto = {
+        sessionId: 'session-1',
+        promptId: 'prompt-1',
+        content: '코드 분석해줘',
+        agentModel: AgentModel.CLAUDE,
+        type: ConversationType.USER_MESSAGE,
+      };
+      const result = await controller.create(dto);
+
+      expect(service.create).toHaveBeenCalledWith(dto);
+      expect(result).toBe(baseConversation);
+    });
+  });
+
+  describe('findBySession', () => {
+    it('service.findBySession을 sessionId로 호출한다', async () => {
+      service.findBySession.mockResolvedValue([baseConversation]);
+
+      const result = await controller.findBySession('session-1');
+
+      expect(service.findBySession).toHaveBeenCalledWith('session-1');
+      expect(result).toEqual([baseConversation]);
+    });
+  });
+
+  describe('findOne', () => {
+    it('service.findOne을 id로 호출한다', async () => {
+      service.findOne.mockResolvedValue(baseConversation);
+
+      const result = await controller.findOne('conv-uuid-1');
+
+      expect(service.findOne).toHaveBeenCalledWith('conv-uuid-1');
+      expect(result).toBe(baseConversation);
+    });
+  });
+
+  describe('remove', () => {
+    it('service.remove를 id로 호출한다', async () => {
+      service.remove.mockResolvedValue(undefined);
+
+      await controller.remove('conv-uuid-1');
+
+      expect(service.remove).toHaveBeenCalledWith('conv-uuid-1');
+    });
+  });
+
+  describe('removeBySession', () => {
+    it('service.removeBySession을 sessionId로 호출한다', async () => {
+      service.removeBySession.mockResolvedValue(undefined);
+
+      await controller.removeBySession('session-1');
+
+      expect(service.removeBySession).toHaveBeenCalledWith('session-1');
+    });
+  });
+});

package/apps/server/src/modules/conversations/conversation.controller.ts

@@ -0,0 +1,60 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  Post,
+  UsePipes,
+  ValidationPipe,
+} from '@nestjs/common';
+import { ApiNoContentResponse, ApiOkResponse, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { ConversationService } from './conversation.service';
+import { CreateConversationDto } from './dto/create-conversation.dto';
+
+@ApiTags('conversations')
+@UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
+@Controller('conversations')
+export class ConversationController {
+  constructor(private readonly conversationService: ConversationService) {}
+
+  @ApiOperation({ summary: '대화 메시지 저장' })
+  @ApiOkResponse({ description: '저장된 대화 레코드' })
+  @Post()
+  create(@Body() dto: CreateConversationDto) {
+    return this.conversationService.create(dto);
+  }
+
+  @ApiOperation({ summary: '세션의 전체 대화 조회' })
+  @ApiOkResponse({ description: '대화 목록 (시간순)' })
+  @Get('session/:sessionId')
+  findBySession(@Param('sessionId') sessionId: string) {
+    return this.conversationService.findBySession(sessionId);
+  }
+
+  @ApiOperation({ summary: '대화 단건 조회' })
+  @ApiOkResponse({ description: '대화 레코드' })
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.conversationService.findOne(id);
+  }
+
+  @ApiOperation({ summary: '대화 단건 삭제' })
+  @ApiNoContentResponse({ description: '삭제 완료 (응답 본문 없음)' })
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  remove(@Param('id') id: string) {
+    return this.conversationService.remove(id);
+  }
+
+  @ApiOperation({ summary: '세션 전체 대화 삭제' })
+  @ApiNoContentResponse({ description: '삭제 완료 (응답 본문 없음)' })
+  @Delete('session/:sessionId')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  removeBySession(@Param('sessionId') sessionId: string) {
+    return this.conversationService.removeBySession(sessionId);
+  }
+}

package/apps/server/src/modules/conversations/conversation.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { ConversationEntity } from '../../database/entities/conversation.entity';
+import { ConversationController } from './conversation.controller';
+import { ConversationService } from './conversation.service';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([ConversationEntity])],
+  controllers: [ConversationController],
+  providers: [ConversationService],
+  exports: [ConversationService],
+})
+export class ConversationModule {}

package/apps/server/src/modules/conversations/conversation.service.spec.ts

@@ -0,0 +1,176 @@
+import { NotFoundException } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+
+import { ConversationEntity } from '../../database/entities/conversation.entity';
+import { AgentModel, ConversationType } from './enums/conversation.enum';
+import { ConversationService } from './conversation.service';
+
+const mockRepo = () => ({
+  create: jest.fn((dto: any) => ({ ...dto })),
+  save: jest.fn((e: any) => Promise.resolve(e)),
+  findOne: jest.fn(),
+  find: jest.fn(),
+  remove: jest.fn().mockResolvedValue({}),
+  delete: jest.fn().mockResolvedValue({}),
+});
+
+describe('ConversationService', () => {
+  let service: ConversationService;
+  let repo: ReturnType<typeof mockRepo>;
+
+  const baseConversation: ConversationEntity = {
+    id: 'conv-uuid-1',
+    sessionId: 'session-1',
+    promptId: 'prompt-1',
+    agentId: null,
+    runId: null,
+    content: '코드 분석해줘',
+    agentModel: AgentModel.CLAUDE,
+    type: ConversationType.USER_MESSAGE,
+    createdAt: new Date('2024-01-01'),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        ConversationService,
+        { provide: getRepositoryToken(ConversationEntity), useFactory: mockRepo },
+      ],
+    }).compile();
+
+    service = module.get(ConversationService);
+    repo = module.get(getRepositoryToken(ConversationEntity));
+  });
+
+  afterEach(() => jest.clearAllMocks());
+
+  // ─── create ──────────────────────────────────────────────────────────────
+
+  describe('create', () => {
+    it('대화 메시지를 생성하고 저장한다', async () => {
+      repo.save.mockResolvedValue(baseConversation);
+
+      const dto = {
+        sessionId: 'session-1',
+        promptId: 'prompt-1',
+        content: '코드 분석해줘',
+        agentModel: AgentModel.CLAUDE,
+        type: ConversationType.USER_MESSAGE,
+      };
+      const result = await service.create(dto);
+
+      expect(repo.create).toHaveBeenCalledWith(dto);
+      expect(repo.save).toHaveBeenCalled();
+      expect(result).toBe(baseConversation);
+    });
+
+    it('agentId와 runId를 포함한 메시지를 생성한다', async () => {
+      const withIds = { ...baseConversation, agentId: 5, runId: 2 };
+      repo.save.mockResolvedValue(withIds);
+
+      const dto = {
+        sessionId: 'session-1',
+        promptId: 'prompt-1',
+        content: 'agent response',
+        agentModel: AgentModel.CLAUDE,
+        type: ConversationType.AGENT_MESSAGE,
+        agentId: 5,
+        runId: 2,
+      };
+      const result = await service.create(dto);
+
+      expect(result.agentId).toBe(5);
+      expect(result.runId).toBe(2);
+    });
+  });
+
+  // ─── findBySession ───────────────────────────────────────────────────────
+
+  describe('findBySession', () => {
+    it('세션의 전체 대화를 생성 시간 오름차순으로 반환한다', async () => {
+      repo.find.mockResolvedValue([baseConversation]);
+
+      const result = await service.findBySession('session-1');
+
+      expect(result).toEqual([baseConversation]);
+      expect(repo.find).toHaveBeenCalledWith({
+        where: { sessionId: 'session-1' },
+        order: { createdAt: 'ASC' },
+      });
+    });
+
+    it('대화가 없으면 빈 배열을 반환한다', async () => {
+      repo.find.mockResolvedValue([]);
+
+      const result = await service.findBySession('empty-session');
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  // ─── findByRun ───────────────────────────────────────────────────────────
+
+  describe('findByRun', () => {
+    it('run의 대화를 생성 시간 오름차순으로 반환한다', async () => {
+      const runConv = { ...baseConversation, runId: 3 };
+      repo.find.mockResolvedValue([runConv]);
+
+      const result = await service.findByRun(3);
+
+      expect(result).toEqual([runConv]);
+      expect(repo.find).toHaveBeenCalledWith({
+        where: { runId: 3 },
+        order: { createdAt: 'ASC' },
+      });
+    });
+  });
+
+  // ─── findOne ─────────────────────────────────────────────────────────────
+
+  describe('findOne', () => {
+    it('ID로 대화를 조회한다', async () => {
+      repo.findOne.mockResolvedValue(baseConversation);
+
+      const result = await service.findOne('conv-uuid-1');
+
+      expect(result).toBe(baseConversation);
+      expect(repo.findOne).toHaveBeenCalledWith({ where: { id: 'conv-uuid-1' } });
+    });
+
+    it('존재하지 않는 ID는 NotFoundException을 던진다', async () => {
+      repo.findOne.mockResolvedValue(null);
+
+      await expect(service.findOne('not-exist')).rejects.toThrow(NotFoundException);
+    });
+  });
+
+  // ─── remove ──────────────────────────────────────────────────────────────
+
+  describe('remove', () => {
+    it('대화를 조회 후 삭제한다', async () => {
+      repo.findOne.mockResolvedValue(baseConversation);
+
+      await service.remove('conv-uuid-1');
+
+      expect(repo.findOne).toHaveBeenCalled();
+      expect(repo.remove).toHaveBeenCalledWith(baseConversation);
+    });
+
+    it('존재하지 않는 ID는 NotFoundException을 던진다', async () => {
+      repo.findOne.mockResolvedValue(null);
+
+      await expect(service.remove('not-exist')).rejects.toThrow(NotFoundException);
+    });
+  });
+
+  // ─── removeBySession ─────────────────────────────────────────────────────
+
+  describe('removeBySession', () => {
+    it('세션의 전체 대화를 삭제한다', async () => {
+      await service.removeBySession('session-1');
+
+      expect(repo.delete).toHaveBeenCalledWith({ sessionId: 'session-1' });
+    });
+  });
+});

package/apps/server/src/modules/conversations/conversation.service.ts

@@ -0,0 +1,54 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { ConversationEntity } from '../../database/entities/conversation.entity';
+import { CreateConversationDto } from './dto/create-conversation.dto';
+
+@Injectable()
+export class ConversationService {
+  constructor(
+    @InjectRepository(ConversationEntity)
+    private readonly repo: Repository<ConversationEntity>,
+  ) {}
+
+  /** 대화 메시지 저장 */
+  create(dto: CreateConversationDto): Promise<ConversationEntity> {
+    const entity = this.repo.create(dto);
+    return this.repo.save(entity);
+  }
+
+  /** 특정 세션의 전체 대화 조회 (생성 순) */
+  findBySession(sessionId: string): Promise<ConversationEntity[]> {
+    return this.repo.find({
+      where: { sessionId },
+      order: { createdAt: 'ASC' },
+    });
+  }
+
+  /** 특정 run의 대화 조회 (생성 순) */
+  findByRun(runId: number): Promise<ConversationEntity[]> {
+    return this.repo.find({
+      where: { runId },
+      order: { createdAt: 'ASC' },
+    });
+  }
+
+  /** 단건 조회 */
+  async findOne(id: string): Promise<ConversationEntity> {
+    const entity = await this.repo.findOne({ where: { id } });
+    if (!entity) throw new NotFoundException(`Conversation ${id} not found`);
+    return entity;
+  }
+
+  /** 단건 삭제 */
+  async remove(id: string): Promise<void> {
+    const entity = await this.findOne(id);
+    await this.repo.remove(entity);
+  }
+
+  /** 세션 전체 삭제 */
+  async removeBySession(sessionId: string): Promise<void> {
+    await this.repo.delete({ sessionId });
+  }
+}

package/apps/server/src/modules/conversations/dto/create-conversation.dto.ts

@@ -0,0 +1,37 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsEnum, IsInt, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
+import { AgentModel, ConversationType } from '../enums/conversation.enum';
+
+export class CreateConversationDto {
+  @ApiProperty({ example: 'uuid-session-id', description: '세션 ID' })
+  @IsString()
+  @IsNotEmpty()
+  sessionId!: string;
+
+  @ApiProperty({ example: 'uuid-prompt-id', description: '프롬프트 ID' })
+  @IsString()
+  @IsNotEmpty()
+  promptId!: string;
+
+  @ApiProperty({ example: '코드 분석해줘', description: '메시지 내용' })
+  @IsString()
+  @IsNotEmpty()
+  content!: string;
+
+  @ApiProperty({ enum: AgentModel, example: AgentModel.CLAUDE, description: '에이전트 모델' })
+  @IsEnum(AgentModel)
+  agentModel!: AgentModel;
+
+  @ApiProperty({ enum: ConversationType, example: ConversationType.USER_MESSAGE, description: '메시지 유형' })
+  @IsEnum(ConversationType)
+  type!: ConversationType;
+
+  @IsInt()
+  @IsOptional()
+  agentId?: number | null;
+
+  @IsInt()
+  @IsOptional()
+  runId?: number | null;
+}

package/apps/server/src/modules/conversations/enums/conversation.enum.ts

@@ -0,0 +1,13 @@
+export enum AgentModel {
+  CLAUDE = 'claude',
+  CHATGPT = 'chatgpt',
+  GEMINI = 'gemini',
+  OPENCODE = 'opencode',
+  GROK = 'grok',
+  CODEX = 'codex',
+}
+
+export enum ConversationType {
+  USER_MESSAGE = 'user_message',
+  AGENT_MESSAGE = 'agent_message',
+}

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

@@ -0,0 +1,29 @@
+import { Controller, Get, Query } from '@nestjs/common';
+import { ApiOperation, ApiTags } from '@nestjs/swagger';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+@ApiTags('fs')
+@Controller('fs')
+export class FsController {
+  @ApiOperation({ summary: '하위 디렉토리 목록 조회' })
+  @Get('dirs')
+  listDirs(@Query('path') inputPath?: string) {
+    const target = inputPath
+      ? path.resolve(inputPath.replace(/^~(?=\/|$)/, os.homedir()))
+      : os.homedir();
+
+    try {
+      const entries = fs.readdirSync(target, { withFileTypes: true });
+      const dirs = entries
+        .filter((e) => e.isDirectory() && !e.name.startsWith('.'))
+        .map((e) => e.name)
+        .sort((a, b) => a.localeCompare(b));
+
+      return { path: target, dirs };
+    } catch {
+      return { path: target, dirs: [] };
+    }
+  }
+}

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

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+
+import { FsController } from './fs.controller';
+
+@Module({
+  controllers: [FsController],
+})
+export class FsModule {}

package/apps/server/src/modules/harness/dto/save-harness.dto.ts

@@ -0,0 +1,9 @@
+import { IsEnum, IsString } from 'class-validator';
+
+export class SaveHarnessDto {
+  @IsString()
+  content!: string;
+
+  @IsEnum(['md', 'tsx'])
+  ext!: 'md' | 'tsx';
+}

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

@@ -0,0 +1,95 @@
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { HarnessController } from './harness.controller';
+import { HarnessService } from './harness.service';
+import type { Harness } from './harness.service';
+
+describe('HarnessController', () => {
+  let controller: HarnessController;
+  let service: jest.Mocked<HarnessService>;
+
+  const commonHarness: Harness = { role: 'common', ext: 'md', content: '# Common Template' };
+  const frontendHarness: Harness = { role: 'frontend', ext: 'tsx', content: 'export default () => null;' };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [HarnessController],
+      providers: [
+        {
+          provide: HarnessService,
+          useValue: {
+            findAll: jest.fn(),
+            findOne: jest.fn(),
+            save: jest.fn(),
+            remove: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    controller = module.get(HarnessController);
+    service = module.get(HarnessService) as jest.Mocked<HarnessService>;
+  });
+
+  afterEach(() => jest.clearAllMocks());
+
+  describe('findAll', () => {
+    it('service.findAll을 호출하고 모든 harness를 반환한다', () => {
+      service.findAll.mockReturnValue([commonHarness, frontendHarness]);
+
+      const result = controller.findAll();
+
+      expect(service.findAll).toHaveBeenCalled();
+      expect(result).toEqual([commonHarness, frontendHarness]);
+    });
+  });
+
+  describe('findOne', () => {
+    it('harness가 존재하면 반환한다', () => {
+      service.findOne.mockReturnValue(commonHarness);
+
+      const result = controller.findOne('common');
+
+      expect(service.findOne).toHaveBeenCalledWith('common');
+      expect(result).toBe(commonHarness);
+    });
+
+    it('harness가 없으면 기본값을 반환한다', () => {
+      service.findOne.mockReturnValue(null);
+
+      const result = controller.findOne('other');
+
+      expect(result).toEqual({ role: 'other', ext: 'md', content: '' });
+    });
+  });
+
+  describe('save', () => {
+    it('service.save를 role, content, ext와 함께 호출한다', () => {
+      service.save.mockReturnValue(commonHarness);
+
+      const result = controller.save('common', { content: '# Common Template', ext: 'md' });
+
+      expect(service.save).toHaveBeenCalledWith('common', '# Common Template', 'md');
+      expect(result).toBe(commonHarness);
+    });
+
+    it('tsx 확장자로 저장할 수 있다', () => {
+      service.save.mockReturnValue(frontendHarness);
+
+      const result = controller.save('frontend', { content: 'export default () => null;', ext: 'tsx' });
+
+      expect(service.save).toHaveBeenCalledWith('frontend', 'export default () => null;', 'tsx');
+      expect(result).toBe(frontendHarness);
+    });
+  });
+
+  describe('remove', () => {
+    it('service.remove를 role과 함께 호출한다', () => {
+      service.remove.mockReturnValue(undefined);
+
+      controller.remove('common');
+
+      expect(service.remove).toHaveBeenCalledWith('common');
+    });
+  });
+});

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

@@ -0,0 +1,35 @@
+import { Body, Controller, Delete, Get, HttpCode, HttpStatus, Param, Put, UsePipes, ValidationPipe } from '@nestjs/common';
+
+import { HarnessService } from './harness.service';
+import { SaveHarnessDto } from './dto/save-harness.dto';
+
+@UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
+@Controller('harness')
+export class HarnessController {
+  constructor(private readonly harnessService: HarnessService) {}
+
+  /** GET /harness */
+  @Get()
+  findAll() {
+    return this.harnessService.findAll();
+  }
+
+  /** GET /harness/:role */
+  @Get(':role')
+  findOne(@Param('role') role: string) {
+    return this.harnessService.findOne(role) ?? { role, ext: 'md', content: '' };
+  }
+
+  /** PUT /harness/:role */
+  @Put(':role')
+  save(@Param('role') role: string, @Body() dto: SaveHarnessDto) {
+    return this.harnessService.save(role, dto.content, dto.ext);
+  }
+
+  /** DELETE /harness/:role */
+  @Delete(':role')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  remove(@Param('role') role: string) {
+    this.harnessService.remove(role);
+  }
+}

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

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+
+import { HarnessController } from './harness.controller';
+import { HarnessService } from './harness.service';
+
+@Module({
+  controllers: [HarnessController],
+  providers: [HarnessService],
+  exports: [HarnessService],
+})
+export class HarnessModule {}