Rocky
9f308fadd2
Rotate AI idle suggestions with optional remote packs, move history/dictionary onto self-sizing Home preview cards, harden clipboard capture/prompting, and simplify keyboard chrome by dropping most liquid-glass shadows.
533 lines
21 KiB
Swift
533 lines
21 KiB
Swift
// KeyboardTextInserter.swift
|
|
// OSGKeyboard · Keyboard Extension
|
|
//
|
|
// Inserts Flow transcripts from the host app and surfaces polish warnings
|
|
// without re-running LLM polish in the extension. Also tracks the last
|
|
// voice insertion so the undo button can roll it back safely.
|
|
|
|
import UIKit
|
|
import OSGKeyboardShared
|
|
|
|
@MainActor
|
|
final class KeyboardTextInserter {
|
|
/// Hosts truncate `documentContextBeforeInput` (often to the current
|
|
/// paragraph), so a long insertion can only ever be matched by its tail.
|
|
private static let caretVerificationLimit = 80
|
|
|
|
private let state: KeyboardState
|
|
private let insertText: (String) -> Void
|
|
private let deleteBackward: () -> Void
|
|
private let contextBeforeInput: () -> String?
|
|
private let fieldContextProvider: () -> FlowFieldContext?
|
|
private let selectedText: () -> String?
|
|
private let scheduleAutoClearError: () -> Void
|
|
private unowned let editHintScheduler: EditHintScheduler
|
|
|
|
/// Exact string last inserted through this inserter — dictation, AI answer,
|
|
/// edit result or clipboard paste (including any word-boundary separator).
|
|
/// Cleared after a successful undo or when the caret no longer sits after
|
|
/// that text.
|
|
private var lastInsertedText: String?
|
|
/// Text captured when the last insertion was undone, so redo can
|
|
/// re-apply it. Cleared by any new insertion or external edit.
|
|
private var redoText: String?
|
|
private var redoContextBefore: String?
|
|
private let extensionInstanceID = UUID()
|
|
private var lastEditUndo: PendingTextEditTransaction?
|
|
/// Suppresses availability refresh while we walk `deleteBackward`
|
|
/// for undo, so intermediate contexts don't flicker the button.
|
|
private var isUndoing = false
|
|
|
|
init(
|
|
state: KeyboardState,
|
|
insertText: @escaping (String) -> Void,
|
|
deleteBackward: @escaping () -> Void,
|
|
contextBeforeInput: @escaping () -> String?,
|
|
fieldContextProvider: @escaping () -> FlowFieldContext?,
|
|
selectedText: @escaping () -> String?,
|
|
scheduleAutoClearError: @escaping () -> Void,
|
|
editHintScheduler: EditHintScheduler
|
|
) {
|
|
self.state = state
|
|
self.insertText = insertText
|
|
self.deleteBackward = deleteBackward
|
|
self.contextBeforeInput = contextBeforeInput
|
|
self.fieldContextProvider = fieldContextProvider
|
|
self.selectedText = selectedText
|
|
self.scheduleAutoClearError = scheduleAutoClearError
|
|
self.editHintScheduler = editHintScheduler
|
|
}
|
|
|
|
func handleFlowTranscript(
|
|
_ delivery: TranscriptionDelivery,
|
|
replacePrevious: String? = nil
|
|
) {
|
|
let trimmed = delivery.text.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
guard !trimmed.isEmpty else {
|
|
state.phase = .idle
|
|
state.level = 0
|
|
return
|
|
}
|
|
|
|
if let previous = replacePrevious?.trimmingCharacters(in: .whitespacesAndNewlines),
|
|
!previous.isEmpty,
|
|
let preceding = contextBeforeInput(),
|
|
preceding.hasSuffix(previous) {
|
|
for _ in 0..<previous.count {
|
|
deleteBackward()
|
|
}
|
|
}
|
|
|
|
// Host app already polished when configured; keyboard only inserts.
|
|
// Word-boundary hygiene: dictating "world" with the cursor right
|
|
// after "Hello" must yield "Hello world", not "Helloworld".
|
|
let separator = DictationTextComposer.insertionSeparator(
|
|
previousContext: contextBeforeInput(),
|
|
insertion: trimmed
|
|
)
|
|
let inserted = separator + trimmed
|
|
insertText(inserted)
|
|
state.noteUserDidInputText()
|
|
recordLastInsertion(
|
|
inserted,
|
|
displayText: trimmed,
|
|
historyEntryID: delivery.historyEntryID,
|
|
historyEntryRevision: delivery.historyEntryRevision,
|
|
pendingHistoryMutationID: nil
|
|
)
|
|
state.lastTranscript = ""
|
|
state.level = 0
|
|
if let warning = delivery.polishWarning {
|
|
state.phase = .error(.polishDegraded(warning), message: warning)
|
|
scheduleAutoClearError()
|
|
} else {
|
|
state.phase = .idle
|
|
}
|
|
OSGLog.keyboardExt.info("flow insert length=\(trimmed.count, privacy: .public)")
|
|
}
|
|
|
|
/// Insert one explicitly confirmed AI answer and enqueue history/statistics
|
|
/// only after the field mutation has been issued.
|
|
@discardableResult
|
|
func insertAIAnswer(_ answer: AIAnswer) -> Bool {
|
|
let trimmed = answer.text.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
guard !trimmed.isEmpty else { return false }
|
|
|
|
let separator = DictationTextComposer.insertionSeparator(
|
|
previousContext: contextBeforeInput(),
|
|
insertion: trimmed
|
|
)
|
|
let inserted = separator + trimmed
|
|
insertText(inserted)
|
|
state.noteUserDidInputText()
|
|
|
|
let mutation = HistoryMutation(
|
|
action: .append,
|
|
entryID: answer.id,
|
|
text: trimmed,
|
|
engineMode: state.engineMode,
|
|
source: .ai,
|
|
usageCategory: .ai
|
|
)
|
|
HistoryMutationOutbox.enqueue(mutation)
|
|
recordLastInsertion(
|
|
inserted,
|
|
displayText: trimmed,
|
|
historyEntryID: answer.id,
|
|
historyEntryRevision: 0,
|
|
pendingHistoryMutationID: mutation.id
|
|
)
|
|
state.lastTranscript = ""
|
|
state.level = 0
|
|
OSGLog.keyboardExt.info("AI answer insert length=\(trimmed.count, privacy: .public)")
|
|
return true
|
|
}
|
|
|
|
/// Insert clipboard text verbatim and make it undoable. Pasted text is not
|
|
/// a dictation result: it never becomes an editable "last input" reference
|
|
/// and never reaches the history outbox, so it only takes the undo record.
|
|
func insertPasteboardText(_ text: String) {
|
|
guard !text.isEmpty else { return }
|
|
// Verbatim on purpose — paste must reproduce exactly what was copied,
|
|
// unlike dictation which needs word-boundary hygiene.
|
|
insertText(text)
|
|
recordUndoableInsertion(text)
|
|
// The paste pushed any previous input away from the caret, so the
|
|
// "editable last input" hint no longer applies.
|
|
clearEditHintIfPositive()
|
|
OSGLog.keyboardExt.info("clipboard insert length=\(text.count, privacy: .public)")
|
|
}
|
|
|
|
/// Roll back the last insertion when it is still at the caret.
|
|
func undoLastInsertion() {
|
|
if undoLastEditIfPossible() {
|
|
return
|
|
}
|
|
guard let text = lastInsertedText, !text.isEmpty else { return }
|
|
guard caretSitsAfter(text) else {
|
|
clearLastInsertion()
|
|
return
|
|
}
|
|
|
|
isUndoing = true
|
|
defer { isUndoing = false }
|
|
|
|
// `UITextDocumentProxy` has no ranged delete, so the whole insertion is
|
|
// walked back one grapheme at a time. Staying synchronous keeps it in a
|
|
// single run-loop turn, which the host coalesces into one visual update.
|
|
for _ in 0..<text.count {
|
|
deleteBackward()
|
|
}
|
|
// Stash the exact inserted string (incl. separator) for redo before
|
|
// dropping the live undo record.
|
|
redoText = text
|
|
redoContextBefore = contextBeforeInput()
|
|
lastInsertedText = nil
|
|
state.undoAvailable = false
|
|
OSGLog.keyboardExt.info("undo length=\(text.count, privacy: .public)")
|
|
}
|
|
|
|
/// Re-apply the last undone insertion when it is still absent from the
|
|
/// caret (i.e. the undo was not overwritten by an external edit).
|
|
func redoLastInsertion() {
|
|
guard let text = redoText, !text.isEmpty,
|
|
contextBeforeInput() == redoContextBefore else {
|
|
redoText = nil
|
|
redoContextBefore = nil
|
|
state.redoAvailable = false
|
|
return
|
|
}
|
|
guard !caretSitsAfter(text) else {
|
|
redoText = nil
|
|
state.redoAvailable = false
|
|
return
|
|
}
|
|
insertText(text)
|
|
recordUndoableInsertion(text)
|
|
OSGLog.keyboardExt.info("redo length=\(text.count, privacy: .public)")
|
|
}
|
|
|
|
/// Copy the host field's current selection to the pasteboard. Needs Full
|
|
/// Access for `selectedText` on some hosts; silently no-ops otherwise.
|
|
func copySelection() {
|
|
guard let text = selectedText(), !text.isEmpty else { return }
|
|
UIPasteboard.general.string = text
|
|
OSGLog.keyboardExt.info("copy length=\(text.count, privacy: .public)")
|
|
}
|
|
|
|
/// Copy the host field's current selection, then delete it.
|
|
func cutSelection() {
|
|
guard let text = selectedText(), !text.isEmpty else { return }
|
|
UIPasteboard.general.string = text
|
|
// `deleteBackward` removes the active selection in one operation.
|
|
deleteBackward()
|
|
OSGLog.keyboardExt.info("cut length=\(text.count, privacy: .public)")
|
|
}
|
|
|
|
/// Re-evaluate undo / redo / copy / cut availability. Call from
|
|
/// `textDidChange` / `selectionDidChange`.
|
|
func refreshEditingAvailability() {
|
|
// Undo: only re-check when not mid-undo (avoids flicker while we walk
|
|
// `deleteBackward`); the undo method manages availability itself.
|
|
if !isUndoing {
|
|
if let text = lastInsertedText, !text.isEmpty {
|
|
let available = caretSitsAfter(text)
|
|
if !available {
|
|
// Caret moved or the user edited the insertion — drop it.
|
|
lastInsertedText = nil
|
|
state.undoAvailable = false
|
|
} else if !state.undoAvailable {
|
|
state.undoAvailable = true
|
|
}
|
|
} else if state.undoAvailable {
|
|
state.undoAvailable = false
|
|
}
|
|
}
|
|
|
|
// Redo: a stashed insertion that hasn't been overwritten by an edit.
|
|
if redoText != nil, contextBeforeInput() != redoContextBefore {
|
|
redoText = nil
|
|
redoContextBefore = nil
|
|
}
|
|
let redo = redoText != nil && !(redoText?.isEmpty ?? true)
|
|
if state.redoAvailable != redo {
|
|
state.redoAvailable = redo
|
|
}
|
|
|
|
// Copy / cut: a non-empty selection exists in the host field.
|
|
let hasSelection = (selectedText()?.isEmpty == false)
|
|
if state.copyAvailable != hasSelection {
|
|
state.copyAvailable = hasSelection
|
|
}
|
|
if state.cutAvailable != hasSelection {
|
|
state.cutAvailable = hasSelection
|
|
}
|
|
}
|
|
|
|
func editableReference() -> EditableInputReference? {
|
|
guard var reference = EditableInputReferenceStore.load() else {
|
|
return nil
|
|
}
|
|
if let mutationID = reference.pendingHistoryMutationID,
|
|
let receipt = HistoryMutationReceiptStore.receipt(for: mutationID) {
|
|
reference = EditableInputReference(
|
|
targetID: reference.targetID,
|
|
historyEntryID: receipt.entryID,
|
|
historyEntryRevision: receipt.revision,
|
|
displayText: reference.displayText,
|
|
insertedText: reference.insertedText,
|
|
postInsertionFingerprint: reference.postInsertionFingerprint,
|
|
extensionInstanceID: reference.extensionInstanceID,
|
|
observedDocumentRevision: reference.observedDocumentRevision,
|
|
createdAt: reference.createdAt
|
|
)
|
|
EditableInputReferenceStore.save(reference)
|
|
}
|
|
guard reference.isWithinLengthBudget,
|
|
let preceding = contextBeforeInput(),
|
|
preceding.hasSuffix(reference.insertedText) else {
|
|
return nil
|
|
}
|
|
guard reference.postInsertionFingerprint == nil
|
|
|| reference.postInsertionFingerprint
|
|
== fieldContextProvider()?.deliveryFingerprint else {
|
|
return nil
|
|
}
|
|
if reference.extensionInstanceID == extensionInstanceID,
|
|
lastInsertedText == reference.insertedText {
|
|
return reference
|
|
}
|
|
return reference.isFullyVerified(
|
|
contextBeforeInput: preceding,
|
|
fieldFingerprint: fieldContextProvider()?.deliveryFingerprint
|
|
) ? reference : nil
|
|
}
|
|
|
|
@discardableResult
|
|
func applyEdit(_ review: EditReview, append: Bool) -> Bool {
|
|
let source = review.source.reference
|
|
let result = review.resultText.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
guard !result.isEmpty else { return false }
|
|
|
|
let mode: PendingTextEditTransaction.DeliveryMode = append ? .append : .replace
|
|
if append {
|
|
guard let context = fieldContextProvider(),
|
|
!context.isSecureEntry,
|
|
context.isContextAvailable else {
|
|
return false
|
|
}
|
|
}
|
|
if !append {
|
|
guard editableReference()?.targetID == source.targetID else { return false }
|
|
}
|
|
|
|
let historyEntryID = append
|
|
? UUID()
|
|
: (source.historyEntryID ?? UUID())
|
|
let historyAction: HistoryMutation.Action = append || source.historyEntryID == nil
|
|
? .append
|
|
: .update
|
|
let mutation = HistoryMutation(
|
|
action: historyAction,
|
|
entryID: historyEntryID,
|
|
expectedRevision: historyAction == .update
|
|
? source.historyEntryRevision
|
|
: nil,
|
|
text: result
|
|
)
|
|
var transaction = PendingTextEditTransaction(
|
|
deliveryMode: mode,
|
|
beforeText: source.insertedText,
|
|
afterText: result,
|
|
expectedFieldFingerprint: fieldContextProvider()?.deliveryFingerprint,
|
|
historyMutation: mutation
|
|
)
|
|
PendingTextEditTransactionStore.save(transaction)
|
|
|
|
if !append {
|
|
for _ in source.insertedText {
|
|
deleteBackward()
|
|
}
|
|
}
|
|
let separator = DictationTextComposer.insertionSeparator(
|
|
previousContext: contextBeforeInput(),
|
|
insertion: result
|
|
)
|
|
let inserted = separator + result
|
|
transaction.appliedInsertedText = inserted
|
|
PendingTextEditTransactionStore.save(transaction)
|
|
insertText(inserted)
|
|
let verificationSuffix = String(inserted.suffix(80))
|
|
guard contextBeforeInput()?.hasSuffix(verificationSuffix) == true else {
|
|
// Never blindly delete after a partial/opaque host insertion. The
|
|
// durable transaction lets a later presentation reconcile safely.
|
|
return false
|
|
}
|
|
|
|
transaction.phase = .fieldApplied
|
|
PendingTextEditTransactionStore.save(transaction)
|
|
HistoryMutationOutbox.enqueue(mutation)
|
|
transaction.phase = .committed
|
|
PendingTextEditTransactionStore.save(transaction)
|
|
recordLastInsertion(
|
|
inserted,
|
|
displayText: result,
|
|
historyEntryID: historyEntryID,
|
|
historyEntryRevision: historyAction == .update
|
|
? (source.historyEntryRevision ?? 0) + 1
|
|
: 0,
|
|
pendingHistoryMutationID: mutation.id
|
|
)
|
|
// Set after recording: the shared bookkeeping drops any stale
|
|
// transaction, and this one must survive as the undo target.
|
|
lastEditUndo = transaction
|
|
PendingTextEditTransactionStore.clear()
|
|
return true
|
|
}
|
|
|
|
@discardableResult
|
|
func recoverPendingEditTransactionIfNeeded() -> Bool {
|
|
guard let transaction = PendingTextEditTransactionStore.load(),
|
|
let preceding = contextBeforeInput() else {
|
|
return false
|
|
}
|
|
let currentFingerprint = fieldContextProvider()?.deliveryFingerprint
|
|
let appliedText = transaction.appliedInsertedText ?? transaction.afterText
|
|
if transaction.phase != .prepared,
|
|
preceding.hasSuffix(appliedText) {
|
|
HistoryMutationOutbox.enqueue(transaction.historyMutation)
|
|
PendingTextEditTransactionStore.clear()
|
|
return true
|
|
}
|
|
if transaction.phase == .prepared,
|
|
currentFingerprint != transaction.expectedFieldFingerprint,
|
|
preceding.hasSuffix(appliedText) {
|
|
HistoryMutationOutbox.enqueue(transaction.historyMutation)
|
|
PendingTextEditTransactionStore.clear()
|
|
return true
|
|
}
|
|
if transaction.deliveryMode == .replace,
|
|
preceding.hasSuffix(transaction.beforeText) {
|
|
PendingTextEditTransactionStore.clear()
|
|
return false
|
|
}
|
|
return false
|
|
}
|
|
|
|
private func undoLastEditIfPossible() -> Bool {
|
|
guard let transaction = lastEditUndo else {
|
|
return false
|
|
}
|
|
let insertedAfter = lastInsertedText ?? transaction.afterText
|
|
guard caretSitsAfter(insertedAfter) else {
|
|
lastEditUndo = nil
|
|
return false
|
|
}
|
|
for _ in insertedAfter {
|
|
deleteBackward()
|
|
}
|
|
|
|
switch transaction.deliveryMode {
|
|
case .replace:
|
|
insertText(transaction.beforeText)
|
|
let restore = HistoryMutation(
|
|
action: transaction.historyMutation.action == .append ? .delete : .restore,
|
|
entryID: transaction.historyMutation.entryID,
|
|
expectedRevision: transaction.historyMutation.expectedRevision.map { $0 + 1 },
|
|
text: transaction.beforeText
|
|
.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
)
|
|
HistoryMutationOutbox.enqueue(restore)
|
|
recordLastInsertion(
|
|
transaction.beforeText,
|
|
displayText: transaction.beforeText
|
|
.trimmingCharacters(in: .whitespacesAndNewlines),
|
|
historyEntryID: transaction.historyMutation.action == .append
|
|
? nil
|
|
: transaction.historyMutation.entryID,
|
|
historyEntryRevision: transaction.historyMutation.expectedRevision.map { $0 + 2 },
|
|
pendingHistoryMutationID: restore.id
|
|
)
|
|
case .append:
|
|
HistoryMutationOutbox.enqueue(
|
|
HistoryMutation(
|
|
action: .delete,
|
|
entryID: transaction.historyMutation.entryID
|
|
)
|
|
)
|
|
clearLastInsertion()
|
|
}
|
|
lastEditUndo = nil
|
|
return true
|
|
}
|
|
|
|
/// Is the caret still sitting right after `text`?
|
|
///
|
|
/// The comparison is limited to the tail of the insertion's last line: a
|
|
/// truncated host context can never contain the earlier part, and text
|
|
/// before a line break is usually stripped from `documentContextBeforeInput`.
|
|
private func caretSitsAfter(_ text: String) -> Bool {
|
|
guard let preceding = contextBeforeInput() else { return false }
|
|
let lastLine: String
|
|
if let breakRange = text.rangeOfCharacter(from: .newlines, options: .backwards) {
|
|
lastLine = String(text[breakRange.upperBound...])
|
|
} else {
|
|
lastLine = text
|
|
}
|
|
let expected = String(lastLine.suffix(Self.caretVerificationLimit))
|
|
// The insertion ended on a line break, so nothing measurable is left
|
|
// before the caret — an empty context is the expected state.
|
|
guard !expected.isEmpty else { return preceding.isEmpty }
|
|
return preceding.hasSuffix(expected)
|
|
}
|
|
|
|
/// Undo bookkeeping shared by every insertion path. Callers that also own
|
|
/// history / editable-reference state layer `recordLastInsertion` on top.
|
|
private func recordUndoableInsertion(_ text: String) {
|
|
lastInsertedText = text
|
|
redoText = nil
|
|
redoContextBefore = nil
|
|
// A newer insertion supersedes any edit transaction: undo must roll back
|
|
// this text, not re-apply the original text of an older edit.
|
|
lastEditUndo = nil
|
|
state.undoAvailable = true
|
|
}
|
|
|
|
private func recordLastInsertion(
|
|
_ text: String,
|
|
displayText: String,
|
|
historyEntryID: UUID?,
|
|
historyEntryRevision: Int64?,
|
|
pendingHistoryMutationID: UUID?
|
|
) {
|
|
recordUndoableInsertion(text)
|
|
EditableInputReferenceStore.save(
|
|
EditableInputReference(
|
|
historyEntryID: historyEntryID,
|
|
historyEntryRevision: historyEntryRevision,
|
|
pendingHistoryMutationID: pendingHistoryMutationID,
|
|
displayText: displayText,
|
|
insertedText: text,
|
|
postInsertionFingerprint: fieldContextProvider()?.deliveryFingerprint,
|
|
extensionInstanceID: extensionInstanceID
|
|
)
|
|
)
|
|
let hint = ExtL10n.string("keyboard.edit.hint.available")
|
|
editHintScheduler.show(
|
|
message: hint,
|
|
isPositive: true,
|
|
duration: .seconds(10)
|
|
)
|
|
}
|
|
|
|
private func clearEditHintIfPositive() {
|
|
editHintScheduler.clearPositive()
|
|
}
|
|
|
|
private func clearLastInsertion() {
|
|
lastInsertedText = nil
|
|
state.undoAvailable = false
|
|
EditableInputReferenceStore.clear()
|
|
}
|
|
}
|