사용 시나리오 가이드

WhatsApp 또는 Telegram에서:

"내일 하루를 정리해줘"
"오늘 있었던 회의 내용을 요약해줘"
"다음 주 목표를 정리해줘"

# 캘더 통합 (선택적)
clawdbot config set integrations.calendar.enabled true
clawdbot config set integrations.calendar.provider "google"

# 이메일 통합 (선택적)
clawdbot config set integrations.email.enabled true
clawdbot config set integrations.email.provider "imap"

WhatsApp에서:

"회의 내용을 바탕으로 메모를 작성해줘"
"다음 회의를 위한 아젠다를 작성해줘"
"이슈 리스트를 정리해줘"

이메일에서:

"오늘 온 이메일을 우선순위로 정리해줘"
"중요한 이메일에 대한 답변 초안을 작성해줘"
"스팸 메일에 대한 응답을 작성해줘"

Slack에서:

"이 PR을 리뷰해줘: https://github.com/user/repo/pull/123"

GitHub 링크 전송 후 Clawdbot이:
1. PR 내용 분석
2. 코드 변경사항 확인
3. 버그 또는 개선사항 식별
4. 구조화된 리뷰 작성

리뷰 요약:
- PR #123: "새로운 기능 추가"
- 변경사항: 5개 파일 수정, 300줄 추가
- 발견된 이슈: 3개 (2개 버그, 1개 개선사항)
- 승인: ✅ (코드 품질 양호, 테스트 충분)
- 권장사항: ...

Discord에서:

"WhatsApp에서 온 메시지를 정리해줘"
"Slack에서 논의 중인 주제를 요약해줘"
"Telegram에서의 투표 내용을 요약해줘"

채널별 요약:

WhatsApp (개인 DM):
- 발신자: A님
- 내용: 프로젝트 일정 문의
- 중요도: 높음

Slack (팀 채널):
- 채널: #development
- 활동량: 지난 1시간 동안 25개 메시지
- 주제: Q3 리뷰 준비, 코드 리팩토링
- 결론: 개발자들이 Q3 리뷰를 진행 중

Telegram (그룹):
- 채널: @project_updates
- 활동량: 지난 24시간 동안 15개 메시지
- 주제: 신규 기능 발표
- 결론: 새로운 기능이 곧 출시될 예정

통합 요약:
- 총 3개 채널에서 활동 발생
- 주요 이슈: Q3 리뷰 준비, 새로운 기능 발표
- 권장사항: WhatsApp에서의 일정 문의를 우선 처리 필요

Discord에서:

"WhatsApp 그룹에서 논의된 내용을 Slack 팀 채널로 전달해줘"
"Slack에서 결정된 사항을 Telegram 그룹으로 알려줘"

Discord (WhatsApp 그룹) → Slack:
"Q3 리뷰 준비를 위해 다음 아젠다를 정리했습니다:

1. API 엔드포인트 리팩토링 완료
2. 프론트엔드 캐싱 최적화
3. 테스트 케이스 작성 완료

다음 단계: 프론트엔드 테스트 시작"

Slack → Telegram (프로젝트 그룹):
"아젠다 항목 전달:

1. API 리팩토링 완료 ✅
2. 프론트엔드 캐싱 최적화 ✅
3. 테스트 케이스 작성 완료 ✅

예상 완료 시간: 이번 주 금요일 오후"

CLI에서:

# 모든 채널에 동시 전송
clawdbot send \
  --to "whatsapp:+1234567890,telegram:@group1,slack:channel:U12345" \
  --message "⚠️ 긴급: 서버 점검 예정 ⚠️"

# 또는 특정 채널만
clawdbot send --to "whatsapp:*" --message "공지 내용"

WhatsApp에서:

"~/Documents/papers 디렉토리에 있는 모든 PDF를 분석해줘"
"주요 개념들을 추출하고 비교해줘"
"요약 문서를 작성해줘"

분석 결과:

1. 문서 1 (machine_learning.pdf):
   - 주요 개념: 신경망, 딥러닝, CNN, RNN
   - 빈도: 높음 (20회)

2. 문서 2 (software_architecture.pdf):
   - 주요 개념: 마이크로서비스, 이벤트 기반 아키텍처, REST API, GraphQL
   - 빈도: 중간 (12회)

3. 문서 3 (distributed_systems.pdf):
   - 주요 개념: 분산 시스템, 컨센서스 패턴, CAP 이론
   - 빈도: 낮음 (5회)

공통 개념:
- "아키텍처"가 세 문서 모두에서 언급됨
- "분산"과 "마이크로서비스"가 상호 보완 관계

요약:
세 문서는 주로 분산 시스템 아키텍처와 관련이며, 마이크로서비스 패턴과 CAP 이론에 초점을 두고 있습니다.

Telegram에서:

"TypeScript 타입 가드 관련 리포지토리를 리서치해줘"
"베스트 프랙티스를 10개 찾아줘"
"각 프랙티스의 장단점을 분석해줘"

리서치 결과:

조건:
- 주제: TypeScript 타입 가드
- 검색 키워드: type guard, conditional types, utility types
- 리포지토리 수: 50개

상위 10개 리포지토리:

1. ts-pattern-community/type-predicate
   - 스타: ⭐ 5,200
   - 설명: 타입 시스템에서 프리디케이트 생성
   - 장점: 컴파일 타임 최적화, 직관적인 API
   - 단점: 복잡한 설정, 러닝 곡선 높음

2. ts-toolbelt/type-fest
   - 스타: ⭐ 7,100
   - 설명: TypeScript 프로그래밍을 위한 유틸리티 타입
   - 장점: 풍부한 기능, 훌륭한 문서
   - 단점: 파일 크기 큼, 로드 타임 길음

3. ts-essentials/build
   - 스타: ⭐ 4,900
   - 설명: 빌드 타임 최적화를 위한 도구 모음
   - 장점: 빌드 속도 향상, 타입 안정성
   - 단점: 빌드 툴체인 설정 복잡

... (총 10개 리포지토리 분석)

베스트 프랙티스:
- 가장 일반적으로 사용되는 3개: ts-pattern-community/type-predicate, ts-toolbelt/type-fest, ts-essentials/build
- 권장: "범용적인 프로젝트에서는 ts-toolbelt/type-fest를 권장"
- 대안: "zod 같은 런타임 검증 라이브러리도 고려"

WhatsApp에서:

"https://example.com 사이트를 스크래핑해줘"
"모든 기사 제목을 추출해줘"
"제목별 요약을 작성해줘"

스크래핑 결과:

사이트: https://example.com

수집된 기사: 25개

상위 5개 기사 요약:

1. "AI 기술 동향 2026년 1월 전망"
   - 링크: https://example.com/article/1
   - 요약: 생성형 AI 모델이 대중적으로 도입되고 있으며, 오픈소스 모델들이 빠르게 성장하고 있습니다.

2. "클라우드 네이티브 서비스 비교"
   - 링크: https://example.com/article/2
   - 요약: AWS, Azure, GCP의 네이티브 서비스를 비교 분석했습니다.

3. "데이터 프라이버시 보안 베스트 프랙티스"
   - 링크: https://example.com/article/3
   - 요약: 최신 데이터 프라이버시 보안 표준과 베스트 프랙티스를 정리했습니다.

4. "서버리스 컨테이너화 전략"
   - 링크: https://example.com/article/4
   - 요약: 마이크로서비스 컨테이너화를 위한 전략과 도구들을 분석했습니다.

5. "오픈소스 라이선스 전략"
   - 링크: https://example.com/article/5
   - 요약: 기업의 오픈소스 채택 전략과 법적 고려사항을 정리했습니다.

전체 요약:
AI 기술 동향, 클라우드 비교, 보안, 컨테이너, 오픈소스 등 다양한 주제를 다루고 있습니다.

Telegram에서:

"이 기능에 대한 테스트 케이스를 작성해줘:
- 기능: 사용자 인증
- 테스트 케이스:
  1. 정상적인 로그인
  2. 잘못된 비밀번호
  3. 만료된 토큰
  4. 계정 잠금
  5. 연속 실패 시도 (DoS 방어)"

생성된 테스트 케이스: tests/auth.test.ts

import { describe, it, expect } from 'vitest';
import { AuthService } from '../src/auth';

describe('사용자 인증', () => {
  it('정상적인 로그인', async () => {
    const result = await AuthService.login('valid-user', 'valid-password');
    expect(result.success).toBe(true);
    expect(result.token).toBeDefined();
  });

  it('잘못된 비밀번호', async () => {
    const result = await AuthService.login('valid-user', 'wrong-password');
    expect(result.success).toBe(false);
    expect(result.error).toBe('InvalidCredentials');
  });

  it('만료된 토큰', async () => {
    const result = await AuthService.login('valid-user', 'valid-password', 'expired-token');
    expect(result.success).toBe(false);
    expect(result.error).toBe('TokenExpired');
  });

  it('계정 잠금', async () => {
    const result = await AuthService.login('locked-user', 'valid-password');
    expect(result.success).toBe(false);
    expect(result.error).toBe('AccountLocked');
  });

  it('연속 실패 시도 (DoS 방어)', async () => {
    for (let i = 0; i < 5; i++) {
      const result = await AuthService.login('user', 'wrong-password');
      expect(result.success).toBe(false);
    }
    // 6번째 시도는 속도 제한으로 차단됨
    const rateLimitedResult = await AuthService.login('user', 'wrong-password');
    expect(rateLimitedResult.error).toBe('RateLimited');
  });
});

Discord에서:

"이 프로젝트를 위한 GitHub Actions 워크플로우를 설정해줘:
- Node.js 테스트
- TypeScript 빌드
- Docker 이미지 빌드
- 배포 자동화

프로젝트: https://github.com/user/myproject"

생성된 워크플로우: .github/workflows/ci.yml

name: CI/CD

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '22'
      - name: Install dependencies
        run: npm install
      - name: Run tests
        run: npm test

  build:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Build
        run: npm run build

  deploy:
    needs: build
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v4
      - name: Build Docker image
        run: docker build -t myproject .
      - name: Deploy
        run: docker push myproject registry.example.com/myproject

Slack에서:

"다음 API 엔드포인트들에 대한 테스트 코드를 작성해줘:
- GET /api/users
- POST /api/users
- GET /api/users/:id
- PUT /api/users/:id
- DELETE /api/users/:id

각 엔드포인트에 대해:
- 성공 케이스
- 실패 케이스
- 에지 케이스"

생성된 테스트 파일: tests/api/users.test.ts

import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import request from 'supertest';
import { app } from '../src/app';
import { setupTestDatabase, teardownTestDatabase } from '../test-utils';

describe('API: /api/users', () => {
  let authToken: string;
  let testUserId: string;

  beforeAll(async () => {
    // 테스트용 사용자 생성 및 인증
    const response = await request(app)
      .post('/api/auth/login')
      .send({ username: 'testuser', password: 'testpass' });
    authToken = response.body.token;
    
    // 테스트 유저 생성
    const userResponse = await request(app)
      .post('/api/users')
      .set('Authorization', `Bearer ${authToken}`)
      .send({
        username: 'test_api_user',
        email: 'test@example.com',
        password: 'testpass'
      });
    testUserId = userResponse.body.id;
  });

  afterAll(async () => {
    // 테스트 데이터 정리
    await teardownTestDatabase();
  });

  describe('GET /api/users', () => {
    it('성공: 전체 사용자 목록 반환', async () => {
      const response = await request(app)
        .get('/api/users')
        .set('Authorization', `Bearer ${authToken}`);
      
      expect(response.status).toBe(200);
      expect(Array.isArray(response.body)).toBe(true);
      expect(response.body.length).toBeGreaterThan(0);
    });

    it('실패: 인증 없음', async () => {
      const response = await request(app).get('/api/users');
      expect(response.status).toBe(401);
    });
  });

  describe('POST /api/users', () => {
    it('성공: 사용자 생성', async () => {
      const newUser = {
        username: 'newuser',
        email: 'new@example.com',
        password: 'password123'
      };
      
      const response = await request(app)
        .post('/api/users')
        .set('Authorization', `Bearer ${authToken}`)
        .send(newUser);
      
      expect(response.status).toBe(201);
      expect(response.body.username).toBe(newUser.username);
      expect(response.body.email).toBe(newUser.email);
      expect(response.body.id).toBeDefined();
    });

    it('실패: 중복 사용자명', async () => {
      const duplicateUser = {
        username: 'test_api_user',  // 이미 존재
        email: 'new2@example.com',
        password: 'password456'
      };
      
      const response = await request(app)
        .post('/api/users')
        .set('Authorization', `Bearer ${authToken}`)
        .send(duplicateUser);
      
      expect(response.status).toBe(400);
      expect(response.body.error).toBe('UsernameAlreadyExists');
    });

    it('실패: 잘못된 이메일 형식', async () => {
      const invalidUser = {
        username: 'newuser2',
        email: 'invalid-email',
        password: 'password789'
      };
      
      const response = await request(app)
        .post('/api/users')
        .set('Authorization', `Bearer ${authToken}`)
        .send(invalidUser);
      
      expect(response.status).toBe(400);
      expect(response.body.error).toBe('InvalidEmailFormat');
    });
  });

  describe('GET /api/users/:id', () => {
    it('성공: 특정 사용자 조회', async () => {
      const response = await request(app)
        .get(`/api/users/${testUserId}`)
        .set('Authorization', `Bearer ${authToken}`);
      
      expect(response.status).toBe(200);
      expect(response.body.id).toBe(testUserId);
      expect(response.body.username).toBe('test_api_user');
    });

    it('실패: 존재하지 않는 사용자', async () => {
      const response = await request(app)
        .get('/api/users/nonexistent-id')
        .set('Authorization', `Bearer ${authToken}`);
      
      expect(response.status).toBe(404);
      expect(response.body.error).toBe('UserNotFound');
    });
  });

  describe('PUT /api/users/:id', () => {
    it('성공: 사용자 정보 업데이트', async () => {
      const updates = {
        email: 'updated@example.com'
      };
      
      const response = await request(app)
        .put(`/api/users/${testUserId}`)
        .set('Authorization', `Bearer ${authToken}`)
        .send(updates);
      
      expect(response.status).toBe(200);
      expect(response.body.email).toBe(updates.email);
    });

    it('실패: 권한 없음', async () => {
      const otherUserToken = 'different-auth-token';
      const updates = { email: 'forbidden@example.com' };
      
      const response = await request(app)
        .put(`/api/users/${testUserId}`)
        .set('Authorization', `Bearer ${otherUserToken}`)
        .send(updates);
      
      expect(response.status).toBe(403);
    });
  });

  describe('DELETE /api/users/:id', () => {
    it('성공: 사용자 삭제', async () => {
      const response = await request(app)
        .delete(`/api/users/${testUserId}`)
        .set('Authorization', `Bearer ${authToken}`);
      
      expect(response.status).toBe(204);
    });

    it('실패: 권한 없음', async () => {
      const otherUserToken = 'different-auth-token';
      
      const response = await request(app)
        .delete(`/api/users/${testUserId}`)
        .set('Authorization', `Bearer ${otherUserToken}`);
      
      expect(response.status).toBe(403);
    });
  });
});