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
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.
1845 lines
77 KiB
TypeScript
1845 lines
77 KiB
TypeScript
// src/main/services/SuggestionService.ts
|
||
//
|
||
// 다음 문장 제안(ghost text) — 입력 맥락을 받아 gemma(Ollama)로 후보를 만들고,
|
||
// 수락 시 대상 앱에 삽입한다.
|
||
//
|
||
// 설계 근거 (2025~2026 인라인 컴플리션 실측):
|
||
// - 디바운스는 타이핑 정지 후 600ms(기본)로, 모델 호출 빈도를 보수적으로 제한한다.
|
||
// - 출력 토큰은 극단적으로 작게(기본 64, Tabby 64 / KeyType 4~16) —
|
||
// 인라인 제안은 스트리밍으로 빨리 보여주고 짧게 끊는 것이 정석이다.
|
||
// - 문맥이 stale 이 된 진행 중 생성만 호출자 시그널로 취소하고, 다음 입력 문맥에서 재평가한다.
|
||
// - 후보가 나온 접두와 현재 접두가 달라지면 그 즉시 오버레이를 지운다 (stale).
|
||
|
||
import { EventEmitter } from 'events'
|
||
import {
|
||
SUGGESTION_DEFAULTS,
|
||
SUGGESTION_MAX_OUTPUT_CHARS,
|
||
buildLocalSuggestionCandidateEntries,
|
||
decideInFlightGeneration,
|
||
decideSuggestion,
|
||
decideSuggestionStep,
|
||
isAppExcluded,
|
||
joinSuggestion,
|
||
matchesSessionPrefix,
|
||
normalizeRequestPrefix,
|
||
normalizeSessionPrefix,
|
||
parseSuggestionCandidates,
|
||
sanitizeSuggestionLine,
|
||
selectPhraseHints,
|
||
shouldPersistSuggestionPrefix,
|
||
isTerminalApp,
|
||
extractContinuation,
|
||
extractTerminalPromptPrefix,
|
||
type AnchorKind,
|
||
type PhysicalRect,
|
||
type SuggestionCandidate,
|
||
type SuggestionPolicyInput,
|
||
type SuggestionProvenance,
|
||
type SuggestionSkipReason,
|
||
type SuggestionState,
|
||
type SuggestionStep
|
||
} from '@d3ro/core/input-intelligence'
|
||
import { renderRawChatPrompt, rawChatStopSequences } from '@d3ro/core/chat-template'
|
||
import { buildQueryTerms, splitSentences } from '@d3ro/core/personal-graph'
|
||
import { analyzeWritingContext, findUnsupportedFacts } from '@d3ro/core/writing-context'
|
||
import { configGet, configSet } from './ConfigService'
|
||
import { getLogger } from './LoggerService'
|
||
import { getLocalLLMService } from './LocalLLMService'
|
||
import { buildSuggestionPrompt } from './llm-prompts'
|
||
import { getInputTelemetryService, type TypingContext } from './InputTelemetryService'
|
||
import { getPersonalGraphService } from './PersonalGraphService'
|
||
import { getTextInsertService } from './TextInsertService'
|
||
import { waitForModifiersReleased } from './modifier-state'
|
||
import {
|
||
createSqliteSuggestionRepository,
|
||
type SuggestionHistoryEntry,
|
||
type SuggestionRecordInput,
|
||
type SuggestionRepository
|
||
} from './SuggestionRepository'
|
||
import { SuggestionBudget } from './suggestion/SuggestionBudget'
|
||
import { ModelWarmTracker } from './suggestion/ModelWarmTracker'
|
||
import { LOCAL_LLM_KEEP_ALIVE, LOCAL_LLM_KEEP_ALIVE_MS } from './llm/model-residency'
|
||
import { getForegroundWindowInfo } from '../utils/win32-foreground'
|
||
|
||
const logger = getLogger('SuggestionService')
|
||
|
||
export type { SuggestionHistoryEntry }
|
||
|
||
/** 지금 포그라운드 창을 알려 주는 포트 — 수락 직전 대상 창 확인에 쓴다. */
|
||
export interface SuggestionForegroundProbe {
|
||
currentWindowHandle(): number | null
|
||
}
|
||
|
||
/** 수락한 텍스트를 학습 쪽에 알리는 포트. */
|
||
export interface SuggestionLearningPort {
|
||
/** 곧 프로그램이 삽입할 텍스트 — 다음 스냅샷 diff 가 "타이핑" 으로 다시 학습하지 않게 한다. 취소 함수를 돌려준다. */
|
||
expectProgrammaticInsert(text: string): () => void
|
||
/** 수락한 문장을 사용자 문체 표본으로 기록한다 (학습 동의 시에만 저장됨). */
|
||
recordAccepted(text: string, meta: { appName: string | null; windowTitle: string | null }): void
|
||
}
|
||
|
||
/** 서비스 협력자 — 기본값은 getSuggestionService() 가 연결한다 (DIP). */
|
||
export interface SuggestionServiceDeps {
|
||
repository: SuggestionRepository
|
||
budget: SuggestionBudget
|
||
warmth: ModelWarmTracker
|
||
foreground: SuggestionForegroundProbe
|
||
learning: SuggestionLearningPort
|
||
}
|
||
|
||
export function createDefaultSuggestionServiceDeps(): SuggestionServiceDeps {
|
||
return {
|
||
repository: createSqliteSuggestionRepository(),
|
||
budget: new SuggestionBudget(),
|
||
// 상주 추정은 로컬 LLM 의 모든 요청(받아쓰기·음성 대화 포함)을 본다.
|
||
warmth: new ModelWarmTracker({ residentUntil: (model) => getLocalLLMService().residency?.residentUntil(model) ?? null }),
|
||
foreground: {
|
||
currentWindowHandle: () => getForegroundWindowInfo()?.hwnd ?? null
|
||
},
|
||
learning: {
|
||
expectProgrammaticInsert: (text) => getInputTelemetryService().expectProgrammaticInsert(text),
|
||
recordAccepted: (text, meta) =>
|
||
getInputTelemetryService().recordExternalText(text, { ...meta, source: 'suggestion' })
|
||
}
|
||
}
|
||
}
|
||
|
||
/** 설정에서 읽은 정책 값 (SSOT 기본값과 상한 적용 후). */
|
||
interface PolicyConfig {
|
||
triggerDelayMs: number
|
||
minPrefixChars: number
|
||
maxRequestsPerMinute: number
|
||
dailyBudget: number
|
||
maxCandidates: number
|
||
maxChars: number
|
||
excludedApps: string[]
|
||
}
|
||
|
||
export interface SuggestionRequestResult {
|
||
ok: boolean
|
||
reason?: SuggestionSkipReason
|
||
}
|
||
|
||
interface SuggestionEvents {
|
||
updated: (state: SuggestionState) => void
|
||
cleared: (payload: { reason: SuggestionSkipReason }) => void
|
||
'state-changed': (state: SuggestionState) => void
|
||
}
|
||
|
||
interface LocalMemoryContext {
|
||
continuationHints: string[]
|
||
/** 직전 문장 뒤에 사용자가 실제로 이어 쓴 문장 (그래프 follows) */
|
||
followUpHints: string[]
|
||
relatedHints: string[]
|
||
/** 지금 글과 용어가 겹치는(또는 같은 앱) 개인 문구 — 프롬프트용 */
|
||
phraseHints: string[]
|
||
/** 관련성과 무관한 자주 쓰는 문구 — 모델 없이 로컬 기억만으로 후보를 만들 때 뒤를 채운다 */
|
||
fallbackPhraseHints: string[]
|
||
appPhraseCount: number
|
||
}
|
||
|
||
/** 커서 뒤 텍스트 — 케어렛을 알 때만 (문서 중간에서 쓸 때 겹치지 않게). */
|
||
function suffixAfterCaret(context: TypingContext): string | null {
|
||
if (context.caretOffset === null || context.caretOffset >= context.fullText.length) return null
|
||
const suffix = context.fullText.slice(context.caretOffset, context.caretOffset + 200).trim()
|
||
return suffix.length > 0 ? suffix : null
|
||
}
|
||
|
||
/** 프롬프트의 [관련해서 사용자가 쓴 문장] — 그래프 관련 문장 먼저, 그다음 문맥과 겹치는 개인 문구. */
|
||
function relatedPromptHints(memory: LocalMemoryContext): string[] {
|
||
return [...memory.relatedHints, ...memory.phraseHints]
|
||
.filter((value, index, list) => list.indexOf(value) === index && !memory.followUpHints.includes(value))
|
||
.slice(0, 5)
|
||
}
|
||
|
||
/**
|
||
* 스냅샷 한 번(약 0.8초) 사이에 사람이 칠 수 있는 글자 수 상한. 빈 터미널 입력칸이 이보다 크게
|
||
* 한 번에 채워지면 타이핑이 아니다(Claude Code 의 회색 추천 문구).
|
||
*/
|
||
const TERMINAL_TYPING_STEP_CHARS = 8
|
||
|
||
/** 모델 출력의 모양 (길이·첫 글자 종류·줄 수) — 로그용, 내용은 담지 않는다. */
|
||
function describeRawOutput(raw: string, prefill: boolean): string {
|
||
const first = raw.charAt(0)
|
||
const kind =
|
||
raw.length === 0
|
||
? 'empty'
|
||
: first === '\n' || first === '\r'
|
||
? 'newline'
|
||
: /\s/u.test(first)
|
||
? 'space'
|
||
: /[\p{L}\p{N}]/u.test(first)
|
||
? 'letter'
|
||
: 'symbol'
|
||
return `mode=${prefill ? 'prefill' : 'instruct'} len=${raw.length} first=${kind} lines=${raw.split('\n').length}`
|
||
}
|
||
|
||
function commonPrefixLength(a: string, b: string): number {
|
||
const max = Math.min(a.length, b.length)
|
||
let index = 0
|
||
while (index < max && a[index] === b[index]) index += 1
|
||
return index
|
||
}
|
||
|
||
/** 이 길이를 넘는 모델 출력은 버린다 (스트리밍 폭주 방지) */
|
||
const MAX_RAW_OUTPUT_CHARS = 1200
|
||
|
||
/**
|
||
* 채우기 루프(2번째 이후 후보)의 온도.
|
||
*
|
||
* prefill 이어 쓰기는 분포가 뾰족해 0.8 에서도 첫 후보와 같은 문장이 자주 나왔다(실측) —
|
||
* 다른 후보를 얻으려면 더 넓게 뽑는다. 사실 검사·중복 검사가 뒤에서 거른다.
|
||
*/
|
||
const FILL_TEMPERATURE = 1.0
|
||
|
||
/** 이어 쓰기 출력이 첫 문장(또는 첫 줄)을 끝내고 다음 글자를 쓰기 시작했는가. */
|
||
const FIRST_SENTENCE_DONE = /\S[\s\S]*?(?:[.!?。!?…]["'”’)\]]*\s+\S|\n\s*\S)/u
|
||
|
||
/** 모델 요청 하나 — 프롬프트, 전송 옵션, 출력 해석기. */
|
||
interface ModelRequest {
|
||
prompt: string
|
||
systemPrompt?: string
|
||
raw: boolean
|
||
stop?: string[]
|
||
/** 완성된 출력 → 후보 (못 쓰면 null, 이유는 rejected) */
|
||
parse(raw: string): { candidate: SuggestionCandidate | null; rejected: string | null }
|
||
/** 스트리밍 중간 표시용 텍스트 */
|
||
partial(raw: string): string
|
||
}
|
||
|
||
/**
|
||
* 모델을 메모리에 유지하는 시간 — 앱 공통 값(LOCAL_LLM_KEEP_ALIVE)을 그대로 쓴다.
|
||
*
|
||
* 예전엔 콜드 리로드(11.4s) 회피용으로 30m 을 따로 썼지만, 다른 기능의 짧은 keep_alive 와
|
||
* 서로 덮어써 리로드를 오히려 부추겼고 유휴 중 RAM 11GB 를 붙잡았다. 쓰는 동안은 아래 연장으로
|
||
* 식지 않게 하고, 콜드 첫 요청은 _keepWarm 의 첫 키 입력 워밍업이 흡수한다.
|
||
*/
|
||
const SUGGESTION_KEEP_ALIVE = LOCAL_LLM_KEEP_ALIVE
|
||
const SUGGESTION_KEEP_ALIVE_MS = LOCAL_LLM_KEEP_ALIVE_MS
|
||
/**
|
||
* 타이핑 중인데 남은 유지 시간이 이보다 짧으면 1토큰 요청으로 유지 시간을 연장한다.
|
||
*
|
||
* 실측(2026-10-03): 50분 자리를 비운 뒤 돌아오자 콜드 로드에 29초가 걸려 그동안 "준비 중" 만
|
||
* 보였다(GPU 메모리 10.6/12GB — 음성 인식 모델과 함께 올라가 있어 로드가 느리다). 쓰는 동안에는
|
||
* 절대 식지 않게, 자리를 비우면 keep-alive 뒤에 내려가게 한다. keep-alive(10m)보다 충분히 작아야
|
||
* 타이핑 중 매분 연장 요청을 쏘지 않는다.
|
||
*/
|
||
const KEEP_WARM_REFRESH_MS = 4 * 60_000
|
||
/** 유지 연장 요청 최소 간격 */
|
||
const KEEP_WARM_MIN_INTERVAL_MS = 60_000
|
||
/** keep-alive 만료 직전 여유 — 경계에서 콜드 모델로 요청하지 않는다. */
|
||
const SUGGESTION_KEEP_ALIVE_MARGIN_MS = 30_000
|
||
/** 워밍업 실패 뒤 같은 모델 재시도를 미루는 시간 — 멈출 때마다 실패 요청을 쏘지 않는다. */
|
||
const WARM_UP_FAILURE_BACKOFF_MS = SUGGESTION_DEFAULTS.minIntervalMs
|
||
|
||
export class SuggestionService extends EventEmitter {
|
||
private _candidates: SuggestionCandidate[] = []
|
||
private _activeIndex = 0
|
||
/** 물리 픽셀 그대로 보관한다 — DIP 변환은 창 배치(WindowManager) 한 곳에서만 한다. */
|
||
private _anchor: PhysicalRect | null = null
|
||
/** anchor 가 케어렛인지 요소 전체인지 — 오버레이가 배치 전략을 고르는 근거 */
|
||
private _anchorKind: AnchorKind = null
|
||
private _appName: string | null = null
|
||
private _windowTitle: string | null = null
|
||
/** 후보를 만든 시점의 접두 — 접두가 달라지면 stale */
|
||
private _generatedForPrefix = ''
|
||
/** 이 세션이 채우려는 후보 총량 (모델 세션 12 / 로컬 기억 세션은 현재 개수) */
|
||
private _targetTotal = 0
|
||
private _lastSkipReason: SuggestionSkipReason | null = null
|
||
private _lastDecisionSignature = ''
|
||
/** 생성 중 — 후보 도착 전에도 오버레이를 띄운다 */
|
||
private _generating = false
|
||
/** 모델 적재 중 — UI 가 "준비 중" 을 표시한다 */
|
||
private _warmingUp = false
|
||
/**
|
||
* 생성 세대 토큰.
|
||
*
|
||
* 사용자가 제안을 닫거나 새로 시작하면 증가한다. 진행 중이던 요청이 나중에
|
||
* 끝나도 토큰이 달라졌으면 결과를 버린다 — "X 로 닫았는데 잠시 뒤 다시 뜨던"
|
||
* 문제를 막는다.
|
||
*/
|
||
private _generationToken = 0
|
||
/** 마지막 문맥 수신 시각 — 늦게 도착한 결과를 판단한다 */
|
||
private _lastContextAt = 0
|
||
/** 표시 수명 타이머 (TTL) */
|
||
private _ttlTimer: NodeJS.Timeout | null = null
|
||
/** 마지막으로 실제 요청한 접두 (같은 텍스트 반복 요청 방지) */
|
||
private _lastRequestedPrefix = ''
|
||
/** 사용자가 X 로 닫은 뒤 재표시를 막는 시각 (ms) */
|
||
private _userDismissedUntil = 0
|
||
/** 스트리밍 누적 텍스트 */
|
||
private _partialText = ''
|
||
/** 마지막 스트리밍 방출 시각 (IPC 과다 방출 방지) */
|
||
private _lastPartialEmitAt = 0
|
||
private _lastContext: TypingContext | null = null
|
||
/** 직전 터미널 입력 줄 — 끝에서 치는 중인지 판단한다 */
|
||
private _lastTerminalPrompt: string | null = null
|
||
/** 지금 터미널 입력 줄이 사용자가 끝에서 쳐 온 글인가 (회색 추천 문구·붙여넣기 덩어리가 아님) */
|
||
private _terminalPromptTyped = false
|
||
private _provenance: SuggestionProvenance | null = null
|
||
/** 세션을 만든 입력창의 최상위 창 핸들 — 수락 직전 포커스가 그대로인지 확인한다. */
|
||
private _windowHandle: number | null = null
|
||
/** 이 세션의 이력 행 id — 한 세션은 한 행이다(채우기 후보·수락은 이 행을 갱신한다). */
|
||
private _sessionRecordId: string | null = null
|
||
|
||
/** 요청 예산 (간격 · 분/일 카운트 · 실패 쿨다운) */
|
||
private readonly _budget: SuggestionBudget
|
||
/** 모델별 온기 (keep-alive) · 워밍업 실패 기록 */
|
||
private readonly _warmth: ModelWarmTracker
|
||
private readonly _repository: SuggestionRepository
|
||
private readonly _foreground: SuggestionForegroundProbe
|
||
private readonly _learning: SuggestionLearningPort
|
||
|
||
private _inFlight = false
|
||
private _abort: AbortController | null = null
|
||
/** 채우기 루프(2번째 이후 후보) 진행 중 — _inFlight 와 별개다 (예산/타임아웃 카운트 제외). */
|
||
private _filling = false
|
||
private _fillAbort: AbortController | null = null
|
||
private _timeoutTimer: NodeJS.Timeout | null = null
|
||
private _lastLatencyMs: number | null = null
|
||
private _warmUpPromise: Promise<void> | null = null
|
||
private _warmUpAbort: AbortController | null = null
|
||
private _warmUpRetryTimer: NodeJS.Timeout | null = null
|
||
private _lastKeepWarmAt = 0
|
||
|
||
constructor(deps: SuggestionServiceDeps = createDefaultSuggestionServiceDeps()) {
|
||
super()
|
||
this._budget = deps.budget
|
||
this._warmth = deps.warmth
|
||
this._repository = deps.repository
|
||
this._foreground = deps.foreground
|
||
this._learning = deps.learning
|
||
}
|
||
|
||
// ── 진단 접근자 (기존 진단·테스트가 읽는 예산 필드 이름을 유지한다) ──
|
||
// 예산 상태의 정본은 SuggestionBudget 이다. 새 코드는 _budget 을 직접 쓴다.
|
||
|
||
/** @internal */
|
||
get _lastRequestAt(): number {
|
||
return this._budget.lastRequestAt
|
||
}
|
||
|
||
/** @internal 진행 플래그 누수(watchdog) 재현용 */
|
||
set _lastRequestAt(at: number) {
|
||
this._budget.overrideLastRequestAt(at)
|
||
}
|
||
|
||
/** @internal */
|
||
get _prevRequestAt(): number {
|
||
return this._budget.prevRequestAt
|
||
}
|
||
|
||
/** @internal */
|
||
get _minuteCount(): number {
|
||
return this._budget.minuteCount
|
||
}
|
||
|
||
/** @internal */
|
||
get _dayCount(): number {
|
||
return this._budget.dayCount
|
||
}
|
||
|
||
/** @internal */
|
||
get _consecutiveFailures(): number {
|
||
return this._budget.consecutiveFailures
|
||
}
|
||
|
||
/** @internal */
|
||
get _cooldownUntil(): number {
|
||
return this._budget.cooldownUntil
|
||
}
|
||
|
||
override on<K extends keyof SuggestionEvents>(event: K, listener: SuggestionEvents[K]): this {
|
||
return super.on(event, listener as (...args: unknown[]) => void)
|
||
}
|
||
|
||
override off<K extends keyof SuggestionEvents>(event: K, listener: SuggestionEvents[K]): this {
|
||
return super.off(event, listener as (...args: unknown[]) => void)
|
||
}
|
||
|
||
override emit<K extends keyof SuggestionEvents>(
|
||
event: K,
|
||
...args: Parameters<SuggestionEvents[K]>
|
||
): boolean {
|
||
return super.emit(event, ...args)
|
||
}
|
||
|
||
// ── 상태 ──────────────────────────────────────────────
|
||
|
||
isEnabled(): boolean {
|
||
return configGet('suggestionEnabled') === true
|
||
}
|
||
|
||
get isVisible(): boolean {
|
||
return this._candidates.length > 0
|
||
}
|
||
|
||
get isPresentationActive(): boolean {
|
||
return this.isVisible || this._generating || this._warmingUp || this._partialText.length > 0
|
||
}
|
||
|
||
get activeText(): string | null {
|
||
return this._candidates[this._activeIndex]?.text ?? null
|
||
}
|
||
|
||
getState(): SuggestionState {
|
||
const now = Date.now()
|
||
return {
|
||
enabled: this.isEnabled(),
|
||
modelId: this.resolveModel(),
|
||
modelAvailable: getLocalLLMService().isAvailable(),
|
||
visible: this.isVisible,
|
||
generating: this._generating,
|
||
warmingUp: this._warmingUp,
|
||
partialText: this._partialText || null,
|
||
candidates: [...this._candidates],
|
||
activeIndex: this._activeIndex,
|
||
targetTotal: this._targetTotal,
|
||
anchor: this._anchor,
|
||
anchorKind: this._anchorKind,
|
||
appName: this._appName,
|
||
updatedAt: now,
|
||
lastSkipReason: this._lastSkipReason,
|
||
requestsToday: this._budget.requestsToday(now),
|
||
coolingDown: this._budget.isCoolingDown(now),
|
||
dailyBudget: configGet('suggestionDailyBudget') ?? SUGGESTION_DEFAULTS.dailyBudget,
|
||
lastLatencyMs: this._lastLatencyMs,
|
||
triggerDelayMs: this.readPolicyConfig().triggerDelayMs,
|
||
minPrefixChars: this.readPolicyConfig().minPrefixChars,
|
||
requestTimeoutMs: this.readTimeoutMs(),
|
||
learnTypedText: configGet('inputLearnTypedText') === true,
|
||
telemetryEnabled: configGet('inputTelemetryEnabled') === true,
|
||
overlayInteractive: configGet('suggestionOverlayInteractive') !== false,
|
||
typoAutoCorrect: configGet('typoAutoCorrectEnabled') !== false,
|
||
provenance: this._provenance
|
||
}
|
||
}
|
||
|
||
/** 제안 전용 모델 (설정 없으면 기본 LLM 모델). */
|
||
resolveModel(): string | null {
|
||
const dedicated = configGet('suggestionModelId')
|
||
if (dedicated) return dedicated
|
||
return configGet('llmModelId') ?? null
|
||
}
|
||
|
||
/**
|
||
* 지금 메모리에 올라와 있는 제안 모델 (아니면 null).
|
||
* 오타 교정의 모델 검사는 콜드 모델로 하지 않는다 — 콜드 로드가 제안까지 붙잡는다.
|
||
*/
|
||
warmModel(): string | null {
|
||
const model = this.resolveModel()
|
||
if (!model || !getLocalLLMService().isAvailable()) return null
|
||
return this._warmth.isWarm(model, Date.now()) ? model : null
|
||
}
|
||
|
||
/** 설정 변경 반영 — 꺼지면 즉시 오버레이를 내린다. */
|
||
applyConfig(): void {
|
||
if (!this.isEnabled()) {
|
||
this.dismiss('disabled')
|
||
}
|
||
this.emit('state-changed', this.getState())
|
||
}
|
||
|
||
/**
|
||
* 제안에 쓸 모델이 바뀌었다 (전용 모델 설정 또는 기본 LLM 모델 변경).
|
||
*
|
||
* 새 모델은 콜드일 수 있다 — 첫 멈춤에서 콜드 로드가 타임아웃되기 전에 미리 올린다.
|
||
* 온기는 모델별로 추적하므로 이 호출이 없어도 첫 요청은 워밍업 경로로 간다.
|
||
*/
|
||
handleModelChanged(): void {
|
||
if (!this.isEnabled()) return
|
||
const model = this.resolveModel()
|
||
if (!model || this._warmth.isWarm(model, Date.now())) return
|
||
logger.info(`제안 모델 변경 감지 (model=${model}) — 미리 워밍업한다`)
|
||
void this.warmUp()
|
||
}
|
||
|
||
setEnabled(enabled: boolean): void {
|
||
configSet('suggestionEnabled', enabled)
|
||
if (!enabled) this.dismiss('disabled')
|
||
// 입력 맥락(수집 동의)이 없으면 제안이 뜰 수 없다 — 모델만 데우지 않는다.
|
||
else if (hasInputContextConsent()) void this.warmUp()
|
||
this.emit('state-changed', this.getState())
|
||
}
|
||
|
||
/**
|
||
* 입력 수집 동의·일시정지가 바뀌었다. 입력 맥락이 끊기면 떠 있는 세션·채우기 루프를 닫고
|
||
* 붙잡고 있던 마지막 문맥을 버린다(동의를 철회한 뒤 수동 요청이 옛 접두로 생성하지 않게).
|
||
* 다시 켜지면 제안이 켜져 있을 때만 모델을 데운다.
|
||
*/
|
||
handleInputConsentChanged(): void {
|
||
if (!hasInputContextConsent()) {
|
||
this.dismiss('disabled')
|
||
this._lastContext = null
|
||
this._lastRequestedPrefix = ''
|
||
} else if (this.isEnabled()) {
|
||
void this.warmUp()
|
||
}
|
||
this.emit('state-changed', this.getState())
|
||
}
|
||
|
||
/** 설정에서 명시적으로 제안을 켤 때만 모델을 짧게 준비한다. */
|
||
warmUp(options: { silent?: boolean } = {}): Promise<void> {
|
||
if (!this.isEnabled()) return Promise.resolve()
|
||
if (this._warmUpPromise) return this._warmUpPromise
|
||
|
||
const abort = new AbortController()
|
||
this._warmUpAbort = abort
|
||
// 조용한 워밍업(타이핑 중 미리 올리기)은 "준비 중" 표시를 켜지 않는다 — 표시는 정책 게이트가
|
||
// 열려 실제로 제안을 기다릴 때(_showWarming)만 한다.
|
||
if (!options.silent) this._warmingUp = true
|
||
this.emit('state-changed', this.getState())
|
||
const warmUp = this._warmUpUntilReady(abort)
|
||
this._warmUpPromise = warmUp
|
||
void warmUp.finally(() => {
|
||
if (this._warmUpPromise === warmUp) this._warmUpPromise = null
|
||
if (this._warmUpAbort === abort) this._warmUpAbort = null
|
||
})
|
||
return warmUp
|
||
}
|
||
|
||
private async _warmUpUntilReady(abort: AbortController): Promise<void> {
|
||
try {
|
||
for (let attempt = 0; attempt <= 15; attempt += 1) {
|
||
if (abort.signal.aborted || !this.isEnabled()) return
|
||
if (!getLocalLLMService().isAvailable()) {
|
||
if (attempt === 15) return
|
||
await this._waitForWarmUpRetry(abort.signal)
|
||
continue
|
||
}
|
||
|
||
const model = this.resolveModel()
|
||
if (!model) return
|
||
|
||
try {
|
||
const stream = getLocalLLMService().streamGenerate('hi', {
|
||
model,
|
||
maxTokens: 1,
|
||
temperature: 0,
|
||
signal: abort.signal,
|
||
keepAlive: SUGGESTION_KEEP_ALIVE
|
||
})
|
||
for await (const chunk of stream) void chunk
|
||
if (abort.signal.aborted) return
|
||
this._noteModelWarm(model)
|
||
logger.info(`제안 모델 워밍업 완료 (model=${model})`)
|
||
} catch (error) {
|
||
if (!abort.signal.aborted) {
|
||
const message = error instanceof Error ? error.message : String(error)
|
||
logger.warn(`제안 모델 워밍업 실패: ${message}`)
|
||
// 실패한 워밍업도 실패다 — 기록하지 않으면 멈출 때마다 새 워밍업을 쏘며
|
||
// "준비 중" 만 깜빡이고, 쿨다운·예산이 전혀 걸리지 않는다.
|
||
this._warmth.noteWarmUpFailure(model, Date.now())
|
||
this._lastSkipReason = 'generation-failed'
|
||
this._noteFailure(`warm-up: ${message}`)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
} finally {
|
||
this._warmingUp = false
|
||
// 'state-changed' 뿐 아니라 'updated' 도 보내야 한다 — 오버레이는 'updated' 를
|
||
// 듣고 표시 여부를 판단하는데, 이게 빠지면 타이핑이 멈춘 사이 워밍업이 끝나도
|
||
// "준비 중" 오버레이가 20초 TTL 까지 그대로 남는다.
|
||
this.emit('updated', this.getState())
|
||
this.emit('state-changed', this.getState())
|
||
}
|
||
}
|
||
|
||
private _waitForWarmUpRetry(signal: AbortSignal): Promise<void> {
|
||
return new Promise((resolve) => {
|
||
const finish = (): void => {
|
||
signal.removeEventListener('abort', finish)
|
||
if (this._warmUpRetryTimer) {
|
||
clearTimeout(this._warmUpRetryTimer)
|
||
this._warmUpRetryTimer = null
|
||
}
|
||
resolve()
|
||
}
|
||
this._warmUpRetryTimer = setTimeout(finish, 2000)
|
||
this._warmUpRetryTimer.unref?.()
|
||
signal.addEventListener('abort', finish, { once: true })
|
||
})
|
||
}
|
||
|
||
private _cancelWarmUp(): void {
|
||
if (this._warmUpRetryTimer) {
|
||
clearTimeout(this._warmUpRetryTimer)
|
||
this._warmUpRetryTimer = null
|
||
}
|
||
this._warmUpAbort?.abort()
|
||
this._warmingUp = false
|
||
}
|
||
|
||
// ── 입력 텍스트 처리 ────────────────────────────────
|
||
|
||
/**
|
||
* 입력 텔레메트리가 보내는 "지금 치고 있는 것" 이벤트.
|
||
*
|
||
* 판단은 core `decideSuggestionStep` 이 한다(세션 유효성 → 쿨다운 → 사용자 닫기 →
|
||
* 정책 → 모델 온기). 서비스는 그 결과만 실행한다.
|
||
*/
|
||
handleTypingContext(input: TypingContext): void {
|
||
// 터미널은 화면 전체가 읽힌다 — 입력 줄만 접두로 쓴다. 입력 줄이 없으면 빈 접두(제안 안 함).
|
||
const context: TypingContext = isTerminalApp(input.appName) ? this._terminalContext(input) : input
|
||
this._lastContext = context
|
||
const now = Date.now()
|
||
this._lastContextAt = now
|
||
this._watchdog()
|
||
|
||
const config = this.readPolicyConfig()
|
||
this._logDecisionInputs(context)
|
||
this._abortStaleGeneration(context.prefix)
|
||
this._keepWarm(context, now)
|
||
|
||
const model = this.resolveModel()
|
||
const step = decideSuggestionStep({
|
||
policy: this._buildPolicyInput(context, config, now),
|
||
sessionVisible: this.isVisible,
|
||
sessionPrefix: this._generatedForPrefix,
|
||
coolingDown: this._budget.isCoolingDown(now),
|
||
userDismissedQuiet: now < this._userDismissedUntil,
|
||
lastRequestedPrefix: this._lastRequestedPrefix,
|
||
modelWarm: this._warmth.isWarm(model, now),
|
||
warmUpBackoff: this._warmth.isBackingOff(model, now, WARM_UP_FAILURE_BACKOFF_MS),
|
||
// 서버가 없을 때 "준비 중" 은 실제 준비 작업(워밍업 루프)이 돌 때만 보여준다.
|
||
modelStarting: this._warmUpPromise !== null
|
||
})
|
||
this._executeStep(step, context, config, now)
|
||
}
|
||
|
||
private _executeStep(step: SuggestionStep, context: TypingContext, config: PolicyConfig, now: number): void {
|
||
switch (step.action) {
|
||
case 'end-session':
|
||
// 세션(페이지 넘기며 보는 고정 목록)을 보여주는 중에 다음 문장이 시작됐다 —
|
||
// 이어 치기로 자란 것도 포함, IME 마지막 글자 조합만 예외. 즉시 세션을 끝내고
|
||
// 다음 멈춤에서 정책 게이트를 다시 거쳐 새 세션을 시작한다.
|
||
logger.debug('제안 닫음: 이어서 입력함 — 멈추면 새 문맥으로 다시 만든다')
|
||
this.dismiss(step.reason)
|
||
// 사용자가 고르지 않고 계속 쳤다 — 이 세션 때문에 최소 간격(5초)에 걸려
|
||
// 정작 멈췄을 때 아무것도 안 뜨면 안 된다. 분당·일일 상한은 그대로 둔다.
|
||
this._budget.relaxInterval(now, SUGGESTION_DEFAULTS.minIntervalMs)
|
||
this.emit('state-changed', this.getState())
|
||
return
|
||
case 'generate':
|
||
// 비동기 실패가 조용히 사라지면 기능이 죽은 이유를 알 수 없다.
|
||
void this._generate(step.prefix, context, config.maxCandidates, config.maxChars).catch(
|
||
(error: unknown) => {
|
||
logger.warn(
|
||
`제안 생성 파이프라인 예외: ${error instanceof Error ? error.message : String(error)}`
|
||
)
|
||
this._releaseGeneration()
|
||
}
|
||
)
|
||
return
|
||
case 'settle':
|
||
this._settle(step, context, config)
|
||
return
|
||
}
|
||
}
|
||
|
||
/** 생성하지 않는 결정 — 사유를 남기고, 필요하면 로컬 기억/준비 중/닫기를 수행한다. */
|
||
private _settle(
|
||
step: Extract<SuggestionStep, { action: 'settle' }>,
|
||
context: TypingContext,
|
||
config: PolicyConfig
|
||
): void {
|
||
logger.debug(`제안 보류: ${step.reason} (${step.then})`)
|
||
this._lastSkipReason = step.reason
|
||
|
||
if (
|
||
step.tryLocalMemory &&
|
||
this._publishLocalMemory(
|
||
this._currentPrefix(context),
|
||
context,
|
||
config.maxCandidates,
|
||
config.maxChars,
|
||
0,
|
||
null
|
||
)
|
||
) {
|
||
return
|
||
}
|
||
|
||
switch (step.then) {
|
||
case 'record':
|
||
break
|
||
case 'dismiss':
|
||
if (this.isPresentationActive) this.dismiss(step.reason)
|
||
break
|
||
case 'warm-up':
|
||
void this.warmUp()
|
||
this._showWarming(context)
|
||
break
|
||
case 'show-warming':
|
||
// 워밍업 루프가 서버를 기다리는 중이면 "준비 중" 을 보여준다 — 아무 반응이 없으면
|
||
// 사용자는 기능이 죽었다고 판단한다(첫 실행에서 실제로 그랬다). 준비 작업이 없으면
|
||
// core 가 'record' 를 준다(끝나지 않는 스피너 방지).
|
||
this._showWarming(context)
|
||
break
|
||
}
|
||
this.emit('state-changed', this.getState())
|
||
}
|
||
|
||
/** "준비 중" 오버레이 — 워밍업 안내도 수명이 있어, 갱신이 없으면 스스로 사라진다. */
|
||
private _showWarming(context: TypingContext): void {
|
||
this._warmingUp = true
|
||
this._anchor = context.anchor
|
||
this._anchorKind = context.anchorKind
|
||
this._appName = context.appName
|
||
this._armVisibleTtl()
|
||
this.emit('updated', this.getState())
|
||
}
|
||
|
||
/**
|
||
* 사용자가 타이핑 중이면 모델을 따뜻하게 유지한다.
|
||
*
|
||
* - 식어 있으면 첫 키 입력 때 바로 조용히 워밍업을 시작한다 — 문장을 다 쓰고 멈춘 뒤에야
|
||
* 올리기 시작하면 그만큼 "준비 중" 이 길어진다(표시는 정책 게이트가 열릴 때만).
|
||
* - 따뜻하지만 유지 시간이 얼마 안 남았으면 1토큰 요청으로 연장한다.
|
||
*/
|
||
private _keepWarm(context: TypingContext, now: number): void {
|
||
if (!this.isEnabled() || !context.typedRecently || !context.isEditable || context.isPassword) return
|
||
if (this._warmUpPromise || this._inFlight || this._filling) return
|
||
const model = this.resolveModel()
|
||
if (!model || !getLocalLLMService().isAvailable()) return
|
||
if (!this._warmth.isWarm(model, now)) {
|
||
if (this._warmth.isBackingOff(model, now, WARM_UP_FAILURE_BACKOFF_MS)) return
|
||
logger.info(`타이핑 감지 — 식은 제안 모델을 미리 올린다 (model=${model})`)
|
||
void this.warmUp({ silent: true })
|
||
return
|
||
}
|
||
if (this._warmth.warmUntil - now > KEEP_WARM_REFRESH_MS) return
|
||
if (now - this._lastKeepWarmAt < KEEP_WARM_MIN_INTERVAL_MS) return
|
||
this._lastKeepWarmAt = now
|
||
void this._refreshKeepAlive(model)
|
||
}
|
||
|
||
private async _refreshKeepAlive(model: string): Promise<void> {
|
||
try {
|
||
const stream = getLocalLLMService().streamGenerate('hi', {
|
||
model,
|
||
maxTokens: 1,
|
||
temperature: 0,
|
||
keepAlive: SUGGESTION_KEEP_ALIVE
|
||
})
|
||
for await (const chunk of stream) void chunk
|
||
this._noteModelWarm(model)
|
||
logger.debug(`제안 모델 유지 시간 연장 (model=${model})`)
|
||
} catch (error) {
|
||
logger.debug(`제안 모델 유지 연장 실패: ${error instanceof Error ? error.message : String(error)}`)
|
||
}
|
||
}
|
||
|
||
/** 수동 요청 (설정/단축키 경로). 디바운스를 건너뛴다. */
|
||
async requestNow(): Promise<SuggestionRequestResult> {
|
||
if (!this.isEnabled()) return { ok: false, reason: 'disabled' }
|
||
const context = this._lastContext
|
||
if (!context?.available || !context.isEditable || context.isPassword || context.hasSelection) {
|
||
const reason = context?.isPassword
|
||
? 'password-field'
|
||
: context?.hasSelection
|
||
? 'selection-active'
|
||
: 'not-editable'
|
||
if (this.isPresentationActive) this.dismiss(reason)
|
||
return { ok: false, reason }
|
||
}
|
||
if (context.caretReliable === false) return { ok: false, reason: 'caret-unknown' }
|
||
const prefix = normalizeRequestPrefix(context.prefix)
|
||
if (prefix.length < 1) return { ok: false, reason: 'empty-prefix' }
|
||
|
||
// 명시적 사용자 액션(단축키/설정)이다 — 텔레메트리가 판단한 "최근에 타이핑했는가" 에
|
||
// 좌우되지 않아야 한다. 그대로 넘기면 _generate 실패 경로의 _canUseLocalMemory 가
|
||
// (클릭만 한 뒤 수동 요청 같은 경우) not-typing 으로 막아 버린다.
|
||
const explicitContext: TypingContext = { ...context, editedSinceFocus: true, typedRecently: true }
|
||
const config = this.readPolicyConfig()
|
||
await this._generate(prefix, explicitContext, config.maxCandidates, config.maxChars).catch((error: unknown) => {
|
||
logger.warn(`수동 제안 생성 예외: ${error instanceof Error ? error.message : String(error)}`)
|
||
this._releaseGeneration()
|
||
})
|
||
return this.isVisible ? { ok: true } : { ok: false, reason: this._lastSkipReason ?? 'generation-failed' }
|
||
}
|
||
|
||
/**
|
||
* 정책 입력 조립 — 모든 경로가 이 한 곳에서 만든다.
|
||
*
|
||
* 기본값: 모델 가용성은 실제 값, overlayVisible 은 "생성/워밍업/후보 표시 중" 전체.
|
||
*/
|
||
private _buildPolicyInput(
|
||
context: TypingContext,
|
||
config: PolicyConfig,
|
||
now: number,
|
||
overrides: Partial<Pick<SuggestionPolicyInput, 'modelAvailable' | 'overlayVisible'>> = {}
|
||
): SuggestionPolicyInput {
|
||
const budget = this._budget.snapshot(now)
|
||
return {
|
||
enabled: this.isEnabled(),
|
||
modelAvailable: overrides.modelAvailable ?? getLocalLLMService().isAvailable(),
|
||
overlayVisible: overrides.overlayVisible ?? this.isPresentationActive,
|
||
composing: context.isComposing,
|
||
hasSelection: context.hasSelection,
|
||
isPassword: context.isPassword,
|
||
isEditable: context.isEditable,
|
||
appName: context.appName,
|
||
excludedApps: config.excludedApps,
|
||
editedSinceFocus: context.editedSinceFocus,
|
||
typedRecently: context.typedRecently,
|
||
prefix: context.prefix,
|
||
caretReliable: context.caretReliable !== false,
|
||
idleMs: context.idleMs,
|
||
triggerDelayMs: config.triggerDelayMs,
|
||
minPrefixChars: config.minPrefixChars,
|
||
sinceLastRequestMs: budget.sinceLastRequestMs,
|
||
minIntervalMs: SUGGESTION_DEFAULTS.minIntervalMs,
|
||
requestsThisMinute: budget.requestsThisMinute,
|
||
maxRequestsPerMinute: config.maxRequestsPerMinute,
|
||
requestsToday: budget.requestsToday,
|
||
dailyBudget: config.dailyBudget
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 터미널 문맥 — 화면 전체 대신 입력 줄만 접두로 쓰고, 커서 신뢰도도 입력 줄로 판단한다.
|
||
*
|
||
* 텔레메트리의 "편집이 문서 끝에서 일어났나" 는 화면 전체로 판정한다. Claude Code 같은 TUI 는
|
||
* 입력 상자 아래에 상태줄이 있어 모든 입력이 "문서 중간 편집" 이 되고 caret-unknown 으로 전부
|
||
* 막혔다(실측 2026-10-03: 보류 721회, 최다). 입력 줄이 이전 입력 줄을 늘리거나 줄인 모양이면
|
||
* (끝에서 치거나 지움) 커서는 입력 줄 끝이다. 중간을 고친 모양이면 다음 입력까지 막는다.
|
||
*/
|
||
private _terminalContext(input: TypingContext): TypingContext {
|
||
const prompt = extractTerminalPromptPrefix(input.fullText ?? input.prefix)
|
||
const previous = this._lastTerminalPrompt
|
||
this._lastTerminalPrompt = prompt
|
||
let typed: boolean
|
||
if (prompt === null) typed = false
|
||
else if (prompt.length === 0) typed = true
|
||
else if (previous === null) typed = prompt.length <= TERMINAL_TYPING_STEP_CHARS
|
||
else if (prompt === previous) typed = this._terminalPromptTyped
|
||
else if (previous.length === 0 && prompt.length > TERMINAL_TYPING_STEP_CHARS) {
|
||
// 빈 입력칸이 한 번에 긴 글로 바뀌었다 — Claude Code 의 회색 "추천 문구" 다. UIA 는 그것도
|
||
// 입력 글자로 준다(실측 2026-10-03: 빈 칸 → 28·29자, 그 뒤에 이어 쓴 ", ready for next test
|
||
// cycle." 이 사용자 메시지 앞에 삽입됐다). 사용자가 치기 시작하면 다음 판정에서 다시 믿는다.
|
||
typed = false
|
||
} else {
|
||
// 바뀐 곳이 끝부분뿐이면 끝에서 치는 중이다: 늘어남·줄어듦, 그리고 한글 조합처럼 마지막
|
||
// 한두 글자가 바뀌는 것("자ㄹ" → "자료"). 조합을 "중간 편집" 으로 보던 탓에 멈춘 뒤에도
|
||
// 막혀 있었다(실측: 30초 동안 치는데 내내 caret-unknown).
|
||
typed = commonPrefixLength(previous, prompt) >= Math.min(previous.length, prompt.length) - 2
|
||
}
|
||
this._terminalPromptTyped = typed
|
||
return { ...input, prefix: prompt ?? '', documentBefore: null, caretReliable: typed }
|
||
}
|
||
|
||
/** 로컬 기억은 모델과 무관하다 — 같은 정책을 "모델 있음 · 표시 없음" 으로 평가한다. */
|
||
private _canUseLocalMemory(context: TypingContext, config: PolicyConfig, now: number): boolean {
|
||
return (
|
||
decideSuggestion(
|
||
this._buildPolicyInput(context, config, now, { modelAvailable: true, overlayVisible: false })
|
||
).action === 'request'
|
||
)
|
||
}
|
||
|
||
private _collectMemoryHints(prefix: string, appName: string | null): LocalMemoryContext {
|
||
const telemetry = getInputTelemetryService()
|
||
const graphContext = getPersonalGraphService().retrieveContext(prefix, 4, { appName })
|
||
const phrases = telemetry.listPhrases(120)
|
||
// 지금 글과 용어가 겹치는 문구만 — 문맥과 무관한 "자주 쓰는 말" 은 프롬프트를 흐린다.
|
||
const writing = analyzeWritingContext(prefix)
|
||
const relevanceTerms = new Set(
|
||
buildQueryTerms([
|
||
{ text: writing.currentSentence, weight: 2 },
|
||
{ text: writing.lastSentence, weight: 1 }
|
||
]).keys()
|
||
)
|
||
const phraseHints = selectPhraseHints(phrases, prefix, 5, { appName, relevanceTerms })
|
||
const fallbackPhraseHints = selectPhraseHints(phrases, prefix, 5, { appName })
|
||
const requestedApp = appName?.trim().toLowerCase()
|
||
const appPhraseCount = requestedApp
|
||
? phrases.filter(
|
||
(phrase) =>
|
||
phrase.appName?.trim().toLowerCase() === requestedApp && phraseHints.includes(phrase.phrase)
|
||
).length
|
||
: 0
|
||
return {
|
||
continuationHints: graphContext.continuations,
|
||
followUpHints: graphContext.followUps ?? [],
|
||
relatedHints: graphContext.related,
|
||
phraseHints,
|
||
fallbackPhraseHints,
|
||
appPhraseCount
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 모델 요청 하나를 만든다.
|
||
*
|
||
* 원형 템플릿을 아는 모델(gemma 계열)이면 prefill 이어 쓰기 — 모델 차례에 사용자가 쓰던 문장을
|
||
* 미리 넣어 그 글자 바로 뒤부터 쓰게 한다. 모르는 모델이면 예전 지시형 프롬프트를 쓴다.
|
||
* 두 경로 모두 같은 문맥(문서 첫머리·사실, 이 창의 앞 글, 개인 그래프)을 받는다.
|
||
*
|
||
* `preferInstruct`: 다음 문장 모드의 채우기 후보는 지시형을 섞는다. prefill 은 분포가 뾰족해
|
||
* 온도를 올려도 첫 후보와 같은 문장이 반복됐고, 지시형은 "이미 제안한 문장" 목록을 따라 다른
|
||
* 내용을 낸다(실측). 마저 쓰기 모드에서는 지시형이 새 문장을 시작해 버려 섞지 않는다.
|
||
*/
|
||
private _buildModelRequest(
|
||
model: string,
|
||
prefix: string,
|
||
context: TypingContext,
|
||
memory: LocalMemoryContext,
|
||
maxChars: number,
|
||
options: { avoidCandidates?: readonly string[]; preferInstruct?: boolean } = {}
|
||
): ModelRequest {
|
||
const now = Date.now()
|
||
const recentWrites = getInputTelemetryService()
|
||
.listRecentWrites({
|
||
windowHandle: context.windowHandle ?? null,
|
||
appName: context.appName,
|
||
windowTitle: context.windowTitle
|
||
})
|
||
.map((entry) => ({ text: entry.text, ageMs: now - entry.at }))
|
||
const promptInput = {
|
||
prefix,
|
||
documentText: context.documentBefore ?? null,
|
||
suffix: suffixAfterCaret(context),
|
||
appName: context.appName,
|
||
windowTitle: context.windowTitle,
|
||
recentWrites,
|
||
phraseHints: relatedPromptHints(memory),
|
||
continuationHints: memory.continuationHints,
|
||
followUpHints: memory.followUpHints,
|
||
avoidCandidates: options.avoidCandidates,
|
||
candidates: 1,
|
||
maxChars
|
||
}
|
||
|
||
const prompt = buildSuggestionPrompt({ ...promptInput, prefill: true })
|
||
const rawPrompt = renderRawChatPrompt(model, {
|
||
system: prompt.systemPrompt,
|
||
user: prompt.text,
|
||
assistantPrefix: prompt.assistantPrefix ?? ''
|
||
})
|
||
|
||
const instruct = options.preferInstruct === true && prompt.writing.mode === 'next-sentence'
|
||
if (rawPrompt !== null && !instruct) {
|
||
const written = splitSentences(context.documentBefore ?? prefix)
|
||
const extract = (raw: string) =>
|
||
extractContinuation(raw, {
|
||
mode: prompt.writing.mode,
|
||
prefill: prompt.assistantPrefix ?? '',
|
||
writtenSentences: written,
|
||
wordFinished: prompt.wordFinished,
|
||
allowEmoji: prompt.allowEmoji,
|
||
maxChars
|
||
})
|
||
return {
|
||
prompt: rawPrompt,
|
||
raw: true,
|
||
stop: rawChatStopSequences(model),
|
||
parse: (raw) => {
|
||
const continuation = extract(raw)
|
||
if (!continuation) return { candidate: null, rejected: 'empty' }
|
||
// 원문·창 제목·앞 글·개인 힌트 어디에도 없는 날짜·이름·숫자 = 지어낸 사실. 수락하면 글에 박힌다.
|
||
const unsupported = findUnsupportedFacts(continuation.text, prompt.factSource)
|
||
if (unsupported.length > 0) return { candidate: null, rejected: `unsupported-facts:${unsupported.join('/')}` }
|
||
return {
|
||
candidate:
|
||
continuation.joint === 'attach'
|
||
? { text: continuation.text, rank: 0, joint: 'attach' }
|
||
: { text: continuation.text, rank: 0 },
|
||
rejected: null
|
||
}
|
||
},
|
||
partial: (raw) => extract(raw)?.text ?? ''
|
||
}
|
||
}
|
||
|
||
const legacy = buildSuggestionPrompt(promptInput)
|
||
return {
|
||
prompt: legacy.text,
|
||
systemPrompt: legacy.systemPrompt,
|
||
raw: false,
|
||
parse: (raw) => {
|
||
const text = parseSuggestionCandidates(raw, prefix, 1, maxChars)[0]
|
||
if (!text) return { candidate: null, rejected: 'empty' }
|
||
const unsupported = findUnsupportedFacts(text, legacy.factSource)
|
||
if (unsupported.length > 0) return { candidate: null, rejected: `unsupported-facts:${unsupported.join('/')}` }
|
||
return { candidate: { text, rank: 0 }, rejected: null }
|
||
},
|
||
partial: sanitizePartial
|
||
}
|
||
}
|
||
|
||
private _isCurrentFallbackContext(
|
||
prefix: string,
|
||
context: TypingContext,
|
||
token: number | null
|
||
): boolean {
|
||
if (token !== null && token !== this._generationToken) return false
|
||
const current = this._lastContext
|
||
if (
|
||
!current ||
|
||
!current.available ||
|
||
!current.isEditable ||
|
||
current.isPassword ||
|
||
current.isComposing ||
|
||
current.hasSelection
|
||
) {
|
||
return false
|
||
}
|
||
return (
|
||
normalizeSessionPrefix(current.prefix) === normalizeSessionPrefix(prefix) &&
|
||
current.appName === context.appName &&
|
||
current.windowTitle === context.windowTitle
|
||
)
|
||
}
|
||
|
||
private _publishLocalMemory(
|
||
prefix: string,
|
||
context: TypingContext,
|
||
maxCandidates: number,
|
||
maxChars: number,
|
||
latencyMs: number,
|
||
token: number | null,
|
||
memory: LocalMemoryContext | null = null
|
||
): boolean {
|
||
if (!this._isCurrentFallbackContext(prefix, context, token)) return false
|
||
const trimmedPrefix = normalizeSessionPrefix(prefix)
|
||
const localMemory = memory ?? this._collectMemoryHints(trimmedPrefix, context.appName)
|
||
// 원문 뒤 공백(단어를 끝냈는가)은 세션 접두 정규화가 지운다 — 최신 원문에서 읽어 넘긴다.
|
||
const rawPrefix = this._lastContext?.prefix ?? context.prefix
|
||
const entries = buildLocalSuggestionCandidateEntries(
|
||
trimmedPrefix,
|
||
{
|
||
continuationHints: localMemory.continuationHints,
|
||
// 직전 문장 뒤에 실제로 이어 쓴 문장이 "다음 문장" 후보로 가장 강하다.
|
||
relatedHints: [...localMemory.followUpHints, ...localMemory.relatedHints],
|
||
phraseHints: [...localMemory.phraseHints, ...localMemory.fallbackPhraseHints]
|
||
},
|
||
maxCandidates,
|
||
maxChars,
|
||
{
|
||
wordFinished: /\s$/u.test(rawPrefix)
|
||
})
|
||
if (entries.length === 0) return false
|
||
|
||
this._partialText = ''
|
||
this._generating = false
|
||
this._warmingUp = false
|
||
// 단어 중간에서 이어지는 나머지(예: "Thank yo" + "u for…")는 수락할 때 공백 없이 붙인다.
|
||
this._candidates = entries.map((entry, index) =>
|
||
entry.attachToPrefix ? { text: entry.text, rank: index, joint: 'attach' } : { text: entry.text, rank: index }
|
||
)
|
||
this._activeIndex = 0
|
||
this._anchor = context.anchor
|
||
this._anchorKind = context.anchorKind
|
||
this._appName = context.appName
|
||
this._windowTitle = context.windowTitle
|
||
this._windowHandle = context.windowHandle ?? null
|
||
this._generatedForPrefix = trimmedPrefix
|
||
this._targetTotal = entries.length
|
||
this._lastSkipReason = null
|
||
this._lastLatencyMs = latencyMs
|
||
this._provenance = {
|
||
mode: 'local-memory',
|
||
continuationCount: localMemory.continuationHints.length,
|
||
relatedCount: localMemory.relatedHints.length + localMemory.followUpHints.length,
|
||
phraseCount: localMemory.phraseHints.length,
|
||
appPhraseCount: localMemory.appPhraseCount
|
||
}
|
||
this._recordSuggestion({
|
||
prefix: trimmedPrefix,
|
||
text: entries[0].text,
|
||
model: 'local-memory',
|
||
latencyMs,
|
||
candidateCount: entries.length
|
||
})
|
||
this._armVisibleTtl()
|
||
this.emit('updated', this.getState())
|
||
this.emit('state-changed', this.getState())
|
||
logger.info(`로컬 기억 제안 ${entries.length}개 생성`)
|
||
return true
|
||
}
|
||
|
||
// ── 생성 ──────────────────────────────────────────────
|
||
|
||
private async _generate(
|
||
prefix: string,
|
||
context: TypingContext,
|
||
maxCandidates: number,
|
||
maxChars: number
|
||
): Promise<void> {
|
||
if (this._inFlight) {
|
||
// 침묵하면 "왜 안 뜨는지" 를 알 수 없다 — 진단을 남긴다.
|
||
logger.debug(`제안 건너뜀: 이미 생성 중 (${Date.now() - this._budget.lastRequestAt}ms 경과)`)
|
||
return
|
||
}
|
||
|
||
// 어떤 경로로 끝나든 진행 플래그는 반드시 해제한다.
|
||
// (emit/showOverlay 쪽 예외가 여기로 새면 _inFlight 가 true 로 굳어
|
||
// 이후 모든 제안이 조용히 막힌다 — "한 번 나오고 안 나옴" 의 원인 후보)
|
||
try {
|
||
|
||
const startedAt = Date.now()
|
||
// 세션 접두 — 프롬프트 입력이자 세션 유효성 비교의 기준 (normalizeSessionPrefix 정본)
|
||
const trimmedPrefix = normalizeSessionPrefix(prefix)
|
||
const model = this.resolveModel()
|
||
if (!model) {
|
||
const config = this.readPolicyConfig()
|
||
if (
|
||
this._canUseLocalMemory(context, config, startedAt) &&
|
||
this._publishLocalMemory(
|
||
trimmedPrefix,
|
||
context,
|
||
maxCandidates,
|
||
maxChars,
|
||
Date.now() - startedAt,
|
||
null
|
||
)
|
||
) {
|
||
return
|
||
}
|
||
this._lastSkipReason = 'model-unavailable'
|
||
this.emit('state-changed', this.getState())
|
||
return
|
||
}
|
||
|
||
this._abort?.abort()
|
||
const abort = new AbortController()
|
||
this._abort = abort
|
||
const token = (this._generationToken += 1)
|
||
|
||
this._inFlight = true
|
||
this._generating = true
|
||
this._lastRequestedPrefix = normalizeRequestPrefix(prefix)
|
||
this._warmingUp = false
|
||
this._provenance = null
|
||
this._budget.consume(Date.now())
|
||
|
||
// 후보가 오기 전에 빈 화면으로 기다리게 하지 않는다 — 즉시 자리를 잡고
|
||
// "생성 중" 을 보여준 뒤 내용으로 채운다. 실측 5초 지연에서 특히 중요하다.
|
||
this._candidates = []
|
||
this._sessionRecordId = null
|
||
this._activeIndex = 0
|
||
this._anchor = context.anchor
|
||
this._anchorKind = context.anchorKind
|
||
this._appName = context.appName
|
||
this._windowTitle = context.windowTitle
|
||
this._windowHandle = context.windowHandle ?? null
|
||
this._armVisibleTtl()
|
||
this.emit('updated', this.getState())
|
||
|
||
const timeoutMs = this.readTimeoutMs()
|
||
let timedOut = false
|
||
if (this._timeoutTimer) clearTimeout(this._timeoutTimer)
|
||
this._timeoutTimer = setTimeout(() => {
|
||
// 모델이 하드웨어보다 느릴 때 UI 를 붙잡지 않는다 (다음 타이핑 주기에 재시도).
|
||
if (!abort.signal.aborted) {
|
||
timedOut = true
|
||
abort.abort()
|
||
}
|
||
}, timeoutMs)
|
||
this._timeoutTimer.unref?.()
|
||
|
||
// 개인 그래프 문맥: (1) 과거에 그 꼬리 뒤에 실제로 이어 쓴 문장,
|
||
// (2) follows/용어공유 관계로 끌어온 관련 문장.
|
||
const memory = this._collectMemoryHints(trimmedPrefix, context.appName)
|
||
const continuationHints = memory.continuationHints
|
||
// 세션의 첫 요청은 딱 1개만 청한다 — 한꺼번에 여러 개를 요청하면 느리다(사용자
|
||
// 요청). 첫 후보를 보여준 뒤 나머지는 채우기 루프가 하나씩 순차로 더 만든다.
|
||
const request = this._buildModelRequest(model, trimmedPrefix, context, memory, maxChars)
|
||
|
||
let parsed: { candidate: SuggestionCandidate | null; rejected: string | null } = { candidate: null, rejected: 'empty' }
|
||
try {
|
||
this._partialText = ''
|
||
// 지어낸 사실(원문에 없는 날짜·이름·숫자)로 버린 첫 후보는 같은 시간 제한 안에서 한 번 더 뽑는다.
|
||
for (let attempt = 0; attempt < 2; attempt += 1) {
|
||
const temperature = attempt === 0 ? SUGGESTION_DEFAULTS.temperature : FILL_TEMPERATURE
|
||
const raw = await this._streamModel(request, model, temperature, abort.signal, (partial) => {
|
||
// 도착하는 대로 오버레이에 흘려보낸다 — 사용자는 "계속 생성되는" 것을 본다.
|
||
// IPC 과다 방출을 막기 위해 120ms 간격으로만 보낸다.
|
||
this._partialText = partial
|
||
const now = Date.now()
|
||
if (now - this._lastPartialEmitAt >= 120) {
|
||
this._lastPartialEmitAt = now
|
||
this.emit('updated', this.getState())
|
||
}
|
||
})
|
||
if (abort.signal.aborted) break
|
||
parsed = request.parse(raw)
|
||
if (!parsed.candidate) {
|
||
// 진단: 왜 비었는지 모양만 남긴다(글자 내용은 남기지 않는다) — 실측 2026-10-03 카톡 10회 모두 빈 후보.
|
||
logger.debug(`제안 정제 실패: ${describeRawOutput(raw, request.raw)}`)
|
||
}
|
||
if (parsed.candidate || !parsed.rejected?.startsWith('unsupported-facts')) break
|
||
logger.info(`제안 후보 버림 (${parsed.rejected}) — 한 번 더 뽑는다`)
|
||
this._partialText = ''
|
||
}
|
||
} catch (error) {
|
||
if (!abort.signal.aborted) {
|
||
this._lastSkipReason = 'generation-failed'
|
||
this._noteFailure(error instanceof Error ? error.message : String(error))
|
||
if (
|
||
this._publishLocalMemory(
|
||
trimmedPrefix,
|
||
context,
|
||
maxCandidates,
|
||
maxChars,
|
||
Date.now() - startedAt,
|
||
token,
|
||
memory
|
||
)
|
||
) {
|
||
logger.warn(`모델 제안 실패 후 로컬 기억 제안으로 전환: ${error instanceof Error ? error.message : String(error)}`)
|
||
return
|
||
}
|
||
this.dismiss('generation-failed')
|
||
this.emit('state-changed', this.getState())
|
||
return
|
||
}
|
||
} finally {
|
||
if (this._abort === abort) this._abort = null
|
||
if (this._timeoutTimer) {
|
||
clearTimeout(this._timeoutTimer)
|
||
this._timeoutTimer = null
|
||
}
|
||
}
|
||
|
||
if (abort.signal.aborted) {
|
||
if (token !== this._generationToken) {
|
||
logger.debug(`중단된 제안 결과 폐기 (세대 ${token} ≠ ${this._generationToken})`)
|
||
return
|
||
}
|
||
|
||
if (!timedOut) return
|
||
|
||
this._lastSkipReason = 'generation-failed'
|
||
// warm 이라 믿고 보낸 요청이 시간 초과했다면 모델은 이미 내려갔다(다른 기능의 짧은 keep_alive 등)
|
||
// — 다음 멈춤은 같은 콜드 요청을 되풀이하지 말고 워밍업("준비 중")부터 한다.
|
||
this._warmth.noteCold(model)
|
||
this._noteFailure(`timeout ${timeoutMs}ms`)
|
||
if (
|
||
this._publishLocalMemory(
|
||
trimmedPrefix,
|
||
context,
|
||
maxCandidates,
|
||
maxChars,
|
||
Date.now() - startedAt,
|
||
token,
|
||
memory
|
||
)
|
||
) {
|
||
logger.warn(`모델 제안 시간 초과 후 로컬 기억 제안으로 전환 (${timeoutMs}ms)`)
|
||
return
|
||
}
|
||
this.dismiss('generation-failed')
|
||
this.emit('state-changed', this.getState())
|
||
return
|
||
}
|
||
|
||
// 사용자가 그사이 닫았거나 새 요청이 시작됐다면 이 결과는 버린다.
|
||
if (token !== this._generationToken) {
|
||
logger.debug(`제안 결과 폐기 (세대 ${token} ≠ ${this._generationToken})`)
|
||
return
|
||
}
|
||
|
||
// 타이핑을 멈추고 자리를 뜬 뒤 도착한 결과는 화면에 띄우지 않는다.
|
||
// (아무것도 안 치는데 제안창이 뜨던 신고의 원인 중 하나)
|
||
const staleness = Date.now() - this._lastContextAt
|
||
if (this._lastContextAt > 0 && staleness > SUGGESTION_DEFAULTS.resultMaxStalenessMs) {
|
||
logger.debug(`제안 결과 폐기 (문맥이 ${staleness}ms 지났다)`)
|
||
this.dismiss('stale')
|
||
return
|
||
}
|
||
|
||
// 요청 뒤 사용자가 더 쳤다면 이 결과는 옛 접두용이다 — 게시하면 다음 스냅샷에서 곧바로
|
||
// stale 로 닫히며(깜빡임) 채우기 요청만 낭비하고, 그사이 수락하면 방금 친 말이 빠진
|
||
// 문장이 들어간다. 세션과 같은 기준(matchesSessionPrefix)으로 최신 문맥과 맞춰 본다.
|
||
const latest = this._lastContext
|
||
if (latest && !matchesSessionPrefix(trimmedPrefix, latest.prefix)) {
|
||
logger.debug('제안 결과 폐기 (요청 뒤 접두가 바뀌었다)')
|
||
this.dismiss('stale')
|
||
this._budget.relaxInterval(Date.now(), SUGGESTION_DEFAULTS.minIntervalMs)
|
||
this.emit('state-changed', this.getState())
|
||
return
|
||
}
|
||
|
||
const first = parsed.candidate
|
||
if (!first) {
|
||
this._lastSkipReason = 'generation-failed'
|
||
logger.info(`제안 후보가 비어 있음 (모델 출력 정제 후: ${parsed.rejected ?? 'empty'})`)
|
||
if (
|
||
this._publishLocalMemory(
|
||
trimmedPrefix,
|
||
context,
|
||
maxCandidates,
|
||
maxChars,
|
||
Date.now() - startedAt,
|
||
token,
|
||
memory
|
||
)
|
||
) {
|
||
return
|
||
}
|
||
this.dismiss('generation-failed')
|
||
this.emit('state-changed', this.getState())
|
||
return
|
||
}
|
||
|
||
const latencyMs = Date.now() - startedAt
|
||
this._lastLatencyMs = latencyMs
|
||
this._budget.noteSuccess()
|
||
this._partialText = ''
|
||
this._candidates = [{ ...first, rank: 0 }]
|
||
this._activeIndex = 0
|
||
this._anchor = context.anchor
|
||
this._anchorKind = context.anchorKind
|
||
this._appName = context.appName
|
||
this._windowTitle = context.windowTitle
|
||
this._windowHandle = context.windowHandle ?? null
|
||
this._generatedForPrefix = trimmedPrefix
|
||
this._targetTotal = SUGGESTION_DEFAULTS.maxCandidatesTotal
|
||
this._lastSkipReason = null
|
||
this._provenance = {
|
||
mode: 'local-model',
|
||
continuationCount: continuationHints.length,
|
||
relatedCount: memory.relatedHints.length + memory.followUpHints.length,
|
||
phraseCount: memory.phraseHints.length,
|
||
appPhraseCount: memory.appPhraseCount
|
||
}
|
||
|
||
this._recordSuggestion({ prefix: trimmedPrefix, text: first.text, model, latencyMs, candidateCount: 1 })
|
||
logger.info(`제안 첫 후보 생성 (${latencyMs}ms, model=${model}) — 최대 ${SUGGESTION_DEFAULTS.maxCandidatesTotal}개까지 순차로 채운다`)
|
||
this._armVisibleTtl()
|
||
this.emit('updated', this.getState())
|
||
|
||
// generating 은 계속 true 로 남는다 — 채우기 루프가 백그라운드에서 나머지를
|
||
// 하나씩 청한다("더 온다" 를 UI 에 알린다). _releaseGeneration() 이 이를
|
||
// 지우지 않도록 _filling 을 먼저 켠다.
|
||
this._filling = true
|
||
void this._runFillLoop(token, context, maxChars).catch((error: unknown) => {
|
||
logger.warn(`제안 채우기 루프 예외: ${error instanceof Error ? error.message : String(error)}`)
|
||
this._filling = false
|
||
})
|
||
} finally {
|
||
// 어떤 경로로 끝나든 진행 플래그를 해제한다 —
|
||
// 예외가 어디로 새든 다음 제안이 조용히 막히지 않는다.
|
||
this._releaseGeneration()
|
||
}
|
||
}
|
||
|
||
// ── 채우기 루프 (2번째 이후 후보, 최대 12개) ────────────
|
||
|
||
/**
|
||
* 첫 후보 공개 뒤 나머지를 하나씩 순차로 채운다.
|
||
*
|
||
* 종료 조건: 12개 도달, 연속 2번 새 후보 없음, 세대 토큰이 바뀜(세션 종료).
|
||
* `_generate` 의 예산/타임아웃/실패 카운트와 무관하다 — 채우기는 그 어느 것도
|
||
* 소비하지 않는다(설계). 시간 초과된 채우기 요청은 조용히 다음으로 넘어간다.
|
||
*/
|
||
private async _runFillLoop(token: number, context: TypingContext, maxChars: number): Promise<void> {
|
||
let consecutiveEmpty = 0
|
||
while (
|
||
token === this._generationToken &&
|
||
this._candidates.length < SUGGESTION_DEFAULTS.maxCandidatesTotal &&
|
||
consecutiveEmpty < 2
|
||
) {
|
||
const appended = await this._fillOne(token, context, maxChars)
|
||
if (token !== this._generationToken) break
|
||
consecutiveEmpty = appended ? 0 : consecutiveEmpty + 1
|
||
}
|
||
if (token === this._generationToken) {
|
||
this._filling = false
|
||
this._generating = false
|
||
this.emit('updated', this.getState())
|
||
}
|
||
}
|
||
|
||
/** 채우기 루프 한 스텝 — 후보 1개를 요청해 고유하면 덧붙인다. */
|
||
private async _fillOne(token: number, context: TypingContext, maxChars: number): Promise<boolean> {
|
||
const model = this.resolveModel()
|
||
if (!model) return false
|
||
|
||
const abort = new AbortController()
|
||
this._fillAbort = abort
|
||
const timeoutMs = this.readTimeoutMs()
|
||
const timer = setTimeout(() => {
|
||
if (!abort.signal.aborted) abort.abort()
|
||
}, timeoutMs)
|
||
timer.unref?.()
|
||
|
||
try {
|
||
// 세션이 고정한 접두를 쓴다 — context.prefix 는 그사이 바뀌었을 수 있지만,
|
||
// 바뀌었다면 이미 위(handleTypingContext)에서 세션이 dismiss 되어 토큰이
|
||
// 달라져 있으므로 이 루프는 다음 체크에서 멈춘다.
|
||
const prefix = this._generatedForPrefix
|
||
const memory = this._collectMemoryHints(prefix, context.appName)
|
||
const avoidCandidates = this._candidates.map((candidate) => candidate.text)
|
||
// 홀수 번째 채우기는 (다음 문장 모드일 때) 지시형으로 — 후보 다양성.
|
||
const request = this._buildModelRequest(model, prefix, context, memory, maxChars, {
|
||
avoidCandidates,
|
||
preferInstruct: this._candidates.length % 2 === 1
|
||
})
|
||
const raw = await this._streamModel(request, model, FILL_TEMPERATURE, abort.signal)
|
||
if (abort.signal.aborted || token !== this._generationToken) return false
|
||
|
||
const parsed = request.parse(raw)
|
||
if (!parsed.candidate) {
|
||
if (parsed.rejected && parsed.rejected !== 'empty') logger.debug(`제안 채우기 후보 버림 (${parsed.rejected})`)
|
||
return false
|
||
}
|
||
const candidate = parsed.candidate
|
||
if (token !== this._generationToken || this._isDuplicateCandidate(candidate.text)) return false
|
||
|
||
this._candidates.push({ ...candidate, rank: this._candidates.length })
|
||
logger.debug(`제안 후보 추가 ${this._candidates.length}/${SUGGESTION_DEFAULTS.maxCandidatesTotal}`)
|
||
this._armVisibleTtl()
|
||
this.emit('updated', this.getState())
|
||
// 채우기 후보는 새 행이 아니다 — 세션 행의 후보 수만 늘린다(지연 0 행이 평균·수락률을 망쳤다).
|
||
if (this._sessionRecordId) {
|
||
this._repository.updateSessionCandidates?.(this._sessionRecordId, this._candidates.length)
|
||
}
|
||
return true
|
||
} catch (error) {
|
||
if (!abort.signal.aborted) {
|
||
logger.debug(
|
||
`제안 채우기 요청 실패 — 조용히 다음으로 넘어간다: ${error instanceof Error ? error.message : String(error)}`
|
||
)
|
||
}
|
||
return false
|
||
} finally {
|
||
clearTimeout(timer)
|
||
if (this._fillAbort === abort) this._fillAbort = null
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 모델 요청 하나를 스트리밍으로 받는다.
|
||
*
|
||
* 이어 쓰기는 첫 문장만 쓴다 — 모델이 그 뒤를 더 쓰기 시작하면 거기서 끊어 지연과 GPU 시간을 아낀다.
|
||
*/
|
||
private async _streamModel(
|
||
request: ModelRequest,
|
||
model: string,
|
||
temperature: number,
|
||
signal: AbortSignal,
|
||
onPartial?: (partial: string) => void
|
||
): Promise<string> {
|
||
let raw = ''
|
||
const stream = getLocalLLMService().streamGenerate(request.prompt, {
|
||
model,
|
||
systemPrompt: request.systemPrompt,
|
||
raw: request.raw,
|
||
stop: request.stop,
|
||
temperature,
|
||
maxTokens: SUGGESTION_DEFAULTS.maxOutputTokens,
|
||
signal,
|
||
keepAlive: SUGGESTION_KEEP_ALIVE
|
||
})
|
||
for await (const chunk of stream) {
|
||
if (signal.aborted) break
|
||
raw += chunk
|
||
// 최소 한 청크라도 도착했으면 모델이 메모리에 올라온 것 — 유지 시각을 갱신한다.
|
||
this._noteModelWarm(model)
|
||
onPartial?.(request.partial(raw))
|
||
if (raw.length >= MAX_RAW_OUTPUT_CHARS) break
|
||
if (request.raw && FIRST_SENTENCE_DONE.test(raw)) break
|
||
}
|
||
return raw
|
||
}
|
||
|
||
/** 정규화 후 완전 중복이거나 기존 후보의 접두/확장이면 중복으로 본다. */
|
||
private _isDuplicateCandidate(candidate: string): boolean {
|
||
const normalized = candidate.replace(/\s+/gu, ' ').trim().toLowerCase()
|
||
return this._candidates.some((existing) => {
|
||
const existingNormalized = existing.text.replace(/\s+/gu, ' ').trim().toLowerCase()
|
||
return (
|
||
existingNormalized === normalized ||
|
||
existingNormalized.startsWith(normalized) ||
|
||
normalized.startsWith(existingNormalized)
|
||
)
|
||
})
|
||
}
|
||
|
||
/**
|
||
* 생성 플래그를 무조건 해제한다 (누수 감시 포함).
|
||
*
|
||
* 응답 제한 + 여유를 넘겨 진행 중이면 비정상 상태로 보고 스스로 복구한다.
|
||
*/
|
||
private _releaseGeneration(): void {
|
||
this._inFlight = false
|
||
// 채우기 루프가 막 시작됐으면 generating 을 그대로 둔다 — 아직 더 올 게 있다.
|
||
// (루프 자신이 끝날 때 스스로 false 로 내린다)
|
||
if (!this._filling) this._generating = false
|
||
this._partialText = ''
|
||
}
|
||
|
||
/** 마지막 생성 이후 흐른 시간 (ms). */
|
||
get inFlightAgeMs(): number {
|
||
return this._inFlight ? Date.now() - this._budget.lastRequestAt : 0
|
||
}
|
||
|
||
/** 응답 제한 (설정 → SSOT 기본값). */
|
||
private readTimeoutMs(): number {
|
||
const configured = configGet('suggestionRequestTimeoutMs')
|
||
return configured && configured > 0 ? configured : SUGGESTION_DEFAULTS.requestTimeoutMs
|
||
}
|
||
|
||
/** 현재 정책 기준의 접두. */
|
||
private _currentPrefix(context: TypingContext): string {
|
||
return normalizeRequestPrefix(context.prefix)
|
||
}
|
||
|
||
/** 판단 입력을 서명이 바뀔 때만 남긴다. */
|
||
private _logDecisionInputs(context: TypingContext): void {
|
||
const signature = [
|
||
context.available,
|
||
context.isEditable,
|
||
context.isPassword,
|
||
context.isComposing,
|
||
context.anchor ? 'A' : '-',
|
||
context.editedSinceFocus,
|
||
context.typedRecently,
|
||
getLocalLLMService().isAvailable(),
|
||
this.isEnabled()
|
||
].join('|')
|
||
|
||
if (signature === this._lastDecisionSignature) return
|
||
this._lastDecisionSignature = signature
|
||
logger.info(
|
||
`제안 판단 입력: avail=${context.available} edit=${context.isEditable} pw=${context.isPassword} ` +
|
||
`comp=${context.isComposing} edited=${context.editedSinceFocus} typed=${context.typedRecently} ` +
|
||
`prefixLen=${context.prefix.length} idle=${context.idleMs}ms ` +
|
||
`app=${context.appName ?? '-'} enabled=${this.isEnabled()} ` +
|
||
`model=${getLocalLLMService().isAvailable()} anchor=${context.anchor ? 'yes' : 'no'}`
|
||
)
|
||
}
|
||
|
||
/**
|
||
* 생성 실패를 기록하고, 연속 실패면 잠시 쉰다.
|
||
*
|
||
* 실패할 때마다 새 요청이 스피너를 다시 걸면 "끝나지도 꺼지지도 않는" 것처럼 보인다
|
||
* (실측 신고). 임계 도달 시 쿨다운 동안은 요청 자체를 하지 않는다.
|
||
*/
|
||
private _noteFailure(reason: string): void {
|
||
if (!this._budget.noteFailure(Date.now())) return
|
||
logger.warn(
|
||
`제안 생성 연속 실패 (${reason}) — ${Math.round(
|
||
SUGGESTION_DEFAULTS.failureCooldownMs / 1000
|
||
)}초 동안 요청을 쉰다 (모델이 다른 작업으로 바쁠 수 있음)`
|
||
)
|
||
}
|
||
|
||
/** 이 모델이 방금 응답했다 — keep-alive 동안 메모리에 남아 있다고 본다. */
|
||
private _noteModelWarm(model: string): void {
|
||
this._warmth.noteWarm(model, Date.now() + SUGGESTION_KEEP_ALIVE_MS - SUGGESTION_KEEP_ALIVE_MARGIN_MS)
|
||
}
|
||
|
||
private _armVisibleTtl(): void {
|
||
if (this._ttlTimer) clearTimeout(this._ttlTimer)
|
||
this._ttlTimer = setTimeout(() => {
|
||
this._ttlTimer = null
|
||
logger.debug('제안 표시 수명 만료 — 자동으로 닫는다')
|
||
this.dismiss('stale')
|
||
}, SUGGESTION_DEFAULTS.visibleTtlMs)
|
||
this._ttlTimer.unref?.()
|
||
}
|
||
|
||
/** 표시 수명 타이머 해제. */
|
||
private _clearVisibleTtl(): void {
|
||
if (this._ttlTimer) {
|
||
clearTimeout(this._ttlTimer)
|
||
this._ttlTimer = null
|
||
}
|
||
}
|
||
|
||
private _abortStaleGeneration(currentPrefix: string): void {
|
||
if (!this._inFlight || !this._abort || this._abort.signal.aborted) return
|
||
// 세션 규칙과 같은 기준 — 요청 뒤 한 글자라도 자라면 결과는 도착하자마자 stale 이다.
|
||
const refresh = decideInFlightGeneration(this._lastRequestedPrefix, currentPrefix)
|
||
if (refresh === 'keep') return
|
||
|
||
this._generationToken += 1
|
||
this._abort.abort()
|
||
|
||
// 취소된 요청은 속도 제한 예산을 쓰지 않았던 것으로 되돌린다.
|
||
// (IME 조합 중 마지막 글자가 바뀌어 stale 로 잡히면, 취소가 예산을 갉아먹어
|
||
// 정작 사용자가 멈췄을 때 rate-limited 로 막히던 문제)
|
||
this._budget.refund()
|
||
// 보여줄 후보가 없으면 스피너만 남는다 — 오버레이를 지운다.
|
||
if (this._candidates.length === 0) this.dismiss('stale')
|
||
logger.debug(`제안 생성 취소 (${refresh}) — 다음 정상 입력 문맥에서만 재평가`)
|
||
}
|
||
|
||
/**
|
||
* 진행 플래그가 비정상적으로 오래 남았으면 강제 해제한다.
|
||
*
|
||
* 응답 제한(기본 8초) + 5초를 넘긴 in-flight 는 죽은 것으로 본다 —
|
||
* 어떤 예외 경로로든 플래그가 누수되면 제안이 영구히 멈추기 때문이다.
|
||
*/
|
||
private _watchdog(): void {
|
||
if (!this._inFlight) return
|
||
const age = Date.now() - this._budget.lastRequestAt
|
||
if (age < this.readTimeoutMs() + 5000) return
|
||
logger.warn(`제안 생성 플래그 누수 감지 (${age}ms) — 강제 해제`)
|
||
this._generationToken += 1
|
||
this._abort?.abort()
|
||
this._abort = null
|
||
if (this._timeoutTimer) {
|
||
clearTimeout(this._timeoutTimer)
|
||
this._timeoutTimer = null
|
||
}
|
||
this._releaseGeneration()
|
||
this._lastSkipReason = 'stale'
|
||
this.emit('updated', this.getState())
|
||
}
|
||
|
||
// ── 사용자 동작 ───────────────────────────────────────
|
||
|
||
/** 이전 후보로 순환 (전체 후보를 가로질러, 페이지 무관). */
|
||
previous(): SuggestionState {
|
||
if (this._candidates.length > 1) {
|
||
this._moveActive((this._activeIndex - 1 + this._candidates.length) % this._candidates.length)
|
||
}
|
||
return this.getState()
|
||
}
|
||
|
||
/**
|
||
* 다음 후보로 — 페이지는 활성 후보를 따라 넘어간다.
|
||
*
|
||
* 마지막 후보에서 아직 더 만드는 중이면 그 자리에 머문다: 처음으로 돌아가 버리면
|
||
* 곧 도착할 후보를 보려던 사용자가 길을 잃는다. 다 만들었으면 처음으로 돌아간다.
|
||
*/
|
||
next(): SuggestionState {
|
||
const last = this._candidates.length - 1
|
||
if (last < 1) return this.getState()
|
||
if (this._activeIndex < last) this._moveActive(this._activeIndex + 1)
|
||
else if (!this._filling) this._moveActive(0)
|
||
return this.getState()
|
||
}
|
||
|
||
/** 사용자가 후보를 훑는 중에는 표시 수명이 끝나 창이 닫히면 안 된다. */
|
||
private _moveActive(index: number): void {
|
||
this._activeIndex = index
|
||
this._armVisibleTtl()
|
||
this.emit('updated', this.getState())
|
||
}
|
||
|
||
dismiss(reason: SuggestionSkipReason = 'dismissed'): void {
|
||
if (reason === 'dismissed') {
|
||
// 명시적 닫기: 잠깐 조용히 있고, 진행 중 생성은 무효화한다.
|
||
this._userDismissedUntil = Date.now() + SUGGESTION_DEFAULTS.userDismissQuietMs
|
||
logger.info(`사용자가 제안을 닫음 — ${SUGGESTION_DEFAULTS.userDismissQuietMs}ms 동안 재표시하지 않는다`)
|
||
}
|
||
const wasVisible = this.isPresentationActive
|
||
// 진행 중이던 생성을 무효화한다 (닫았는데 잠시 뒤 결과가 다시 뜨는 것을 막는다).
|
||
this._generationToken += 1
|
||
this._clearVisibleTtl()
|
||
this._candidates = []
|
||
this._generating = false
|
||
this._warmingUp = false
|
||
this._partialText = ''
|
||
this._activeIndex = 0
|
||
this._anchor = null
|
||
this._anchorKind = null
|
||
this._generatedForPrefix = ''
|
||
this._targetTotal = 0
|
||
this._provenance = null
|
||
this._sessionRecordId = null
|
||
this._lastSkipReason = reason
|
||
this._abort?.abort()
|
||
this._abort = null
|
||
// 채우기 루프도 함께 끝낸다 — accept/dismiss/stale 은 전부 세션 종료다(설계).
|
||
this._filling = false
|
||
this._fillAbort?.abort()
|
||
this._fillAbort = null
|
||
if (this._timeoutTimer) {
|
||
clearTimeout(this._timeoutTimer)
|
||
this._timeoutTimer = null
|
||
}
|
||
// 워밍업은 오버레이 표시와 독립된 요청이다 — 포커스 전환/stale 등으로 오버레이를
|
||
// 지울 때마다 취소하면 모델이 영영 안 뜬다. 설정에서 기능을 끌 때만 취소한다.
|
||
if (reason === 'disabled') this._cancelWarmUp()
|
||
if (wasVisible || reason === 'dismissed') {
|
||
this.emit('cleared', { reason })
|
||
}
|
||
}
|
||
|
||
/** 활성 후보를 대상 앱에 삽입하고 수락으로 기록한다. */
|
||
async accept(index?: number): Promise<SuggestionRequestResult> {
|
||
if (index !== undefined && index >= 0 && index < this._candidates.length) {
|
||
this._activeIndex = index
|
||
}
|
||
const candidate = this._candidates[this._activeIndex]
|
||
if (!candidate) {
|
||
// 창이 이미 닫힌 뒤의 클릭·단축키 — 조용히 끝나면 "골라도 안 들어간다" 의 원인이 안 보인다.
|
||
logger.info(`제안 수락 무시: 표시 중인 후보 없음 (index=${index ?? 'active'})`)
|
||
return { ok: false, reason: 'already-visible' }
|
||
}
|
||
// 케어렛을 모르는 필드에서 문서 중간을 고친 뒤다 — 후보는 문서 끝의 이어 쓰기라
|
||
// 실제 커서(문서 중간)에 붙이면 엉뚱한 곳에 문장이 들어간다.
|
||
if (this._lastContext?.caretReliable === false) {
|
||
logger.info('제안 수락 거부: 케어렛 위치를 알 수 없고 마지막 편집이 문서 끝이 아니다')
|
||
this.dismiss('caret-unknown')
|
||
this.emit('state-changed', this.getState())
|
||
return { ok: false, reason: 'caret-unknown' }
|
||
}
|
||
// 후보는 정제 과정에서 앞 공백을 잃는다 — 커서 앞 원문의 마지막 글자를 보고 구분 공백을
|
||
// 붙인다(joinSuggestion). 세션을 닫기 전에(dismiss 가 세션 접두를 지운다) 계산한다.
|
||
const text = joinSuggestion(this._acceptPrefix(), candidate.text, candidate.joint ?? 'separate')
|
||
const appName = this._appName
|
||
const windowTitle = this._windowTitle
|
||
const targetWindow = this._windowHandle
|
||
const sessionRecordId = this._sessionRecordId
|
||
|
||
// 먼저 창을 닫고 생성을 멈춘다 — 수락은 즉시 반응해야 한다.
|
||
this.dismiss('accepted')
|
||
this.emit('state-changed', this.getState())
|
||
|
||
// 단축키로 수락했다면 사용자가 아직 Ctrl+Alt 를 쥐고 있다. 그대로 Ctrl+V 를 보내면
|
||
// 대상 앱에 Ctrl+Alt+V 가 들어가 붙여넣기가 되지 않는다(실측) — 뗄 때까지 기다린다.
|
||
const modifierWaitStartedAt = Date.now()
|
||
if (!(await waitForModifiersReleased())) {
|
||
logger.warn('수정자 키가 떼어지지 않은 채 제안을 삽입한다 (1.5초 초과)')
|
||
}
|
||
// "붙여넣기가 느리다" 신고 진단 — 수락 지연이 손 떼기 대기인지 삽입 자체인지 가른다.
|
||
logger.debug(`제안 수락: 수정자 키 떼기 대기 ${Date.now() - modifierWaitStartedAt}ms`)
|
||
|
||
// 붙여넣기(Ctrl+V)는 그 순간의 포그라운드 창으로 간다. 오버레이는 다음 스냅샷이 와야
|
||
// 닫히므로, 그사이 다른 앱으로 옮겨 간 뒤 수락하면 엉뚱한 창에 삽입됐다 — 세션을 만든
|
||
// 창이 아니면 삽입하지 않는다 (창을 알 수 없으면 기존처럼 진행한다).
|
||
if (targetWindow !== null) {
|
||
const currentWindow = this._foreground.currentWindowHandle()
|
||
if (currentWindow !== null && currentWindow !== targetWindow) {
|
||
logger.info(`제안 수락 취소: 포커스가 다른 창으로 옮겨 감 (app=${appName ?? '-'})`)
|
||
this._lastSkipReason = 'stale'
|
||
this.emit('state-changed', this.getState())
|
||
return { ok: false, reason: 'stale' }
|
||
}
|
||
}
|
||
|
||
// 삽입 직후의 텍스트 스냅샷 diff 가 이 텍스트를 "타이핑" 으로 다시 학습하지 않도록 알린다.
|
||
const cancelExpectedInsert = this._learning.expectProgrammaticInsert(text)
|
||
const method = configGet('insertMethod')
|
||
try {
|
||
const result = await getTextInsertService().insertText(
|
||
text,
|
||
method === 'keyboard' ? 'keyboard' : 'clipboard'
|
||
)
|
||
if (!result.success) {
|
||
cancelExpectedInsert()
|
||
logger.warn(`제안 삽입 실패 (method=${result.method}, len=${result.textLength})`)
|
||
return { ok: false, reason: 'generation-failed' }
|
||
}
|
||
} catch (error) {
|
||
cancelExpectedInsert()
|
||
logger.warn(`제안 삽입 예외: ${error instanceof Error ? error.message : String(error)}`)
|
||
return { ok: false, reason: 'generation-failed' }
|
||
}
|
||
|
||
logger.info(`제안 수락: ${text.length}자 삽입 (method=${method === 'keyboard' ? 'keyboard' : 'clipboard'}, app=${appName ?? '-'})`)
|
||
// 이력은 후보 원문으로 기록돼 있다 — 구분 공백이 붙은 삽입 문자열로는 찾지 못한다.
|
||
// 세션 행을 알면 그 행을 수락으로 표시한다 — 텍스트로 찾으면 로컬 기억의 2번째 이후 후보는
|
||
// 행이 없어 사라지거나 같은 문구의 옛 행(다른 앱·다른 날)이 수락으로 잡혔다.
|
||
if (sessionRecordId && this._repository.markSessionAccepted) {
|
||
this._repository.markSessionAccepted(sessionRecordId, candidate.text)
|
||
} else {
|
||
this._repository.markAccepted(candidate.text)
|
||
}
|
||
// 수락한 문장은 사용자 문체의 확실한 표본이다 (학습 동의 시에만 저장됨).
|
||
this._learning.recordAccepted(candidate.text, { appName, windowTitle })
|
||
return { ok: true }
|
||
}
|
||
|
||
/**
|
||
* 수락 시 이음새 판단에 쓸 커서 앞 원문.
|
||
*
|
||
* 세션 접두는 뒤 공백을 걷어낸 값이라, 사용자가 멈추기 전에 공백을 쳤는지 알 수 없다.
|
||
* 최신 문맥이 여전히 이 세션의 것이면(세션 규칙) 그 원문을, 아니면 세션 접두를 쓴다.
|
||
*/
|
||
private _acceptPrefix(): string {
|
||
const latest = this._lastContext
|
||
if (latest && matchesSessionPrefix(this._generatedForPrefix, latest.prefix)) return latest.prefix
|
||
return this._generatedForPrefix
|
||
}
|
||
|
||
getHistory(limit = 50): SuggestionHistoryEntry[] {
|
||
return this._repository.list(limit)
|
||
}
|
||
|
||
// ── 내부 ──────────────────────────────────────────────
|
||
|
||
private readPolicyConfig(): PolicyConfig {
|
||
return {
|
||
triggerDelayMs: Math.max(
|
||
SUGGESTION_DEFAULTS.minTriggerDelayMs,
|
||
configGet('suggestionTriggerDelayMs') || SUGGESTION_DEFAULTS.triggerDelayMs
|
||
),
|
||
minPrefixChars: configGet('suggestionMinPrefixChars') || SUGGESTION_DEFAULTS.minPrefixChars,
|
||
maxRequestsPerMinute:
|
||
Math.min(
|
||
configGet('suggestionMaxRequestsPerMinute') || SUGGESTION_DEFAULTS.maxRequestsPerMinute,
|
||
12
|
||
),
|
||
dailyBudget: configGet('suggestionDailyBudget') || SUGGESTION_DEFAULTS.dailyBudget,
|
||
maxCandidates: SUGGESTION_DEFAULTS.maxCandidates,
|
||
maxChars: SUGGESTION_MAX_OUTPUT_CHARS,
|
||
// 터미널은 셸 프롬프트라 문장 제안이 의미 없다 — 사용자 목록과 무관하게 뺀다.
|
||
// 터미널도 제안한다(입력 줄만 추출). 학습 제외는 InputTelemetryService 가 따로 한다.
|
||
excludedApps: [...configGet('inputExcludedApps')]
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 제안 이력 기록 — 접두(사용자가 친 글 원문)는 학습 동의가 있고 학습 제외 앱이 아닐 때만
|
||
* 남긴다(core shouldPersistSuggestionPrefix). 그 밖에는 빈 문자열로 남겨 개수·수락률만 유지한다.
|
||
*/
|
||
private _recordSuggestion(input: Omit<SuggestionRecordInput, 'appName'>): void {
|
||
const persistPrefix = shouldPersistSuggestionPrefix({
|
||
learnTypedText: configGet('inputLearnTypedText') === true,
|
||
appName: this._appName
|
||
})
|
||
const id = this._repository.record({ ...input, prefix: persistPrefix ? input.prefix : '', appName: this._appName })
|
||
this._sessionRecordId = typeof id === 'string' ? id : null
|
||
}
|
||
|
||
/** 테스트/진단 — 현재 앱이 제외 대상인지. */
|
||
isAppAllowed(appName: string | null): boolean {
|
||
if (!appName) return true
|
||
return !isAppExcluded(appName, configGet('inputExcludedApps'))
|
||
}
|
||
|
||
dispose(): void {
|
||
this.dismiss('disabled')
|
||
this._cancelWarmUp()
|
||
this.removeAllListeners()
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 스트리밍 중간 텍스트 정제 — 번호/불릿/따옴표와 지시문 누출을 화면에 잠깐
|
||
* 보여주지 않도록 줄 단위로 다듬는다.
|
||
*/
|
||
function sanitizePartial(raw: string): string {
|
||
const lines = raw
|
||
.split(/\r?\n/u)
|
||
.map((line) => sanitizeSuggestionLine(line, SUGGESTION_MAX_OUTPUT_CHARS) ?? line.trim())
|
||
.filter((line) => line.length > 0)
|
||
return lines.slice(0, 2).join(' ').slice(0, SUGGESTION_MAX_OUTPUT_CHARS)
|
||
}
|
||
|
||
/** 입력 텔레메트리가 맥락을 보낼 수 있는 상태인가 (수집 동의 + 일시정지 아님). */
|
||
export function hasInputContextConsent(): boolean {
|
||
return configGet('inputTelemetryEnabled') === true && configGet('inputTelemetryPaused') !== true
|
||
}
|
||
|
||
let instance: SuggestionService | null = null
|
||
|
||
export function getSuggestionService(): SuggestionService {
|
||
if (!instance) instance = new SuggestionService()
|
||
return instance
|
||
}
|
||
|
||
export function resetSuggestionServiceForTests(): void {
|
||
instance?.dispose()
|
||
instance = null
|
||
}
|