وویس تایپینگ سانی اوکس مک
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 

414 lines
18 KiB

import Cocoa
import ApplicationServices
public final class InputBoxManager {
public static let shared = InputBoxManager()
private let lock = NSLock()
private var accumulatedStreamedText: String = ""
private var pendingPrefixBuffer: String = ""
private var isPrefixResolved: Bool = false
private var needsNewlineBeforeNextDelta: Bool = false
private var sessionGeneration: UInt64 = 0
private var clipboardRestoreWorkItem: DispatchWorkItem?
private let pasteQueue = DispatchQueue(label: "com.soniox.pasteQueue", qos: .userInteractive)
private static let punctRegex: NSRegularExpression = {
return try! NSRegularExpression(pattern: #"[.,!?:;،؛؟"'()\[\]{}«»–—\-…]"#, options: [])
}()
private init() {}
public static func stripPunctuation(_ str: String) -> String {
let range = NSRange(location: 0, length: str.utf16.count)
return punctRegex.stringByReplacingMatches(in: str, options: [], range: range, withTemplate: "")
}
/// Reset session state at the beginning of speech
public func resetSession() {
lock.lock()
sessionGeneration &+= 1
accumulatedStreamedText = ""
pendingPrefixBuffer = ""
isPrefixResolved = false
needsNewlineBeforeNextDelta = false
clipboardRestoreWorkItem?.cancel()
clipboardRestoreWorkItem = nil
lock.unlock()
}
/// Returns true if any text has been streamed into the input box during this session
public var hasStreamedText: Bool {
lock.lock()
defer { lock.unlock() }
let s = accumulatedStreamedText.trimmingCharacters(in: .whitespacesAndNewlines)
let p = pendingPrefixBuffer.trimmingCharacters(in: .whitespacesAndNewlines)
return !s.isEmpty || !p.isEmpty
}
/// Prepares session state before recording starts.
/// STRICT RULE: Focus is 100% user-directed. Never steal focus to browser address bar or toolbar.
public func ensureFocusedInputBox() {
resetSession()
let promptKey = kAXTrustedCheckOptionPrompt.takeUnretainedValue() as String
let isTrusted = AXIsProcessTrustedWithOptions([promptKey: true] as CFDictionary)
guard isTrusted else {
print("InputBoxManager: Accessibility not trusted.")
return
}
}
/// Streams word-by-word delta text directly into the focused input box in real time
public func streamDelta(text: String) {
guard !text.isEmpty else { return }
// Suppress trailing end triggers ("and", "تمام", "end") from live typing
let triggerWords = text.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty }
if let lastRaw = triggerWords.last {
let last = InputBoxManager.stripPunctuation(lastRaw).lowercased()
if last == "and" || last == "تمام" || last == "end" {
if triggerWords.count <= 1 {
return // Drop completely if it was just the end word
}
let textWithoutEnd = triggerWords.dropLast().joined(separator: " ") + " "
streamDelta(text: textWithoutEnd)
return
}
}
// Apply lightweight inline formatting (domain vocabulary, voice punctuation, digits) so streamed words match final text
let normalizedDelta = TextProcessor.shared.processLiveChunk(text)
lock.lock()
let expectedGen = sessionGeneration
if isPrefixResolved {
var textToPaste = normalizedDelta
if needsNewlineBeforeNextDelta {
needsNewlineBeforeNextDelta = false
let trimmed = normalizedDelta.trimmingCharacters(in: .whitespacesAndNewlines)
if !trimmed.isEmpty {
textToPaste = "\n" + trimmed
}
}
accumulatedStreamedText += textToPaste
lock.unlock()
pasteQueue.async { [weak self] in
guard let self = self else { return }
self.lock.lock()
let valid = (self.sessionGeneration == expectedGen)
self.lock.unlock()
guard valid else { return }
self.pasteSynchronously(textToPaste)
}
return
}
// Not resolved yet: buffer to check if speech starts with a slash command
pendingPrefixBuffer += normalizedDelta
let trimmed = pendingPrefixBuffer.trimmingCharacters(in: .whitespacesAndNewlines)
let words = trimmed.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty }
guard let firstWord = words.first else {
lock.unlock()
return
}
let slashTriggers = ["اسلش", "اصلش", "slash", "/", "\\"]
let isSlashPrefix = slashTriggers.contains { firstWord.lowercased().hasPrefix($0) }
if !isSlashPrefix {
// Normal speech: flush buffer immediately and continue normal streaming!
isPrefixResolved = true
let toFlush = pendingPrefixBuffer
pendingPrefixBuffer = ""
accumulatedStreamedText += toFlush
lock.unlock()
pasteQueue.async { [weak self] in
guard let self = self else { return }
self.lock.lock()
let valid = (self.sessionGeneration == expectedGen)
self.lock.unlock()
guard valid else { return }
self.pasteSynchronously(toFlush)
}
return
}
// Starts with slash trigger: check if it matches a Bot Command (/steer, /queue, /cancel)
if let botRes = BotCommandProcessor.parse(text: trimmed) {
isPrefixResolved = true
var textToPaste = botRes.command
if !botRes.body.isEmpty {
textToPaste += "\n" + botRes.body
needsNewlineBeforeNextDelta = false
} else {
needsNewlineBeforeNextDelta = true
}
pendingPrefixBuffer = ""
accumulatedStreamedText = textToPaste
lock.unlock()
pasteQueue.async { [weak self] in
guard let self = self else { return }
self.lock.lock()
let valid = (self.sessionGeneration == expectedGen)
self.lock.unlock()
guard valid else { return }
self.pasteSynchronously(textToPaste)
}
return
}
// If 2 words have accumulated and it's NOT a bot command:
if words.count >= 2 {
isPrefixResolved = true
// If it's an executive voice command, do NOT stream it to the input box!
if SonioxSettings.shared.voiceCommands && VoiceCommandExecutor.shared.isSlashCommand(text: trimmed) {
pendingPrefixBuffer = ""
lock.unlock()
return
}
// Otherwise, it was just regular speech starting with "اسلش..."
let toFlush = pendingPrefixBuffer
pendingPrefixBuffer = ""
accumulatedStreamedText += toFlush
lock.unlock()
pasteQueue.async { [weak self] in
guard let self = self else { return }
self.lock.lock()
let valid = (self.sessionGeneration == expectedGen)
self.lock.unlock()
guard valid else { return }
self.pasteSynchronously(toFlush)
}
return
}
lock.unlock()
}
/// Commits the final speech result: ensures 100% complete text in input box & clipboard without ANY duplication
public func commitFinalText(fullText: String, addTrailingSpace: Bool) {
let trimmed = fullText.trimmingCharacters(in: .whitespacesAndNewlines)
guard !trimmed.isEmpty else { return }
let textWithTrailing = addTrailingSpace ? (trimmed + " ") : trimmed
lock.lock()
let expectedGen = sessionGeneration
// Flush any pending buffer if recording ended before prefix resolution
if !isPrefixResolved && !pendingPrefixBuffer.isEmpty {
let pending = pendingPrefixBuffer
pendingPrefixBuffer = ""
if let botRes = BotCommandProcessor.parse(text: pending) {
accumulatedStreamedText = botRes.formattedText
} else if !(SonioxSettings.shared.voiceCommands && VoiceCommandExecutor.shared.isSlashCommand(text: pending)) {
accumulatedStreamedText += pending
}
}
let rawStreamed = accumulatedStreamedText
accumulatedStreamedText = ""
lock.unlock()
// CRITICAL: Process the streamed text through the EXACT same TextProcessor pipeline as fullText!
// This guarantees that numbers (۱ -> 1), ellipses (... -> . . .), and punctuation tokens have identical word counts & tokens!
let processedStreamed = rawStreamed.isEmpty ? "" : TextProcessor.shared.process(text: rawStreamed)
let cleanStreamed = processedStreamed.trimmingCharacters(in: .whitespacesAndNewlines)
pasteQueue.async { [weak self] in
guard let self = self else { return }
self.lock.lock()
let valid = (self.sessionGeneration == expectedGen)
self.lock.unlock()
guard valid else { return }
let restoreClipboardFullText = { [weak self] in
guard let self = self else { return }
let work = DispatchWorkItem { [weak self] in
guard let self = self else { return }
self.lock.lock()
let stillValid = (self.sessionGeneration == expectedGen)
self.lock.unlock()
guard stillValid else { return }
let pb = NSPasteboard.general
pb.clearContents()
pb.setString(textWithTrailing, forType: .string)
}
self.lock.lock()
self.clipboardRestoreWorkItem?.cancel()
self.clipboardRestoreWorkItem = work
self.lock.unlock()
DispatchQueue.main.asyncAfter(deadline: .now() + 0.30, execute: work)
}
// Case 1: Nothing was streamed live -> Paste entire text
if cleanStreamed.isEmpty {
let pb = NSPasteboard.general
pb.clearContents()
pb.setString(textWithTrailing, forType: .string)
self.postCleanCmdV()
restoreClipboardFullText()
return
}
// Case 2: Exactly matches streamed text
if cleanStreamed == trimmed {
if addTrailingSpace {
self.pasteSynchronously(" ")
}
restoreClipboardFullText()
return
}
// Case 3: Streamed prefix is exact prefix of trimmed final text
if trimmed.count > cleanStreamed.count && trimmed.hasPrefix(cleanStreamed) {
let suffix = String(trimmed.dropFirst(cleanStreamed.count))
let suffixToPaste = addTrailingSpace ? (suffix + " ") : suffix
self.pasteSynchronously(suffixToPaste)
restoreClipboardFullText()
return
}
// Case 4: Word-level Tail-Anchor Matching with 1-to-1 Aligned Index Mapping
let rawStreamedWords = cleanStreamed.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty }
let rawFinalWords = trimmed.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty }
let cleanWord: (String) -> String = { w in
let noZwnj = w.replacingOccurrences(of: "\u{200C}", with: "").replacingOccurrences(of: "\u{200D}", with: "")
return InputBoxManager.stripPunctuation(noZwnj).lowercased()
}
// Keep ONLY words that contain actual alphanumeric/Persian letters so standalone punctuation (".", "...") NEVER shifts indices!
let streamedPairs: [(raw: String, norm: String)] = rawStreamedWords.compactMap { w in
let nw = cleanWord(w)
return nw.isEmpty ? nil : (w, nw)
}
let finalPairs: [(raw: String, norm: String)] = rawFinalWords.compactMap { w in
let nw = cleanWord(w)
return nw.isEmpty ? nil : (w, nw)
}
guard !finalPairs.isEmpty else {
restoreClipboardFullText()
return
}
let wordsMatch: (String, String) -> Bool = { w1, w2 in
if w1 == w2 { return true }
if w1.count >= 2 && w2.count >= 2 {
if w1.hasPrefix(w2) || w2.hasPrefix(w1) { return true }
}
return false
}
var unstreamedPairIndex: Int? = nil
// Strategy 4A: 3-word tail anchor
if streamedPairs.count >= 3 {
let a1 = streamedPairs[streamedPairs.count - 3].norm
let a2 = streamedPairs[streamedPairs.count - 2].norm
let a3 = streamedPairs[streamedPairs.count - 1].norm
for j in stride(from: finalPairs.count - 1, through: 2, by: -1) {
if wordsMatch(finalPairs[j].norm, a3) && wordsMatch(finalPairs[j - 1].norm, a2) && wordsMatch(finalPairs[j - 2].norm, a1) {
unstreamedPairIndex = j + 1
break
}
}
}
// Strategy 4B: 2-word tail anchor
if unstreamedPairIndex == nil && streamedPairs.count >= 2 {
let a1 = streamedPairs[streamedPairs.count - 2].norm
let a2 = streamedPairs[streamedPairs.count - 1].norm
for j in stride(from: finalPairs.count - 1, through: 1, by: -1) {
if wordsMatch(finalPairs[j].norm, a2) && wordsMatch(finalPairs[j - 1].norm, a1) {
unstreamedPairIndex = j + 1
break
}
}
}
// Strategy 4C: 1-word tail anchor
if unstreamedPairIndex == nil && !streamedPairs.isEmpty {
let a1 = streamedPairs[streamedPairs.count - 1].norm
let searchStart = max(0, finalPairs.count - max(15, streamedPairs.count))
for j in stride(from: finalPairs.count - 1, through: searchStart, by: -1) {
if wordsMatch(finalPairs[j].norm, a1) {
unstreamedPairIndex = j + 1
break
}
}
}
// Strategy 4D: Forward prefix match fallback
if unstreamedPairIndex == nil {
var prefixMatchCount = 0
for i in 0..<min(streamedPairs.count, finalPairs.count) {
if wordsMatch(streamedPairs[i].norm, finalPairs[i].norm) {
prefixMatchCount = i + 1
} else {
break
}
}
if prefixMatchCount > 0 {
unstreamedPairIndex = prefixMatchCount
}
}
// Guaranteed Safety Fallback: aligned 1-to-1 on content-bearing pairs
if unstreamedPairIndex == nil {
unstreamedPairIndex = min(streamedPairs.count, finalPairs.count)
}
if let startIndex = unstreamedPairIndex {
if startIndex < finalPairs.count {
let remainingWords = finalPairs.dropFirst(startIndex).map { $0.raw }
let suffix = remainingWords.joined(separator: " ")
let suffixToPaste = addTrailingSpace ? (" " + suffix + " ") : (" " + suffix)
self.pasteSynchronously(suffixToPaste)
restoreClipboardFullText()
return
} else {
if addTrailingSpace {
self.pasteSynchronously(" ")
}
restoreClipboardFullText()
return
}
}
restoreClipboardFullText()
}
}
/// Places text on NSPasteboard, posts Cmd+V, and waits 22ms so target app consumes this chunk BEFORE next clipboard write!
private func pasteSynchronously(_ text: String) {
let pb = NSPasteboard.general
pb.clearContents()
pb.setString(text, forType: .string)
postCleanCmdV()
usleep(22000) // 22ms guard ensures browser/app reads NSPasteboard before next chunk overwrites it (~45 chunks/sec capacity)
}
private func postCleanCmdV() {
let src = CGEventSource(stateID: .privateState)
let vKeyCode: CGKeyCode = 0x09 // 'v'
if let down = CGEvent(keyboardEventSource: src, virtualKey: vKeyCode, keyDown: true),
let up = CGEvent(keyboardEventSource: src, virtualKey: vKeyCode, keyDown: false) {
down.flags = .maskCommand
up.flags = .maskCommand
down.post(tap: .cgAnnotatedSessionEventTap)
up.post(tap: .cgAnnotatedSessionEventTap)
}
}
}