범인찾기 v1.3.2: 외부 전적 사이트 접속 제거 — OP.GG · LOL.PS 는 계산법만 참고

- 사용자 결정: 실제 OP.GG 연결이 아니라 계산법 참고 → 분석 때 OP.GG 를 찾아보던 opgg.ts · 결과의 OP.GG 점수 · 조회 상태 · 지시문 줄 · Riot 태그/경기 찾기 정보 제거
- 남은 것: 기록 점수(OP.GG OP스코어 계산법, 앱이 경기 기록으로 계산) · 10/15분 라인전(LOL.PS 정의)
- 실제 E2E (Claude Opus 5.5 high, 외부 접속 없음): 발로란트 33초 $0.138, 롤 36초 $0.123
- 테스트: 앱 40 · 서버 16 통과

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
EJClaw
2026-10-15 16:11:53 +09:00
parent 2ddba2e4e5
commit b8e76aba25
17 changed files with 88 additions and 600 deletions

View File

@@ -8,7 +8,7 @@
- 설계·계획: [`docs/gemnoki-project-plan.pdf`](docs/gemnoki-project-plan.pdf), 개발 구조·인터페이스: [`docs/dev/ARCHITECTURE.md`](docs/dev/ARCHITECTURE.md)
- 범인찾기 · 리플레이 동기화 계획서 v1.2 (결정 반영): [`docs/culprit-finder-plan.pdf`](docs/culprit-finder-plan.pdf) · 원본 · 비용 계산 · 프롬프트 초안: `docs/report/culprit/` (실제로 쓰는 프롬프트는 `site/server/prompt/`)
- **제작 완료 보고서 (M0~M8)**: [`docs/gemnoki-final-report.pdf`](docs/gemnoki-final-report.pdf) · 단계별 테스트 기록: [`docs/dev/test-results.md`](docs/dev/test-results.md)
- Windows 실행 파일: Gitea 릴리스 [v1.3.1](https://git.tkrmagid.kr/tkrmagid/game_voice_recorder/releases/tag/v1.3.1) (`GameVoiceRecorder-1.3.1-win-x64.zip` 권장, 단일 파일 `GameVoiceRecorder-1.3.1-portable.exe`) · 처음 버전 [v1.0.0](https://git.tkrmagid.kr/tkrmagid/game_voice_recorder/releases/tag/v1.0.0)
- Windows 실행 파일: Gitea 릴리스 [v1.3.2](https://git.tkrmagid.kr/tkrmagid/game_voice_recorder/releases/tag/v1.3.2) (`GameVoiceRecorder-1.3.2-win-x64.zip` 권장, 단일 파일 `GameVoiceRecorder-1.3.2-portable.exe`) · 처음 버전 [v1.0.0](https://git.tkrmagid.kr/tkrmagid/game_voice_recorder/releases/tag/v1.0.0)
## 로그인 · 관리자 (v1.2.0~)
@@ -37,17 +37,16 @@
- 사이트 서버: 보안 정책(CSP)으로 이 사이트 스크립트와 이 사이트로의 접속만 허용, 실시간 WebSocket 은 이 사이트에서 온 연결만, 로그인 세션 · 앱 토큰 · 기기 키는 해시로만 저장, 로그에서 로그인 code · state · 검색어를 지운다. 등록 코드 대입 · 로그인 요청 폭주는 IP 별로 막는다. HSTS · http→https 이동 · TLS 1.2 미만 차단은 앞단 프록시(NPMplus)가 한다.
- 디스코드 음성은 디스코드 자체 암호화(DAVE 종단간 암호화)로 간다.
## 🔍 범인찾기 (v1.3.0~)
## 🔍 범인찾기 (v1.3.2~)
끝난 경기를 고르고 "범인 분석"을 누르면 AI(Claude)가 그 경기의 음성 대화 · 킬 · 라운드/오브젝트 · 경제 · 채팅 · 10명 스탯을 읽고 10명 평점 · 태그 · 한 줄 평과 팀별 범인 1명(이유 + 근거)을 만든다. 근거를 누르면 그 순간의 음성 · 타임라인으로 간다. 계획서: [`docs/culprit-finder-plan.pdf`](docs/culprit-finder-plan.pdf)
- 정한 것 (2026-10-15): 범인 = 가장 못함 + 가장 발목 + 결과의 원인을 종합해 팀마다 1명 · 분석 버튼은 등록된 앱 유저 이상(다시 분석은 관리자) · Claude Opus 5.5(생각 high) · 말투 중간맛 · 녹음 안내(TTS)에 "녹음된 대화는 AI 경기 분석에 쓰일 수 있어요" 추가
- **전적 사이트 점수 참고**: 평점과 범인은 전적 사이트 점수에서 출발해 승부처 · 역할 · 경제 · 음성 소통으로 더하고 뺀다 (지시문 v1.2)
- **기록 점수** (0~10, 모든 경기): OP.GG OP스코어를 우리 기록으로 다시 계산한 점수 + 경기/팀 순위 + MVP · ACE + 점수를 올리고 깎은 지표. 발로란트는 OP.GG 가 밝힌 입력(라운드 승률 · KAST · ACS · 피해 격차), 롤은 킬 관여 · 데스 · 딜/받은 피해/골드 비중 · CS · 레벨 · CC · 와드. 계수는 OP.GG 공식 MCP 로 받은 실제 경기의 OP스코어에 맞췄다 (교차 검증: 발로란트 상관 0.97 · 평균 오차 0.49점, 롤 상관 0.94 · 0.60점 · 팀 최하위 일치 85%). `packages/shared/src/rating.ts`, 맞추는 도구 `tools/opscore-fit/`
- **OP.GG 실제 OP스코어**: 분석할 때 OP.GG 공식 MCP(`mcp-api.op.gg`)에서 그 경기를 찾으면 그 사이트의 실제 점수를 같이 준다 (롤: 시작 시각 · 길이로 찾고 10명, 발로란트: 경기 번호로 선수마다). 내전(사용자 설정 게임)은 OP.GG 에 없어 기록 점수만 쓴다. `site/server/src/opgg.ts`, 끄기 `CULPRIT_OPGG=0`
- **전적 사이트 계산법 참고**: 평점과 범인은 기록 점수에서 출발해 승부처 · 역할 · 경제 · 음성 소통으로 더하고 뺀다 (지시문 v1.2). 분석할 때 외부 전적 사이트에는 접속하지 않고, 앱이 경기 기록으로 직접 계산한다
- **기록 점수** (0~10, 모든 경기): OP.GG OP스코어 계산법을 따라 우리 기록으로 계산한 점수 + 경기/팀 순위 + MVP · ACE + 점수를 올리고 깎은 지표. 발로란트는 OP.GG 가 밝힌 입력(라운드 승률 · KAST · ACS · 피해 격차), 롤은 킬 관여 · 데스 · 딜/받은 피해/골드 비중 · CS · 레벨 · CC · 와드. OP.GG 는 가중치를 공개하지 않아서, 계수는 개발할 때 한 번 OP.GG 공식 MCP 로 받은 실제 경기 점수에 맞춰 정했다 (교차 검증: 발로란트 상관 0.97 · 평균 오차 0.49점, 롤 상관 0.94 · 0.60점 · 팀 최하위 일치 85%). `packages/shared/src/rating.ts`, 맞추는 도구 `tools/opscore-fit/`
- **LOL.PS 라인전**: LOL.PS 라인전 점수의 입력과 같은 10 · 15분 맞라이너 CS · 골드 · 경험치 차 (LOL.PS 점수 모델은 공개되지 않아 차이 값만). 참고한 원문 · 구현 대응: [`tools/opscore-fit/README.md`](tools/opscore-fit/README.md)
- 실제 E2E (2026-10-15, `app/scripts/culprit-real-e2e.mts`): 실제 Claude Opus 5.5(생각 high) + 실제 OP.GG. 발로란트 시연 경기 42초 · $0.15, 롤 실제 랭크 경기(OP.GG 점수 10명 찾음) 36초 · $0.11. 기록 · [`docs/dev/test-results.md`](docs/dev/test-results.md)
- 리플레이 동기화: 공식 · 비공식 API 로 리플레이 시간을 읽을 수 있을 때만 넣는다 (화면 글자 인식(OCR) · 게임 설정 파일 고치기는 하지 않음). Windows 실기 확인 전이라 v1.3.0 에는 없다
- 실제 E2E (2026-10-15, v1.3.2, `app/scripts/culprit-real-e2e.mts`): 실제 Claude Opus 5.5(생각 high), 외부 사이트 접속 없음. 발로란트 시연 경기 33초 · $0.138, 롤 시연 경기 36초 · $0.123. 기록 · [`docs/dev/test-results.md`](docs/dev/test-results.md)
- 리플레이 동기화: 공식 · 비공식 API 로 리플레이 시간을 읽을 수 있을 때만 넣는다 (화면 글자 인식(OCR) · 게임 설정 파일 고치기는 하지 않음). Windows 실기 확인 전이라 v1.3.x 에는 없다
- 앱: 경기 상세에서 추가 지표 저장(발로란트 피해량 · 받은 피해 · KAST · 첫킬 · 설치/해체 · 라운드별 장비, 롤 포지션 · 딜량 · 시야 · 10/15분 CS), "분석할 수 있는 경기" 판정(경기 결과 · 녹음 공백 1분 · 음성 변환), 근거 번호가 달린 AI 자료 만들기, 결과 저장(`culprit_analyses`). `app/src/core/culprit.ts`
- 사이트 서버: Claude API 키는 서버 환경 변수 `ANTHROPIC_API_KEY` 에만 (`deploy/site/set-anthropic-key.sh`). 권한 · 월 $100 · 하루 20회 · 중복 잠금, 구조화 출력, 근거 번호 확인, 비용 장부(토큰 · 비용만, 대화 내용 없음). `site/server/src/culprit.ts`, 지시문 · 지식 묶음 `site/server/prompt/` (지식 묶음의 요원 · 챔피언 목록은 공식 데이터로 하루 한 번 갱신)
- 화면: 사이트 🔍 범인찾기 탭 (`site/web/src/pages/CulpritPage.tsx`), 경기 화면의 "🔍 범인 보기". 화면 확인: `node --import tsx app/scripts/culprit-shots.mts`
@@ -65,7 +64,7 @@
| M6 단어사전 · UI/UX | 핫워드·교정 사전, 사이트 교정 반영, 테마·애니메이션·효과음 | ✅ 완료 ([사전 효과](docs/dev/test-results.md)) |
| M7 실사용 테스트 | 통합 테스트, 성능·안정화 | ✅ 완료 (GPU 실음성: CER 3.6%, 지연 1.05초 · [기록](docs/dev/test-results.md)) |
| M8 파인튜닝 | 교정 데이터 + 합성 음성 LoRA 학습, 오류율 비교 후 교체 | ✅ 완료 (GPU 시험 학습: CER 4.8% → 1.8%) |
| 범인찾기 (v1.3.0) | AI(Claude Opus 5.5 high) 10명 평점 · 팀별 범인 · 근거, 기록 점수(OP.GG OP스코어 방식) · OP.GG 실제 점수 · LOL.PS 라인전 | ✅ 완료 (실제 Claude · OP.GG E2E, 사이트 배포, [v1.3.1](https://git.tkrmagid.kr/tkrmagid/game_voice_recorder/releases/tag/v1.3.1) · 리플레이 동기화는 Windows 실기 확인 뒤) |
| 범인찾기 (v1.3.x) | AI(Claude Opus 5.5 high) 10명 평점 · 팀별 범인 · 근거, 기록 점수(OP.GG OP스코어 계산법) · 10/15분 라인전(LOL.PS 정의) | ✅ 완료 (실제 Claude E2E, 사이트 배포, [v1.3.2](https://git.tkrmagid.kr/tkrmagid/game_voice_recorder/releases/tag/v1.3.2) · 리플레이 동기화는 Windows 실기 확인 뒤) |
## 저장소 구조

4
app/package-lock.json generated
View File

@@ -1,12 +1,12 @@
{
"name": "gvr-app",
"version": "1.3.1",
"version": "1.3.2",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "gvr-app",
"version": "1.3.1",
"version": "1.3.2",
"license": "UNLICENSED",
"dependencies": {
"@discordjs/voice": "^0.19.2",

View File

@@ -1,7 +1,7 @@
{
"name": "gvr-app",
"productName": "겜녹이",
"version": "1.3.1",
"version": "1.3.2",
"description": "겜녹이 (Game Voice Recorder) - 게임 연동 디스코드 음성 기록",
"private": true,
"main": "dist/main.cjs",

View File

@@ -1,119 +1,53 @@
// 범인찾기 실제 E2E: 실제 앱 코어 + 실제 사이트 서버 + 실제 Claude API(Opus 5.5, 생각 high) + 실제 OP.GG MCP + 헤드리스 브라우저.
// 1) 발로란트 시연 경기 (22라운드 · 대화) → OP.GG 에 없는 경기 → 기록 점수만으로 분석
// 2) 롤: OP.GG 에서 받은 실제 랭크 경기(10명 실제 스탯)에 우리 팀 2명의 대화를 붙인 경기 → OP.GG 실제 OP스코어를 찾아 같이 분석
// 비용이 든다 (경기당 약 $0.4). API 키는 secrets.json 에서 읽어 이 프로세스 안에서만 쓴다.
// 범인찾기 실제 E2E: 실제 앱 코어 + 실제 사이트 서버 + 실제 Claude API(Opus 5.5, 생각 high) + 헤드리스 브라우저.
// 외부 전적 사이트에는 접속하지 않는다 (기록 점수는 OP.GG 계산법을 따라 경기 기록으로 계산).
// 1) 발로란트 시연 경기 (22라운드 · 대화) 2) 롤 시연 경기 (10 · 15분 라인전 · 대화)
// 비용이 든다 (경기당 약 $0.1~0.4). API 키는 secrets.json 에서 읽어 이 프로세스 안에서만 쓴다.
// node --import tsx scripts/culprit-real-e2e.mts [결과 폴더]
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import type { CulpritInput, CulpritMatchInfo, MatchPlayer } from '@gvr/shared';
import type { CulpritInput, CulpritMatchInfo } from '@gvr/shared';
import { makeDemoLol } from '../test/fixtures/demo-matches.ts';
import { culpritApi, MIN, seedValorant, setup } from '../test/fixtures/culprit-seed.ts';
const outDir = process.argv[2] || path.join(os.homedir(), '.tmp', 'culprit-real');
fs.mkdirSync(outDir, { recursive: true });
const root = path.resolve(import.meta.dirname, '..', '..');
const apiKey = JSON.parse(fs.readFileSync(path.join(os.homedir(), '.config/ejclaw/secrets.json'), 'utf8')).credentials['anthropic.api/game-voice-recorder'].token as string;
const { opggCaller } = await import('../../site/server/src/opgg.ts');
const opgg = opggCaller();
const core = setup();
await core.assets.refresh(true).catch(() => undefined);
const { id: valId } = seedValorant(core);
// ---------------------------------------------------------------- 롤: OP.GG 의 실제 랭크 경기
const POS: Record<string, string> = { TOP: '탑', JUNGLE: '정글', MID: '미드', ADC: '원딜', SUPPORT: '서폿' };
const listOf = async (name: string, tag: string) =>
((await opgg('lol_list_summoner_matches', { game_name: name, tag_line: tag, region: 'KR', limit: 10, desired_output_fields: ['data.game_history[].{created_at,game_length_second,game_type,id}'] })) as any).data.game_history as any[];
const detailOf = async (g: any) =>
((await opgg('lol_get_summoner_game_detail', {
region: 'KR',
game_id: g.id,
created_at: g.created_at,
desired_output_fields: [
'data.game_detail.teams[].participants[].stats.{assist,champion_level,death,gold_earned,kill,minion_kill,neutral_minion_kill,op_score,time_ccing_others,total_damage_dealt_to_champions,total_damage_taken,vision_wards_bought_in_game,ward_place}',
'data.game_detail.teams[].participants[].{position,team_key,champion_id,champion_name}',
'data.game_detail.teams[].participants[].summoner.{puuid,game_name,tagline,player}',
'data.game_detail.teams[].game_stat.{champion_kill,is_win}',
],
})) as any).data.game_detail;
// 프로 선수가 아닌 사람의 최근 솔로 랭크 (15분 이상)
const seedGame = (await listOf('Hide on bush', 'KR1')).find((g) => g.game_type === 'SOLORANKED')!;
const seedDet = await detailOf(seedGame);
const pick = seedDet.teams.flatMap((t: any) => t.participants).find((p: any) => !p.summoner.player && p.summoner.game_name !== 'Hide on bush');
const g = (await listOf(pick.summoner.game_name, pick.summoner.tagline)).find((x) => x.game_type === 'SOLORANKED' && x.game_length_second > 1200)!;
const det = await detailOf(g);
const all = det.teams.flatMap((t: any) => t.participants.map((p: any) => ({ ...p, win: t.game_stat.is_win, teamKills: t.game_stat.champion_kill })));
const selfP = all.find((p: any) => p.summoner.puuid === pick.summoner.puuid) ?? all[0];
const opggTruth = new Map<string, number>(all.map((p: any) => [p.summoner.puuid, p.stats.op_score]));
const players: MatchPlayer[] = all.map((p: any) => ({
puuid: p.summoner.puuid,
name: p.summoner.game_name,
tag: p.summoner.tagline,
team: p.team_key,
ally: p.team_key === selfP.team_key,
character: { id: String(p.champion_id), name: p.champion_name, icon: null },
kills: p.stats.kill,
deaths: p.stats.death,
assists: p.stats.assist,
cs: (p.stats.minion_kill ?? 0) + (p.stats.neutral_minion_kill ?? 0),
gold: p.stats.gold_earned,
level: p.stats.champion_level,
stats: {
role: POS[p.position],
damage: p.stats.total_damage_dealt_to_champions,
damageTaken: p.stats.total_damage_taken,
ccSeconds: p.stats.time_ccing_others ?? 0,
wardsPlaced: p.stats.ward_place ?? 0,
controlWards: p.stats.vision_wards_bought_in_game ?? 0,
},
}));
const LS = Date.parse(g.created_at) + 60000;
const LEN = g.game_length_second * 1000;
const allyWin = !!selfP.win;
const allyKills = all.filter((p: any) => p.team_key === selfP.team_key)[0].teamKills;
const enemyKills = all.filter((p: any) => p.team_key !== selfP.team_key)[0].teamKills;
const lolId = `lol-${g.id.replace(/[^\w]/g, '').slice(0, 20)}`;
core.store.upsertMatch({
id: lolId,
game: 'lol',
started_at: LS,
ended_at: LS + LEN,
status: 'complete',
map: 'Map11',
mode: 'CLASSIC',
queue: '420',
result: JSON.stringify({ win: allyWin, score: { ally: allyKills, enemy: enemyKills } }),
detail: JSON.stringify({ live: false, players, goldDiff: [], self: selfP.summoner.puuid }),
});
// 우리 팀 두 명이 음성채널에 있었다고 하고 대화를 붙인다 (실제 경기 기록 + 시험용 대화)
const mates = players.filter((p) => p.ally);
const [a, b] = [mates.find((p) => p.puuid === selfP.summoner.puuid)!, mates.find((p) => p.puuid !== selfP.summoner.puuid)!];
core.store.upsertUser({ id: 'ua', name: '승한', avatar: null });
core.store.upsertUser({ id: 'ub', name: '민수', avatar: null });
core.store.setAccounts('ua', [{ puuid: a.puuid, riotId: `${a.name}#${a.tag}` }]);
core.store.setAccounts('ub', [{ puuid: b.puuid, riotId: `${b.name}#${b.tag}` }]);
// ---------------------------------------------------------------- 롤 시연 경기 + 우리 팀 2명 대화
const LS = Date.now() - 80 * MIN;
const lol = makeDemoLol();
const lolId = 'lol-demo';
core.store.setMeta('riot_self_puuid', 'l-sh');
core.store.setAccounts('u1', [{ puuid: 'p-sh', riotId: '승한#V' }, { puuid: 'l-sh', riotId: '승한#L' }]);
core.store.setAccounts('u2', [{ puuid: 'p-ms', riotId: '민수#V' }, { puuid: 'l-ms', riotId: '민수#L' }]);
core.store.startSession('s-lol', 'g', 'c', '음성', LS - MIN);
core.games.matchStarted({ id: lolId, game: 'lol', startedAt: LS, map: 'Map11', mode: 'CLASSIC', queue: '420', detail: { live: true } });
core.games.matchEnded(lolId, LS + lol.durationMs);
(core.games.adapters[1] as any).applyHistory(lolId, lol.game, lol.timeline, LS);
const talk: [string, number, string][] = [
['ua', 2.5, '정글 위쪽에서 시작했어 바텀 조심해'],
['ub', 6.2, '용 앞에 와드 박아 줘 시야 없어'],
['ua', 6.5, '알았어 지금 갈게'],
['ub', 11.0, '미드 미아 미드 미아 내려간다'],
['ua', 14.8, '용 한타 열지 마 아직 우리 텔 없어'],
['ub', 15.1, '아 들어갔다 아 죽었다 미안'],
['ua', 19.5, '바론 시야 먼저 잡고 하자 혼자 가지 마'],
['ub', 24.0, allyWin ? '좋아 한타 이겼다 미드 밀자' : '아 또 잡혔네 이거 그냥 서렌 치자'],
['ua', 24.3, allyWin ? '억제기 깨고 바로 빠지자' : '아직 안 끝났어 수비하자'],
['u1', 2.5, '정글 위쪽에서 시작했어 바텀 조심해'],
['u2', 6.2, '용 앞에 와드 박아 줘 시야 없어'],
['u1', 8.1, '용 같이 하자 바텀 밀었어'],
['u2', 8.3, '아니 탑 갱 각이야 잠깐만'],
['u1', 14.8, '용 한타 열지 마 아직 우리 텔 없어'],
['u2', 15.1, '아 들어갔다 아 죽었다 미안'],
['u1', 19.5, '바론 시야 먼저 잡고 하자 혼자 가지 마'],
];
for (const [uid, min, text] of talk) {
if (min * MIN > LEN) continue;
const ts = LS + min * MIN;
const id = `lol-${uid}-${min}`;
core.store.insertUtterance({ id, session_id: 's-lol', user_id: uid, started_at: ts, ended_at: ts + 1800, audio_path: null, match_id: lolId });
core.store.updateUtteranceResult(id, { text, raw_text: text, words: [], noise: false, noise_reason: null, confidence: 0.9, lufs: -20, gain_db: 0, model: 'large-v3', status: 'precise' });
}
core.store.endSession('s-lol', LS + LEN + MIN);
core.store.endSession('s-lol', LS + lol.durationMs + MIN);
// ---------------------------------------------------------------- 사이트 서버 (실제 Claude · 실제 OP.GG)
// ---------------------------------------------------------------- 사이트 서버 (실제 Claude)
const local = await culpritApi(core);
const { buildServer } = await import('../../site/server/src/app.ts');
const port = 18961;
@@ -121,7 +55,7 @@ const site = await buildServer({
port, host: '127.0.0.1', publicUrl: `http://127.0.0.1:${port}`, clientId: 'x', clientSecret: 'x', botToken: 'x', allowedGuilds: [], owners: ['u1'], superAdmins: ['u1'],
sessionSecret: 'real-e2e-secret-'.repeat(3), dataDir: fs.mkdtempSync(path.join(os.tmpdir(), 'gvr-real-')), webDir: path.join(root, 'site', 'web', 'dist'), version: 't', discordApi: 'http://127.0.0.1:1',
assetUpstream: { valmedia: 'https://media.valorant-api.com/', ddragon: 'https://ddragon.leagueoflegends.com/', cdragon: 'https://raw.communitydragon.org/' },
culprit: { apiKey, model: 'claude-opus-5-5', effort: 'high', monthLimitUsd: 100, dailyLimit: 20, tone: 'medium', opgg: true },
culprit: { apiKey, model: 'claude-opus-5-5', effort: 'high', monthLimitUsd: 100, dailyLimit: 20, tone: 'medium' },
});
site.app.log.level = 'info';
await site.app.listen({ host: '127.0.0.1', port });
@@ -171,9 +105,9 @@ for (const id of [valId, lolId]) {
const ref = (pid: string) => a.players.find((p) => p.id === pid)!;
const rows = a.result.players.map((p) => {
const pl = ref(p.id);
return { id: p.id, team: pl.team, ai: p.score, rating: pl.rating?.score ?? null, opgg: pl.opgg?.score ?? null, truth: opggTruth.get(pl.puuid) ?? null, tag: p.tag, comment: p.comment };
return { id: p.id, team: pl.team, ai: p.score, rating: pl.rating?.score ?? null, lane: pl.rating?.lane ?? null, tag: p.tag, comment: p.comment };
});
const teamLowest = (team: string, key: 'rating' | 'opgg') => {
const teamLowest = (team: string, key: 'rating') => {
const ps = rows.filter((r) => r.team === team && r[key] !== null);
return ps.length ? ps.reduce((x, y) => ((x[key] as number) <= (y[key] as number) ? x : y)).id : null;
};
@@ -182,11 +116,10 @@ for (const id of [valId, lolId]) {
model: a.model,
costUsd: a.meta.costUsd,
usage: a.meta.usage,
opgg: a.meta.opgg,
stages: stages[id],
summary: a.result.summary,
confidence: a.result.confidence,
culprits: a.result.teams.map((t) => ({ team: t.team, culprit: t.culprit, reason: t.reason, evidence: t.evidence.map((e) => e.ref), lowestRating: teamLowest(t.team, 'rating'), lowestOpgg: teamLowest(t.team, 'opgg') })),
culprits: a.result.teams.map((t) => ({ team: t.team, culprit: t.culprit, reason: t.reason, evidence: t.evidence.map((e) => e.ref), lowestRating: teamLowest(t.team, 'rating') })),
players: rows,
};
console.log(JSON.stringify(report[id], null, 1));

View File

@@ -60,13 +60,6 @@ const site = await buildServer(
},
{
culpritKnowledge: new KnowledgeAuto(async () => { throw new Error('offline'); }),
// OP.GG: 발로란트 시연 경기는 "찾음"(가짜 점수), 롤 시연 경기는 "없음"
culpritOpgg: async (name: string, args: any) => {
if (name !== 'valorant_list_player_matches') return {};
const input = (await local.inject({ url: `/api/culprit/internal/${valId}/input`, headers: { 'x-gvr-internal': '1' } })).json().input as CulpritInput;
const p = input.players.find((x) => x.name === args.game_name)!;
return [{ matchId: 'demo', puuid: p.puuid, opScore: Math.round((p.rating?.score ?? 5) * 100 + 30) }];
},
culpritCall: async (req) => {
await new Promise((r) => setTimeout(r, 2500));
const isVal = req.user.includes('# 경기 발로란트');

View File

@@ -173,7 +173,6 @@ export class Culprit {
character: p.character ?? null,
userId: userId ?? null,
voice: !!userId && speakers.has(userId),
...(p.tag ? { tag: p.tag } : {}),
...(ratings.get(p.puuid) ? { rating: ratings.get(p.puuid) } : {}),
hasExtraStats: !!p.stats,
};
@@ -334,12 +333,6 @@ export class Culprit {
refs,
players: players.map(({ hasExtraStats: _x, ...p }) => p),
stats: { utterances: utts.length, utterancesTotal: totalUtts, events: ei, chats: ci, rounds: rounds.length, basic },
lookup: {
riotMatchId: m.id.replace(/^(val|lol)-/, '') || null,
startedAt: realStart(m),
endedAt: m.ended_at ?? realStart(m),
durationSec: Math.round(((m.ended_at ?? realStart(m)) - realStart(m)) / 1000),
},
};
}
}
@@ -364,8 +357,8 @@ function ratingLines(game: string, players: CulpritPlayer[]): string[] {
if (!players.some((p) => p.rating)) return [];
const head =
game === 'valorant'
? '# 기록 점수 (0~10, OP.GG OP스코어 방식: 라운드 승률 · KAST · ACS · 피해 격차를 실제 OP.GG 점수에 맞춘 계산. 경기 순위/팀 순위, 경기 평균보다 점수를 올린 강점 · 깎은 약점)'
: '# 기록 점수 (0~10, OP.GG OP스코어 방식: 킬 관여 · 데스 · 딜/받은 피해 · 골드 · CS · 레벨 · CC · 와드를 실제 OP.GG 점수에 맞춘 계산. 경기 순위/팀 순위, 경기 평균보다 점수를 올린 강점 · 깎은 약점, 라인전 = LOL.PS 라인전 점수의 입력인 10 · 15분 맞라이너와의 CS · 골드 · 경험치 차)';
? '# 기록 점수 (0~10, OP.GG OP스코어 계산법: 라운드 승률 · KAST · ACS · 피해 격차로 계산. 경기 순위/팀 순위, 경기 평균보다 점수를 올린 강점 · 깎은 약점)'
: '# 기록 점수 (0~10, OP.GG OP스코어 계산법: 역할 · 킬 관여 · 데스 · 딜/받은 피해/골드 비중 · CS · 레벨 · CC · 와드로 계산. 경기 순위/팀 순위, 경기 평균보다 점수를 올린 강점 · 깎은 약점, 라인전 = LOL.PS 라인전 점수의 입력인 10 · 15분 맞라이너와의 CS · 골드 · 경험치 차)';
const out = [head];
if (players.some((p) => p.rating?.basic)) out.push('# (추가 지표가 없어 K/D/A · 골드 · CS 같은 기본 기록으로만 낸 점수다)');
const idOf = new Map(players.map((p) => [p.puuid, p.id]));

View File

@@ -56,8 +56,8 @@ test('범인찾기: 분석 가능 판정과 AI 자료', () => {
// 우리 팀이 P1~P5, 승한은 음성O, 디스코드 계정이 없는 상대는 음성X
const p1 = lines.find((l) => l.startsWith('P1 '))!;
assert.match(p1, /^P1 승한 우리 제트\(타격대\) \d+\/\d+\/\d+ ACS\d+ ADR\d+ KAST\d+% 피해격차[+-]\d+ 첫킬\d+\/첫데스\d+ HS\d+% 설치\d+\/해체\d+ .*음성O$/);
// 기록 점수 (OP.GG OP스코어 방식): 10명 모두, 이긴 팀 1등 MVP · 진 팀 1등 ACE
const head = lines.findIndex((l) => l.startsWith('# 기록 점수 (0~10, OP.GG OP스코어 방식'));
// 기록 점수 (OP.GG OP스코어 계산법): 10명 모두, 이긴 팀 1등 MVP · 진 팀 1등 ACE
const head = lines.findIndex((l) => l.startsWith('# 기록 점수 (0~10, OP.GG OP스코어 계산법'));
assert.ok(head > 0, '기록 점수 칸');
const rl = lines.slice(head + 1, head + 11);
assert.ok(rl.every((l, i) => new RegExp(`^P${i + 1} \\d+\\.\\d점 \\d+위/팀\\d위`).test(l)), rl.join('\n'));
@@ -68,7 +68,6 @@ test('범인찾기: 분석 가능 판정과 AI 자료', () => {
assert.ok(rp.every((r) => r && r.score >= 0 && r.score <= 10 && !r.basic));
assert.deepEqual(rp.map((r) => r.rank).sort((a, b) => a - b), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
assert.equal(rp.find((r) => r.rank === 1)!.score, Math.max(...rp.map((r) => r.score)));
assert.equal(input.lookup?.riotMatchId, 'demo');
assert.match(lines.find((l) => l.startsWith('P6 '))!, /상대 .*음성X$/);
assert.equal(input.players.find((p) => p.id === 'P2')!.voice, true, '민수는 대화가 있다');
assert.equal(input.players.find((p) => p.id === 'P3')!.voice, false);
@@ -139,7 +138,7 @@ test('범인찾기: 롤 포지션 · 시야 · 10/15분 지표와 골드 차', (
assert.match(input.text, /\n\[e\d+\] \d+:\d+ 킬 P\d+ → P\d+/);
assert.match(input.text, /\n\[e\d+\] \d+:\d+ 내셔 남작 처치 우리 팀 · P2\n/);
// 기록 점수 + LOL.PS 라인전 점수의 입력 (10 · 15분 맞라이너와 차)
assert.match(input.text, /\n# 기록 점수 \(0~10, OP\.GG OP스코어 방식/);
assert.match(input.text, /\n# 기록 점수 \(0~10, OP\.GG OP스코어 계산법/);
assert.match(input.text, /\nP1 \d+\.\d점 \d+위\/팀\d위.* · 라인전\(vs P6\) 10분 CS[+-][\d,]+ 골드[+-][\d,]+ 경험치[+-][\d,]+ 15분 CS[+-][\d,]+ 골드[+-][\d,]+ 경험치[+-][\d,]+\n/);
const p1 = input.players.find((p) => p.id === 'P1')!;
const p6 = input.players.find((p) => p.id === 'P6')!;
@@ -147,7 +146,6 @@ test('범인찾기: 롤 포지션 · 시야 · 10/15분 지표와 골드 차', (
assert.equal(p1.rating!.lane!.at10!.xp, -p6.rating!.lane!.at10!.xp);
assert.ok(p1.rating!.lane!.at10!.cs !== undefined && p1.rating!.lane!.at15!.gold !== undefined);
assert.equal(input.players.filter((p) => p.rating?.badge).length, 2);
assert.equal(p1.tag !== undefined, true);
});
test('범인찾기 API: 목록 · 상세 · 내부 전용 경로', async () => {

View File

@@ -152,3 +152,17 @@ VOICE E2E PASS
- LOL.PS 라인전: LOL.PS 원문 정의("10, 15분 맞라이너 골드차, 경험치차, cs차이")대로 10분 값을 더해 10 · 15분 차이를 보여 준다. 참고한 원문과 구현 대응은 `tools/opscore-fit/README.md`
- 테스트: 앱 40개 · 사이트 서버 20개 통과, 화면 오류 · CSP 위반 없음
- 배포: 사이트 서버 다시 배포(지시문 · 화면 반영 확인), Windows CI (0e0a272, full) 8개 모두 PASS · 앱 버전 1.3.1 → Gitea 릴리스 v1.3.1 (v1.3.0 에 새 버전 안내)
## 범인찾기 v1.3.2 — 외부 전적 사이트 접속 제거 (2026-10-15)
사용자 결정: 전적 사이트는 "계산법을 참고"하라는 뜻이었고 실제로 연결하는 것이 아니다 → 분석할 때 OP.GG 를 찾아보던 기능(`site/server/src/opgg.ts`, 결과의 OP.GG 점수 · 조회 상태, 지시문의 OP.GG 실제 점수 줄)을 뺐다. 기록 점수(OP.GG 계산법) · 10/15분 라인전(LOL.PS 정의)은 앱이 경기 기록으로 계산한다.
`node --import tsx app/scripts/culprit-real-e2e.mts` — 실제 Claude Opus 5.5(생각 high), 외부 사이트 접속 없음 (로그에 OP.GG 0건)
| 경기 | 걸린 시간 | 토큰 (입력 / 캐시 쓰기 / 출력) | 비용 | 범인 (기록 점수 팀 최하위) |
|---|---|---|---|---|
| 발로란트 시연 경기 (22라운드, 대화 4문장) | 33초 | 10,562 / 7,382 / 2,943 | $0.138 | 우리 P5 (공동 최하위 5.0, 동점자 P4 와 비교해 이유) · 상대 P7 (1.9, 최하위) |
| 롤 시연 경기 (10 · 15분 라인전, 대화 7문장) | 36초 | 3,186 / 8,937 / 3,300 | $0.123 | 우리 P1 (2.7, 최하위) · 상대 P7 (4.5, 최하위) |
- AI 평점과 기록 점수 차: 평균 0.4점 (롤 P2 는 "용 셋 · 유충 · 바론 싹쓸이"를 근거로 기록 3.0 → AI 5.0)
- 테스트: 앱 40개 · 사이트 서버 16개 통과 (서버 테스트에 "자료에 기록 점수 칸, 지시문 '평점은 기록 점수에서 출발', OP.GG 실제 점수 없음" 확인 추가)

View File

@@ -239,12 +239,8 @@ export interface CulpritPlayer {
userId: string | null;
/** 이 경기 음성 대화가 있는지 */
voice: boolean;
/** Riot ID 태그 (OP.GG 에서 경기를 찾을 때, v1.3~) */
tag?: string;
/** 기록 점수: OP.GG OP스코어 방식으로 우리 기록에서 계산 (v1.3~) */
/** 기록 점수: OP.GG OP스코어 계산법을 따라 우리 기록에서 계산 (v1.3~) */
rating?: PlayerRating;
/** OP.GG 에 이 경기가 있으면 그 사이트의 실제 OP스코어 (사이트 서버가 분석할 때 붙인다) */
opgg?: { score: number; rank: number | null };
}
/** 근거 번호가 가리키는 것 (사이트에서 누르면 그 순간으로 이동) */
export type CulpritRefTarget =
@@ -259,8 +255,6 @@ export interface CulpritInput {
refs: Record<string, CulpritRefTarget>;
players: CulpritPlayer[];
stats: { utterances: number; utterancesTotal: number; events: number; chats: number; rounds: number; basic: boolean };
/** OP.GG 에서 같은 경기를 찾을 정보 (v1.3~). riotMatchId = 발로란트 경기 UUID · 롤 gameId */
lookup?: { riotMatchId: string | null; startedAt: number; endedAt: number; durationSec: number };
}
export interface CulpritEvidence {
ref: string;
@@ -290,8 +284,6 @@ export interface CulpritAnalysis {
usage?: { input: number; output: number; cacheRead?: number; cacheWrite?: number };
inputStats?: CulpritInput['stats'];
fallback?: boolean;
/** OP.GG 실제 점수를 찾았는지 · 못 찾은 이유. error = 조회 실패로 확인 못 함 (경기 없음과 다르다) */
opgg?: { found: boolean; error?: boolean; note?: string };
};
}
export interface CulpritMatchItem {

View File

@@ -1,5 +1,5 @@
<!-- 겜녹이 범인찾기 시스템 프롬프트 v1.2 (2026-10-15, 사용자 결정 반영: 범인 = 종합 판단, 말투 기본 중간맛,
전적 사이트 점수 참고: 기록 점수 = OP.GG OP스코어 방식, OP.GG 실제 점수, LOL.PS 방식 라인전)
전적 사이트 계산법 참고: 기록 점수 = OP.GG OP스코어 계산법, 라인전 = LOL.PS 라인전 점수의 입력. 외부 사이트에 접속하지 않고 경기 기록으로 계산)
서버가 이 파일 + 게임별 knowledge-*.md 를 system 에 넣고, 경기 자료는 user 메시지로 보낸다.
{{tone}} 은 말투 설정(mild|medium|spicy)으로 바꾼다. 이 파일과 knowledge 는 경기마다 같아서 프롬프트 캐시 대상이다. -->
너는 겜녹이의 경기 분석가다. 디스코드 친구들이 함께 한 발로란트 또는 리그 오브 레전드 경기 한 판의 기록을 읽고, 참가자 10명을 평가하고 팀마다 "범인"을 한 명씩 고른다. 결과는 친구들이 재미로 보는 사이트에 그대로 뜬다. 정확하고 공정해야 웃고 넘길 수 있다.
@@ -8,10 +8,9 @@
user 메시지의 <match> 안에 경기 자료가 온다.
- 경기: 게임, 모드, 맵, 최종 점수, 길이. "우리 팀" = 음성을 녹음한 쪽 팀, "상대 팀" = 다른 팀.
- 참가자: P1~P10 번호, 이름, 팀, 요원·챔피언과 역할(포지션), 스탯, 음성 유무(음성O / 음성X).
- 기록 점수: 전적 사이트 OP.GG 의 OP스코어를 같은 방식으로 이 경기 기록에서 다시 계산한 0~10점. 경기 순위 · 팀 순위, 이긴 팀 1등 MVP · 진 팀 1등 ACE, 그 점수를 경기 평균보다 올린 강점과 깎은 약점이 붙는다.
발로란트는 라운드 승률 · KAST · ACS · 피해 격차, 롤은 킬 관여 · 데스 · 딜/받은 피해/골드 비중 · CS · 레벨 · CC · 와드로 낸다. 실제 OP.GG 점수와 평균 0.5~0.6점 차이다.
- 기록 점수: 전적 사이트 OP.GG 의 OP스코어 계산법을 따라 이 경기 기록으로 계산한 0~10점. 경기 순위 · 팀 순위, 이긴 팀 1등 MVP · 진 팀 1등 ACE, 그 점수를 경기 평균보다 올린 강점과 깎은 약점이 붙는다.
발로란트는 라운드 승률 · KAST · ACS · 피해 격차, 롤은 킬 관여 · 데스 · 딜/받은 피해/골드 비중 · CS · 레벨 · CC · 와드로 낸다. OP.GG 가 매기는 점수와 평균 0.5~0.6점 차이다.
롤 "라인전(vs P6) 10분 CS+5 골드+300 경험치+120 15분 CS+12 골드+640 경험치+210" = 전적 사이트 LOL.PS 가 라인전 점수를 낼 때 쓰는 값. 10분 · 15분에 맞라이너보다 앞선(+) · 뒤진(-) CS · 골드 · 경험치.
- "OP.GG 실제 OP스코어" 줄이 있으면 이 경기를 OP.GG 에서 찾은 그 사이트의 실제 점수다. 기록 점수보다 이것을 먼저 본다. 이 줄이 없으면 OP.GG 에 없는 경기(내전 등)이거나 조회하지 못한 경기다.
- 시간 순서의 줄. 줄 앞 번호가 근거 번호다.
- [e번호] 게임 이벤트 (킬, 스파이크, 오브젝트, 라운드 결과 등)
- [u번호] 음성 문장. 디스코드 음성채널에서 자동 음성 인식으로 받아 적은 것이라 글자가 틀릴 수 있다.
@@ -28,13 +27,13 @@ user 메시지의 <match> 안에 경기 자료가 온다.
<task>
1. 경기 흐름을 먼저 파악한다. 어느 라운드·시간대에서 승부가 갈렸는지 찾는다.
2. 10명 모두 평가한다: 평점(1.0~10.0, 0.5 단위), 태그 하나, 한 줄 평(40자 안팎).
- 평점은 전적 사이트 점수(OP.GG 실제 점수가 있으면 그것, 없으면 기록 점수)에서 출발한다. 여기에 그 점수가 못 보는 것을 더하고 뺀다: 승부처에서 한 일, 역할 수행, 경제, 음성 소통과 콜.
- 출발 점수와 2점 넘게 다르게 줄 때는 그 이유가 되는 근거를 그 사람 evidence 에 단다.
- 평점은 기록 점수에서 출발한다. 여기에 그 점수가 못 보는 것을 더하고 뺀다: 승부처에서 한 일, 역할 수행, 경제, 음성 소통과 콜.
- 기록 점수와 2점 넘게 다르게 줄 때는 그 이유가 되는 근거를 그 사람 evidence 에 단다.
3. 팀마다 범인을 한 명씩 고른다. 범인은 아래를 모두 합쳐 종합으로 판단한다. 한 가지만 보지 않는다.
- 가장 못한 사람: 자기 역할·포지션 기준으로 플레이가 가장 나빴다.
- 가장 발목을 잡은 사람: 팀의 계획·경제·콜을 가장 많이 망쳤다.
- 결과의 원인: 진 팀이면 패배에 가장 큰 책임, 이긴 팀이면 이기는 데 가장 방해가 된 사람.
- 범인 후보는 그 팀에서 전적 사이트 점수가 낮은 사람부터 본다. 점수가 팀 최하위가 아닌 사람을 범인으로 고르면, 최하위보다 책임이 더 큰 이유(점수가 못 보는 근거)를 reason 에 쓴다.
- 범인 후보는 그 팀에서 기록 점수가 낮은 사람부터 본다. 점수가 팀 최하위가 아닌 사람을 범인으로 고르면, 최하위보다 책임이 더 큰 이유(점수가 못 보는 근거)를 reason 에 쓴다.
- 범인은 그 팀에서 평점이 가장 낮아야 한다. 동점이면 근거가 더 분명한 사람.
4. 범인마다 이유(2~3문장)와 근거 3~4개, 나머지 사람은 근거 0~2개를 단다.
5. 경기 전체 한 줄 요약(1~2문장)을 쓴다.

View File

@@ -8,7 +8,6 @@ import type { Config } from './config.js';
import { registerAppAuth } from './app-auth.js';
import { BotBroker, type BotSource } from './bot-broker.js';
import { registerCulprit, type ModelCall } from './culprit.js';
import type { ToolCaller } from './opgg.js';
import type { KnowledgeAuto } from './culprit-prompt.js';
import { avatarUrl, DiscordApi } from './discord.js';
import { RateLimiter } from './rate-limit.js';
@@ -19,7 +18,7 @@ const SID = 'gvr_sid';
const RECHECK_MS = 10 * 60000;
/** botSource: 겜녹이 봇 디스코드 연결 (main.ts 가 discord.js 로 만든다. 없으면 /app/bot/ws 는 503) */
export async function buildServer(cfg: Config, opts: { botSource?: BotSource; botRecheckMs?: number; culpritCall?: ModelCall; culpritKnowledge?: KnowledgeAuto; culpritOpgg?: ToolCaller | null } = {}) {
export async function buildServer(cfg: Config, opts: { botSource?: BotSource; botRecheckMs?: number; culpritCall?: ModelCall; culpritKnowledge?: KnowledgeAuto } = {}) {
const app = Fastify({
logger: {
level: process.env.LOG_LEVEL || 'info',
@@ -178,7 +177,7 @@ export async function buildServer(cfg: Config, opts: { botSource?: BotSource; bo
});
// ------------------------------------------------------------------ 범인찾기 (Claude API 는 이 서버만 부른다)
const culprit = registerCulprit(app, { cfg, store, hub, requireSession, log: app.log, call: opts.culpritCall, knowledge: opts.culpritKnowledge, opgg: opts.culpritOpgg });
const culprit = registerCulprit(app, { cfg, store, hub, requireSession, log: app.log, call: opts.culpritCall, knowledge: opts.culpritKnowledge });
// ------------------------------------------------------------------ 기록 API 중계
const relay = async (req: FastifyRequest, reply: FastifyReply) => {

View File

@@ -28,8 +28,6 @@ export interface Config {
monthLimitUsd: number;
dailyLimit: number;
tone: 'mild' | 'medium' | 'spicy';
/** 분석할 때 OP.GG 실제 OP스코어를 찾을지 (기본 켬, CULPRIT_OPGG=0 이면 끔) */
opgg?: boolean;
};
}
@@ -74,7 +72,6 @@ export function loadConfig(env = process.env): Config {
monthLimitUsd: Number(env.CULPRIT_MONTH_LIMIT_USD || 100),
dailyLimit: Number(env.CULPRIT_DAILY_LIMIT || 20),
tone: (env.CULPRIT_TONE as any) || 'medium',
opgg: env.CULPRIT_OPGG !== '0',
},
};
}

View File

@@ -14,7 +14,6 @@ import {
} from '@gvr/shared';
import { CULPRIT_DEFAULTS, type Config } from './config.js';
import { buildSystemPrompt, KnowledgeAuto, outputSchema } from './culprit-prompt.js';
import { lookupOpgg, opggCaller, opggLines, type ToolCaller } from './opgg.js';
import type { RelayHub } from './relay.js';
import type { ServerStore, Session } from './store.js';
@@ -255,8 +254,6 @@ export interface CulpritOptions {
log: { info: (o: any, m?: string) => void; warn: (o: any, m?: string) => void; error: (o: any, m?: string) => void };
call?: ModelCall;
knowledge?: KnowledgeAuto;
/** OP.GG 실제 점수 찾기 (테스트에서 바꿔 끼운다, null = 끔) */
opgg?: ToolCaller | null;
}
export function registerCulprit(app: FastifyInstance, o: CulpritOptions) {
@@ -265,7 +262,6 @@ export function registerCulprit(app: FastifyInstance, o: CulpritOptions) {
const ledger = new Ledger(cfg.dataDir);
const call: ModelCall | null = o.call ?? (c.apiKey ? anthropicCall(c.apiKey) : null);
const knowledge = o.knowledge ?? new KnowledgeAuto(undefined, log);
const opgg: ToolCaller | null = o.opgg !== undefined ? o.opgg : c.opgg === false ? null : opggCaller();
const running = new Map<string, { by: string; at: number; stage: CulpritStage }>();
/** (가) 등록된 앱 유저 이상만 분석 버튼, 다시 분석은 관리자 이상 (사용자 결정 ②) */
@@ -352,27 +348,17 @@ export function registerCulprit(app: FastifyInstance, o: CulpritOptions) {
log.error(e, '범인찾기 자료 받기 실패');
return reply.code(502).send({ error: 'input_failed' });
}
publish(matchId, 'thinking');
void run(matchId, input, { id: s.user.id, name: s.user.name }).finally(() => running.delete(matchId));
return reply.code(202).send({ ok: true });
});
/** AI 분석 (버튼 응답 뒤에 돈다. 창을 닫아도 계속, 끝나면 실시간 알림) */
async function run(matchId: string, raw: CulpritInput, by: { id: string; name: string }): Promise<void> {
async function run(matchId: string, input: CulpritInput, by: { id: string; name: string }): Promise<void> {
const started = Date.now();
const usages: Usage[] = [];
let fallback = false;
try {
// 전적 사이트 점수: 이 경기가 OP.GG 에 있으면 실제 OP스코어를 자료에 붙인다 (없거나 실패해도 기록 점수로 계속)
let opggMeta: { found: boolean; error?: boolean; note?: string } | undefined;
let input = raw;
if (opgg && raw.lookup) {
publish(matchId, 'collect', 'OP.GG 점수 찾는 중');
const r = await lookupOpgg(raw, opgg).catch((e) => ({ scores: new Map(), found: false, error: true, note: `OP.GG 연결 실패 (${String(e?.message ?? e).slice(0, 80)})` }));
opggMeta = { found: r.found, ...(r.error ? { error: true } : {}), ...(r.note ? { note: r.note } : {}) };
input = withOpgg(raw, r);
log.info({ matchId, opgg: opggMeta, n: r.scores.size }, '범인찾기 OP.GG 점수');
}
publish(matchId, 'thinking');
const system = buildSystemPrompt(input.game, c.tone, await knowledge.get(input.game));
const schema = outputSchema();
const user = `<match>\n${input.text}\n</match>`;
@@ -413,7 +399,7 @@ export function registerCulprit(app: FastifyInstance, o: CulpritOptions) {
players: input.players,
model: usages.at(-1)?.model ?? c.model,
createdBy: by,
meta: { tone: c.tone, durationMs: Date.now() - started, costUsd: totalCost, usage: sumUsage(usages), inputStats: input.stats, fallback, ...(opggMeta ? { opgg: opggMeta } : {}) },
meta: { tone: c.tone, durationMs: Date.now() - started, costUsd: totalCost, usage: sumUsage(usages), inputStats: input.stats, fallback },
},
60000,
);
@@ -435,20 +421,6 @@ export function registerCulprit(app: FastifyInstance, o: CulpritOptions) {
return { budget, ledger, running };
}
/** OP.GG 점수를 자료(시간 순서 기록 앞)와 참가자에 붙인다 */
export function withOpgg(input: CulpritInput, r: Awaited<ReturnType<typeof lookupOpgg>>): CulpritInput {
const lines = opggLines(input, r);
if (!lines.length) return input;
const text = input.text.split('\n');
const at = text.indexOf('# 시간 순서 기록');
text.splice(at < 0 ? text.length : at, 0, ...lines);
return {
...input,
text: text.join('\n'),
players: input.players.map((p) => (r.scores.has(p.id) ? { ...p, opgg: r.scores.get(p.id)! } : p)),
};
}
function sumUsage(us: Usage[]) {
return us.reduce((a, u) => ({ input: a.input + u.input, output: a.output + u.output, cacheRead: a.cacheRead + u.cacheRead, cacheWrite: a.cacheWrite + u.cacheWrite }), { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
}

View File

@@ -1,234 +0,0 @@
import type { CulpritInput } from '@gvr/shared';
/**
* OP.GG 실제 OP스코어 찾기 (범인찾기 참고 자료).
* OP.GG 가 AI 도구용으로 연 공식 MCP 서버(https://mcp-api.op.gg/mcp, 키 없음)를 부른다.
* - 롤: 우리 팀 한 명의 최근 경기에서 시작 시각 · 길이가 같은 경기를 찾고, 그 경기 상세에서 10명의 op_score
* - 발로란트: 경기 UUID 가 같으니 각 선수의 최근 경기에서 그 경기를 찾아 opScore(0~1000 → 0~10)
* 사용자 지정 게임(내전)은 OP.GG 에 올라가지 않아 못 찾는 게 정상이다. 못 찾거나 실패해도 분석은 기록 점수만으로 계속한다.
*/
export const OPGG_MCP_URL = 'https://mcp-api.op.gg/mcp';
const PROTOCOL = '2025-06-18';
export interface OpggResult {
/** P번호 → 점수 (0~10) · OP.GG 경기 순위 (롤만) */
scores: Map<string, { score: number; rank: number | null }>;
found: boolean;
/** 조회가 실패해서 경기가 있는지 확인하지 못했다 (OP.GG 장애 · 연결 실패). "경기 없음"과 다르다 */
error?: boolean;
note?: string;
}
/** 세션이 끝났다는 서버 응답 (MCP 규격: 404 → 새로 initialize) */
class SessionExpired extends Error {}
export type ToolCaller = (name: string, args: Record<string, unknown>) => Promise<unknown>;
/** MCP 스트리머블 HTTP 클라이언트 (세션 하나로 여러 번 부른다) */
export function opggCaller(opts: { url?: string; timeoutMs?: number; fetchFn?: typeof fetch } = {}): ToolCaller {
const url = opts.url ?? OPGG_MCP_URL;
const f = opts.fetchFn ?? fetch;
const timeoutMs = opts.timeoutMs ?? 20000;
let sid: string | null = null;
let id = 1;
const post = async (body: unknown) => {
const headers: Record<string, string> = { 'content-type': 'application/json', accept: 'application/json, text/event-stream', 'user-agent': 'gvr-site/1.3' };
if (sid) Object.assign(headers, { 'mcp-session-id': sid, 'mcp-protocol-version': PROTOCOL });
const r = await f(url, { method: 'POST', headers, body: JSON.stringify(body), signal: AbortSignal.timeout(timeoutMs) });
if (sid && r.status === 404) throw new SessionExpired('OP.GG 세션 만료');
if (!r.ok) throw new Error(`OP.GG ${r.status}`);
const s = r.headers.get('mcp-session-id');
const text = await r.text();
// 서버가 SSE 로 줄 때는 마지막 data: 줄
const json = text.trimStart().startsWith('{') ? text : (text.split('\n').filter((l) => l.startsWith('data:')).pop() ?? '').slice(5);
return { sid: s, data: JSON.parse(json) };
};
let starting: Promise<void> | null = null;
const start = () =>
(starting ??= (async () => {
sid = null;
const init = await post({ jsonrpc: '2.0', id: id++, method: 'initialize', params: { protocolVersion: PROTOCOL, capabilities: {}, clientInfo: { name: 'gvr', version: '1.3' } } });
if (!init.sid) throw new Error('OP.GG 세션 없음');
sid = init.sid;
})().finally(() => (starting = null)));
const toolCall = (name: string, args: Record<string, unknown>) => post({ jsonrpc: '2.0', id: id++, method: 'tools/call', params: { name, arguments: args } });
return async (name, args) => {
if (!sid) await start();
let res;
try {
res = await toolCall(name, args);
} catch (e) {
// 세션이 끝났으면(서버 재시작 · 만료) 새 세션으로 한 번 다시
if (!(e instanceof SessionExpired)) throw e;
await start();
res = await toolCall(name, args);
}
if (res.data.error) throw new Error(`OP.GG ${name}: ${res.data.error.message ?? 'error'}`);
const text = res.data.result?.content?.[0]?.text ?? '';
if (res.data.result?.isError) throw new Error(`OP.GG ${name}: ${String(text).slice(0, 200)}`);
return parseOpgg(text);
};
}
/**
* OP.GG MCP 응답 해석. JSON 이면 그대로, 아니면 "class X: a,b … X(…)" 모양(필드 이름은 class 줄)을 객체로.
*/
export function parseOpgg(text: string): unknown {
const t = text.trim();
if (t.startsWith('{') || t.startsWith('[')) return JSON.parse(t);
const classes = new Map<string, string[]>();
const lines = t.split('\n');
let bodyStart = 0;
lines.forEach((ln, i) => {
const m = /^class (\w+): (.*)$/.exec(ln);
if (m) {
classes.set(m[1], m[2].split(','));
bodyStart = i + 1;
}
});
const body = lines.slice(bodyStart).join('\n');
const re = /\s*(?:("(?:[^"\\]|\\.)*")|(-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)|([A-Za-z_][A-Za-z0-9_]*)|([()[\],]))/y;
const toks: [string, string][] = [];
let m: RegExpExecArray | null;
while (re.lastIndex < body.length && (m = re.exec(body))) {
if (m[1] !== undefined) toks.push(['s', m[1]]);
else if (m[2] !== undefined) toks.push(['n', m[2]]);
else if (m[3] !== undefined) toks.push(['i', m[3]]);
else if (m[4] !== undefined) toks.push(['p', m[4]]);
}
let pos = 0;
const isP = (v: string) => toks[pos]?.[0] === 'p' && toks[pos][1] === v;
const list = (close: string): unknown[] => {
const out: unknown[] = [];
while (pos < toks.length && !isP(close)) {
out.push(val());
if (isP(',')) pos++;
}
pos++;
return out;
};
const val = (): unknown => {
const [k, v] = toks[pos++] ?? ['p', ')'];
if (k === 's') return JSON.parse(v);
if (k === 'n') return Number(v);
if (k === 'p' && v === '[') return list(']');
if (k === 'i') {
if (v === 'true' || v === 'True') return true;
if (v === 'false' || v === 'False') return false;
if (v === 'null' || v === 'None') return null;
if (!isP('(')) throw new Error(`OP.GG 응답 해석 실패: ${v}`);
pos++;
const args = list(')');
const fields = classes.get(v) ?? [];
return Object.fromEntries(fields.map((f, i) => [f, args[i]]));
}
throw new Error('OP.GG 응답 해석 실패');
};
return val();
}
const NOT_FOUND = 'OP.GG 에 이 경기가 없습니다 (사용자 설정 게임은 OP.GG 에 올라가지 않습니다)';
const riotKey = (name: string, tag: string) => `${name}#${tag}`.toLowerCase().replace(/\s+/g, '');
/** 이 경기를 OP.GG 에서 찾아 참가자별 실제 점수. 전체 제한 시간 안에 못 끝나면 그때까지 찾은 만큼 */
export async function lookupOpgg(input: CulpritInput, call: ToolCaller, opts: { region?: string; deadlineMs?: number } = {}): Promise<OpggResult> {
const lk = input.lookup;
const scores: OpggResult['scores'] = new Map();
if (!lk?.riotMatchId) return { scores, found: false, note: '앱이 경기 번호를 보내지 않았습니다' };
const tagged = input.players.filter((p) => p.tag && p.name && p.name !== '?');
if (!tagged.length) return { scores, found: false, note: '참가자 Riot ID 가 없습니다' };
const deadline = Date.now() + (opts.deadlineMs ?? 45000);
const region = opts.region ?? 'KR';
// 우리 사람(음성 · 앱 계정)부터 찾아본다
const order = [...tagged].sort((a, b) => Number(!!b.userId) - Number(!!a.userId) || Number(a.team !== 'ally') - Number(b.team !== 'ally'));
let calls = 0;
let failed = 0;
let lastError = '';
const fail = (e: unknown) => {
failed++;
lastError = String((e as Error)?.message ?? e).slice(0, 80);
};
/** 못 찾았을 때: 조회가 모두(또는 일부) 실패했으면 "확인 못 함", 다 성공했는데 없으면 "경기 없음" */
const missing = (): OpggResult =>
failed
? { scores, found: false, error: true, note: `OP.GG 조회 실패로 이 경기를 확인하지 못했습니다 (${calls}번 중 ${failed}번 실패: ${lastError})` }
: { scores, found: false, note: NOT_FOUND };
if (input.game === 'valorant') {
let seen = false;
// 각자의 최근 경기 목록에 자기 opScore 만 있다 → 사람마다 부른다 (동시에 3개까지)
const queue = [...order];
const worker = async () => {
for (let p = queue.shift(); p && Date.now() < deadline; p = queue.shift()) {
calls++;
try {
const list = (await call('valorant_list_player_matches', { game_name: p.name, tag_line: p.tag })) as any;
const arr: any[] = Array.isArray(list) ? list : (list?.data ?? []);
const hit = arr.find((x) => x?.matchId === lk.riotMatchId);
if (!hit) continue;
seen = true;
if (typeof hit.opScore === 'number' && (!hit.puuid || hit.puuid === p.puuid)) scores.set(p.id, { score: Math.round(hit.opScore / 10) / 10, rank: null });
} catch (e) {
fail(e); // 이 사람은 건너뛴다
}
}
};
await Promise.all([worker(), worker(), worker()]);
if (!seen) return missing();
return { scores, found: scores.size > 0, note: scores.size < input.players.length ? `OP.GG 에서 ${scores.size}명 점수를 찾았습니다` : undefined };
}
// 롤: 한 사람의 최근 경기에서 같은 경기(시작 ±5분 · 길이 ±2분)를 찾는다
for (const p of order.slice(0, 3)) {
if (Date.now() >= deadline) break;
calls++;
try {
const hist = (await call('lol_list_summoner_matches', {
game_name: p.name,
tag_line: p.tag,
region,
limit: 20,
desired_output_fields: ['data.game_history[].{created_at,game_length_second,game_type,id}'],
})) as any;
const games: any[] = hist?.data?.game_history ?? [];
const g = games.find(
(x) => Math.abs(Date.parse(x.created_at) - lk.startedAt) < 5 * 60000 && Math.abs((x.game_length_second ?? 0) - lk.durationSec) < 120,
);
if (!g) continue;
calls++;
const det = (await call('lol_get_summoner_game_detail', {
region,
game_id: g.id,
created_at: g.created_at,
desired_output_fields: [
'data.game_detail.teams[].participants[].stats.{op_score,op_score_rank}',
'data.game_detail.teams[].participants[].summoner.{puuid,game_name,tagline}',
],
})) as any;
const parts: any[] = (det?.data?.game_detail?.teams ?? []).flatMap((t: any) => t.participants ?? []);
for (const q of input.players) {
const hit = parts.find((x) => (x.summoner?.puuid && x.summoner.puuid === q.puuid) || (q.tag && x.summoner?.game_name && riotKey(x.summoner.game_name, x.summoner.tagline ?? '') === riotKey(q.name, q.tag)));
const s = hit?.stats;
if (s && typeof s.op_score === 'number') scores.set(q.id, { score: Math.round(s.op_score * 10) / 10, rank: typeof s.op_score_rank === 'number' ? s.op_score_rank : null });
}
return { scores, found: scores.size > 0, note: scores.size ? undefined : 'OP.GG 경기에서 참가자를 맞추지 못했습니다' };
} catch (e) {
fail(e); // 다음 사람으로
}
}
return missing();
}
/** AI 자료에 붙일 줄 (찾은 것만) */
export function opggLines(input: CulpritInput, r: OpggResult): string[] {
if (!r.found || !r.scores.size) return [];
const cells = input.players
.filter((p) => r.scores.has(p.id))
.map((p) => {
const s = r.scores.get(p.id)!;
return `${p.id} ${s.score.toFixed(1)}${s.rank ? `(${s.rank}위)` : ''}`;
});
return [`# OP.GG 실제 OP스코어 (이 경기를 OP.GG 에서 찾음, 0~10${input.game === 'lol' ? ', 괄호 = OP.GG 경기 순위' : ''}): ${cells.join(' · ')}`];
}

View File

@@ -9,7 +9,6 @@ import { buildServer } from '../src/app.ts';
import type { Config } from '../src/config.ts';
import { checkResult, costOf, normRef, type ModelCall } from '../src/culprit.ts';
import { buildSystemPrompt, KnowledgeAuto, outputSchema, replaceAutoSection } from '../src/culprit-prompt.ts';
import { lookupOpgg, opggCaller, parseOpgg, type ToolCaller } from '../src/opgg.ts';
const tmp = () => fs.mkdtempSync(path.join(process.env.TMPDIR || os.tmpdir(), 'gvr-culprit-srv-'));
@@ -39,7 +38,7 @@ function answer(input: CulpritInput, opts: { badRefs?: boolean; culpritScore?: n
};
}
async function harness(opts: { calls: ((input: CulpritInput) => Awaited<ReturnType<ModelCall>>)[]; culprit?: Partial<NonNullable<Config['culprit']>>; opgg?: ToolCaller | null }) {
async function harness(opts: { calls: ((input: CulpritInput) => Awaited<ReturnType<ModelCall>>)[]; culprit?: Partial<NonNullable<Config['culprit']>> }) {
// 앱 코어 (실제 범인찾기 코드 + 시연 경기)
const seed = await import('../../../app/test/fixtures/culprit-seed.ts');
const core = seed.setup();
@@ -75,9 +74,7 @@ async function harness(opts: { calls: ((input: CulpritInput) => Awaited<ReturnTy
const knowledge = new KnowledgeAuto(async () => {
throw new Error('offline');
});
// OP.GG: 기본은 "이 경기 없음" (네트워크 안 씀)
const opgg: ToolCaller | null = opts.opgg !== undefined ? opts.opgg : async () => [];
const { app, store, hub } = await buildServer(cfg, { culpritCall: call, culpritKnowledge: knowledge, culpritOpgg: opgg });
const { app, store, hub } = await buildServer(cfg, { culpritCall: call, culpritKnowledge: knowledge });
await app.listen({ host: '127.0.0.1', port: 0 });
const base = `http://127.0.0.1:${(app.server.address() as any).port}`;
const login = (id: string) => {
@@ -145,7 +142,7 @@ test('범인찾기 서버: 권한 · 분석 · 근거 확인 · 결과 저장 ·
const dup = await h.post(user);
assert.ok(dup.status === 409, `중복 ${dup.status}`);
await waitFor(() => h.stages().includes('done') || h.stages().includes('failed'));
assert.deepEqual(h.stages(), ['collect', 'thinking', 'verify', 'done']);
assert.deepEqual(h.stages(), ['thinking', 'verify', 'done']);
// 보낸 프롬프트: 지시문 + 발로란트 지식 묶음(파일 스냅샷) + 말투 중간맛, 경기 자료는 <match> 안
const sent = h.seen[0];
@@ -154,6 +151,10 @@ test('범인찾기 서버: 권한 · 분석 · 근거 확인 · 결과 저장 ·
assert.match(sent.system, /<knowledge game="valorant">[\s\S]*## 자동 갱신 \(2026-10-15 스냅샷\)/);
assert.ok(!sent.system.includes('<!--'), 'HTML 주석은 빼고 보낸다');
assert.match(sent.user, /^<match>\n# 경기 발로란트 /);
// 기록 점수(OP.GG 계산법)는 앱이 경기 기록으로 계산해 자료에 넣는다 (외부 사이트 접속 없음)
assert.match(sent.user, /\n# 기록 점수 \(0~10, OP\.GG OP스코어 계산법: 라운드 승률 · KAST · ACS · 피해 격차로 계산/);
assert.match(sent.system, /평점은 기록 점수에서 출발한다/);
assert.ok(!/OP\.GG 실제/.test(sent.system + sent.user));
assert.equal(sent.effort, 'high');
assert.equal(sent.maxTokens, 32000);
assert.equal(sent.schema.type, 'object');
@@ -290,159 +291,3 @@ test('범인찾기: 결과 확인 규칙 · 비용 계산 · 프롬프트 조립
const schema = outputSchema() as any;
assert.deepEqual(schema.required, ['summary', 'confidence', 'confidence_note', 'teams', 'players']);
});
test('범인찾기 서버: OP.GG 조회 실패는 "경기 없음"과 따로 저장하고 기록 점수로 분석을 마친다', async () => {
const h = await harness({
calls: [(i) => ok(i)],
opgg: async () => {
throw new Error('OP.GG 503');
},
});
try {
assert.equal((await h.post(h.login('user1'))).status, 202);
await waitFor(() => h.stages().includes('done') || h.stages().includes('failed'));
assert.deepEqual(h.stages(), ['collect', 'thinking', 'verify', 'done']);
assert.ok(!h.seen[0].user.includes('# OP.GG 실제 OP스코어'));
const info = (await (await fetch(`${h.base}/api/culprit/matches/${h.matchId}`, { headers: { cookie: h.login('member1') } })).json()) as CulpritMatchInfo;
assert.equal(info.analysis!.meta.opgg!.found, false);
assert.equal(info.analysis!.meta.opgg!.error, true);
assert.match(info.analysis!.meta.opgg!.note!, /조회 실패/);
} finally {
await h.close();
}
});
test('범인찾기 서버: OP.GG 에 경기가 있으면 실제 OP스코어를 자료 · 결과에 붙인다', async () => {
const puuidOf: Record<string, string> = {};
const calls: string[] = [];
const opgg: ToolCaller = async (name, args: any) => {
calls.push(name);
if (name !== 'valorant_list_player_matches') throw new Error('unexpected');
// 각자 자기 경기 목록에 자기 opScore 만 (OP.GG 와 같은 모양)
return [{ matchId: 'other', puuid: puuidOf[args.game_name], opScore: 100 }, { matchId: 'demo', puuid: puuidOf[args.game_name], opScore: 655 }];
};
const h = await harness({ calls: [(i) => ok(i)], opgg });
try {
const input = (await h.local.inject({ url: `/api/culprit/internal/${h.matchId}/input`, headers: { 'x-gvr-internal': '1' } })).json().input as CulpritInput;
for (const p of input.players) puuidOf[p.name] = p.puuid;
assert.deepEqual(input.lookup?.riotMatchId, 'demo');
assert.equal((await h.post(h.login('user1'))).status, 202);
await waitFor(() => h.stages().includes('done') || h.stages().includes('failed'));
assert.deepEqual(h.stages(), ['collect', 'thinking', 'verify', 'done']);
const user = h.seen[0].user;
const lines = user.split('\n');
const at = lines.findIndex((l) => l.startsWith('# OP.GG 실제 OP스코어'));
assert.ok(at > 0 && at < lines.indexOf('# 시간 순서 기록'), 'OP.GG 줄은 시간 순서 기록 앞');
assert.match(lines[at], /: P1 6\.6 · P2 6\.6 .* · P10 6\.6$/);
assert.ok(lines.some((l) => l.startsWith('# 기록 점수 (0~10, OP.GG OP스코어 방식')), '기록 점수 칸 (앱이 만든다)');
assert.equal(calls.length, 10);
const info = (await (await fetch(`${h.base}/api/culprit/matches/${h.matchId}`, { headers: { cookie: h.login('member1') } })).json()) as CulpritMatchInfo;
assert.deepEqual(info.analysis!.meta.opgg, { found: true });
assert.deepEqual(info.analysis!.players.find((p) => p.id === 'P3')!.opgg, { score: 6.6, rank: null });
assert.ok(info.analysis!.players.every((p) => p.rating && p.rating.score >= 0), '저장된 참가자에 기록 점수');
} finally {
await h.close();
}
});
test('OP.GG: 응답 해석 · 롤 경기 찾기 (시작 시각 · 길이) · 못 찾음 · 연결 실패', async () => {
const text = [
'class L: data',
'class Data: game_history',
'class GameHistory: id,created_at,game_length_second,game_type',
'',
'L(Data([GameHistory("g1","2026-10-15T02:12:05+09:00",1387,"SOLORANKED"),GameHistory("g2","2026-10-15T01:00:00+09:00",900,"NORMAL")]))',
].join('\n');
assert.deepEqual(parseOpgg(text), {
data: {
game_history: [
{ id: 'g1', created_at: '2026-10-15T02:12:05+09:00', game_length_second: 1387, game_type: 'SOLORANKED' },
{ id: 'g2', created_at: '2026-10-15T01:00:00+09:00', game_length_second: 900, game_type: 'NORMAL' },
],
},
});
assert.deepEqual(parseOpgg('X(true,null,-1.5,"a\\"b",[1,2])\n'.replace(/^/, 'class X: a,b,c,d,e\n\n')), { a: true, b: null, c: -1.5, d: 'a"b', e: [1, 2] });
const players = Array.from({ length: 10 }, (_, i) => ({ id: `P${i + 1}`, puuid: `pu${i}`, name: `n${i}`, tag: 'KR1', team: i < 5 ? 'ally' : 'enemy', character: null, userId: i === 2 ? 'u' : null, voice: false })) as CulpritInput['players'];
const input = { game: 'lol', text: '', refs: {}, players, stats: {} as any, lookup: { riotMatchId: '777', startedAt: Date.parse('2026-10-15T02:12:30+09:00'), endedAt: 0, durationSec: 1400 } } as CulpritInput;
const asked: any[] = [];
const caller: ToolCaller = async (name, args) => {
asked.push([name, args]);
if (name === 'lol_list_summoner_matches') return parseOpgg(text);
return {
data: {
game_detail: {
teams: [0, 1].map((t) => ({
participants: players.slice(t * 5, t * 5 + 5).map((p, i) => ({
// 한 명은 puuid 가 달라도 Riot ID 로 맞춘다
summoner: { puuid: p.id === 'P9' ? 'other' : p.puuid, game_name: p.name.toUpperCase(), tagline: 'kr1' },
stats: { op_score: 5 + t + i / 10, op_score_rank: t * 5 + i + 1 },
})),
})),
},
},
};
};
const r = await lookupOpgg(input, caller);
assert.equal(r.found, true);
assert.equal(r.scores.size, 10);
assert.deepEqual(r.scores.get('P9'), { score: 6.3, rank: 9 });
assert.equal(asked[0][1].game_name, 'n2', '우리 사람(앱 계정)부터');
assert.deepEqual(asked[1][1].game_id, 'g1');
// 시작 시각이 다르면 못 찾음 (내전 · 아직 OP.GG 에 없음)
const miss = await lookupOpgg({ ...input, lookup: { ...input.lookup!, startedAt: Date.parse('2026-10-14T10:00:00+09:00') } }, caller);
assert.equal(miss.found, false);
assert.match(miss.note!, /OP\.GG 에 이 경기가 없습니다/);
// 조회가 실패하면 "경기 없음"이 아니라 "확인 못 함" (분석은 멈추지 않는다)
const down = await lookupOpgg(input, async () => {
throw new Error('OP.GG 503');
});
assert.equal(down.found, false);
assert.equal(down.error, true);
assert.match(down.note!, /OP\.GG 조회 실패로 이 경기를 확인하지 못했습니다 \(3번 중 3번 실패: OP\.GG 503\)/);
assert.equal(miss.error, undefined, '조회는 됐는데 없으면 error 아님');
const vMiss = await lookupOpgg({ ...input, game: 'valorant' }, async () => []);
assert.deepEqual([vMiss.found, vMiss.error, /이 경기가 없습니다/.test(vMiss.note!)], [false, undefined, true]);
// 일부만 실패하고 못 찾았으면 확인 못 함
let k = 0;
const vHalf = await lookupOpgg({ ...input, game: 'valorant' }, async () => {
if (k++ % 2) throw new Error('OP.GG 503');
return [];
});
assert.equal(vHalf.error, true);
});
test('OP.GG 클라이언트: 세션이 끝나면(404) 새로 initialize 하고 다시 부른다', async () => {
let serverSid = 's1';
let inits = 0;
const seen: { method: string; sid: string | null }[] = [];
const fetchFn = (async (_url: string, init: any) => {
const body = JSON.parse(init.body);
const sid = init.headers['mcp-session-id'] ?? null;
seen.push({ method: body.method, sid });
if (body.method === 'initialize') {
inits++;
if (sid) return new Response('bad', { status: 400 });
return new Response(JSON.stringify({ jsonrpc: '2.0', id: body.id, result: {} }), { status: 200, headers: { 'mcp-session-id': serverSid } });
}
if (sid !== serverSid) return new Response('session not found', { status: 404 });
if (body.params.name === 'boom') return new Response('unavailable', { status: 503 });
// SSE 로 줄 때도 읽는다
const msg = JSON.stringify({ jsonrpc: '2.0', id: body.id, result: { content: [{ type: 'text', text: JSON.stringify({ ok: body.params.name, sid }) }] } });
return new Response(`event: message\ndata: ${msg}\n\n`, { status: 200, headers: { 'content-type': 'text/event-stream' } });
}) as typeof fetch;
const call = opggCaller({ url: 'http://opgg.test/mcp', fetchFn });
assert.deepEqual(await call('a', {}), { ok: 'a', sid: 's1' });
// 서버가 재시작해 세션이 사라졌다
serverSid = 's2';
assert.deepEqual(await call('b', {}), { ok: 'b', sid: 's2' });
assert.deepEqual(await call('c', {}), { ok: 'c', sid: 's2' }, '새 세션을 계속 쓴다');
assert.equal(inits, 2);
assert.deepEqual(
seen.map((x) => `${x.method}:${x.sid ?? '-'}`),
['initialize:-', 'tools/call:s1', 'tools/call:s1', 'initialize:-', 'tools/call:s2', 'tools/call:s2'],
);
// 세션 문제가 아닌 실패(503)는 다시 initialize 하지 않고 그대로 실패
await assert.rejects(call('boom', {}), /OP\.GG 503/);
assert.equal(inits, 2);
});

View File

@@ -277,7 +277,7 @@ function PrepPanel({ info, budget, progress, onStart, onOpen }: { info: CulpritM
<section className="panel">
<h4>
<span>참가자 {info.players.length}명</span>
<span className="ph-right">음성 = 대화 기록 있음{info.players.some((p) => p.rating) ? ' · 숫자 = 기록 점수(OP.GG 방식)' : ''}</span>
<span className="ph-right">음성 = 대화 기록 있음{info.players.some((p) => p.rating) ? ' · 숫자 = 기록 점수(OP.GG 계산법)' : ''}</span>
</h4>
{info.players.map((p) => (
<div key={p.id} className="cu-pl">
@@ -288,7 +288,7 @@ function PrepPanel({ info, budget, progress, onStart, onOpen }: { info: CulpritM
{p.team === 'ally' ? '우리 팀' : '상대 팀'} · {p.character?.name ?? '?'}
</span>
{p.rating && (
<span className="cu-ref" title="기록 점수: OP.GG OP스코어 방식으로 이 경기 기록에서 계산 (0~10)">
<span className="cu-ref" title="기록 점수: OP.GG OP스코어 계산법을 따라 이 경기 기록으로 계산 (0~10)">
{p.rating.badge && <em className={p.rating.badge === 'MVP' ? 'mvp' : 'ace'}>{p.rating.badge}</em>}
{p.rating.score.toFixed(1)}
</span>
@@ -425,14 +425,6 @@ function ResultView({ info, budget, onBack, onReanalyze }: { info: CulpritMatchI
기본 기록으로 분석
</>
)}
{a.meta.opgg && (
<>
<br />
<span title={a.meta.opgg.note}>
{a.meta.opgg.found ? 'OP.GG 실제 점수 참고' : a.meta.opgg.error ? 'OP.GG 조회 실패 · 기록 점수로 분석' : 'OP.GG 에 없는 경기 · 기록 점수로 분석'}
</span>
</>
)}
{budget?.canReanalyze && (
<>
<br />
@@ -537,22 +529,17 @@ function ResultView({ info, budget, onBack, onReanalyze }: { info: CulpritMatchI
);
}
/** 전적 사이트 점수 줄: 기록 점수(OP.GG 방식) · OP.GG 실제 점수 · MVP/ACE, parts 면 강점 · 약점 · 롤 라인전(LOL.PS 방식) */
/** 기록 점수 줄: 기록 점수(OP.GG 계산법) · 팀 순위 · MVP/ACE, parts 면 강점 · 약점 · 롤 라인전(LOL.PS 라인전 점수의 입력) */
function RefLine({ p, parts = false }: { p: CulpritPlayer; parts?: boolean }) {
const r = p.rating;
if (!r && !p.opgg) return null;
if (!r) return null;
return (
<div className="cu-refline">
{r && (
<span title="OP.GG OP스코어 방식으로 이 경기 기록에서 계산한 점수">
<span title="OP.GG OP스코어 계산법을 따라 이 경기 기록으로 계산한 점수">
기록 점수 <b>{r.score.toFixed(1)}</b> · 팀 {r.teamRank}위
</span>
)}
{p.opgg && (
<span title="OP.GG 에서 찾은 이 경기의 실제 OP스코어">
OP.GG <b>{p.opgg.score.toFixed(1)}</b>
</span>
)}
{r?.badge && <em className={r.badge === 'MVP' ? 'mvp' : 'ace'}>{r.badge}</em>}
{parts &&
r?.parts.map((x) => (

View File

@@ -1,6 +1,7 @@
# 기록 점수 공식 맞추기 (OP.GG OP스코어)
범인찾기의 "기록 점수"(0~10)는 OP.GG OP스코어를 우리 앱 기록으로 다시 계산한 값이다. 이 폴더는 그 계수를 만든다.
범인찾기의 "기록 점수"(0~10)는 OP.GG OP스코어 계산법을 따라 우리 앱 기록으로 계산한 값이다. OP.GG 는 어떤 지표를 보는지만 밝히고 가중치는 공개하지 않아서, 이 폴더에서 개발할 때 한 번 실제 경기 점수에 맞춰 계수를 정한다.
앱 · 사이트 서버는 분석할 때 OP.GG 나 다른 전적 사이트에 접속하지 않는다 (계수는 `rating-model.ts` 에 고정).
1. `python3 collect.py val 40` · `python3 collect.py lol 80` — OP.GG 공식 MCP(`https://mcp-api.op.gg/mcp`, AI 도구용으로 OP.GG 가 연 API)에서 실제 경기의 스탯과 OP스코어를 받는다. 이름 · puuid 는 저장하지 않는다 (`data/*.jsonl`).
2. `python3 fit_val.py` · `python3 fit_lol.py save 10` — 릿지 회귀. 경기 단위 5겹 교차 검증 값을 함께 낸다.
@@ -22,10 +23,10 @@
| 사이트 | 원문 인용 (… = 생략) | 우리 구현 |
|---|---|---|
| OP.GG 롤 (`op.gg/ko/lol/summoners/…` 의 `op_score_desc` · `op_score_info_tooltip`) | "역할군과 라인전, 킬/데스/데미지/시야장악/오브젝트 파괴 등의 지표를 종합해 게임 내 활약 정도를 측정하는 평점 시스템입니다." "평점은 0~10점을 기준으로 경기에 기여한 정도에 따라 차등 부여됩니다. 탈주 등 패배에 결정적인 영향을 끼친 경우 0점에 가까운 점수가 부여됩니다." MVP = "해당 경기에서 가장 뛰어난 활약을 보여준 1명", ACE = "팀은 비록 패배했지만 승리팀 못지 않은 활약을 보여준 1명" | 0~10 기록 점수 (롤 모델), MVP = 이긴 팀 1등 · ACE = 진 팀 1등. 계수는 OP.GG MCP 의 실제 `op_score` 에 맞춤 |
| OP.GG 발로란트 (`op.gg/ko/valorant/profile/…` 의 `op_score_description`) | "라운드 승률, KAST, 평균 전투 점수(ACS), 피해량 격차(DDΔ) 등 발로란트의 핵심 지표를 기반으로 … 산출한 종합 실력 지표입니다." "전체 플레이어 풀을 기준으로, 같은 실력대 대비 얼마나 뛰어난 퍼포먼스를 보였는지 점수화" · `kast_tooltip` "라운드별 킬·어시·생존·트레이드 기여 비율" | 발로란트 모델 입력 = 라운드 승률 · KAST(5초 트레이드) · ACS · 라운드당 (준 피해 - 받은 피해). 계수는 MCP 의 실제 `opScore`(0~1000) 에 맞춤 |
| OP.GG 롤 (`op.gg/ko/lol/summoners/…` 의 `op_score_desc` · `op_score_info_tooltip`) | "역할군과 라인전, 킬/데스/데미지/시야장악/오브젝트 파괴 등의 지표를 종합해 게임 내 활약 정도를 측정하는 평점 시스템입니다." "평점은 0~10점을 기준으로 경기에 기여한 정도에 따라 차등 부여됩니다. 탈주 등 패배에 결정적인 영향을 끼친 경우 0점에 가까운 점수가 부여됩니다." MVP = "해당 경기에서 가장 뛰어난 활약을 보여준 1명", ACE = "팀은 비록 패배했지만 승리팀 못지 않은 활약을 보여준 1명" | 0~10 기록 점수 (롤 모델), MVP = 이긴 팀 1등 · ACE = 진 팀 1등. 계수는 개발 때 모은 실제 `op_score` 에 맞춤 |
| OP.GG 발로란트 (`op.gg/ko/valorant/profile/…` 의 `op_score_description`) | "라운드 승률, KAST, 평균 전투 점수(ACS), 피해량 격차(DDΔ) 등 발로란트의 핵심 지표를 기반으로 … 산출한 종합 실력 지표입니다." "전체 플레이어 풀을 기준으로, 같은 실력대 대비 얼마나 뛰어난 퍼포먼스를 보였는지 점수화" · `kast_tooltip` "라운드별 킬·어시·생존·트레이드 기여 비율" | 발로란트 모델 입력 = 라운드 승률 · KAST(5초 트레이드) · ACS · 라운드당 (준 피해 - 받은 피해). 계수는 개발 때 모은 실제 `opScore`(0~1000) 에 맞춤 |
| LOL.PS (`lol.ps` 번역 문자열 `summoner_lane_score_desc`) | "맞라이너 대비 소환사가 라인전을 몇 대 몇 정도로 수행하는지에 대한 점수입니다. 라인전 점수는 해당 소환사 챔피언의 10, 15분 맞라이너 골드차, 경험치차, cs차이 등을 바탕으로 최종 승리에 어느정도 기여하였는가를 AI기반으로 추론하여 계산합니다." | 같은 입력인 **10 · 15분 맞라이너 골드 · 경험치 · CS 차**를 앱 기록(LCU 타임라인 10 · 15분 프레임)에서 계산해 참가자마다 보여 주고 AI 자료에 넣는다 (`rating.ts` `lane`). LOL.PS 의 AI 추론 모델은 공개되지 않아 점수로 바꾸지 않는다 |
| LOL.PS PS 스코어 (번역 문자열) | "PS스코어는 라인전 점수, 캐리력 점수, 재화 활용도를 기반으로 산출 … 재화 활용도는 골드 당 kda, 골드 당 딜량, 한타 당 딜량 등으로 계산됩니다." 라인전 지표 탭: 레벨 격차 · 최대 CS 격차 · 시간대별 격차("게임 시간별로 발생한 맞라이너와의 CS, 골드, 경험치 격차") | 참고만 했다. PS 스코어는 공개 API · 실제 값이 없어 맞출 수 없고, 골드 비중 · 딜 비중 · KDA 는 OP.GG 모델 입력에 이미 들어 있다 |
- OP.GG MCP 는 OP.GG 가 AI 도구용으로 공개한 서버다 (`https://mcp-api.op.gg/mcp`, 키 없음, 도구 목록: `tools/list`). 롤 `lol_get_summoner_game_detail` 은 10명의 `op_score` · `op_score_rank`, 발로란트 `valorant_list_player_matches` 는 본인 `opScore` 를 준다.
- LOL.PS 는 공개 API 가 없어 실제 점수를 받아 오지 않는다.
- OP.GG MCP 는 OP.GG 가 AI 도구용으로 공개한 서버다 (`https://mcp-api.op.gg/mcp`, 키 없음). 계수 맞추기(`collect.py`)에만 썼다. 롤 `lol_get_summoner_game_detail` 은 10명의 `op_score`, 발로란트 `valorant_list_player_matches` 는 본인 `opScore` 를 준다.
- LOL.PS 는 원문의 지표 정의만 따른다.