d3ro-voice/apps/desktop/src/main/services/InputTelemetryService.ts
Yun Chan cdeeff4c11 fix(suggestion): insert accepted suggestions reliably and learn typing as whole sentences
Acceptance waited for modifiers using only the uiohook-tracked set; a missed keyup
made it time out after 1.5 s and paste while Ctrl/Alt counted as held, so nothing
was inserted. Trust GetAsyncKeyState instead, and suppress new suggestions while an
accept is in flight.

Typed deltas were saved per snapshot (every 0.4-0.8 s), storing mid-word fragments.
Buffer them per field and save one diff on idle, sentence end, send or focus change;
drop short pieces, URLs, trailing jamo and truncated emoji.
2026-10-24 13:15:29 +09:00

1773 lines
68 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// src/main/services/InputTelemetryService.ts
//
// 입력 텔레메트리 수집기 — 키보드/마우스 집계 + 포커스 입력창 텍스트 학습.
//
// 설계 근거 (조사 기반):
// - 수집 항목·집계·flush 주기는 ActivityWatch `aw-watcher-input` 따른다:
// 카운트(keystrokes/clicks/scroll) + 마우스 이동량(축별 절대값 합)만 남기고
// **키 내용은 저장하지 않는다**. 5초 heartbeat 로 집계를 확정한다.
// - 키 이벤트는 uiohook(이미 사용 중) 글로벌 후킹에서 받는다. 후킹은 프로세스
// 전역 글턴이므로 global-input-hook 의 참조 카운트로 KeyBindingService 와 공존한다.
// - 이핑한 텍스트는 키코드로 복원하지 않는다 (한/일 IME 는 조합 결과가 텍스트라
// 원리적으로 불가). 대신 UIA 로 커밋된 텍스트를 읽어 스냅샷 diff 로 계산한다.
// - 비밀번호 필드(IsPassword)와 IME 조합 중에는 스트를 쓰지 않는다 (fail-closed).
//
// 동의(consent) 기본값은 모두 OFF 다. `inputTelemetryEnabled` 없이는 아무것도 하지 않는다.
import { EventEmitter } from 'events'
import { screen } from 'electron'
import { uIOhook } from 'uiohook-napi'
import type { UiohookKeyboardEvent, UiohookMouseEvent, UiohookWheelEvent } from 'uiohook-napi'
import { sql, gte, eq, desc, inArray } from 'drizzle-orm'
import {
INPUT_TELEMETRY_DEFAULTS,
SUGGESTION_CONTEXT_MAX_CHARS,
COMPOSING_IDLE_MULTIPLIER,
SUGGESTION_DEFAULTS,
calculateFrictionInsight,
classifyKeyStroke,
computeTypedDelta,
isEditAtTextEnd,
shouldLearnFromApp,
countWords,
emptyActivityBucket,
extractPhrases,
isLearnablePhrase,
isTerminalApp,
manhattanDistance,
mergeActivityBucket,
rankFlowWindows,
recommendAppExclusion,
summarizeActivity,
textBeforeCaret,
withoutPlaceholderText,
type AnchorKind,
type FocusSnapshot,
type InputActivityBucket,
type InputAppStat,
type InputAppSuggestionStat,
type InputDailyStat,
type InputHourlyStat,
type InputInsightsSummary,
type InputPrivacyReceipt,
type InputTelemetryState,
type InputSnapshotSummary,
type AppReadabilityEvidence,
type KeyStrokeClass,
type PersonalPhrase,
type PhraseSource,
type PhysicalRect
} from '@d3ro/core/input-intelligence'
import { RecentWritesBuffer, type RecentWrite, type RecentWriteMeta } from '@d3ro/core/recent-writes'
import { getDatabase } from '../db'
import { inputActivity, personalPhrases, suggestions as suggestionsTable, typingSamples } from '../db/schema'
import { configGet, configSet } from './ConfigService'
import { getLogger } from './LoggerService'
import { acquireGlobalInputHook } from './global-input-hook'
import { uiohookCodeToVk } from './KeyBindingService'
import { getUiaContextService } from './UiaContextService'
import { getForegroundWindowInfo } from '../utils/win32-foreground'
import { getPersonalGraphService } from './PersonalGraphService'
const logger = getLogger('InputTelemetryService')
/** 제안 서비스가 소비하는 "지금 치고 있는 것" 스냅샷. */
export interface TypingContext {
/** 어렛 앞 텍스트 (>제안 프롬프트 입력) */
prefix: string
fullText: string
caretOffset: number | null
/**
* 오버레이 앵커 — UIA 가 준 물리 픽셀 그대로다(사이드카가 DPI-aware 로 동작).
* DIP 변환은 창 배치(WindowManager → ScreenGeometryPort) 한 곳에서만 한다.
*/
anchor: PhysicalRect | null
/** anchor 가 케어렛인지 포커스 요소 전체인지 — 오버레이 배치 전략을 결정한다 */
anchorKind: AnchorKind
isPassword: boolean
isEditable: boolean
isComposing: boolean
hasSelection: boolean
available: boolean
appName: string | null
windowTitle: string | null
/**
* 입력창이 속한 최상위 창 핸들 (HWND). 알 수 없으면 null.
* 제안 수락 직전 "아직 같은 창인가" 를 확인하는 기준이다.
*/
windowHandle?: number | null
idleMs: number
capturedAt: number
/** 포커스가 바뀐 뒤 이 필드에서 실제로 편집이 있었는가 (마우스로 들어오기만 한 경우 false) */
editedSinceFocus: boolean
/** 최근에 실제로 타이핑했는가 (recentTypingWindowMs 이내) */
typedRecently: boolean
/**
* prefix 가 실제 커서 앞 텍스트라고 믿을 수 있는가 — 케어렛 오프셋을 알면 true, 모르면
* 마지막 편집이 문서 끝에서 일어났을 때만 true. 생략하면 true 로 본다(호환).
*/
caretReliable?: boolean
/**
* 커서 앞 문서 전체 (원문, 최대 DOCUMENT_BEFORE_MAX_CHARS). prefix 는 400자 창이라 글 앞쪽의
* 인사·이름·날짜를 모른다 — 제안 프롬프트가 첫머리·사실을 여기서 뽑는다.
* 문서형 컨트롤(터미널 버퍼 등)·비밀번호 칸은 null. 생략하면 prefix 만 쓴다(호환).
*/
documentBefore?: string | null
}
/** 제안 문맥으로 넘길 커서 앞 문서 길이 상한. */
const DOCUMENT_BEFORE_MAX_CHARS = 6000
interface InputTelemetryEvents {
'state-changed': (state: InputTelemetryState) => void
'typed-context': (context: TypingContext) => void
activity: (payload: { totals: InputActivityBucket; appName: string | null }) => void
}
interface ForegroundInfo {
appName: string | null
windowTitle: string | null
hwnd: number | null
}
const MAX_SAMPLE_CHARS = 500
/**
* 프로그램 삽입(제안 수락 등) 예고의 유효 시간.
*
* 수락은 수정자 키가 떼어지길 최대 1.5초 기다린 뒤 붙여넣고, 스냅샷은 디바운스(700ms)·
* settle·UIA 조회(최대 1.5초)를 거쳐 온다 — 그 합을 넉넉히 덮는다.
*/
const PROGRAMMATIC_INSERT_TTL_MS = 10_000
/**
* 타이핑 학습은 스냅샷 diff(0.4~0.8초마다)를 바로 저장하지 않고 필드별로 모았다가 문장 단위로 저장한다.
* 바로 저장하면 "찬받고 초콜릿을 받은 아이. 아빠" / "도 잘했으니까…" 처럼 단어 중간에서 잘린
* 조각이 표본·문구로 쌓여 제안 힌트를 오염시켰다(실측 2026-10-24 DB).
*/
const LEARN_IDLE_FLUSH_MS = 2000
/** diff 붙여넣기 판정(200자)에 걸리기 전에 끊어 저장한다. */
const LEARN_MAX_PENDING_CHARS = 150
const RETENTION_PRUNE_INTERVAL_MS = 6 * 60 * 60 * 1000
const MAX_READABILITY_APPS = 64
/**
* "실제로 타이핑했다" 로 볼 키 종류.
*
* 화살표/단축키/기능키/엔터/탭 등은 제외한다 — 필드 이동이나 명령일 뿐 텍스트를
* 치는 게 아니다. IME 조합은 포함한다(한/일 입력은 조합 중이 곧 타이핑이다).
*/
const TYPING_KEY_CLASSES = new Set<KeyStrokeClass>([
'letter',
'digit',
'symbol',
'space',
'backspace',
'delete',
'ime'
])
class InputTelemetryService extends EventEmitter {
private _running = false
private _releaseHook: (() => void) | null = null
/** 아직 DB에 쓰지 않은 버킷 (key = date|hour|appName) */
private _pending: Map<string, InputActivityBucket> = new Map()
/** 세션 누적 (라이브 UI 용) */
private _sessionTotals: InputActivityBucket = emptyActivityBucket()
private _flushTimer: NodeJS.Timeout | null = null
private _textTimer: NodeJS.Timeout | null = null
/** 디바운스 이후의 settle 스냅샷 — 제안 게이트는 더 늦게 열린다 */
private _settleTimer: NodeJS.Timeout | null = null
/** 백그라운드 주기 샘플러 — 타이핑이 이어져도 계속 관측한다 */
private _sampleTimer: NodeJS.Timeout | null = null
/** 주기 샘플 스냅샷 진행 중 (중복 방지) */
private _sampling = false
/** 제안 오버레이가 표시 중일 때만 포커스 이탈/선택을 계속 확인한다. */
private _suggestionPresentationActive = false
private _presentationValidationTimer: NodeJS.Timeout | null = null
private _lastEventAt = 0
/**
* 마지막 키보드 입력 시각.
*
* 제안 문맥은 키보드 기준으로만 판단한다 — 마우스 클릭만으로 스냅샷이 돌면
* 필드에 이미 있던 텍스트로 제안이 만들어졌다(실측 신고).
*/
private _lastKeyAt = 0
/**
* 마지막 "실제 타이핑" 시각 (TYPING_KEY_CLASSES 에 속하는 키만).
*
* `_lastKeyAt` 은 화살표/단축키를 포함한 모든 키를 기록해 필드 이동만으로도
* 갱신된다. 제안 게이트는 진짜 타이핑만 기준으로 삼아야 한다(실측: 필드에
* 이미 있던 텍스트를 마우스로 클릭만 했는데 제안이 뜸).
*/
private _lastTypedAt = 0
/** 현재 포커스된 (창, 컨트롤 종류, 위치)를 식별하는 키 — 바뀌면 새 필드로 본다. */
private _lastFocusKey = ''
/** 현재 포커스에 들어왔을 때의 텍스트 (비밀번호는 저장하지 않는다) — 편집 여부 판정 기준선. */
private _textAtFocus = ''
/** 직전 스냅샷의 (포커스 키, 텍스트) — 케어렛을 모를 때 편집 위치 판정에 쓴다 */
private _editProbe: { key: string; text: string } | null = null
/** 마지막 편집이 문서 끝에서 일어났는가 (케어렛을 모를 때만 의미가 있다) */
private _lastEditAtEnd = true
/** 클릭 뒤 첫 스냅샷에서 기준선을 다시 잡는다 */
private _rebaseFocusText = false
/** 포커스 깜빡임 뒤 돌아온 칸 — 키보드로 친 채 돌아왔으므로 이미 편집한 칸으로 본다 */
private _typedIntoFocus = false
/** 직전 스냅샷이 편집 가능한 칸이었는가 / 어느 창이었는가 (포커스 깜빡임 판정) */
private _prevSnapshotEditable = false
private _lastFocusHwnd: number | null = null
/** 이 창에서 조금 전에 쓴(보낸) 글 — 메모리 전용, 제안 문맥용 */
private readonly _recentWrites = new RecentWritesBuffer()
private _lastActiveTickAt = 0
private _lastMouse: { x: number; y: number } | null = null
private _lastClickAt = 0
private _lastClickButton = -1
private _lastClickPos: { x: number; y: number } | null = null
private _modifiers = { ctrl: false, alt: false, shift: false, meta: false }
private _foreground: ForegroundInfo = { appName: null, windowTitle: null, hwnd: null }
private _foregroundSampledAt = 0
private _lastSnapshot: FocusSnapshot | null = null
/** 마지막 스냅샷이 caret 폴백(tail 가정)을 썠는지 — 진단용 */
private _caretFallback = false
private _lastSnapshotKey = ''
private _lastContext: TypingContext | null = null
/** UI 진단용 스냅샷 요약 */
private _lastSnapshotSummary: InputSnapshotSummary | null = null
/** 원문 없이 앱별 UIA 읽기 가능성만 누적한다. */
private _appReadability = new Map<string, AppReadabilityEvidence>()
/** 곧(또는 방금) 프로그램이 삽입한 텍스트 — 다음 diff 에서 "타이핑" 으로 학습하지 않는다. */
private _expectedInserts: Array<{ id: number; text: string; expiresAt: number }> = []
/** 아직 저장하지 않은 타이핑 구간 — 같은 필드에서 baseline → latest 로 바뀐 부분을 한 번에 학습한다. */
private _pendingLearn: {
baseline: string
latest: string
appName: string | null
windowTitle: string | null
} | null = null
private _learnFlushTimer: ReturnType<typeof setTimeout> | null = null
private _expectedInsertSeq = 0
/** 통계에서 뺄 프로그램 키 남은 수와 유효 시각 */
private _programmaticKeys = 0
/** 진단용 마지막 키 종류 (키 값 아님) */
private _lastKeyDiag = '-'
private _programmaticKeysUntil = 0
private _prunedAt = 0
private _onKeyDown: ((e: UiohookKeyboardEvent) => void) | null = null
private _onKeyUp: ((e: UiohookKeyboardEvent) => void) | null = null
private _onMouseDown: ((e: UiohookMouseEvent) => void) | null = null
private _onMouseUp: ((e: UiohookMouseEvent) => void) | null = null
private _onMouseMove: ((e: UiohookMouseEvent) => void) | null = null
private _onWheel: ((e: UiohookWheelEvent) => void) | null = null
// ── 타입 안전한 이벤트 오버로드 ────────────────────────
override on<K extends keyof InputTelemetryEvents>(event: K, listener: InputTelemetryEvents[K]): this {
return super.on(event, listener as (...args: unknown[]) => void)
}
override off<K extends keyof InputTelemetryEvents>(
event: K,
listener: InputTelemetryEvents[K]
): this {
return super.off(event, listener as (...args: unknown[]) => void)
}
override emit<K extends keyof InputTelemetryEvents>(
event: K,
...args: Parameters<InputTelemetryEvents[K]>
): boolean {
return super.emit(event, ...args)
}
get isRunning(): boolean {
return this._running
}
get lastContext(): TypingContext | null {
return this._lastContext
}
/** 마지막 키보드 입력 시각 (ms) — 오타 교정이 "스냅샷 뒤 사용자가 더 쳤는가" 를 확인한다. */
get lastKeyAt(): number {
return this._lastKeyAt
}
/**
* 곧 프로그램이 키 count 개를 보낸다 — 그 키들은 입력 통계에 넣지 않는다.
* 남은 예고는 ttlMs 뒤 무효다(보내지 못한 키가 사용자 키를 삼키지 않게).
*/
expectProgrammaticKeys(count: number, ttlMs = 3000): void {
this._programmaticKeys = Math.max(0, count)
this._programmaticKeysUntil = Date.now() + ttlMs
}
setSuggestionPresentationActive(active: boolean): void {
this._suggestionPresentationActive = active
if (!active && this._presentationValidationTimer) {
clearTimeout(this._presentationValidationTimer)
this._presentationValidationTimer = null
}
}
// ─ 수명 주기 ──────────────────────────────────────────
/** 설정이 허용하면 수집을 시작한다. 실패해도 앱은 계속 돌아간다. */
start(): void {
if (!this._isEnabledByConfig()) {
logger.info('입력 텔레메트리 비활성 (설정 또는 일시정지)')
return
}
if (this._running) return
try {
this._onKeyDown = (e: UiohookKeyboardEvent) => this._handleKeyDown(e)
this._onKeyUp = (e: UiohookKeyboardEvent) => this._handleKeyUp(e)
this._onMouseDown = (e: UiohookMouseEvent) => this._handleMouseDown(e)
this._onMouseUp = (e: UiohookMouseEvent) => this._handleMouseUp(e)
this._onMouseMove = (e: UiohookMouseEvent) => this._handleMouseMove(e)
this._onWheel = (e: UiohookWheelEvent) => this._handleWheel(e)
uIOhook.on('keydown', this._onKeyDown)
uIOhook.on('keyup', this._onKeyUp)
uIOhook.on('mousedown', this._onMouseDown)
uIOhook.on('mouseup', this._onMouseUp)
uIOhook.on('mousemove', this._onMouseMove)
uIOhook.on('wheel', this._onWheel)
this._releaseHook = acquireGlobalInputHook()
this._running = true
this._flushTimer = setInterval(
() => this._flush(),
INPUT_TELEMETRY_DEFAULTS.flushIntervalMs
)
this._flushTimer.unref?.()
// 주기 샘플러.
//
// 스냅샷이 "타이핑을 멈춘 뒤" 에만 돌면, 계속 치는 동안에는 디바운스 타이머가
// 계속 리셋돼 샘플이 하나도 만들어지지 않는다(실측: 에이전트 개발처럼
// 끊김 없이 치는 상황에서 제안이 전혀 안 뜸). 최근 입력이 있었으면
// 주기적으로 스냅샷을 만들어, 타이핑 중에도 제안이 계속 갱신되게 한다.
this._sampleTimer = setInterval(
() => this._sampleWhileTyping(),
INPUT_TELEMETRY_DEFAULTS.sampleIntervalMs
)
this._sampleTimer.unref?.()
this._pruneOldData()
logger.info('입력 텔레메트리 시작 (키/마우스 집계)')
this._emitState()
} catch (error) {
logger.error(
`입력 텔레메트리 시작 실패: ${error instanceof Error ? error.message : String(error)}`
)
this._detachListeners()
}
}
stop(): void {
// 입력 관찰을 끄면 메모리에 잡아 둔 "조금 전에 쓴 글" 도 버린다.
this._recentWrites.clear()
if (!this._running) {
this.setSuggestionPresentationActive(false)
return
}
this._detachListeners()
this._releaseHook?.()
this._releaseHook = null
this._running = false
if (this._flushTimer) {
clearInterval(this._flushTimer)
this._flushTimer = null
}
if (this._sampleTimer) {
clearInterval(this._sampleTimer)
this._sampleTimer = null
}
if (this._textTimer) {
clearTimeout(this._textTimer)
this._textTimer = null
}
if (this._settleTimer) {
clearTimeout(this._settleTimer)
this._settleTimer = null
}
this.setSuggestionPresentationActive(false)
this.flushPendingLearning()
this._flush()
this._lastSnapshot = null
this._lastSnapshotKey = ''
logger.info('입력 텔레메트리 중지')
this._emitState()
}
/** 설정 변경 반영 (enable/pause/excludedApps). */
applyConfig(): void {
const shouldRun = this._isEnabledByConfig()
if (shouldRun && !this._running) this.start()
else if (!shouldRun && this._running) this.stop()
this._emitState()
}
dispose(): void {
this.stop()
this._recentWrites.clear()
this.removeAllListeners()
}
/** 같은 창에서 조금 전에 쓴(보내서 칸이 비워진) 글 — 오래된 것부터. 메모리에만 있다. */
listRecentWrites(meta: RecentWriteMeta, limit = 4): RecentWrite[] {
return this._recentWrites.listFor(meta, Date.now(), limit)
}
private _detachListeners(): void {
if (this._onKeyDown) {
uIOhook.removeListener('keydown', this._onKeyDown)
this._onKeyDown = null
}
if (this._onKeyUp) {
uIOhook.removeListener('keyup', this._onKeyUp)
this._onKeyUp = null
}
if (this._onMouseDown) {
uIOhook.removeListener('mousedown', this._onMouseDown)
this._onMouseDown = null
}
if (this._onMouseUp) {
uIOhook.removeListener('mouseup', this._onMouseUp)
this._onMouseUp = null
}
if (this._onMouseMove) {
uIOhook.removeListener('mousemove', this._onMouseMove)
this._onMouseMove = null
}
if (this._onWheel) {
uIOhook.removeListener('wheel', this._onWheel)
this._onWheel = null
}
}
private _isEnabledByConfig(): boolean {
return configGet('inputTelemetryEnabled') === true && configGet('inputTelemetryPaused') !== true
}
// ── 이벤트 수집 ────────────────────────────────────────
private _handleKeyDown(event: UiohookKeyboardEvent): void {
this._syncModifiers(event)
// 프로그램이 보낸 키(오타 교정의 백스페이스·붙여넣기)는 통계에 넣지 않는다 — 사용자의
// 수정 빈도(backspaces)를 부풀린다. 시각·스냅샷 예약은 그대로 해 교정 뒤 문맥을 다시 읽는다.
if (this._programmaticKeys > 0 && Date.now() <= this._programmaticKeysUntil) {
this._programmaticKeys -= 1
this._lastKeyAt = Date.now()
this._scheduleTextSnapshot()
return
}
this._registerInput(true)
const bucket = this._bucket()
// uiohook 키코드는 VK 와 다른 표계다 — 정본(VK)으로 변환해 분류한다.
const vk = uiohookCodeToVk(event.keycode)
// 한글·일본어 IME 가 켜져 있으면 Windows 는 글자 키를 VK_PROCESSKEY 로 넘기고, uiohook 은 그것을
// 변환표에 없는 키코드로 보낸다 — 그대로 'other' 로 두면 한글 타이핑 전체가 "타이핑 아님" 이 되어
// 제안이 영영 뜨지 않았다(2026-10-03 실측: 글자 키가 전부 key=other). 수정자 없이 눌린 미지의
// 키는 IME 조합 키로 본다. 실제 텍스트 변화(editedSinceFocus)가 함께 있어야 제안이 열린다.
const keyClass =
vk === null
? this._modifiers.ctrl || this._modifiers.alt || this._modifiers.meta
? 'shortcut'
: 'ime'
: classifyKeyStroke(vk, this._modifiers)
if (keyClass === 'shortcut') bucket.shortcuts += 1
else bucket.keystrokes += 1
if (keyClass === 'backspace') bucket.backspaces += 1
this._lastKeyAt = Date.now()
if (TYPING_KEY_CLASSES.has(keyClass)) this._lastTypedAt = this._lastKeyAt
// 진단: 키 값이 아니라 종류·수정자만 남긴다 (typed 판정이 왜 틀리는지 로그로 보이게)
this._lastKeyDiag = `${keyClass}${vk === null ? `?${event.keycode}` : ''}${this._modifiers.ctrl ? '+C' : ''}${this._modifiers.alt ? '+A' : ''}${this._modifiers.meta ? '+M' : ''}`
this._scheduleTextSnapshot()
}
private _handleKeyUp(event: UiohookKeyboardEvent): void {
this._syncModifiers(event)
}
private _handleMouseDown(event: UiohookMouseEvent): void {
this._registerInput(false)
const now = Date.now()
const position = { x: event.x, y: event.y }
const button = Number(event.button)
const isDoubleClick =
now - this._lastClickAt < 400 &&
this._lastClickButton === button &&
this._lastClickPos !== null &&
manhattanDistance(this._lastClickPos, position) < 6
const bucket = this._bucket()
if (isDoubleClick) bucket.doubleClicks += 1
else bucket.clicks += 1
this._lastClickAt = now
this._lastClickButton = button
this._lastClickPos = position
// 클릭은 다른 칸으로 옮겨 갔을 수 있다 — 다음 스냅샷의 텍스트를 새 기준으로 삼는다.
this._rebaseFocusText = true
}
private _handleMouseUp(event: UiohookMouseEvent): void {
this._lastMouse = { x: event.x, y: event.y }
if (!this._suggestionPresentationActive) return
if (this._presentationValidationTimer) clearTimeout(this._presentationValidationTimer)
this._presentationValidationTimer = setTimeout(() => {
this._presentationValidationTimer = null
void this._captureTextSnapshot()
}, 120)
this._presentationValidationTimer.unref?.()
}
private _handleMouseMove(event: UiohookMouseEvent): void {
const position = { x: event.x, y: event.y }
if (this._lastMouse) {
const distance = manhattanDistance(this._lastMouse, position)
// 픽셀 단위 미세抖动 제거 (ActivityWatch 는 전량 누적하지만 노이즈가 크다)
if (distance >= 2) {
this._bucket().mouseDistancePx += distance
this._registerInput(false)
}
}
this._lastMouse = position
}
private _handleWheel(event: UiohookWheelEvent): void {
const bucket = this._bucket()
bucket.scrollTicks += Math.max(1, Math.abs(Number(event.rotation) || 1))
this._registerInput(false)
}
/**
* 활성 시간 누적 + 포그라운드 샘플링.
*
* ActivityWatch 처럼 "입력이 있으면 활성" 으로 판단한다. 연속 입력 간격이
* activeIdleTimeoutMs 를 넘으면 그 구간은 활성 시간에서 제외한다.
*/
private _registerInput(isKeyboard: boolean): void {
const now = Date.now()
const gap = this._lastEventAt === 0 ? 0 : now - this._lastEventAt
if (gap > 0 && gap <= INPUT_TELEMETRY_DEFAULTS.activeIdleTimeoutMs) {
this._bucket().activeMs += gap
} else if (isKeyboard && this._lastActiveTickAt > 0) {
this._bucket().activeMs += 250
}
if (isKeyboard) this._lastActiveTickAt = now
this._lastEventAt = now
this._sampleForeground(now)
}
/**
* 수정자 상태 — uiohook 이 모든 키 이벤트에 실어 보내는 플래그를 그대로 다.
* (별도 상태 머신을 두면 키 반복/포커스 이동에서 어긋난다)
*/
private _syncModifiers(event: UiohookKeyboardEvent): void {
this._modifiers = {
ctrl: event.ctrlKey === true,
alt: event.altKey === true,
shift: event.shiftKey === true,
meta: event.metaKey === true
}
}
/** 포그라운드 창 정보 — 1초에 한 번만 갱신 (FFI 호출 비용) */
private _sampleForeground(now = Date.now()): void {
if (now - this._foregroundSampledAt < INPUT_TELEMETRY_DEFAULTS.activeWindowSampleMinIntervalMs) {
return
}
this._foregroundSampledAt = now
const info = getForegroundWindowInfo()
if (info) {
this._foreground = {
appName: info.appName || null,
windowTitle: info.title || null,
hwnd: info.hwnd
}
}
}
/** 이 시각의 (날짜, 시간, 앱) 버킷 */
private _bucket(now = new Date()): InputActivityBucket {
const date = formatLocalDate(now)
const hour = now.getHours()
const appName = this._foreground.appName ?? ''
const key = `${date}|${hour}|${appName}`
let bucket = this._pending.get(key)
if (!bucket) {
bucket = emptyActivityBucket()
this._pending.set(key, bucket)
}
return bucket
}
// ── 텍스트 학습 (UIA 스냅샷 diff) ──────────────────────
/**
* 최근 입력이 있었으면 주기적으로 스냅샷을 만든다 (백그라운드 관측).
*
* 입력이 끊긴 뒤에는 굳이 돌리지 않는다 — 그 시점은 디바운스/ settle 타이머가
* 이미 담당한다.
*/
private async _sampleWhileTyping(): Promise<void> {
if (!this._running || this._sampling) return
const hasRecentKeyboardInput =
this._lastKeyAt > 0 &&
Date.now() - this._lastKeyAt <= INPUT_TELEMETRY_DEFAULTS.sampleActiveWindowMs
if (!hasRecentKeyboardInput && !this._suggestionPresentationActive) return
this._sampling = true
try {
await this._captureTextSnapshot()
} finally {
this._sampling = false
}
}
private _scheduleTextSnapshot(): void {
if (this._textTimer) clearTimeout(this._textTimer)
this._textTimer = setTimeout(() => {
this._textTimer = null
void this._captureTextSnapshot()
}, INPUT_TELEMETRY_DEFAULTS.textSnapshotDebounceMs)
this._textTimer.unref?.()
// 제안 트리거 지연(기본 1000ms)이 스냅샷 디바운스(700ms)보다 크다. 스냅샷이
// 디바운스에만 돌면 "타이핑을 멈춘 뒤 N ms" 조건이 결코 충족되지 않아
// 제안이 영원히 요청되지 않는다(실측: debounce 로그만 반복). 그래서
// 트리거 지연을 넘긴 시점에 한 번 더 스냅샷을 돌려 게이트를 연다.
if (this._settleTimer) clearTimeout(this._settleTimer)
// 조합 중(한글은 멈출 때 거의 늘 조합 중이다)에 필요한 유휴 시간을 막 넘긴 순간에 찍는다 — 예전엔
// 지연+400ms(=1초)라 멈춘 뒤 제안이 그만큼 늦게 시작됐다(실측 2026-10-17: "빠릿하지 않다").
const settleDelay = Math.max(
INPUT_TELEMETRY_DEFAULTS.textSnapshotDebounceMs + 50,
Math.ceil((configGet('suggestionTriggerDelayMs') || SUGGESTION_DEFAULTS.triggerDelayMs) * COMPOSING_IDLE_MULTIPLIER) + 60
)
this._settleTimer = setTimeout(() => {
this._settleTimer = null
void this._captureTextSnapshot()
}, settleDelay)
this._settleTimer.unref?.()
}
/**
* 포커스 입력창 스냅샷을 읽어 (1) 타이핑 통계를 갱신하고
* (2) 제안 서비스에 컨텍스트 이벤트를 보낸다.
*/
private async _captureTextSnapshot(): Promise<TypingContext | null> {
if (!this._running) return null
const uia = getUiaContextService()
const snapshot = withoutPlaceholderText(await uia.getSnapshot())
const now = Date.now()
// 유휴 시간은 키보드 기준이다 (마우스 이동/클릭으로는 제안하지 않는다).
const idleMs = this._lastKeyAt > 0 ? now - this._lastKeyAt : Number.MAX_SAFE_INTEGER
const typedRecently =
this._lastTypedAt > 0 && now - this._lastTypedAt <= SUGGESTION_DEFAULTS.recentTypingWindowMs
const context: TypingContext = {
prefix: '',
fullText: '',
caretOffset: null,
anchor: null,
anchorKind: null,
isPassword: snapshot.isPassword,
isEditable: snapshot.isEditable,
isComposing: snapshot.isComposing,
hasSelection: snapshot.hasSelection,
available: snapshot.available,
appName: this._foreground.appName,
windowTitle: snapshot.windowTitle ?? this._foreground.windowTitle,
windowHandle: this._foreground.hwnd,
idleMs,
capturedAt: snapshot.capturedAt,
editedSinceFocus: false,
typedRecently
}
if (snapshot.available) {
const usesCaretRect = snapshot.caretRect !== null
context.anchor = snapshot.caretRect ?? snapshot.elementRect
context.anchorKind = usesCaretRect ? 'caret' : snapshot.elementRect ? 'element' : null
context.caretOffset = snapshot.caretOffset
context.fullText = snapshot.text
// 케어렛 오프셋을 못 얻는 제공자가 많다(실측: Notepad — src=value, caret=null).
// 그때는 "문서 마지막 = 커서 앞" 으로 가정해 tail 만 쓴다. 문서 전체를 접두로
// 쓰면 프롬프트가 실제 입력 위치와 무관해진다.
const caretKnown = snapshot.caretOffset !== null
// 문서형 컨트롤(터미널 버퍼 등)은 tail 이 직전 출력/이전 줄까지 포함한다.
// "지금 치는 줄" 만 접두로 써야 한다 — 마지막 줄을 취한다.
const documentLike = snapshot.textSource === 'text'
const tail = snapshot.text.slice(-SUGGESTION_CONTEXT_MAX_CHARS)
context.prefix = caretKnown
? textBeforeCaret(snapshot.text, snapshot.caretOffset)
: documentLike
? lastLineOf(tail)
: tail
const documentBefore = snapshot.isPassword
? null
: caretKnown
? snapshot.text.slice(0, snapshot.caretOffset ?? snapshot.text.length)
: documentLike
? null
: snapshot.text
context.documentBefore = documentBefore === null ? null : documentBefore.slice(-DOCUMENT_BEFORE_MAX_CHARS)
this._caretFallback = !caretKnown
// 포커스 식별: 칸이 바뀌었거나 클릭이 있었으면 그 시점 텍스트를 기준선으로 저장한다
// (비밀번호는 비운다). 마우스로 칸에 들어오기만 하고 아무것도 안 쳤으면 기준선과
// 현재 텍스트가 같아 editedSinceFocus 가 false 로 남는다(실측: YouTube 검색창 클릭만
// 했는데 옛 검색어로 제안이 뜸).
const focusKey = computeFocusKey(this._foreground.hwnd, snapshot.controlType ?? null, snapshot.controlName ?? null)
const textForFocus = snapshot.isPassword ? '' : snapshot.text
if (focusKey !== this._lastFocusKey || this._rebaseFocusText) {
// 포커스 깜빡임: 같은 창에서 타이핑하는 동안 UIA 포커스가 입력칸 ↔ 읽을 수 없는 요소(legacy)를
// 오간다(실측 Chrome 2026-10-03: 보류 사유 not-typing 122회). 그때마다 기준선을 다시 잡으면
// 방금 친 글이 "들어올 때부터 있던 글" 이 되어 제안이 영영 안 뜬다. 클릭 없이 키보드로 치다가
// 읽을 수 없는 요소를 거쳐 같은 창의 입력칸으로 돌아온 것이면 이미 편집한 칸으로 본다.
const now = Date.now()
this._typedIntoFocus =
!this._rebaseFocusText &&
this._foreground.hwnd !== null &&
this._foreground.hwnd === this._lastFocusHwnd &&
!this._prevSnapshotEditable &&
this._lastTypedAt > this._lastClickAt &&
now - this._lastTypedAt <= SUGGESTION_DEFAULTS.recentTypingWindowMs
this._lastFocusKey = focusKey
this._textAtFocus = textForFocus
this._rebaseFocusText = false
}
context.editedSinceFocus = textForFocus !== this._textAtFocus || this._typedIntoFocus
// 보내면 비워지는 칸(채팅)의 직전 내용을 "이 창에서 조금 전에 쓴 글" 로 잠시 기억한다.
// 비밀번호·편집 불가 칸과 터미널(명령 기록)은 보지 않는다. 조합 중인 칸도 본다 — 한글은 보내기 직전
// 스냅샷이 거의 늘 조합 중이라, 빼면 보낸 글이 하나도 기억되지 않았다(실측 2026-10-17 에이전트 창 comp=true 연속).
if (snapshot.isEditable && !snapshot.isPassword && !isTerminalApp(this._foreground.appName)) {
this._recentWrites.observe(
focusKey,
snapshot.text,
{ windowHandle: this._foreground.hwnd, appName: this._foreground.appName, windowTitle: context.windowTitle },
Date.now()
)
}
// 케어렛을 모르면 "문서 끝 = 커서" 가정이 맞는지 마지막 편집 위치로 확인한다.
// 문서 중간을 고쳤다면 접두(문서 끝)는 커서와 무관하다 — 제안·수락을 막는다.
if (this._editProbe === null || this._editProbe.key !== focusKey) {
this._lastEditAtEnd = true
} else if (this._editProbe.text !== textForFocus) {
this._lastEditAtEnd = isEditAtTextEnd(this._editProbe.text, textForFocus)
}
this._editProbe = { key: focusKey, text: textForFocus }
context.caretReliable = caretKnown || this._lastEditAtEnd
if (snapshot.isEditable && !snapshot.isPassword && !snapshot.isComposing) {
this._applyTypedDelta(snapshot)
}
}
// 포커스 깜빡임 판정용 — 이번 스냅샷이 편집 가능한 칸이었는가, 어느 창이었는가.
this._prevSnapshotEditable = snapshot.available && snapshot.isEditable
this._lastFocusHwnd = this._foreground.hwnd
this._recordReadabilityEvidence(snapshot)
// 진단: 왜 제안이 안 뜨는지 로그만으로 판단할 수 있게 스냅샷 요약을 남긴다.
logger.debug(
`입력 스냅샷: avail=${snapshot.available} edit=${snapshot.isEditable} ` +
`pw=${snapshot.isPassword} comp=${snapshot.isComposing} src=${snapshot.textSource} ` +
`len=${snapshot.text.length} caret=${snapshot.caretOffset ?? -1} tail=${this._caretFallback} ` +
`anchor=${context.anchor ? 'yes' : 'no'} app=${this._foreground.appName ?? '-'} ` +
`reason=${snapshot.reason ?? '-'} key=${this._lastKeyDiag}`
)
this._lastSnapshotSummary = {
at: context.capturedAt,
appName: this._foreground.appName,
windowTitle: snapshot.windowTitle ?? this._foreground.windowTitle,
editable: snapshot.isEditable,
isPassword: snapshot.isPassword,
composing: snapshot.isComposing,
textSource: snapshot.textSource,
textLength: snapshot.text.length,
caretFallback: this._caretFallback
}
this._lastContext = context
this.emit('typed-context', context)
// 진단 줄이 즉시 갱신되도록 상태 변경을 알린다 (키 입력마다가 아니라 스냅샷마다).
this._emitState()
return context
}
private _recordReadabilityEvidence(snapshot: FocusSnapshot): void {
const appName = this._foreground.appName?.trim()
if (!appName || snapshot.isPassword) return
let evidence = this._appReadability.get(appName)
if (!evidence) {
if (this._appReadability.size >= MAX_READABILITY_APPS) {
const oldest = this._appReadability.keys().next().value
if (oldest) this._appReadability.delete(oldest)
}
evidence = { appName, samples: 0, readable: 0, unreadable: 0, empty: 0 }
this._appReadability.set(appName, evidence)
}
evidence.samples += 1
if (snapshot.isEditable && snapshot.textSource !== 'none' && snapshot.text.length > 0) {
evidence.readable += 1
} else if (snapshot.isEditable && snapshot.textSource !== 'none' && snapshot.text.length === 0) {
evidence.empty += 1
} else {
evidence.unreadable += 1
}
}
private _applyTypedDelta(snapshot: FocusSnapshot): void {
const key = `${snapshot.windowTitle ?? ''}|${snapshot.controlName ?? ''}|${snapshot.controlType ?? ''}`
const previous = this._lastSnapshot
const focusChanged = key !== this._lastSnapshotKey
this._lastSnapshot = snapshot
this._lastSnapshotKey = key
// 필드가 바뀌면 이전 텍스트와 diff 할 수 없다 — 모아 둔 학습을 저장하고 기준선만 잡는다.
if (focusChanged || !previous) {
this.flushPendingLearning()
return
}
const keepText = configGet('inputLearnTypedText') === true
const delta = computeTypedDelta(previous.text, snapshot.text, { keepText })
if (delta.replaced) {
// 붙여넣기 — 직접 친 글이 아니다. 그 앞까지 친 것만 저장하고 새로 모은다.
this._flushPendingLearningAt(previous.text)
return
}
if (delta.insertedChars === 0 && delta.insertedWords === 0) {
// 지우기만 했다. 칸이 비었거나 기준선보다 짧아졌으면(메시지 전송 등) 비우기 직전까지가 친 글이다.
const pending = this._pendingLearn
if (pending && (snapshot.text.length === 0 || snapshot.text.length < pending.baseline.length)) {
this._flushPendingLearningAt(previous.text)
} else if (pending) {
pending.latest = snapshot.text
}
return
}
const bucket = this._bucket()
bucket.chars += delta.insertedChars
bucket.words += delta.insertedWords
bucket.sentences += delta.insertedSentences
if (!delta.insertedText) return
const typedText = this._withoutExpectedInsert(delta.insertedText)
if (typedText !== delta.insertedText) {
// 프로그램 삽입(제안 수락 등)이 섞였다 — 그 앞까지 모은 것을 저장하고, 이번에 직접 친
// 나머지만 바로 학습한다. 다음 diff 부터는 삽입 뒤 텍스트를 기준선으로 다시 모은다.
this._flushPendingLearningAt(previous.text)
if (typedText) {
this._learnText(typedText, {
appName: this._foreground.appName,
windowTitle: snapshot.windowTitle ?? this._foreground.windowTitle,
source: 'typed'
})
}
return
}
if (!this._pendingLearn) {
this._pendingLearn = {
baseline: previous.text,
latest: snapshot.text,
appName: this._foreground.appName,
windowTitle: snapshot.windowTitle ?? this._foreground.windowTitle
}
} else {
this._pendingLearn.latest = snapshot.text
}
const grown = snapshot.text.length - this._pendingLearn.baseline.length
if (/[.!?…。?!\n]\s*$/u.test(snapshot.text) || grown >= LEARN_MAX_PENDING_CHARS) {
this.flushPendingLearning()
return
}
this._scheduleLearnFlush()
}
private _scheduleLearnFlush(): void {
if (this._learnFlushTimer) clearTimeout(this._learnFlushTimer)
this._learnFlushTimer = setTimeout(() => {
this._learnFlushTimer = null
this.flushPendingLearning()
}, LEARN_IDLE_FLUSH_MS)
}
/** 모아 둔 타이핑 구간을 지금 학습한다 (멈춤·문장 끝·포커스 이동·종료 시). */
flushPendingLearning(): void {
this._flushPendingLearningAt(null)
}
private _flushPendingLearningAt(latestOverride: string | null): void {
const pending = this._pendingLearn
this._discardPendingLearning()
if (!pending || configGet('inputLearnTypedText') !== true) return
// baseline → latest 를 한 번에 diff 한다 — 친 뒤 지운 오타·IME 가 바꾼 글자는 최종 결과만 남는다.
const delta = computeTypedDelta(pending.baseline, latestOverride ?? pending.latest, { keepText: true })
if (delta.replaced || !delta.insertedText) return
this._learnText(delta.insertedText, {
appName: pending.appName,
windowTitle: pending.windowTitle,
source: 'typed'
})
}
private _discardPendingLearning(): void {
if (this._learnFlushTimer) {
clearTimeout(this._learnFlushTimer)
this._learnFlushTimer = null
}
this._pendingLearn = null
}
/**
* 곧 프로그램이 이 텍스트를 삽입한다 (제안 수락 · 받아쓰기 삽입).
*
* 삽입된 텍스트는 다음 스냅샷 diff 에 그대로 나타난다. 붙여넣기 판정 임계(200자)보다
* 짧으면 "타이핑" 으로 다시 학습돼, 삽입 경로가 이미 출처(source)를 붙여 기록한 문장이
* 두 번 쌓이고 제안이 자기 출력을 강화했다. 예고된 텍스트는 diff 학습에서 뺀다.
*
* 삽입이 실패했으면 돌려준 함수로 예고를 취소한다.
*/
expectProgrammaticInsert(text: string): () => void {
const trimmed = text.trim()
if (!trimmed) return () => undefined
const now = Date.now()
this._pruneExpectedInserts(now)
this._expectedInsertSeq += 1
const id = this._expectedInsertSeq
this._expectedInserts.push({ id, text: trimmed, expiresAt: now + PROGRAMMATIC_INSERT_TTL_MS })
return () => {
this._expectedInserts = this._expectedInserts.filter((entry) => entry.id !== id)
}
}
private _pruneExpectedInserts(now: number): void {
if (this._expectedInserts.length === 0) return
this._expectedInserts = this._expectedInserts.filter((entry) => entry.expiresAt > now)
}
/**
* diff 로 얻은 삽입 텍스트에서 예고된 프로그램 삽입을 뺀 "실제 타이핑" 부분.
*
* - 삽입 구간이 예고 텍스트를 품으면 그 부분만 빼고 나머지(앞뒤로 직접 친 글)는 남긴다.
* - diff 경계가 반복 글자에서 한 칸 밀려 회전된 형태로 잡힌 경우도 같은 텍스트로 본다.
* - 삽입 구간이 예고 텍스트의 앞부분이면(키보드 방식으로 치는 도중 잡힌 스냅샷) 전부
* 프로그램 삽입이고, 남은 뒷부분을 계속 기다린다.
*/
private _withoutExpectedInsert(inserted: string): string {
this._pruneExpectedInserts(Date.now())
const trimmed = inserted.trim()
if (!trimmed) return inserted
for (let i = 0; i < this._expectedInserts.length; i += 1) {
const expected = this._expectedInserts[i]
const index = inserted.indexOf(expected.text)
if (index >= 0) {
this._expectedInserts.splice(i, 1)
return `${inserted.slice(0, index)} ${inserted.slice(index + expected.text.length)}`.trim()
}
if (trimmed.length === expected.text.length && `${trimmed}${trimmed}`.includes(expected.text)) {
this._expectedInserts.splice(i, 1)
return ''
}
if (expected.text.startsWith(trimmed)) {
const remainder = expected.text.slice(trimmed.length).trim()
if (remainder) expected.text = remainder
else this._expectedInserts.splice(i, 1)
return ''
}
}
return inserted
}
/**
* 외부(음성 전사 등)에서 들어온 텍스트를 코퍼스에 넣는다.
*
* 음성 전사는 이미 사용자가 말한 문장이므로 제안 품질에 가장 강한 신호다.
* 학습 동의(`inputLearnTypedText`)가 없으면 아무것도 저장하지 않는다.
*/
recordExternalText(
text: string,
meta: { appName?: string | null; windowTitle?: string | null; source: PhraseSource }
): void {
if (configGet('inputLearnTypedText') !== true) return
this._learnText(text, {
appName: meta.appName ?? null,
windowTitle: meta.windowTitle ?? null,
source: meta.source
})
}
private _learnText(
raw: string,
meta: { appName: string | null; windowTitle: string | null; source: PhraseSource }
): void {
// 학습 제외 앱은 출처와 무관하다 — 터미널에서 수락한 제안(개발 지시)도 코퍼스에 넣지 않는다.
if (!shouldLearnFromApp(meta.appName)) return
const text = sanitizeSample(
raw
.split(/\r?\n/u)
.map(stripTrailingJamo)
.filter((line) => isLearnablePhrase(line) && !isUrlLike(line))
.join('\n')
)
if (!text) return
// 직접 친 글이 너무 짧으면 문체 표본이 아니다("처음", "pow") — 음성·수락 문장은 이미 문장 단위다.
if (meta.source === 'typed' && text.replace(/\s/gu, '').length < MIN_TYPED_SAMPLE_CHARS) return
try {
const db = getDatabase()
const now = Date.now()
const wordCount = countWords(text)
const charCount = text.length
db.insert(typingSamples)
.values({
id: crypto.randomUUID(),
text: text.slice(0, MAX_SAMPLE_CHARS),
wordCount,
charCount,
appName: meta.appName,
windowTitle: meta.windowTitle,
source: meta.source,
createdAt: now
})
.run()
// 개인 그래프에 반영 (문장 노드 + follows/용어공유 엣지)
getPersonalGraphService().indexText(text, {
source: meta.source,
appName: meta.appName,
at: now
})
for (const phrase of extractPhrases(text).filter(isLearnablePhrase)) {
db.insert(personalPhrases)
.values({
id: crypto.randomUUID(),
phrase,
count: 1,
source: meta.source,
lastUsedAt: now,
createdAt: now,
appName: meta.appName
})
.onConflictDoUpdate({
target: personalPhrases.phrase,
set: {
count: sql`${personalPhrases.count} + 1`,
lastUsedAt: now,
appName: meta.appName
}
})
.run()
}
} catch (error) {
logger.warn(
`텍스트 학습 저장 실패: ${error instanceof Error ? error.message : String(error)}`
)
}
}
// ─ 영속화 ─────────────────────────────────────────────
/** 대기 중인 버킷을 DB로 확정한다 (5초 heartbeat). */
flushNow(): void {
this._flush()
}
private _flush(): void {
if (this._pending.size === 0) return
const entries = [...this._pending.entries()]
this._pending.clear()
const now = Date.now()
try {
const db = getDatabase()
for (const [key, bucket] of entries) {
const [date, hourRaw, appName] = key.split('|')
const hour = Number(hourRaw)
if (!date || Number.isNaN(hour)) continue
mergeActivityBucket(this._sessionTotals, bucket)
db.insert(inputActivity)
.values({
id: crypto.randomUUID(),
date,
hour,
appName: appName ?? '',
...bucket,
updatedAt: now
})
.onConflictDoUpdate({
target: [inputActivity.date, inputActivity.hour, inputActivity.appName],
set: {
keystrokes: sql`${inputActivity.keystrokes} + ${bucket.keystrokes}`,
shortcuts: sql`${inputActivity.shortcuts} + ${bucket.shortcuts}`,
backspaces: sql`${inputActivity.backspaces} + ${bucket.backspaces}`,
clicks: sql`${inputActivity.clicks} + ${bucket.clicks}`,
doubleClicks: sql`${inputActivity.doubleClicks} + ${bucket.doubleClicks}`,
scrollTicks: sql`${inputActivity.scrollTicks} + ${bucket.scrollTicks}`,
mouseDistancePx: sql`${inputActivity.mouseDistancePx} + ${bucket.mouseDistancePx}`,
chars: sql`${inputActivity.chars} + ${bucket.chars}`,
words: sql`${inputActivity.words} + ${bucket.words}`,
sentences: sql`${inputActivity.sentences} + ${bucket.sentences}`,
activeMs: sql`${inputActivity.activeMs} + ${bucket.activeMs}`,
updatedAt: now
}
})
.run()
}
this.emit('activity', {
totals: { ...this._sessionTotals },
appName: this._foreground.appName
})
} catch (error) {
logger.warn(
`입력 텔레메트리 저장 실패(다음 주기에 재시도): ${
error instanceof Error ? error.message : String(error)
}`
)
// 저장 실패 시 버킷을 되돌려 유실을 막는다.
for (const [key, bucket] of entries) {
const existing = this._pending.get(key)
if (existing) mergeActivityBucket(existing, bucket)
else this._pending.set(key, bucket)
}
}
}
// ── 조회 / 관리 ────────────────────────────────────────
getState(): InputTelemetryState {
const uia = getUiaContextService()
const currentApp = this._foreground.appName
const excludedApps = [...configGet('inputExcludedApps')]
const evidence = currentApp ? this._appReadability.get(currentApp) : undefined
return {
enabled: configGet('inputTelemetryEnabled') === true,
paused: configGet('inputTelemetryPaused') === true,
running: this._running,
learnTypedText: configGet('inputLearnTypedText') === true,
excludedApps,
appName: currentApp,
windowTitle: this._foreground.windowTitle,
bridgeReason: uia.lastReason,
bridgeAvailable: uia.isAvailable(),
lastSnapshotAt: uia.lastSuccessAt,
lastSnapshot: this._lastSnapshotSummary,
exclusionRecommendation:
evidence && !excludedApps.some((app) => app.toLowerCase() === currentApp?.toLowerCase())
? recommendAppExclusion(evidence)
: null
}
}
/** 최근 N일 인사이트 (일별/시간대별/앱별). */
getSummary(days = 7): InputInsightsSummary {
const safeDays = Math.max(1, Math.min(days, 365))
const since = new Date()
since.setHours(0, 0, 0, 0)
since.setDate(since.getDate() - (safeDays - 1))
const sinceDate = formatLocalDate(since)
const totals = emptyActivityBucket()
const daily = new Map<string, InputDailyStat>()
const hourly = new Map<number, InputHourlyStat>()
const apps = new Map<string, InputAppStat>()
try {
const db = getDatabase()
const rows = db
.select()
.from(inputActivity)
.where(gte(inputActivity.date, sinceDate))
.all()
for (const row of rows) {
mergeActivityBucket(totals, {
keystrokes: row.keystrokes,
shortcuts: row.shortcuts,
backspaces: row.backspaces,
clicks: row.clicks,
doubleClicks: row.doubleClicks,
scrollTicks: row.scrollTicks,
mouseDistancePx: row.mouseDistancePx,
chars: row.chars,
words: row.words,
sentences: row.sentences,
activeMs: row.activeMs
})
const day = daily.get(row.date) ?? {
date: row.date,
keystrokes: 0,
clicks: 0,
words: 0,
sentences: 0,
mouseDistancePx: 0,
activeMs: 0
}
day.keystrokes += row.keystrokes
day.clicks += row.clicks
day.words += row.words
day.sentences += row.sentences
day.mouseDistancePx += row.mouseDistancePx
day.activeMs += row.activeMs
daily.set(row.date, day)
const hour = hourly.get(row.hour) ?? {
hour: row.hour,
keystrokes: 0,
clicks: 0,
chars: 0,
backspaces: 0,
activeMs: 0
}
hour.keystrokes += row.keystrokes
hour.clicks += row.clicks
hour.chars += row.chars
hour.backspaces += row.backspaces
hour.activeMs += row.activeMs
hourly.set(row.hour, hour)
if (row.appName) {
const app = apps.get(row.appName) ?? {
appName: row.appName,
keystrokes: 0,
clicks: 0,
activeMs: 0
}
app.keystrokes += row.keystrokes
app.clicks += row.clicks
app.activeMs += row.activeMs
apps.set(row.appName, app)
}
}
// 24시간 전체 분포 (topHours 는 상위만 잘라 쓴다)
const hourlyAll: InputHourlyStat[] = Array.from({ length: 24 }, (_, hour) => ({
hour,
keystrokes: 0,
clicks: 0,
chars: 0,
backspaces: 0,
activeMs: 0
}))
for (const stat of hourly.values()) {
if (stat.hour >= 0 && stat.hour < 24) hourlyAll[stat.hour] = stat
}
const dailySorted = [...daily.values()].sort((a, b) => a.date.localeCompare(b.date))
const activeDays = dailySorted.length
const peakDay = dailySorted.reduce<InputDailyStat | null>(
(best, day) => (!best || day.keystrokes > best.keystrokes ? day : best),
null
)
// 연속 기록 일수 (최장)
let longestStreakDays = 0
let currentStreak = 0
let previousDate: string | null = null
for (const day of dailySorted) {
if (previousDate === null) {
currentStreak = 1
} else {
const prev = new Date(`${previousDate}T00:00:00`)
const gapDays = Math.round(
(new Date(`${day.date}T00:00:00`).getTime() - prev.getTime()) / 86400000
)
currentStreak = gapDays === 1 ? currentStreak + 1 : 1
}
longestStreakDays = Math.max(longestStreakDays, currentStreak)
previousDate = day.date
}
const suggestionTotals = db
.select({
total: sql<number>`count(*)`,
accepted: sql<number>`coalesce(sum(case when accepted then 1 else 0 end), 0)`,
avgLatency: sql<number | null>`avg(latency_ms)`
})
.from(suggestionsTable)
.where(gte(suggestionsTable.createdAt, Date.now() - safeDays * 86400000))
.get()
const suggestionStats: InputInsightsSummary['suggestions'] = {
total: Number(suggestionTotals?.total ?? 0),
accepted: Number(suggestionTotals?.accepted ?? 0),
acceptRate:
Number(suggestionTotals?.total ?? 0) > 0
? Number(suggestionTotals?.accepted ?? 0) / Number(suggestionTotals?.total ?? 1)
: 0,
avgLatencyMs:
suggestionTotals?.avgLatency === null || suggestionTotals?.avgLatency === undefined
? null
: Math.round(Number(suggestionTotals.avgLatency))
}
const suggestionRows = db
.select({
appName: suggestionsTable.appName,
accepted: suggestionsTable.accepted,
latencyMs: suggestionsTable.latencyMs
})
.from(suggestionsTable)
.where(gte(suggestionsTable.createdAt, Date.now() - safeDays * 86400000))
.all()
const suggestionAppsByName = new Map<
string,
{ total: number; accepted: number; latencyTotal: number; latencyCount: number }
>()
for (const row of suggestionRows) {
const appName = row.appName?.trim()
if (!appName) continue
const stat = suggestionAppsByName.get(appName) ?? {
total: 0,
accepted: 0,
latencyTotal: 0,
latencyCount: 0
}
stat.total += 1
if (row.accepted) stat.accepted += 1
if (row.latencyMs !== null && row.latencyMs !== undefined) {
stat.latencyTotal += row.latencyMs
stat.latencyCount += 1
}
suggestionAppsByName.set(appName, stat)
}
const suggestionApps: InputAppSuggestionStat[] = [...suggestionAppsByName.entries()]
.map(([appName, stat]) => ({
appName,
total: stat.total,
accepted: stat.accepted,
acceptRate: stat.total > 0 ? stat.accepted / stat.total : 0,
avgLatencyMs: stat.latencyCount > 0 ? Math.round(stat.latencyTotal / stat.latencyCount) : null
}))
.sort((a, b) => b.total - a.total || b.acceptRate - a.acceptRate || a.appName.localeCompare(b.appName))
.slice(0, 12)
const phraseCount = db
.select({ value: sql<number>`count(*)` })
.from(personalPhrases)
.get()
const sampleCount = db
.select({ value: sql<number>`count(*)` })
.from(typingSamples)
.get()
return {
days: safeDays,
totals,
daily: dailySorted,
topHours: [...hourly.values()].sort((a, b) => b.keystrokes - a.keystrokes).slice(0, 6),
topApps: [...apps.values()].sort((a, b) => b.keystrokes - a.keystrokes).slice(0, 12),
phraseCount: Number(phraseCount?.value ?? 0),
sampleCount: Number(sampleCount?.value ?? 0),
averages: summarizeActivity(totals, safeDays, getDisplayScaleFactor()),
hourly: hourlyAll,
activeDays,
longestStreakDays,
peakDay,
suggestions: suggestionStats,
friction: calculateFrictionInsight(totals.chars, totals.backspaces),
flowWindows: rankFlowWindows(hourlyAll, activeDays),
suggestionApps
}
} catch (error) {
logger.warn(
`입력 인사이트 조회 실패: ${error instanceof Error ? error.message : String(error)}`
)
return {
days: safeDays,
totals,
daily: [],
topHours: [],
topApps: [],
phraseCount: 0,
sampleCount: 0,
averages: summarizeActivity(totals, safeDays),
hourly: Array.from({ length: 24 }, (_, hour) => ({
hour,
keystrokes: 0,
clicks: 0,
chars: 0,
backspaces: 0,
activeMs: 0
})),
activeDays: 0,
longestStreakDays: 0,
peakDay: null,
suggestions: { total: 0, accepted: 0, acceptRate: 0, avgLatencyMs: null },
friction: calculateFrictionInsight(0, 0),
flowWindows: [],
suggestionApps: []
}
}
}
/**
* 과거에 이 접두 꼬리 뒤에 실제로 이어 쓴 텍스트를 찾는다 (개인 기억).
*
* 자주 쓰는 문구 목록보다 강한 개인화 신호다: 사용자가 그 문맥에서 실제로
* 어떤 문장을 이어 썼는지가 그대로 들어간다. 임베딩 검색이 아니라 로컬
* 문자열 관계 조회이므로 추가 의존성이나 네트워크가 없다.
*
* 학습 동의(inputLearnTypedText)가 없으면 저장된 표본이 없어 자연히 빈 배열이다.
*/
findContinuationHints(prefixTail: string, limit = 3): string[] {
const tail = prefixTail.trim()
if (tail.length < 4) return []
try {
const db = getDatabase()
const pattern = `%${tail.replace(/[%_\\]/gu, '')}%`
const rows = db
.select({ text: typingSamples.text })
.from(typingSamples)
.where(sql`${typingSamples.text} LIKE ${pattern}`)
.orderBy(desc(typingSamples.createdAt))
.limit(40)
.all()
const out: string[] = []
for (const row of rows) {
const index = row.text.indexOf(tail)
if (index < 0) continue
const continuation = row.text
.slice(index + tail.length)
.replace(/\s+/gu, ' ')
.trim()
// 바로 뒤가 비어 있으면(문장이 그대로 끝) 참고 가치가 없다
if (continuation.length < 3) continue
const clipped = continuation.slice(0, 60)
if (out.some((existing) => existing === clipped)) continue
out.push(clipped)
if (out.length >= limit) break
}
return out
} catch (error) {
logger.warn(
`과거 이어쓰기 조회 실패: ${error instanceof Error ? error.message : String(error)}`
)
return []
}
}
getPrivacyReceipt(): InputPrivacyReceipt {
try {
const db = getDatabase()
const countRows = (table: typeof inputActivity | typeof typingSamples | typeof personalPhrases | typeof suggestionsTable): number =>
Number(db.select({ value: sql<number>`count(*)` }).from(table).get()?.value ?? 0)
const counts = {
activityBuckets: countRows(inputActivity),
typingSamples: countRows(typingSamples),
personalPhrases: countRows(personalPhrases),
suggestions: countRows(suggestionsTable)
}
return {
localOnly: true,
rawKeyContentStored: false,
retention: {
activityDays: INPUT_TELEMETRY_DEFAULTS.retentionDays,
typingSamplesDays: INPUT_TELEMETRY_DEFAULTS.retentionDays,
suggestionDays: INPUT_TELEMETRY_DEFAULTS.retentionDays,
personalPhrases: 'until-deleted'
},
counts
}
} catch (error) {
logger.warn(`입력 개인정보 영수증 조회 실패: ${error instanceof Error ? error.message : String(error)}`)
throw error
}
}
listPhrases(limit = 100): PersonalPhrase[] {
try {
const db = getDatabase()
const rows = db
.select()
.from(personalPhrases)
.orderBy(desc(personalPhrases.count), desc(personalPhrases.lastUsedAt))
.limit(Math.max(1, Math.min(limit, 500)))
.all()
return rows.map((row) => ({
id: row.id,
phrase: row.phrase,
count: row.count,
source: row.source,
appName: row.appName,
lastUsedAt: row.lastUsedAt,
createdAt: row.createdAt
}))
} catch (error) {
logger.warn(`개인 문구 조회 실패: ${error instanceof Error ? error.message : String(error)}`)
return []
}
}
/**
* 학습 문구 삭제.
*
* 그래프 엣지(phrase_edges)는 문장 텍스트를 외래 키 없이 들고 있다 — 문구 행만 지우면
* follows 엣지를 따라 지운 문장이 제안 프롬프트와 그래프 통계에 계속 나온다.
* 문구와 그 문장을 가리키는 엣지를 한 트랜잭션에서 함께 지운다.
*/
deletePhrase(id: string): boolean {
try {
const db = getDatabase()
return db.transaction(() => {
const row = db
.select({ phrase: personalPhrases.phrase })
.from(personalPhrases)
.where(eq(personalPhrases.id, id))
.get()
const result = db.delete(personalPhrases).where(eq(personalPhrases.id, id)).run()
if (row) getPersonalGraphService().removePhrase(row.phrase)
return Number(result.changes ?? 0) > 0
})
} catch (error) {
logger.warn(`개인 문구 제 실패: ${error instanceof Error ? error.message : String(error)}`)
return false
}
}
/** 수집된 모든 입력 데이터 삭제 (동의 철회/초기화). */
clearAll(): void {
try {
const db = getDatabase()
db.delete(inputActivity).run()
db.delete(typingSamples).run()
db.delete(personalPhrases).run()
db.delete(suggestionsTable).run()
getPersonalGraphService().clearAll()
this._pending.clear()
this._appReadability.clear()
this._sessionTotals = emptyActivityBucket()
this._lastSnapshot = null
this._lastSnapshotKey = ''
this._discardPendingLearning()
logger.info('입력 텔레메트리 데이터 전체 삭제')
} catch (error) {
logger.warn(`입력 데이터 삭제 실패: ${error instanceof Error ? error.message : String(error)}`)
throw error
}
}
/**
* 지금의 학습 규칙(제외 앱·문장 판정)에 맞지 않는 기존 코퍼스를 걷어낸다.
*
* 규칙이 생기기 전에 쌓인 터미널 상태줄·개발 지시가 그래프를 개발 쪽으로 끌고
* 있었다 — 규칙을 과거 데이터에도 똑같이 적용해 그래프를 되돌린다.
*/
private _pruneUnlearnableCorpus(): void {
// 학습과 같은 규칙(출처 무관) — 규칙 이전에 쌓인 제외 앱의 수락 제안도 걷어낸다.
const excluded = (_source: string, appName: string | null): boolean => !shouldLearnFromApp(appName)
try {
const db = getDatabase()
const phraseIds = db
.select({
id: personalPhrases.id,
phrase: personalPhrases.phrase,
source: personalPhrases.source,
appName: personalPhrases.appName
})
.from(personalPhrases)
.all()
.filter((row) => excluded(row.source, row.appName) || !isLearnablePhrase(row.phrase))
.map((row) => row.id)
const sampleIds = db
.select({
id: typingSamples.id,
text: typingSamples.text,
source: typingSamples.source,
appName: typingSamples.appName
})
.from(typingSamples)
.all()
.filter(
(row) =>
excluded(row.source, row.appName) ||
!row.text.split(/\r?\n/u).some((line) => isLearnablePhrase(line))
)
.map((row) => row.id)
for (let i = 0; i < phraseIds.length; i += 200) {
db.delete(personalPhrases).where(inArray(personalPhrases.id, phraseIds.slice(i, i + 200))).run()
}
for (let i = 0; i < sampleIds.length; i += 200) {
db.delete(typingSamples).where(inArray(typingSamples.id, sampleIds.slice(i, i + 200))).run()
}
db.run(
sql`DELETE FROM phrase_edges
WHERE from_phrase NOT IN (SELECT phrase FROM personal_phrases)
OR to_phrase NOT IN (SELECT phrase FROM personal_phrases)`
)
if (phraseIds.length > 0 || sampleIds.length > 0) {
logger.info(`학습 규칙에 맞지 않는 코퍼스 정리: 문구 ${phraseIds.length}개, 표본 ${sampleIds.length}개`)
}
} catch (error) {
logger.warn(`코퍼스 정리 실패: ${error instanceof Error ? error.message : String(error)}`)
}
}
/** 보존 기간 초과 데이터 정리 (ActivityWatch 와 동일한 로컬 보존 정책). */
private _pruneOldData(now = Date.now()): void {
if (now - this._prunedAt < RETENTION_PRUNE_INTERVAL_MS) return
this._prunedAt = now
this._pruneUnlearnableCorpus()
// 그래프 유지보수도 같은 주기에 돌린다 (용어 공유 엣지 백필).
getPersonalGraphService().runMaintenance()
const cutoff = now - INPUT_TELEMETRY_DEFAULTS.retentionDays * 24 * 60 * 60 * 1000
try {
const db = getDatabase()
db.delete(typingSamples).where(sql`${typingSamples.createdAt} < ${cutoff}`).run()
db.delete(inputActivity).where(sql`${inputActivity.updatedAt} < ${cutoff}`).run()
db.delete(suggestionsTable).where(sql`${suggestionsTable.createdAt} < ${cutoff}`).run()
logger.info(`입력 데이터 보존 정리 완료 (${INPUT_TELEMETRY_DEFAULTS.retentionDays}일 초과)`)
} catch (error) {
logger.warn(`보존 정리 실패: ${error instanceof Error ? error.message : String(error)}`)
}
}
/** 일시정지 토글 (동의는 유지). */
setPaused(paused: boolean): void {
configSet('inputTelemetryPaused', paused)
this.applyConfig()
}
/** 수집 동의 설정. 끄면 즉시 중지하고 수집분도 지운다. */
setEnabled(enabled: boolean): void {
configSet('inputTelemetryEnabled', enabled)
if (!enabled) {
this.clearAll()
configSet('inputLearnTypedText', false)
}
this.applyConfig()
}
private _emitState(): void {
this.emit('state-changed', this.getState())
}
}
/**
* 마지막 비어 있지 않은 줄을 돌려준다 (터미널/문서형 컨트롤용).
*
* 터미널 버퍼 전체를 프롬프트로 넘기면 모델이 과거 출력을 이어 쓰려 한다.
*/
function lastLineOf(text: string): string {
const lines = text.split(/\r?\n/u)
for (let i = lines.length - 1; i >= 0; i -= 1) {
const line = lines[i].trim()
if (line.length > 0) return line.slice(-SUGGESTION_CONTEXT_MAX_CHARS)
}
return text.slice(-SUGGESTION_CONTEXT_MAX_CHARS)
}
/**
* 포커스된 컨트롤 식별 키 — 창(hwnd) + 컨트롤 종류 + 컨트롤 이름.
*
* 위치·크기는 쓰지 않는다 — 채팅 입력창은 글이 늘면 자라고 움직여, 넣으면 같은 칸인데도
* 칠 때마다 "새 칸" 으로 오인돼 기준선이 리셋되고 제안이 거의 막혔다(실측: Agent
* Switchboard 에서 not-typing 반복). 같은 창 안의 칸 이동은 클릭 재기준으로 잡는다.
*/
function computeFocusKey(hwnd: number | null, controlType: string | null, controlName: string | null): string {
return `${hwnd ?? ''}|${controlType ?? ''}|${controlName ?? ''}`
}
function formatLocalDate(date: Date): string {
const year = date.getFullYear()
const month = String(date.getMonth() + 1).padStart(2, '0')
const day = String(date.getDate()).padStart(2, '0')
return `${year}-${month}-${day}`
}
const MIN_TYPED_SAMPLE_CHARS = 4
/** 주소·쿼리 문자열 한 줄은 문체 표본이 아니다. */
function isUrlLike(line: string): boolean {
const trimmed = line.trim()
if (/^(https?:\/\/|www\.)\S*$/iu.test(trimmed)) return true
return !/\s/u.test(trimmed) && /[/=&?#]/u.test(trimmed)
}
/** 조합이 덜 끝난 채 잡힌 끝 자모("아냐 ㅇ")를 뗀다. */
function stripTrailingJamo(line: string): string {
return line.replace(/\s*[\u3131-\u318e]+$/u, '')
}
/** 제어문자 제거 + 공백 정규화. 2자 미만은 버린다. */
function sanitizeSample(raw: string): string {
let stripped = ''
for (const char of raw) {
const code = char.codePointAt(0) ?? 0
// 제어문자(개행/탭 포함)는 공백으로 바다 — 학습 표본에 제어문자를 남기지 않는다.
// 사용 영역(PUA)·짝 잃은 서로게이트는 이모지가 16비트로 잘려 들어온 흔적이다(🍫 → U+F36B) — 버린다.
if ((code >= 0xe000 && code <= 0xf8ff) || (code >= 0xd800 && code <= 0xdfff)) continue
stripped += code < 0x20 || code === 0x7f ? ' ' : char
}
const cleaned = stripped.replace(/\s+/gu, ' ').trim()
if (cleaned.length < 2) return ''
return cleaned.slice(0, MAX_SAMPLE_CHARS)
}
function getDisplayScaleFactor(): number {
try {
return screen.getPrimaryDisplay().scaleFactor || 1
} catch {
return 1
}
}
let instance: InputTelemetryService | null = null
export function getInputTelemetryService(): InputTelemetryService {
if (!instance) instance = new InputTelemetryService()
return instance
}
export function resetInputTelemetryServiceForTests(): void {
instance?.dispose()
instance = null
}
export { formatLocalDate, sanitizeSample }
export type { InputTelemetryState }