Clearing the chat mid-answer emptied the panel and then the truncated answer reappeared, a turn the model's history never recorded.
1629 lines
63 KiB
TypeScript
1629 lines
63 KiB
TypeScript
// src/main/services/MeetingModeService.ts
|
|
// Phase 14 / 14.5: Meeting Mode — 실시간 녹음 + 타임스탬프 메모 + 문서 생성/내보내기
|
|
// 싱글톤 + EventEmitter 패턴. CaptionService 연동.
|
|
|
|
import { EventEmitter } from 'events'
|
|
import { BrowserWindow, Notification, app, dialog } from 'electron'
|
|
import fs from 'fs'
|
|
import { dirname as pathDirname, join as pathJoin } from 'path'
|
|
import { eq, desc, sql, inArray } from 'drizzle-orm'
|
|
import { getLogger } from './LoggerService'
|
|
import { configGet } from './ConfigService'
|
|
import { getCloudSyncService } from './CloudSyncService'
|
|
import { getMainWindow } from '../windows/WindowManager'
|
|
import { getDatabase } from '../db'
|
|
import { onAccountScopeChanged } from './account-scope'
|
|
import { getLlmGateway } from './llm/LlmGateway'
|
|
import { MeetingRecordingSession, type RecordingSnapshot } from './meeting/MeetingRecordingSession'
|
|
import {
|
|
isRecoverableMeeting,
|
|
syncStateRecordingLedger,
|
|
type LocalRecordingLedger,
|
|
} from './meeting/local-recording-ledger'
|
|
import {
|
|
createTranscriptStore,
|
|
transcriptBase,
|
|
type MeetingTranscriptStore,
|
|
type TranscriptRevision,
|
|
} from './meeting/transcript-revision-store'
|
|
import {
|
|
buildDiarizationChunkInput,
|
|
diarizationContinuityHint,
|
|
extractSpeakerLabels,
|
|
lastLines,
|
|
stripEchoedContext,
|
|
} from './meeting/diarization-context'
|
|
import { condenseTranscriptToBudget } from './meeting/transcript-condenser'
|
|
import { selectTranscriptExcerpts } from '@d3ro/core/meeting-llm-input'
|
|
import { LLM_PROXY_CHAT_LIMITS } from '@d3ro/core/llm-chat'
|
|
import type { MeetingChatHistoryTurn, MeetingLiveSession } from '@d3ro/core/meeting-live'
|
|
import { meetingSessions, meetingMemos, meetingDocuments } from '../db/schema'
|
|
import { IPC_CHANNELS } from '@d3ro/core/ipc-channels'
|
|
import { D3ROError, ErrorCode } from '@d3ro/core/errors'
|
|
import {
|
|
buildExportMarkdown,
|
|
renderMeetingPdfHtml,
|
|
formatTime,
|
|
formatDateFile,
|
|
formatDateRange,
|
|
} from '@d3ro/core/utils/meeting-markdown'
|
|
import {
|
|
applySpeakerLabels,
|
|
buildTranscriptFromSegments,
|
|
chunkTranscriptByLines,
|
|
formatTranscriptLines,
|
|
looksTruncatedRewrite,
|
|
parseTranscriptLines,
|
|
} from '@d3ro/core/meeting-transcript'
|
|
import { markdownToDocx } from '@d3ro/core/utils/markdown-to-docx'
|
|
import type {
|
|
MeetingModeState,
|
|
MeetingMemo,
|
|
MeetingSessionSummary,
|
|
MeetingSessionDetail,
|
|
MeetingMinutes,
|
|
MeetingSessionPage,
|
|
MeetingStartResult,
|
|
MeetingModeStateInfo,
|
|
MeetingProcessingStep,
|
|
MeetingProcessingProgress,
|
|
MeetingDocument,
|
|
MeetingGenerateDocParams,
|
|
MeetingExportFormat,
|
|
MeetingDocGeneratingProgress,
|
|
} from '@d3ro/core/types'
|
|
|
|
const logger = getLogger('MeetingModeService')
|
|
|
|
/** 회의 전사를 LLM 으로 다시 쓸 때 한 번에 보낼 최대 글자 수 (출력 토큰 한도 안에 들도록) */
|
|
const REWRITE_CHUNK_CHARS = 1500
|
|
/** 조각 하나의 출력 토큰 상한 — 로컬(Ollama)·Premium 모두 4096 이하만 허용한다 */
|
|
const REWRITE_CHUNK_MAX_TOKENS = 2048
|
|
/** 화자 추정에서 다음 조각에 넘기는 앞 조각의 라벨된 마지막 줄 수 */
|
|
const DIARIZATION_CONTEXT_LINES = 4
|
|
/** 회의 채팅 히스토리를 세션마다 이 개수(메시지)까지만 유지한다 */
|
|
const MAX_CHAT_HISTORY_MESSAGES = 20
|
|
/** 녹음 중 전사를 DB 에 남기는 주기 — 비정상 종료 시 잃는 양의 상한 */
|
|
const TRANSCRIPT_CHECKPOINT_MS = 15_000
|
|
/** 중단된 녹음(전사 없음)의 오류 메시지 — 저장용(UI 는 status 로 표시) */
|
|
const INTERRUPTED_MESSAGE = 'Recording was interrupted before it was saved'
|
|
/** 녹음 동안 인식이 계속 실패해 전사가 하나도 없다 */
|
|
const TRANSCRIPTION_FAILED_MESSAGE = 'Transcription failed during recording'
|
|
/** 자막 인식 실패를 렌더러에 다시 알리는 최소 간격 */
|
|
const CAPTION_FAILURE_NOTICE_INTERVAL_MS = 30_000
|
|
|
|
/**
|
|
* 회의 기능이 쓰는 LLM 포트 — 백엔드 선택(local/online, 폴백)은 LlmGateway 한 곳이 정한다.
|
|
* 문서 생성·요약 입력은 이 한도(프록시 메시지 한도) 안으로 맞춘다.
|
|
*/
|
|
type MeetingLlm = {
|
|
generate: (
|
|
text: string,
|
|
options?: { systemPrompt?: string; temperature?: number; maxTokens?: number },
|
|
) => Promise<{ text: string; model?: string }>
|
|
}
|
|
|
|
/** 문서 생성 사용자 메시지의 머리말(LLM 지시문) */
|
|
const DOCUMENT_REQUEST_PREFIX = '다음 회의 전사록과 참석자 메모를 분석하여 문서를 작성해주세요:\n\n## 전사록\n'
|
|
const CONDENSED_NOTE = '(회의가 길어 구간별로 정리한 내용입니다)\n'
|
|
/** 채팅 system 프롬프트 머리말 여유 — 지시문·발췌 안내가 들어갈 자리 */
|
|
const CHAT_SYSTEM_OVERHEAD_CHARS = 600
|
|
|
|
/** 회의 녹음 WAV 경로 (화자 구분·동기화·삭제가 같은 규칙을 쓴다) */
|
|
function meetingAudioFilePathSync(sessionId: string): string {
|
|
return pathJoin(app.getPath('userData'), 'meeting-audio', `${sessionId}.wav`)
|
|
}
|
|
|
|
async function meetingAudioFilePath(sessionId: string): Promise<string> {
|
|
return meetingAudioFilePathSync(sessionId)
|
|
}
|
|
|
|
let isShowingMeetingSaveDialog = false
|
|
|
|
class MeetingModeService extends EventEmitter {
|
|
private _state: MeetingModeState = 'idle'
|
|
/**
|
|
* 진행 중인 녹음. 녹음 한 건의 세그먼트·메모·오디오·구독은 이 객체가 단독으로 소유한다.
|
|
* 후처리가 끝날 때까지 남아 있어 getStateInfo 가 세션 id 를 계속 보고한다(실시간 편집 반영용).
|
|
*/
|
|
private _current: MeetingRecordingSession | null = null
|
|
/** 진행 중인 정지 — 동시에 온 정지 요청(두 번 클릭, 로그아웃)은 이 promise 를 함께 기다린다 */
|
|
private _stopInFlight: Promise<void> | null = null
|
|
private _audioLevelTimer: ReturnType<typeof setInterval> | null = null
|
|
private _checkpointTimer: ReturnType<typeof setInterval> | null = null
|
|
private _checkpointedSegments = 0
|
|
/** CaptionService session-saved 방지 플래그 */
|
|
private _meetingModeActive = false
|
|
|
|
// Phase 15: Meeting AI Chat — 세션마다 따로 보관한다(회의 A 의 질의응답이 B 로 새지 않게)
|
|
private _chatHistories = new Map<string, Array<{ role: 'user' | 'assistant'; content: string }>>()
|
|
/** 회의마다 진행 중인 채팅 — 한 회의의 취소가 다른 회의 채팅을 끊지 않게 */
|
|
private _chatAbortControllers = new Map<string, AbortController>()
|
|
private readonly _unsubscribeScope: () => void
|
|
/** 회의별 자막 인식 실패 수 — 전사가 비었을 때 'completed' 대신 'error' 로 닫는 근거 */
|
|
private readonly _captionFailures = new Map<string, number>()
|
|
/** 정지 후처리가 최종 저장을 마친 회의 — 종료(shutdown) 때 다시 쓰지 않는다. */
|
|
private _finalizedSessionId: string | null = null
|
|
private _unsubscribeCaptionFailure: (() => void) | null = null
|
|
private _lastCaptionFailureNoticeAt = 0
|
|
|
|
constructor(
|
|
private readonly _recordingLedger: LocalRecordingLedger = syncStateRecordingLedger,
|
|
/** 전사 수정본 쓰기의 단일 관문 — 기준본 확인(compare-and-set)과 동기화 예약을 맡는다 */
|
|
private readonly _transcripts: MeetingTranscriptStore = createSqliteMeetingTranscriptStore(),
|
|
) {
|
|
super()
|
|
// 이 서비스가 내는 'error' 는 알림용이다 — 듣는 쪽이 없어도 throw 되지 않게 기본 수신자를 둔다
|
|
// (EventEmitter 는 리스너 없는 'error' 를 던져 후처리 catch 를 깨뜨렸다).
|
|
this.on('error', () => { /* default sink */ })
|
|
// 계정 DB 가 바뀔 때마다(로그인·로그아웃) 그 DB 에 남은 중단된 녹음을 정리한다.
|
|
this._unsubscribeScope = onAccountScopeChanged(() => {
|
|
try {
|
|
this.recoverInterruptedSessions()
|
|
} catch (err) {
|
|
logger.warn(`중단된 회의 정리 실패: ${err instanceof Error ? err.message : String(err)}`)
|
|
}
|
|
})
|
|
}
|
|
|
|
/** 테스트 전용: 타이머·구독을 푼다 */
|
|
disposeForTests(): void {
|
|
this._stopTimers()
|
|
this._unsubscribeScope()
|
|
this.cancelMeetingChat()
|
|
this.removeAllListeners()
|
|
}
|
|
|
|
// ── 공개 접근자 ──
|
|
|
|
getState(): MeetingModeState {
|
|
return this._state
|
|
}
|
|
|
|
getStateInfo(): MeetingModeStateInfo {
|
|
const session = this._current
|
|
return {
|
|
state: this._state,
|
|
sessionId: session?.id ?? null,
|
|
elapsedMs: session ? session.elapsedMs() : 0,
|
|
memoCount: session?.memos.length ?? 0,
|
|
segmentCount: session?.segments.length ?? 0,
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 진행 중인 녹음의 세그먼트·메모 사본. 녹음 화면을 다시 열었을 때(페이지 이동 후 복귀) 그동안의
|
|
* 실시간 전사와 메모를 복원한다. 녹음 중이 아니면 null.
|
|
*/
|
|
getLiveSession(): MeetingLiveSession | null {
|
|
const session = this._current
|
|
if (!session) return null
|
|
return {
|
|
sessionId: session.id,
|
|
state: this._state,
|
|
startedAt: session.startedAt,
|
|
elapsedMs: session.elapsedMs(),
|
|
segments: session.segments.map((segment) => ({ ...segment })),
|
|
memos: session.memos.map((memo) => ({ ...memo })),
|
|
}
|
|
}
|
|
|
|
isMeetingModeActive(): boolean {
|
|
return this._meetingModeActive
|
|
}
|
|
|
|
/** 활성 세션, 자막, 오디오 캡처 상태를 강제로 완전 초기화 */
|
|
async forceReset(): Promise<void> {
|
|
logger.warn('MeetingModeService: forceReset 실행')
|
|
this._stopTimers()
|
|
const session = this._current
|
|
if (session) {
|
|
session.detach()
|
|
// 아직 녹음 중이던 세션은 지금까지의 전사를 남기고 닫는다(행이 'recording' 으로 굳지 않게).
|
|
if (!session.isStopping) {
|
|
try {
|
|
this._persistSnapshot(session.checkpoint({ includeAudio: true }), { interrupted: true })
|
|
} catch (err) {
|
|
logger.warn(`forceReset 전사 저장 실패: ${err instanceof Error ? err.message : String(err)}`)
|
|
}
|
|
}
|
|
}
|
|
try {
|
|
const { getCaptionService } = await import('./CaptionService')
|
|
// 강제 정지(소유자 무시)
|
|
await getCaptionService().stop().catch(() => null)
|
|
} catch { /* noop */ }
|
|
|
|
try {
|
|
const { getAudioCaptureService } = await import('./AudioCaptureService')
|
|
await getAudioCaptureService().stop().catch(() => {})
|
|
} catch { /* noop */ }
|
|
|
|
this._stopInFlight = null
|
|
this._resetSession()
|
|
this._setState('idle')
|
|
this._sendStateToRenderer()
|
|
}
|
|
|
|
// ── 녹음 시작 ──
|
|
|
|
async startRecording(options?: { force?: boolean }): Promise<MeetingStartResult> {
|
|
if (options?.force) {
|
|
await this.forceReset()
|
|
}
|
|
|
|
if (this._state !== 'idle') {
|
|
throw new D3ROError(
|
|
ErrorCode.MeetingAlreadyRecording,
|
|
`회의 모드가 이미 실행 중입니다 (${this._state}). 이전 회의를 종료하거나 강제 초기화 후 다시 시도해주세요.`,
|
|
)
|
|
}
|
|
|
|
// CaptionService 상태 확인
|
|
const { getCaptionService } = await import('./CaptionService')
|
|
const captionService = getCaptionService()
|
|
const captionState = captionService.getState()
|
|
if (captionState !== 'inactive') {
|
|
if (options?.force) {
|
|
await captionService.stop().catch(() => {})
|
|
} else {
|
|
throw new D3ROError(
|
|
ErrorCode.MeetingAlreadyRecording,
|
|
'실시간 자막 모드가 아직 실행 중입니다. 자막을 먼저 종료하거나 강제 초기화 후 시작해주세요.',
|
|
)
|
|
}
|
|
}
|
|
|
|
this._setState('recording')
|
|
this._meetingModeActive = true
|
|
|
|
const sessionId = crypto.randomUUID()
|
|
const now = Date.now()
|
|
|
|
// DB에 세션 생성
|
|
const db = getDatabase()
|
|
db.insert(meetingSessions).values({
|
|
id: sessionId,
|
|
status: 'recording',
|
|
startedAt: now,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
}).run()
|
|
// 이 기기에서 시작한 녹음 — 앱이 끊기면 다음 시작 때 이것만 복구한다(다른 기기 회의는 건드리지 않음).
|
|
this._markLocalRecording(sessionId)
|
|
|
|
const { getAudioCaptureService, calculateRMS } = await import('./AudioCaptureService')
|
|
const audioCaptureService = getAudioCaptureService()
|
|
const session = new MeetingRecordingSession(
|
|
sessionId,
|
|
now,
|
|
{
|
|
caption: {
|
|
onSegment: (listener) => {
|
|
captionService.on('segment', listener)
|
|
return () => { captionService.off('segment', listener) }
|
|
},
|
|
// 회의가 소유한 세션만 멈춘다. 다른 소유자면 false(요약 없음).
|
|
stop: () => captionService.stop('meeting'),
|
|
},
|
|
audio: {
|
|
onChunk: (listener) => {
|
|
const handler = (payload: { buffer: Buffer; timestamp: number }): void => listener(payload.buffer)
|
|
audioCaptureService.on('audio-data', handler)
|
|
return () => { audioCaptureService.off('audio-data', handler) }
|
|
},
|
|
},
|
|
onSegment: (segment) => {
|
|
this.emit('segment', segment)
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.SEGMENT, segment)
|
|
},
|
|
onStopError: (err) => {
|
|
logger.error(`자막 정지 실패 — 지금까지의 전사로 저장한다: ${err instanceof Error ? err.message : String(err)}`)
|
|
},
|
|
},
|
|
calculateRMS,
|
|
)
|
|
this._current = session
|
|
this._checkpointedSegments = 0
|
|
// 세그먼트 구독은 자막 시작 전에 건다 — 첫 문장을 놓치지 않게.
|
|
session.attachCaption()
|
|
|
|
try {
|
|
// 회의 모드가 소유한 자막 세션: 마이크 고정(전역 설정은 건드리지 않음), 오버레이 없음
|
|
// (회의 UI 가 자체 패널에 표시), 'caption' 히스토리 중복 저장 없음, 핫키로 끌 수 없음.
|
|
await captionService.start({
|
|
owner: 'meeting',
|
|
audioSource: 'mic',
|
|
showOverlay: false,
|
|
persistHistory: false,
|
|
})
|
|
} catch (err) {
|
|
// 시작 실패 시 복원
|
|
session.detach()
|
|
if (this._current === session) this._current = null
|
|
this._meetingModeActive = false
|
|
this._clearLocalRecording(sessionId)
|
|
|
|
db.update(meetingSessions).set({
|
|
status: 'error',
|
|
errorMessage: err instanceof Error ? err.message : String(err),
|
|
updatedAt: Date.now(),
|
|
}).where(eq(meetingSessions.id, sessionId)).run()
|
|
getCloudSyncService().pushOne('meetings', sessionId)
|
|
|
|
this._setState('idle')
|
|
throw err
|
|
}
|
|
|
|
// 인식이 계속 실패하면(사이드카 다운·모델 로드 실패) 회의가 조용히 빈 전사로 끝나지 않게 알린다.
|
|
this._watchCaptionFailures(captionService, sessionId)
|
|
|
|
// 오디오 레벨 모니터링 + WAV 저장용 버퍼 (Phase 15.5-2)
|
|
session.attachAudio()
|
|
this._audioLevelTimer = setInterval(() => {
|
|
this._sendToRenderer('meetingMode:audioLevel', { level: session.lastRms })
|
|
}, 100)
|
|
// 전사를 주기적으로 DB 에 남긴다 — 앱이 비정상 종료돼도 회의 전체가 사라지지 않게.
|
|
this._checkpointTimer = setInterval(() => this._checkpointTranscript(), TRANSCRIPT_CHECKPOINT_MS)
|
|
|
|
logger.info(`회의 녹음 시작: sessionId=${sessionId}`)
|
|
this._sendStateToRenderer()
|
|
|
|
// Phase 3.3: 부모 meeting row를 즉시 push (빈 상태로).
|
|
// 자식 meeting_memos/meeting_documents의 RLS/FK가 부모 존재를 요구하므로,
|
|
// 녹음 중에 들어오는 addMemo/generateDocument 푸시가 통과하려면 필수.
|
|
getCloudSyncService().pushOne('meetings', sessionId)
|
|
|
|
return { sessionId }
|
|
}
|
|
|
|
// ── 메모 추가 ──
|
|
|
|
async addMemo(content: string): Promise<MeetingMemo> {
|
|
const session = this._current
|
|
if (this._state !== 'recording' || !session) {
|
|
throw new D3ROError(ErrorCode.MeetingNotRecording, '녹음 중이 아닙니다')
|
|
}
|
|
const memo = session.addMemo(crypto.randomUUID(), content)
|
|
if (!memo) {
|
|
throw new D3ROError(ErrorCode.MeetingNotRecording, '녹음 중이 아닙니다')
|
|
}
|
|
|
|
// DB 저장
|
|
const db = getDatabase()
|
|
db.insert(meetingMemos).values({
|
|
id: memo.id,
|
|
sessionId: memo.sessionId,
|
|
content: memo.content,
|
|
timestampMs: memo.timestampMs,
|
|
createdAt: memo.createdAt,
|
|
}).run()
|
|
|
|
this.emit('memo-added', memo)
|
|
logger.debug(`메모 추가: [${formatTime(memo.timestampMs)}] ${content}`)
|
|
|
|
// Phase 3.3: 자동 push (fire-and-forget)
|
|
getCloudSyncService().pushOne('meeting_memos', memo.id)
|
|
|
|
return memo
|
|
}
|
|
|
|
// ── 녹음 종료 ──
|
|
|
|
/**
|
|
* 녹음을 멈추고 전사를 저장한다. 정지가 진행 중이면 그 정지를 함께 기다린다 — 정지를 두 번 눌러도
|
|
* (또는 로그아웃이 동시에 멈춰도) 정지·저장·완료 알림은 한 번만 일어난다.
|
|
*/
|
|
async stopRecording(): Promise<void> {
|
|
if (this._stopInFlight) return this._stopInFlight
|
|
const session = this._current
|
|
if (this._state !== 'recording' || !session) {
|
|
throw new D3ROError(ErrorCode.MeetingNotRecording, '녹음 중이 아닙니다')
|
|
}
|
|
const run = this._stopSession(session)
|
|
this._stopInFlight = run
|
|
try {
|
|
await run
|
|
} finally {
|
|
if (this._stopInFlight === run) this._stopInFlight = null
|
|
}
|
|
}
|
|
|
|
private async _stopSession(session: MeetingRecordingSession): Promise<void> {
|
|
this._stopTimers()
|
|
// 정지(마지막 문장 flush)가 끝날 때까지 '처리 중'으로 보인다 — 정지 버튼이 사라져 다시 누를 수 없다.
|
|
this._setState('processing')
|
|
this._sendStateToRenderer()
|
|
|
|
const snapshot = await session.stop()
|
|
|
|
// 세션 종료 시간 기록 — 불변 스냅샷에서 읽는다(인스턴스 필드는 다른 호출이 바꿀 수 있다)
|
|
const db = getDatabase()
|
|
db.update(meetingSessions).set({
|
|
endedAt: snapshot.endedAt,
|
|
durationMs: snapshot.durationMs,
|
|
updatedAt: Date.now(),
|
|
}).where(eq(meetingSessions.id, snapshot.id)).run()
|
|
getCloudSyncService().pushOne('meetings', snapshot.id)
|
|
|
|
logger.info(`회의 녹음 종료: sessionId=${snapshot.id}, segments=${snapshot.segments.length}`)
|
|
|
|
await this._runPostProcessing(snapshot)
|
|
}
|
|
|
|
/**
|
|
* 앱 종료(ShutdownRegistry)용. 녹음 중이면 지금까지의 전사·녹음을 곧바로 저장하고(자막 flush 를
|
|
* 기다리지 않는다 — 종료 예산 안에 끝나야 한다), 자막·마이크를 멈춘다. 알림·렌더러 전송은 하지 않는다.
|
|
*/
|
|
async shutdown(): Promise<void> {
|
|
this._stopTimers()
|
|
const session = this._current
|
|
if (!session) return
|
|
// 정지 중(마지막 문장 flush 대기)이어도 아직 최종 저장 전이면 지금까지를 저장한다 — 건너뛰면
|
|
// 메모리에만 있던 녹음과 마지막 주기 저장 이후 전사가 사라졌다.
|
|
if (this._finalizedSessionId !== session.id) {
|
|
try {
|
|
this._persistSnapshot(session.checkpoint({ includeAudio: true }), { interrupted: false })
|
|
logger.info(`종료 중 회의 저장: sessionId=${session.id}`)
|
|
} catch (err) {
|
|
logger.error(`종료 중 회의 저장 실패: ${err instanceof Error ? err.message : String(err)}`)
|
|
}
|
|
}
|
|
session.detach()
|
|
try {
|
|
const { getCaptionService } = await import('./CaptionService')
|
|
await getCaptionService().stop().catch(() => null)
|
|
} catch { /* noop */ }
|
|
this._resetSession()
|
|
this._state = 'idle'
|
|
}
|
|
|
|
/**
|
|
* 이 DB 에 'recording'/'processing' 으로 남은 회의(앱 강제 종료·정전 등)를 닫는다.
|
|
* 저장된 전사가 있으면 'completed', 없으면 'error'. 진행 중인 녹음은 건드리지 않는다.
|
|
* 이 기기에서 시작한 녹음만 닫는다 — 동기화로 들어온 폰의 진행 중인 회의는 폰이 끝낸다.
|
|
* @returns 정리한 회의 수
|
|
*/
|
|
recoverInterruptedSessions(): number {
|
|
let db: ReturnType<typeof getDatabase>
|
|
try {
|
|
db = getDatabase()
|
|
} catch {
|
|
return 0
|
|
}
|
|
const liveId = this._current?.id ?? null
|
|
const rows = db.select().from(meetingSessions).where(inArray(meetingSessions.status, ['recording', 'processing'])).all()
|
|
let recovered = 0
|
|
for (const row of rows) {
|
|
if (row.id === liveId) continue
|
|
if (!isRecoverableMeeting(row, this._recordingLedger)) continue
|
|
const now = Date.now()
|
|
const endedAt = row.endedAt ?? row.updatedAt ?? now
|
|
const hasTranscript = !!row.rawTranscript && row.rawTranscript.trim().length > 0
|
|
db.update(meetingSessions).set({
|
|
status: hasTranscript ? 'completed' : 'error',
|
|
endedAt,
|
|
durationMs: row.durationMs ?? Math.max(0, endedAt - row.startedAt),
|
|
errorMessage: hasTranscript ? row.errorMessage : (row.errorMessage ?? INTERRUPTED_MESSAGE),
|
|
updatedAt: now,
|
|
}).where(eq(meetingSessions.id, row.id)).run()
|
|
getCloudSyncService().pushOne('meetings', row.id)
|
|
this._clearLocalRecording(row.id)
|
|
recovered++
|
|
}
|
|
if (recovered > 0) logger.warn(`중단된 회의 ${recovered}건을 정리했다`)
|
|
return recovered
|
|
}
|
|
|
|
// ── 후처리 파이프라인 ──
|
|
|
|
/** 불변 스냅샷만 읽는다 — 서비스 필드(다른 호출이 초기화할 수 있다)에 기대지 않는다. */
|
|
private async _runPostProcessing(snapshot: RecordingSnapshot): Promise<void> {
|
|
this._setState('processing')
|
|
this._sendStateToRenderer()
|
|
const sessionId = snapshot.id
|
|
const db = getDatabase()
|
|
|
|
try {
|
|
db.update(meetingSessions).set({
|
|
status: 'processing',
|
|
updatedAt: Date.now(),
|
|
}).where(eq(meetingSessions.id, sessionId)).run()
|
|
getCloudSyncService().pushOne('meetings', sessionId)
|
|
|
|
// Step 1: 전사 텍스트 합산
|
|
this._sendProgress(sessionId, 'merging', 40)
|
|
|
|
// Step 2: DB 저장 (rawTranscript + completed) + Step 2.5: 오디오 WAV 파일 저장 (화자 구분용)
|
|
this._sendProgress(sessionId, 'saving', 80)
|
|
this._persistSnapshot(snapshot, { interrupted: false })
|
|
this._finalizedSessionId = sessionId
|
|
|
|
// Step 3: 알림
|
|
this._sendProgress(sessionId, 'notifying', 95)
|
|
// 알림 실패는 저장된 회의를 실패로 만들지 않는다
|
|
try {
|
|
new Notification({
|
|
title: '녹음 완료',
|
|
body: '전사가 완료되었습니다. 문서 생성 탭에서 회의록을 만들어보세요.',
|
|
}).show()
|
|
} catch (err) {
|
|
logger.warn(`완료 알림 실패: ${err instanceof Error ? err.message : String(err)}`)
|
|
}
|
|
|
|
// 완료 이벤트
|
|
this._sendProgress(sessionId, 'notifying', 100)
|
|
const detail = this._loadSessionDetail(sessionId)
|
|
if (detail) {
|
|
this.emit('session-completed', detail)
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.SESSION_COMPLETED, detail)
|
|
}
|
|
|
|
this._finishSession(snapshot.id)
|
|
logger.info(`회의 전사 저장 완료: sessionId=${sessionId}`)
|
|
} catch (err) {
|
|
try {
|
|
db.update(meetingSessions).set({
|
|
status: 'error',
|
|
errorMessage: err instanceof Error ? err.message : String(err),
|
|
updatedAt: Date.now(),
|
|
}).where(eq(meetingSessions.id, sessionId)).run()
|
|
getCloudSyncService().pushOne('meetings', sessionId)
|
|
} catch (dbErr) {
|
|
logger.error(`후처리 오류 기록 실패: ${dbErr instanceof Error ? dbErr.message : String(dbErr)}`)
|
|
}
|
|
|
|
this._finishSession(snapshot.id)
|
|
|
|
const d3roErr = new D3ROError(
|
|
ErrorCode.MeetingProcessingFailed,
|
|
`후처리 실패: ${err instanceof Error ? err.message : String(err)}`,
|
|
)
|
|
this.emit('error', d3roErr)
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.ERROR, {
|
|
code: d3roErr.code,
|
|
message: d3roErr.message,
|
|
})
|
|
logger.error(`후처리 실패: ${d3roErr.message}`)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 스냅샷(전사·종료 시각·녹음)을 DB·파일에 쓴다. 동기 — 앱 종료 예산 안에서도 끝난다.
|
|
* interrupted 면 전사가 없을 때 'error' 로 닫는다.
|
|
*/
|
|
private _persistSnapshot(snapshot: RecordingSnapshot, options: { interrupted: boolean }): void {
|
|
const db = getDatabase()
|
|
const rawTranscript = buildTranscriptFromSegments([...snapshot.segments], snapshot.startedAt)
|
|
const hasTranscript = rawTranscript.trim().length > 0
|
|
// 전사가 비었는데 녹음 동안 인식이 실패했다면 '완료'가 아니다 — 사용자가 끝난 뒤에야 빈 회의를 발견했다.
|
|
const transcriptionFailed = !hasTranscript && (this._captionFailures.get(snapshot.id) ?? 0) > 0
|
|
const status = !hasTranscript && (options.interrupted || transcriptionFailed) ? 'error' : 'completed'
|
|
const errorMessage = options.interrupted ? INTERRUPTED_MESSAGE : TRANSCRIPTION_FAILED_MESSAGE
|
|
db.update(meetingSessions).set({
|
|
status,
|
|
rawTranscript,
|
|
endedAt: snapshot.endedAt,
|
|
durationMs: snapshot.durationMs,
|
|
sttModel: configGet('sttModelId') as string | undefined,
|
|
...(status === 'error' ? { errorMessage } : {}),
|
|
updatedAt: Date.now(),
|
|
}).where(eq(meetingSessions.id, snapshot.id)).run()
|
|
getCloudSyncService().pushOne('meetings', snapshot.id)
|
|
this._captionFailures.delete(snapshot.id)
|
|
this._clearLocalRecording(snapshot.id)
|
|
|
|
if (snapshot.pcm.length > 0) {
|
|
try {
|
|
const wavPath = meetingAudioFilePathSync(snapshot.id)
|
|
fs.mkdirSync(pathDirname(wavPath), { recursive: true })
|
|
this._saveWav(wavPath, snapshot.pcm)
|
|
getCloudSyncService().pushOne('meeting_audio', snapshot.id)
|
|
logger.info(`회의 오디오 저장: ${wavPath}`)
|
|
} catch (err) {
|
|
logger.warn(`오디오 저장 실패: ${err instanceof Error ? err.message : String(err)}`)
|
|
}
|
|
}
|
|
}
|
|
|
|
/** 녹음 중 주기 저장 — 새 세그먼트가 있을 때만 rawTranscript 를 갱신한다(푸시는 정지 때). */
|
|
private _checkpointTranscript(): void {
|
|
const session = this._current
|
|
if (!session || session.isStopping || this._state !== 'recording') return
|
|
if (session.segments.length === this._checkpointedSegments) return
|
|
try {
|
|
const snapshot = session.checkpoint({ includeAudio: false })
|
|
const rawTranscript = buildTranscriptFromSegments([...snapshot.segments], snapshot.startedAt)
|
|
getDatabase().update(meetingSessions).set({
|
|
rawTranscript,
|
|
updatedAt: Date.now(),
|
|
}).where(eq(meetingSessions.id, snapshot.id)).run()
|
|
this._checkpointedSegments = snapshot.segments.length
|
|
} catch (err) {
|
|
logger.warn(`전사 중간 저장 실패: ${err instanceof Error ? err.message : String(err)}`)
|
|
}
|
|
}
|
|
|
|
private _watchCaptionFailures(
|
|
captionService: { on(event: 'failure', listener: (error: D3ROError) => void): unknown; off(event: 'failure', listener: (error: D3ROError) => void): unknown },
|
|
sessionId: string,
|
|
): void {
|
|
this._unsubscribeCaptionFailure?.()
|
|
this._captionFailures.set(sessionId, 0)
|
|
this._lastCaptionFailureNoticeAt = 0
|
|
const listener = (error: D3ROError): void => {
|
|
if (this._current?.id !== sessionId) return
|
|
this._captionFailures.set(sessionId, (this._captionFailures.get(sessionId) ?? 0) + 1)
|
|
const now = Date.now()
|
|
if (now - this._lastCaptionFailureNoticeAt < CAPTION_FAILURE_NOTICE_INTERVAL_MS) return
|
|
this._lastCaptionFailureNoticeAt = now
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.ERROR, {
|
|
code: error.code ?? ErrorCode.MeetingProcessingFailed,
|
|
message: error.message,
|
|
})
|
|
}
|
|
captionService.on('failure', listener)
|
|
this._unsubscribeCaptionFailure = () => {
|
|
captionService.off('failure', listener)
|
|
}
|
|
}
|
|
|
|
private _markLocalRecording(sessionId: string): void {
|
|
try {
|
|
this._recordingLedger.mark(sessionId)
|
|
} catch (err) {
|
|
logger.warn(`로컬 녹음 표식 기록 실패: ${err instanceof Error ? err.message : String(err)}`)
|
|
}
|
|
}
|
|
|
|
private _clearLocalRecording(sessionId: string): void {
|
|
try {
|
|
this._recordingLedger.clear(sessionId)
|
|
} catch (err) {
|
|
logger.warn(`로컬 녹음 표식 정리 실패: ${err instanceof Error ? err.message : String(err)}`)
|
|
}
|
|
}
|
|
|
|
private _stopTimers(): void {
|
|
this._unsubscribeCaptionFailure?.()
|
|
this._unsubscribeCaptionFailure = null
|
|
if (this._audioLevelTimer) {
|
|
clearInterval(this._audioLevelTimer)
|
|
this._audioLevelTimer = null
|
|
}
|
|
if (this._checkpointTimer) {
|
|
clearInterval(this._checkpointTimer)
|
|
this._checkpointTimer = null
|
|
}
|
|
}
|
|
|
|
/** 이 세션의 후처리가 끝났다 — 그사이 새 녹음이 시작됐으면 그것은 건드리지 않는다. */
|
|
private _finishSession(sessionId: string): void {
|
|
if (this._current && this._current.id !== sessionId) return
|
|
this._resetSession()
|
|
this._setState('idle')
|
|
this._sendStateToRenderer()
|
|
}
|
|
|
|
// ── 세션 조회 ──
|
|
|
|
getSessions(page: number, pageSize: number): MeetingSessionPage {
|
|
const db = getDatabase()
|
|
const offset = (page - 1) * pageSize
|
|
|
|
const countResult = db.select({ count: sql<number>`count(*)` })
|
|
.from(meetingSessions)
|
|
.get()
|
|
const total = countResult?.count ?? 0
|
|
|
|
const rows = db.select()
|
|
.from(meetingSessions)
|
|
.orderBy(desc(meetingSessions.createdAt))
|
|
.limit(pageSize)
|
|
.offset(offset)
|
|
.all()
|
|
|
|
const sessions: MeetingSessionSummary[] = rows.map((row) => {
|
|
const memoCount = db.select({ count: sql<number>`count(*)` })
|
|
.from(meetingMemos)
|
|
.where(eq(meetingMemos.sessionId, row.id))
|
|
.get()?.count ?? 0
|
|
|
|
return {
|
|
id: row.id,
|
|
title: row.title,
|
|
status: row.status as MeetingSessionSummary['status'],
|
|
startedAt: row.startedAt,
|
|
endedAt: row.endedAt,
|
|
durationMs: row.durationMs,
|
|
memoCount,
|
|
}
|
|
})
|
|
|
|
return {
|
|
sessions,
|
|
total,
|
|
page,
|
|
pageSize,
|
|
totalPages: Math.ceil(total / pageSize),
|
|
}
|
|
}
|
|
|
|
getSession(sessionId: string): MeetingSessionDetail {
|
|
const detail = this._loadSessionDetail(sessionId)
|
|
if (!detail) {
|
|
throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${sessionId}`)
|
|
}
|
|
return detail
|
|
}
|
|
|
|
deleteSession(sessionId: string): void {
|
|
const db = getDatabase()
|
|
const row = db.select().from(meetingSessions).where(eq(meetingSessions.id, sessionId)).get()
|
|
if (!row) {
|
|
throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${sessionId}`)
|
|
}
|
|
|
|
db.delete(meetingMemos).where(eq(meetingMemos.sessionId, sessionId)).run()
|
|
db.delete(meetingDocuments).where(eq(meetingDocuments.sessionId, sessionId)).run()
|
|
db.delete(meetingSessions).where(eq(meetingSessions.id, sessionId)).run()
|
|
// 서버는 회의 삭제가 메모·문서로 cascade 된다 — 회의 하나만 지우면 된다.
|
|
getCloudSyncService().pushDelete('meetings', sessionId)
|
|
this.cancelMeetingChat(sessionId)
|
|
this._chatHistories.delete(sessionId)
|
|
// 로컬 녹음(WAV)도 지운다 — 행이 사라지면 어떤 경로도 이 파일을 다시 찾지 않는다(best-effort)
|
|
void this._deleteMeetingAudio(sessionId)
|
|
logger.info(`회의 세션 삭제: ${sessionId}`)
|
|
}
|
|
|
|
private async _deleteMeetingAudio(sessionId: string): Promise<void> {
|
|
try {
|
|
const audioPath = await meetingAudioFilePath(sessionId)
|
|
await fs.promises.rm(audioPath, { force: true })
|
|
} catch (err) {
|
|
logger.warn(`회의 오디오 삭제 실패: ${err instanceof Error ? err.message : String(err)}`)
|
|
}
|
|
}
|
|
|
|
updateTitle(sessionId: string, title: string): void {
|
|
const db = getDatabase()
|
|
const row = db.select().from(meetingSessions).where(eq(meetingSessions.id, sessionId)).get()
|
|
if (!row) {
|
|
throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${sessionId}`)
|
|
}
|
|
db.update(meetingSessions).set({ title, updatedAt: Date.now() })
|
|
.where(eq(meetingSessions.id, sessionId)).run()
|
|
getCloudSyncService().pushOne('meetings', sessionId)
|
|
}
|
|
|
|
// ── 내보내기 ──
|
|
|
|
async exportPdf(sessionId: string): Promise<string> {
|
|
const session = this._loadSessionDetail(sessionId)
|
|
if (!session) {
|
|
throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${sessionId}`)
|
|
}
|
|
|
|
const html = this._buildPdfHtml(session)
|
|
|
|
const { filePath } = await dialog.showSaveDialog({
|
|
title: 'PDF로 내보내기',
|
|
defaultPath: `회의록_${formatDateFile(session.startedAt)}.pdf`,
|
|
filters: [{ name: 'PDF', extensions: ['pdf'] }],
|
|
})
|
|
if (!filePath) return ''
|
|
|
|
const win = new BrowserWindow({ show: false, width: 800, height: 600 })
|
|
try {
|
|
await win.loadURL(`data:text/html;charset=utf-8,${encodeURIComponent(html)}`)
|
|
const pdfBuffer = await win.webContents.printToPDF({
|
|
printBackground: true,
|
|
pageSize: 'A4',
|
|
margins: { top: 20, bottom: 20, left: 20, right: 20 },
|
|
})
|
|
fs.writeFileSync(filePath, pdfBuffer)
|
|
logger.info(`PDF 내보내기 완료: ${filePath}`)
|
|
return filePath
|
|
} finally {
|
|
win.close()
|
|
}
|
|
}
|
|
|
|
async exportMarkdown(sessionId: string): Promise<string> {
|
|
const session = this._loadSessionDetail(sessionId)
|
|
if (!session) {
|
|
throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${sessionId}`)
|
|
}
|
|
|
|
const { filePath } = await dialog.showSaveDialog({
|
|
title: '마크다운으로 내보내기',
|
|
defaultPath: `회의록_${formatDateFile(session.startedAt)}.md`,
|
|
filters: [{ name: 'Markdown', extensions: ['md'] }],
|
|
})
|
|
if (!filePath) return ''
|
|
|
|
const md = buildExportMarkdown(session)
|
|
fs.writeFileSync(filePath, md, 'utf-8')
|
|
logger.info(`마크다운 내보내기 완료: ${filePath}`)
|
|
return filePath
|
|
}
|
|
|
|
// ── 내부 헬퍼 ──
|
|
|
|
private _setState(state: MeetingModeState): void {
|
|
this._state = state
|
|
this.emit('state-changed', state)
|
|
}
|
|
|
|
private _resetSession(): void {
|
|
this._stopTimers()
|
|
this._current?.detach()
|
|
this._current = null
|
|
this._checkpointedSegments = 0
|
|
this._meetingModeActive = false
|
|
}
|
|
|
|
/** PCM16 버퍼를 WAV 파일로 저장 (16kHz mono 16-bit) */
|
|
private _saveWav(filePath: string, pcmBuffer: Buffer): void {
|
|
const sampleRate = 16000
|
|
const numChannels = 1
|
|
const bitsPerSample = 16
|
|
const byteRate = sampleRate * numChannels * (bitsPerSample / 8)
|
|
const blockAlign = numChannels * (bitsPerSample / 8)
|
|
const dataSize = pcmBuffer.length
|
|
|
|
const header = Buffer.alloc(44)
|
|
header.write('RIFF', 0)
|
|
header.writeUInt32LE(36 + dataSize, 4)
|
|
header.write('WAVE', 8)
|
|
header.write('fmt ', 12)
|
|
header.writeUInt32LE(16, 16) // fmt chunk size
|
|
header.writeUInt16LE(1, 20) // PCM
|
|
header.writeUInt16LE(numChannels, 22)
|
|
header.writeUInt32LE(sampleRate, 24)
|
|
header.writeUInt32LE(byteRate, 28)
|
|
header.writeUInt16LE(blockAlign, 32)
|
|
header.writeUInt16LE(bitsPerSample, 34)
|
|
header.write('data', 36)
|
|
header.writeUInt32LE(dataSize, 40)
|
|
|
|
// 헤더와 PCM 을 이어 붙이지 않고 따로 쓴다 — 3시간 회의면 concat 사본만 350MB 가 더 생긴다
|
|
const fd = fs.openSync(filePath, 'w')
|
|
try {
|
|
fs.writeSync(fd, header)
|
|
fs.writeSync(fd, pcmBuffer)
|
|
} finally {
|
|
fs.closeSync(fd)
|
|
}
|
|
}
|
|
|
|
private _sendToRenderer(channel: string, data: unknown): void {
|
|
const win = getMainWindow()
|
|
if (win && !win.isDestroyed()) {
|
|
win.webContents.send(channel, data)
|
|
}
|
|
}
|
|
|
|
private _sendStateToRenderer(): void {
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.STATE_CHANGED, this.getStateInfo())
|
|
}
|
|
|
|
private _sendProgress(sessionId: string, step: MeetingProcessingStep, percent: number): void {
|
|
const progress: MeetingProcessingProgress = { sessionId, step, percent }
|
|
this.emit('processing-progress', progress)
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.PROCESSING_PROGRESS, progress)
|
|
}
|
|
|
|
/**
|
|
* 회의 문서/폴리시/화자추정 LLM — LlmGateway(백엔드 선택 정책의 정본)에 위임한다.
|
|
* llmBackend==='local' 이면 로컬, online 이면 Premium(불가·실패 시 로컬 폴백).
|
|
*/
|
|
private async _resolveMeetingLlm(): Promise<MeetingLlm> {
|
|
const gateway = getLlmGateway()
|
|
return {
|
|
generate: (text, options) =>
|
|
gateway.generate(text, options, {
|
|
onFallback: (reason) => logger.warn(`Meeting LLM fallback: ${reason}`),
|
|
}),
|
|
}
|
|
}
|
|
|
|
// ── Phase 14.5: 전사 수정 ──
|
|
|
|
updateTranscript(sessionId: string, editedTranscript: string): void {
|
|
// 사용자의 수동 저장(실시간 세그먼트 반영 포함)은 기준본 확인 없이 쓴다 — 렌더러 계약은 그대로다.
|
|
if (this._transcripts.writeEdited(sessionId, editedTranscript) === 'not-found') {
|
|
throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${sessionId}`)
|
|
}
|
|
logger.info(`전사 수정 저장: sessionId=${sessionId}`)
|
|
}
|
|
|
|
/**
|
|
* LLM 결과(다듬기·화자 구분)를 읽었던 기준본 위에서만 쓴다. 그 사이 사용자가 전사를 고쳤으면
|
|
* 덮어쓰지 않고 실패시킨다 — 예전엔 마지막 쓰기가 이겨 수동 편집이 조용히 사라졌다.
|
|
*/
|
|
private _writeRewrite(sessionId: string, text: string, base: TranscriptRevision, failureCode: ErrorCode): void {
|
|
const result = this._transcripts.writeEdited(sessionId, text, base.revision)
|
|
if (result === 'not-found') {
|
|
throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션 없음: ${sessionId}`)
|
|
}
|
|
if (result === 'conflict') {
|
|
throw new D3ROError(failureCode, '작업하는 동안 전사가 수정되어 결과를 저장하지 않았습니다. 다시 시도해 주세요.')
|
|
}
|
|
}
|
|
|
|
// ── Phase 14.5: 문서 생성 ──
|
|
|
|
async generateDocument(params: MeetingGenerateDocParams): Promise<MeetingDocument> {
|
|
const db = getDatabase()
|
|
const row = db.select().from(meetingSessions).where(eq(meetingSessions.id, params.sessionId)).get()
|
|
if (!row) {
|
|
throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${params.sessionId}`)
|
|
}
|
|
|
|
const { getMeetingDocTemplateService } = await import('./MeetingDocTemplateService')
|
|
const templateService = getMeetingDocTemplateService()
|
|
const template = templateService.getById(params.templateId)
|
|
if (!template) {
|
|
throw new D3ROError(ErrorCode.MeetingDocTemplateNotFound, `템플릿을 찾을 수 없습니다: ${params.templateId}`)
|
|
}
|
|
|
|
const transcript = row.editedTranscript ?? row.rawTranscript ?? ''
|
|
|
|
// 메모도 함께 참조
|
|
const memoRows = db.select().from(meetingMemos)
|
|
.where(eq(meetingMemos.sessionId, params.sessionId))
|
|
.orderBy(meetingMemos.timestampMs)
|
|
.all()
|
|
const formattedMemos = memoRows.length > 0
|
|
? memoRows.map((m) => `[${formatTime(m.timestampMs)}] 📝 ${m.content}`).join('\n')
|
|
: ''
|
|
|
|
const systemPrompt = params.customPrompt ?? template.systemPrompt
|
|
const docTitle = params.customTitle ?? `${template.name} — ${row.title ?? '무제 회의'}`
|
|
|
|
// 진행률 전송
|
|
const sendProgress = (percent: number): void => {
|
|
const progress: MeetingDocGeneratingProgress = {
|
|
sessionId: params.sessionId,
|
|
templateId: params.templateId,
|
|
percent,
|
|
}
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DOC_GENERATING_PROGRESS, progress)
|
|
}
|
|
|
|
sendProgress(10)
|
|
|
|
const llmService = await this._resolveMeetingLlm()
|
|
|
|
sendProgress(30)
|
|
|
|
const llmStart = Date.now()
|
|
const memoSection = formattedMemos
|
|
? `\n\n## 참석자 메모 (📝 표시)\n${formattedMemos}`
|
|
: ''
|
|
// 긴 회의는 한 번에 보내면 프록시 한도(8,000자)를 넘어 거부된다 — 구간별로 줄인 뒤 보낸다.
|
|
const budget =
|
|
LLM_PROXY_CHAT_LIMITS.maxMessageChars - DOCUMENT_REQUEST_PREFIX.length - CONDENSED_NOTE.length - memoSection.length
|
|
const fitted = await condenseTranscriptToBudget(llmService, transcript, budget)
|
|
if (fitted.condensed) {
|
|
logger.info(`문서 생성: 전사를 ${fitted.rounds}회 구간 정리해 한도 안에 맞췄다 (sessionId=${params.sessionId})`)
|
|
}
|
|
sendProgress(60)
|
|
const transcriptSection = fitted.condensed ? `${CONDENSED_NOTE}${fitted.text}` : fitted.text
|
|
const result = await llmService.generate(
|
|
`${DOCUMENT_REQUEST_PREFIX}${transcriptSection}${memoSection}`,
|
|
{
|
|
systemPrompt,
|
|
temperature: 0.3,
|
|
maxTokens: 4096,
|
|
},
|
|
)
|
|
const llmLatencyMs = Date.now() - llmStart
|
|
|
|
sendProgress(85)
|
|
|
|
const now = Date.now()
|
|
const docId = crypto.randomUUID()
|
|
db.insert(meetingDocuments).values({
|
|
id: docId,
|
|
sessionId: params.sessionId,
|
|
templateType: template.templateType,
|
|
title: docTitle,
|
|
content: result.text,
|
|
promptUsed: systemPrompt,
|
|
llmModel: result.model,
|
|
llmLatencyMs,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
}).run()
|
|
|
|
sendProgress(100)
|
|
logger.info(`문서 생성 완료: docId=${docId}, sessionId=${params.sessionId}`)
|
|
|
|
// Phase 3.3: 자동 push (fire-and-forget)
|
|
getCloudSyncService().pushOne('meeting_documents', docId)
|
|
|
|
return {
|
|
id: docId,
|
|
sessionId: params.sessionId,
|
|
templateType: template.templateType,
|
|
title: docTitle,
|
|
content: result.text,
|
|
promptUsed: systemPrompt,
|
|
llmModel: result.model ?? null,
|
|
llmLatencyMs,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
}
|
|
}
|
|
|
|
// ── Phase 14.5: 문서 조회/수정/삭제 ──
|
|
|
|
getDocuments(sessionId: string): MeetingDocument[] {
|
|
const db = getDatabase()
|
|
const rows = db.select().from(meetingDocuments)
|
|
.where(eq(meetingDocuments.sessionId, sessionId))
|
|
.all()
|
|
|
|
return rows.map((r) => ({
|
|
id: r.id,
|
|
sessionId: r.sessionId,
|
|
templateType: r.templateType,
|
|
title: r.title,
|
|
content: r.content,
|
|
promptUsed: r.promptUsed,
|
|
llmModel: r.llmModel,
|
|
llmLatencyMs: r.llmLatencyMs,
|
|
createdAt: r.createdAt,
|
|
updatedAt: r.updatedAt,
|
|
}))
|
|
}
|
|
|
|
updateDocument(documentId: string, content: string): void {
|
|
const db = getDatabase()
|
|
const row = db.select().from(meetingDocuments).where(eq(meetingDocuments.id, documentId)).get()
|
|
if (!row) {
|
|
throw new D3ROError(ErrorCode.MeetingDocumentNotFound, `문서를 찾을 수 없습니다: ${documentId}`)
|
|
}
|
|
db.update(meetingDocuments).set({ content, updatedAt: Date.now() })
|
|
.where(eq(meetingDocuments.id, documentId)).run()
|
|
getCloudSyncService().pushOne('meeting_documents', documentId)
|
|
logger.info(`문서 수정: docId=${documentId}`)
|
|
}
|
|
|
|
deleteDocument(documentId: string): void {
|
|
const db = getDatabase()
|
|
const row = db.select().from(meetingDocuments).where(eq(meetingDocuments.id, documentId)).get()
|
|
if (!row) {
|
|
throw new D3ROError(ErrorCode.MeetingDocumentNotFound, `문서를 찾을 수 없습니다: ${documentId}`)
|
|
}
|
|
db.delete(meetingDocuments).where(eq(meetingDocuments.id, documentId)).run()
|
|
getCloudSyncService().pushDelete('meeting_documents', documentId)
|
|
logger.info(`문서 삭제: docId=${documentId}`)
|
|
}
|
|
|
|
// ── Phase 14.5: 문서 내보내기 ──
|
|
|
|
async exportDocument(documentId: string, format: MeetingExportFormat, targetPath?: string): Promise<string> {
|
|
const db = getDatabase()
|
|
const row = db.select().from(meetingDocuments).where(eq(meetingDocuments.id, documentId)).get()
|
|
if (!row) {
|
|
throw new D3ROError(ErrorCode.MeetingDocumentNotFound, `문서를 찾을 수 없습니다: ${documentId}`)
|
|
}
|
|
|
|
const safeTitle = row.title.replace(/[/\\?%*:|"<>]/g, '-').slice(0, 50)
|
|
const dateStr = formatDateFile(row.createdAt)
|
|
|
|
let filters: Electron.FileFilter[]
|
|
let defaultName: string
|
|
|
|
switch (format) {
|
|
case 'md':
|
|
filters = [{ name: 'Markdown', extensions: ['md'] }]
|
|
defaultName = `${safeTitle}_${dateStr}.md`
|
|
break
|
|
case 'txt':
|
|
filters = [{ name: 'Text', extensions: ['txt'] }]
|
|
defaultName = `${safeTitle}_${dateStr}.txt`
|
|
break
|
|
case 'docx':
|
|
filters = [{ name: 'Word Document', extensions: ['docx'] }]
|
|
defaultName = `${safeTitle}_${dateStr}.docx`
|
|
break
|
|
case 'pdf':
|
|
filters = [{ name: 'PDF', extensions: ['pdf'] }]
|
|
defaultName = `${safeTitle}_${dateStr}.pdf`
|
|
break
|
|
}
|
|
|
|
let filePath: string | undefined = targetPath
|
|
if (!filePath) {
|
|
if (isShowingMeetingSaveDialog) {
|
|
return ''
|
|
}
|
|
isShowingMeetingSaveDialog = true
|
|
try {
|
|
const { getMainWindow } = await import('../windows/WindowManager')
|
|
const mainWindow = getMainWindow()
|
|
const dialogOptions = {
|
|
title: '문서 내보내기',
|
|
defaultPath: defaultName,
|
|
filters,
|
|
}
|
|
const res = mainWindow
|
|
? await dialog.showSaveDialog(mainWindow, dialogOptions)
|
|
: await dialog.showSaveDialog(dialogOptions)
|
|
filePath = res.filePath
|
|
} finally {
|
|
isShowingMeetingSaveDialog = false
|
|
}
|
|
}
|
|
if (!filePath) return ''
|
|
|
|
switch (format) {
|
|
case 'md':
|
|
case 'txt':
|
|
fs.writeFileSync(filePath, row.content, 'utf-8')
|
|
break
|
|
case 'docx': {
|
|
const buf = await markdownToDocx(row.content, row.title)
|
|
fs.writeFileSync(filePath, buf)
|
|
break
|
|
}
|
|
case 'pdf': {
|
|
const html = renderMeetingPdfHtml({ title: row.title, markdown: row.content })
|
|
const win = new BrowserWindow({ show: false, width: 800, height: 600 })
|
|
try {
|
|
await win.loadURL(`data:text/html;charset=utf-8,${encodeURIComponent(html)}`)
|
|
const pdfBuffer = await win.webContents.printToPDF({
|
|
printBackground: true,
|
|
pageSize: 'A4',
|
|
margins: { top: 20, bottom: 20, left: 20, right: 20 },
|
|
})
|
|
fs.writeFileSync(filePath, pdfBuffer)
|
|
} finally {
|
|
win.close()
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
logger.info(`문서 내보내기 완료: format=${format}, path=${filePath}`)
|
|
return filePath
|
|
}
|
|
|
|
async exportTranscript(sessionId: string, targetPath?: string): Promise<string> {
|
|
const db = getDatabase()
|
|
const row = db.select().from(meetingSessions).where(eq(meetingSessions.id, sessionId)).get()
|
|
if (!row) {
|
|
throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션을 찾을 수 없습니다: ${sessionId}`)
|
|
}
|
|
|
|
const transcript = row.editedTranscript ?? row.rawTranscript ?? ''
|
|
const dateStr = formatDateFile(row.startedAt)
|
|
const safeTitle = (row.title ?? '무제_회의').replace(/[/\\?%*:|"<>]/g, '-').slice(0, 50)
|
|
|
|
let filePath: string | undefined = targetPath
|
|
if (!filePath) {
|
|
const res = await dialog.showSaveDialog({
|
|
title: '전사 내보내기',
|
|
defaultPath: `전사_${safeTitle}_${dateStr}.txt`,
|
|
filters: [{ name: 'Text', extensions: ['txt'] }],
|
|
})
|
|
filePath = res.filePath
|
|
}
|
|
if (!filePath) return ''
|
|
|
|
fs.writeFileSync(filePath, transcript, 'utf-8')
|
|
logger.info(`전사 내보내기 완료: path=${filePath}`)
|
|
return filePath
|
|
}
|
|
|
|
// ── 내부 헬퍼 ──
|
|
|
|
private _loadSessionDetail(sessionId: string): MeetingSessionDetail | null {
|
|
const db = getDatabase()
|
|
const row = db.select().from(meetingSessions).where(eq(meetingSessions.id, sessionId)).get()
|
|
if (!row) return null
|
|
|
|
const memoRows = db.select().from(meetingMemos)
|
|
.where(eq(meetingMemos.sessionId, sessionId))
|
|
.orderBy(meetingMemos.timestampMs)
|
|
.all()
|
|
|
|
const memos: MeetingMemo[] = memoRows.map((m) => ({
|
|
id: m.id,
|
|
sessionId: m.sessionId,
|
|
content: m.content,
|
|
timestampMs: m.timestampMs,
|
|
createdAt: m.createdAt,
|
|
}))
|
|
|
|
const docRows = db.select().from(meetingDocuments)
|
|
.where(eq(meetingDocuments.sessionId, sessionId))
|
|
.all()
|
|
|
|
const documents: MeetingDocument[] = docRows.map((d) => ({
|
|
id: d.id,
|
|
sessionId: d.sessionId,
|
|
templateType: d.templateType,
|
|
title: d.title,
|
|
content: d.content,
|
|
promptUsed: d.promptUsed,
|
|
llmModel: d.llmModel,
|
|
llmLatencyMs: d.llmLatencyMs,
|
|
createdAt: d.createdAt,
|
|
updatedAt: d.updatedAt,
|
|
}))
|
|
|
|
let minutes: MeetingMinutes | null = null
|
|
if (row.minutesJson) {
|
|
try {
|
|
minutes = JSON.parse(row.minutesJson) as MeetingMinutes
|
|
} catch {
|
|
logger.warn(`회의록 JSON 파싱 실패: sessionId=${sessionId}`)
|
|
}
|
|
}
|
|
|
|
return {
|
|
id: row.id,
|
|
title: row.title,
|
|
status: row.status as MeetingSessionDetail['status'],
|
|
startedAt: row.startedAt,
|
|
endedAt: row.endedAt,
|
|
durationMs: row.durationMs,
|
|
memoCount: memos.length,
|
|
rawTranscript: row.rawTranscript,
|
|
editedTranscript: row.editedTranscript,
|
|
minutesMarkdown: row.minutesMarkdown,
|
|
minutes,
|
|
memos,
|
|
documents,
|
|
sttModel: row.sttModel,
|
|
llmModel: row.llmModel,
|
|
errorMessage: row.errorMessage,
|
|
}
|
|
}
|
|
|
|
// ── Phase 15: Auto Polish ──
|
|
|
|
async polishTranscript(sessionId: string): Promise<string> {
|
|
const base = this._transcripts.read(sessionId)
|
|
if (!base) throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션 없음: ${sessionId}`)
|
|
|
|
// 기준본은 수정본(사용자 편집·화자 라벨) 우선 — 원문으로 다듬으면 편집과 라벨이 통째로 사라졌다.
|
|
const transcript = transcriptBase(base)
|
|
if (!transcript) throw new D3ROError(ErrorCode.MeetingPolishFailed, '전사 텍스트가 없습니다')
|
|
|
|
const llm = await this._resolveMeetingLlm()
|
|
const polished = await this._rewriteTranscriptInChunks(
|
|
llm,
|
|
transcript,
|
|
'다음 음성 전사 텍스트를 다듬어주세요. 필러 단어(음, 어, 그, 아 등)를 제거하고, 문장 구조를 자연스럽게 교정하되, 원래 의미와 내용은 절대 변경하지 마세요. 타임스탬프 형식 [MM:SS]과 화자 표기([화자 N] 등)는 그대로 유지하세요.',
|
|
ErrorCode.MeetingPolishFailed,
|
|
)
|
|
|
|
this._writeRewrite(sessionId, polished, base, ErrorCode.MeetingPolishFailed)
|
|
|
|
logger.info(`Auto Polish 완료: sessionId=${sessionId}`)
|
|
return polished
|
|
}
|
|
|
|
/**
|
|
* 긴 전사를 줄 경계 조각으로 나눠 LLM 으로 다시 쓰고 이어 붙인다.
|
|
* 한 번에 통째로 보내면 출력 토큰 한도(2048/4096)에서 잘린 결과가 editedTranscript 를
|
|
* 덮어써 회의 뒷부분이 문서·채팅·동기화에서 조용히 사라졌다. 조각 하나라도 잘린 것으로
|
|
* 보이면 저장하지 않고 실패시킨다.
|
|
*/
|
|
private async _rewriteTranscriptInChunks(
|
|
llm: MeetingLlm,
|
|
transcript: string,
|
|
systemPrompt: string,
|
|
failureCode: ErrorCode,
|
|
options: { carrySpeakerContext?: boolean } = {},
|
|
): Promise<string> {
|
|
const chunks = chunkTranscriptByLines(transcript, REWRITE_CHUNK_CHARS)
|
|
if (chunks.length === 0) {
|
|
throw new D3ROError(failureCode, '전사 텍스트가 없습니다')
|
|
}
|
|
const outputs: string[] = []
|
|
let previousTail: string[] = []
|
|
for (let i = 0; i < chunks.length; i++) {
|
|
const chunk = chunks[i]
|
|
// 화자 추정은 조각 사이에 화자 번호를 이어 준다 — 앞 조각의 라벨된 끝부분과 지금까지의 화자 목록.
|
|
const carry = options.carrySpeakerContext === true
|
|
const input = carry ? buildDiarizationChunkInput(chunk, previousTail) : chunk
|
|
const prompt = carry ? systemPrompt + diarizationContinuityHint(extractSpeakerLabels(outputs.join('\n'))) : systemPrompt
|
|
const result = await llm.generate(input, {
|
|
systemPrompt: prompt,
|
|
temperature: 0.3,
|
|
maxTokens: REWRITE_CHUNK_MAX_TOKENS,
|
|
})
|
|
const text = carry ? stripEchoedContext(result.text, previousTail) : result.text.trim()
|
|
if (looksTruncatedRewrite(chunk, text)) {
|
|
throw new D3ROError(
|
|
failureCode,
|
|
`LLM 결과가 잘린 것으로 보여 저장하지 않았습니다 (조각 ${i + 1}/${chunks.length})`,
|
|
)
|
|
}
|
|
outputs.push(text.trim())
|
|
if (carry) previousTail = lastLines(text, DIARIZATION_CONTEXT_LINES)
|
|
}
|
|
return outputs.join('\n')
|
|
}
|
|
|
|
// ── Phase 15: Meeting AI Chat ──
|
|
|
|
async chatWithMeeting(sessionId: string, userMessage: string): Promise<void> {
|
|
const db = getDatabase()
|
|
const row = db.select().from(meetingSessions).where(eq(meetingSessions.id, sessionId)).get()
|
|
if (!row) throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션 없음: ${sessionId}`)
|
|
|
|
const transcript = row.editedTranscript ?? row.rawTranscript ?? ''
|
|
// system 은 한도(8,000자)에서 앞부분만 남기고 잘린다 — 예전엔 긴 회의의 뒷부분이 조용히 빠져
|
|
// 그 부분 질문에 "확인되지 않습니다"라고 답했다. 한도를 넘으면 질문과 관련된 구간을 골라 넣고,
|
|
// 일부만 봤다는 사실을 모델이 답에 밝히게 한다.
|
|
const excerpt = selectTranscriptExcerpts(
|
|
transcript,
|
|
userMessage,
|
|
LLM_PROXY_CHAT_LIMITS.maxSystemChars - CHAT_SYSTEM_OVERHEAD_CHARS,
|
|
)
|
|
const systemPrompt = excerpt.complete
|
|
? `당신은 회의 내용을 분석하는 AI 어시스턴트입니다.
|
|
아래 회의 전사 내용을 참고하여 사용자의 질문에 정확하게 답변하세요.
|
|
전사 내용에 없는 것은 "전사 내용에서 확인되지 않습니다"라고 답하세요.
|
|
|
|
## 회의 전사
|
|
${excerpt.text}`
|
|
: `당신은 회의 내용을 분석하는 AI 어시스턴트입니다.
|
|
회의가 길어 전체 ${excerpt.totalChunks}개 구간 중 질문과 관련된 ${excerpt.includedChunks}개 구간의 발췌만 아래에 있습니다.
|
|
발췌를 참고하여 사용자의 질문에 정확하게 답변하세요.
|
|
발췌에 없는 것은 "제공된 전사 발췌에서는 확인되지 않습니다(회의가 길어 일부 구간만 참고했습니다)"라고 답하세요.
|
|
|
|
## 회의 전사 (발췌)
|
|
${excerpt.text}`
|
|
if (!excerpt.complete) {
|
|
logger.info(
|
|
`회의 채팅: 전사 ${excerpt.totalChunks}개 구간 중 ${excerpt.includedChunks}개만 발췌해 보냈다 (sessionId=${sessionId})`,
|
|
)
|
|
}
|
|
|
|
// 이 회의의 히스토리만 쓴다. 사용자 턴은 답변이 끝났을 때 함께 기록한다
|
|
// (실패·취소 시 짝 없는 사용자 턴이 남지 않게).
|
|
const history = this._chatHistories.get(sessionId) ?? []
|
|
const messages = [
|
|
{ role: 'system' as const, content: systemPrompt },
|
|
...history,
|
|
{ role: 'user' as const, content: userMessage },
|
|
]
|
|
|
|
// 같은 회의에서 흐르던 채팅만 끊는다 — 다른 회의의 채팅은 건드리지 않는다
|
|
this._chatAbortControllers.get(sessionId)?.abort()
|
|
const controller = new AbortController()
|
|
this._chatAbortControllers.set(sessionId, controller)
|
|
const signal = controller.signal
|
|
|
|
let fullResponse = ''
|
|
try {
|
|
const { generator } = await getLlmGateway().openChatStream(
|
|
messages,
|
|
{ signal, local: { temperature: 0.5 } },
|
|
{ onFallback: (reason) => logger.warn(`Meeting chat fallback: ${reason}`) },
|
|
)
|
|
|
|
for await (const token of generator) {
|
|
if (signal.aborted) break
|
|
fullResponse += token
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_CHAT.DELTA, { sessionId, token })
|
|
}
|
|
|
|
// 취소(대화 지우기·패널 떠남·같은 회의의 새 질문)된 답변은 보내지 않는다 — 비운 대화에 잘린 답변이
|
|
// 다시 나타났고, 기록에 없는 턴이라 화면과 모델의 대화가 어긋났다.
|
|
if (signal.aborted) return
|
|
const updated = [
|
|
...history,
|
|
{ role: 'user' as const, content: userMessage },
|
|
{ role: 'assistant' as const, content: fullResponse },
|
|
]
|
|
this._chatHistories.set(sessionId, updated.slice(-MAX_CHAT_HISTORY_MESSAGES))
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_CHAT.MESSAGE, {
|
|
sessionId,
|
|
role: 'assistant',
|
|
content: fullResponse,
|
|
timestamp: Date.now(),
|
|
})
|
|
} catch (err) {
|
|
if (!signal.aborted && (err as Error).name !== 'AbortError') {
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_CHAT.ERROR, {
|
|
sessionId,
|
|
message: err instanceof Error ? err.message : String(err),
|
|
})
|
|
}
|
|
} finally {
|
|
if (this._chatAbortControllers.get(sessionId) === controller) this._chatAbortControllers.delete(sessionId)
|
|
}
|
|
}
|
|
|
|
/** 회의 채팅을 멈춘다. sessionId 를 주면 그 회의만, 생략하면 전부. */
|
|
cancelMeetingChat(sessionId?: string): void {
|
|
if (sessionId) {
|
|
this._chatAbortControllers.get(sessionId)?.abort()
|
|
this._chatAbortControllers.delete(sessionId)
|
|
return
|
|
}
|
|
for (const controller of this._chatAbortControllers.values()) controller.abort()
|
|
this._chatAbortControllers.clear()
|
|
}
|
|
|
|
/** 회의 채팅 히스토리를 비운다. sessionId 를 주면 그 회의만, 생략하면 전부. */
|
|
clearMeetingChatHistory(sessionId?: string): void {
|
|
if (sessionId) {
|
|
this._chatHistories.delete(sessionId)
|
|
} else {
|
|
this._chatHistories.clear()
|
|
}
|
|
}
|
|
|
|
/** 특정 회의의 채팅 히스토리 사본 — 채팅 패널을 다시 열 때 main 이 기억하는 대화를 보여 준다 */
|
|
getMeetingChatHistory(sessionId: string): MeetingChatHistoryTurn[] {
|
|
return [...(this._chatHistories.get(sessionId) ?? [])]
|
|
}
|
|
|
|
// ── Phase 15.5: 화자 구분 ──
|
|
|
|
async diarizeSession(sessionId: string, numSpeakers?: number): Promise<void> {
|
|
const row = this._transcripts.read(sessionId)
|
|
if (!row) throw new D3ROError(ErrorCode.MeetingSessionNotFound, `세션 없음: ${sessionId}`)
|
|
if (!row.raw) throw new D3ROError(ErrorCode.DiarizationFailed, '전사 텍스트가 없습니다')
|
|
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 10 })
|
|
|
|
// 오디오 파일 존재 확인
|
|
const audioPath = await meetingAudioFilePath(sessionId)
|
|
const hasAudioFile = fs.existsSync(audioPath)
|
|
|
|
const hfToken = configGet('hfToken') as string
|
|
|
|
if (hasAudioFile && hfToken) {
|
|
// Phase 15.5-2: pyannote 실제 화자 구분
|
|
logger.info(`pyannote 화자 구분 시작: ${audioPath}`)
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 20 })
|
|
|
|
try {
|
|
const audioBuffer = fs.readFileSync(audioPath)
|
|
const serverUrl = `http://127.0.0.1:18765`
|
|
|
|
const formData = new FormData()
|
|
formData.append('audio', new Blob([audioBuffer]), 'audio.wav')
|
|
formData.append('hf_token', hfToken)
|
|
if (numSpeakers && numSpeakers > 0) {
|
|
formData.append('num_speakers', String(numSpeakers))
|
|
}
|
|
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 40 })
|
|
|
|
const response = await fetch(`${serverUrl}/diarize`, {
|
|
method: 'POST',
|
|
body: formData,
|
|
})
|
|
|
|
if (!response.ok) {
|
|
const errData = await response.json() as { message?: string }
|
|
throw new Error(errData.message ?? `Diarization failed: ${response.status}`)
|
|
}
|
|
|
|
const diarResult = await response.json() as {
|
|
segments: Array<{ speaker: string; start: number; end: number }>
|
|
num_speakers: number
|
|
}
|
|
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 70 })
|
|
|
|
// 전사 줄과 화자 구간 매칭 — 줄 형식 규칙은 core meeting-transcript 한 곳에서만 해석한다.
|
|
// 화자는 덧붙이지 않고 교체하므로 다시 돌려도 라벨이 쌓이지 않는다.
|
|
const transcript = transcriptBase(row) ?? ''
|
|
const labeledLines = applySpeakerLabels(
|
|
parseTranscriptLines(transcript),
|
|
diarResult.segments,
|
|
(raw) => raw.replace('SPEAKER_', '화자 '),
|
|
)
|
|
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 85 })
|
|
|
|
this._writeRewrite(sessionId, formatTranscriptLines(labeledLines), row, ErrorCode.DiarizationFailed)
|
|
|
|
logger.info(`pyannote 화자 구분 완료: ${diarResult.num_speakers}명, sessionId=${sessionId}`)
|
|
} catch (err) {
|
|
logger.warn(`pyannote 실패, LLM 폴백: ${err instanceof Error ? err.message : String(err)}`)
|
|
// pyannote 실패 시 LLM 폴백
|
|
await this._diarizeLLMFallback(sessionId, row, numSpeakers)
|
|
}
|
|
} else {
|
|
// LLM 기반 화자 추정 (오디오 없거나 HF 토큰 없음)
|
|
await this._diarizeLLMFallback(sessionId, row, numSpeakers)
|
|
}
|
|
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 100 })
|
|
logger.info(`화자 구분 완료: sessionId=${sessionId}`)
|
|
}
|
|
|
|
private async _diarizeLLMFallback(
|
|
sessionId: string,
|
|
row: TranscriptRevision,
|
|
numSpeakers?: number,
|
|
): Promise<void> {
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 30 })
|
|
|
|
const llm = await this._resolveMeetingLlm()
|
|
|
|
const transcript = transcriptBase(row) ?? ''
|
|
const speakerHint = numSpeakers && numSpeakers > 0
|
|
? `회의에는 총 ${numSpeakers}명의 화자가 있습니다.`
|
|
: '화자 수는 문맥에서 추정하세요.'
|
|
|
|
const labeled = await this._rewriteTranscriptInChunks(
|
|
llm,
|
|
transcript,
|
|
`다음 회의 전사록을 분석하여 각 발언의 화자를 추정해주세요.
|
|
${speakerHint}
|
|
각 줄을 [시간] [화자] 내용 형식으로 변환하세요.
|
|
화자는 "화자 1", "화자 2" 등으로 표시하세요.
|
|
발언 내용, 어조, 문맥을 기반으로 화자를 추정하세요.
|
|
원문의 타임스탬프와 내용은 변경하지 마세요.`,
|
|
ErrorCode.DiarizationFailed,
|
|
{ carrySpeakerContext: true },
|
|
)
|
|
|
|
this._sendToRenderer(IPC_CHANNELS.MEETING_MODE.DIARIZATION_PROGRESS, { sessionId, percent: 80 })
|
|
|
|
this._writeRewrite(sessionId, labeled, row, ErrorCode.DiarizationFailed)
|
|
}
|
|
|
|
private _buildPdfHtml(session: MeetingSessionDetail): string {
|
|
const durationMin = session.durationMs ? Math.round(session.durationMs / 60000) : 0
|
|
return renderMeetingPdfHtml({
|
|
title: session.title ?? '무제 회의',
|
|
meta: `일시: ${formatDateRange(session.startedAt, session.endedAt)} | 소요: ${durationMin}분`,
|
|
markdown: session.minutesMarkdown,
|
|
emptyMessage: '회의록이 생성되지 않았습니다.',
|
|
})
|
|
}
|
|
}
|
|
|
|
// ── 싱글톤 ──
|
|
/** 기본 전사 저장소 — meeting_sessions 행을 읽고 쓰며, 쓴 뒤 동기화를 예약한다. */
|
|
function createSqliteMeetingTranscriptStore(): MeetingTranscriptStore {
|
|
return createTranscriptStore({
|
|
readRow: (sessionId) =>
|
|
getDatabase()
|
|
.select({ rawTranscript: meetingSessions.rawTranscript, editedTranscript: meetingSessions.editedTranscript })
|
|
.from(meetingSessions)
|
|
.where(eq(meetingSessions.id, sessionId))
|
|
.get(),
|
|
writeEdited: (sessionId, editedTranscript, now) => {
|
|
getDatabase()
|
|
.update(meetingSessions)
|
|
.set({ editedTranscript, updatedAt: now })
|
|
.where(eq(meetingSessions.id, sessionId))
|
|
.run()
|
|
},
|
|
onWritten: (sessionId) => getCloudSyncService().pushOne('meetings', sessionId),
|
|
})
|
|
}
|
|
|
|
let instance: MeetingModeService | null = null
|
|
|
|
export function getMeetingModeService(): MeetingModeService {
|
|
if (!instance) {
|
|
instance = new MeetingModeService()
|
|
}
|
|
return instance
|
|
}
|
|
|
|
export function resetMeetingModeServiceForTests(): void {
|
|
if (instance) instance.disposeForTests()
|
|
instance = null
|
|
}
|
|
|
|
export type { MeetingModeService }
|