d3ro-voice/apps/desktop/tests/main/services/SuggestionService.test.ts
Yun Chan d63854db67
Some checks failed
ci / 정본·보안·린트·타입·테스트 (push) Successful in 56s
ci / .NET API 서버 테스트 (push) Successful in 10s
deploy-site / deploy (push) Successful in 38s
ci / 모바일 린트·타입·Jest (push) Successful in 44s
ci / 워크스페이스 빌드 검증 (push) Successful in 54s
ci / Supabase Edge Functions + Cloudflare Worker (push) Successful in 22s
portable-unsigned / portable-windows (push) Failing after 35s
release / release-windows (push) Failing after 13s
fix(desktop): stop pinning local models in memory and cap audio buffers
The PC-wide slowdown was not a leak but model residency: boot warmup loaded
gemma4:e4b (~11.6 GB RAM incl. 5.9 GB pinned host buffer, no mmap on Windows
CUDA) and kept it for 30m, next to the large-v3 sidecar. Measured on the HEAD
build: free RAM 7.9 GB -> 32 MB within 20 s; after this change 10.8 GB with no
Ollama model loaded until typing starts.

- single LOCAL_LLM_KEEP_ALIVE (10m) for every local request; no boot warmup
- unload this app's resident Ollama models (keep_alive 0) on quit
- sidecar POST /unload for the aux slot; captions release it on stop
- partial dictation copies only the tail window, not the whole recording
- cap the voice-conversation listen buffer at 5 minutes
- mic test: generation guard so re-entry cannot orphan lease/timers
- startRealtime: single-flight and removeChannel to stop duplicate bindings
- meeting WAV save writes header and PCM without a concat copy

Docs: AI-01 policy note, GAP-PERF-01 with remaining work.
2026-10-11 11:35:15 +09:00

647 lines
29 KiB
TypeScript

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
const config = vi.hoisted(() => ({
suggestionEnabled: true,
suggestionModelId: 'gemma4:e4b',
llmModelId: 'gemma4:e4b',
inputExcludedApps: [],
suggestionTriggerDelayMs: 600,
suggestionMinPrefixChars: 8,
suggestionMaxRequestsPerMinute: 6,
suggestionDailyBudget: 500,
suggestionRequestTimeoutMs: 8000,
inputLearnTypedText: false,
inputTelemetryEnabled: false,
suggestionOverlayInteractive: true
}))
const localLlm = vi.hoisted(() => ({
isAvailable: vi.fn(() => true),
streamGenerate: vi.fn()
}))
vi.mock('../../../src/main/services/ConfigService', () => ({
configGet: vi.fn((key: keyof typeof config) => config[key]),
configSet: vi.fn()
}))
vi.mock('../../../src/main/services/LoggerService', () => ({
getLogger: () => ({ info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() })
}))
vi.mock('../../../src/main/services/LocalLLMService', () => ({
getLocalLLMService: () => localLlm
}))
vi.mock('../../../src/main/services/InputTelemetryService', () => ({
getInputTelemetryService: () => ({ listPhrases: vi.fn(() => []), listRecentWrites: vi.fn(() => []), recordExternalText: vi.fn() })
}))
vi.mock('../../../src/main/services/PersonalGraphService', () => ({
getPersonalGraphService: () => ({ retrieveContext: vi.fn(() => ({ continuations: [], related: [] })) })
}))
vi.mock('../../../src/main/services/TextInsertService', () => ({
getTextInsertService: () => ({ insertText: vi.fn() })
}))
vi.mock('../../../src/main/db', () => ({ getDatabase: vi.fn() }))
vi.mock('../../../src/main/db/schema', () => ({ suggestions: {} }))
const PREFIX = '오늘 회의에서 논의한 내용을 정리해서'
const context = {
prefix: PREFIX,
fullText: PREFIX,
caretOffset: PREFIX.length,
anchor: null,
anchorKind: null,
isPassword: false,
isEditable: true,
isComposing: false,
hasSelection: false,
available: true,
appName: 'notepad.exe',
windowTitle: 'notes',
idleMs: 1000,
capturedAt: Date.now(),
editedSinceFocus: true,
typedRecently: true
}
interface InternalSuggestionService {
_abort: AbortController | null
_consecutiveFailures: number
_cooldownUntil: number
_inFlight: boolean
_lastRequestAt: number
_generate(prefix: string, currentContext: typeof context, maxCandidates: number, maxChars: number): Promise<void>
_abortStaleGeneration(currentPrefix: string): void
_watchdog(): void
_generationToken: number
}
function waitForAbort(signal: AbortSignal | undefined): AsyncGenerator<string> {
return (async function* () {
await new Promise<void>((_resolve, reject) => {
if (!signal) {
reject(new Error('missing abort signal'))
return
}
signal.addEventListener('abort', () => reject(new Error('intentional abort')), { once: true })
})
yield 'unreachable'
})()
}
beforeEach(() => {
Object.assign(config, {
suggestionEnabled: true,
suggestionModelId: 'gemma4:e4b',
llmModelId: 'gemma4:e4b',
inputExcludedApps: [],
suggestionTriggerDelayMs: 600,
suggestionMinPrefixChars: 8,
suggestionMaxRequestsPerMinute: 6,
suggestionDailyBudget: 500,
suggestionRequestTimeoutMs: 8000,
inputLearnTypedText: false,
inputTelemetryEnabled: false,
suggestionOverlayInteractive: true
})
localLlm.isAvailable.mockReset()
localLlm.isAvailable.mockReturnValue(true)
localLlm.streamGenerate.mockReset()
})
afterEach(async () => {
const { resetSuggestionServiceForTests } = await import('../../../src/main/services/SuggestionService')
resetSuggestionServiceForTests()
config.suggestionEnabled = true
vi.useRealTimers()
vi.clearAllMocks()
})
describe('SuggestionService warm-up', () => {
it('동시 warm-up 호출을 하나의 1토큰 요청으로 합치고 공통 keep-alive(10분)로 유지한다', async () => {
localLlm.streamGenerate.mockImplementation(async function* () {
yield 'ok'
})
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const warmingStates: boolean[] = []
service.on('state-changed', (state) => warmingStates.push(state.warmingUp))
await Promise.all([service.warmUp(), service.warmUp()])
expect(localLlm.streamGenerate).toHaveBeenCalledTimes(1)
expect(localLlm.streamGenerate).toHaveBeenCalledWith(
'hi',
expect.objectContaining({ maxTokens: 1, keepAlive: '10m' })
)
expect(warmingStates).toEqual([true, false])
})
it('콜드 모델(워밍업 전)에서는 요청 결정이어도 생성 대신 워밍업을 트리거한다', async () => {
localLlm.streamGenerate.mockImplementation(async function* () {
yield 'ok'
})
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as InternalSuggestionService & {
_warmUpPromise: Promise<void> | null
}
const generateSpy = vi.spyOn(internal, '_generate')
service.handleTypingContext({ ...context, idleMs: 1000 })
expect(generateSpy).not.toHaveBeenCalled()
expect(localLlm.streamGenerate).toHaveBeenCalledWith('hi', expect.objectContaining({ maxTokens: 1 }))
const state = service.getState()
expect(state.warmingUp).toBe(true)
expect(state.lastSkipReason).toBe('model-unavailable')
await internal._warmUpPromise
})
it('타이핑 중이면(아직 멈추지 않았어도) 식은 모델을 "준비 중" 표시 없이 미리 올린다', async () => {
localLlm.streamGenerate.mockImplementation(async function* () {
yield 'ok'
})
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as InternalSuggestionService & {
_warmUpPromise: Promise<void> | null
}
// 치는 중(유휴 100ms) — 정책상 아직 제안할 때가 아니다
service.handleTypingContext({ ...context, idleMs: 100 })
expect(localLlm.streamGenerate).toHaveBeenCalledWith('hi', expect.objectContaining({ maxTokens: 1 }))
expect(service.getState().warmingUp).toBe(false)
expect(service.isPresentationActive).toBe(false)
await internal._warmUpPromise
})
it('dismiss(stale)는 진행 중인 워밍업을 취소하지 않는다', async () => {
let resolveChunk: (() => void) | null = null
localLlm.streamGenerate.mockImplementation((_text: string, options: { signal?: AbortSignal }) => {
return (async function* () {
await new Promise<void>((resolve, reject) => {
resolveChunk = resolve
options.signal?.addEventListener('abort', () => reject(new Error('aborted')), { once: true })
})
yield 'ok'
})()
})
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as InternalSuggestionService & {
_warmUpAbort: AbortController | null
}
const warmUpPromise = service.warmUp()
await Promise.resolve()
expect(internal._warmUpAbort?.signal.aborted).toBe(false)
service.dismiss('stale')
expect(internal._warmUpAbort?.signal.aborted).toBe(false)
resolveChunk?.()
await warmUpPromise
expect(localLlm.streamGenerate).toHaveBeenCalledTimes(1)
})
it('비활성화하면 가용성 재시도 타이머와 warm-up을 취소한다', async () => {
vi.useFakeTimers()
localLlm.isAvailable.mockReturnValue(false)
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const warmUp = service.warmUp()
config.suggestionEnabled = false
service.applyConfig()
await warmUp
expect(vi.getTimerCount()).toBe(0)
expect(localLlm.streamGenerate).not.toHaveBeenCalled()
})
it('dismiss 취소는 실패 쿨다운을 올리거나 재귀 생성하지 않는다', async () => {
localLlm.streamGenerate.mockImplementation((_text: string, options: { signal?: AbortSignal }) =>
waitForAbort(options.signal)
)
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as InternalSuggestionService
const cleared: string[] = []
service.on('cleared', ({ reason }) => cleared.push(reason))
const generation = internal._generate(PREFIX, context, 3, 240)
await Promise.resolve()
service.dismiss('dismissed')
await generation
expect(internal._consecutiveFailures).toBe(0)
expect(internal._cooldownUntil).toBe(0)
expect(localLlm.streamGenerate).toHaveBeenCalledTimes(1)
expect(cleared).toEqual(['dismissed'])
})
it('생성 중 동일 접두의 주기 스냅샷은 요청을 취소하지 않는다', async () => {
let signal: AbortSignal | undefined
localLlm.streamGenerate.mockImplementation((_text: string, options: { signal?: AbortSignal }) => {
signal = options.signal
return waitForAbort(options.signal)
})
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as InternalSuggestionService
const generation = internal._generate(PREFIX, context, 3, 240)
await Promise.resolve()
service.handleTypingContext(context)
expect(signal?.aborted).toBe(false)
expect(internal._inFlight).toBe(true)
service.dismiss('dismissed')
await generation
})
it.each([
['선택', { hasSelection: true }, 'selection-active'],
['포커스 이탈', { isEditable: false }, 'not-editable']
])('생성 중 %s은 후보가 없어도 취소하고 정확한 cleared 사유를 낸다', async (_case, update, reason) => {
let signal: AbortSignal | undefined
localLlm.streamGenerate.mockImplementation((_text: string, options: { signal?: AbortSignal }) => {
signal = options.signal
return waitForAbort(options.signal)
})
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const cleared: string[] = []
service.on('cleared', ({ reason: clearedReason }) => cleared.push(clearedReason))
const generation = (service as unknown as InternalSuggestionService)._generate(PREFIX, context, 3, 240)
await Promise.resolve()
expect(service.getState()).toMatchObject({ candidates: [], generating: true })
service.handleTypingContext({ ...context, ...update })
await generation
expect(signal?.aborted).toBe(true)
expect(cleared).toEqual([reason])
expect(service.getState()).toMatchObject({ candidates: [], generating: false, partialText: null })
})
it('후보 게시 updated 상태에는 생성 플래그와 부분 텍스트가 남지 않는다', async () => {
localLlm.streamGenerate.mockImplementation(async function* () {
yield '다음 단계도 확인하겠습니다.'
})
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const states: Array<{ candidates: unknown[]; generating: boolean; partialText: string | null }> = []
service.on('updated', (state) => states.push(state))
await (service as unknown as InternalSuggestionService)._generate(PREFIX, context, 3, 240)
const published = states.find((state) => state.candidates.length > 0)
// partialText 는 후보 공개와 함께 비워지지만, generating 은 계속 true 로 남는다 —
// 첫 후보 공개 뒤 채우기 루프가 백그라운드에서 나머지(최대 12개)를 마저
// 청하는 중이라는 신호다(설계).
expect(published).toMatchObject({ generating: true, partialText: null })
})
it('stale 취소는 실패 쿨다운을 올리거나 즉시 재시작하지 않고, 보여줄 후보가 없으면 오버레이를 지운다', async () => {
localLlm.streamGenerate.mockImplementation((_text: string, options: { signal?: AbortSignal }) =>
waitForAbort(options.signal)
)
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as InternalSuggestionService
const cleared: string[] = []
service.on('cleared', ({ reason }) => cleared.push(reason))
const generation = internal._generate(PREFIX, context, 3, 240)
await Promise.resolve()
internal._abortStaleGeneration('완전히 다른 문맥으로 바뀐 입력입니다')
await generation
expect(internal._consecutiveFailures).toBe(0)
expect(internal._cooldownUntil).toBe(0)
expect(localLlm.streamGenerate).toHaveBeenCalledTimes(1)
// 스피너만 뜬 채로 남지 않도록, 후보가 없는 stale 취소는 오버레이를 닫는다.
expect(cleared).toEqual(['stale'])
})
it('stale 취소는 속도 제한 예산을 환급해 다음 요청이 rate-limited 되지 않는다', async () => {
localLlm.streamGenerate.mockImplementation((_text: string, options: { signal?: AbortSignal }) =>
waitForAbort(options.signal)
)
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as InternalSuggestionService & {
_minuteCount: number
_dayCount: number
_prevRequestAt: number
_lastSkipReason: string | null
}
// 분당 카운터 창을 먼저 굳힌다 — 그렇지 않으면 이 인스턴스의 첫 getState() 호출
// (_generate 내부의 emit('updated', ...) 에서 일어난다) 이 창을 "지금" 으로
// 다시 잡으며 방금 늘린 카운트를 0으로 되돌린다 (실제 흐름에선 handleTypingContext
// 가 먼저 창을 굳혀 두므로 일어나지 않는 순서 문제).
service.getState()
const generation = internal._generate(PREFIX, context, 3, 240)
await Promise.resolve()
expect(internal._minuteCount).toBe(1)
const requestedAt = internal._lastRequestAt
expect(requestedAt).toBeGreaterThan(0)
internal._abortStaleGeneration('완전히 다른 문맥으로 바뀐 입력입니다')
await generation
// 취소된 요청이 쓴 예산이 되돌아간다.
expect(internal._minuteCount).toBe(0)
expect(internal._lastRequestAt).toBe(internal._prevRequestAt)
expect(internal._lastRequestAt).toBeLessThan(requestedAt)
// 되돌아간 예산으로 바로 다음 요청은 rate-limited 로 막히지 않는다.
service.handleTypingContext({ ...context, idleMs: 1000 })
expect(internal._lastSkipReason).not.toBe('rate-limited')
})
it('마지막 후보에서 아직 더 만드는 중이면 next 는 제자리, 다 만들었으면 처음으로 돌아간다', async () => {
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as {
_candidates: Array<{ text: string; rank: number }>
_filling: boolean
}
internal._candidates = Array.from({ length: 4 }, (_v, i) => ({ text: `후보${i}`, rank: i }))
for (let i = 0; i < 3; i += 1) service.next()
// 3번째(0-based 3)에서 ↓ — 4번째 칸이 곧 페이지 2 로 넘어간 상태다.
expect(service.getState().activeIndex).toBe(3)
internal._filling = true
service.next()
expect(service.getState().activeIndex).toBe(3)
internal._filling = false
service.next()
expect(service.getState().activeIndex).toBe(0)
})
it('next/previous는 페이지와 무관하게 전체 후보를 가로질러 순환한다', async () => {
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as { _candidates: Array<{ text: string; rank: number }> }
internal._candidates = Array.from({ length: 4 }, (_v, i) => ({ text: `후보${i}`, rank: i }))
service.next()
service.next()
service.next()
expect(service.getState().activeIndex).toBe(3)
service.next()
expect(service.getState().activeIndex).toBe(0)
service.previous()
expect(service.getState().activeIndex).toBe(3)
})
it('watchdog는 실제 요청 signal을 abort하고 세대를 무효화한다', async () => {
let signal: AbortSignal | undefined
localLlm.streamGenerate.mockImplementation((_text: string, options: { signal?: AbortSignal }) => {
signal = options.signal
return waitForAbort(options.signal)
})
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as InternalSuggestionService
const cleared: string[] = []
service.on('cleared', ({ reason }) => cleared.push(reason))
const generation = internal._generate(PREFIX, context, 3, 240)
await Promise.resolve()
internal._lastRequestAt = Date.now() - 13001
internal._watchdog()
await generation
expect(signal?.aborted).toBe(true)
expect(internal._inFlight).toBe(false)
expect(internal._consecutiveFailures).toBe(0)
expect(cleared).toEqual([])
})
})
describe('SuggestionService 세션 채우기 (최대 12개, 순차 · 페이지)', () => {
it('첫 요청은 1개만 청하고, 성공하면 채우기 루프가 하나씩 최대 12개까지 채운다', async () => {
// 접두/확장 중복 판정 때문에 숫자 접미사(1, 10, 11…)는 서로를 중복으로 오판한다
// ("이어지는 문장 1" 이 "이어지는 문장 10" 의 접두이므로) — 서로소인 글자를 쓴다.
// 영문 한 글자("A")는 원문에 없는 식별자로 보고 사실 검사가 버리므로 한글을 쓴다.
const LETTERS = '가나다라마바사아자차카타'
let call = 0
localLlm.streamGenerate.mockImplementation(async function* () {
const letter = LETTERS[call % LETTERS.length]
call += 1
yield `이어지는 문장 ${letter}`
})
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as InternalSuggestionService
await internal._generate(PREFIX, context, 3, 240)
// 세션의 첫 요청은 정확히 1개만 청한다 (한꺼번에 여러 개를 청하면 느리다 — 사용자 요청).
// gemma 는 원형 템플릿 prefill 이어 쓰기 — 모델 차례에 사용자 글을 넣어 한 문장만 잇게 한다.
expect(localLlm.streamGenerate).toHaveBeenCalledWith(
expect.stringContaining('<|turn>model\n'),
expect.objectContaining({ raw: true, stop: expect.arrayContaining(['<turn|>']) })
)
await vi.waitFor(() => {
expect(service.getState().candidates).toHaveLength(12)
})
expect(service.getState().generating).toBe(false)
expect(service.getState().targetTotal).toBe(12)
expect(localLlm.streamGenerate).toHaveBeenCalledTimes(12)
})
it('연속 2번 새 후보가 없으면(전부 중복) 채우기를 멈춘다', async () => {
localLlm.streamGenerate.mockImplementation(async function* () {
yield '같은 문장입니다.'
})
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as InternalSuggestionService
await internal._generate(PREFIX, context, 3, 240)
await vi.waitFor(() => {
expect(service.getState().generating).toBe(false)
})
expect(service.getState().candidates).toHaveLength(1)
// 첫 요청 1번 + 중복으로 끝난 채우기 시도 2번 = 3번.
expect(localLlm.streamGenerate).toHaveBeenCalledTimes(3)
})
it('중복(완전 일치·접두/확장)은 건너뛰고 고유한 후보만 덧붙인다', async () => {
const sequence = ['같은 문장입니다.', '같은 문장입니다.', '다른 문장입니다.']
let call = 0
localLlm.streamGenerate.mockImplementation(async function* () {
const text = sequence[Math.min(call, sequence.length - 1)]
call += 1
yield text
})
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as InternalSuggestionService
await internal._generate(PREFIX, context, 3, 240)
await vi.waitFor(() => {
expect(service.getState().generating).toBe(false)
})
expect(service.getState().candidates.map((c) => c.text)).toEqual([
'같은 문장입니다.',
'다른 문장입니다.'
])
})
it('dismiss는 진행 중인 채우기 요청을 취소하고 루프를 멈춘다', async () => {
let fillSignal: AbortSignal | undefined
let firstServed = false
localLlm.streamGenerate.mockImplementation((_text: string, options: { signal?: AbortSignal }) => {
if (!firstServed) {
firstServed = true
return (async function* () {
yield '첫 후보입니다.'
})()
}
fillSignal = options.signal
return waitForAbort(options.signal)
})
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as InternalSuggestionService
await internal._generate(PREFIX, context, 3, 240)
await vi.waitFor(() => expect(fillSignal).toBeDefined())
expect(fillSignal?.aborted).toBe(false)
service.dismiss('dismissed')
expect(fillSignal?.aborted).toBe(true)
expect(service.getState().candidates).toHaveLength(0)
})
it('세션의 첫 요청만 분당/일일 예산을 쓴다 — 채우기 요청은 쓰지 않는다', async () => {
const LETTERS = '가나다라마바사아자차카타'
let call = 0
localLlm.streamGenerate.mockImplementation(async function* () {
const letter = LETTERS[call % LETTERS.length]
call += 1
yield `문장 ${letter}`
})
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as InternalSuggestionService & {
_minuteCount: number
_dayCount: number
}
// 분당 카운터 창을 먼저 굳힌다 (다른 테스트와 같은 이유 — 위 주석 참조).
service.getState()
await internal._generate(PREFIX, context, 3, 240)
await vi.waitFor(() => expect(service.getState().candidates).toHaveLength(12))
expect(internal._minuteCount).toBe(1)
expect(internal._dayCount).toBe(1)
})
it('세션이 떠 있는 동안 접두가 자라면(다음 문장 시작) 즉시 세션을 끝낸다', async () => {
localLlm.streamGenerate.mockImplementation(async function* () {
yield '첫 후보입니다.'
})
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as InternalSuggestionService
const cleared: string[] = []
service.on('cleared', ({ reason }) => cleared.push(reason))
await internal._generate(PREFIX, context, 3, 240)
await vi.waitFor(() => expect(service.getState().visible).toBe(true))
service.handleTypingContext({ ...context, prefix: `${PREFIX} 추가로 입력했습니다`, idleMs: 1000 })
expect(service.getState().visible).toBe(false)
expect(cleared).toContain('stale')
})
it('세션이 떠 있는 동안 마지막 글자만 IME 조합으로 바뀌면 세션을 유지한다', async () => {
localLlm.streamGenerate.mockImplementation(async function* () {
yield '첫 후보입니다.'
})
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const service = getSuggestionService()
const internal = service as unknown as InternalSuggestionService
const cleared: string[] = []
service.on('cleared', ({ reason }) => cleared.push(reason))
await internal._generate(PREFIX, context, 3, 240)
await vi.waitFor(() => expect(service.getState().visible).toBe(true))
const mutatedLastChar = `${PREFIX.slice(0, -1)}요`
service.handleTypingContext({ ...context, prefix: mutatedLastChar, idleMs: 1000 })
expect(service.getState().visible).toBe(true)
expect(cleared).not.toContain('stale')
})
})
describe('SuggestionService 터미널 문맥 (Claude Code 입력 상자)', () => {
const screen = (input: string): string =>
['● 이전 답변 출력', '╭──────────────╮', `│ > ${input}`, '╰──────────────╯', ' ⏵⏵ bypass permissions on · 1 shell'].join('\n')
it('입력 상자 아래 상태줄 때문에 텔레메트리가 caret 미상이라 해도, 입력 줄 끝에서 치는 중이면 커서를 믿는다', async () => {
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const internal = getSuggestionService() as unknown as {
_terminalContext(input: typeof context & { caretReliable?: boolean }): typeof context & { caretReliable?: boolean }
}
const base = { ...context, appName: 'WindowsTerminal.exe', caretReliable: false }
const first = internal._terminalContext({ ...base, fullText: screen('제안 창이 왜') })
expect(first.prefix).toBe('제안 창이 왜')
expect(first.caretReliable).toBe(true)
// 끝에서 더 침 / 끝에서 지움 → 믿는다
expect(internal._terminalContext({ ...base, fullText: screen('제안 창이 왜 잘') }).caretReliable).toBe(true)
expect(internal._terminalContext({ ...base, fullText: screen('제안 창이 왜') }).caretReliable).toBe(true)
// 중간을 고친 모양 → 막는다
expect(internal._terminalContext({ ...base, fullText: screen('추천 창이 왜') }).caretReliable).toBe(false)
// 입력 줄을 못 찾으면 제안하지 않는다
expect(internal._terminalContext({ ...base, fullText: '빌드 출력만 있음' }).caretReliable).toBe(false)
})
it('빈 입력칸에 한꺼번에 나타난 회색 추천 문구는 사용자 글로 보지 않는다 — 치기 시작하면 다시 믿는다', async () => {
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const internal = getSuggestionService() as unknown as {
_terminalContext(input: typeof context & { caretReliable?: boolean }): typeof context & { caretReliable?: boolean }
}
const base = { ...context, appName: 'WindowsTerminal.exe', caretReliable: false }
expect(internal._terminalContext({ ...base, fullText: screen('') }).caretReliable).toBe(true)
// 빈 칸 → 29자 추천 문구가 한 번에 (그대로 머물러도 계속 믿지 않는다)
expect(internal._terminalContext({ ...base, fullText: screen('run the full desktop test suite') }).caretReliable).toBe(false)
expect(internal._terminalContext({ ...base, fullText: screen('run the full desktop test suite') }).caretReliable).toBe(false)
// 사용자가 치기 시작하면 추천 문구가 사라지고 친 글만 남는다
expect(internal._terminalContext({ ...base, fullText: screen('해') }).caretReliable).toBe(true)
expect(internal._terminalContext({ ...base, fullText: screen('해봤어') }).caretReliable).toBe(true)
})
it('한글 조합으로 마지막 글자가 바뀌어도(늘지 않아도) 끝에서 치는 중으로 보고, 멈춘 뒤에도 유지한다', async () => {
const { getSuggestionService } = await import('../../../src/main/services/SuggestionService')
const internal = getSuggestionService() as unknown as {
_terminalContext(input: typeof context & { caretReliable?: boolean }): typeof context & { caretReliable?: boolean }
}
const base = { ...context, appName: 'WindowsTerminal.exe', caretReliable: false }
internal._terminalContext({ ...base, fullText: screen('') })
expect(internal._terminalContext({ ...base, fullText: screen('오늘 회의 자') }).caretReliable).toBe(true)
expect(internal._terminalContext({ ...base, fullText: screen('오늘 회의 잘') }).caretReliable).toBe(true)
expect(internal._terminalContext({ ...base, fullText: screen('오늘 회의 자료') }).caretReliable).toBe(true)
// 멈춤 — 같은 입력 줄이 계속 와도 믿음을 유지한다
expect(internal._terminalContext({ ...base, fullText: screen('오늘 회의 자료') }).caretReliable).toBe(true)
// 긴 글 붙여넣기(빈 칸이 아닌 곳에서 끝에 덧붙임)도 끝에서 친 것이다
expect(internal._terminalContext({ ...base, fullText: screen('오늘 회의 자료 정리해서 내일 오전까지 공유') }).caretReliable).toBe(true)
})
})