refactor(suggestion): drive suggestion decisions from one core step and split SuggestionService collaborators

2026-09-28 00:53:42 +09:00 · 2026-09-28 00:53:42 +09:00 · 190b6db284
commit 190b6db284
parent 9aa7302944
13 changed files with 1994 additions and 496 deletions
--- a/apps/desktop/tests/main/services/suggestion-redteam-r1-1.test.ts
+++ b/apps/desktop/tests/main/services/suggestion-redteam-r1-1.test.ts
@ -0,0 +1,415 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const config = vi.hoisted(() => ({
+  suggestionEnabled: true as boolean,
+  suggestionModelId: 'model-a' as string | null,
+  llmModelId: 'model-a' as string | null,
+  inputExcludedApps: [] as string[],
+  suggestionTriggerDelayMs: 600,
+  suggestionMinPrefixChars: 8,
+  suggestionMaxRequestsPerMinute: 12,
+  suggestionDailyBudget: 500,
+  suggestionRequestTimeoutMs: 8000,
+  inputLearnTypedText: false,
+  inputTelemetryEnabled: false,
+  suggestionOverlayInteractive: true,
+  insertMethod: 'clipboard'
+}))
+const harness = vi.hoisted(() => ({
+  isAvailable: vi.fn(() => true),
+  streamGenerate: vi.fn(),
+  insertText: vi.fn(async (text: string) => ({ success: true, method: 'clipboard', textLength: text.length })),
+  continuations: [] as string[]
+}))
+
+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: () => ({ isAvailable: harness.isAvailable, streamGenerate: harness.streamGenerate })
+}))
+vi.mock('../../../src/main/services/InputTelemetryService', () => ({
+  getInputTelemetryService: () => ({ listPhrases: () => [] })
+}))
+vi.mock('../../../src/main/services/PersonalGraphService', () => ({
+  getPersonalGraphService: () => ({
+    retrieveContext: () => ({ continuations: harness.continuations, related: [] })
+  })
+}))
+vi.mock('../../../src/main/services/TextInsertService', () => ({
+  getTextInsertService: () => ({ insertText: harness.insertText })
+}))
+vi.mock('../../../src/main/services/modifier-state', () => ({ waitForModifiersReleased: async () => true }))
+vi.mock('../../../src/main/utils/win32-foreground', () => ({ getForegroundWindowInfo: () => null }))
+vi.mock('../../../src/main/db', () => ({ getDatabase: vi.fn() }))
+vi.mock('../../../src/main/db/schema', () => ({ suggestions: {} }))
+
+import { SuggestionService, type SuggestionServiceDeps } from '../../../src/main/services/SuggestionService'
+import { SuggestionBudget } from '../../../src/main/services/suggestion/SuggestionBudget'
+import { ModelWarmTracker } from '../../../src/main/services/suggestion/ModelWarmTracker'
+import type { TypingContext } from '../../../src/main/services/InputTelemetryService'
+
+const SHORT_PREFIX = '오늘 회의에서 논의한 내용을 정리해서'
+const LONG_PREFIX = `${'가나다라 '.repeat(100)}${SHORT_PREFIX}`
+
+function typingContext(overrides: Partial<TypingContext> = {}): TypingContext {
+  const prefix = overrides.prefix ?? SHORT_PREFIX
+  return {
+    prefix,
+    fullText: prefix,
+    caretOffset: prefix.length,
+    anchor: null,
+    anchorKind: null,
+    isPassword: false,
+    isEditable: true,
+    isComposing: false,
+    hasSelection: false,
+    available: true,
+    appName: 'chrome.exe',
+    windowTitle: 'Gmail',
+    windowHandle: 101,
+    idleMs: 2000,
+    capturedAt: Date.now(),
+    editedSinceFocus: true,
+    typedRecently: true,
+    ...overrides
+  }
+}
+
+interface Fakes {
+  deps: SuggestionServiceDeps
+  record: ReturnType<typeof vi.fn>
+  foregroundHandle: { value: number | null }
+  expectInsert: ReturnType<typeof vi.fn>
+  cancelInsert: ReturnType<typeof vi.fn>
+  recordAccepted: ReturnType<typeof vi.fn>
+}
+
+function fakes(): Fakes {
+  const record = vi.fn()
+  const foregroundHandle = { value: 101 as number | null }
+  const cancelInsert = vi.fn()
+  const expectInsert = vi.fn(() => cancelInsert)
+  const recordAccepted = vi.fn()
+  return {
+    record,
+    foregroundHandle,
+    expectInsert,
+    cancelInsert,
+    recordAccepted,
+    deps: {
+      repository: { record, markAccepted: vi.fn(), list: vi.fn(() => []) },
+      budget: new SuggestionBudget(),
+      warmth: new ModelWarmTracker(),
+      foreground: { currentWindowHandle: () => foregroundHandle.value },
+      learning: { expectProgrammaticInsert: expectInsert, recordAccepted }
+    }
+  }
+}
+
+function streamOf(text: string) {
+  return (async function* () {
+    yield text
+  })()
+}
+
+let services: SuggestionService[] = []
+function create(deps: SuggestionServiceDeps): SuggestionService {
+  const service = new SuggestionService(deps)
+  services.push(service)
+  return service
+}
+
+interface Internal {
+  _generate(prefix: string, context: TypingContext, maxCandidates: number, maxChars: number): Promise<void>
+  _warmUpPromise: Promise<void> | null
+  _lastSkipReason: string | null
+}
+
+beforeEach(() => {
+  config.suggestionEnabled = true
+  config.suggestionModelId = 'model-a'
+  config.llmModelId = 'model-a'
+  harness.isAvailable.mockReset()
+  harness.isAvailable.mockReturnValue(true)
+  harness.streamGenerate.mockReset()
+  harness.insertText.mockClear()
+  harness.continuations = []
+})
+
+afterEach(() => {
+  for (const service of services) service.dispose()
+  services = []
+  vi.useRealTimers()
+})
+
+describe('버그 1: 400자 넘는 접두에서 세션이 stale 로 닫히지 않는다', () => {
+  it('같은 긴 접두의 다음 스냅샷에서도 세션이 유지되고 재생성하지 않는다', async () => {
+    harness.streamGenerate.mockImplementation(() => streamOf('다음 단계도 확인하겠습니다.'))
+    const { deps } = fakes()
+    deps.warmth.noteWarm('model-a', Date.now() + 600_000)
+    const service = create(deps)
+    const internal = service as unknown as Internal
+    const context = typingContext({ prefix: LONG_PREFIX })
+    expect(LONG_PREFIX.length).toBeGreaterThan(400)
+
+    await internal._generate(LONG_PREFIX, context, 3, 160)
+    expect(service.isVisible).toBe(true)
+
+    service.handleTypingContext(context)
+
+    expect(service.isVisible).toBe(true)
+    expect(service.getState().lastSkipReason).not.toBe('stale')
+    // 세션이 유지되므로 새 첫 요청(예산 소비)이 일어나지 않는다.
+    expect(deps.budget.minuteCount).toBe(1)
+  })
+
+  it('긴 접두에서도 이어 치면 세션을 끝낸다', async () => {
+    harness.streamGenerate.mockImplementation(() => streamOf('다음 단계도 확인하겠습니다.'))
+    const { deps } = fakes()
+    deps.warmth.noteWarm('model-a', Date.now() + 600_000)
+    const service = create(deps)
+    await (service as unknown as Internal)._generate(LONG_PREFIX, typingContext({ prefix: LONG_PREFIX }), 3, 160)
+
+    service.handleTypingContext(typingContext({ prefix: `${LONG_PREFIX} 그리고`, idleMs: 100 }))
+
+    expect(service.isVisible).toBe(false)
+    expect(service.getState().lastSkipReason).toBe('stale')
+  })
+})
+
+describe('버그 2: 쿨다운 중 표시된 로컬 기억 세션', () => {
+  function coolingService(): { service: SuggestionService; fake: Fakes } {
+    const fake = fakes()
+    fake.deps.budget.noteFailure(Date.now())
+    fake.deps.budget.noteFailure(Date.now())
+    expect(fake.deps.budget.isCoolingDown(Date.now())).toBe(true)
+    harness.continuations = ['첫 번째 이어쓰기 문장입니다', '두 번째 이어쓰기 문장입니다']
+    const service = create(fake.deps)
+    service.handleTypingContext(typingContext())
+    expect(service.getState()).toMatchObject({ visible: true, provenance: { mode: 'local-memory' } })
+    expect(fake.record).toHaveBeenCalledTimes(1)
+    return { service, fake }
+  }
+
+  it('다음 후보 단축키(키 입력 직후 스냅샷)로 세션이 닫히지 않는다', () => {
+    const { service } = coolingService()
+    service.next()
+    service.handleTypingContext(typingContext({ idleMs: 100 }))
+    expect(service.getState()).toMatchObject({ visible: true, activeIndex: 1 })
+  })
+
+  it('멈춘 상태의 주기 스냅샷이 선택을 초기화하거나 이력을 중복 기록하지 않는다', () => {
+    const { service, fake } = coolingService()
+    service.next()
+    service.handleTypingContext(typingContext({ idleMs: 2000 }))
+    service.handleTypingContext(typingContext({ idleMs: 2800 }))
+    expect(service.getState().activeIndex).toBe(1)
+    expect(fake.record).toHaveBeenCalledTimes(1)
+  })
+
+  it('타이핑이 끊긴 뒤(not-typing)에도 읽는 중인 세션을 닫지 않는다', () => {
+    const { service } = coolingService()
+    service.handleTypingContext(typingContext({ typedRecently: false, idleMs: 9000 }))
+    expect(service.isVisible).toBe(true)
+  })
+
+  it('비밀번호 칸으로 옮기면 쿨다운 중에도 닫는다', () => {
+    const { service } = coolingService()
+    service.handleTypingContext(typingContext({ isPassword: true }))
+    expect(service.isVisible).toBe(false)
+  })
+})
+
+describe('버그 4: 모델 변경 뒤 콜드 모델로 바로 생성하지 않는다', () => {
+  it('이전 모델이 warm 이어도 새 모델은 워밍업부터 한다', async () => {
+    harness.streamGenerate.mockImplementation(() => streamOf('ok'))
+    const { deps } = fakes()
+    deps.warmth.noteWarm('model-a', Date.now() + 600_000)
+    const service = create(deps)
+    const internal = service as unknown as Internal
+    const generateSpy = vi.spyOn(internal, '_generate')
+
+    config.suggestionModelId = 'model-b'
+    service.handleTypingContext(typingContext())
+
+    expect(generateSpy).not.toHaveBeenCalled()
+    expect(harness.streamGenerate).toHaveBeenCalledWith('hi', expect.objectContaining({ model: 'model-b', maxTokens: 1 }))
+    expect(service.getState().lastSkipReason).toBe('model-unavailable')
+    await internal._warmUpPromise
+    expect(deps.warmth.isWarm('model-b', Date.now())).toBe(true)
+  })
+
+  it('handleModelChanged 는 새 콜드 모델을 미리 워밍업한다', async () => {
+    harness.streamGenerate.mockImplementation(() => streamOf('ok'))
+    const { deps } = fakes()
+    deps.warmth.noteWarm('model-a', Date.now() + 600_000)
+    const service = create(deps)
+
+    service.handleModelChanged()
+    expect(harness.streamGenerate).not.toHaveBeenCalled()
+
+    config.suggestionModelId = 'model-b'
+    service.handleModelChanged()
+    await (service as unknown as Internal)._warmUpPromise
+    expect(harness.streamGenerate).toHaveBeenCalledTimes(1)
+    expect(harness.streamGenerate).toHaveBeenCalledWith('hi', expect.objectContaining({ model: 'model-b' }))
+  })
+})
+
+describe('버그 5: 실패한 워밍업은 실패로 센다', () => {
+  it('워밍업 실패 뒤 다음 멈춤에서 워밍업을 바로 다시 쏘지 않고, 두 번째 실패로 쿨다운에 들어간다', async () => {
+    vi.useFakeTimers()
+    harness.streamGenerate.mockImplementation(() =>
+      (async function* () {
+        throw new Error('Ollama responded with 404')
+      })()
+    )
+    const { deps } = fakes()
+    const service = create(deps)
+    const internal = service as unknown as Internal
+
+    service.handleTypingContext(typingContext())
+    await internal._warmUpPromise
+    expect(harness.streamGenerate).toHaveBeenCalledTimes(1)
+    expect(deps.budget.consecutiveFailures).toBe(1)
+    expect(service.getState().lastSkipReason).toBe('generation-failed')
+
+    // 800ms 뒤 샘플 — 실패 직후라 워밍업을 다시 쏘지 않는다.
+    vi.advanceTimersByTime(800)
+    service.handleTypingContext(typingContext())
+    expect(harness.streamGenerate).toHaveBeenCalledTimes(1)
+    expect(service.getState()).toMatchObject({ warmingUp: false, lastSkipReason: 'generation-failed' })
+
+    // 물러서기 시간이 지나면 한 번 더 시도하고, 그 실패로 쿨다운에 들어간다.
+    vi.advanceTimersByTime(5000)
+    service.handleTypingContext(typingContext())
+    await internal._warmUpPromise
+    expect(harness.streamGenerate).toHaveBeenCalledTimes(2)
+    expect(deps.budget.isCoolingDown(Date.now())).toBe(true)
+    expect(service.getState().coolingDown).toBe(true)
+  })
+})
+
+describe('버그 6: 수락 직전 대상 창 확인', () => {
+  async function visibleService(fake: Fakes): Promise<SuggestionService> {
+    harness.streamGenerate.mockImplementation(() => streamOf('다음 단계도 확인하겠습니다.'))
+    fake.deps.warmth.noteWarm('model-a', Date.now() + 600_000)
+    const service = create(fake.deps)
+    await (service as unknown as Internal)._generate(SHORT_PREFIX, typingContext({ windowHandle: 101 }), 3, 160)
+    expect(service.isVisible).toBe(true)
+    return service
+  }
+
+  it('포커스가 다른 창으로 옮겨 갔으면 붙여넣지 않는다', async () => {
+    const fake = fakes()
+    const service = await visibleService(fake)
+    fake.foregroundHandle.value = 202
+
+    const result = await service.accept()
+
+    expect(result).toEqual({ ok: false, reason: 'stale' })
+    expect(harness.insertText).not.toHaveBeenCalled()
+    expect(fake.expectInsert).not.toHaveBeenCalled()
+  })
+
+  it('같은 창이면 삽입하고, 삽입 예고와 수락 학습을 한 번씩 알린다', async () => {
+    const fake = fakes()
+    const service = await visibleService(fake)
+
+    const result = await service.accept()
+
+    expect(result).toEqual({ ok: true })
+    expect(harness.insertText).toHaveBeenCalledWith('다음 단계도 확인하겠습니다.', 'clipboard')
+    expect(fake.expectInsert).toHaveBeenCalledWith('다음 단계도 확인하겠습니다.')
+    expect(fake.recordAccepted).toHaveBeenCalledTimes(1)
+    expect(fake.cancelInsert).not.toHaveBeenCalled()
+  })
+
+  it('삽입이 실패하면 삽입 예고를 취소한다', async () => {
+    const fake = fakes()
+    const service = await visibleService(fake)
+    harness.insertText.mockResolvedValueOnce({ success: false, method: 'clipboard', textLength: 0 })
+
+    const result = await service.accept()
+
+    expect(result.ok).toBe(false)
+    expect(fake.cancelInsert).toHaveBeenCalledTimes(1)
+    expect(fake.recordAccepted).not.toHaveBeenCalled()
+  })
+
+  it('창을 알 수 없으면(포그라운드 조회 실패) 기존처럼 삽입한다', async () => {
+    const fake = fakes()
+    const service = await visibleService(fake)
+    fake.foregroundHandle.value = null
+
+    expect(await service.accept()).toEqual({ ok: true })
+  })
+})
+
+describe('SuggestionBudget', () => {
+  it('consume 은 창을 먼저 굴린다 — 오래 쉰 뒤의 요청도 예산에 잡힌다', () => {
+    const budget = new SuggestionBudget()
+    const t0 = new Date(2026, 8, 28, 10, 0, 0).getTime()
+    budget.consume(t0)
+    const later = t0 + 120_000
+    budget.consume(later)
+    // 직후의 상태 조회(창 굴리기)가 방금 소비를 지우면 안 된다.
+    expect(budget.snapshot(later + 10)).toMatchObject({ requestsThisMinute: 1, requestsToday: 2 })
+  })
+
+  it('창이 바뀐 뒤의 환급은 새 창의 카운트를 깎지 않는다', () => {
+    const budget = new SuggestionBudget()
+    const t0 = new Date(2026, 8, 28, 10, 0, 0).getTime()
+    budget.consume(t0)
+    budget.consume(t0 + 61_000)
+    budget.snapshot(t0 + 61_000)
+    budget.consume(t0 + 62_000)
+    budget.refund()
+    expect(budget.snapshot(t0 + 62_000)).toMatchObject({ requestsThisMinute: 1 })
+    expect(budget.lastRequestAt).toBe(t0 + 61_000)
+
+    const other = new SuggestionBudget()
+    other.consume(t0)
+    other.snapshot(t0 + 61_000)
+    other.refund()
+    expect(other.minuteCount).toBe(0)
+    expect(other.dayCount).toBe(0)
+  })
+
+  it('연속 실패 임계에서 쿨다운, 성공이면 초기화, relaxInterval 은 최소 간격만 푼다', () => {
+    const budget = new SuggestionBudget({ failureCooldownThreshold: 2, failureCooldownMs: 60_000 })
+    expect(budget.noteFailure(1000)).toBe(false)
+    expect(budget.noteFailure(2000)).toBe(true)
+    expect(budget.isCoolingDown(61_999)).toBe(true)
+    expect(budget.isCoolingDown(62_000)).toBe(false)
+    budget.noteSuccess()
+    expect(budget.isCoolingDown(3000)).toBe(false)
+
+    budget.consume(100_000)
+    budget.relaxInterval(101_000, 5000)
+    expect(budget.snapshot(101_000)).toMatchObject({ sinceLastRequestMs: 5000, requestsThisMinute: 1 })
+  })
+})
+
+describe('ModelWarmTracker', () => {
+  it('온기와 워밍업 실패를 모델별로 기억한다', () => {
+    const tracker = new ModelWarmTracker()
+    tracker.noteWarm('a', 10_000)
+    expect(tracker.isWarm('a', 9_999)).toBe(true)
+    expect(tracker.isWarm('a', 10_000)).toBe(false)
+    expect(tracker.isWarm('b', 5_000)).toBe(false)
+    expect(tracker.isWarm(null, 5_000)).toBe(false)
+
+    tracker.noteWarmUpFailure('b', 1_000)
+    expect(tracker.isBackingOff('b', 5_999, 5_000)).toBe(true)
+    expect(tracker.isBackingOff('b', 6_000, 5_000)).toBe(false)
+    expect(tracker.isBackingOff('a', 2_000, 5_000)).toBe(false)
+    tracker.noteWarm('b', 20_000)
+    expect(tracker.isBackingOff('b', 2_000, 5_000)).toBe(false)
+  })
+})